def lazy_number(func, resultclass, number=None, **kwargs): if isinstance(number, six.integer_types): kwargs['number'] = number proxy = lazy(func, resultclass)(**kwargs) else: class NumberAwareString(resultclass): def __mod__(self, rhs): if isinstance(rhs, dict) and number: try: number_value = rhs[number] except KeyError: raise KeyError('Your dictionary lacks key \'%s\'. ' 'Please provide it, because it is required to ' 'determine whether string is singular or plural.' % number) else: number_value = rhs kwargs['number'] = number_value translated = func(**kwargs) try: translated = translated % rhs except TypeError: # String doesn't contain a placeholder for the number pass return translated proxy = lazy(lambda **kwargs: NumberAwareString(), NumberAwareString)(**kwargs) return proxy
def lazy_number(func, resultclass, number=None, **kwargs): if isinstance(number, int): kwargs['number'] = number proxy = lazy(func, resultclass)(**kwargs) else: original_kwargs = kwargs.copy() class NumberAwareString(resultclass): def __bool__(self): return bool(kwargs['singular']) def __mod__(self, rhs): if isinstance(rhs, dict) and number: try: number_value = rhs[number] except KeyError: raise KeyError( "Your dictionary lacks key '%s\'. Please provide " "it, because it is required to determine whether " "string is singular or plural." % number ) else: number_value = rhs kwargs['number'] = number_value translated = func(**kwargs) try: translated = translated % rhs except TypeError: # String doesn't contain a placeholder for the number. pass return translated proxy = lazy(lambda **kwargs: NumberAwareString(), NumberAwareString)(**kwargs) proxy.__reduce__ = lambda: (_lazy_number_unpickle, (func, resultclass, number, original_kwargs)) return proxy
def auth(request): """ Returns context variables required by apps that use Django's authentication system. If there is no 'user' attribute in the request, uses AnonymousUser (from django.contrib.auth). """ # If we access request.user, request.session is accessed, which results in # 'Vary: Cookie' being sent in every request that uses this context # processor, which can easily be every request on a site if # TEMPLATE_CONTEXT_PROCESSORS has this context processor added. This kills # the ability to cache. So, we carefully ensure these attributes are lazy. # We don't use django.utils.functional.lazy() for User, because that # requires knowing the class of the object we want to proxy, which could # break with custom auth backends. LazyObject is a less complete but more # flexible solution that is a good enough wrapper for 'User'. def get_user(): if hasattr(request, 'user'): return request.user else: from django.contrib.auth.models import AnonymousUser return AnonymousUser() return { 'user': SimpleLazyObject(get_user), 'messages': lazy(memoize(lambda: get_user().get_and_delete_messages(), {}, 0), list)(), 'perms': lazy(lambda: PermWrapper(get_user()), PermWrapper)(), }
def __init__(self, attrs=None, date_format=None, time_format=None): attrs = attrs or {} if 'placeholder' in attrs: del attrs['placeholder'] date_attrs = dict(attrs) time_attrs = dict(attrs) date_attrs.setdefault('class', 'form-control splitdatetimepart') time_attrs.setdefault('class', 'form-control splitdatetimepart') date_attrs.setdefault('autocomplete', 'off') time_attrs.setdefault('autocomplete', 'off') date_attrs['class'] += ' datepickerfield' time_attrs['class'] += ' timepickerfield' def date_placeholder(): df = date_format or get_format('DATE_INPUT_FORMATS')[0] return now().replace( year=2000, month=12, day=31, hour=18, minute=0, second=0, microsecond=0 ).strftime(df) def time_placeholder(): tf = time_format or get_format('TIME_INPUT_FORMATS')[0] return now().replace( year=2000, month=1, day=1, hour=0, minute=0, second=0, microsecond=0 ).strftime(tf) date_attrs['placeholder'] = lazy(date_placeholder, str) time_attrs['placeholder'] = lazy(time_placeholder, str) widgets = ( forms.DateInput(attrs=date_attrs, format=date_format), forms.TimeInput(attrs=time_attrs, format=time_format), ) # Skip one hierarchy level forms.MultiWidget.__init__(self, widgets, attrs)
def display_text(cls, bc): """Return the text to be used for representing the given choice instance `bc` to the user. Override this to customize the display text of choices. :class:`lino.modlib.users.choicelists.UserGroups` and :class:`lino.modlib.cv.models.CefLevel` used to do this before we had the :attr:`ChoiceList.show_values` option. This must be lazyly translatable because the result are also used to build the `choices` attribute of ChoiceListFields on this choicelist. Note that Django's `lazy` function has a list of "resultclasses" which are used "so that the automatic forcing of the lazy evaluation code is triggered". """ if cls.show_values: # if unicodeerror: # assert_pure(str(bc)) # str(bc) def fn(bc): # return "%s (%s)" % (bc.value, str(bc)) return "{0} ({1})".format(bc.value, bc) return lazy(fn, str, six.text_type)(bc) return lazy(str, str, six.text_type)(bc)
def stats(request): def _formations(): return str(Formation.objects.exclude(statut=StatutsFormation.supprimee).count()) def _etablissements(): data = Formation.objects.exclude(statut=StatutsFormation.supprimee) \ .values('etablissement') etablissements = set() for d in data: etablissements.add(d['etablissement']) return str(len(etablissements)) def _disciplines(): data = Formation.objects.exclude(statut=StatutsFormation.supprimee) \ .values('discipline_1', 'discipline_2', 'discipline_3') disciplines = set() for d in data: disciplines.add(d['discipline_1']) disciplines.add(d['discipline_2']) disciplines.add(d['discipline_3']) return str(len(disciplines)) def _pays(): data = Formation.objects.exclude(statut=StatutsFormation.supprimee).values('etablissement__pays') pays = set() for d in data: pays.add(d['etablissement__pays']) return str(len(pays)) return { 'stats_formations': lazy(_formations, str), 'stats_etablissements': lazy(_etablissements, str), 'stats_disciplines': lazy(_disciplines, str), 'stats_pays': lazy(_pays, str), }
def __init__(self, *args, **kwargs): """We need to override this to make the choices lazy and prevent import madness""" super(Group, self).__init__(*args, **kwargs) field = self._meta.get_field('permissions') field._choices = lazy(get_permission_choices, list)() field.item_field_type._choices = lazy(get_permission_choices, list)()
def test_IPAddressField(self): with warnings.catch_warnings(record=True): warnings.simplefilter("always") lazy_func = lazy(lambda: "127.0.0.1", six.text_type) self.assertIsInstance(IPAddressField().get_prep_value(lazy_func()), six.text_type) lazy_func = lazy(lambda: 0, int) self.assertIsInstance(IPAddressField().get_prep_value(lazy_func()), six.text_type)
def test_CommaSeparatedIntegerField(self): lazy_func = lazy(lambda: '1,2', six.text_type) self.assertIsInstance( CommaSeparatedIntegerField().get_prep_value(lazy_func()), six.text_type) lazy_func = lazy(lambda: 0, int) self.assertIsInstance( CommaSeparatedIntegerField().get_prep_value(lazy_func()), six.text_type)
def test_FileField(self): lazy_func = lazy(lambda: 'filename.ext', six.text_type) self.assertIsInstance( FileField().get_prep_value(lazy_func()), six.text_type) lazy_func = lazy(lambda: 0, int) self.assertIsInstance( FileField().get_prep_value(lazy_func()), six.text_type)
def test_FilePathField(self): lazy_func = lazy(lambda: 'tests.py', six.text_type) self.assertIsInstance( FilePathField().get_prep_value(lazy_func()), six.text_type) lazy_func = lazy(lambda: 0, int) self.assertIsInstance( FilePathField().get_prep_value(lazy_func()), six.text_type)
def test_GenericIPAddressField(self): lazy_func = lazy(lambda: '127.0.0.1', six.text_type) self.assertIsInstance( GenericIPAddressField().get_prep_value(lazy_func()), six.text_type) lazy_func = lazy(lambda: 0, int) self.assertIsInstance( GenericIPAddressField().get_prep_value(lazy_func()), six.text_type)
def test_TextField(self): lazy_func = lazy(lambda: 'Abc', six.text_type) self.assertIsInstance( TextField().get_prep_value(lazy_func()), six.text_type) lazy_func = lazy(lambda: 0, int) self.assertIsInstance( TextField().get_prep_value(lazy_func()), six.text_type)
def test_lazy_equality(self): """ == and != work correctly for Promises. """ lazy_a = lazy(lambda: 4, int) lazy_b = lazy(lambda: 4, int) lazy_c = lazy(lambda: 5, int) self.assertEqual(lazy_a(), lazy_b()) self.assertNotEqual(lazy_b(), lazy_c())
def override_gettext(real_translation): """replace django's translation functions with safe versions""" translation.gettext = real_translation.gettext translation.ugettext = real_translation.ugettext translation.ngettext = real_translation.ngettext translation.ungettext = real_translation.ungettext translation.gettext_lazy = lazy(real_translation.gettext, str) translation.ugettext_lazy = lazy(real_translation.ugettext, unicode) translation.ngettext_lazy = lazy(real_translation.ngettext, str) translation.ungettext_lazy = lazy(real_translation.ungettext, unicode)
def display_text(cls, bc): """ Override this to customize the display text of choices. :class:`lino.core.perms.UserGroups` and :class:`lino.modlib.cv.models.CefLevel` used to do this before we had the :attr:`ChoiceList.show_values` option. """ if cls.show_values: def fn(bc): return u"%s (%s)" % (bc.value, unicode(bc)) return lazy(fn, unicode)(bc) return lazy(unicode, unicode)(bc)
def display_text(cls, bc): """Override this to customize the display text of choices. :class:`lino.modlib.users.choicelists.UserGroups` and :class:`lino.modlib.cv.models.CefLevel` used to do this before we had the :attr:`ChoiceList.show_values` option. """ if cls.show_values or True: def fn(bc): # return "%s (%s)" % (bc.value, str(bc)) return "{0} ({1})".format(bc.value, bc) return lazy(fn, bytes)(bc) return lazy(bytes, bytes)(bc)
def test_lazy(self): from django.utils import functional from django.utils.encoding import force_text lazy_unicode = functional.lazy(lambda: u'abc', unicode)() lazy_string = functional.lazy(lambda: 'abc', str)() self.assertEqual(force_text(lazy_unicode), 'abc') self.assertEqual(force_text(lazy_string), 'abc') self.assertEqual(unicode(lazy_unicode), 'abc') self.assertEqual(unicode(lazy_string), 'abc') self.assertEqual(str(lazy_unicode), 'abc') self.assertEqual(str(lazy_string), 'abc')
def csrf(request): """ Context processor that provides a CSRF token, or the string 'NOTPROVIDED' if it has not been provided by either a view decorator or the middleware """ def _get_val(): token = get_token(request) if token is None: # In order to be able to provide debugging info in the # case of misconfiguration, we use a sentinel value # instead of returning an empty dict. return 'NOTPROVIDED' else: key = force_bytes(get_random_string(16)) aes = AES.new(key) pad_length = 16 - (len(token) % 16 or 16) padding = ''.join('#' for _ in range(pad_length)) value = base64.b64encode( aes.encrypt('{0}{1}'.format(token, padding)) ) token = '$'.join((force_text(key), force_text(value))) return force_text(token) _get_val = lazy(_get_val, text_type) return {'csrf_token': _get_val()}
def register_recent_contests(request): if not hasattr(request, 'contest') or not hasattr(request, 'session'): return {} def generator(): return recent_contests(request) return {'recent_contests': lazy(generator, list)()}
def test_basic(self): from django.utils.functional import lazy obj = lazy(lambda: 'bar', six.text_type)() res = transform(obj) expected = "'bar'" if six.PY3 else "u'bar'" self.assertEquals(res, expected)
def __init__(self, *args, **kwargs): kwargs["max_length"] = 1000 if not "help_text" in kwargs: kwargs["help_text"] = "Type in name to search for person" super(EmailsField, self).__init__(*args, **kwargs) self.widget.attrs["class"] = "tokenized-field" self.widget.attrs["data-ajax-url"] = lazy(urlreverse, str)("ajax_search_emails") # make this lazy to prevent initialization problem
def likes(user, work, request=None): if not user.is_authenticated(): return False if request is None: return work.tags.filter(category='set', user=user).exists() if not hasattr(request, 'social_likes'): # tuple: unchecked, checked, liked request.social_likes = defaultdict(lambda: (set(), set(), set())) ct = ContentType.objects.get_for_model(type(work)) likes_t = request.social_likes[ct.pk] if work.pk in likes_t[1]: return work.pk in likes_t[2] else: likes_t[0].add(work.pk) def _likes(): if likes_t[0]: ids = tuple(likes_t[0]) likes_t[0].clear() likes_t[2].update(Tag.intermediary_table_model.objects.filter( content_type_id=ct.pk, tag__user_id=user.pk, object_id__in=ids ).distinct().values_list('object_id', flat=True)) likes_t[1].update(ids) return work.pk in likes_t[2] return lazy(_likes, bool)()
def dangling_problems_processor(request): if not getattr(request, 'contest', None): return {} if not is_contest_admin(request): return {} def generator(): dangling_pis = ProblemInstance.objects.filter(contest=request.contest, round__isnull=True) count = dangling_pis.count() if not count: return '' elif count == 1: pi = dangling_pis.get() link = reverse('oioioiadmin:contests_probleminstance_change', args=(pi.id,)) if request.path == link: return '' else: link = reverse('oioioiadmin:contests_probleminstance_changelist') text = ungettext('%(count)d PROBLEM WITHOUT ROUND', '%(count)d PROBLEMS WITHOUT ROUNDS', count) % {'count': count} return make_navbar_badge(link, text) return {'extra_navbar_right_dangling_problems': lazy(generator, unicode)()}
def auth(request): """Adds a new 'obj_perms' context variable. If there is no 'user' attribute in the request, uses AnonymousUser (from django.contrib.auth). """ # If we access request.user, request.session is accessed, which results in # 'Vary: Cookie' being sent in every request that uses this context # processor, which can easily be every request on a site if # TEMPLATE_CONTEXT_PROCESSORS has this context processor added. This kills # the ability to cache. So, we carefully ensure these attributes are lazy. # We don't use django.utils.functional.lazy() for User, because that # requires knowing the class of the object we want to proxy, which could # break with custom auth backends. LazyObject is a less complete but more # flexible solution that is a good enough wrapper for 'User'. def _get_user(): user = None if hasattr(request, 'user'): user = request.user if not user: from django.contrib.auth.models import AnonymousUser user = AnonymousUser() return user return { 'obj_perms': lazy(lambda: ObjPermWrapper(_get_user()), ObjPermWrapper)(), }
def patch(): global django_reverse # Will not patch twice. if urlresolvers.reverse is not reverse: django_reverse = urlresolvers.reverse urlresolvers.reverse = reverse urlresolvers.reverse_lazy = lazy(reverse, str)
def navbar_tip_processor(request): if not getattr(request, 'contest', None): return {} if not request.user.is_authenticated(): return {} def generator(): is_admin = request.user.has_perm('contests.contest_admin', request.contest) messages = visible_messages(request) if is_admin: messages = messages.filter(message__isnull=True, top_reference__isnull=True, kind='QUESTION') else: messages = new_messages(request, messages) count = messages.count() if count: text = ungettext('%(count)d NEW MESSAGE', '%(count)d NEW MESSAGES', count) % {'count': count} if count == 1: message = messages.get() link = reverse('message', kwargs={ 'contest_id': request.contest.id, 'message_id': message.top_reference_id or message.id }) else: link = reverse('contest_messages', kwargs={'contest_id': request.contest.id}) return make_navbar_badge(link, text) else: return '' return {'extra_navbar_right_messages': lazy(generator, unicode)()}
def test_find_item_lazy(self): lazy_attribute = lazy(lambda x: x, str)("Test") api = ToolbarAPIMixin() api.add_link_item(lazy_attribute, None) result = api.find_first(LinkItem, name="Test") self.assertNotEqual(result, None) self.assertEqual(result.index, 0)
def wrapper(*args, **kwargs): for arg in list(args) + list(six.itervalues(kwargs)): if isinstance(arg, Promise): break else: return func(*args, **kwargs) return lazy(func, six.text_type)(*args, **kwargs)
def test_basic(self): from django.utils.functional import lazy obj = lazy(lambda: 'bar', text_type)() res = transform(obj) expected = "'bar'" if not PY2 else "u'bar'" assert res == expected
from django.conf.urls.defaults import * from h1ds_configdb.views import HomeView from django.utils.functional import lazy from django.core.urlresolvers import reverse from django.views.generic import RedirectView # TODO: when update to django 1.4, use inbuilt reverse_lazy reverse_lazy = lazy(reverse, str) urlpatterns = patterns( '', url(r'^$', RedirectView.as_view( url=reverse_lazy("h1ds-configdb-filetypes", kwargs={'filetype_str': 'all_filetypes'})), name="h1ds-configdb-homepage"), url(r'^(?P<filetype_str>[^/]+)/$', HomeView.as_view(), name="h1ds-configdb-filetypes"), url(r'^(?P<filetype_str>[^/]+)/(?P<filter_str>[^/]+)/$', HomeView.as_view(), name="h1ds-configdb-filtered"))
def test_charfield_get_choices_doesnt_evaluate_lazy_strings(self): # Regression test for #23098 # Will raise ZeroDivisionError if lazy is evaluated lazy_func = lazy(lambda x: 0 / 0, int) f = models.CharField(choices=[(lazy_func('group'), (('a', 'A'), ('b', 'B')))]) self.assertEqual(f.get_choices(True)[0], ('', '---------'))
def test_BigIntegerField(self): lazy_func = lazy(lambda: long(9999999999999999999), long) self.assertIsInstance( BigIntegerField().get_prep_value(lazy_func()), long)
from django.utils.safestring import mark_safe from django.urls import reverse from collections import OrderedDict from rdrf.forms.dynamic import fields from rdrf.forms.widgets import widgets import logging from rdrf.forms.dynamic.calculated_fields import CalculatedFieldScriptCreator, CalculatedFieldScriptCreatorError from rdrf.forms.dynamic.validation import ValidatorFactory from rdrf.models.definition.models import CommonDataElement from django.utils.functional import lazy from django.utils.translation import ugettext_lazy as _ from django.conf import settings mark_safe_lazy = lazy(mark_safe, str) logger = logging.getLogger(__name__) class FieldContext: """ Where a field can appear - on a form or in a questionnaire On the questionnaire we use a different label text """ CLINICAL_FORM = "Form" QUESTIONNAIRE = "Questionnaire" class FieldFactory(object): # registry overrides
def test_BooleanField(self): lazy_func = lazy(lambda: True, bool) self.assertIsInstance( BooleanField().get_prep_value(lazy_func()), bool)
def test_DecimalField(self): lazy_func = lazy(lambda: Decimal('1.2'), Decimal) self.assertIsInstance( DecimalField().get_prep_value(lazy_func()), Decimal)
class FormField(models.Model): form = models.ForeignKey(Form, related_name='fields', verbose_name=_('form'), on_delete=models.CASCADE) ordering = models.IntegerField(_('ordering'), default=0) title = models.CharField(_('title'), max_length=100) name = models.CharField(_('name'), max_length=100) type = models.CharField(_('type'), max_length=20, choices=lazy(get_type_choices, list)()) choices = models.CharField(_('choices'), max_length=1024, blank=True, help_text=_('Comma-separated')) help_text = models.CharField( _('help text'), max_length=1024, blank=True, help_text=_('Optional extra explanatory text beside the field')) default_value = models.CharField( _('default value'), max_length=255, blank=True, help_text=_('Optional default value of the field')) is_required = models.BooleanField(_('is required'), default=True) class Meta: ordering = ['ordering', 'id'] unique_together = (('form', 'name'), ) verbose_name = _('form field') verbose_name_plural = _('form fields') def __str__(self): return self.title def clean(self): if self.choices and not isinstance(self.get_type(), forms.ChoiceField): raise forms.ValidationError( _("You can't specify choices for %s fields") % self.type) def get_choices(self): def get_tuple(value): return (slugify(value.strip()), value.strip()) choices = [get_tuple(value) for value in self.choices.split(',')] if not self.is_required and self.type == 'select': choices = BLANK_CHOICE_DASH + choices return tuple(choices) def get_type(self, **kwargs): types = dict((r[0], r[2]) for r in FIELD_TYPES) return types[self.type](**kwargs) def add_formfield(self, fields, form): fields[slugify(self.name)] = self.formfield() def formfield(self): kwargs = dict( label=self.title, required=self.is_required, initial=self.default_value, ) if self.choices: kwargs['choices'] = self.get_choices() if self.help_text: kwargs['help_text'] = self.help_text return self.get_type(**kwargs)
def test_comparison_with_lazy(): x = Translation(localized_string='xxx') lazy_u = lazy(lambda x: x, unicode) x == lazy_u('xxx') lazy_u('xxx') == x
def get_langs(): return DEV_LANGUAGES if DEV else PROD_LANGUAGES LANGUAGE_URL_MAP = dict([(i.lower(), i) for i in get_langs()]) def lazy_langs(): from product_details import product_details return [(lang.lower(), product_details.languages[lang]['native']) for lang in get_langs() if lang in product_details.languages] LANGUAGES = lazy(lazy_langs, list)() # Not all URLs need locale. SUPPORTED_NONLOCALES = [ 'media', 'static', 'admin', 'csp', 'api', 'contribute.json', 'admin', 'autocomplete', 'humans.txt' ] # Email SERVER_EMAIL = config('SERVER_EMAIL', default='*****@*****.**') EMAIL_BACKEND = config( 'EMAIL_BACKEND', default='django.core.mail.backends.console.EmailBackend') FROM_NOREPLY = config('FROM_NOREPLY', default='Mozillians.org <*****@*****.**>') FROM_NOREPLY_VIA = config( 'FROM_NOREPLY_VIA',
def test_ImageField(self): lazy_func = lazy(lambda: 'filename.ext', six.text_type) self.assertIsInstance( ImageField().get_prep_value(lazy_func()), six.text_type)
def test_FloatField(self): lazy_func = lazy(lambda: 1.2, float) self.assertIsInstance( FloatField().get_prep_value(lazy_func()), float)
def test_EmailField(self): lazy_func = lazy(lambda: '*****@*****.**', six.text_type) self.assertIsInstance( EmailField().get_prep_value(lazy_func()), six.text_type)
if val is None: if format_type not in FORMAT_SETTINGS: return format_type val = getattr(settings, format_type) elif format_type in ISO_INPUT_FORMATS.keys(): # If a list of input formats from one of the format_modules was # retrieved, make sure the ISO_INPUT_FORMATS are in this list. val = list(val) for iso_input in ISO_INPUT_FORMATS.get(format_type, ()): if iso_input not in val: val.append(iso_input) _format_cache[cache_key] = val return val get_format_lazy = lazy(get_format, six.text_type, list, tuple) def date_format(value, format=None, use_l10n=None): """ Formats a datetime.date or datetime.datetime object using a localizable format If use_l10n is provided and is not None, that will force the value to be localized (or not), overriding the value of settings.USE_L10N. """ return dateformat.format( value, get_format(format or 'DATE_FORMAT', use_l10n=use_l10n)) def time_format(value, format=None, use_l10n=None):
def test_DateTimeField(self): lazy_func = lazy(lambda: datetime.datetime.now(), datetime.datetime) self.assertIsInstance( DateTimeField().get_prep_value(lazy_func()), datetime.datetime)
from django.utils.safestring import mark_safe from django.utils.translation import ugettext_lazy as _ from enumfields import Enum, EnumIntegerField from shuup.core.excs import (ProductNotOrderableProblem, ProductNotVisibleProblem) from shuup.core.fields import MoneyValueField, QuantityField, UnsavedForeignKey from shuup.core.signals import get_orderability_errors, get_visibility_errors from shuup.core.utils import context_cache from shuup.utils.analog import define_log_model from shuup.utils.properties import MoneyPropped, PriceProperty from ._product_media import ProductMediaKind from ._products import ProductMode, ProductVisibility, StockBehavior mark_safe_lazy = lazy(mark_safe, six.text_type) class ShopProductVisibility(Enum): NOT_VISIBLE = 0 SEARCHABLE = 1 LISTED = 2 ALWAYS_VISIBLE = 3 class Labels: NOT_VISIBLE = _("not visible") SEARCHABLE = _("searchable") LISTED = _("listed") ALWAYS_VISIBLE = _("always visible")
def widget_attrs(self, widget): lazy_reverse = lazy(reverse, str) return { 'class': 'email-autocomplete', 'data-src': lazy_reverse('users.ajax') }
from django.utils.functional import lazy from modeltranslation.settings import * def get_language(): """ Return an active language code that is guaranteed to be in settings.LANGUAGES (Django does not seem to guarantee this for us). """ lang = _get_language() if lang not in AVAILABLE_LANGUAGES and '-' in lang: lang = lang.split('-')[0] if lang in AVAILABLE_LANGUAGES: return lang return DEFAULT_LANGUAGE def get_translation_fields(field): """Returns a list of localized fieldnames for a given field.""" return [build_localized_fieldname(field, l) for l in AVAILABLE_LANGUAGES] def build_localized_fieldname(field_name, lang): return str('%s_%s' % (field_name, lang.replace('-', '_'))) def _build_localized_verbose_name(verbose_name, lang): return u'%s [%s]' % (verbose_name, LANGUAGE_VERBOSE_NAMES.get(lang, lang)) build_localized_verbose_name = lazy(_build_localized_verbose_name, unicode)
def test_BinaryField(self): lazy_func = lazy(lambda: b'', bytes) self.assertIsInstance( BinaryField().get_prep_value(lazy_func()), bytes)
for validator in password_validators: help_texts.append(validator.get_help_text()) return help_texts def _password_validators_help_text_html(password_validators=None): """ Return an HTML string with all help texts of all configured validators in an <ul>. """ help_texts = password_validators_help_texts(password_validators) help_items = [format_html('<li>{}</li>', help_text) for help_text in help_texts] return '<ul>%s</ul>' % ''.join(help_items) if help_items else '' password_validators_help_text_html = lazy(_password_validators_help_text_html, text_type) class MinimumLengthValidator(object): """ Validate whether the password is of a minimum length. """ def __init__(self, min_length=8): self.min_length = min_length def validate(self, password, user=None): if len(password) < self.min_length: raise ValidationError( ungettext( "This password is too short. It must contain at least %(min_length)d character.", "This password is too short. It must contain at least %(min_length)d characters.",
'NestedGenericStackedInlineMixin', 'NestedGenericTabularInlineMixin', 'NestedGenericInlineModelAdminMixin', 'NestedInlineAdminFormsetMixin') def get_method_function(fn): return fn.im_func if six.PY2 else fn def get_model_id(model_cls): opts = model_cls._meta return "%s-%s" % (opts.app_label, opts.model_name) lazy_reverse = lazy(reverse, str) server_data_js_url = lazy_reverse('nesting_server_data') class NestedAdminMixin(object): @property def _djn_js_deps(self): """ Returns a set of js files that, if present, ought to precede nested_admin.js in the media load order """ extra = '' if settings.DEBUG else '.min' return { 'admin/js/core.js', 'admin/js/vendor/jquery/jquery%s.js' % extra,
except NoReverseMatch: # In case the versioning scheme reversal fails, fallback to the # default implementation url = _reverse(viewname, args, kwargs, request, format, **extra) else: url = _reverse(viewname, args, kwargs, request, format, **extra) return preserve_builtin_query_params(url, request) def _reverse(viewname, args=None, kwargs=None, request=None, format=None, **extra): """ Same as `django.urls.reverse`, but optionally takes a request and returns a fully qualified URL, using the request to get the base URL. """ if format is not None: kwargs = kwargs or {} kwargs['format'] = format url = django_reverse(viewname, args=args, kwargs=kwargs, **extra) if request: return request.build_absolute_uri(url) return url reverse_lazy = lazy(reverse, six.text_type)
from oslo_utils import units from django.conf import settings from django.contrib.auth import logout from django import http from django.utils.encoding import force_text from django.utils.functional import lazy from django.utils import translation def _lazy_join(separator, strings): return separator.join([force_text(s) for s in strings]) lazy_join = lazy(_lazy_join, str) def bytes_to_gigabytes(bytes): # Converts the number of bytes to the next highest number of Gigabytes # For example 5000000 (5 Meg) would return '1' return int(math.ceil(float(bytes) / units.Gi)) def add_logout_reason(request, response, reason, status='success'): # Store the translated string in the cookie lang = translation.get_language_from_request(request) with translation.override(lang): reason = force_text(reason).encode('unicode_escape').decode('ascii') response.set_cookie('logout_reason', reason, max_age=10) response.set_cookie('logout_status', status, max_age=10)
class IntegrationScaffoldingForm(Form): name = CharField(max_length=80, label=_('Integration name'), widget=TextInput()) author_homepage = URLField(label=_('Author\'s homepage'), required=False) issue_tracker = URLField(label=_('Issue tracker URL'), required=False, help_text=_('Bug reports and feature requests')) categories = MultipleChoiceField(widget=HiddenInput(), disabled=True, required=True, label=_('Categories'), choices=lazy(get_categories, list), help_text=_('Hold down Ctrl and click to ' 'select multiple entries')) summary = CharField( max_length=256, label=_('Summary'), help_text= _('Short description of your app that will be rendered as short teaser' )) screenshot = URLField(max_length=256, label=_('Screenshot URL'), required=False, help_text=_('URL for integration screenshot')) screenshot_thumbnail = URLField(max_length=256, label=_('Screenshot ' 'thumbnail URL'), required=False, help_text=_('URL for integration ' 'screenshot in ' 'smaller dimensions. ' 'Must be used in combination ' 'with a larger screenshot.')) description = CharField(widget=Textarea, label=_('Description'), help_text=_('Full description of what your' ' integration ' 'does. Can contain Markdown.')) def _create_discourse_category(self, app_id: str) -> None: url = '%s/categories?api_key=%s&api_username=%s' % ( settings.DISCOURSE_URL.rstrip('/'), settings.DISCOURSE_TOKEN, settings.DISCOURSE_USER) data = { 'name': app_id.replace('_', '-'), 'color': '3c3945', 'text_color': 'ffffff' } if settings.DISCOURSE_PARENT_CATEGORY_ID: data['parent_category_id'] = settings.DISCOURSE_PARENT_CATEGORY_ID # ignore requests errors because there can be many issues and we do not # want to abort app registration just because the forum is down or # leak sensitive data like tokens or users try: requests.post(url, data=data) except requests.HTTPError: pass def save(self, user, app_id, action): if app_id is None: app_id = slugify(self.cleaned_data['name']).replace('-', '_')[:80] try: app = App.objects.get(id=app_id) if app.can_update(user) or user.is_superuser: if action == "reject" and user.is_superuser: '''Not optimal but works''' Screenshot.objects.filter(app=app).delete() app.delete() elif action == "approve" and user.is_superuser: app.approved = True if settings.DISCOURSE_TOKEN: self._create_discourse_category(app_id) app.save() return app_id else: '''Not optimal but works''' Screenshot.objects.filter(app=app).delete() if self.data['screenshot']: screenshot = Screenshot.objects.create( url=self.cleaned_data['screenshot'], small_thumbnail=self. cleaned_data['screenshot_thumbnail'], ordering=1, app=app) screenshot.save() app.description = self.cleaned_data['description'] app.name = self.cleaned_data['name'] app.summary = self.cleaned_data['summary'] app.website = self.cleaned_data['author_homepage'] app.issue_tracker = self.cleaned_data['issue_tracker'] app.save() return app_id except App.DoesNotExist: app = App.objects.create(id=app_id, owner=user, certificate=uuid.uuid1().urn) app.set_current_language('en') app.categories.set(self.cleaned_data['categories']) app.description = self.cleaned_data['description'] app.name = self.cleaned_data['name'] app.summary = self.cleaned_data['summary'] app.website = self.cleaned_data['author_homepage'] app.issue_tracker = self.cleaned_data['issue_tracker'] app.save() p = App.objects.get(id=app_id) p.is_integration = True if user.is_superuser: p.approved = True if settings.DISCOURSE_TOKEN: self._create_discourse_category(app_id) else: send_mail( "New integration submitted", "Please review the " "integration to make " "sure it fits the " "guidelines.", settings.NEXTCLOUD_FROM_EMAIL, settings.NEXTCLOUD_INTEGRATIONS_APPROVAL_EMAILS) p.save() if self.data['screenshot']: screenshot = Screenshot.objects.create( url=self.cleaned_data['screenshot'], small_thumbnail=self.cleaned_data['screenshot_thumbnail'], ordering=1, app=p) screenshot.save() if not p.is_integration or p.approved or user.is_superuser: return app_id
# In order to be able to use ALLOWED_HOSTS to validate URLs, we need to # have a version of the host that contains the port. This only applies # to local development (usually the host is localhost:8000). if ":" in host: host_no_port = host.rsplit(":", 1)[0] result = [host, host_no_port] # add values from environment variable. Needed in case of URL/domain redirections env_vars_str = os.getenv("ALLOWED_HOSTS", "127.0.0.1:8000") env_vars = [x.strip() for x in env_vars_str.split(",")] result.extend(env_vars) return result ALLOWED_HOSTS = lazy(_allowed_hosts, list)() # Auth # The first hasher in this list will be used for new passwords. # Any other hasher in the list can be used for existing passwords. PASSWORD_HASHERS = ( "django.contrib.auth.hashers.PBKDF2PasswordHasher", "django.contrib.auth.hashers.PBKDF2SHA1PasswordHasher", "django.contrib.auth.hashers.BCryptSHA256PasswordHasher", "django.contrib.auth.hashers.BCryptPasswordHasher", "django.contrib.auth.hashers.SHA1PasswordHasher", "django.contrib.auth.hashers.MD5PasswordHasher", "django.contrib.auth.hashers.UnsaltedMD5PasswordHasher", ) # Logging
Remove characters that aren't alphanumerics, underscores, or hyphens. Convert to lowercase. Also strip leading and trailing whitespace. """ value = str(value) if allow_unicode: value = unicodedata.normalize('NFKC', value) else: value = unicodedata.normalize('NFKD', value).encode('ascii', 'ignore').decode('ascii') value = re.sub(r'[^\w\s-]', '', value).strip().lower() return re.sub(r'[-\s]+', '-', value) def camel_case_to_spaces(value): """ Split CamelCase and convert to lowercase. Strip surrounding whitespace. """ return re_camel_case.sub(r' \1', value).strip().lower() def _format_lazy(format_string, *args, **kwargs): """ Apply str.format() on 'format_string' where format_string, args, and/or kwargs might be lazy. """ return format_string.format(*args, **kwargs) format_lazy = lazy(_format_lazy, str)
def test_AutoField(self): lazy_func = lazy(lambda: 1, int) self.assertIsInstance( AutoField(primary_key=True).get_prep_value(lazy_func()), int)
def ngettext(singular, plural, number): return _trans.ngettext(singular, plural, number) def ugettext(message): return _trans.ugettext(message) def ungettext(singular, plural, number): return _trans.ungettext(singular, plural, number) def pgettext(context, message): return _trans.pgettext(context, message) def npgettext(context, singular, plural, number): return _trans.npgettext(context, singular, plural, number) ngettext_lazy = lazy(ngettext, str) gettext_lazy = lazy(gettext, str) ungettext_lazy = lazy(ungettext, unicode) ugettext_lazy = lazy(ugettext, unicode) pgettext_lazy = lazy(pgettext, unicode) npgettext_lazy = lazy(npgettext, unicode) def activate(language): return _trans.activate(language) def deactivate(): return _trans.deactivate() def get_language(): return _trans.get_language()
def __init__(self, *args, **kwargs): """We need to override this to make the choices lazy and prevent import madness""" super(PermissionsMixin, self).__init__(*args, **kwargs) self._meta.get_field('user_permissions')._choices = lazy(get_permission_choices, list)()
def test_IntegerField(self): lazy_func = lazy(lambda: 1, int) self.assertIsInstance( IntegerField().get_prep_value(lazy_func()), int)
import logging logger = logging.getLogger(__name__) class TranslationDoesNotExist(AttributeError): """ A tagging interface to detect missing translations. The exception inherits from :class:`AttributeError` to reflect what is actually happening. It also causes the templates to handle the missing attributes silently, which is very useful in the admin for example. """ pass _lazy_verbose_name = lazy( lambda x: ugettext("{0} Translation").format(x._meta.verbose_name), unicode) def create_translations_model(shared_model, related_name, meta, **fields): """ Dynamically create the translations model. Create the translations model for the shared model 'model'. :param related_name: The related name for the reverse FK from the translations model. :param meta: A (optional) dictionary of attributes for the translations model's inner Meta class. :param fields: A dictionary of fields to put on the translations model. Two fields are enforced on the translations model: language_code: A 15 char, db indexed field.