def get_review_request_fieldsets(include_main=False, include_change_entries_only=False): """Returns a list of all registered fieldset classes. As an internal optimization, the "main" fieldset can be filtered out, to help with rendering the side of the review request page. """ _populate_defaults() if include_main and include_change_entries_only: return six.itervalues(_fieldsets) else: excluded_ids = [] if not include_main: excluded_ids.append('main') if not include_change_entries_only: excluded_ids.append('_change_entries_only') return [ fieldset for fieldset in six.itervalues(_fieldsets) if fieldset.fieldset_id not in excluded_ids ]
def reset(self): # Delete temporary files before breaking reference to them. wizard_files = self.data[self.step_files_key] for step_files in six.itervalues(wizard_files): for step_file in six.itervalues(step_files): self.file_storage.delete(step_file['tmp_name']) self.init_data()
def test_mergedict_merges_multivaluedict(self): """ MergeDict can merge MultiValueDicts """ multi1 = MultiValueDict({'key1': ['value1'], 'key2': ['value2', 'value3']}) multi2 = MultiValueDict({'key2': ['value4'], 'key4': ['value5', 'value6']}) mm = MergeDict(multi1, multi2) # Although 'key2' appears in both dictionaries, # only the first value is used. self.assertEqual(mm.getlist('key2'), ['value2', 'value3']) self.assertEqual(mm.getlist('key4'), ['value5', 'value6']) self.assertEqual(mm.getlist('undefined'), []) self.assertEqual(sorted(six.iterkeys(mm)), ['key1', 'key2', 'key4']) self.assertEqual(len(list(six.itervalues(mm))), 3) self.assertTrue('value1' in six.itervalues(mm)) self.assertEqual(sorted(six.iteritems(mm), key=lambda k: k[0]), [('key1', 'value1'), ('key2', 'value3'), ('key4', 'value6')]) self.assertEqual([(k,mm.getlist(k)) for k in sorted(mm)], [('key1', ['value1']), ('key2', ['value2', 'value3']), ('key4', ['value5', 'value6'])])
def __init__(self, form, inline_formsets): if form.is_bound: self.extend(list(six.itervalues(form.errors))) for inline_formset in inline_formsets: self.extend(inline_formset.non_form_errors()) for errors_in_inline_form in inline_formset.errors: self.extend(list(six.itervalues(errors_in_inline_form)))
def compute_form_list(self, form_list=None, *args, **kwargs): """Compute the forms list.""" form_list = form_list or kwargs.pop('form_list', getattr(self, 'form_list', None)) or [] computed_form_list = OrderedDict() # walk through the passed form list for i, form in enumerate(form_list): if isinstance(form, (list, tuple)): # if the element is a tuple, add the tuple to the new created # sorted dictionary. computed_form_list[six.text_type(form[0])] = form[1] else: # if not, add the form with a zero based counter as unicode computed_form_list[six.text_type(i)] = form # walk through the new created list of forms for form in six.itervalues(computed_form_list): if issubclass(form, formsets.BaseFormSet): # if the element is based on BaseFormSet (FormSet/ModelFormSet) # we need to override the form variable. form = form.form # check if any form contains a FileField, if yes, we need a # file_storage added to the wizardview (by subclassing). for field in six.itervalues(form.base_fields): if (isinstance(field, forms.FileField) and not hasattr(self, 'file_storage')): raise NoFileStorageConfigured( "You need to define 'file_storage' in your " "wizard view in order to handle file uploads.") return computed_form_list
def test_mergedict_merges_multivaluedict(self): """ MergeDict can merge MultiValueDicts """ multi1 = MultiValueDict({"key1": ["value1"], "key2": ["value2", "value3"]}) multi2 = MultiValueDict({"key2": ["value4"], "key4": ["value5", "value6"]}) mm = MergeDict(multi1, multi2) # Although 'key2' appears in both dictionaries, # only the first value is used. self.assertEqual(mm.getlist("key2"), ["value2", "value3"]) self.assertEqual(mm.getlist("key4"), ["value5", "value6"]) self.assertEqual(mm.getlist("undefined"), []) self.assertEqual(sorted(six.iterkeys(mm)), ["key1", "key2", "key4"]) self.assertEqual(len(list(six.itervalues(mm))), 3) self.assertIn("value1", six.itervalues(mm)) self.assertEqual( sorted(six.iteritems(mm), key=lambda k: k[0]), [("key1", "value1"), ("key2", "value3"), ("key4", "value6")] ) self.assertEqual( [(k, mm.getlist(k)) for k in sorted(mm)], [("key1", ["value1"]), ("key2", ["value2", "value3"]), ("key4", ["value5", "value6"])], )
def get_initkwargs(cls, form_list, initial_dict=None, instance_dict=None, condition_dict=None, *args, **kwargs): """ Creates a dict with all needed parameters for the form wizard instances. * `form_list` - is a list of forms. The list entries can be single form classes or tuples of (`step_name`, `form_class`). If you pass a list of forms, the wizardview will convert the class list to (`zero_based_counter`, `form_class`). This is needed to access the form for a specific step. * `initial_dict` - contains a dictionary of initial data dictionaries. The key should be equal to the `step_name` in the `form_list` (or the str of the zero based counter - if no step_names added in the `form_list`) * `instance_dict` - contains a dictionary whose values are model instances if the step is based on a ``ModelForm`` and querysets if the step is based on a ``ModelFormSet``. The key should be equal to the `step_name` in the `form_list`. Same rules as for `initial_dict` apply. * `condition_dict` - contains a dictionary of boolean values or callables. If the value of for a specific `step_name` is callable it will be called with the wizardview instance as the only argument. If the return value is true, the step's form will be used. """ kwargs.update({ 'initial_dict': initial_dict or {}, 'instance_dict': instance_dict or {}, 'condition_dict': condition_dict or {}, }) init_form_list = SortedDict() assert len(form_list) > 0, 'at least one form is needed' # walk through the passed form list for i, form in enumerate(form_list): if isinstance(form, (list, tuple)): # if the element is a tuple, add the tuple to the new created # sorted dictionary. init_form_list[six.text_type(form[0])] = form[1] else: # if not, add the form with a zero based counter as unicode init_form_list[six.text_type(i)] = form # walk through the new created list of forms for form in six.itervalues(init_form_list): if issubclass(form, formsets.BaseFormSet): # if the element is based on BaseFormSet (FormSet/ModelFormSet) # we need to override the form variable. form = form.form # check if any form contains a FileField, if yes, we need a # file_storage added to the wizardview (by subclassing). for field in six.itervalues(form.base_fields): if (isinstance(field, forms.FileField) and not hasattr(cls, 'file_storage')): raise NoFileStorageConfigured # build the kwargs for the wizardview instances kwargs['form_list'] = init_form_list return kwargs
def version_matrix(request): matrix = defaultdict(partial(defaultdict, LatestList)) latest = defaultdict(list) groups = defaultdict(list) judges = {judge.id: judge.name for judge in Judge.objects.filter(online=True)} languages = Language.objects.all() for runtime in RuntimeVersion.objects.filter(judge__online=True).order_by('priority'): if runtime.version: matrix[runtime.judge_id][runtime.language_id].append(runtime) for judge, data in six.iteritems(matrix): name_tuple = judges[judge].rpartition('.') groups[name_tuple[0] or name_tuple[-1]].append((judges[judge], data)) matrix = {} for group, data in six.iteritems(groups): if len(data) == 1: judge, data = data[0] matrix[judge] = data continue ds = list(range(len(data))) size = [1] * len(data) for i, (p, x) in enumerate(data): if ds[i] != i: continue for j, (q, y) in enumerate(data): if i != j and compare_version_list(x, y): ds[j] = i size[i] += 1 size[j] = 0 rep = max(range(len(data)), key=size.__getitem__) matrix[group] = data[rep][1] for i, (j, x) in enumerate(data): if ds[i] != rep: matrix[j] = x for data in six.itervalues(matrix): for language, versions in six.iteritems(data): versions.versions = [version.parse(runtime.version) for runtime in versions] if versions.versions > latest[language]: latest[language] = versions.versions for data in six.itervalues(matrix): for language, versions in six.iteritems(data): versions.is_latest = versions.versions == latest[language] languages = sorted(languages, key=lambda lang: version.parse(lang.name)) return render(request, 'status/versions.html', { 'title': _('Version matrix'), 'judges': sorted(matrix.keys()), 'languages': languages, 'matrix': matrix, })
def reset(self): # Store unused temporary file names in order to delete them # at the end of the response cycle through a callback attached in # `update_response`. wizard_files = self.data[self.step_files_key] for step_files in six.itervalues(wizard_files): for step_file in six.itervalues(step_files): self._tmp_files.append(step_file['tmp_name']) self.init_data()
def _prepare(self, model): # 排序的属性 if self.order_with_respect_to: self.order_with_respect_to = self.get_field(self.order_with_respect_to) self.ordering = ('_order',) model.add_to_class('_order', OrderWrt()) else: self.order_with_respect_to = None if self.pk is None: if self.parents: # Promote 促进, 提升 the first parent link in lieu of adding yet another # field. field = next(six.itervalues(self.parents)) # Look for a local field with the same name as the # first parent link. If a local field has already been # created, use it instead of promoting the parent already_created = [fld for fld in self.local_fields if fld.name == field.name] if already_created: field = already_created[0] field.primary_key = True self.setup_pk(field) else: auto = AutoField(verbose_name='ID', primary_key=True, auto_created=True) model.add_to_class('id', auto) # 如果两个属性同时关联两个外部表, 比如两个外键的时候, 需要创建一个集合. # Determine any sets of fields that are pointing to the same targets # (e.g. two ForeignKeys to the same remote model). The query # construction code needs to know this. At the end of this, # self.duplicate_targets will map each duplicate field column to the # columns it duplicates. collections = {} for column, target in six.iteritems(self.duplicate_targets): try: collections[target].add(column) except KeyError: collections[target] = set([column]) self.duplicate_targets = {} for elt in six.itervalues(collections): if len(elt) == 1: continue for column in elt: # elt_set - set([column]) self.duplicate_targets[column] = elt.difference(set([column]))
def ready(self): # Models have been imported (these are imported # reverse order, due to Django loading them. # We correctly register these calls now. dummy = params.loader params.loader = params._loader del params._loader # Apply calls in reversed order for args in reversed(dummy.calls): params.loader.register(*args[0], **args[1]) # Import .modules and .configure submodules for # each Sellmo App imports = ['modules', 'indexes', 'configure'] apps = list(six.itervalues(params.sellmo_apps)) for module_name in imports: for app in reversed(apps): app.import_module(module_name) # At this point Sellmo's loading functionality # should no longer be used. loader = params.loader del params.loader # Delayed loading is now done. We can now call all # delayed functions in correct order. loader.load() # Initialize Sellmo modules now modules.init_modules() # Import extra modules for # each Sellmo App. Like: # .views and .links. apps = list(six.itervalues(params.sellmo_apps)) for module_name in params.extra_imports: for app in reversed(apps): app.import_module(module_name) # Everything has been imported and all chains # should have been created and linked to by now. chainer = params.chainer del params.chainer # Hookup all chains chainer.hookup() # We are done post_init.send(self)
def __init__(self, form, inline_formsets): if form.is_bound: self.extend(list(six.itervalues(form.errors))) for inline_formset in inline_formsets: self.extend(inline_formset.non_form_errors()) for errors_in_inline_form in inline_formset.errors: self.extend(list(six.itervalues(errors_in_inline_form))) for form in inline_formset: if hasattr(form, "nested_formsets"): for nested_formset in form.nested_formsets: self.extend(nested_formset.formset.non_form_errors()) for errors_in_nested_form in nested_formset.formset.errors: self.extend(list(six.itervalues(errors_in_nested_form))) log.info("Errors: %s" % self.as_text())
def sitemap(request, sitemaps, section=None): """ This view generates a sitemap with additional geographic elements defined by Google. """ warnings.warn("Geo Sitemaps are deprecated. Use plain sitemaps from " "django.contrib.sitemaps instead", DeprecationWarning, stacklevel=2) maps, urls = [], [] if section is not None: if section not in sitemaps: raise Http404(_("No sitemap available for section: %r") % section) maps.append(sitemaps[section]) else: maps = list(six.itervalues(sitemaps)) page = request.GET.get("p", 1) current_site = get_current_site(request) for site in maps: try: if callable(site): urls.extend(site().get_urls(page=page, site=current_site)) else: urls.extend(site.get_urls(page=page, site=current_site)) except EmptyPage: raise Http404(_("Page %s empty") % page) except PageNotAnInteger: raise Http404(_("No page '%s'") % page) xml = loader.render_to_string('gis/sitemaps/geo_sitemap.xml', {'urlset': urls}) return HttpResponse(xml, content_type='application/xml')
def sitemap(request, sitemaps, section=None, template_name='sitemap.xml', content_type='application/xml'): req_protocol = request.scheme req_site = get_current_site(request) if section is not None: if section not in sitemaps: raise Http404("No sitemap available for section: %r" % section) maps = [sitemaps[section]] else: maps = list(six.itervalues(sitemaps)) page = request.GET.get("p", 1) urls = [] for site in maps: try: if callable(site): site = site() urls.extend(site.get_urls(page=page, site=req_site, protocol=req_protocol)) except EmptyPage: raise Http404("Page %s empty" % page) except PageNotAnInteger: raise Http404("No page '%s'" % page) response = TemplateResponse(request, template_name, {'urlset': urls}, content_type=content_type) if hasattr(site, 'latest_lastmod'): # if latest_lastmod is defined for site, set header so as # ConditionalGetMiddleware is able to send 304 NOT MODIFIED response['Last-Modified'] = http_date( timegm(site.latest_lastmod.utctimetuple())) return response
def test_multiple_keys(self): """Test QueryDict with two key/value pairs with same keys.""" q = QueryDict(str('vote=yes&vote=no')) self.assertEqual(q['vote'], 'no') self.assertRaises(AttributeError, q.__setitem__, 'something', 'bar') self.assertEqual(q.get('vote', 'default'), 'no') self.assertEqual(q.get('foo', 'default'), 'default') self.assertEqual(q.getlist('vote'), ['yes', 'no']) self.assertEqual(q.getlist('foo'), []) self.assertRaises(AttributeError, q.setlist, 'foo', ['bar', 'baz']) self.assertRaises(AttributeError, q.setlist, 'foo', ['bar', 'baz']) self.assertRaises(AttributeError, q.appendlist, 'foo', ['bar']) if not six.PY3: self.assertEqual(q.has_key('vote'), True) self.assertEqual('vote' in q, True) if not six.PY3: self.assertEqual(q.has_key('foo'), False) self.assertEqual('foo' in q, False) self.assertEqual(list(six.iteritems(q)), [('vote', 'no')]) self.assertEqual(list(six.iterlists(q)), [('vote', ['yes', 'no'])]) self.assertEqual(list(six.iterkeys(q)), ['vote']) self.assertEqual(list(six.itervalues(q)), ['no']) self.assertEqual(len(q), 1) self.assertRaises(AttributeError, q.update, {'foo': 'bar'}) self.assertRaises(AttributeError, q.pop, 'foo') self.assertRaises(AttributeError, q.popitem) self.assertRaises(AttributeError, q.clear) self.assertRaises(AttributeError, q.setdefault, 'foo', 'bar') self.assertRaises(AttributeError, q.__delitem__, 'vote')
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, *resultclasses)(*args, **kwargs)
def test_get_context_data(self): """Testing ConfigPagesView.get_context_data""" request = RequestFactory().request() request.user = User.objects.create(username='******') view = MyConfigPagesView() view.request = request view.dispatch(view.request) self.assertEqual( view.get_context_data(), { 'base_template_name': 'base.html', 'page_title': 'My Page Title', 'nav_title': 'My Nav Entry', 'pages_id': 'config_pages', 'pages': view.pages, 'css_bundle_names': ['my-css-bundle'], 'js_bundle_names': ['my-js-bundle'], 'js_model_class': 'MyModel', 'js_view_class': 'MyView', 'js_model_data': { 'my-attr': 'value', }, 'js_view_data': { 'my-option': 'value', }, 'forms': list(six.itervalues(view.forms)), 'render_sidebar': True, })
def test_multivaluedict(self): d = MultiValueDict({'name': ['Adrian', 'Simon'], 'position': ['Developer']}) self.assertEqual(d['name'], 'Simon') self.assertEqual(d.get('name'), 'Simon') self.assertEqual(d.getlist('name'), ['Adrian', 'Simon']) self.assertEqual(sorted(list(six.iteritems(d))), [('name', 'Simon'), ('position', 'Developer')]) self.assertEqual(sorted(list(six.iterlists(d))), [('name', ['Adrian', 'Simon']), ('position', ['Developer'])]) six.assertRaisesRegex(self, MultiValueDictKeyError, 'lastname', d.__getitem__, 'lastname') self.assertEqual(d.get('lastname'), None) self.assertEqual(d.get('lastname', 'nonexistent'), 'nonexistent') self.assertEqual(d.getlist('lastname'), []) self.assertEqual(d.getlist('doesnotexist', ['Adrian', 'Simon']), ['Adrian', 'Simon']) d.setlist('lastname', ['Holovaty', 'Willison']) self.assertEqual(d.getlist('lastname'), ['Holovaty', 'Willison']) self.assertEqual(sorted(list(six.itervalues(d))), ['Developer', 'Simon', 'Willison'])
def _process_aggregate_args(self, args, kwargs): """for aggregate and annotate kwargs: allow ModelX___field syntax for kwargs, forbid it for args. Modifies kwargs if needed (these are Aggregate objects, we translate the lookup member variable)""" for a in args: assert not '___' in a.lookup, 'PolymorphicModel: annotate()/aggregate(): ___ model lookup supported for keyword arguments only' for a in six.itervalues(kwargs): a.lookup = translate_polymorphic_field_path(self.model, a.lookup)
def sitemap(request, sitemaps, section=None, template_name='sitemap.xml', content_type='application/xml', mimetype=None): if mimetype: warnings.warn("The mimetype keyword argument is deprecated, use " "content_type instead", DeprecationWarning, stacklevel=2) content_type = mimetype req_protocol = 'https' if request.is_secure() else 'http' req_site = get_current_site(request) req_site = Site(name='movie', domain='movie.' + req_site.domain) if section is not None: if section not in sitemaps: raise Http404("No sitemap available for section: %r" % section) maps = [sitemaps[section]] else: maps = list(six.itervalues(sitemaps)) page = request.GET.get("p", 1) urls = [] for site in maps: try: if callable(site): site = site() urls.extend(site.get_urls(page=page, site=req_site, protocol=req_protocol)) except EmptyPage: raise Http404("Page %s empty" % page) except PageNotAnInteger: raise Http404("No page '%s'" % page) return TemplateResponse(request, template_name, {'urlset': urls}, content_type=content_type)
def _prepare(self, model): if self.order_with_respect_to: # The app registry will not be ready at this point, so we cannot # use get_field(). query = self.order_with_respect_to try: self.order_with_respect_to = next( f for f in self._get_fields(reverse=False) if f.name == query or f.attname == query ) except StopIteration: raise FieldDoesNotExist("%s has no field named %r" % (self.object_name, query)) self.ordering = ("_order",) if not any(isinstance(field, OrderWrt) for field in model._meta.local_fields): model.add_to_class("_order", OrderWrt()) else: self.order_with_respect_to = None if self.pk is None: if self.parents: # Promote the first parent link in lieu of adding yet another # field. field = next(six.itervalues(self.parents)) # Look for a local field with the same name as the # first parent link. If a local field has already been # created, use it instead of promoting the parent already_created = [fld for fld in self.local_fields if fld.name == field.name] if already_created: field = already_created[0] field.primary_key = True self.setup_pk(field) else: auto = AutoField(verbose_name="ID", primary_key=True, auto_created=True) model.add_to_class("id", auto)
def _get_any_translated_model(self): """ Return any available translation. Returns None if there are no translations at all. """ if self._translations_cache: # There is already a language available in the case. No need for queries. # Give consistent answers if they exist. try: return self._translations_cache.get(self._current_language, None) \ or self._translations_cache.get(self.get_fallback_language(), None) \ or next(t for t in six.itervalues(self._translations_cache) if t if not None) # Skip fallback markers. except StopIteration: pass try: # Use prefetch if available, otherwise perform separate query. qs = self._get_translated_queryset() if qs._prefetch_done: translation = list(qs)[0] else: translation = qs[0] except IndexError: return None else: self._translations_cache[translation.language_code] = translation _cache_translation(translation) return translation
def main(): leden = Es.by_name('leden') lut = {} id2name = {} for m in Es.users(): if not m.name: continue lut[str(m.name)] = set() id2name[m._id] = str(m.name) max_q = Es.date_to_year(Es.now()) * 4 for q in range(1, max_q + 1): start, end = Es.quarter_to_range(q) for m in leden.get_rrelated(_from=start, until=end, how=None, deref_who=False, deref_with=False, deref_how=False): lut[id2name[m['who']]].add(q) for i, name in enumerate(sorted(six.itervalues(id2name))): if i % 20 == 0: print() print('%20s %s' % ( 'year', ' '.join([str(((q - 1) / 4) + 1).ljust(7) for q in range(1, max_q + 1, 4)]) )) print('%20s %s' % ( 'quarter', ' '.join([str(((q - 1) % 4) + 1) for q in range(1, max_q + 1)]) )) print('%-20s %s' % ( name, ' '.join(['*' if q in lut[name] else ' ' for q in range(1, max_q + 1)]) ))
def delete(self): """ deletion for versioned objects means setting the 'ends_at' field to the current datetime. Applied only for active versions, having ends_at=NULL """ now = timezone.now() # sort instance collections for model, instances in self.data.items(): self.data[model] = sorted(instances, key=attrgetter("pk")) # if possible, bring the models in an order suitable for databases that # don't support transactions or cannot defer constraint checks until the # end of a transaction. self.sort() with transaction.commit_on_success_unless_managed(using=self.using): # send pre_delete signals for model, obj in self.instances_with_model(): if not model._meta.auto_created: signals.pre_delete.send( sender=model, instance=obj, using=self.using ) # fast deletes - TODO check works correctly with versioned rels for qs in self.fast_deletes: query = sql.UpdateQuery(qs.model) pk_list = [obj.pk for obj in qs.all()] query.update_batch(pk_list, {'ends_at': now}, self.using) # update fields - TODO check works correctly with versioned rels for model, instances_for_fieldvalues in six.iteritems(self.field_updates): for (field, value), instances in six.iteritems(instances_for_fieldvalues): for o in instances: # update FK fields setattr(o, field.name, value) model.objects.bulk_create(instances) # reverse instance collections for instances in six.itervalues(self.data): instances.reverse() # delete instances by setting 'ends_at' to 'now' for model, instances in six.iteritems(self.data): query = sql.UpdateQuery(model) pk_list = [obj.pk for obj in instances] query.update_batch(pk_list, {'ends_at': now}, self.using) if not model._meta.auto_created: for obj in instances: signals.post_delete.send( sender=model, instance=obj, using=self.using ) # update collected instances for model, instances_for_fieldvalues in six.iteritems(self.field_updates): for (field, value), instances in six.iteritems(instances_for_fieldvalues): for obj in instances: setattr(obj, field.attname, value) for model, instances in six.iteritems(self.data): for instance in instances: setattr(instance, model._meta.pk.attname, None)
def __init__(self, *args, **kwargs): """Initialize the form. Args: limit_to_local_site (reviewboard.site.models.LocalSite, optional): The Local Site to limit configurations to. If ``None`` (or not provided), the configuration's Local Site (or lack thereof) can be specified by the user. *args (tuple): Positional arguments to pass to the parent form. **kwargs (dict): Keyword arguments to pass to the parent form. """ local_site = kwargs.pop('limit_to_local_site', None) self.limit_to_local_site = local_site super(IntegrationConfigForm, self).__init__(*args, **kwargs) if local_site: self.fields['local_site'].queryset = \ LocalSite.objects.filter(pk=local_site.pk) # Limit LocalSites for all condition fields. for field in six.itervalues(self.fields): if isinstance(field, ConditionsField): field.choice_kwargs['local_site'] = local_site
def _find_longest_move_range(self, r_move_ranges): # Go through every range of lines we've found and find the longest. # # The longest move range wins. If we find two ranges that are equal, # though, we'll ignore both. The idea is that if we have two identical # moves, then it's probably common enough code that we don't want to # show the move. An example might be some standard part of a comment # block, with no real changes in content. # # Note that with the current approach, finding duplicate moves doesn't # cause us to reset the winning range to the second-highest identical # match. We may want to do that down the road, but it means additional # state, and this is hopefully uncommon enough to not be a real # problem. r_move_range = None for iter_move_range in six.itervalues(r_move_ranges): if not r_move_range: r_move_range = iter_move_range else: len1 = r_move_range.end - r_move_range.start len2 = iter_move_range.end - iter_move_range.start if len1 < len2: r_move_range = iter_move_range elif len1 == len2: # If there are two that are the same, it may be common # code that we don't want to see moves for. Comments, # for example. r_move_range = None return r_move_range
def index(self, request, extra_context=None): """ Displays the main admin index page, which lists all of the installed apps that have been registered in this site. """ app_dict = {} user = request.user for model, model_admin in self._registry.items(): app_label = model._meta.app_label has_module_perms = user.has_module_perms(app_label) if has_module_perms: perms = model_admin.get_model_perms(request) # Check whether user has any perm for this module. # If so, add the module to the model_list. if True in perms.values(): info = (app_label, model._meta.model_name) model_dict = { 'name': capfirst(model._meta.verbose_name_plural), 'object_name': model._meta.object_name, 'perms': perms, } if perms.get('change', False): try: model_dict['admin_url'] = reverse('admin:%s_%s_changelist' % info, current_app=self.name) except NoReverseMatch: pass if perms.get('add', False): try: model_dict['add_url'] = reverse('admin:%s_%s_add' % info, current_app=self.name) except NoReverseMatch: pass if app_label in app_dict: app_dict[app_label]['models'].append(model_dict) else: app_dict[app_label] = { 'name': app_label.title(), 'app_label': app_label, 'app_url': reverse('admin:app_list', kwargs={'app_label': app_label}, current_app=self.name), 'has_module_perms': has_module_perms, 'models': [model_dict], } # Sort the apps alphabetically. app_list = list(six.itervalues(app_dict)) app_list.sort(key=lambda x: x['name']) # Sort the models alphabetically within each app. for app in app_list: app['models'].sort(key=lambda x: x['name']) context = dict(self.each_context(), title=self.index_title, app_list=app_list, ) context.update(extra_context or {}) return TemplateResponse(request, self.index_template or 'admin/index.html', context, current_app=self.name)
def test_multiple_keys(self): """Test QueryDict with two key/value pairs with same keys.""" q = QueryDict(str("vote=yes&vote=no")) self.assertEqual(q["vote"], "no") self.assertRaises(AttributeError, q.__setitem__, "something", "bar") self.assertEqual(q.get("vote", "default"), "no") self.assertEqual(q.get("foo", "default"), "default") self.assertEqual(q.getlist("vote"), ["yes", "no"]) self.assertEqual(q.getlist("foo"), []) self.assertRaises(AttributeError, q.setlist, "foo", ["bar", "baz"]) self.assertRaises(AttributeError, q.setlist, "foo", ["bar", "baz"]) self.assertRaises(AttributeError, q.appendlist, "foo", ["bar"]) if six.PY2: self.assertEqual(q.has_key("vote"), True) self.assertEqual("vote" in q, True) if six.PY2: self.assertEqual(q.has_key("foo"), False) self.assertEqual("foo" in q, False) self.assertEqual(list(six.iteritems(q)), [("vote", "no")]) self.assertEqual(list(six.iterlists(q)), [("vote", ["yes", "no"])]) self.assertEqual(list(six.iterkeys(q)), ["vote"]) self.assertEqual(list(six.itervalues(q)), ["no"]) self.assertEqual(len(q), 1) self.assertRaises(AttributeError, q.update, {"foo": "bar"}) self.assertRaises(AttributeError, q.pop, "foo") self.assertRaises(AttributeError, q.popitem) self.assertRaises(AttributeError, q.clear) self.assertRaises(AttributeError, q.setdefault, "foo", "bar") self.assertRaises(AttributeError, q.__delitem__, "vote")
def get_grouping(self): """ Returns a tuple representing the SQL elements in the "group by" clause. """ qn = self.quote_name_unless_alias result, params = [], [] if self.query.group_by is not None: if (len(self.query.model._meta.fields) == len(self.query.select) and self.connection.features.allows_group_by_pk): self.query.group_by = [ (self.query.model._meta.db_table, self.query.model._meta.pk.column) ] group_by = self.query.group_by or [] extra_selects = [] for extra_select, extra_params in six.itervalues(self.query.extra_select): extra_selects.append(extra_select) params.extend(extra_params) cols = (group_by + self.query.select + self.query.related_select_cols + extra_selects) seen = set() for col in cols: if col in seen: continue seen.add(col) if isinstance(col, (list, tuple)): result.append('%s.%s' % (qn(col[0]), qn(col[1]))) elif hasattr(col, 'as_sql'): result.append(col.as_sql(qn, self.connection)) else: result.append('(%s)' % str(col)) return result, params
def _prepare(self, model): if self.order_with_respect_to: self.order_with_respect_to = self.get_field(self.order_with_respect_to) self.ordering = ('_order',) model.add_to_class('_order', OrderWrt()) else: self.order_with_respect_to = None if self.pk is None: if self.parents: # Promote the first parent link in lieu of adding yet another # field. field = next(six.itervalues(self.parents)) # Look for a local field with the same name as the # first parent link. If a local field has already been # created, use it instead of promoting the parent already_created = [fld for fld in self.local_fields if fld.name == field.name] if already_created: field = already_created[0] field.primary_key = True self.setup_pk(field) else: auto = AutoField(verbose_name='ID', primary_key=True, auto_created=True) model.add_to_class('id', auto)
def test_immutable_basic_operations(self): q = QueryDict() self.assertEqual(q.getlist('foo'), []) if six.PY2: self.assertIs(q.has_key('foo'), False) self.assertNotIn('foo', q) self.assertEqual(list(six.iteritems(q)), []) self.assertEqual(list(six.iterlists(q)), []) self.assertEqual(list(six.iterkeys(q)), []) self.assertEqual(list(six.itervalues(q)), []) self.assertEqual(len(q), 0) self.assertEqual(q.urlencode(), '')
def to_internal_value(self, data): if isinstance(data, list): result = [self.inverted_choices.get(item, None) for item in data] else: result = self.inverted_choices.get(data, None) if result is None: if not data: raise ValidationError("This field cannot be blank.") raise ValidationError( "'%s' is not a valid choice. Expected one of %s." % (data, [choice for choice in six.itervalues(self.choices)])) return result
def __init__(self, *args, **kwargs): rule_names = kwargs.pop('rules', tuple()) disabled = kwargs.pop('disabled', False) # in set fields are note editable super(CodepointForm, self).__init__(*args, **kwargs) self.fields['when'].choices = rule_names self.fields['not_when'].choices = rule_names if disabled: for field in six.itervalues(self.fields): # field.disabled = True XXX need django 1.9 field.widget.attrs['disabled'] = True
def test_immutable_basic_operations(self): q = QueryDict(str('')) self.assertEqual(q.getlist('foo'), []) if not six.PY3: self.assertEqual(q.has_key('foo'), False) self.assertEqual('foo' in q, False) self.assertEqual(list(six.iteritems(q)), []) self.assertEqual(list(six.iterlists(q)), []) self.assertEqual(list(six.iterkeys(q)), []) self.assertEqual(list(six.itervalues(q)), []) self.assertEqual(len(q), 0) self.assertEqual(q.urlencode(), '')
def delete(self): # sort instance collections for model, instances in self.data.items(): self.data[model] = sorted(instances, key=attrgetter("pk")) # if possible, bring the models in an order suitable for databases that # don't support transactions or cannot defer constraint checks until the # end of a transaction. self.sort() with transaction.atomic(using=self.using, savepoint=False): # send pre_delete signals for model, obj in self.instances_with_model(): if not model._meta.auto_created: signals.pre_delete.send( sender=model, instance=obj, using=self.using ) # fast deletes for qs in self.fast_deletes: qs._raw_delete(using=self.using) # update fields for model, instances_for_fieldvalues in six.iteritems(self.field_updates): query = sql.UpdateQuery(model) for (field, value), instances in six.iteritems(instances_for_fieldvalues): query.update_batch([obj.pk for obj in instances], {field.name: value}, self.using) # reverse instance collections for instances in six.itervalues(self.data): instances.reverse() # delete instances for model, instances in six.iteritems(self.data): query = sql.DeleteQuery(model) pk_list = [obj.pk for obj in instances] query.delete_batch(pk_list, self.using) if not model._meta.auto_created: for obj in instances: signals.post_delete.send( sender=model, instance=obj, using=self.using ) # update collected instances for model, instances_for_fieldvalues in six.iteritems(self.field_updates): for (field, value), instances in six.iteritems(instances_for_fieldvalues): for obj in instances: setattr(obj, field.attname, value) for model, instances in six.iteritems(self.data): for instance in instances: setattr(instance, model._meta.pk.attname, None)
def get_all_conditions(self): """ Returns a generator which yields groups of lists of conditions. >>> for set_id, label, field in gargoyle.get_all_conditions(): >>> print("%(label)s: %(field)s" % (label, field.label)) """ for condition_set in sorted(self.get_condition_sets(), key=lambda x: x.get_group_label()): group = six.text_type(condition_set.get_group_label()) for field in six.itervalues(condition_set.fields): yield condition_set.get_id(), group, field
def get_context_data(self, **kwargs): context = {'base_url': self.get_base_url()} organization = self.kwargs.get('organization', None) if organization: for accessible in self.get_accessibles(self.request): if accessible['slug'] == organization: context.update({'organization': accessible}) break from_root, trail = self.breadcrumbs root = None if trail: root = self._build_tree(trail[-1][0], from_root, cut=TransparentCut()) # Flatten icons and practices (i.e. Energy Efficiency) to produce # the list of charts. for element in six.itervalues(root[1]): for chart in self.score_charts: # We use `score_charts`, not `get_printable_charts` because # not all top level icons might show up in the benchmark # graphs, yet we need to display the scores under the icons. if element[0]['slug'] == chart['slug']: if 'normalized_score' in chart: element[0][ 'normalized_score'] = "%s%%" % chart.get( 'normalized_score') else: element[0]['normalized_score'] = "N/A" element[0]['score_weight'] = chart.get( 'score_weight', "N/A") break charts = self.get_printable_charts() for chart in charts: if chart['slug'] == 'totals': context.update({ 'total_chart': chart, 'nb_respondents': chart.get('nb_respondents', "N/A") }) break context.update({ 'charts': [chart for chart in charts if chart['slug'] != 'totals'], 'breadcrumbs': trail, 'root': root, 'at_time': datetime_or_now() }) return context
def get_root_entities(cls, containers): """Returns a list of entities that aren't contained within others :type containers: nav.ipdevpoll.storage.ContainerRepository """ if cls in containers: entities = itervalues(containers[cls]) return [ e for e in entities if e.contained_in is None or e.contained_in == -1 ] else: return []
def get_chassis_entities(cls, containers): """Returns a list of chassis entities in containers :type containers: nav.ipdevpoll.storage.ContainerRepository """ if cls in containers: entities = itervalues(containers[cls]) return [ e for e in entities if e.physical_class == manage.NetboxEntity.CLASS_CHASSIS ] else: return []
def _get_smoke_alarms_params(self, smoke_alarms): sensors = [] for smoke_alarm in itervalues(smoke_alarms): smoke_alarm_avail = smoke_alarm.get('smokeAlarmAvail', None) if smoke_alarm_avail: smoke_alarm_oid = smoke_alarm.get(0, None) serial = smoke_alarm.get('smokeAlarmSerial', None) name = smoke_alarm.get('smokeAlarmName', None) sensors.append(self._make_result_dict( smoke_alarm_oid, self._get_oid_for_sensor('smokeAlarmStatus'), serial, 'smokeAlarmStatus', name=name)) return sensors
def _get_analog_sensors_params(self, analog_sensors): sensors = [] for analog_sensor in itervalues(analog_sensors): analog_avail = analog_sensor.get('analogSensorAvail', None) if analog_avail: analog_sensor_oid = analog_sensor.get(0, None) serial = analog_sensor.get('analogSensorSerial', None) name = analog_sensor.get('analogSensorName', None) sensors.append(self._make_result_dict( analog_sensor_oid, self._get_oid_for_sensor('analogSensorAnalog'), serial, 'analogSensorAnalog', name=name)) return sensors
def _get_digital_sensors_params(self, digital_sensors): sensors = [] for digital_sensor in itervalues(digital_sensors): digital_avail = digital_sensor.get('digitalSensorAvail', None) if digital_avail: digital_sensor_oid = digital_sensor.get(0, None) serial = digital_sensor.get('digitalSensorSerial', None) name = digital_sensor.get('digitalSensorName', None) sensors.append(self._make_result_dict( digital_sensor_oid, self._get_oid_for_sensor('digitalSensorDigital'), serial, 'digitalSensorDigital', name=name)) return sensors
def _get_cpm_params(self, cpm_sensors): sensors = [] for cpm_sensor in itervalues(cpm_sensors): cpm_sensor_avail = cpm_sensor.get('cpmSensorAvail', None) if cpm_sensor_avail: cpm_sensor_oid = cpm_sensor.get(0, None) serial = cpm_sensor.get('cpmSensorSerial', None) name = cpm_sensor.get('cpmSensorName', None) sensors.append(self._make_result_dict( cpm_sensor_oid, self._get_oid_for_sensor('cpmSensorStatus'), serial, 'cpmSensorStatus', name=name)) return sensors
def _get_water_sensors_params(self, water_sensors): sensors = [] for water_sensor in itervalues(water_sensors): water_sensor_avail = water_sensor.get('waterSensorAvail', None) if water_sensor_avail: water_sensor_oid = water_sensor.get(0, None) serial = water_sensor.get('waterSensorSerial', None) name = water_sensor.get('waterSensorName', None) sensors.append(self._make_result_dict( water_sensor_oid, self._get_oid_for_sensor('waterSensorDampness'), serial, 'waterSensorSerial', name=name)) return sensors
def encode_response(self, results): """Pack the raw execute response.""" outputs = [] for data, prm, req in itervalues(results): if prm.identifier in self.resp_form: outputs.append(_encode_raw_output(data, prm, req)) if len(outputs) == 1: self.content_type = outputs[0].content_type else: self.content_type = "multipart/related" return outputs
def to_representation(self, instance): ret = super(HighlighterMixin, self).to_representation(instance) terms = " ".join(six.itervalues(self.context["request"].GET)) if terms: highlighter = self.get_highlighter()(terms, **{ "html_tag": self.highlighter_html_tag, "css_class": self.highlighter_css_class, "max_length": self.highlighter_max_length }) document_field = self.get_document_field(instance) if highlighter and document_field: ret["highlighted"] = highlighter.highlight(getattr(instance, self.highlighter_field or document_field)) return ret
def _validate_max_depth(self, root_instructions): max_depth = self.get_max_expand_depth() for nested_field_names in six.itervalues(root_instructions): for nested_field_name in nested_field_names: depth = len(nested_field_name.split(EXPAND_DELIMITER)) if depth > max_depth: raise ValueError( 'Expansion of "{0}" exceeds max depth of {1}'.format( nested_field_name, max_depth ) )
def _process_aggregate_args(self, args, kwargs): """for aggregate and annotate kwargs: allow ModelX___field syntax for kwargs, forbid it for args. Modifies kwargs if needed (these are Aggregate objects, we translate the lookup member variable)""" ___lookup_assert_msg = 'PolymorphicModel: annotate()/aggregate(): ___ model lookup supported for keyword arguments only' if django.VERSION < (1, 8): def patch_lookup(a): a.lookup = translate_polymorphic_field_path(self.model, a.lookup) def test___lookup(a): assert '___' not in a.lookup, ___lookup_assert_msg else: def patch_lookup(a): # With Django > 1.8, the field on which the aggregate operates is # stored inside a complex query expression. if isinstance(a, Q): translate_polymorphic_Q_object(self.model, a) elif hasattr(a, 'get_source_expressions'): for source_expression in a.get_source_expressions(): if source_expression is not None: patch_lookup(source_expression) else: a.name = translate_polymorphic_field_path(self.model, a.name) def test___lookup(a): """ *args might be complex expressions too in django 1.8 so the testing for a '___' is rather complex on this one """ if isinstance(a, Q): def tree_node_test___lookup(my_model, node): " process all children of this Q node " for i in range(len(node.children)): child = node.children[i] if type(child) == tuple: # this Q object child is a tuple => a kwarg like Q( instance_of=ModelB ) assert '___' not in child[0], ___lookup_assert_msg else: # this Q object child is another Q object, recursively process this as well tree_node_test___lookup(my_model, child) tree_node_test___lookup(self.model, a) elif hasattr(a, 'get_source_expressions'): for source_expression in a.get_source_expressions(): test___lookup(source_expression) else: assert '___' not in a.name, ___lookup_assert_msg for a in args: test___lookup(a) for a in six.itervalues(kwargs): patch_lookup(a)
def _get_dsts_params(self, dsts_sensors): sensors = [] for dsts_sensor in itervalues(dsts_sensors): dsts_avail = dsts_sensor.get('dstsAvail', None) if dsts_avail: dsts_oid = dsts_sensor.get(0, None) serial = dsts_sensor.get('dstsSerial', None) name = dsts_sensor.get('dstsName', None) sensors.append(self._make_result_dict( dsts_oid, self._get_oid_for_sensor('dstsVoltsA'), serial, 'dstsVoltsA', u_o_m=Sensor.UNIT_VOLTS_DC, name=name)) sensors.append(self._make_result_dict( dsts_oid, self._get_oid_for_sensor('dstsAmpsA'), serial, 'dstsAmpsA', u_o_m=Sensor.UNIT_AMPERES, name=name)) sensors.append(self._make_result_dict( dsts_oid, self._get_oid_for_sensor('dstsVoltsB'), serial, 'dstsVoltsB', u_o_m=Sensor.UNIT_VOLTS_DC, name=name)) sensors.append(self._make_result_dict( dsts_oid, self._get_oid_for_sensor('dstsAmpsB'), serial, 'dstsAmpsB', u_o_m=Sensor.UNIT_AMPERES, name=name)) sensors.append(self._make_result_dict( dsts_oid, self._get_oid_for_sensor('dstsSourceAActive'), serial, 'dstsSourceAActive', name=name)) sensors.append(self._make_result_dict( dsts_oid, self._get_oid_for_sensor('dstsSourceBActive'), serial, 'dstsSourceBActive', name=name)) sensors.append(self._make_result_dict( dsts_oid, self._get_oid_for_sensor('dstsPowerStatusA'), serial, 'dstsPowerStatusA', name=name)) sensors.append(self._make_result_dict( dsts_oid, self._get_oid_for_sensor('dstsPowerStatusB'), serial, 'dstsPowerStatusB', name=name)) sensors.append(self._make_result_dict( dsts_oid, self._get_oid_for_sensor('dstsSourceATempC'), serial, 'dstsSourceATempC', u_o_m=Sensor.UNIT_CELCIUS, name=name)) sensors.append(self._make_result_dict( dsts_oid, self._get_oid_for_sensor('dstsSourceBTempC'), serial, 'dstsSourceBTempC', u_o_m=Sensor.UNIT_CELCIUS, name=name)) return sensors
def get_models(self, app_mod=None, include_auto_created=False, include_deferred=False, only_installed=True, include_swapped=False): """ Given a module containing models, returns a list of the models. Otherwise returns a list of all installed models. By default, auto-created models (i.e., m2m models without an explicit intermediate table) are not included. However, if you specify include_auto_created=True, they will be. By default, models created to satisfy deferred attribute queries are *not* included in the list of models. However, if you specify include_deferred, they will be. By default, models that aren't part of installed apps will *not* be included in the list of models. However, if you specify only_installed=False, they will be. By default, models that have been swapped out will *not* be included in the list of models. However, if you specify include_swapped, they will be. """ cache_key = (app_mod, include_auto_created, include_deferred, only_installed, include_swapped) try: return self._get_models_cache[cache_key] except KeyError: pass self._populate() if app_mod: if app_mod in self.app_store: app_list = [self.app_models.get(self._label_for(app_mod), SortedDict())] else: app_list = [] else: if only_installed: app_list = [self.app_models.get(app_label, SortedDict()) for app_label in six.iterkeys(self.app_labels)] else: app_list = six.itervalues(self.app_models) model_list = [] for app in app_list: model_list.extend( model for model in app.values() if ((not model._deferred or include_deferred) and (not model._meta.auto_created or include_auto_created) and (not model._meta.swapped or include_swapped)) ) self._get_models_cache[cache_key] = model_list return model_list
def paginate_queryset(self, queryset, request, view=None): self.nb_organizations = 0 self.reporting_publicly_count = 0 self.no_assessment = 0 self.abandoned = 0 self.expired = 0 self.assessment_phase = 0 self.improvement_phase = 0 self.completed = 0 accounts = {} for sample in queryset: slug = sample.get('slug') reporting_status = sample.get( 'reporting_status', AccountSerializer.REPORTING_NOT_STARTED) if not slug in accounts: accounts[slug] = { 'reporting_status': reporting_status, 'reporting_publicly': bool(sample.get('reporting_publicly')), 'reporting_fines': bool(sample.get('reporting_fines')) } continue if reporting_status > accounts[slug]['reporting_status']: accounts[slug]['reporting_status'] == reporting_status if sample.get('reporting_publicly'): accounts[slug]['reporting_publicly'] = True if sample.get('reporting_fines'): accounts[slug]['reporting_fines'] = True self.nb_organizations = len(accounts) for account in six.itervalues(accounts): reporting_status = account.get( 'reporting_status', AccountSerializer.REPORTING_NOT_STARTED) if reporting_status == AccountSerializer.REPORTING_ABANDONED: self.abandoned += 1 elif reporting_status == AccountSerializer.REPORTING_EXPIRED: self.expired += 1 elif (reporting_status == AccountSerializer.REPORTING_ASSESSMENT_PHASE): self.assessment_phase += 1 elif reporting_status == AccountSerializer.REPORTING_PLANNING_PHASE: self.improvement_phase += 1 elif reporting_status == AccountSerializer.REPORTING_COMPLETED: self.completed += 1 else: self.no_assessment += 1 if account.get('reporting_publicly'): self.reporting_publicly_count += 1 return super(CompletionSummaryPagination, self).paginate_queryset(queryset, request, view=view)
def get_app_list(self, request, registry, label=''): #register the explicit app_labels if label: self.app_dict = {label: self.app_labels[label]} if label in self.app_labels else {} else: self.app_dict = self.app_labels user = request.user for model, model_admin in registry.items(): app_label = model._meta.app_label if label and not label == app_label: continue has_module_perms = user.has_module_perms(app_label) if has_module_perms and not app_label in self.exclude: perms = model_admin.get_model_perms(request) # Check whether user has any perm for this module. # If so, add the module to the model_list. if True in perms.values(): info = (app_label, model._meta.model_name) model_dict = { 'classname': model.__name__, 'name': capfirst(model._meta.verbose_name_plural), 'perms': perms, } if perms.get('change', False): try: model_dict['admin_url'] = reverse('admin:%s_%s_changelist' % info, current_app=self.name) except NoReverseMatch: pass if perms.get('add', False): try: model_dict['add_url'] = reverse('admin:%s_%s_add' % info, current_app=self.name) except NoReverseMatch: pass self._check_app_dict(app_label, has_module_perms) if not 'exclude' in self.app_dict[app_label] or \ model_dict['classname'] not in self.app_dict[app_label]['exclude']: self.app_dict[app_label]['models'].append(model_dict) self._app_dict_sets() if not label: # Sort the apps by the specified sorter - alphabetically by default. app_list = list(six.itervalues(self.app_dict)) app_list.sort(key=self.app_sorter) return app_list return self.app_dict[label]
def smart_values(self, *fields): fields = list(fields) value_field_names = [ typ.get_value_field_name() for typ in six.itervalues(attribute_types) ] if 'value' in fields: fields.remove('value') fields.extend(value_field_names) values = self.values(*fields) values = values._clone(klass=SmartValueValuesQuerySet) return values.order_by(*fields)
def _get_current_monitors_params(self, current_monitors): sensors = [] for current_mon in itervalues(current_monitors): current_mon_avail = current_mon.get('currentMonitorAvail', None) if current_mon_avail: current_mon_oid = current_mon.get(0, None) serial = current_mon.get('currentMonitorSerial', None) name = current_mon.get('currentMonitorName', None) sensors.append(self._make_result_dict( current_mon_oid, self._get_oid_for_sensor('currentMonitorDeciAmps'), serial, 'currentMonitorDeciAmps', u_o_m=Sensor.UNIT_AMPERES, name=name)) return sensors
def validate_unique(self, exclude=None): """ Also validate the unique_together of the translated model. """ # This is called from ModelForm._post_clean() or Model.full_clean() errors = {} try: super(TranslatableModel, self).validate_unique(exclude=exclude) except ValidationError as e: errors = e.message_dict # Django 1.5 + 1.6 compatible for local_cache in six.itervalues(self._translations_cache): for translation in six.itervalues(local_cache): if translation is MISSING: # Skip fallback markers continue try: translation.validate_unique(exclude=exclude) except ValidationError as e: errors.update(e.message_dict) if errors: raise ValidationError(errors)
def check_generic_foreign_keys(app_configs=None, **kwargs): from .fields import GenericForeignKey if app_configs is None: models = apps.get_models() else: models = chain.from_iterable(app_config.get_models() for app_config in app_configs) errors = [] fields = (obj for model in models for obj in six.itervalues(vars(model)) if isinstance(obj, GenericForeignKey)) for field in fields: errors.extend(field.check()) return errors
def _get_temp_sensors_params(self, temp_sensors): sensors = [] for temp_sensor in itervalues(temp_sensors): temp_avail = temp_sensor.get('tempSensorAvail', None) if temp_avail: temp_oid = temp_sensor.get(0, None) serial = temp_sensor.get('tempSensorSerial', None) name = temp_sensor.get('tempSensorName', None) sensors.append(self._make_result_dict( temp_oid, self._get_oid_for_sensor('tempSensorTempC'), serial, 'tempSensorTempC', u_o_m=Sensor.UNIT_CELSIUS, name=name)) return sensors
def _add_formset_recursive(self, formset): #check if it is a wrapped formset if isinstance(formset, InlineAdminFormSet): formset = formset.formset self.extend(formset.non_form_errors()) for errors_in_inline_form in formset.errors: self.extend(list(six.itervalues(errors_in_inline_form))) #support for nested formsets for form in formset: if hasattr(form, 'nested_formsets'): for fs in form.nested_formsets: self._add_formset_recursive(fs)
def _construct_form(self, i, **kwargs): """ Called when building "internal" forms. Hook ourselves into this function to set the required flag on fields """ form = super(BaseDisableableFormSet, self)._construct_form(i, **kwargs) if self.disabled: for field in six.itervalues(form.fields): # field.disabled = True XXX need django 1.9 field.widget.attrs['disabled'] = True return form
def _get_millivolt_monitors_params(self, millivolts_monitors): sensors = [] for mvolts_mon in itervalues(millivolts_monitors): mvolts_mon_avail = mvolts_mon.get('millivoltMonitorAvail', None) if mvolts_mon_avail: mvolts_mon_oid = mvolts_mon.get(0, None) serial = mvolts_mon.get('millivoltMonitorSerial', None) name = mvolts_mon.get('millivoltMonitorName', None) sensors.append(self._make_result_dict( mvolts_mon_oid, self._get_oid_for_sensor('millivoltMonitorMV'), serial, 'millivoltMonitorMV', u_o_m=Sensor.UNIT_VOLTS_DC, scale='milli', name=name)) return sensors