def test_transform(self):
try:
IntegerField.register_lookup(Chr)
authors = Author.objects.annotate(name_code_point=Ord('name'))
self.assertCountEqual(
authors.filter(name_code_point__chr=Chr(ord('J'))),
[self.john])
self.assertCountEqual(
authors.exclude(name_code_point__chr=Chr(ord('J'))),
[self.elena, self.rhonda])
finally:
IntegerField._unregister_lookup(Chr)
def test_chr_transform(self):
try:
IntegerField.register_lookup(Chr, 'chr')
Author.objects.create(name='John Smith', alias='smithj')
Author.objects.create(name='Élena Jordan', alias='elena')
Author.objects.create(name='Rhonda')
authors = Author.objects.annotate(name_code_point=Ord('name'))
self.assertQuerysetEqual(
authors.filter(name_code_point__chr=Chr(ord('J'))),
['John Smith'], lambda x: x.name)
self.assertQuerysetEqual(
authors.exclude(name_code_point__chr=Chr(ord('J'))),
['Élena Jordan', 'Rhonda'],
lambda x: x.name,
ordered=False,
)
finally:
IntegerField._unregister_lookup(Chr, 'chr')
Meant to be used in the larger ER_plotter Django app.
Each page request is defined by a function below.
Note that several points use an infinite scroll module in place of Digg pagination.
Most elements exist in try blocks that on exception set an object invalid to True.
These invalidations are used in the template and elsewhere.
'''
class AbsoluteValue(Transform):
lookup_name = 'abs'
function = 'ABS'
from django.db.models import IntegerField
IntegerField.register_lookup(AbsoluteValue)
class nvertx_results(object):
'''
nvertx_results():
Class to query the database and return a series of dictionaries with the results
usage: nvertx_1_results = nvertx_results(nvertx, log2)
Arguments:
nvertx = the nvertx id, this is used as the key for querying the db
log2 = boolean to determine whether or not to convert results to log2
dicionary results:
invalid = series of boolean operators. If a 'Try' block fails, it sets to True. These are used as tests in the template
sequence_fasta = nucelotide sequence of the transcript. Not in fasta, just raw sequence.
# Codigo da implementacao de um custom lookup exatamente como esta documentado para maior didatica
class Funcao(Lookup):
lookup_name = 'func'
def as_sql(self, qn, connection):
lhs, lhs_params = self.process_lhs(qn, connection)
rhs, rhs_params = self.process_rhs(qn, connection)
params = lhs_params + rhs_params
print params
return '%s <> %s' % (lhs, rhs), params
# Avisando o Django sobre a implementacao do custom lookup
Field.register_lookup(Funcao)
# Codigo da implementacao de uma transformacao
# foram feitas algumas alteracoes da documentacao
# para se adequar ao template
class IdadeMenor(Transform):
lookup_name = 'idmenor'
def as_sql(self, qn, connection):
lhs, params = qn.compile(self.lhs)
return "ABS(%s)" % lhs, params
# Avisando o Django sobre a implementacao da transformacao
IntegerField.register_lookup(IdadeMenor)
class Funcao(Lookup):
lookup_name = 'func'
def as_sql(self, qn, connection):
lhs, lhs_params = self.process_lhs(qn, connection)
rhs, rhs_params = self.process_rhs(qn, connection)
params = lhs_params + rhs_params
print params
return '%s <> %s' % (lhs, rhs), params
# Avisando o Django sobre a implementacao do custom lookup
Field.register_lookup(Funcao)
# Codigo da implementacao de uma transformacao
# foram feitas algumas alteracoes da documentacao
# para se adequar ao template
class IdadeMenor(Transform):
lookup_name = 'idmenor'
def as_sql(self, qn, connection):
lhs, params = qn.compile(self.lhs)
return "ABS(%s)" % lhs, params
# Avisando o Django sobre a implementacao da transformacao
IntegerField.register_lookup(IdadeMenor)
rhs, rhs_params = self.process_rhs(compiler, connection)
params = lhs_params + rhs_params
return '%s <> %s' % (lhs, rhs), params
from django.db.models import Transform
class AbsoluteValue(Transform):
lookup_name = 'abs'
def as_sql(self, compiler, connection):
lhs, params = compiler.compile(self.lhs)
return "ABS(%s)" % lhs, params
from django.db.models import IntegerField
IntegerField.register_lookup(AbsoluteValue)
#*******************************
from django.db.models import Transform, FloatField, Lookup
class NegativeValue(Transform):
lookup_name = 'ne'
def as_sql(self, compiler, connection):
lhs, params = compiler.compile(self.lhs) #Сравнить с process_lhs
return '-1 * %s' % lhs, params
@property
def output_field(self):
return IntegerField()
class StartClassDate(Transform):
lookup_name = 'datestart'
@property
def output_field(self):
return DateField()
DateField.register_lookup(AddDate)
DateTimeField.register_lookup(AddDate)
DateField.register_lookup(DateDiff)
DateTimeField.register_lookup(DateDiff)
DateField.register_lookup(DayYear)
DateTimeField.register_lookup(DayYear)
DateField.register_lookup(NumDay)
DateTimeField.register_lookup(NumDay)
SmallIntegerField.register_lookup(DateFromNum)
PositiveIntegerField.register_lookup(DateFromNum)
IntegerField.register_lookup(DateFromNum)
# AddDate, DateDiff, DayYear, NumDay, DateFromNum, MakeDate, DateToday
# Find the difference between two dates, may span over some years.
# Create a new date by adding or subtracting an integer of days. date1: datetime, num: integer -> datetime
# Determine if a date is before or after another date.
# Transform with my special rules for determining the start date of a given classoffer
# date1: datetime, day: integer for day of the week, shift: integer for direction and max to go in that direction.
# From the day of the week of date1, try to go in the direction of shift to get to day.
# If that requires going beyond the range of shift, then go the opposite direction.
# Thus, the new date is computed for before or after the date1 and returned as a DateField
