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')