from htswfrontend.analys_track.models import *
from htswfrontend.exp_track.models import *
from string import *
+from htswfrontend.htsw_reports.utils import *
import re
##from p1 import LibInfo
from libinfopar import *
return '%s<br/>%s' % (self.submitted_to_NCBI,varText)
submit_to_NCBI.allow_tags = True
- #REPS = ((1,1),(2,2),(3,3))
- #replicate = models.PositiveSmallIntegerField(choices=REPS,verbose_name='Replicate Number')
-
- ## -- Utility functions
- def unique(self,s):
- """Return a list of the elements in s, but without duplicates.
- For example, unique([1,2,3,1,2,3]) is some permutation of [1,2,3],
- unique("abcabc") some permutation of ["a", "b", "c"], and
- unique(([1, 2], [2, 3], [1, 2])) some permutation of
- [[2, 3], [1, 2]].
- For best speed, all sequence elements should be hashable. Then
- unique() will usually work in linear time.
- If not possible, the sequence elements should enjoy a total
- ordering, and if list(s).sort() doesn't raise TypeError it's
- assumed that they do enjoy a total ordering. Then unique() will
- usually work in O(N*log2(N)) time.
- If that's not possible either, the sequence elements must support
- equality-testing. Then unique() will usually work in quadratic
- time.
- """
-
- n = len(s)
- if n == 0:
- return []
-
- # Try using a dict first, as that's the fastest and will usually
- # work. If it doesn't work, it will usually fail quickly, so it
- # usually doesn't cost much to *try* it. It requires that all the
- # sequence elements be hashable, and support equality comparison.
- u = {}
- try:
- for x in s:
- u[x] = 1
- except TypeError:
- del u # move on to the next method
- else:
- return u.keys()
-
- # We can't hash all the elements. Second fastest is to sort,
- # which brings the equal elements together; then duplicates are
- # easy to weed out in a single pass.
- # NOTE: Python's list.sort() was designed to be efficient in the
- # presence of many duplicate elements. This isn't true of all
- # sort functions in all languages or libraries, so this approach
- # is more effective in Python than it may be elsewhere.
- try:
- t = list(s)
- t.sort()
- except TypeError:
- del t # move on to the next method
- else:
- assert n > 0
- last = t[0]
- lasti = i = 1
- while i < n:
- if t[i] != last:
- t[lasti] = last = t[i]
- lasti += 1
- i += 1
- return t[:lasti]
-
- # Brute force is all that's left.
- u = []
- for x in s:
- if x not in u:
- u.append(x)
- return u
-
+ ## -- Utility functions <-- This method was transfered to untils.py
## --- LIBARAY PREPARATION SECTION
def getLibIds(self):
arLibs.append(t.subject1.library_id)
if t.subject2 is not None:
arLibs.append(t.subject2.library_id)
- arLibs = self.unique(arLibs)
+ arLibs = unique(arLibs)
return arLibs #.sort()
def getFCInfo(self,libid): ## This is the haviest function
arRows.append('<li>'+rec.antibody.antibodies+' for <b>'+rec.antibody.antigene+'</b> (src:'+rec.antibody.source+', cat:'+rec.antibody.catalog+')</li>')
except ObjectDoesNotExist:
tstr += ""
- tstr += "".join(self.unique(arRows))+'</ul>'
+ tstr += "".join(unique(arRows))+'</ul>'
return tstr
ab_batch.allow_tags = True
arRows.append('<li><b>'+rec.cell_line.cellline_name+'</b> ('+rec.condition.condition_name+')</li>')
except ObjectDoesNotExist:
tstr += ""
- tstr += "".join(self.unique(arRows))+'</ul>'
+ tstr += "".join(unique(arRows))+'</ul>'
return tstr
cell_line.allow_tags = True
arRows.append('<li><b>'+rec.condition.condition_name+'</b></li>')
except ObjectDoesNotExist:
tstr += ""
- tstr += "".join(self.unique(arRows))+'</ul>'
+ tstr += "".join(unique(arRows))+'</ul>'
return tstr
cell_harvest_batch.allow_tags = True
arRows.append('<li><b>'+rec.library_id+'</b>: '+rec.library_name+'.<br/>Made By: '+rec.made_by+', On: '+ rec.creation_date.__str__()+'</li>')
except ObjectDoesNotExist:
tstr += ""
- tstr += "".join(self.unique(arRows))+'</ul></div>'
+ tstr += "".join(unique(arRows))+'</ul></div>'
return tstr
library.allow_tags = True
list_display = ('Study','ab_batch','cell_line','library','sequencing','aligned_reads','QPCR','submit_to_DCC','submit_to_NCBI','interactome_complete')
## list_filter = ('interactome_complete')
+
+#############################################
--- /dev/null
+def unique(s):
+ """Return a list of the elements in s, but without duplicates.
+ For example, unique([1,2,3,1,2,3]) is some permutation of [1,2,3],
+ unique("abcabc") some permutation of ["a", "b", "c"], and
+ unique(([1, 2], [2, 3], [1, 2])) some permutation of
+ [[2, 3], [1, 2]].
+ For best speed, all sequence elements should be hashable. Then
+ unique() will usually work in linear time.
+ If not possible, the sequence elements should enjoy a total
+ ordering, and if list(s).sort() doesn't raise TypeError it's
+ assumed that they do enjoy a total ordering. Then unique() will
+ usually work in O(N*log2(N)) time.
+ If that's not possible either, the sequence elements must support
+ equality-testing. Then unique() will usually work in quadratic
+ time.
+ """
+
+ n = len(s)
+ if n == 0:
+ return []
+
+ # Try using a dict first, as that's the fastest and will usually
+ # work. If it doesn't work, it will usually fail quickly, so it
+ # usually doesn't cost much to *try* it. It requires that all the
+ # sequence elements be hashable, and support equality comparison.
+ u = {}
+ try:
+ for x in s:
+ u[x] = 1
+ except TypeError:
+ del u # move on to the next method
+ else:
+ return u.keys()
+ # We can't hash all the elements. Second fastest is to sort,
+ # which brings the equal elements together; then duplicates are
+ # easy to weed out in a single pass.
+ # NOTE: Python's list.sort() was designed to be efficient in the
+ # presence of many duplicate elements. This isn't true of all
+ # sort functions in all languages or libraries, so this approach
+ # is more effective in Python than it may be elsewhere.
+ try:
+ t = list(s)
+ t.sort()
+ except TypeError:
+ del t # move on to the next method
+ else:
+ assert n > 0
+ last = t[0]
+ lasti = i = 1
+ while i < n:
+ if t[i] != last:
+ t[lasti] = last = t[i]
+ lasti += 1
+ i += 1
+ return t[:lasti]
+ # Brute force is all that's left.
+ u = []
+ for x in s:
+ if x not in u:
+ u.append(x)
+ return u
projects / htsworkflow.git / commitdiff