Split (1)

train · 303k rows

Subsets and Splits

No community queries yet

The top public SQL queries from the community will appear here once available.

rem stringlengths 0 322k	add stringlengths 0 2.05M	context stringlengths 8 228k
sci_name=organism_element.text elif organism_element.attrib['type']== 'common': com_name=organism_element.text else:	if organism_element.text: sci_name=organism_element.text if (organism_element.attrib['type']== 'common') and not sci_name: if organism_element.text: com_name=organism_element.text if (sci_name == '') and (com_name == ''):	def _parse_organism(element): com_name=sci_name='' for organism_element in element.getchildren(): if organism_element.tag==NS + 'name': if organism_element.attrib['type']== 'scientific': sci_name=organism_element.text elif organism_element.attrib['type']== 'common': com_name=organism_element.text else: append_to_annotations("organism_name", organism_element.text) elif organism_element.tag==NS + 'dbReference': self.ParsedSeqRecord.dbxrefs.append(organism_element.attrib['type']+':'+organism_element.attrib['id']) elif organism_element.tag==NS + 'lineage': for taxon_element in organism_element.getchildren(): if taxon_element.tag==NS + 'taxon': append_to_annotations('taxonomy',taxon_element.text) organism_name=sci_name if com_name: organism_name+=' (%s)'%com_name self.ParsedSeqRecord.annotations['organism']=organism_name
""" return (self.get_path(target, **kwargs) is not None)	""" return self.get_path(target, **kwargs) is not None	def is_parent_of(self, target=None, **kwargs): """True if target is a descendent of this tree.
outstr = join(outstr, '\n')	outstr = "\n".join(outstr)	def __str__(self): """ __str__(self) -> ""
if element is None :	if not element:	def __init__(self, name, coord, bfactor, occupancy, altloc, fullname, serial_number, element=None): """ Atom object.
lasty = trackheight*(val-minval)/resolution + \	lasty = trackheight*(val-midval)/resolution + \	def draw_line_graph(self, graph): """ draw_line_graph(self, graph) -> [element, element,...]
(self.dbid, value))[0])	(self.dbid, bioentry_id))[0])	def __contains__(self, value): """Check if a primary (internal) id is this namespace (sub database).""" sql = "SELECT COUNT(bioentry_id) FROM bioentry " + \ "WHERE biodatabase_id=%s AND bioentry_id=%s;" return bool(self.adaptor.execute_and_fetch_col0(sql, (self.dbid, value))[0])
answer.features.sort(cmp=lambda x,y: cmp(x.location.start.position, y.location.start.position))	answer.features.sort(key=lambda x : x.location.start.position)	def reverse_complement(self, id=False, name=False, description=False, features=True, annotations=False, letter_annotations=True, dbxrefs=False): """Returns new SeqRecord with reverse complement sequence.
line = line.strip()	line = line[5:].strip()	def __create_motif(line): line = line.strip() ls = line.split() motif = MEMEMotif() motif.length = int(ls[4]) motif._numoccurrences(ls[7]) motif._evalue(ls[13]) return motif
motif.length = int(ls[4]) motif._numoccurrences(ls[7]) motif._evalue(ls[13])	motif.length = int(ls[3]) motif._numoccurrences(ls[6]) motif._evalue(ls[12])	def __create_motif(line): line = line.strip() ls = line.split() motif = MEMEMotif() motif.length = int(ls[4]) motif._numoccurrences(ls[7]) motif._evalue(ls[13]) return motif
from_res = "<%s" % to_res	from_res = "<%s" % str(to_res).lstrip("<").lstrip(">")	def _make_seqfeature(name, from_res, to_res, description, ft_id): """Construct SeqFeature from feature data from parser (PRIVATE).""" #print name, repr(from_res), repr(to_res), "..." if from_res == "?" and to_res == "?": #If this does happen, will need to think about this some more! raise ValueError("Swiss file FT location ? ? (completely unknown)") elif from_res == "?": #e.g. given "? 5" in the Swiss file, treat this as <5..5 in GenBank from_res = "<%s" % to_res elif to_res == "?": #e.g. given "10 ?" in the Swiss file, treat this as 10..>10 in GenBank to_res = ">%s" % from_res loc = SeqFeature.FeatureLocation(_make_position(from_res,-1), _make_position(to_res, 0)) #print name, repr(from_res), repr(to_res), loc return SeqFeature.SeqFeature(loc, type=name, id=ft_id, qualifiers={"description":description})
to_res = ">%s" % from_res	to_res = ">%s" % str(from_res).lstrip("<").lstrip(">")	def _make_seqfeature(name, from_res, to_res, description, ft_id): """Construct SeqFeature from feature data from parser (PRIVATE).""" #print name, repr(from_res), repr(to_res), "..." if from_res == "?" and to_res == "?": #If this does happen, will need to think about this some more! raise ValueError("Swiss file FT location ? ? (completely unknown)") elif from_res == "?": #e.g. given "? 5" in the Swiss file, treat this as <5..5 in GenBank from_res = "<%s" % to_res elif to_res == "?": #e.g. given "10 ?" in the Swiss file, treat this as 10..>10 in GenBank to_res = ">%s" % from_res loc = SeqFeature.FeatureLocation(_make_position(from_res,-1), _make_position(to_res, 0)) #print name, repr(from_res), repr(to_res), loc return SeqFeature.SeqFeature(loc, type=name, id=ft_id, qualifiers={"description":description})
align = AlignIO.read(open("output.2.nex"), "nexus") for old, new in zip(records, align): self.assertEqual(old.id[:9], new.id) self.assertEqual(str(new.seq).replace("-",""), str(old.seq).replace("-",""))	try: align = AlignIO.read(open("output.2.nex"), "nexus") for old, new in zip(records, align): self.assertEqual(old.id[:9], new.id) self.assertEqual(str(new.seq).replace("-",""), str(old.seq).replace("-","")) except NexusError: pass	def test_Prank_simple_with_NEXUS_output(self): """Simple round-trip through app with infile, output in NEXUS output.?.??? files written to cwd - no way to redirect """ records = list(SeqIO.parse(open(self.infile1),"fasta")) #Try using keyword argument, cmdline = PrankCommandline(prank_exe, d=self.infile1, noxml=True) #Try using a property, cmdline.d = self.infile1 cmdline.f = 17 # NEXUS format cmdline.set_parameter("notree", True) self.assertEqual(str(cmdline), prank_exe + \ " -d=Fasta/fa01 -f=17 -noxml -notree") self.assertEqual(str(eval(repr(cmdline))), str(cmdline)) child = subprocess.Popen(str(cmdline), stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True, shell=(sys.platform!="win32")) return_code = child.wait() self.assertEqual(return_code, 0) self.assertTrue("Total time" in child.stdout.read()) self.assertEqual(child.stderr.read(), "") align = AlignIO.read(open("output.2.nex"), "nexus") for old, new in zip(records, align): #Prank automatically reduces name to 9 chars self.assertEqual(old.id[:9], new.id) #infile1 has alignment gaps in it self.assertEqual(str(new.seq).replace("-",""), str(old.seq).replace("-","")) del child
if not isinstance(date, str) or len(date) != 11 \	if not isinstance(date, basestring) or len(date) != 11 \	def _get_date(self, record) : default = "01-JAN-1980" try : date = record.annotations["date"] except KeyError : return default #Cope with a list of one string: if isinstance(date, list) and len(date)==1 : date = date[0] #TODO - allow a Python date object if not isinstance(date, str) or len(date) != 11 \ or date[2] != "-" or date[6] != "-" \ or not date[:2].isdigit() or not date[7:].isdigit() \ or int(date[:2]) > 31 \ or date[3:6] not in ["JAN", "FEB", "MAR", "APR", "MAY", "JUN", "JUL", "AUG", "SEP", "OCT", "NOV", "DEC"] : #TODO - Check is a valid date (e.g. not 31 Feb) return default return date
sys.stderr.write(str(m2))	sys.stderr.write(str(motif))	def compare_motifs (self, motif): if isinstance(motif, MEMEMotif): if not self.pssm: raise ValueError('This motif does not have a PSSM') if not motif.pssm: raise ValueError('The other motif does not have a PSSM') mylen = len(self.pssm) yourlen = len(motif.pssm) myr = None if mylen == yourlen: myr = _corr(self.pssm, motif.pssm) elif mylen < yourlen: diff = yourlen - mylen for i in range(0,diff): yourpssm = motif.pssm[i:mylen+i] r = _corr(self.pssm, yourpssm) if r > myr: myr = r else: diff = mylen - yourlen for i in range(0, diff): mypssm = self.pssm[i:yourlen+i] r = _corr(mypssm, motif.pssm) if r > myr: myr = r return myr else: sys.stderr.write(str(m2)) return None
def test_blasp(self):	def test_blastp(self):	def test_blasp(self): """Pairwise BLASTP search""" global exe_names cline = Applications.NcbiblastpCommandline(exe_names["blastp"], query="Fasta/rose.pro", subject="GenBank/NC_005816.faa", evalue=1) self.assertEqual(str(cline), exe_names["blastp"] \ + " -query Fasta/rose.pro -evalue 1" \ + " -subject GenBank/NC_005816.faa") child = subprocess.Popen(str(cline), stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True, shell=(sys.platform!="win32")) stdoutdata, stderrdata = child.communicate() return_code = child.returncode self.assertEqual(return_code, 0, "Got error code %i back from:\n%s" % (return_code, cline)) self.assertEqual(10, stdoutdata.count("Query= ")) self.assertEqual(9, stdoutdata.count("*** No hits found ***")) #TODO - Parse it? I think we'd need to update this obsole code :( #records = list(NCBIStandalone.Iterator(StringIO(stdoutdata), # NCBIStandalone.BlastParser()))
self.assertTrue(key in id_list)	self.assertTrue(key in ids)	def check_dict_methods(self, rec_dict, keys, ids): self.assertEqual(set(keys), set(rec_dict.keys())) #This is redundant, I just want to make sure len works: self.assertEqual(len(keys), len(rec_dict)) #Make sure boolean evaluation works self.assertEqual(bool(keys), bool(rec_dict)) for key,id in zip(keys, ids): self.assertTrue(key in rec_dict) self.assertEqual(id, rec_dict[key].id) self.assertEqual(id, rec_dict.get(key).id) #Check non-existant keys, assert chr(0) not in keys, "Bad example in test" try: rec = rec_dict[chr(0)] raise ValueError("Accessing a non-existent key should fail") except KeyError: pass self.assertEqual(rec_dict.get(chr(0)), None) self.assertEqual(rec_dict.get(chr(0), chr(1)), chr(1)) if hasattr(dict, "iteritems"): #Python 2.x for key, rec in rec_dict.iteritems(): self.assertTrue(key in keys) self.assertTrue(isinstance(rec, SeqRecord)) self.assertTrue(rec.id in ids) #Now check non-defined methods... self.assertRaises(NotImplementedError, rec_dict.items) self.assertRaises(NotImplementedError, rec_dict.values) else: #Python 3 assert not hasattr(rec_dict, "iteritems") for key, rec in rec_dict.iteritems(): self.assertTrue(key in id_list) self.assertTrue(isinstance(rec, SeqRecord)) self.assertTrue(rec.id in ids) for rec in rec_dict.itervalues(): self.assertTrue(key in id_list) self.assertTrue(isinstance(rec, SeqRecord)) self.assertTrue(rec.id in ids) #Check the following fail self.assertRaises(NotImplementedError, rec_dict.popitem) self.assertRaises(NotImplementedError, rec_dict.pop, chr(0)) self.assertRaises(NotImplementedError, rec_dict.pop, chr(0), chr(1)) self.assertRaises(NotImplementedError, rec_dict.clear) self.assertRaises(NotImplementedError, rec_dict.__setitem__, "X", None) self.assertRaises(NotImplementedError, rec_dict.copy) self.assertRaises(NotImplementedError, rec_dict.fromkeys, [])
intersect=sets.set(self.ambiguous_values[seqsite]).intersection(sets.set(site[1]))	intersect = set(self.ambiguous_values[seqsite]).intersection(set(site[1]))	def constant(self,matrix=None,delete=[],exclude=[]): """Return a list with all constant characters.""" if not matrix: matrix=self.matrix undelete=[t for t in self.taxlabels if t in matrix and t not in delete] if not undelete: return None elif len(undelete)==1: return [x for x in range(len(matrix[undelete[0]])) if x not in exclude] # get the first sequence and expand all ambiguous values constant=[(x,self.ambiguous_values.get(n.upper(),n.upper())) for x,n in enumerate(matrix[undelete[0]].tostring()) if x not in exclude] for taxon in undelete[1:]: newconstant=[] for site in constant: #print '%d (paup=%d)' % (site[0],site[0]+1), seqsite=matrix[taxon][site[0]].upper() #print seqsite,'checked against',site[1],'\t', if seqsite==self.missing or (seqsite==self.gap and self.options['gapmode'].lower()=='missing') or seqsite==site[1]: # missing or same as before -> ok newconstant.append(site) elif seqsite in site[1] or site[1]==self.missing or (self.options['gapmode'].lower()=='missing' and site[1]==self.gap): # subset of an ambig or only missing in previous -> take subset newconstant.append((site[0],self.ambiguous_values.get(seqsite,seqsite))) elif seqsite in self.ambiguous_values: # is it an ambig: check the intersection with prev. values intersect=sets.set(self.ambiguous_values[seqsite]).intersection(sets.set(site[1])) if intersect: newconstant.append((site[0],''.join(intersect))) # print 'ok' #else: # print 'failed' #else: # print 'failed' constant=newconstant cpos=[s[0] for s in constant] return constant # return [x[0] for x in constant]
% ', '.join(sets.set(delete).difference(self.taxlabels)))	% ', '.join(set(delete).difference(self.taxlabels)))	def crop_matrix(self,matrix=None, delete=[], exclude=[]): """Return a matrix without deleted taxa and excluded characters.""" if not matrix: matrix=self.matrix if [t for t in delete if not self._check_taxlabels(t)]: raise NexusError('Unknown taxa: %s' \ % ', '.join(sets.set(delete).difference(self.taxlabels))) if exclude!=[]: undelete=[t for t in self.taxlabels if t in matrix and t not in delete] if not undelete: return {} m=[matrix[k].tostring() for k in undelete] zipped_m=zip(m) sitesm=[s for i,s in enumerate(zipped_m) if i not in exclude] if sitesm==[]: return dict([(t,Seq('',self.alphabet)) for t in undelete]) else: zipped_sitesm=zip(sitesm) m=[Seq(s,self.alphabet) for s in map(''.join,zipped_sitesm)] return dict(zip(undelete,m)) else: return dict([(t,matrix[t]) for t in self.taxlabels if t in matrix and t not in delete])
handle.close()	file.close()	def quicker_apply_on_multi_fasta(file, function, args): """Apply a function on each sequence in a multiple FASTA file (OBSOLETE). file - filename of a FASTA format file function - the function you wish to invoke on each record args - any extra arguments you want passed to the function This function will use quick_FASTA_reader to load every record in the FASTA file into memory as a list of tuples. For each record, it will call your supplied function with the record as a tuple of the name and sequence as strings (plus any supplied args). This function returns a list. For those records where your function returns a value, this is taken as a sequence and used to construct a FASTA format string. If your function never has a return value, this means quicker_apply_on_multi_fasta will return an empty list. """ try: f = globals()[function] except: raise NotImplementedError("%s not implemented" % function) entries = quick_FASTA_reader(file) results = [] for name, seq in entries: arguments = [seq] for arg in args: arguments.append(arg) result = f(*arguments) if result: results.append('>%s\n%s' % (name, result)) handle.close() return results
self.assert_("STEP 2 / 2 d" in stderrdata)	self.assert_("Progressive alignment ..." in stderrdata, stderrdata)	def test_Mafft_simple(self): """Simple round-trip through app with infile. Result passed to stdout. """ #Use a keyword argument at init, cmdline = MafftCommandline(mafft_exe, input=self.infile1) self.assertEqual(str(eval(repr(cmdline))), str(cmdline)) child = subprocess.Popen(str(cmdline), stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=(sys.platform!="win32")) stdoutdata, stderrdata = child.communicate() return_code = child.returncode self.assertEqual(return_code, 0, "Got error code %i back from:\n%s" % (return_code, cmdline)) self.assert_(stdoutdata.startswith(">gi\|1348912\|gb\|G26680\|G26680")) self.assert_("STEP 2 / 2 d" in stderrdata) self.assert_("$#=0" not in stderrdata) del child
"Your description cannot be broken into nice lines!"	"Your description cannot be broken into nice lines!:\n%s" \ % repr(text)	def _split_multi_line(self, text, max_len): "Returns a list of strings.""" #TODO - Do the line spliting while preserving white space? text = text.strip() if len(text) < max_len: return [text]
start_end = identifier.rsplit("/",1)[1]	name, start_end = identifier.rsplit("/",1)	def _identifier_split(self, identifier): """Returns (name,start,end) string tuple from an identier.""" if identifier.find("/")!=-1: start_end = identifier.rsplit("/",1)[1] if start_end.count("-")==1: start, end = map(int, start_end.split("-")) name = identifier.split("/",1)[0] return (name, start, end) return (identifier, None, None)
name = identifier.split("/",1)[0]		def _identifier_split(self, identifier): """Returns (name,start,end) string tuple from an identier.""" if identifier.find("/")!=-1: start_end = identifier.rsplit("/",1)[1] if start_end.count("-")==1: start, end = map(int, start_end.split("-")) name = identifier.split("/",1)[0] return (name, start, end) return (identifier, None, None)
def values(self): """Would be a list of the SeqRecord objects, but not implemented. In general you can be indexing very very large files, with millions of sequences. Loading all these into memory at once as SeqRecord objects would (probably) use up all the RAM. Therefore we simply don't support this dictionary method. """ raise NotImplementedError("Due to memory concerns, when indexing a " "sequence file you cannot access all the " "records at once.") def items(self): """Would be a list of the (key, SeqRecord) tuples, but not implemented. In general you can be indexing very very large files, with millions of sequences. Loading all these into memory at once as SeqRecord objects would (probably) use up all the RAM. Therefore we simply don't support this dictionary method. """ raise NotImplementedError("Due to memory concerns, when indexing a " "sequence file you cannot access all the " "records at once.") def iteritems(self): """Iterate over the (key, SeqRecord) items.""" for key in self.__iter__(): yield key, self.__getitem__(key)	if hasattr(dict, "iteritems"): def values(self): """Would be a list of the SeqRecord objects, but not implemented. In general you can be indexing very very large files, with millions of sequences. Loading all these into memory at once as SeqRecord objects would (probably) use up all the RAM. Therefore we simply don't support this dictionary method. """ raise NotImplementedError("Due to memory concerns, when indexing a " "sequence file you cannot access all the " "records at once.") def items(self): """Would be a list of the (key, SeqRecord) tuples, but not implemented. In general you can be indexing very very large files, with millions of sequences. Loading all these into memory at once as SeqRecord objects would (probably) use up all the RAM. Therefore we simply don't support this dictionary method. """ raise NotImplementedError("Due to memory concerns, when indexing a " "sequence file you cannot access all the " "records at once.") def iteritems(self): """Iterate over the (key, SeqRecord) items.""" for key in self.__iter__(): yield key, self.__getitem__(key) else: def items(self): """Iterate over the (key, SeqRecord) items.""" for key in self.__iter__(): yield key, self.__getitem__(key) def values(self): """Iterate over the SeqRecord items.""" for key in self.__iter__(): yield self.__getitem__(key)	def values(self): """Would be a list of the SeqRecord objects, but not implemented.
Copes mixed case seuqneces, and with the ambiguous nucleotide S (G or C)	Copes mixed case sequences, and with the ambiguous nucleotide S (G or C)	def GC(seq): """Calculates G+C content, returns the percentage (float between 0 and 100). Copes mixed case seuqneces, and with the ambiguous nucleotide S (G or C) when counting the G and C content. The percentage is calculated against the full length, e.g.: >>> from Bio.SeqUtils import GC >>> GC("ACTGN") 40.0 Note that this will return zero for an empty sequence. """ try: gc = sum(map(seq.count,['G','C','g','c','S','s'])) return gc*100.0/len(seq) except ZeroDivisionError: return 0.0
start_end = identifier.split("/",1)[1]	start_end = identifier.rsplit("/",1)[1]	def _identifier_split(self, identifier): """Returns (name,start,end) string tuple from an identier.""" if identifier.find("/")!=-1: start_end = identifier.split("/",1)[1] if start_end.count("-")==1: start, end = map(int, start_end.split("-")) name = identifier.split("/",1)[0] return (name, start, end) return (identifier, None, None)
f.write("POP\n")	start_pop = True	def remove_population(self, pos, fname): """Removes a population (by position).
f.write("POP\n")		def remove_population(self, pos, fname): """Removes a population (by position).
clade.node_id = elem.text and elem.text.strip() or None	clade.node_id = PX.Id(elem.text.strip(), elem.attrib.get('provider'))	def _parse_clade(self, parent): """Parse a Clade node and its children, recursively.""" clade = PX.Clade(**parent.attrib) if clade.branch_length is not None: clade.branch_length = float(clade.branch_length) # NB: Only evaluate nodes at the current level tag_stack = [] for event, elem in self.context: namespace, tag = split_namespace(elem.tag) if event == 'start': if tag == 'clade': clade.clades.append(self._parse_clade(elem)) continue if tag == 'taxonomy': clade.taxonomies.append(self._parse_taxonomy(elem)) continue if tag == 'sequence': clade.sequences.append(self._parse_sequence(elem)) continue if tag in self._clade_tracked_tags: tag_stack.append(tag) if event == 'end': if tag == 'clade': elem.clear() break if tag != tag_stack[-1]: continue tag_stack.pop() # Handle the other non-recursive children if tag in self._clade_list_types: getattr(clade, self._clade_list_types[tag]).append( getattr(self, tag)(elem)) elif tag in self._clade_complex_types: setattr(clade, tag, getattr(self, tag)(elem)) elif tag == 'branch_length': # NB: possible collision with the attribute if clade.branch_length is not None: raise PhyloXMLError( 'Attribute branch_length was already set ' 'for this Clade.') clade.branch_length = _float(elem.text) elif tag == 'width': clade.width = _float(elem.text) elif tag == 'name': clade.name = collapse_wspace(elem.text) elif tag == 'node_id': clade.node_id = elem.text and elem.text.strip() or None elif namespace != NAMESPACES['phy']: clade.other.append(self.other(elem, namespace, tag)) elem.clear() else: raise PhyloXMLError('Misidentified tag: ' + tag) return clade
Roche SFF indices use base 255 not 256, meaning we see bytes in range the range 0 to 254 only. This appears to be so that byte 0xFF (character 255) can be used as a marker character to separate entries (required if the read name lengths vary). Note that since only four bytes are used for the read offset, this is limited to 255^4 bytes (nearly 4GB). If you try to use the Roche sfffile tool to combined SFF files beyound this limit, they issue a warning and ommit the index (and manifest).	Roche SFF indices use base 255 not 256, meaning we see bytes in range the range 0 to 254 only. This appears to be so that byte 0xFF (character 255) can be used as a marker character to separate entries (required if the read name lengths vary). Note that since only four bytes are used for the read offset, this is limited to 255^4 bytes (nearly 4GB). If you try to use the Roche sfffile tool to combine SFF files beyound this limit, they issue a warning and omit the index (and manifest).	def _sff_read_roche_index(handle): """Reads any existing Roche style read index provided in the SFF file (PRIVATE). Will use the handle seek/tell functions. This works on ".srt1.00" and ".mft1.00" style Roche SFF index blocks. Roche SFF indices use base 255 not 256, meaning we see bytes in range the range 0 to 254 only. This appears to be so that byte 0xFF (character 255) can be used as a marker character to separate entries (required if the read name lengths vary). Note that since only four bytes are used for the read offset, this is limited to 255^4 bytes (nearly 4GB). If you try to use the Roche sfffile tool to combined SFF files beyound this limit, they issue a warning and ommit the index (and manifest). """ number_of_reads, header_length, index_offset, index_length, xml_offset, \ xml_size, read_index_offset, read_index_size = _sff_find_roche_index(handle) #Now parse the read index... handle.seek(read_index_offset) fmt = ">5B" for read in range(number_of_reads): #TODO - Be more aware of when the index should end? data = handle.read(6) while True: more = handle.read(1) if not more: raise ValueError("Premature end of file!") data += more if more == _flag: break assert data[-1:] == _flag, data[-1:] name = _bytes_to_string(data[:-6]) off4, off3, off2, off1, off0 = struct.unpack(fmt, data[-6:-1]) offset = off0 + 255off1 + 65025off2 + 16581375off3 if off4: #Could in theory be used as a fifth piece of offset information, #i.e. offset =+ 4228250625Loff4, but testing the Roche tools this #is not the case. They simple don't support such large indexes. raise ValueError("Expected a null terminator to the read name.") yield name, offset if handle.tell() != read_index_offset + read_index_size: raise ValueError("Problem with index length? %i vs %i" \ % (handle.tell(), read_index_offset + read_index_size))
"to store in the Roche SFF index structure. No index " "block will be recorded." % (name, offset))	"to store in the Roche SFF index structure. No " "index block will be recorded." % (name, offset))	def write_record(self, record): """Write a single additional record to the output file.
if type(seq)!=type("aa"): seq=seq.tostring()		def gcg(seq): """Returns the GCG checksum (int) for a sequence (string or Seq object). Given a nucleotide or amino-acid secuence (or any string), returns the GCG checksum (int). Checksum used by GCG program. seq type = str. Based on BioPerl GCG_checksum. Adapted by Sebastian Bassi with the help of John Lenton, Pablo Ziliani, and Gabriel Genellina. All sequences are converted to uppercase """ index = checksum = 0 if type(seq)!=type("aa"): seq=seq.tostring() for char in seq: index += 1 checksum += index * ord(char.upper()) if index == 57: index = 0 return checksum % 10000
if type(seq)!=type("aa"): seq=seq.tostring().upper() else: seq=seq.upper() m.update(seq)		def seguid(seq): """Returns the SEGUID (string) for a sequence (string or Seq object). Given a nucleotide or amino-acid secuence (or any string), returns the SEGUID string (A SEquence Globally Unique IDentifier). seq type = str. For more information about SEGUID, see: http://bioinformatics.anl.gov/seguid/ DOI: 10.1002/pmic.200600032 """ try: #Python 2.5 sha1 is in hashlib import hashlib m = hashlib.sha1() except: #For older versions import sha m = sha.new() import base64 if type(seq)!=type("aa"): seq=seq.tostring().upper() else: seq=seq.upper() m.update(seq) try: #For Python 2.5 return base64.b64encode(m.digest()).rstrip("=") except: #For older versions import os #Note: Using os.linesep doesn't work on Windows, #where os.linesep= "\r\n" but the encoded string #contains "\n" but not "\r\n" return base64.encodestring(m.digest()).replace("\n","").rstrip("=")
	seq = seq.tostring() except AttributeError: pass m.update(seq.upper().encode()) try: return base64.encodebytes(m.digest()).decode().replace("\n","").rstrip("=") except AttributeError: pass try:	def seguid(seq): """Returns the SEGUID (string) for a sequence (string or Seq object). Given a nucleotide or amino-acid secuence (or any string), returns the SEGUID string (A SEquence Globally Unique IDentifier). seq type = str. For more information about SEGUID, see: http://bioinformatics.anl.gov/seguid/ DOI: 10.1002/pmic.200600032 """ try: #Python 2.5 sha1 is in hashlib import hashlib m = hashlib.sha1() except: #For older versions import sha m = sha.new() import base64 if type(seq)!=type("aa"): seq=seq.tostring().upper() else: seq=seq.upper() m.update(seq) try: #For Python 2.5 return base64.b64encode(m.digest()).rstrip("=") except: #For older versions import os #Note: Using os.linesep doesn't work on Windows, #where os.linesep= "\r\n" but the encoded string #contains "\n" but not "\r\n" return base64.encodestring(m.digest()).replace("\n","").rstrip("=")
