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 ""
