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
class Servers(object): def __init__(self): self.servers = SortedDict() fp = open(settings.CONFIG_FILE) index = 0 for line in fp: sid = str(index) server = Server(line.strip(), sid=sid) self.servers[sid] = server index += 1 fp.close() def refresh(self): for s in self.servers.values(): s.refresh() def stop(self, name): for s in self.servers.values(): s.stop(name) def start(self, name): for s in self.servers.values(): s.start(name) def restart(self, name): for s in self.servers.values(): s.restart(name) def start_all(self): for s in self.servers.values(): s.start_all()
class Servers(object): def __init__(self): self.servers = SortedDict() fp = open(settings.CONFIG_FILE) index = 0 for line in fp: sid = str(index) server = Server(line.strip(), sid=sid) self.servers[sid] = server index += 1 fp.close() def refresh(self): for s in self.servers.values(): s.refresh() def stop(self, name): for s in self.servers.values(): s.stop(name) def start(self, name): for s in self.servers.values(): s.start(name) def restart(self, name): for s in self.servers.values(): s.restart(name) def start_all(self): for s in self.servers.values(): s.start_all()
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 get_nav_menu(self): nav_menu = self.get_site_menu() if nav_menu: return nav_menu nav_menu = SortedDict() for model, model_admin in self.admin_site._registry.items(): app_label = model._meta.app_label model_dict = { 'title': unicode(capfirst(model._meta.verbose_name_plural)), 'url': self.get_model_url(model, "changelist"), 'perm': self.get_model_perm(model, 'change') } app_key = "app:%s" % app_label if app_key in nav_menu: nav_menu[app_key]['menus'].append(model_dict) else: nav_menu[app_key] = { 'title': unicode(app_label.title()), 'menus': [model_dict], } for menu in nav_menu.values(): menu['menus'].sort(key=lambda x: x['title']) nav_menu = nav_menu.values() nav_menu.sort(key=lambda x: x['title']) return nav_menu
class ChoicesNumEnum(AbstractChoicesEnum, AbstractEnum): def __init__(self, *items): self.container = SortedDict() super(ChoicesNumEnum, self).__init__() i = 0 for item in items: if len(item) == 3: key, val, i = item if not isinstance(i, int): raise ValueError('Last value of item must by integer') elif len(item) == 2: key, val = item i += 1 else: raise ValueError('Wrong input data format') if i in (j for j, _ in self.container.values()): raise ValueError('Index %s already exists, please renumber choices') self.container[key] = (i, val) def _get_attr_val(self, name): return self.container[name][0] def _get_choices(self): return self.container.values()
def model_factory(model, *args, **kwargs): ''' Simple object fabric for tests ''' save = kwargs.pop('save', False) num = kwargs.pop('num', 1) kwargs = SortedDict(kwargs) if kwargs and not isinstance(kwargs.values()[0], list): for key in kwargs: kwargs[key] = [kwargs[key]] def _create_model_obj(**_kwargs): ''' Create or build object ''' if save: return model.objects.create(*args, **_kwargs) return model(*args, **_kwargs) models = DebugList(fields=kwargs.keys()) if kwargs: model_kwargs = map(lambda value: dict(zip(kwargs.keys(), value)), zip(*kwargs.values())) for model_kw in model_kwargs * num: models.append(_create_model_obj(**model_kw)) elif num: for counter in range(num): models.append(_create_model_obj()) else: models.append(_create_model_obj()) if len(models) == 1: return models[0] return models
class ZipCodeFilterSpec(FilterSpec): def __init__(self, request, params, model, model_admin): super(ZipCodeFilterSpec, self).__init__(request, params, model, model_admin) self.links = SortedDict((("Any", "zip_any"), ("90***", "zip_90"), ("75***", "zip_75"))) def consumed_params(self): return self.links.values() def choices(self, cl): selected = [v for v in self.links.values() if self.params.has_key(v)] for title, key in self.links.items(): yield { "selected": (self.params.has_key(key) or (key == "zip_any" and selected == [])), "query_string": cl.get_query_string({key: 1}, selected), "display": title, } def get_query_set(self, cl, qs): if self.params.has_key("zip_90"): return qs.filter(locations__zip_code__startswith="90").distinct() if self.params.has_key("zip_75"): return qs.filter(locations__zip_code__startswith="75").distinct() return qs def title(self): return u"Zip code"
class CompanyOpenFilterSpec(FilterSpec): def __init__(self, request, params, model, model_admin): super(CompanyOpenFilterSpec, self).__init__(request, params, model, model_admin) self.links = SortedDict((("Any", "open_any"), ("Weekdays", "open_weedays"), ("Weekends", "open_weekends"))) def consumed_params(self): return self.links.values() def choices(self, cl): selected = [v for v in self.links.values() if self.params.has_key(v)] for title, key in self.links.items(): yield { "selected": (self.params.has_key(key) or (key == "open_any" and selected == [])), "query_string": cl.get_query_string({key: 1}, selected), "display": title, } def get_query_set(self, cl, qs): if self.params.has_key("open_weedays"): return qs.filter(locations__open_days__contains="12345").distinct() if self.params.has_key("open_weekends"): return qs.filter(locations__open_days__contains="67").distinct() return qs def title(self): return u"Locations open?"
def get_nav_menu(self): site_menu = list(self.get_site_menu() or []) had_urls = [] def get_url(menu, had_urls): if 'url' in menu: had_urls.append(menu['url']) if 'menus' in menu: for m in menu['menus']: get_url(m, had_urls) get_url({'menus': site_menu}, had_urls) nav_menu = SortedDict() for model, model_admin in self.admin_site._registry.items(): if getattr(model_admin, 'hidden_menu', False): continue app_label = model._meta.app_label model_dict = { 'title': unicode(capfirst(model._meta.verbose_name_plural)), 'url': self.get_model_url(model, "changelist"), 'icon': self.get_model_icon(model), 'perm': self.get_model_perm(model, 'view'), 'order': model_admin.order, } if model_dict['url'] in had_urls: continue app_key = "app:%s" % app_label if app_key in nav_menu: nav_menu[app_key]['menus'].append(model_dict) else: nav_menu[app_key] = { 'title': self.apps_label_title.get(app_label.lower(), unicode(app_label.title())), 'menus': [model_dict], } app_menu = nav_menu[app_key] if ('first_icon' not in app_menu or app_menu['first_icon'] == self.default_model_icon) and model_dict.get('icon'): app_menu['first_icon'] = model_dict['icon'] if 'first_url' not in app_menu and model_dict.get('url'): app_menu['first_url'] = model_dict['url'] for menu in nav_menu.values(): menu['menus'].sort(key=sortkeypicker(['order', 'title'])) nav_menu = nav_menu.values() nav_menu.sort(key=lambda x: x['title']) site_menu.extend(nav_menu) return site_menu
def get_nav_menu(self): site_menu = list(self.get_site_menu() or []) had_urls = [] def get_url(menu, had_urls): if 'url' in menu: had_urls.append(menu['url']) if 'menus' in menu: for m in menu['menus']: get_url(m, had_urls) get_url({'menus': site_menu}, had_urls) nav_menu = SortedDict() for model, model_admin in self.admin_site._registry.items(): if getattr(model_admin, 'hidden_menu', False): continue app_label = model._meta.app_label model_dict = { 'title': unicode(capfirst(model._meta.verbose_name_plural)), 'url': self.get_model_url(model, "changelist"), 'icon': self.get_model_icon(model), 'perm': self.get_model_perm(model, 'view'), 'order': model_admin.order, } if model_dict['url'] in had_urls: continue app_key = "app:%s" % app_label if app_key in nav_menu: nav_menu[app_key]['menus'].append(model_dict) else: nav_menu[app_key] = { 'title': self.apps_label_title.get(app_label.lower(), unicode(app_label.title())), 'menus': [model_dict], } app_menu = nav_menu[app_key] if ('first_icon' not in app_menu or app_menu['first_icon'] == self.default_model_icon) and model_dict.get('icon'): app_menu['first_icon'] = model_dict['icon'] if 'first_url' not in app_menu and model_dict.get('url'): app_menu['first_url'] = model_dict['url'] for menu in nav_menu.values(): menu['menus'].sort(key=sortkeypicker(['order', 'title'])) nav_menu = nav_menu.values() nav_menu.sort(key=lambda x: x['title']) site_menu.extend(nav_menu) return site_menu
class PhotosBag(object): def __init__(self, min_photos, max_photos, collectors=None): self._photos = SortedDict() self.min = min_photos self.max = max_photos self.collectors = collectors or [] def add_collector(self, collector): """A collector is a callable return an iterator of photos. When the PhotosBag calls the collector it passes two arguments: - the destination object - the number of photos that can be added at this point """ self.collectors.append(collector) def get_photos(self): size = len(self._photos) if size < self.min: photos = [] elif size > self.max: photos = self._photos.values()[:self.max] else: photos = self._photos.values() return photos def collect_photos(self, *args, **kwargs): def photos_fetcher(max_photos): n_photos_collected = 0 for collector in self.collectors: n_photos_remaining = max_photos - n_photos_collected for photo_info in collector(n_photos_remaining, *args, **kwargs): photo_key = photo_info['photo_url'] if photo_key in self._photos: continue yield photo_key, photo_info n_photos_collected += 1 if n_photos_collected > max_photos: return for photo_key, photo_info in photos_fetcher(self.max): self._photos[photo_key] = photo_info return self.get_photos()
class PhotosBag(object): def __init__(self, min_photos, max_photos, collectors=None): self._photos = SortedDict() self.min = min_photos self.max = max_photos self.collectors = collectors or [] def add_collector(self, collector): """A collector is a callable return an iterator of photos. When the PhotosBag calls the collector it passes two arguments: - the destination object - the number of photos that can be added at this point """ self.collectors.append(collector) def get_photos(self): size = len(self._photos) if size < self.min: photos = [] elif size > self.max: photos = self._photos.values()[:self.max] else: photos = self._photos.values() return photos def collect_photos(self, *args, **kwargs): def photos_fetcher(max_photos): n_photos_collected = 0 for collector in self.collectors: n_photos_remaining = max_photos - n_photos_collected for photo_info in collector(n_photos_remaining, *args, **kwargs): photo_key = photo_info['photo_url'] if photo_key in self._photos: continue yield photo_key, photo_info n_photos_collected += 1 if n_photos_collected > max_photos: return for photo_key, photo_info in photos_fetcher(self.max): self._photos[photo_key] = photo_info return self.get_photos()
def __new__(cls, name, bases, attrs): super_new = super(PistonViewMetaclass, cls).__new__ parents = [b for b in bases if isinstance(b, PistonViewMetaclass)] if not parents: # If this isn't a subclass of PistonViewMetaclass, don't do anything special. return super_new(cls, name, bases, attrs) base_fields = SortedDict() for parent_cls in parents: for field in getattr(parent_cls, 'base_fields', []): # if the superclass has defined a field, don't add # that field from the base class since inspect.getmro # lists classes in order from super to base if field.destination not in base_fields: base_fields[field.destination] = field for field in attrs.get('fields', []): if isinstance(field, basestring): field = Field(field) base_fields[field.destination] = field attrs['base_fields'] = base_fields.values() new_class = super_new(cls, name, bases, attrs) return new_class
def create_report_criteria_form(report, jsonform=False, **kwargs): """ Create a form for this report. Any TableCriteria objects linked to this report or it's widgets are passed to the initialization method for a ReportCriteriaForm. If the report has no associated TableCriteria, nothing special will occur, and a nominal form will be returned. Only criteria objects which have no 'parent' will be included, 'parent' objects will later provide the form values to all children criteria during processing. """ # use SortedDict to limit to unique criteria objects only extra = SortedDict() # Collect all criteria objects tied to this report for c in report.criteria.all(): if not c.parent: extra[c.id] = c # Collect all criteria objects tied to any widgets associated with report for widget in Widget.objects.filter(report=report): for table in widget.tables.all(): for tc in table.criteria.all(): if not tc.parent: extra[tc.id] = tc kwargs['extra'] = extra.values() if jsonform: return ReportCriteriaJSONForm(**kwargs) else: return ReportCriteriaForm(**kwargs)
def make_basic_chart_json( values, chart_type='pie', chart_tip='#val#', chart_nolabels=True, chart_make_value=default_make_value, chart_params=None, elements_params=None, ): # Sorts from biggest to smallest values = values.items() values.sort(lambda a,b: cmp(b[1], a[1])) values = SortedDict([(k,v) for k,v in values if v]) data = {"bg_colour": "#ffffff", "elements": [{ "type": chart_type, "tip": _(chart_tip), "no-labels": chart_nolabels, "colours": [random_color() for i in values.values()], "values": [chart_make_value(num, i) for num, i in enumerate(values.items())], "alpha": 0.7, }], } if chart_params: data.update(chart_params) if elements_params: for e in data['elements']: e.update(elements_params) return HttpResponse(simplejson.dumps(data, cls=BIEncoder), mimetype="text/javascript")
def _build_keys(self, slug, date=None, granularity="all"): """Builds redis keys used to store metrics. * ``slug`` -- a slug used for a metric, e.g. "user-signups" * ``date`` -- (optional) A ``datetime.date`` or ``datetime.datetime`` objects used to generate the time period for the metric. If omitted, the current date will be used. * ``granularity`` -- Must be one of: "all" (default), "daily", "weekly", "monthly", "yearly". Returns a list of strings. """ slug = slugify(slug) # Make sure our slugs have a consistent format if date is None: date = datetime.date.today() # we want to keep the order, here: daily, weekly, monthly, yearly patterns = SortedDict() patterns.insert(0, "daily", "m:{0}:{1}".format(slug, date.strftime("%Y-%m-%d"))) patterns.insert(1, "weekly", "m:{0}:w:{1}".format(slug, date.strftime("%U"))) patterns.insert(2, "monthly", "m:{0}:m:{1}".format(slug, date.strftime("%Y-%m"))) patterns.insert(3, "yearly", "m:{0}:y:{1}".format(slug, date.strftime("%Y"))) if granularity == "all": return patterns.values() else: return [patterns[granularity]]
def post(self, request, *args, **kwargs): fields = self.generate_fields() readonly_fields = self.generate_readonly_fields() form_class = self.generate_form_class(fields, readonly_fields) form = self.get_form(form_class) inline_form_views = SortedDict() inline_forms_is_valid = True inline_views = self.init_inline_views(form.instance) inline_form_views = self._filter_inline_form_views(inline_views) for inline_form_view in inline_form_views.values(): inline_forms_is_valid = (inline_form_view.formset.is_valid()) \ and inline_forms_is_valid is_valid = form.is_valid() is_changed = self.is_changed(form, inline_form_views=inline_form_views) if is_valid and inline_forms_is_valid and is_changed: return self.form_valid(form, inline_form_views, inline_views) else: if is_valid and not is_changed: return self.form_invalid(form, inline_form_views, inline_views, msg=_('No changes have been submitted.'), msg_level=constants.INFO) return self.form_invalid(form, inline_form_views, inline_views)
def post(self, request, *args, **kwargs): fields = self.generate_fields() readonly_fields = self.generate_readonly_fields() form_class = self.generate_form_class(fields, readonly_fields) form = self.get_form(form_class) inline_form_views = SortedDict() inline_forms_is_valid = True inline_views = self.init_inline_views(form.instance) inline_form_views = self._filter_inline_form_views(inline_views) for inline_form_view in inline_form_views.values(): inline_forms_is_valid = (inline_form_view.formset.is_valid()) \ and inline_forms_is_valid is_valid = form.is_valid() is_changed = self.is_changed(form, inline_form_views=inline_form_views) if is_valid and inline_forms_is_valid and is_changed: return self.form_valid(form, inline_form_views, inline_views) else: if is_valid and not is_changed: return self.form_invalid( form, inline_form_views, inline_views, msg=_('No changes have been submitted.'), msg_level=constants.INFO) return self.form_invalid(form, inline_form_views, inline_views)
def handle(self, *args, **options): from django.conf import settings from rent.models import Booking log.info('Starting monthly insurance billing batch') csv_file = TemporaryFile() writer = csv.writer(csv_file, delimiter='|') period = (date.today() - relativedelta(months=1)) for booking in Booking.objects.ended().filter(created_at__year=period.year, created_at__month=period.month): row = SortedDict() row['Numéro police'] = settings.POLICY_NUMBER row['Numéro partenaire'] = settings.PARTNER_NUMBER row['Numéro contrat'] = booking.contract_id row[u'Durée de garantie'] = (booking.ended_at - booking.started_at).days row[u'Numéro de commande'] = booking.uuid row['Date d\'effet des garanties'] = booking.started_at.strftime("%Y%m%d") row[u'Désignation'] = smart_str(booking.product.description) row['Prix de la location TTC'] = booking.total_amount row['Prix de cession HT'] = booking.insurance_fee row['Com. du partenaire'] = booking.insurance_commission row['Taxes assurance à 9%'] = booking.insurance_taxes row['Cotisation TTC'] = booking.insurance_amount writer.writerow(row.values()) log.info('Sending monthly insurance billing by mail') email = EmailMessage('Fichier de facturation e-loue.com', 'Ci-joint le fichier de facturion du %s/%s' % ( period.month, period.year ), '*****@*****.**', [settings.INSURANCE_EMAIL]) email.attach('facturation-eloue-%s-%s.csv' % (period.month, period.year), csv_file) email.send() log.info('Finished monthly insurance reimbursement batch')
def download_selected_searchrequests(self, request, searchrequests): response = HttpResponse(content_type='text/csv') response['Content-Disposition'] = 'attachment; filename=%s' \ % self.get_download_filename(request) writer = CsvUnicodeWriter(response, delimiter=',') meta_data = (('id', _('Search request number')), ('num_items', _('Number of items')), ('state', _('Status')), ('owner', _('Owner')), ('creation_date', _('Creation date')), ) columns = SortedDict() for k, v in meta_data: columns[k] = v writer.writerow(columns.values()) for searchrequest in searchrequests: row = columns.copy() row['id'] = searchrequest.id row['creation_date'] = format_datetime(searchrequest.date_created, 'DATETIME_FORMAT') row['state'] = searchrequest.state row['num_items'] = searchrequest.num_items row['owner'] = searchrequest.owner.email encoded_values = [six.text_type(value).encode('utf8') for value in row.values()] writer.writerow(encoded_values) return response
def _build_report_data(self): tmp_data = SortedDict() totals = ['Totals'] + [0] * len(self.DEVICE_TYPES) visit_counts = self.visit_queryset().values( 'visit_date', 'device__device_type__code', ).filter( device__device_type__code__in=self.DEVICE_TYPES ).annotate(Count('device__device_type')).order_by('visit_date') if not visit_counts: return [] for visit in visit_counts: device_type = visit['device__device_type__code'] date_obj = visit['visit_date'] if date_obj not in tmp_data: date_str = format_date(date_obj) tmp_data[date_obj] = [date_str] + ([0] * len(self.DEVICE_TYPES)) index = self.DEVICE_TYPES.index(device_type) + 1 tmp_data[date_obj][index] += visit['device__device_type__count'] totals[index] += visit['device__device_type__count'] return tmp_data.values() + [totals]
def testQuickpayPayments(self): data = SortedDict([ ('msgtype', 'authorize'), ('ordernumber', self.booking.ordernumber), ('amount', '1000'), ('currency', 'DKK'), ('time', '120101090000'), ('state', '1'), ('qpstat', '000'), ('qpstatmsg', 'qpstat message'), ('chstat', '000'), ('chstatmsg', 'chstat message'), ('merchant', self.account.merchant_id), ('merchantemail', '*****@*****.**'), ('transaction', '0123456789'), ('cardtype', 'dankort'), ('cardnumber', ''), ]) md_input = ''.join(data.values()) + self.account.secret_key data['md5check'] = md5_constructor(md_input).hexdigest() response = self.client.post( reverse('quickpay_callback'), data, HTTP_HOST=self.http_host ) self.assertTrue(Booking.objects.get(pk=self.booking.pk).confirmed)
def full_print(self): if self.last_print and (datetime.datetime.now() - self.last_print < datetime.timedelta(seconds=3)): return d = SortedDict() for name, deltas in self.messages.items(): sum = datetime.timedelta() for delta in deltas: sum += delta avg = sum / len(deltas) mx = max(deltas) mn = min(deltas) if len(name) > 50: name = name[:50] line = self.format %(name, avg, mx, mn, len(deltas)) d[avg] = line d.keyOrder.sort() d.keyOrder.reverse() line_number = 3 self.stdscr.clear() self.stdscr.addstr(1, 4, self.header_line) for line in d.values(): try: self.stdscr.addstr(line_number, 4, line) except Exception: break line_number += 1 self.stdscr.refresh() self.last_print = datetime.datetime.now()
class BindingDict(object): """ This dict-like object is used to store fields on a serializer. This ensures that whenever fields are added to the serializer we call `field.bind()` so that the `field_name` and `parent` attributes can be set correctly. """ def __init__(self, serializer): self.serializer = serializer self.fields = SortedDict() def __setitem__(self, key, field): self.fields[key] = field field.bind(field_name=key, parent=self.serializer) def __getitem__(self, key): return self.fields[key] def __delitem__(self, key): del self.fields[key] def items(self): return self.fields.items() def keys(self): return self.fields.keys() def values(self): return self.fields.values()
def get_and_child(parents, cqs): """ Retourne les valeurs d'un SortedDict avec parents (liste reduite) et enfants accessibles par l'attribut enfants, les enfants sont données en queryset par le param cqs """ ret = SortedDict() for p in parents: p.enfants = [] p.file = False ret[p.id] = p parent_ids = ret.keys() cqs = cqs.filter(parent__in=parent_ids) alarms = TicketAlarm.opened.filter(ticket__in=parent_ids) files = TicketFile.objects.filter(ticket__in=parent_ids) for e in cqs: ret[e.parent.id].enfants.append(e) for a in alarms: ret[a.ticket_id].alarm = a for f in files: ret[f.ticket.id].file = True return ret.values()
class Node(object): """ A base class representing a navigation or page node and providing some dictionary-like behavior for navigating the tree. """ def __init__(self): super(Node, self).__init__() self.children = SortedDict() def __getitem__(self, key): return self.children.__getitem__(key) def __iter__(self): return self.children.__iter__() def __setitem__(self, key, value): return self.children.__setitem__(key, value) def __unicode__(self): return self.title def keys(self): return self.children.keys() def values(self): return self.children.values() @property def is_leaf(self): return not bool(self.children)
def handle_noargs(self, **options): self.set_options(**options) found_files = SortedDict() manifest = ConfiguredStaticFilesManifest() manifest.clear() ignore_patterns = getattr(settings, 'ECSTATIC_MANIFEST_EXCLUDES', []) for finder in finders.get_finders(): for path, storage in finder.list(ignore_patterns): # Prefix the relative path if the source storage contains it if getattr(storage, 'prefix', None): prefixed_path = os.path.join(storage.prefix, path) else: prefixed_path = path if prefixed_path not in found_files: found_files[prefixed_path] = path for path in found_files.values() + settings.ECSTATIC_MANIFEST_EXTRAS: try: generate_url = self.storage.generate_url except AttributeError: raise AttributeError( '%s doesn\'t define a generate_url method.' ' Did you remember to extend StaticManifestMixin?' % self.storage) hashed_name = generate_url(path) manifest.add(path, hashed_name) manifest.flush()
def get_message_list(project_id, lang_id, src_filters={}, target_filters={}): lang_id = int(lang_id) project_language = Project.objects.get(id=project_id).lang.id new_query = SetMessage.objects.all() if not new_query.exists(): return [] new_query = new_query.filter(_normalize_filters(src_filters)) target_predicate = _normalize_filters(target_filters) if target_predicate: new_query = new_query.filter(Q(lang=project_language) | Q(target_predicate)) res = SortedDict() new_query = _update_message_query(new_query, project_id, lang_id) for data in new_query.order_by('msgid'): msg_info = res.setdefault(data.msgid, {'msg_id': data.msgid}) if data.lang_id == lang_id: msg_info.update( { 'msg_target': data.msgstr, 'target_id': data.id, 'is_translated': data.is_translated } ) if data.lang_id == project_language: msg_info.update({'msg_source': data.msgstr, 'id': data.id}) messages = [i for i in res.values() if 'msg_target' in i] return messages
def _handle_messages(self, child): """ ``<messages>`` has a somewhat nonstandard structure:: <messages> <topic type="message" href="/messages/id/123" /> <!-- first message in thread --> <read> <!-- read count (?) --> <count type="int">5</count> </read> <linear> <!-- list of messages --> <!-- note: first message is equal to topic --> <message type="message" href="/messages/id/123" /> <message type="message" href="/messages/id/124" /> <message type="message" href="/messages/id/125" /> </linear> </messages> """ messages = SortedDict() for elem in child: if elem.tag == 'topic': self.topic = xml_to_type(elem, self._api) messages[self.topic.href] = self.topic elif elem.tag == 'linear': for message in elem: m = xml_to_type(message, self._api) if m.href not in messages: messages[m.href] = m if m.parent and m.parent.href in messages: m.parent = messages[m.parent.href] elif elem.tag == 'read': self.read_count = elem.text self.messages = messages.values()
def create_report_criteria_form(*args, **kwargs): """ Factory function to create dynamic Report forms Included `report` kwargs will be assessed for any linked TableCriteria objects and passed to the initialization method for a ReportCriteriaForm. If the report has no associated TableCriteria, nothing special will occur, and a nominal form will be returned. Only objects which have no "parents" will be included, "parent" objects will later provide the form values to all children criteria during processing. """ report = kwargs.pop('report') jsonform = kwargs.pop('jsonform', False) # use SortedDict to limit to unique criteria objects only extra = SortedDict() for c in report.criteria.all(): if not c.parent: extra[c.id] = c for widget in Widget.objects.filter(report=report): for table in widget.tables.all(): for tc in table.criteria.all(): if not tc.parent: extra[tc.id] = tc kwargs['extra'] = extra.values() if jsonform: return ReportCriteriaJSONForm(*args, **kwargs) else: return ReportCriteriaForm(*args, **kwargs)
def _site_query(period, start, end, field=None, request=None): old_version = request and request.GET.get("old_version", "0") or "0" cursor = connection.cursor() # Let MySQL make this fast. Make sure we prevent SQL injection with the # assert. if period not in SERIES_GROUPS_DATE: raise AssertionError("%s period is not valid." % period) sql = ( "SELECT name, MIN(date), SUM(count) " "FROM global_stats " "WHERE date > %%s AND date <= %%s " "AND name IN (%s) " "GROUP BY %s(date), name " "ORDER BY %s(date) DESC;" % (", ".join(["%s" for key in _KEYS.keys()]), period, period) ) cursor.execute(sql, [start, end] + _KEYS.keys()) # Process the results into a format that is friendly for render_*. default = dict([(k, 0) for k in _CACHED_KEYS]) result = SortedDict() for name, date, count in cursor.fetchall(): date = date.strftime("%Y-%m-%d") if date not in result: result[date] = default.copy() result[date]["date"] = date result[date]["data"] = {} result[date]["data"][_KEYS[name]] = count return result.values(), _CACHED_KEYS
def render(self): product = self.context.get("product", None) category = self.context.get("category", None) if product: cats = product.category.all() if cats: category = cats[0] if not category: categories = SortedDict() first_level_categories = Category.objects.filter( parent__isnull=True, is_active=True).order_by('ordering', 'name') for item in first_level_categories: categories[item.pk] = SortedDict({ 'name': item.name, 'slug': item.slug, 'url': item.get_absolute_url(), 'subcategories': {}, 'current': False}) return {'menu': self.asHtml(categories), 'categories': categories.values()} else: internal_categories = self.look_for_category( category, category.id) html_categories = self.asHtml(internal_categories) return {'menu': html_categories, 'categories': internal_categories.values()}
def handle_noargs(self, **options): self.set_options(**options) found_files = SortedDict() manifest = ConfiguredStaticFilesManifest() manifest.clear() ignore_patterns = getattr(settings, 'ECSTATIC_MANIFEST_EXCLUDES', []) for finder in finders.get_finders(): for path, storage in finder.list(ignore_patterns): # Prefix the relative path if the source storage contains it if getattr(storage, 'prefix', None): prefixed_path = os.path.join(storage.prefix, path) else: prefixed_path = path if prefixed_path not in found_files: found_files[prefixed_path] = path for path in found_files.values() + settings.ECSTATIC_MANIFEST_EXTRAS: try: generate_url = self.storage.generate_url except AttributeError: raise AttributeError('%s doesn\'t define a generate_url method.' ' Did you remember to extend StaticManifestMixin?' % self.storage) hashed_name = generate_url(path) manifest.add(path, hashed_name) manifest.flush()
class PasswdListView(PdfMixin, KlassDetailMixin, LoginRequiredMixin, generic.TemplateView): """ Renders the PDF password list and saves in the klass the passwords were printed. """ template_name = 'teachers/clients/passwd_list.html' def get(self, request, *args, **kwargs): password_list = request.session.get('password_list', {}) if str(self.klass.pk) in password_list: self.klass.password_list_printed_at = timezone.now() self.klass.save() self.passwords = SortedDict(password_list[str(self.klass.pk)]) return super(PasswdListView, self).get(request, *args, **kwargs) else: raise ValueError('You are trying to access the pdf list of passwords' ' but it is not in the session.') def get_context_data(self, *args, **kwargs): context = super(PasswdListView, self).get_context_data(*args, **kwargs) context['klass'] = self.klass users = User.objects.filter(pk__in=self.passwords.keys()) context['passwords'] = zip(users, self.passwords.values()) return context
def __new__(cls, name, bases, attrs): super_new = super(PistonViewMetaclass, cls).__new__ parents = [b for b in bases if isinstance(b, PistonViewMetaclass)] if not parents: # If this isn't a subclass of PistonViewMetaclass, don't do anything special. return super_new(cls, name, bases, attrs) base_fields = SortedDict() for parent_cls in parents: for field in getattr(parent_cls, 'base_fields', []): # if the superclass has defined a field, don't add # that field from the base class since inspect.getmro # lists classes in order from super to base if field.destination not in base_fields: base_fields[field.destination] = field for field in attrs.get('fields', []): if isinstance(field, basestring): field = Field(field) base_fields[field.destination] = field attrs['base_fields'] = base_fields.values() new_class = super_new(cls, name, bases, attrs) return new_class
class Node(object): """ A base class representing a navigation or page node and providing some dictionary-like behavior for navigating the tree. """ def __init__(self): super(Node, self).__init__() self.children = SortedDict() def __getitem__(self, key): return self.children.__getitem__(key) def __iter__(self): return self.children.__iter__() def __setitem__(self, key, value): return self.children.__setitem__(key, value) def __unicode__(self): return self.title def keys(self): return self.children.keys() def values(self): return self.children.values() @property def is_leaf(self): return not bool(self.children)
def _site_query(period, start, end, field=None, request=None): cursor = connection.cursor() # Let MySQL make this fast. Make sure we prevent SQL injection with the # assert. if period not in SERIES_GROUPS_DATE: raise AssertionError('%s period is not valid.' % period) sql = ("SELECT name, MIN(date), SUM(count) " "FROM global_stats " "WHERE date > %%s AND date <= %%s " "AND name IN (%s) " "GROUP BY %s(date), name " "ORDER BY %s(date) DESC;" % (', '.join(['%s' for key in _KEYS.keys()]), period, period)) cursor.execute(sql, [start, end] + _KEYS.keys()) # Process the results into a format that is friendly for render_*. default = dict([(k, 0) for k in _CACHED_KEYS]) result = SortedDict() for name, date_, count in cursor.fetchall(): date_ = date_.strftime('%Y-%m-%d') if date_ not in result: result[date_] = default.copy() result[date_]['date'] = date_ result[date_]['data'] = {} result[date_]['data'][_KEYS[name]] = int(count) return result.values(), _CACHED_KEYS
def _site_query(period, start, end, field=None, request=None): cursor = connection.cursor() # Let MySQL make this fast. Make sure we prevent SQL injection with the # assert. if period not in SERIES_GROUPS_DATE: raise AssertionError('%s period is not valid.' % period) sql = ("SELECT name, MIN(date), SUM(count) " "FROM global_stats " "WHERE date > %%s AND date <= %%s " "AND name IN (%s) " "GROUP BY %s(date), name " "ORDER BY %s(date) DESC;" % (', '.join(['%s' for key in _KEYS.keys()]), period, period)) cursor.execute(sql, [start, end] + _KEYS.keys()) # Process the results into a format that is friendly for render_*. default = dict([(k, 0) for k in _CACHED_KEYS]) result = SortedDict() for name, date_, count in cursor.fetchall(): date_ = date_.strftime('%Y-%m-%d') if date_ not in result: result[date_] = default.copy() result[date_]['date'] = date_ result[date_]['data'] = {} result[date_]['data'][_KEYS[name]] = int(count) return result.values(), _CACHED_KEYS
def get_context_data(self, **kwargs): context = super(DedicatedBindingView, self).get_context_data(**kwargs) self.page_title=self.request.GET.get("page_title", None) context['pool_type']=self.request.GET.get("pool_type", None) context['tenant_id']=self.kwargs['tenant_id'] context['instance'] = self.get_instance() tenant = SortedDict([(t.id, t.name)for t in self.tenant_list()]) user_list = [us.id for us in api.keystone.user_list(self.request)] free_instance = list() for ins in self.get_instance(): if not ins.tenant_id: free_instance.append(ins) elif ins.tenant_id not in tenant.keys(): free_instance.append(ins) elif ins.user_id not in user_list and ins.tenant_id == self.kwargs['tenant_id']: free_instance.append(ins) elif ins.tenant_id in tenant.keys(): _values = tenant.values() admin_index = _values.index(u'admin') _keys = tenant.keys() admin_keys_id = _keys.pop(admin_index) if ins.tenant_id == admin_keys_id: free_instance.append(ins) context['free_instance']=sorted(free_instance, key=operator.attrgetter('name')) context['user']=sorted(self.get_user(tenant_id=self.kwargs['tenant_id']), key=operator.attrgetter('name')) return context
def vote(request, course_id): # retrieve course and make sure that the user is allowed to vote course = get_object_or_404(Course, id=course_id) if not course.can_user_vote(request.user): raise PermissionDenied # build forms forms = SortedDict() for questionnaire, contribution in questionnaires_and_contributions( course): form = QuestionsForm(request.POST or None, contribution=contribution, questionnaire=questionnaire) forms[(contribution, questionnaire)] = form if all(form.is_valid() for form in forms.values()): # begin vote operation with transaction.commit_on_success(): for (contribution, questionnaire), form in forms.items(): for question in questionnaire.question_set.all(): identifier = make_form_identifier(contribution, questionnaire, question) value = form.cleaned_data.get(identifier) if type(value) in [str, unicode]: value = value.strip() if value == 6: #no answer value = None # store the answer if one was given if value: question.answer_class.objects.create( contribution=contribution, question=question, answer=value) # remember that the user voted already course.voters.add(request.user) messages.add_message(request, messages.INFO, _("Your vote was recorded.")) return redirect('evap.student.views.index') else: return render_to_response("student_vote.html", dict(forms=forms.values(), course=course), context_instance=RequestContext(request))
def get_best_matches(record): ret = SortedDict() record.documents = {} # Match based on legacy id (record.stokes_db) hand_id = record.stokes_db.strip() if hand_id: hands = Hand.objects.filter(legacy_id=hand_id) for hand in hands: add_matching_hand_to_result(ret, record, hand, 'L', True) # Match based on scragg id (record.scragg, hand.scragg) hand_id = record.scragg.strip() if hand_id: hands = Hand.objects.filter(scragg=hand_id) for hand in hands: add_matching_hand_to_result(ret, record, hand, 'Scr', False) # Match based on K/G/S/P ids sources = ['ker', 'gneuss', 'sp'] for source in sources: document_id = getattr(record, source, '').strip() if document_id: source_dp = source if source == 'sp': source_dp = settings.SOURCE_SAWYER_KW document_id_p = re.sub('(?i)^\s*p\s*(\d+)', r'\1', document_id) source = 'S' if document_id_p != document_id: document_id = document_id_p source_dp = 'pelteret' source = 'P' document_ids = re.split('\s*,\s*', document_id) documents = ItemPart.objects.filter(Q(historical_items__catalogue_numbers__source=Source.get_source_from_keyword(source_dp)) & \ Q(historical_items__catalogue_numbers__number__in=document_ids)).distinct() for doc in documents: record.documents[doc.id] = doc hands = Hand.objects.filter(latin_only=False).filter(Q(images__item_part__in=documents) | Q(item_part__in=documents)).distinct().order_by('id') for hand in hands: add_matching_hand_to_result(ret, record, hand, source.upper()[0]) # find best matches based on the historical item # Existing matches for match in record.get_matched_hands(): rtype, rid = match.split(':') if rtype == 'h': add_matching_hand_to_result(ret, record, Hand.objects.get(id=rid), 'M') if rtype == 'ip': add_matching_hand_to_result(ret, record, Hand(item_part_id=rid, label="NEW HAND"), 'M') # New Hand add_matching_hand_to_result(ret, record, Hand(), 'New') record.documents = record.documents.values() ret = [h for h in ret.values()] return ret
class Meta(object): auto_created = False abstract = False db_table = None local_many_to_many = [] many_to_many = local_many_to_many unique_together = [] parents = {} proxy = None managed = False pk = Field('pk', unique=True, primary_key=True, auto_created=True, editable=False) def __init__(self, model_name, app_label, fields, verbose_name, verbose_name_plural, ordering=None): self.object_name = self.model_name = model_name self.module_name = self.model_name.lower() self.app_label = app_label self.verbose_name_raw = self.verbose_name = verbose_name self.verbose_name_plural = verbose_name_plural self.fields_dict = SortedDict( [('pk', self.pk)] + [(f, Field(f)) for f in fields] ) self.has_auto_field = True self.auto_field = self.pk self.fields = self.local_fields = self.fields_dict.values() self.ordering = ordering def get_field(self, name): if name not in self.fields_dict: raise FieldDoesNotExist('No field `%s` in model: %s' % (name, self.object_name)) return self.fields_dict[name] def get_field_by_name(self, name): return (self.get_field(name), None, True) def get_ordered_objects(self): return [] def get_all_related_objects(self, include_hidden=None): return [] def get_all_related_many_to_many_objects(self): return [] def get_delete_permission(self): return 'delete'
def handle(self, *args, **options): from django.conf import settings from rent.models import Sinister log.info('Starting daily insurance sinisters batch') csv_file = TemporaryFile() writer = csv.writer(csv_file, delimiter='|') period = (date.today() - timedelta(days=1)) for sinister in Sinister.objects.filter( ~Q(product__owner__is_professional=True), product__carproduct=None, product__realestateproduct=None, created_at__year=period.year, created_at__month=period.month, created_at__day=period.day, product__category__need_insurance=True): row = SortedDict() row['Login locataire'] = sinister.booking.borrower.username row['Adresse email'] = sinister.booking.borrower.email phones = sinister.booking.borrower.phones.all() if phones: row[u'Numéro de téléphone'] = phones[0] else: row[u'Numéro de téléphone'] = None row[u'Numéro du sinistre'] = sinister.sinister_id row['Date de survenance du sinistre'] = sinister.created_at.strftime( "%Y%m%d") row['Nature du sinistre'] = 'bris' row['Description des circonstances'] = smart_str( sinister.description) row[u'Numéro police'] = settings.POLICY_NUMBER row[u'Numéro partenaire'] = settings.PARTNER_NUMBER row[u'Numéro contrat'] = sinister.booking.contract_id row['Date d\'effet des garanties'] = sinister.booking.started_at.strftime( "%Y%m%d") row[u'Numéro de commande'] = sinister.booking.uuid row[u'Type de produit'] = smart_str( sinister.booking.product.category.name) row['Montant de la Caution'] = comma_separated( sinister.booking.deposit_amount) row['Prix de la location TTC'] = comma_separated( sinister.booking.total_amount) writer.writerow(row.values()) csv_file.seek(0) latin1csv_file = TemporaryFile() for line in csv_file: latin1csv_file.write( line.decode('utf-8').encode('latin1', 'ignore')) latin1csv_file.seek(0) log.info('Uploading daily insurance subscriptions') ftp = FTP(settings.INSURANCE_FTP_HOST) ftp.login(settings.INSURANCE_FTP_USER, settings.INSURANCE_FTP_PASSWORD) if settings.INSURANCE_FTP_CWD: ftp.cwd(settings.INSURANCE_FTP_CWD) ftp.storlines("STOR sinistre-eloue-%s-%s" % (period.month, period.day), latin1csv_file) ftp.quit() log.info('Finished daily insurance sinisters batch')
class ToolbarPool(object): def __init__(self): self.toolbars = SortedDict() self._discovered = False self.force_register = False def discover_toolbars(self): if self._discovered: return #import all the modules toolbars = get_cms_setting('TOOLBARS') if toolbars: for cls in iterload_objects(toolbars): self.force_register = True self.register(cls) self.force_register = False else: load('cms_toolbar') self._discovered = True def clear(self): self.toolbars = SortedDict() self._discovered = False def register(self, toolbar): if not self.force_register and get_cms_setting('TOOLBARS'): return toolbar from cms.toolbar_base import CMSToolbar # validate the app if not issubclass(toolbar, CMSToolbar): raise ImproperlyConfigured( 'CMS Toolbar must inherit ' 'cms.toolbar_base.CMSToolbar, %r does not' % toolbar) name = "%s.%s" % (toolbar.__module__, toolbar.__name__) if name in self.toolbars.keys(): raise ToolbarAlreadyRegistered( "[%s] a toolbar with this name is already registered" % name) self.toolbars[name] = toolbar return toolbar def unregister(self, toolbar): name = '%s.%s' % (toolbar.__module__, toolbar.__name__) if name not in self.toolbars: raise ToolbarNotRegistered('The toolbar %s is not registered' % name) del self.toolbars[name] def get_toolbars(self): self.discover_toolbars() return self.toolbars def get_watch_models(self): models = [] for toolbar in self.toolbars.values(): if hasattr(toolbar, 'watch_models'): models += toolbar.watch_models return models
def course_preview(request, semester_id, course_id): semester = get_object_or_404(Semester, id=semester_id) course = get_object_or_404(Course, id=course_id) # build forms forms = SortedDict() for questionnaire, contribution in questionnaires_and_contributions(course): form = QuestionsForm(request.POST or None, contribution=contribution, questionnaire=questionnaire) forms[(contribution, questionnaire)] = form return render_to_response("fsr_course_preview.html", dict(forms=forms.values(), course=course, semester=semester), context_instance=RequestContext(request))
def collect_fields_by_section(self): """ Return a dict of all fields related to this report by section id. """ # map of section id to field dict fields_by_section = {} # section id=0 is the "common" section fields_by_section[0] = SortedDict() if self.fields: report_fields = {} for f in self.fields.all(): report_fields[f.keyword] = f fields_by_section[0].update(report_fields) # Pull in fields from each section (which may add fields to # the common as well) for s in Section.objects.filter(report=self): for section_id, fields in s.collect_fields_by_section().iteritems( ): if section_id not in fields_by_section: fields_by_section[section_id] = fields else: fields.update(fields_by_section[section_id]) fields_by_section[section_id] = fields # Reorder fields in each section according to the field_order list new_fields_by_section = {} for i, fields in fields_by_section.iteritems(): # fields_by_section will have the format: # { 's17_duration' : TableField(keyword='duration'), # 's18_duration' : TableField(keyword='duration'), ...} # The field_order list is by keyword, not the <sectionid>_<keyword> format keywords_to_field_names = SortedDict() for (field_name, field) in fields_by_section[i].iteritems(): keywords_to_field_names[field.keyword] = (field_name, field) ordered_field_names = SortedDict() # Iterate over the defined order list, which may not address all fields if self.field_order: for keyword in self.field_order: if keyword in keywords_to_field_names: pair = keywords_to_field_names[keyword] ordered_field_names[pair[0]] = pair[1] del keywords_to_field_names[keyword] # Preserve the order of any fields left for pair in keywords_to_field_names.values(): ordered_field_names[pair[0]] = pair[1] new_fields_by_section[i] = ordered_field_names return new_fields_by_section
def galYearPurchase(request): ''' Plots a pie chart showing the material cost by Organizational Units''' width = int(request.GET.get('w', '400')) height = int(request.GET.get('h', '240')) end_date = datetime.strptime( request.GET.get('end_date', datetime.today().strftime('%Y-%m-%d')), '%Y-%m-%d') if 'start_date' in request.GET: start_date = datetime.strptime( request.GET.get('start_date', datetime.today().strftime('%Y-%m-%d')), '%Y-%m-%d') else: # Calcs 12 months ago if end_date.month == 12: start_date = datetime(end_date.year, 1, 1) else: start_date = datetime(end_date.year - 1, end_date.month + 1, 1) year = start_date.year month = start_date.month data = SortedDict() while (datetime(year, month, 1) < end_date): data[datetime(year, month, 1).strftime('%m-%Y')] = 0 month += 1 if month > 12: year += 1 month = 1 for inv in PurchaseInvoice.objects.filter( input_date__gt=start_date, input_date__lte=end_date).order_by('input_date'): month_year = inv.input_date.strftime('%m-%Y') data[month_year] += inv.total_cost chart = pygal.Line(width=width, height=height, style=LightStyle, x_label_rotation=30, show_legend=False, interpolate='cubic', title_font_size=12) chart.title = _(u'From %(startdate)s to %(enddate)s') % { 'startdate': start_date.strftime('%d-%m-%Y'), 'enddate': end_date.strftime('%d-%m-%Y') } chart.x_labels = data.keys() chart.add(_(u'Purchases'), map(float, data.values())) svg = chart.render() png = cairosvg.svg2png(svg) return HttpResponse(png, 'image/png')
class DebugToolbar(object): def __init__(self, request): self.request = request self._panels = SortedDict() base_url = self.request.META.get('SCRIPT_NAME', '') self.config = { 'INTERCEPT_REDIRECTS': True, 'MEDIA_URL': u'%s/__debug__/m/' % base_url, 'ROOT_TAG_ATTRS': '', } # Check if settings has a DEBUG_TOOLBAR_CONFIG and updated config self.config.update(getattr(settings, 'DEBUG_TOOLBAR_CONFIG', {})) self.template_context = { 'BASE_URL': base_url, # for backwards compatibility 'DEBUG_TOOLBAR_MEDIA_URL': self.config.get('MEDIA_URL'), 'STATIC_URL': settings.STATIC_URL, 'TOOLBAR_ROOT_TAG_ATTRS': self.config.get('ROOT_TAG_ATTRS'), } self.load_panels() self.stats = {} def _get_panels(self): return self._panels.values() panels = property(_get_panels) def get_panel(self, cls): return self._panels[cls] def load_panels(self): """ Populate debug panels """ global panel_classes for panel_class in panel_classes: try: panel_instance = panel_class(context=self.template_context) except: raise # Bubble up problem loading panel self._panels[panel_class] = panel_instance def render_toolbar(self): """ Renders the overall Toolbar with panels inside. """ context = self.template_context.copy() context.update({ 'panels': self.panels, }) return render_to_string('debug_toolbar/base.html', context)
def main_menu(context): app_list = lfssite.index(context['request']).context_data['app_list'] new_app_list = SortedDict() for app in app_list: if app['name'] in new_app_list: new_app_list[app['name']]['models'].extend(app['models']) else: new_app_list[app['name']] = app context['new_app_list'] = new_app_list.values() if context.get('title') == _('Site administration'): context['app_list'] = context['new_app_list'] return context
class IndicatorSet(object): def __init__(self, spec): self.slug = spec["slug"] self.name = spec["name"] self.indicators = SortedDict() for ispec in spec.get("indicators", []): self.indicators[ispec["slug"]] = Indicator(ispec) def get_indicators(self): return self.indicators.values() def get_indicator(self, slug): return self.indicators[slug]
class IndicatorSet(object): def __init__(self, spec): from django.utils.datastructures import SortedDict self.slug = spec["slug"] self.name = spec["name"] self.indicators = SortedDict() for ispec in spec.get("indicators", []): self.indicators[ispec["slug"]] = Indicator(ispec) def get_indicators(self): return list(self.indicators.values()) def get_indicator(self, slug): return self.indicators[slug]
def products_photos_get(qset): ids_map = SortedDict() for product in qset: ids_map[product.pk] = product for img in ProductImage.active_objects.filter( product__in=ids_map.keys()).order_by('pos'): product = ids_map[img.product_id] if not hasattr(product, 'images'): product.images = [] product.images.append(img) return ids_map.values()
class Backend(object): def __init__(self): self.servers = SortedDict() fp = open(settings.DASHVISOR_CONFIG_FILE) index = 0 for line in fp.xreadlines(): id = str(index) server = Server(line.strip(), id=id) self.servers[id] = server index += 1 fp.close() def refresh(self): for s in self.servers.values(): s.refresh()
def build_events_by_year(events, **config): display_months_without_events = (config.get( 'display_months_without_events', True)) # archive view means time runs in reverse. of the current year in a # other order is_archive_view = config.get('is_archive_view', False) now = timezone.now() events_by_year = SortedDict() for event in events: year = event.start_date.year if year not in events_by_year: events_by_year[year] = { 'year': year, 'date': date(year, 1, 1), 'months': build_months(year=year, is_archive_view=is_archive_view) } (events_by_year[year]['months'][event.start_date.month] ['events'].append(event)) flattened_events_by_year = events_by_year.values() for year in flattened_events_by_year: year['months'] = year['months'].values() year['event_count'] = 0 for month in year['months']: month['event_count'] = len(month['events']) year['event_count'] += month['event_count'] month['has_events'] = bool(month['event_count']) month['display_in_navigation'] = ( (not display_months_without_events and month['has_events']) or display_months_without_events) # if this is the current year, hide months before this month (or after # this month if we're in archive view) if year['year'] == now.year: if is_archive_view: # don't display any months after the current month for month in year['months']: if month['month'] > now.month: month['display_in_navigation'] = False else: # don't display any months before the current month for month in year['months']: if month['month'] < now.month: month['display_in_navigation'] = False return flattened_events_by_year
class DebugToolbar(object): def __init__(self, request): self.request = request self._panels = SortedDict() base_url = self.request.META.get('SCRIPT_NAME', '') self.config = { 'MEDIA_URL': '%s/__debug__/m/' % base_url, } self.config.update(CONFIG) self.template_context = { 'BASE_URL': base_url, # for backwards compatibility 'DEBUG_TOOLBAR_MEDIA_URL': self.config['MEDIA_URL'], 'STATIC_URL': settings.STATIC_URL, 'TOOLBAR_ROOT_TAG_ATTRS': self.config['ROOT_TAG_ATTRS'], } self.load_panels() self.stats = {} def _get_panels(self): return list(self._panels.values()) panels = property(_get_panels) def get_panel(self, cls): return self._panels[cls] def load_panels(self): """ Populate debug panels """ global panel_classes for panel_class in panel_classes: panel_instance = panel_class(context=self.template_context) self._panels[panel_class] = panel_instance def render_toolbar(self): """ Renders the overall Toolbar with panels inside. """ context = self.template_context.copy() context.update({ 'panels': self.panels, }) return render_to_string('debug_toolbar/base.html', context)
def test_init_keys(self): """ Initialising a SortedDict with two keys will just take the first one. A real dict will actually take the second value so we will too, but we'll keep the ordering from the first key found. """ tuples = ((2, 'two'), (1, 'one'), (2, 'second-two')) d = SortedDict(tuples) self.assertEqual(d.keys(), [2, 1]) real_dict = dict(tuples) self.assertEqual(sorted(real_dict.values()), ['one', 'second-two']) # Here the order of SortedDict values *is* what we are testing self.assertEqual(d.values(), ['second-two', 'one'])
def download_selected_orders(self, request, orders): response = HttpResponse(mimetype='text/csv') response[ 'Content-Disposition'] = 'attachment; filename=%s' % self.get_download_filename( request) writer = CsvUnicodeWriter(response, delimiter=',') meta_data = ( ('number', _('Order number')), ('value', _('Order value')), ('date', _('Date of purchase')), ('num_items', _('Number of items')), ('status', _('Order status')), ('customer', _('Customer email address')), ('shipping_address', _('Shipping address')), ('billing_address', _('Billing address')), ) columns = SortedDict() for k, v in meta_data: columns[k] = v writer.writerow(columns.values()) for order in orders: row = columns.copy() row['number'] = order.number row['value'] = order.total_incl_tax row['date'] = format_date(order.date_placed, 'DATETIME_FORMAT') row['num_items'] = order.num_items row['status'] = order.status row['customer'] = order.email if order.shipping_address: row['shipping_address'] = order.shipping_address else: row['shipping_address'] = '' if order.billing_address: row['billing_address'] = order.billing_address else: row['billing_address'] = '' encoded_values = [ unicode(value).encode('utf8') for value in row.values() ] writer.writerow(encoded_values) return response
def get_querysets(self): from django.db.models import get_app, get_apps, get_model if not self._querysets: app_list = SortedDict() for label in self.app_labels: app_label, _, model_qs = label.partition('.') try: app = get_app(app_label) except ImproperlyConfigured: raise CommandError("Unknown application: %s" % app_label) model_label, _, given_qs = model_qs.partition('.') # this ensures that model exists and thus the eval'ed string # (if valid) is at least a method of the model default manager. model = get_model(app_label, model_label) if model is None: raise CommandError("Unknown model: %s.%s" % (app_label, model_label)) if model == Page: qs = [] temp_qs = eval("model._default_manager.using('%s').%s" % (self.options.get('database'), given_qs.partition('.')[2])) if self.options.get('recursive'): for page in temp_qs: qs.extend(page.get_descendants(include_self=True)) else: qs = temp_qs else: if self.options.get('use_base_manager'): qs = eval("model._base_manager.using('%s').%s" % (self.options.get('database'), given_qs.partition('.')[2])) else: qs = eval("model._default_manager.using('%s').%s" % (self.options.get('database'), given_qs.partition('.')[2])) if app in app_list.keys(): if app_list[app] and model not in app_list[app]: app_list[app].extend(qs) else: app_list[app] = qs self._querysets = app_list.values() return self._querysets
def download_selected_invoices(self, request, invoices): response = http.HttpResponse(content_type='text/csv') response['Content-Disposition'] = 'attachment; filename=%s' \ % self.get_download_filename(request) writer = UnicodeCSVWriter(open_file=response) meta_data = ( ('number', _('Invoice number')), ('value', _('Invoice value')), ('date', _('Date of purchase')), ('order_number', _('Order number')), ('num_items', _('Number of items')), ('status', _('Invoice status')), ('customer', _('Customer email address')), ('person_name', _('Pay as juristic person')), ('person_vatin', _('Juristic person VAT number')), ('person_code', _('Juristic person code (e.g. KPP in Russia)')), ) columns = SortedDict() for k, v in meta_data: columns[k] = v writer.writerow(columns.values()) for invoice in invoices: row = columns.copy() row['number'] = invoice.number row['value'] = invoice.total_incl_tax row['date'] = format_datetime(invoice.date_created, 'DATETIME_FORMAT') row['order_number'] = invoice.order_number row['num_items'] = invoice.order.num_items row['status'] = invoice.status row['customer'] = invoice.order.email if invoice.person: row['person_name'] = invoice.person.name row['person_vatin'] = invoice.person.vatin row['person_code'] = invoice.person.reason_code else: row['person_name'] = '<none>' row['person_vatin'] = '<none>' row['person_code'] = '<none>' writer.writerow(row.values()) return response