self.assertEqual(self.ctrl.get_alleles(0,"Locus3"), [3, 20])	self.assertEqual(set(self.ctrl.get_alleles(0,"Locus3")), set([3, 20]))	def test_get_alleles(self): """Test get alleles. """ self.assertEqual(self.ctrl.get_alleles(0,"Locus3"), [3, 20])
dx = float(max_d - values[-1]) / (values[-1] - values[-2])	dx = len(values) > 1 and float(max_d - values[-1]) / \ (values[-1] - values[-2]) or max_d	def field_size(self, axis): size = {'x': 'width', 'y': 'height'}[axis] side = {'x': 'right', 'y': 'top'}[axis] values = getattr(self, 'get_%s_values' % axis)() max_d = self.data_max(axis) dx = float(max_d - values[-1]) / (values[-1] - values[-2]) graph_size = getattr(self, 'graph_%s' % size) side_font = getattr(self, '%s_font' % side) side_align = getattr(self, '%s_align' % side) result = (float(graph_size) - self.font_size2side_font) / \ (len(values) + dx - side_align) return result
lisp.push_mark()	marker_ring = self.get('marker_ring') marker = lisp.point_marker() lisp.ring_insert(marker_ring, marker) def pop_mark(self): marker_ring = self.get('marker_ring') if lisp.ring_empty_p(marker_ring): self.message("There are no more marked buffers in \ the rope-marker-ring") else: oldbuf = lisp.current_buffer() marker = lisp.ring_remove(marker_ring, 0) marker_buffer = lisp.marker_buffer(marker) if marker_buffer is None: lisp.message("The marked buffer has been deleted") return marker_point = lisp.marker_position(marker) lisp.set_buffer(marker_buffer) lisp.goto_char(marker_point) lisp.set_marker(marker, None, None) if not lisp.eq(oldbuf, marker_buffer): lisp.switch_to_buffer(marker_buffer)	def push_mark(self): lisp.push_mark()
conf.registerPlugin('Bantracker', True)	Bantracker = conf.registerPlugin('Bantracker', True)	def anything(prompt, default=None): """Because supybot is pure fail""" from supybot.questions import expect return expect(prompt, [], default=default)
output("%r is an invalid value, it must be an integer or float greater or equal to 0", review)	output("%r is an invalid value, it must be an integer or float greater or equal to 0" % review)	def getReviewTime(): output("How many days should the bot wait before requesting a ban/quiet review?") review = something("Can be an integer or decimal value. Zero disables reviews.", default=str(Bantracker.request.review._default))
from supybot.question import yn, something, output	from supybot.questions import yn, something, output	def configure(advanced): from supybot.question import yn, something, output import sqlite import re import os from supybot.utils.str import format def anything(prompt, default=None): """Because supybot is pure fail""" from supybot.questions import expect return expect(prompt, [], default=default) conf.registerPlugin('Bantracker', True) def getReviewTime(): output("How many days should the bot wait before requesting a ban/quiet review?") review = something("Can be an integer or decimal value. Zero disables reviews.", default=str(Bantracker.review._default)) try: review = float(review) if review < 0: raise TypeError except TypeError: output("%r is an invalid value, it must be an integer or float greater or equal to 0", review) return getReviewTime() else: return review enabled = yn("Enable Bantracker for all channels?") database = something("Location of the Bantracker database", default=conf.supybot.directories.data.dirize('bans.db')) bansite = anything("URL of the Bantracker web interface, without the 'bans.cgi'. (leave this blank if you don't want to run a web server)") request = yn("Enable review and comment requests from bot?", default=False) if request and advanced: output("Which types would you like the bot to request comments for?") output(format("The available request types are %L", type)) types = anything("Separate types by spaces or commas:", default=', '.join(Bantracker.type._default)) type = set([]) for name in re.split(r',?\s+', types): name = name.lower() if name in ('removal', 'ban', 'quiet'): type.append(name) output("Which nicks should be bot not requets comments from?") output("Is case insensitive and wildcards '' and '?' are accepted.") ignores = anything("Separate types by spaces or commas:", default=', '.join(Bantracker.ignore._default)) ignore = set([]) for name in re.split(r',?\s+', ignores): name = name.lower() ignore.add(name) output("You can set the comment and review requests for some nicks to be forwarded to specific nicks/channels") output("Which nicks should these requests be forwarded for?") output("Is case insensitive and wildcards '' and '?' are accepted.") forwards = anything("Separate types by spaces or commas:", default=', '.join(Bantracker.forward._default)) forward = set([]) for name in re.split(r',?\s+', forwards): name = name.lower() forward.add(name) output("Which nicks/channels should the requests be forwarded to?") output("Is case insensitive and wildcards '*' and '?' are accepted.") channels_i = anything("Separate types by spaces or commas:", default=', '.join(Bantracker.channels._default)) channels = set([]) for name in re.split(r',?\s+', channel_i): name = name.lower() channels.add(name) review = getReviewTime() else: type = Bantracker.type._default ignore = Bantracker.ignore._default forward = Bantracker.forward._default channels = Bantracker.channels._default review = Bantracker.review._default Bantracker.enabled.setValue(enabled) Bantracker.database.setValue(database) Bantracker.bansite.setValue(bansite) Bantracker.request.setValue(request) Bantracker.type.setValue(type) Bantracker.ignore.setValue(ignore) Bantracker.forward.setValue(forward) Bantracker.channels.setValue(channels) Bantracker.review.setValue(review) # Create the initial database db_file = Bantracker.database() if not db_file: db_file = conf.supybot.directories.data.dirize('bans.db') output("supybot.plugins.Bantracker.database will be set to %r" % db_file) Bantracker.database.setValue(db_file) if os.path.exists(db_file): return output("Creating an initial database in %r" % db_file) con = sqlite.connect(db_file) cur = con.cursor() try: con.begin() cur.execute("""CREATE TABLE 'bans' ( id INTEGER PRIMARY KEY, channel VARCHAR(30) NOT NULL, mask VARCHAR(100) NOT NULL, operator VARCHAR(30) NOT NULL, time VARCHAR(300) NOT NULL, removal DATETIME, removal_op VARCHAR(30), log TEXT