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