It should be noted that no checks are performed to prevent the same name being used for annotations. """ operator, value = \ self.validate(field, roperator, rvalue, tree, **kwargs) condition = self._condition(field, operator, value, tree) language = self.language(field, operator, value, **kwargs) return { 'field': field.pk, 'operator': roperator, 'value': rvalue, 'cleaned_data': { 'value': value, 'operator': operator, 'language': language, }, 'query_modifiers': { 'condition': condition, 'annotations': None, 'extra': None, } } registry = loader.Registry(default=Translator) # this will be invoked when it is imported by models.py to use the # registry choices loader.autodiscover('translators')
from avocado.core import loader from avocado.conf import OPTIONAL_DEPS from _base import BaseExporter # noqa from _csv import CSVExporter from _sas import SASExporter from _r import RExporter from _json import JSONExporter from _html import HTMLExporter # noqa registry = loader.Registry(register_instance=False) registry.register(CSVExporter, CSVExporter.short_name.lower()) registry.register(SASExporter, SASExporter.short_name.lower()) registry.register(RExporter, RExporter.short_name.lower()) registry.register(JSONExporter, JSONExporter.short_name.lower()) # registry.register(HTMLExporter, HTMLExporter.short_name.lower()) if OPTIONAL_DEPS['openpyxl']: from _excel import ExcelExporter registry.register(ExcelExporter, ExcelExporter.short_name.lower()) loader.autodiscover('exporters')
def is_valid(self, value): return super(Range, self).is_valid(value) and len(value) == 2 def text(self, value): value = map(self.coerce_to_unicode, value) return u'{0} {1}'.format(self.verbose_name, ' and '.join(value)) class NotRange(Range): short_name = 'not between' verbose_name = 'is not between' negated = True # Register operators registry = loader.Registry() # General equality registry.register(Exact, Exact.uid) registry.register(NotExact, NotExact.uid) # String operators registry.register(InsensitiveExact, InsensitiveExact.uid) registry.register(Contains, Contains.uid) registry.register(InsensitiveContains, InsensitiveContains.uid) registry.register(InsensitiveNotExact, InsensitiveNotExact.uid) registry.register(NotContains, NotContains.uid) registry.register(NotInsensitiveContains, NotInsensitiveContains.uid) registry.register(Regex, Regex.uid) registry.register(NotRegex, NotRegex.uid) registry.register(InsensitiveRegex, InsensitiveRegex.uid)
return float(value) except (ValueError, TypeError): pass raise ExpectedFormatterException('cannot be converted into a number') def to_coded(self, value, field, context): # Attempts to convert value to its coded representation if field: coded_values = field.coded_values() if coded_values is not None: return coded_values.get(value) raise ExpectedFormatterException('field does not support coded values') def to_raw(self, value, field, context): return value class RawFormatter(Formatter): def __init__(self, *args, **kwargs): kwargs.pop('formats', None) kwargs['formats'] = ('raw', ) return super(RawFormatter, self).__init__(*args, **kwargs) registry = loader.Registry(default=Formatter, register_instance=False) loader.autodiscover('formatters')