rem stringlengths 0 322k | add stringlengths 0 2.05M | context stringlengths 8 228k |
|---|---|---|
if ((n_aa > n_na) and ((n_aa / len(rn_seq)) >= min_content)) : | if ((n_aa > n_na) and ((float(n_aa) / len(rn_seq)) >= min_content)) : | def is_protein (self, min_content=0.95) : rn_seq, residue_classes = self.get_residue_names_and_classes() n_aa = residue_classes["common_amino_acid"] n_na = residue_classes["common_rna_dna"] if ((n_aa > n_na) and ((n_aa / len(rn_seq)) >= min_content)) : return True return False |
bmp1 = wxtbx.bitmaps.fetch_icon_bitmap("actions", "1leftarrow", 16) bmp2 = wxtbx.bitmaps.fetch_icon_bitmap("actions", "gohome", 16) bmp3 = wxtbx.bitmaps.fetch_icon_bitmap("actions", "viewmag", 16) bmp4 = wxtbx.bitmaps.fetch_icon_bitmap("actions", "1rightarrow", 16) | bmp1 = bitmaps.fetch_icon_bitmap("actions", "1leftarrow", 16) bmp2 = bitmaps.fetch_icon_bitmap("actions", "gohome", 16) bmp3 = bitmaps.fetch_icon_bitmap("actions", "viewmag", 16) bmp4 = bitmaps.fetch_icon_bitmap("actions", "1rightarrow", 16) | def OnToggle (evt) : index = evt.GetClientData() print "Toggle button clicked: %d, %s" % (index, evt.GetEventObject().GetValue(index)) |
n_alpha = self.alpha_selection(limit="and name N").count(True) n_beta = self.beta_selection(limit="and name N").count(True) | alpha_sele = self.alpha_selection(limit="and name N", main_conf_only=True) n_alpha = alpha_sele.count(True) beta_sele = self.beta_selection(limit="and name N", main_conf_only=True) n_beta = beta_sele.count(True) | def calculate_structure_content (self) : isel = self.selection_cache.iselection calpha = isel("name N and (altloc ' ' or altloc 'A')") n_alpha = self.alpha_selection(limit="and name N").count(True) n_beta = self.beta_selection(limit="and name N").count(True) if calpha.size() == 0 : return (0.0, 0.0) return (n_alpha / c... |
def alpha_selections (self, limit="") : | def alpha_selections (self, limit=None, main_conf_only=False) : | def alpha_selections (self, limit="") : sele = self.selection_cache.selection all_selections = [] for helix in self.params.helix : if helix.selection is not None : helix_sel = sele("(%s) %s and (altloc ' ' or altloc 'A')" % (helix.selection, limit)) all_selections.append(helix_sel) return all_selections |
helix_sel = sele("(%s) %s and (altloc ' ' or altloc 'A')" % (helix.selection, limit)) | clauses = [ "(%s)" % helix.selection ] if (limit is not None) : assert isinstance(limit, str) clauses.append("(%s)" % limit) if main_conf_only : clauses.append("(altloc ' ' or altloc 'A')") helix_sel = sele(" and ".join(clauses)) | def alpha_selections (self, limit="") : sele = self.selection_cache.selection all_selections = [] for helix in self.params.helix : if helix.selection is not None : helix_sel = sele("(%s) %s and (altloc ' ' or altloc 'A')" % (helix.selection, limit)) all_selections.append(helix_sel) return all_selections |
def alpha_selection (self, limit="") : | def alpha_selection (self, **kwds) : | def alpha_selection (self, limit="") : whole_selection = flex.bool(self.xray_structure.sites_cart().size()) for helix in self.alpha_selections(limit=limit) : whole_selection |= helix return whole_selection |
for helix in self.alpha_selections(limit=limit) : | for helix in self.alpha_selections(**kwds) : | def alpha_selection (self, limit="") : whole_selection = flex.bool(self.xray_structure.sites_cart().size()) for helix in self.alpha_selections(limit=limit) : whole_selection |= helix return whole_selection |
def beta_selections (self, limit="") : | def beta_selections (self, limit=None, main_conf_only=False) : | def beta_selections (self, limit="") : sele = self.selection_cache.selection all_selections = [] for sheet in self.params.sheet : sheet_selection = flex.bool(self.xray_structure.sites_cart().size()) strand_sel = sele("(%s) %s and (altloc ' ' or altloc 'A')" % (sheet.first_strand, limit)) sheet_selection |= strand_sel f... |
strand_sel = sele("(%s) %s and (altloc ' ' or altloc 'A')" % (sheet.first_strand, limit)) | clauses = [] if (limit is not None) : assert isinstance(limit, str) clauses.append("(%s)" % limit) if main_conf_only : clauses.append("(altloc ' ' or altloc 'A')") main_clause = [ "(%s)" % sheet.first_strand ] strand_sel = sele(" and ".join(main_clause+clauses)) | def beta_selections (self, limit="") : sele = self.selection_cache.selection all_selections = [] for sheet in self.params.sheet : sheet_selection = flex.bool(self.xray_structure.sites_cart().size()) strand_sel = sele("(%s) %s and (altloc ' ' or altloc 'A')" % (sheet.first_strand, limit)) sheet_selection |= strand_sel f... |
strand_sel = sele("(%s) %s and (altloc ' ' or altloc 'A')" % (strand.selection, limit)) | main_clause = [ "(%s)" % strand.selection ] strand_sel = sele(" and ".join(main_clause+clauses)) | def beta_selections (self, limit="") : sele = self.selection_cache.selection all_selections = [] for sheet in self.params.sheet : sheet_selection = flex.bool(self.xray_structure.sites_cart().size()) strand_sel = sele("(%s) %s and (altloc ' ' or altloc 'A')" % (sheet.first_strand, limit)) sheet_selection |= strand_sel f... |
def beta_selection (self, limit="") : | def beta_selection (self, **kwds) : | def beta_selection (self, limit="") : whole_selection = flex.bool(self.xray_structure.sites_cart().size()) for sheet in self.beta_selections(limit=limit) : whole_selection |= sheet return whole_selection |
for sheet in self.beta_selections(limit=limit) : | for sheet in self.beta_selections(**kwds) : | def beta_selection (self, limit="") : whole_selection = flex.bool(self.xray_structure.sites_cart().size()) for sheet in self.beta_selections(limit=limit) : whole_selection |= sheet return whole_selection |
annotations.append(base_pairs) | if (base_pairs is not None) : annotations.append(base_pairs) | def find_base_pairs_with_segids (self, log=sys.stderr, force=False) : annotations = [] for chain in self.pdb_hierarchy.models()[0].chains() : if not force and not chain.conformers()[0].is_na() : continue segid = chain.atoms()[0].segid detached_hierarchy = iotbx.pdb.hierarchy.new_hierarchy_from_chain(chain) pdb_str = de... |
file_name_prefix = params.maps.output.prefix, | file_name_prefix = None, | def run(args, log = sys.stdout): print >> log, legend print >> log, "-"*79 if(len(args) == 0): parameter_file_name = "maps.params" print >> log, "Creating parameter file %s in the following directory:\n%s"%( parameter_file_name, os.path.abspath('.')) pfo = open(parameter_file_name, "w") mmtbx.maps.maps_including_IO_mas... |
def first_action_callback(O, tardy_model): | def first_action_callback(O, tardy_model, rmsd_calculator): | def first_action_callback(O, tardy_model): O.tardy_model = tardy_model tpo = tardy_model.potential_obj O.draw_map.set_unit_cell_and_density_map( unit_cell=tpo.geo_manager.crystal_symmetry.unit_cell(), density_map=tpo.density_map) O.points = tardy_model.sites_moved().deep_copy() if (tpo.ideal_sites_cart is not None): O.... |
f_000=0) | f_000=0, constant_rho_c=self.flipping_iterator.delta) | def _polishing(self): low_density_elimination = low_density_elimination_iterator( f_obs=self.flipping_iterator.f_obs, f_calc=self.flipping_iterator.f_calc, f_000=0) while 1: for i in xrange(self.polishing_iterations): low_density_elimination.next() yield self.evaluating low_density_elimination.restart(f_calc=self.flipp... |
ss_group_params_str = """ | helix_group_params_str = """ | def get_helix_class (helix_class) : class_id = int(helix_class) - 1 return helix_classes[class_id] |
} | }""" sheet_group_params_str = """ | def get_helix_class (helix_class) : class_id = int(helix_class) - 1 return helix_classes[class_id] |
self.sec_str_from_pdb_file = self.find_sec_str() | self.sec_str_from_pdb_file = self.find_sec_str(log=log) | def find_automatically (self, log=sys.stderr) : params = self.params find_automatically = params.input.find_automatically if len(params.helix) == 0 and len(params.sheet) == 0 : if self.sec_str_from_pdb_file is None and find_automatically != False : find_automatically = True elif find_automatically != True : self.sec_st... |
def find_sec_str (self) : | def find_sec_str (self, log=sys.stderr) : | def find_sec_str (self) : tmp_file = ".dssp.%d.pdb" % os.getpid() open(tmp_file, "w").write(acp.pdb_hierarchy.as_pdb_string()) records = run_ksdssp(tmp_file, log=log) sec_str_from_pdb_file = iotbx.pdb.secondary_structure.process_records( records=records) os.remove(tmp_file) return sec_str_from_pdb_file |
open(tmp_file, "w").write(acp.pdb_hierarchy.as_pdb_string()) | open(tmp_file, "w").write(self.pdb_hierarchy.as_pdb_string()) | def find_sec_str (self) : tmp_file = ".dssp.%d.pdb" % os.getpid() open(tmp_file, "w").write(acp.pdb_hierarchy.as_pdb_string()) records = run_ksdssp(tmp_file, log=log) sec_str_from_pdb_file = iotbx.pdb.secondary_structure.process_records( records=records) os.remove(tmp_file) return sec_str_from_pdb_file |
sources.append(libtbx.phil.parse(arg)) | try : sources.append(libtbx.phil.parse(arg)) except RuntimeError : pass | def run (args, out=sys.stdout, log=sys.stderr) : pdb_files = [] sources = [] force_new_annotation = False master_phil = libtbx.phil.parse(""" show_histograms = False .type = bool show_pymol_dashes = False .type = bool |
records = run_ksdssp(pdb_files[0], log=log) | records = [] for file_name in pdb_files : record.extend(run_ksdssp(file_name, log=log)) | def run (args, out=sys.stdout, log=sys.stderr) : pdb_files = [] sources = [] force_new_annotation = False master_phil = libtbx.phil.parse(""" show_histograms = False .type = bool show_pymol_dashes = False .type = bool |
pdb_hierarchy = get_pdb_hierarchy(pdb_files) | def run (args, out=sys.stdout, log=sys.stderr) : pdb_files = [] sources = [] force_new_annotation = False master_phil = libtbx.phil.parse(""" show_histograms = False .type = bool show_pymol_dashes = False .type = bool | |
if "--test" in sys.argv : exercise() else : run(sys.argv[1:]) | exercise() | def exercise () : pdb_file = libtbx.env.find_in_repositories( relative_path="phenix_regression/pdb/1ywf.pdb", test=os.path.isfile) pdb_file_h = libtbx.env.find_in_repositories( relative_path="phenix_regression/pdb/1ywf_h.pdb", test=os.path.isfile) if pdb_file is None : print "Skipping" return False log = cStringIO.Stri... |
["$D/refinement/restraints/tests/tst_restraints.py", '--verbose', '--scatterers=5', '--resolution=0.2'], | def run(): tst_list = ( "$D/absolute_structure/tests/tst_absolute_structure.py", "$D/ab_initio/tests/tst_ab_initio_ext.py", ["$D/ab_initio/tests/tst_charge_flipping.py", '--fix_seed', '--on=E', '"hall: P 1"', '"hall: P 3"', '"hall: -P 2ybc"' ], "$D/masks/tests/tst_masks.py", "$D/structure_factors/direct/tests/tst_stand... | |
callback(' | callback(include_with_prefix("functions")) | def include_separate(callback): if (len(separate_files_separate_namespace) == 0): return False for name in sorted(separate_files_separate_namespace.keys()): callback('#include "%s.hpp"' % name) return True |
callback(' | callback(include_with_prefix("cmn")) | def include_separate(callback): if (len(separate_files_separate_namespace) == 0): return False for name in sorted(separate_files_separate_namespace.keys()): callback('#include "%s.hpp"' % name) return True |
buffer.append(' | buffer.append(include_with_prefix("functions")) | def include_separate(callback): if (len(separate_files_separate_namespace) == 0): return False for name in sorted(separate_files_separate_namespace.keys()): callback('#include "%s.hpp"' % name) return True |
fcb(' | fcb(include_with_prefix("cmn")) | def fcb(line): print >> f, line |
fcb(' | fcb(include_with_prefix("functions")) | def fcb(line): print >> f, line |
assert abs( dmatrix( 2, smath.pi ).djmn(2,2,0) )< eps | assert abs( dmatrix( 20, smath.pi ).djmn(2,2,0) )< eps | def tst_dmatrix(): # expected values are the d_jmn at beta=1.0 and j=2, m=-2, -2<=n<=2 expect = [0.593133, 0.64806, 0.433605, 0.193411, 0.0528305] eps = 1e-4 d2 = dmatrix( 2, 1.0) # dmatrix( max_L, beta ) for n in range(-2, 3): assert abs(expect[n+2] - d2.djmn(2, -2, n) ) < eps d4 = dmatrix( 4, 1.0) for n in range(-2... |
assert abs( dmatrix( 2, smath.pi*0.5 ).djmn(2,2,0)-smath.sqrt(6.0)/4.0 )< eps | assert abs( dmatrix( 20, smath.pi*0.5 ).djmn(2,2,0)-smath.sqrt(6.0)/4.0 )< eps | def tst_dmatrix(): # expected values are the d_jmn at beta=1.0 and j=2, m=-2, -2<=n<=2 expect = [0.593133, 0.64806, 0.433605, 0.193411, 0.0528305] eps = 1e-4 d2 = dmatrix( 2, 1.0) # dmatrix( max_L, beta ) for n in range(-2, 3): assert abs(expect[n+2] - d2.djmn(2, -2, n) ) < eps d4 = dmatrix( 4, 1.0) for n in range(-2... |
self.is_unique_set_under_symmetry() | assert self.is_unique_set_under_symmetry() | def generate_r_free_flags_on_lattice_symmetry(self, fraction=0.10, max_free=2000, max_delta=5.0, return_integer_array=False, n_partitions=None, use_dataman_shells=False, n_shells=20): # the max_number of reflections is wrst the non anomalous set n_original = self.indices().size() if n_original<=0: raise Sorry("An array... |
self.pool.map_async(func, iterable, chunksize, callback) | result = self.pool.map_async(func, iterable, chunksize, callback) return result.get() | def map_async (self, func, iterable, chunksize=None, callback=None) : if self.enable_multiprocessing : self.pool.map_async(func, iterable, chunksize, callback) else : map(func, iterable) |
map(func, iterable) | return map(func, iterable) | def map_async (self, func, iterable, chunksize=None, callback=None) : if self.enable_multiprocessing : self.pool.map_async(func, iterable, chunksize, callback) else : map(func, iterable) |
self.pool.map(func, iterable, chunksize) | return self.pool.map(func, iterable, chunksize) | def map (self, func, iterable, chunksize=None) : if self.enable_multiprocessing : self.pool.map(func, iterable, chunksize) else : map(func, iterable) |
map(func, iterable) | return map(func, iterable) | def map (self, func, iterable, chunksize=None) : if self.enable_multiprocessing : self.pool.map(func, iterable, chunksize) else : map(func, iterable) |
self.map(_run_many, objects) | return self.map(_run_many, objects) def run_many_async (self, objects, callback=None) : self.map_async(_run_many, objects, callback=callback) | def run_many (self, objects) : self.map(_run_many, objects) |
self.chem_mod_ids = [] | self.chem_mod_ids = set() | def __init__(self, pdb_atoms, mon_lib_srv, translate_cns_dna_rna_residue_names, rna_sugar_pucker_analysis_params, apply_cif_modifications, apply_cif_links_mm_pdbres_dict, i_model, i_conformer, is_first_conformer_in_chain, conf_altloc, pdb_residue, next_pdb_residue): self.pdb_atoms = pdb_atoms self.mon_lib_srv = mon_lib... |
self.chem_mod_ids.append(chem_mod_id) | self.chem_mod_ids.add(chem_mod_id) | def _track_mods(self, chem_mod_ids): for chem_mod_id in chem_mod_ids: self.chem_mod_ids.append(chem_mod_id) self.residue_name += "%" + chem_mod_id |
mod_mon = self.monomer.apply_mod(mod_mod_id) | if (mod_mod_id.chem_mod.id in self.chem_mod_ids): return try: mod_mon = self.monomer.apply_mod(mod_mod_id) except Exception, e: import traceback msg = traceback.format_exc().splitlines() msg.extend([ "apply_mod failure:", " %s" % self.pdb_residue.id_str(), " comp id: %s" % self.monomer.chem_comp.id, " mod id: %s" %... | def apply_mod(self, mod_mod_id): mod_mon = self.monomer.apply_mod(mod_mod_id) self._track_mods(chem_mod_ids=[mod_mod_id.chem_mod.id]) mod_mon.classification = self.monomer.classification self.monomer = mod_mon if ( mod_mod_id.chem_mod.name is not None and mod_mod_id.chem_mod.name.lower().find("terminus") >= 0): self... |
for a in xrange(f,l+1): rapp(a) | if (f <= l): for a in xrange(f,l+1): rapp(a) else: for a in xrange(f,l-1,-1): rapp(a) | def rapp(a): result.append(line[:i] + str(a) + line[j:]) |
d = op.dirname(cmd_info.log) os.mkdir(d) os.chdir(d) from libtbx.command_line import printenv printenv.show(out=open("os_environ_at_start", "w")) if (sys.version_info[:2] < (2,6)): from libtbx.easy_run import subprocess else: import subprocess log = open("log", "w") t0 = time.time() | cwd_on_entry = os.getcwd() | def run_in_dir(cmd_info): d = op.dirname(cmd_info.log) os.mkdir(d) os.chdir(d) from libtbx.command_line import printenv printenv.show(out=open("os_environ_at_start", "w")) if (sys.version_info[:2] < (2,6)): from libtbx.easy_run import subprocess else: import subprocess log = open("log", "w") t0 = time.time() try: subpr... |
subprocess.Popen( args=cmd_info.cmd, shell=True, bufsize=-1, stdout=log, stderr=log, universal_newlines=True).wait() except: show_traceback(file=log) print >> log, fmt_time(t0) sys.stdout.flush() | d = op.dirname(cmd_info.log) os.mkdir(d) os.chdir(d) from libtbx.command_line import printenv printenv.show(out=open("os_environ_at_start", "w")) if (sys.version_info[:2] < (2,6)): from libtbx.easy_run import subprocess else: import subprocess log = open("log", "w") t0 = time.time() try: subprocess.Popen( args=cmd_info... | def run_in_dir(cmd_info): d = op.dirname(cmd_info.log) os.mkdir(d) os.chdir(d) from libtbx.command_line import printenv printenv.show(out=open("os_environ_at_start", "w")) if (sys.version_info[:2] < (2,6)): from libtbx.easy_run import subprocess else: import subprocess log = open("log", "w") t0 = time.time() try: subpr... |
mp_pool.map(run_one_cmd, cmd_infos) | mp_pool.map(run_one_cmd, cmd_infos, chunksize=1) | def show_logs(): for cmd_info in cmd_infos: if (cmd_info.index == 0 and co.dirs is None): continue print "command:", cmd_info.cmd show_log(cmd_info=cmd_info) |
mp_pool.map(run_in_dir, cmd_infos) | mp_pool.map(run_in_dir, cmd_infos, chunksize=1) | def show_logs(): for cmd_info in cmd_infos: if (cmd_info.index == 0 and co.dirs is None): continue print "command:", cmd_info.cmd show_log(cmd_info=cmd_info) |
except ImportError: del sys.path[0] | except ImportError: show_traceback() del sys.path[0] | def run(): engine_path = find_scons_engine_path() if (engine_path is not None): sys.path.insert(0, engine_path) try: import SCons except ImportError: del sys.path[0] try: import SCons.Script except ImportError: msg = ["SCons is not available.", " A possible solution is to unpack a SCons distribution in", " one of the... |
new_array = new_array.average_bijvoet_mateS() | new_array = new_array.average_bijvoet_mates() | def __init__ (self, params, input_files=None, log=sys.stderr, accumulation_callback=None, symmetry_callback=None) : adopt_init_args(self, locals()) if len(params.mtz_file.miller_array) == 0 : raise Sorry("No Miller arrays have been selected for the output file.") elif len(params.mtz_file.miller_array) > 25 : raise Sorr... |
refine_da( fmodel = fmodel, number_of_iterations = params.number_of_minimization_iterations, number_of_cycles = params.number_of_refinement_cycles, selection = da_sel) | refine_da(fmodel = fmodel, selection = da_sel, params = params) | def grow_density(f_obs, r_free_flags, xray_structure, params): print "Start creating DAs..." da_xray_structures = create_da_xray_structures(xray_structure = xray_structure, params = params) n_da = 0 for daxrs in da_xray_structures: n_da += daxrs.scatterers().size() print "Total number of dummy atoms to be added:", n_da... |
da_sel.extend(flex.bool(xray_structure_current.scatterers().size()-xray_structure_start.scatterers().size(), True)) da_sel.count(True) == n_da | da_sel.extend(flex.bool(xray_structure_current.scatterers().size()- xray_structure_start.scatterers().size(), True)) | def grow_density(f_obs, r_free_flags, xray_structure, params): print "Start creating DAs..." da_xray_structures = create_da_xray_structures(xray_structure = xray_structure, params = params) n_da = 0 for daxrs in da_xray_structures: n_da += daxrs.scatterers().size() print "Total number of dummy atoms to be added:", n_da... |
pdb_file_str = pdb_file_str.replace(" %s"%params.atom_type.upper(),"") | def grow_density(f_obs, r_free_flags, xray_structure, params): print "Start creating DAs..." da_xray_structures = create_da_xray_structures(xray_structure = xray_structure, params = params) n_da = 0 for daxrs in da_xray_structures: n_da += daxrs.scatterers().size() print "Total number of dummy atoms to be added:", n_da... | |
def reset_occupancies(fmodels, occ_min, occ_max, set_min, set_max): | fmodels.fmodel_xray().xray_structure.scatterers().flags_set_grads(state=False) def reset_occupancies(fmodels, selection, occ_min, occ_max, set_min, set_max): | def refinery(fmodels, number_of_iterations, iselection, parameter): lbfgs_termination_params = scitbx.lbfgs.termination_parameters( max_iterations = number_of_iterations) if(parameter == "occupancies"): fmodels.fmodel_xray().xray_structure.scatterers().flags_set_grad_occupancy( iselection = iselection) elif(parameter =... |
def reset_adps(fmodels, b_min, b_max, set_min, set_max): | def reset_adps(fmodels, selection, b_min, b_max, set_min, set_max): | def reset_adps(fmodels, b_min, b_max, set_min, set_max): xrs = fmodels.fmodel_xray().xray_structure b = xrs.extract_u_iso_or_u_equiv()*adptbx.u_as_b(1.) sel = b > b_max b = b.set_selected(sel, set_max) sel = b < b_min b = b.set_selected(sel, set_min) xrs = xrs.set_b_iso(values=b) fmodels.update_xray_structure(xray_stru... |
def refine_da(fmodel, number_of_iterations, number_of_cycles, selection): | def refine_da(fmodel, selection, params): def show(fmodels, selection, prefix): fmt1 = "%s Rwork= %8.6f Rfree= %8.6f Number of: non-DA= %d DA= %d all= %d" print fmt1%(prefix, fmodel.r_work(), fmodel.r_free(), selection.count(False),selection.count(True), fmodels.fmodel_xray().xray_structure.scatterers().size()) occ = f... | def refine_da(fmodel, number_of_iterations, number_of_cycles, selection): fmodels = mmtbx.fmodels(fmodel_xray = fmodel) print " START: Rwork = %8.6f Rfree = %8.6f"%(fmodel.r_work(), fmodel.r_free()) for i in xrange(number_of_cycles): refinery(fmodels=fmodels, number_of_iterations=number_of_iterations, iselection=selec... |
print " START: Rwork = %8.6f Rfree = %8.6f"%(fmodel.r_work(), fmodel.r_free()) for i in xrange(number_of_cycles): refinery(fmodels=fmodels, number_of_iterations=number_of_iterations, iselection=selection.iselection(), parameter="occupancies") reset_occupancies(fmodels=fmodels, occ_min=0., occ_max=10., set_min=0., set_... | show(fmodels, selection, " START:") assert params.number_of_refinement_cycles > params.stop_reset_occupancies_at_macro_cycle assert params.number_of_refinement_cycles > params.stop_reset_adp_at_macro_cycle assert params.number_of_refinement_cycles > params.start_filtering_at_macro_cycle for i in xrange(params.number_o... | def refine_da(fmodel, number_of_iterations, number_of_cycles, selection): fmodels = mmtbx.fmodels(fmodel_xray = fmodel) print " START: Rwork = %8.6f Rfree = %8.6f"%(fmodel.r_work(), fmodel.r_free()) for i in xrange(number_of_cycles): refinery(fmodels=fmodels, number_of_iterations=number_of_iterations, iselection=selec... |
def filter_da(params, f_obs, r_free_flags): xray_structure_mac = iotbx.pdb.input( file_name=params.pdb_file_name).xray_structure_simple() coeffs = None xrs_da_all = None for i_model, fp in enumerate(params.filter): xrs = iotbx.pdb.input(file_name=fp.pdb_file_name).xray_structure_simple() occ = xrs.scatterers().extract_... | def filter_da(fmodels, selection, params): xrs = fmodels.fmodel_xray().xray_structure xrs_d = xrs.select(selection) xrs_m = xrs.select(~selection) | def filter_da(params, f_obs, r_free_flags): xray_structure_mac = iotbx.pdb.input( file_name=params.pdb_file_name).xray_structure_simple() coeffs = None xrs_da_all = None for i_model, fp in enumerate(params.filter): xrs = iotbx.pdb.input(file_name=fp.pdb_file_name).xray_structure_simple() occ = xrs.scatterers().extract_... |
fc = coeffs.structure_factors_from_scatterers( xray_structure = xrs_da_all).f_calc() mtz_dataset.add_miller_array( miller_array = fc, column_root_label = "Fcalc_DAonly") | occ = xrs_d.scatterers().extract_occupancies() adp = xrs_d.extract_u_iso_or_u_equiv()*adptbx.u_as_b(1.) sel = occ < params.filter.occupancy_max sel &= occ > params.filter.occupancy_min sel &= adp < params.filter.b_iso_max sel &= adp > params.filter.b_iso_min | def filter_da(params, f_obs, r_free_flags): xray_structure_mac = iotbx.pdb.input( file_name=params.pdb_file_name).xray_structure_simple() coeffs = None xrs_da_all = None for i_model, fp in enumerate(params.filter): xrs = iotbx.pdb.input(file_name=fp.pdb_file_name).xray_structure_simple() occ = xrs.scatterers().extract_... |
mtz_object = mtz_dataset.mtz_object() mtz_object.write(file_name = "map_coeffs.mtz") tmp = xrs_da_all.as_pdb_file() tmp = tmp.replace("PDB= PDB"," DA DA") tmp = tmp.replace(" D","") print >> open(params.pdb_file_name+"_filtered_all.pdb","w"), tmp | xrs_d = xrs_d.select(sel) xrs = xrs_m.concatenate(xrs_d) selection = flex.bool(xrs_m.scatterers().size(), False) selection.extend(flex.bool(xrs_d.scatterers().size(), True)) fmodels.update_xray_structure(xray_structure = xrs, update_f_calc=True, update_f_mask=False) return fmodels, selection | def filter_da(params, f_obs, r_free_flags): xray_structure_mac = iotbx.pdb.input( file_name=params.pdb_file_name).xray_structure_simple() coeffs = None xrs_da_all = None for i_model, fp in enumerate(params.filter): xrs = iotbx.pdb.input(file_name=fp.pdb_file_name).xray_structure_simple() occ = xrs.scatterers().extract_... |
CA_xyz_dict[int(residue_group.resseq)] = atom.xyz | CA_xyz_dict[residue_group.resseq_as_int()] = atom.xyz | def rama_outliers(chain, pdbID, ram_outliers): ram_out = "@subgroup {Rama outliers} master= {Rama outliers}\n" ram_out += "@vectorlist {bad Rama Ca} width= 4 color= green\n" outlier_list = [] for outlier in ram_outliers.splitlines(): outlier_list.append(outlier.split(':')[0]) #prev_CA_xyz = None #cur_CA_xyz = None #nex... |
CA_key_dict[int(residue_group.resseq)] = key | CA_key_dict[residue_group.resseq_as_int()] = key | def rama_outliers(chain, pdbID, ram_outliers): ram_out = "@subgroup {Rama outliers} master= {Rama outliers}\n" ram_out += "@vectorlist {bad Rama Ca} width= 4 color= green\n" outlier_list = [] for outlier in ram_outliers.splitlines(): outlier_list.append(outlier.split(':')[0]) #prev_CA_xyz = None #cur_CA_xyz = None #nex... |
prev_xyz = CA_xyz_dict[int(residue_group.resseq)-1] next_xyz = CA_xyz_dict[int(residue_group.resseq)+1] prev_key = CA_key_dict[int(residue_group.resseq)-1] next_key = CA_key_dict[int(residue_group.resseq)+1] cur_xyz = CA_xyz_dict[int(residue_group.resseq)] | prev_xyz = CA_xyz_dict[residue_group.resseq_as_int()-1] next_xyz = CA_xyz_dict[residue_group.resseq_as_int()+1] prev_key = CA_key_dict[residue_group.resseq_as_int()-1] next_key = CA_key_dict[residue_group.resseq_as_int()+1] cur_xyz = CA_xyz_dict[residue_group.resseq_as_int()] | def rama_outliers(chain, pdbID, ram_outliers): ram_out = "@subgroup {Rama outliers} master= {Rama outliers}\n" ram_out += "@vectorlist {bad Rama Ca} width= 4 color= green\n" outlier_list = [] for outlier in ram_outliers.splitlines(): outlier_list.append(outlier.split(':')[0]) #prev_CA_xyz = None #cur_CA_xyz = None #nex... |
p_hash_key[int(residue_group.resseq)] = key p_hash_xyz[int(residue_group.resseq)] = atom.xyz | p_hash_key[residue_group.resseq_as_int()] = key p_hash_xyz[residue_group.resseq_as_int()] = atom.xyz | def get_kin_lots(chain, pdbID=None, index=0, show_hydrogen=True): mc_atoms = ["N", "CA", "C", "O", "OXT", "P", "OP1", "OP2", "O5'", "C5'", "C4'", "O4'", "C1'", "C3'", "O3'", "C2'", "O2'"] mc_veclist = "" sc_veclist = "" mc_h_veclist = "" sc_h_veclist = "" ca_trace = "" virtual_bb = "" water_list = "" kin_out = "" color... |
c1_hash_key[int(residue_group.resseq)] = key c1_hash_xyz[int(residue_group.resseq)] = atom.xyz | c1_hash_key[residue_group.resseq_as_int()] = key c1_hash_xyz[residue_group.resseq_as_int()] = atom.xyz | def get_kin_lots(chain, pdbID=None, index=0, show_hydrogen=True): mc_atoms = ["N", "CA", "C", "O", "OXT", "P", "OP1", "OP2", "O5'", "C5'", "C4'", "O4'", "C1'", "C3'", "O3'", "C2'", "O2'"] mc_veclist = "" sc_veclist = "" mc_h_veclist = "" sc_h_veclist = "" ca_trace = "" virtual_bb = "" water_list = "" kin_out = "" color... |
c4_hash_key[int(residue_group.resseq)] = key c4_hash_xyz[int(residue_group.resseq)] = atom.xyz | c4_hash_key[residue_group.resseq_as_int()] = key c4_hash_xyz[residue_group.resseq_as_int()] = atom.xyz | def get_kin_lots(chain, pdbID=None, index=0, show_hydrogen=True): mc_atoms = ["N", "CA", "C", "O", "OXT", "P", "OP1", "OP2", "O5'", "C5'", "C4'", "O4'", "C1'", "C3'", "O3'", "C2'", "O2'"] mc_veclist = "" sc_veclist = "" mc_h_veclist = "" sc_h_veclist = "" ca_trace = "" virtual_bb = "" water_list = "" kin_out = "" color... |
virtual_bb += "{%s} P %.3f %.3f %.3f {%s} L %.3f %.3f %.3f\n" % ( c4_hash_key[int(residue_group.resseq)-1], c4_hash_xyz[int(residue_group.resseq)-1][0], c4_hash_xyz[int(residue_group.resseq)-1][1], c4_hash_xyz[int(residue_group.resseq)-1][2], p_hash_key[int(residue_group.resseq)], p_hash_xyz[int(residue_group.resseq)][... | virtual_bb += kin_vec(c4_hash_key[residue_group.resseq_as_int()-1], c4_hash_xyz[residue_group.resseq_as_int()-1], p_hash_key[residue_group.resseq_as_int()], p_hash_xyz[residue_group.resseq_as_int()]) | def get_kin_lots(chain, pdbID=None, index=0, show_hydrogen=True): mc_atoms = ["N", "CA", "C", "O", "OXT", "P", "OP1", "OP2", "O5'", "C5'", "C4'", "O4'", "C1'", "C3'", "O3'", "C2'", "O2'"] mc_veclist = "" sc_veclist = "" mc_h_veclist = "" sc_h_veclist = "" ca_trace = "" virtual_bb = "" water_list = "" kin_out = "" color... |
virtual_bb += "{%s} P %.3f %.3f %.3f {%s} L %.3f %.3f %.3f\n" % ( p_hash_key[int(residue_group.resseq)], p_hash_xyz[int(residue_group.resseq)][0], p_hash_xyz[int(residue_group.resseq)][1], p_hash_xyz[int(residue_group.resseq)][2], c4_hash_key[int(residue_group.resseq)], c4_hash_xyz[int(residue_group.resseq)][0], c4_has... | virtual_bb += kin_vec(p_hash_key[residue_group.resseq_as_int()], p_hash_xyz[residue_group.resseq_as_int()], c4_hash_key[residue_group.resseq_as_int()], c4_hash_xyz[residue_group.resseq_as_int()]) | def get_kin_lots(chain, pdbID=None, index=0, show_hydrogen=True): mc_atoms = ["N", "CA", "C", "O", "OXT", "P", "OP1", "OP2", "O5'", "C5'", "C4'", "O4'", "C1'", "C3'", "O3'", "C2'", "O2'"] mc_veclist = "" sc_veclist = "" mc_h_veclist = "" sc_h_veclist = "" ca_trace = "" virtual_bb = "" water_list = "" kin_out = "" color... |
virtual_bb += "{%s} P %.3f %.3f %.3f {%s} L %.3f %.3f %.3f\n" % ( c4_hash_key[int(residue_group.resseq)], c4_hash_xyz[int(residue_group.resseq)][0], c4_hash_xyz[int(residue_group.resseq)][1], c4_hash_xyz[int(residue_group.resseq)][2], c1_hash_key[int(residue_group.resseq)], c1_hash_xyz[int(residue_group.resseq)][0], c1... | virtual_bb += kin_vec(c4_hash_key[residue_group.resseq_as_int()], c4_hash_xyz[residue_group.resseq_as_int()], c1_hash_key[residue_group.resseq_as_int()], c1_hash_xyz[residue_group.resseq_as_int()]) | def get_kin_lots(chain, pdbID=None, index=0, show_hydrogen=True): mc_atoms = ["N", "CA", "C", "O", "OXT", "P", "OP1", "OP2", "O5'", "C5'", "C4'", "O4'", "C1'", "C3'", "O3'", "C2'", "O2'"] mc_veclist = "" sc_veclist = "" mc_h_veclist = "" sc_h_veclist = "" ca_trace = "" virtual_bb = "" water_list = "" kin_out = "" color... |
for bond in bonds: if (bond[0].startswith('H') or bond[1].startswith('H')): if show_hydrogen: try: het_h += kin_vec(het_hash[bond[0]][0], | if bonds is not None: for bond in bonds: if (bond[0].startswith('H') or bond[1].startswith('H')): if show_hydrogen: try: het_h += kin_vec(het_hash[bond[0]][0], | def get_kin_lots(chain, pdbID=None, index=0, show_hydrogen=True): mc_atoms = ["N", "CA", "C", "O", "OXT", "P", "OP1", "OP2", "O5'", "C5'", "C4'", "O4'", "C1'", "C3'", "O3'", "C2'", "O2'"] mc_veclist = "" sc_veclist = "" mc_h_veclist = "" sc_h_veclist = "" ca_trace = "" virtual_bb = "" water_list = "" kin_out = "" color... |
else: | if bonds is not None: for bond in bonds: if bond[0] in mc_atoms and bond[1] in mc_atoms: | def get_kin_lots(chain, pdbID=None, index=0, show_hydrogen=True): mc_atoms = ["N", "CA", "C", "O", "OXT", "P", "OP1", "OP2", "O5'", "C5'", "C4'", "O4'", "C1'", "C3'", "O3'", "C2'", "O2'"] mc_veclist = "" sc_veclist = "" mc_h_veclist = "" sc_h_veclist = "" ca_trace = "" virtual_bb = "" water_list = "" kin_out = "" color... |
hets += "{%s} P %.3f %.3f %.3f {%s} L %.3f %.3f %.3f\n" % ( het_hash[bond[0]][0], het_hash[bond[0]][1][0], het_hash[bond[0]][1][1], het_hash[bond[0]][1][2], het_hash[bond[1]][0], het_hash[bond[1]][1][0], het_hash[bond[1]][1][1], het_hash[bond[1]][1][2]) except: continue for bond in bonds: if bond[0] in mc_atoms and bo... | mc_veclist += kin_vec(key_hash[bond[0]], | def get_kin_lots(chain, pdbID=None, index=0, show_hydrogen=True): mc_atoms = ["N", "CA", "C", "O", "OXT", "P", "OP1", "OP2", "O5'", "C5'", "C4'", "O4'", "C1'", "C3'", "O3'", "C2'", "O2'"] mc_veclist = "" sc_veclist = "" mc_h_veclist = "" sc_h_veclist = "" ca_trace = "" virtual_bb = "" water_list = "" kin_out = "" color... |
symmetry_flags = maptbx.use_space_group_symmetry, average_maps = True) | symmetry_flags = maptbx.use_space_group_symmetry) | def __init__(self, fmodel, map_type, map_cutoff, params = None, log = None, use_kick_map = False, kick_map_params = None): adopt_init_args(self, locals()) self.mapped = False self.peaks_ = None if(self.log is None): self.log = sys.stdout if(self.params is None): self.params = master_params.extract() if(use_kick_map): f... |
width=txt_w + 200, dc=wx.MemoryDC()) | width=txt_w, dc=dc) | def __DrawCaption (self, gc, xpos, ypos) : if self._label2 != '' : gc.SetFont(self._label2_font) min_w, min_h = self._size if min_w == -1 : min_w = 120 txt_w = min_w - xpos - 10 if False : #self._caption_lines is not None : lines = self._caption_lines else : lines = wx.lib.wordwrap.wordwrap(self._label2, width=txt_w + ... |
path_normcase = os.path.normcase(path) | path_normcase = op.normcase(path) | def unique_paths(paths): hash = set() result = [] for path in paths: path_normcase = os.path.normcase(path) if (path_normcase in hash): continue hash.add(path_normcase) result.append(path) return result |
if (must_exist and not os.path.isdir(include_path)): | if (must_exist and not op.isdir(include_path)): | def python_include_path(must_exist=True): if (sys.platform == "win32"): include_path = sys.prefix + r"\include" else: include_path = sys.prefix + "/include/python%d.%d" % sys.version_info[:2] include_path = libtbx.path.norm_join(include_path) if (must_exist and not os.path.isdir(include_path)): raise RuntimeError("Cann... |
print info, os.path.basename(path) | print info, op.basename(path) | def open_info(path, mode="w", info=" "): print info, os.path.basename(path) try: return open(path, mode) except IOError, e: raise Sorry(str(e)) |
if (os.path.isfile(path)): | if (op.isfile(path)): | def remove_or_rename(path): if (os.path.isfile(path)): try: os.remove(path) except OSError: try: os.remove(path+".old") except OSError: pass try: os.rename(path, path+".old") except OSError: pass |
assert os.path.isabs(sys.executable) assert os.path.isfile(sys.executable) | assert op.isabs(sys.executable) assert op.isfile(sys.executable) | def __init__(self, build_path=None): self.python_version_major_minor = sys.version_info[:2] self.build_path = build_path self._shortpath_bat = None self.build_path = self.abs_path_clean(build_path) self.manage_python_version_major_minor() self.reset_dispatcher_support() self.set_derived_paths() assert os.path.isabs(sys... |
assert os.path.isfile(self.python_exe) | assert op.isfile(self.python_exe) | def __init__(self, build_path=None): self.python_version_major_minor = sys.version_info[:2] self.build_path = build_path self._shortpath_bat = None self.build_path = self.abs_path_clean(build_path) self.manage_python_version_major_minor() self.reset_dispatcher_support() self.set_derived_paths() assert os.path.isabs(sys... |
self.python_exe = os.path.normpath(sys.executable) | self.python_exe = op.normpath(sys.executable) | def __init__(self, build_path=None): self.python_version_major_minor = sys.version_info[:2] self.build_path = build_path self._shortpath_bat = None self.build_path = self.abs_path_clean(build_path) self.manage_python_version_major_minor() self.reset_dispatcher_support() self.set_derived_paths() assert os.path.isabs(sys... |
path = os.path.join(self.build_path, "lib") if (not os.path.isdir(path)): | path = op.join(self.build_path, "lib") if (not op.isdir(path)): | def manage_python_version_major_minor(self): path = os.path.join(self.build_path, "lib") if (not os.path.isdir(path)): os.makedirs(path) path = os.path.join(path, "PYTHON_VERSION_MAJOR_MINOR") pvmm = "%d.%d" % self.python_version_major_minor if (not os.path.isfile(path)): open(path, "w").write("""\ |
path = os.path.join(path, "PYTHON_VERSION_MAJOR_MINOR") | path = op.join(path, "PYTHON_VERSION_MAJOR_MINOR") | def manage_python_version_major_minor(self): path = os.path.join(self.build_path, "lib") if (not os.path.isdir(path)): os.makedirs(path) path = os.path.join(path, "PYTHON_VERSION_MAJOR_MINOR") pvmm = "%d.%d" % self.python_version_major_minor if (not os.path.isfile(path)): open(path, "w").write("""\ |
if (not os.path.isfile(path)): | if (not op.isfile(path)): | def manage_python_version_major_minor(self): path = os.path.join(self.build_path, "lib") if (not os.path.isdir(path)): os.makedirs(path) path = os.path.join(path, "PYTHON_VERSION_MAJOR_MINOR") pvmm = "%d.%d" % self.python_version_major_minor if (not os.path.isfile(path)): open(path, "w").write("""\ |
assert os.path.exists(self._shortpath_bat) | assert op.exists(self._shortpath_bat) | def abs_path_short(self, abs_path): if (os.name != "nt"): return abs_path if (self._shortpath_bat is None): self._shortpath_bat = self.under_build("shortpath.bat") assert os.path.exists(self._shortpath_bat) from libtbx import easy_run return easy_run.fully_buffered( command='call "%s" "%s"' % (self._shortpath_bat, abs_... |
abs_path = os.path.normpath(os.path.abspath(path)) | abs_path = op.normpath(op.abspath(path)) | def abs_path_clean(self, path): abs_path = os.path.normpath(os.path.abspath(path)) if (os.name != "nt" or abs_path.find(" ") < 0): return abs_path short = self.abs_path_short(abs_path).split(os.sep) orig = abs_path.split(os.sep) clean = [] for o,s in zip(orig, short): if (o.find(" ") < 0): clean.append(o) else: clean.a... |
if (not os.path.isdir(self.bin_path)): return | if (not op.isdir(self.bin_path)): return | def clear_bin_directory(self): if (not os.path.isdir(self.bin_path)): return buffer = [] have_libtbx_command = False for file_name in os.listdir(self.bin_path): if ( not have_libtbx_command and file_name.lower().startswith("libtbx.")): have_libtbx_command = True path = os.path.join(self.bin_path, file_name) if (os.p... |
path = os.path.join(self.bin_path, file_name) if (os.path.isfile(path)): | path = op.join(self.bin_path, file_name) if (op.isfile(path)): | def clear_bin_directory(self): if (not os.path.isdir(self.bin_path)): return buffer = [] have_libtbx_command = False for file_name in os.listdir(self.bin_path): if ( not have_libtbx_command and file_name.lower().startswith("libtbx.")): have_libtbx_command = True path = os.path.join(self.bin_path, file_name) if (os.p... |
if (not os.path.isfile(path)): | if (not op.isfile(path)): | def read_command_version_suffix(self): path = self.under_build("command_version_suffix") if (not os.path.isfile(path)): self.command_version_suffix = None else: try: self.command_version_suffix = open(path).read().strip() except IOError: raise Sorry('Cannot read command_version_suffix file: "%s"' % path) |
if (test is None or test(os.path.join(path, name))): | if (test is None or test(op.join(path, name))): | def listdir_in_repositories(self, test=None): for path in self.repository_paths: for name in os.listdir(path): if (test is None or test(os.path.join(path, name))): yield path, name |
test=os.path.isdir, | test=op.isdir, | def match_in_repositories(self, relative_path_pattern, test=os.path.isdir, optional=True, must_be_unique=True): compiled_pattern = re.compile(relative_path_pattern) all_matches = [] for path,name in self.listdir_in_repositories(test=test): if (compiled_pattern.match(name) is not None): if (len(all_matches) > 0 and all_... |
test=os.path.isdir, | test=op.isdir, | def find_in_repositories(self, relative_path, test=os.path.isdir, optional=True): assert len(relative_path) != 0 for path in self.repository_paths: result = self.abs_path_clean( libtbx.path.norm_join(path, relative_path)) if (test is None or test(result)): return result if (not optional): self.raise_sorry_not_found_in_... |
new_name_normcase = os.path.normcase(new_module.name) | new_name_normcase = op.normcase(new_module.name) | def process_module(self, dependent_module, module_name, optional): dist_path = self.find_dist_path(module_name, optional=optional) if (dist_path is None): return False new_module = module(env=self, name=module_name, dist_path=dist_path) new_name_normcase = os.path.normcase(new_module.name) for name in self.module_dict:... |
if (os.path.normcase(name) == new_name_normcase): return True | if (op.normcase(name) == new_name_normcase): return True | def process_module(self, dependent_module, module_name, optional): dist_path = self.find_dist_path(module_name, optional=optional) if (dist_path is None): return False new_module = module(env=self, name=module_name, dist_path=dist_path) new_name_normcase = os.path.normcase(new_module.name) for name in self.module_dict:... |
path_normcase = os.path.normcase(path) | path_normcase = op.normcase(path) | def add_repository(self, path): path = self.abs_path_clean(path) path_normcase = os.path.normcase(path) for repository_path in self.repository_paths: if (os.path.normcase(repository_path) == path_normcase): break else: self.repository_paths.append(path) |
if (os.path.normcase(repository_path) == path_normcase): | if (op.normcase(repository_path) == path_normcase): | def add_repository(self, path): path = self.abs_path_clean(path) path_normcase = os.path.normcase(path) for repository_path in self.repository_paths: if (os.path.normcase(repository_path) == path_normcase): break else: self.repository_paths.append(path) |
dist_path = self.abs_path_clean(os.path.expandvars(redirection)) if (not os.path.isdir(dist_path)): | dist_path = self.abs_path_clean(op.expandvars(redirection)) if (not op.isdir(dist_path)): | def process_args(self, pre_processed_args): command_line = pre_processed_args.command_line for path in pre_processed_args.repository_paths: self.add_repository(path=path) module_names = [] for module_name in command_line.args: if (len(module_name) == 0): continue # ignore arguments like "" if (module_name == ".."): rai... |
assert os.path.isfile(self.path_utility) | assert op.isfile(self.path_utility) | def process_args(self, pre_processed_args): command_line = pre_processed_args.command_line for path in pre_processed_args.repository_paths: self.add_repository(path=path) module_names = [] for module_name in command_line.args: if (len(module_name) == 0): continue # ignore arguments like "" if (module_name == ".."): rai... |
and os.path.isfile("/etc/redhat-release")): | and op.isfile("/etc/redhat-release")): | def dispatcher_precall_commands(self): if (self._dispatcher_precall_commands is None): lines = [] if ( self.python_version_major_minor == (2,2) and sys.platform == "linux2" and os.path.isfile("/etc/redhat-release")): try: red_hat_linux_release = open("/etc/redhat-release").readline() except KeyboardInterrupt: raise ... |
if (not os.path.isfile(path)): continue | if (not op.isfile(path)): continue | def reset_dispatcher_bookkeeping(self): self._dispatcher_registry = {} self._dispatcher_include_at_start = [] self._dispatcher_include_before_command = [] include_files = [] for file_name in os.listdir(self.build_path): path = self.under_build(file_name) if (not os.path.isfile(path)): continue if ( file_name.startsw... |
dispatcher_name = os.path.basename(target_file) | dispatcher_name = op.basename(target_file) | def write_bin_sh_dispatcher(self, source_file, target_file): f = open(target_file, "w") if (source_file is not None): print >> f, '#! /bin/sh' print >> f, '# LIBTBX_DISPATCHER DO NOT EDIT' else: print >> f, '# LIBTBX_DISPATCHER_HEAD DO NOT EDIT' print >> f, '#' print >> f, '# This file is intended to be sourced from ot... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.