def _group_facets(self, facets): """Returns `facets` grouped appropriately. Currently this means creating a hierarchical grouping of FeatureSet values. """ values = facets['fields']['feature_sets'] group = SortedDict() for value, count, display, url in values: parts = value.split(': ') level = group for part in parts: # The part corresponds to the display name, so we # switch the two around here, and it gets switched # back in _group_facet_values. Why, you ask? Because # if we use the full value for the key # (level.setdefault), bad things happen to the # hierarchy. level = level.setdefault( part, SortedDict({ 'count': 0, 'display': '', 'url': None })) if part == parts[-1]: level['count'] = count level['url'] = url level['display'] = value new_values = self._group_facet_values([], group) facets['fields']['feature_sets'] = new_values return facets
def __init__(self, *args, **kwargs): self.code_map = SortedDict() self.prop_map = SortedDict() self.reverse_map = {} for code, prop, verbose in args: self.code_map[code] = verbose self.prop_map[code] = prop self.reverse_map[prop] = code
def obj_perms_manage_view(self, request, object_pk): """ Main object permissions view. Presents all users and groups with any object permissions for the current model *instance*. Users or groups without object permissions for related *instance* would **not** be shown. In order to add or manage user or group one should use links or forms presented within the page. """ obj = get_object_or_404(self.queryset(request), pk=object_pk) users_perms = SortedDict( get_users_with_perms(obj, attach_perms=True, with_group_users=False)) users_perms.keyOrder.sort( key=lambda user: getattr(user, get_user_model().USERNAME_FIELD)) groups_perms = SortedDict(get_groups_with_perms(obj, attach_perms=True)) groups_perms.keyOrder.sort(key=lambda group: group.name) if request.method == 'POST' and 'submit_manage_user' in request.POST: user_form = UserManage(request.POST) group_form = GroupManage() info = (self.admin_site.name, self.model._meta.app_label, get_model_name(self.model)) if user_form.is_valid(): user_id = user_form.cleaned_data['user'].pk url = reverse('%s:%s_%s_permissions_manage_user' % info, args=[obj.pk, user_id]) return redirect(url) elif request.method == 'POST' and 'submit_manage_group' in request.POST: user_form = UserManage() group_form = GroupManage(request.POST) info = (self.admin_site.name, self.model._meta.app_label, get_model_name(self.model)) if group_form.is_valid(): group_id = group_form.cleaned_data['group'].id url = reverse('%s:%s_%s_permissions_manage_group' % info, args=[obj.pk, group_id]) return redirect(url) else: user_form = UserManage() group_form = GroupManage() context = self.get_obj_perms_base_context(request, obj) context['users_perms'] = users_perms context['groups_perms'] = groups_perms context['user_form'] = user_form context['group_form'] = group_form return render_to_response( self.get_obj_perms_manage_template(), context, RequestContext(request, current_app=self.admin_site.name))
def reload_django_appcache(app_name=None): cache = apps cache.app_store = SortedDict() cache.app_models = SortedDict() cache.app_errors = {} cache.handled = set() #{} cache.loaded = False for app in cache.get_app_configs(): __import__(app.name) reload(app.module) if app.name == app_name: reload(app.module.models)
def get_language_config(content_language=None): language = get_language()[:2] if content_language: content_language = content_language[:2] else: content_language = language config = {} config['language'] = language lang_names = SortedDict() for lang, name in settings.LANGUAGES: if lang[:2] not in lang_names: lang_names[lang[:2]] = [] lang_names[lang[:2]].append(_(name)) sp_langs = [] for lang, names in lang_names.items(): if lang == content_language: default = '+' else: default = '' sp_langs.append('%s%s=%s' % (default, ' / '.join(names), lang)) config['spellchecker_languages'] = ','.join(sp_langs) if content_language in settings.LANGUAGES_BIDI: config['directionality'] = 'rtl' else: config['directionality'] = 'ltr' if tinymce_settings.USE_SPELLCHECKER: config['spellchecker_rpc_url'] = reverse('tinymce-spellcheck') return config
def get_ordering_field_columns(self): """ Returns a SortedDict of ordering field column numbers and asc/desc """ # We must cope with more than one column having the same underlying sort # field, so we base things on column numbers. ordering = self._get_default_ordering() ordering_fields = SortedDict() if ORDER_VAR not in self.params or not self.params[ORDER_VAR]: # for ordering specified on ModelAdmin or model Meta, we don't know # the right column numbers absolutely, because there might be more # than one column associated with that ordering, so we guess. for field in ordering: if field.startswith('-'): field = field[1:] order_type = 'desc' else: order_type = 'asc' for attr in self.list_display: if self.get_ordering_field(attr) == field: ordering_fields[field] = order_type break else: for p in self.params[ORDER_VAR].split('.'): none, pfx, field_name = p.rpartition('-') ordering_fields[field_name] = 'desc' if pfx == '-' else 'asc' return ordering_fields
def _generate_vqs(self): """Generates and yields the value query set for each query in the query group.""" # query_groups is a list of lists. for tk_td_tuples in self.query_groups: # tk: term key, td: term dict # All (tk, td) tuples within the list tk_td_tuples, share the same # source, categories and legend_by. So we can extract these three # from the first tuple in the list. tk, td = tk_td_tuples[0] qs = td['source'] categories = td['categories'] legend_by = td['legend_by'] #vqs = values queryset values_terms = chain(categories, legend_by) vqs = qs.values(*values_terms) # NOTE: Order of annotation is important!!! # So need an SortedDict. Can't use a regular dict. ann_terms = SortedDict((k, d['func']) for k, d in tk_td_tuples) vqs = vqs.annotate(**ann_terms) # Now order by top_n_per_cat = td['top_n_per_cat'] if top_n_per_cat > 0: order_by = ('-' + tk, ) elif top_n_per_cat < 0: order_by = (tk, ) else: order_by = () order_by_terms = chain(categories, order_by) vqs = vqs.order_by(*order_by_terms) yield tk_td_tuples, vqs
class CompanyApplications(models.Model): APPLICATION_TYPE_REMOTE_DEVELOPER = "R" APPLICATION_TYPE_FULLTIME_DEVELOPER = "F" APPLICATION_TYPES = SortedDict([ (APPLICATION_TYPE_REMOTE_DEVELOPER, _("Hire Remote developer")), (APPLICATION_TYPE_FULLTIME_DEVELOPER, _("Hire FullTime developer")), ]) job_type = models.CharField(max_length=5, choices=list(APPLICATION_TYPES.items()), help_text=_("application type"), default=APPLICATION_TYPE_REMOTE_DEVELOPER, blank=True) company = models.ForeignKey(Company) job_title = models.CharField( max_length=255, help_text="Job title", null=True, blank=True, ) job_description = models.TextField( help_text="Job description", null=True, blank=True, ) created_at = models.DateTimeField(auto_now_add=True) class Meta: app_label = 'company' ordering = ['created_at']
def listsort(value): if isinstance(value,dict): new_dict = SortedDict() key_list = value.keys() key_list=sorted(key_list) for key in key_list: new_dict[key] = value[key] return new_dict
def render(self, context): form = template.Variable(self.form_variable).resolve(context) new_form = copy.copy(form) new_form.fields = SortedDict( [(key, form.fields[key]) for key in self.fields] ) context[self.variable_name] = new_form return u''
def cleanup_email_addresses(request, addresses): """ Takes a list of EmailAddress instances and cleans it up, making sure only valid ones remain, without multiple primaries etc. Order is important: e.g. if multiple primary e-mail addresses exist, the first one encountered will be kept as primary. """ from .models import EmailAddress adapter = get_adapter() # Let's group by `email` e2a = SortedDict() # maps email to EmailAddress primary_addresses = [] verified_addresses = [] primary_verified_addresses = [] for address in addresses: # Pick up only valid ones... email = valid_email_or_none(address.email) if not email: continue # ... and non-conflicting ones... if (app_settings.UNIQUE_EMAIL and EmailAddress.objects.filter(email__iexact=email).exists()): continue a = e2a.get(email.lower()) if a: a.primary = a.primary or address.primary a.verified = a.verified or address.verified else: a = address a.verified = a.verified or adapter.is_email_verified( request, a.email) e2a[email.lower()] = a if a.primary: primary_addresses.append(a) if a.verified: primary_verified_addresses.append(a) if a.verified: verified_addresses.append(a) # Now that we got things sorted out, let's assign a primary if primary_verified_addresses: primary_address = primary_verified_addresses[0] elif verified_addresses: # Pick any verified as primary primary_address = verified_addresses[0] elif primary_addresses: # Okay, let's pick primary then, even if unverified primary_address = primary_addresses[0] elif e2a: # Pick the first primary_address = e2a.keys()[0] else: # Empty primary_address = None # There can only be one primary for a in e2a.values(): a.primary = primary_address.email.lower() == a.email.lower() return list(e2a.values()), primary_address
def ar_aya_query(context, result_content): fields = xget(context, 'bidi.fields') return build_query( context['params'], SortedDict([ (fields['sura_arabic'], quotes(xget(result_content, 'identifier.sura_arabic_name'))), (fields['aya_id'], xget(result_content, 'aya.id')), ]))
def _get_tenant_list(self): if not hasattr(self, "_tenants"): try: tenants, has_more = keystone.tenant_list(self.request) except Exception: tenants = [] msg = _('Unable to retrieve instance project information.') exceptions.handle(self.request, msg) tenant_dict = SortedDict([(t.id, t) for t in tenants]) self._tenants = tenant_dict return self._tenants
def get_for_field(self, field): """ returns valid functions for passed field :param field Field django Model Field :return list of (label, (__, param, enabler, help)) """ valid = SortedDict() operators = self.get(field.__class__) for label, (func, param, enabler, help) in list(operators.items()): if (callable(enabler) and enabler(field)) or enabler is True: valid[label] = (func, param, enabler, help) return valid
def rearrange_field_order(self): original_fields = self.fields new_fields = SortedDict() for field_name in self.ordered_field_names: field = original_fields.get(field_name) if field: new_fields[field_name] = field self.fields = new_fields
def annotate_functions(self, **kwargs): extra_select, params = SortedDict(), [] clone = self._clone() for alias, node in kwargs.items(): _sql, _params = node.as_sql(self.quote_name, self) extra_select[alias] = _sql params.extend(_params) clone.query.add_extra(extra_select, params, None, None, None, None) return clone
def __new__(cls, name, bases, attrs): attrs = SortedDict(attrs) if 'Meta' in attrs and hasattr(attrs['Meta'], 'translate'): fields = attrs['Meta'].translate delattr(attrs['Meta'], 'translate') else: new_class = super(TransMeta, cls).__new__(cls, name, bases, attrs) # we inherits possible translatable_fields from superclasses abstract_model_bases = [base for base in bases if hasattr(base, '_meta') \ and base._meta.abstract] translatable_fields = [] for base in abstract_model_bases: if hasattr(base._meta, 'translatable_fields'): translatable_fields.extend( list(base._meta.translatable_fields)) new_class._meta.translatable_fields = tuple(translatable_fields) return new_class if not isinstance(fields, tuple): raise ImproperlyConfigured( "Meta's translate attribute must be a tuple") for field in fields: if not field in attrs or \ not isinstance(attrs[field], models.fields.Field): raise ImproperlyConfigured( "There is no field %(field)s in model %(name)s, "\ "as specified in Meta's translate attribute" % \ dict(field=field, name=name)) original_attr = attrs[field] for lang in get_languages(): lang_code = lang[LANGUAGE_CODE] lang_name = lang[LANGUAGE_NAME] lang_attr = copy.copy(original_attr) lang_attr.original_fieldname = field lang_attr_name = get_real_fieldname(field, lang_code) if lang_code != mandatory_language(): # only will be required for mandatory language if not lang_attr.null and lang_attr.default is NOT_PROVIDED: lang_attr.null = True if not lang_attr.blank: lang_attr.blank = True if hasattr(lang_attr, 'verbose_name'): lang_attr.verbose_name = LazyString( lang_attr.verbose_name, _(lang_name)) attrs[lang_attr_name] = lang_attr del attrs[field] attrs[field] = property(default_value(field)) new_class = super(TransMeta, cls).__new__(cls, name, bases, attrs) if hasattr(new_class, '_meta'): new_class._meta.translatable_fields = fields return new_class
def get_actions(self): if self.actions is None: return SortedDict() actions = [self.get_action(action) for action in self.global_actions] for klass in self.admin_view.__class__.mro()[::-1]: class_actions = getattr(klass, 'actions', []) if not class_actions: continue actions.extend( [self.get_action(action) for action in class_actions]) # get_action might have returned None, so filter any of those out. actions = filter(None, actions) # Convert the actions into a SortedDict keyed by name. actions = SortedDict([(name, (ac, name, desc, icon)) for ac, name, desc, icon in actions]) return actions
def convert_to_dict(sheet): first_row = sheet.row(0) fields = list(map(lambda cell: cell.value, first_row[1:])) #skip first column converted_data = [] print(sheet.nrows) for rx in range(1, sheet.nrows): row = sheet.row(rx) if not row: continue values = list(map(lambda cell: datetime(*xldate_as_tuple(cell.value, sheet.book.datemode)) if cell.ctype==XL_CELL_DATE else cell.value, row[1:])) item_data = SortedDict(zip(fields, values)) converted_data.append(item_data) return converted_data
def get_form_list(self): if not hasattr(self, '_form_list'): init_form_list = SortedDict() assert len( self.wizard_form_list) > 0, 'at least one form is needed' for i, form in enumerate(self.wizard_form_list): init_form_list[unicode(form[0])] = form[1] self._form_list = init_form_list return self._form_list
def __init__(self, apps=None, *args, **kwargs): # List of locations with static files self.locations = get_directories_in_tethys_apps(('static', 'public'), with_app_name=True) # Maps dir paths to an appropriate storage instance self.storages = SortedDict() for prefix, root in self.locations: filesystem_storage = FileSystemStorage(location=root) filesystem_storage.prefix = prefix self.storages[root] = filesystem_storage super(TethysAppsStaticFinder, self).__init__(*args, **kwargs)
def __init__(self, name=None, model=None, template_dir=None, exclude=None): self.links = {self.default_global_link: []} self.instance_links = {self.default_instance_link: []} if exclude: self.exclude = exclude if model: self.model = model if self.model: self.opts = self.model._meta if name: self.name = name elif not self.name: self.name = self.model._meta.verbose_name_plural.lower() self.name = slugify(self.name) base_url = self.get_base_url() self.views = SortedDict() for ordering, (name, view) in enumerate( (("list", ViewSetListView), ("create", ViewSetCreateView), ("detail", ViewSetDetailView), ("update", ViewSetUpdateView), ("delete", ViewSetDeleteView))): if name not in self.exclude: if name in ( "update", "delete", ): self.instance_view(name, ordering=ordering)(view) elif name in ("list", ): self.register(name, url=r'^$', ordering=ordering, links=[])(view) elif name in ("detail", ): self.register(name, url=r'^%s$' % self.object_url, links=[])(view) else: self.register(name, ordering=ordering)(view) if template_dir: self.template_dir = template_dir elif not self.template_dir: self.template_dir = self.name ViewSet._managers.append(self)
def get_features(self): """Returns this site's features organised into nested SortedDicts by feature set.""" features = SortedDict() features['features'] = [] # Iterate over Features, which are in the desired final order, # and group them according to the FeatureSet hierarchy. This # grouping removes duplication (ie, each FeatureSet will occur # only once), which may change the specified order. The first # occurrence of a FeatureSet determines its placement in the # order. for feature in self.features.all(): fs_rank = features feature_sets = feature.get_feature_set_hierarchy() i = 1 for feature_set in feature_sets: container = SortedDict() fs_rank = fs_rank.setdefault(feature_set, container) if 'features' not in fs_rank: fs_rank['features'] = [] i += 1 fs_rank['features'].append(feature) return features
def get_response(self, __): if self.request.GET.get('_format') == 'html': self.admin_view.detail_template = 'xadmin/views/quick_detail.html' return __() form = self.admin_view.form_obj layout = form.helper.layout results = [] for p, f in layout.get_field_names(): result = self.admin_view.get_field_result(f) results.append((result.label, result.val)) return self.render_response(SortedDict(results))
def get_checking_fields(self, special_exclude=['id']): """ Returns the set of fields on which we perform checkings """ ret = SortedDict() for f in self._meta.fields: # avoid special_exclude fields if f.attname in special_exclude: continue ret[f.attname] = f # Deal with reverse relationships reverse_rels = self._meta.get_all_related_objects() # reverse_rels += self._meta.get_all_related_many_to_many_objects() for relation in reverse_rels: accessor_name = relation.get_accessor_name() to_many = relation.field.rel.multiple if not self.opts.fields or accessor_name not in self.opts.fields: continue if not to_many: raise NotImplementedError ret[accessor_name] = PrimaryKeyRelatedField() # If 'fields' is specified, use those fields, in that order. if self.opts.fields: new = SortedDict() for key in self.opts.fields: new[key] = ret[key] ret = new # Remove anything in 'exclude' if self.opts.exclude: for key in self.opts.exclude: ret.pop(key, None) return ret
def view(request, variant_id): variant = get_object_or_404(Variant, pk=variant_id) variant.info = json.loads(variant.info) new_dict = SortedDict() key_list = list(variant.info.keys()) key_list.sort() for key in key_list: new_dict[key] = variant.info[key] variant.info = new_dict print(type(variant.info)) return render(request, 'variants/view.html', {'variant': variant})
def __init__(self, meta, help_text=None): self.use_sites = meta.pop('use_sites', False) self.use_i18n = meta.pop('use_i18n', False) self.use_redirect = meta.pop('use_redirect', False) self.use_cache = meta.pop('use_cache', False) self.groups = meta.pop('groups', {}) self.seo_views = meta.pop('seo_views', []) self.verbose_name = meta.pop('verbose_name', None) self.verbose_name_plural = meta.pop('verbose_name_plural', None) self.backends = list( meta.pop('backends', ('path', 'modelinstance', 'model', 'view'))) self._set_seo_models(meta.pop('seo_models', [])) self.bulk_help_text = help_text self.original_meta = meta self.models = SortedDict() self.name = None self.elements = None self.metadata = None
def prepare_actions(self): self.action_list = SortedDict() for action in self.get_actions(): try: slug, func = self.get_action(action) except NoActionFound: continue if hasattr(func, "short_description"): title = func.short_description % { "verbose_name": force_text(self.model._meta.verbose_name), "verbose_name_plural": force_text(self.model._meta.verbose_name_plural) } else: title = slug.title().replace("_", " ") self.action_list[slug] = (title, func) return self.action_list
def __init__(self, apps=None, *args, **kwargs): # List of locations with static files self.locations = [] # Maps dir paths to an appropriate storage instance self.storages = SortedDict() for theme_name in os.listdir('{}/themes/'.format( settings.BOOKTYPE_ROOT)): theme_dir = '{}/themes/{}'.format(settings.BOOKTYPE_ROOT, theme_name) static_dir = '{}/static/'.format(theme_dir) if os.path.isdir(static_dir): theme_prefix = 'themes/{}'.format(theme_name) self.locations.append((theme_prefix, static_dir)) filesystem_storage = FileSystemStorage(location=static_dir) filesystem_storage.prefix = theme_prefix self.storages[static_dir] = filesystem_storage super(ThemeFinder, self).__init__(*args, **kwargs)
def admin_reorder(context, token): """ Called in admin/base_site.html template override and applies custom ordering of apps/models defined by settings.ADMIN_REORDER """ # sort key function - use index of item in order if exists, otherwise item sort = lambda order, item: (order.index(item), "") if item in order else ( len(order), item) if "app_list" in context: # sort the app list order = SortedDict(settings.ADMIN_REORDER) context["app_list"].sort( key=lambda app: sort(order.keys(), app["app_url"][:-1])) for i, app in enumerate(context["app_list"]): # sort the model list for each app app_name = app["app_url"][:-1] if not app_name: app_name = context["request"].path.strip("/").split("/")[-1] model_order = [m.lower() for m in order.get(app_name, [])] context["app_list"][i]["models"].sort(key=lambda model: sort( model_order, model["admin_url"].strip("/").split("/")[-1])) return ""