def short(self): if self.day: return dateformat.format(self.lower_bound, "jS F Y") elif self.month: return dateformat.format(self.lower_bound, "F Y") else: return dateformat.format(self.lower_bound, "Y")
def __str__(self): if self.day: return dateformat.format(self.lower_bound, "l jS F Y") elif self.month: return dateformat.format(self.lower_bound, "F Y") else: return dateformat.format(self.lower_bound, "Y")
def diff_date(date, limen=2): if not date: return _('unknown') now = datetime.datetime.now() diff = now - date days = diff.days hours = int(diff.seconds/3600) minutes = int(diff.seconds/60) if date.year != now.year: return dateformat.format(date, 'd M \'y, H:i') elif days > 2 or (limen == 0): return dateformat.format(date, 'd M, H:i') elif days == 2: return _('2 days ago') elif days == 1: return _('yesterday') elif minutes >= 60: return ungettext('%(hr)d ' + _("hour ago"), '%(hr)d ' + _("hours ago"), hours) % {'hr':hours} elif diff.seconds >= 60: return ungettext('%(min)d ' + _("min ago"), '%(min)d ' + _("mins ago"), minutes) % {'min':minutes} else: return ungettext('%(sec)d ' + _("sec ago"), '%(sec)d ' + _("secs ago"), diff.seconds) % {'sec':diff.seconds}
def naturaldatetime(value): """ Return given past datetime formatted "naturally", omitting unnecessary data. If the given date is today, display only the time. If the date is within the past week, prepend the three-letter day of the week name to the time. Otherwise, prepend e.g. "Jan 23 2012", omitting the year if it is the current year. A given timezone-naive datetime is assumed to be in the current timezone. """ if timezone.is_naive(value): value = timezone.make_aware(value, timezone.get_current_timezone()) else: value = timezone.localtime(value) nowdt = timezone.localtime(now()) delta = nowdt - value period = dateformat.format(value, 'A').lower() if delta.days <= 0: format_string = 'f' elif 0 < delta.days < 7: format_string = 'D f' elif nowdt.year == value.year: format_string = 'M j, f' else: format_string = 'M j Y, f' return dateformat.format(value, format_string) + period
def export_as_csv(queryset, fields=None, header=None, filename=None, options=None, out=None): """ Exports a queryset as csv from a queryset with the given fields. :param queryset: queryset to export :param fields: list of fields names to export. None for all fields :param header: if True, the exported file will have the first row as column names :param filename: name of the filename :param options: CSVOptions() instance or none :param: out: object that implements File protocol. HttpResponse if None. :return: HttpResponse instance """ if out is None: if filename is None: filename = filename or "%s.csv" % queryset.model._meta.verbose_name_plural.lower().replace(" ", "_") response = HttpResponse(content_type='text/csv') response['Content-Disposition'] = 'attachment;filename="%s"' % filename.encode('us-ascii', 'replace') else: response = out if options is None: config = csv_options_default else: config = csv_options_default.copy() config.update(options) if fields is None: fields = [f.name for f in queryset.model._meta.fields] dialect = config.get('dialect', None) if dialect is not None: writer = csv.writer(response, dialect=dialect) else: writer = csv.writer(response, escapechar=str(config['escapechar']), delimiter=str(config['delimiter']), quotechar=str(config['quotechar']), quoting=int(config['quoting'])) if bool(header): if isinstance(header, (list, tuple)): writer.writerow(header) else: writer.writerow([f for f in fields]) for obj in queryset: row = [] for fieldname in fields: value = get_field_value(obj, fieldname) if isinstance(value, datetime.datetime): value = dateformat.format(value, config['datetime_format']) elif isinstance(value, datetime.date): value = dateformat.format(value, config['date_format']) elif isinstance(value, datetime.time): value = dateformat.format(value, config['time_format']) row.append(smart_str(value)) writer.writerow(row) return response
def values(self): """ Returns a list of values for this field for this instance. It's a list so we can accomodate many-to-many fields. """ # This import is deliberately inside the function because it causes # some settings to be imported, and we don't want to do that at the # module level. if self.field.rel: if isinstance(self.field.rel, models.ManyToOneRel): objs = getattr(self.instance.instance, self.field.name) elif isinstance(self.field.rel, models.ManyToManyRel): # ManyToManyRel return list(getattr(self.instance.instance, self.field.name).all()) elif self.field.choices: objs = dict(self.field.choices).get(self.raw_value, EMPTY_VALUE) elif isinstance(self.field, models.DateField) or isinstance(self.field, models.TimeField): if self.raw_value: date_format, datetime_format, time_format = get_date_formats() if isinstance(self.field, models.DateTimeField): objs = capfirst(dateformat.format(self.raw_value, datetime_format)) elif isinstance(self.field, models.TimeField): objs = capfirst(dateformat.time_format(self.raw_value, time_format)) else: objs = capfirst(dateformat.format(self.raw_value, date_format)) else: objs = EMPTY_VALUE elif isinstance(self.field, models.BooleanField) or isinstance(self.field, models.NullBooleanField): objs = {True: 'Yes', False: 'No', None: 'Unknown'}[self.raw_value] else: objs = self.raw_value return [objs]
def prep_date(date): import datetime if date == "month": right_now = datetime.datetime.now() thisMonth = datetime.datetime(right_now.year,right_now.month,1)#make a datetime obj for 1st of this month delta = datetime.timedelta(seconds=1) #create a delta of 1 second last_day = thisMonth - delta #last day of last month if last_day.day < right_now.day: final_day = last_day.day else: final_day=right_now.day #all this is to have a valid month span for dates, basicly from a month ago(validated) to now #return str(datetime.date(right_now.year,right_now.month-1,final_day))+','+str(datetime.date(right_now.year,right_now.month,right_now.day)) sDate = dateformat.format(datetime.date(right_now.year,right_now.month-1,final_day), settings.DATE_FORMAT) eDate = dateformat.format(datetime.date(right_now.year,right_now.month,right_now.day), settings.DATE_FORMAT) return str(sDate)+","+str(eDate) elif (date == "day") | (date == "yesterday"): right_now = datetime.datetime.now() yesterday = right_now.day-1 if yesterday == 0: thisMonth = datetime.date(right_now.year,right_now.month,1)#make a datetime obj for 1st of this month delta = datetime.timedelta(seconds=1) #create a delta of 1 second last_month = thisMonth - delta #last day of last month return str(datetime.date(last_month.year,last_month.month, last_month.day))+","+str(datetime.date(last_month.year,last_month.month, last_month.day)) else: sDate = dateformat.format(datetime.date(right_now.year,right_now.month, yesterday), settings.DATE_FORMAT) eDate = dateformat.format(datetime.date(right_now.year,right_now.month, yesterday), settings.DATE_FORMAT) return str(sDate)+","+str(eDate) try: x = str(date.split(",")) except: date = str(date)+","+str(date) return str(date)
def last_message(request): lastModif = request.GET.get('timestamp') if Messages.objects.all() : currentModif = format(Messages.objects.order_by('-date')[0].date, 'U') else: currentModif = 0 if lastModif == "0": lastModif = currentModif while currentModif <= lastModif: time.sleep(0.1) if Messages.objects.all() : currentModif = format(Messages.objects.order_by('-date')[0].date, 'U') else: currentModif = 0 return render(request, 'submissions/message.html', { 'message' : Messages.objects.last(), 'user' : request.user.profil, 'timestamp': currentModif })
def __init__(self, data, survey, record_model, idx=0, description=''): """Creates a new SurveyRecordList template. Args: data: The RequestData object to use. survey: The Survey to show the records for record_model: The Model class of the Record entities. idx: The index of the list to use. description: The (optional) description of the list. """ super(SurveyRecordList, self).__init__(data) self.survey = survey self.record_model = record_model self.idx = idx self.description = description # Create the configuration based on the schema of the survey list_config = lists.ListConfiguration() schema = surveys.SurveySchema(survey) for field in schema: label = field.getLabel() field_id = field.getFieldName() list_config.addColumn( field_id, label, field_or_empty(field_id), hidden=True) list_config.addColumn( 'created', 'Created On', lambda ent, *args: format(ent.created, DATETIME_FORMAT)) list_config.addColumn( 'modified', 'Last Modified On', lambda ent, *args: format(ent.modified, DATETIME_FORMAT)) self.list_config = list_config
def value_list(self): """ Returns a list of {value, url} dictionaries representing each value for this attribute. """ from django.utils.dateformat import format, time_format urls = [None] descriptions = [None] if self.is_filter: if self.is_lookup: urls = [look and '/%s/by-%s/%s/' % (self.schema_slug, self.sf.slug, look.slug) or None for look in self.values] elif isinstance(self.raw_value, datetime.date): urls = ['/%s/by-%s/%s/%s/%s/' % (self.schema_slug, self.sf.slug, self.raw_value.year, self.raw_value.month, self.raw_value.day)] elif self.raw_value in (True, False, None): urls = ['/%s/by-%s/%s/' % (self.schema_slug, self.sf.slug, {True: 'yes', False: 'no', None: 'na'}[self.raw_value])] if self.is_lookup: values = [val and val.name or 'None' for val in self.values] descriptions = [val and val.description or None for val in self.values] elif isinstance(self.raw_value, datetime.datetime): values = [format(self.raw_value, 'F j, Y, P')] elif isinstance(self.raw_value, datetime.date): values = [format(self.raw_value, 'F j, Y')] elif isinstance(self.raw_value, datetime.time): values = [time_format(self.raw_value, 'P')] elif self.raw_value is True: values = ['Yes'] elif self.raw_value is False: values = ['No'] elif self.raw_value is None: values = ['N/A'] else: values = [self.raw_value] return [{'value': value, 'url': url, 'description': description} for value, url, description in zip(values, urls, descriptions)]
def repdate (approx): """Alternative to Django's date filter which doesn't play well with ApproximateDateFields. @param approx: approximate date @type: ApproximateDateField @return: nicely formatted date @rtype: str """ if not approx: return '' if approx.month == 1 and approx.day == 1: return dateformat.format(approx, 'Y').encode('utf-8') elif hasattr(approx, 'future') and approx.future: return _(u'future') elif approx.year and approx.month and approx.day: # return dateformat.format(approx, 'j F Y').encode('utf-8') return dateformat.format(approx, 'Y').encode('utf-8') elif approx.year and approx.month: #return dateformat.format(approx, 'F Y').encode('utf-8') return dateformat.format(approx, 'Y').encode('utf-8') elif approx.year: return dateformat.format(approx, 'Y').encode('utf-8') else: return _(u'invalid')
def render(self, context): try: start_date = self.start_date.resolve(context) end_date = self.end_date.resolve(context) except template.VariableDoesNotExist: return '' start_format = "" end_format = "" if end_date: if end_date and start_date == end_date : start_format = "%s %s, %s" % (self.format['month'], self.format['day'], self.format['year']) else : start_format = "%s %s" % (self.format['month'], self.format['day']) end_format = "%s %s, %s" % (self.format['month'], self.format['day'], self.format['year']) if start_date.year != end_date.year: start_format += ", %s" % self.format['year'] else: start_format = "%s %s, %s" % (self.format['month'], self.format['day'], self.format['year']) ret = dateformat.format(start_date, start_format) if end_format: ret += " - " + dateformat.format(end_date, end_format) return ret
def ajax_allocation_details(request): if request.is_ajax(): aloc = Allocation.objects.get(id=int(request.POST['id'])) html ='''<table class="TFtable-lists"><tr><td><p class='my-modal-content'>Book Code : </td><td> <span>%s</span></p></td></tr><tr><td> <p class='my-modal-content'>Book Title : </td><td> <span>%s</span></p></td></tr><tr><td> <p class='my-modal-content'>Allocated To : </td><td> <span>%s</span></p></td></tr><tr><td> <p class='my-modal-content'>Start Date : </td><td> <span>%s</span></p></td></tr><tr><td> <p class='my-modal-content'>End Date : </td><td> <span>%s</span></p></td></tr><tr><td> <p class='my-modal-content'>Allocated By : </td><td> <span>%s</span></p></td></tr><tr><td> <p class='my-modal-content'>Status : </td><td> <span >%s</span></p></td></tr></table> ''' % (aloc.book.code, aloc.book.title, aloc.student, dateformat.format(aloc.start_date, 'F j, Y'), dateformat.format(aloc.end_date, 'F j, Y'), aloc.allocated_by, bookFlags.get(aloc.status,'Undefined')) return HttpResponse(html)
def test_changes_display_dict_datetime(self): timestamp = datetime.datetime(2017, 1, 10, 15, 0, tzinfo=timezone.utc) date = datetime.date(2017, 1, 10) time = datetime.time(12, 0) dtm = DateTimeFieldModel(label='DateTimeField model', timestamp=timestamp, date=date, time=time, naive_dt=self.now) dtm.save() localized_timestamp = timestamp.astimezone(gettz(settings.TIME_ZONE)) self.assertTrue(dtm.history.latest().changes_display_dict["timestamp"][1] == \ dateformat.format(localized_timestamp, settings.DATETIME_FORMAT), msg=("The datetime should be formatted according to Django's settings for" " DATETIME_FORMAT")) timestamp = timezone.now() dtm.timestamp = timestamp dtm.save() localized_timestamp = timestamp.astimezone(gettz(settings.TIME_ZONE)) self.assertTrue(dtm.history.latest().changes_display_dict["timestamp"][1] == \ dateformat.format(localized_timestamp, settings.DATETIME_FORMAT), msg=("The datetime should be formatted according to Django's settings for" " DATETIME_FORMAT")) # Change USE_L10N = True with self.settings(USE_L10N=True, LANGUAGE_CODE='en-GB'): self.assertTrue(dtm.history.latest().changes_display_dict["timestamp"][1] == \ formats.localize(localized_timestamp), msg=("The datetime should be formatted according to Django's settings for" " USE_L10N is True with a different LANGUAGE_CODE."))
def display_for_field(value, field): from django.contrib.admin.templatetags.admin_list import _boolean_icon from django.contrib.admin.views.main import EMPTY_CHANGELIST_VALUE if field.flatchoices: return dict(field.flatchoices).get(value, EMPTY_CHANGELIST_VALUE) # NullBooleanField needs special-case null-handling, so it comes # before the general null test. elif isinstance(field, models.BooleanField) or isinstance(field, models.NullBooleanField): return _boolean_icon(value) elif value is None: return EMPTY_CHANGELIST_VALUE elif isinstance(field, models.DateField) or isinstance(field, models.TimeField): if value: date_format = formats.get_format('DATE_FORMAT') datetime_format = formats.get_format('DATETIME_FORMAT') time_format = formats.get_format('TIME_FORMAT') if isinstance(field, models.DateTimeField): return capfirst(dateformat.format(value, datetime_format)) elif isinstance(field, models.TimeField): return capfirst(dateformat.time_format(value, time_format)) else: return capfirst(dateformat.format(value, date_format)) else: return EMPTY_CHANGELIST_VALUE elif isinstance(field, models.DecimalField): if value is not None: return ('%%.%sf' % field.decimal_places) % value else: return EMPTY_CHANGELIST_VALUE elif isinstance(field, models.FloatField): return escape(value) else: return smart_str(value)
def _render_obj_list(self, obj, fields): """ methodo usado para rendererizar um objeto nao suportado pelo simplejson parametros obj: é o objeto em si list_fields: os atributos desse objeto que serão renderizados a diferença do anterior que tudo vai ser realizado em forma de lista """ list_obj = [] for field in fields: attr, attrfound = self._find_attr(obj, field) if not attrfound: list_obj.append(None) continue if callable(attr): attr = attr() if isinstance(attr, datetime.datetime): attr = format(attr, DATETIME_FORMAT) if isinstance(attr, datetime.date): attr = format(attr, DATE_FORMAT) if hasattr(attr, "__unicode__"): attr = unicode(attr) list_obj.append(attr) return list_obj
def safe(self, value): """Returns the safe representation of the specified value. It is assumed that only date values are passed here, so the the output is not HTML escaped. Args: value: the specified string or a date for which to return the safe representation Returns: textual representation of the specified value or the empty string for None and the empty string. Raises: ValueError: if the specified value is invalid TypeError: if the specified value is neither a number nor a string """ if not value: return 'N/A' elif self.birthdate: return dateformat.format(value, BIRTHDATE_FORMAT) elif isinstance(value, datetime.datetime): return dateformat.format(value, DATETIME_FORMAT) else: return dateformat.format(value, DATE_FORMAT)
def __init__(self, request, data, survey): """Initializes the component. Args: request: The HTTPRequest object data: The RequestData object survey: the OrgApplicationSurvey entity """ super(MyOrgApplicationsComponent, self).__init__(request, data) # passed in so we don't have to do double queries self.survey = survey list_config = lists.ListConfiguration() list_config.addSimpleColumn("name", "Name") list_config.addSimpleColumn("org_id", "Organization ID") list_config.addColumn("created", "Created On", lambda ent, *args: format(ent.created, DATETIME_FORMAT)) list_config.addColumn("modified", "Last Modified On", lambda ent, *args: format(ent.modified, DATETIME_FORMAT)) if self.data.timeline.surveyPeriod(survey): url_name = "gci_retake_org_app" else: url_name = "gci_show_org_app" list_config.setRowAction(lambda e, *args: data.redirect.id(e.key().id()).urlOf(url_name)) self._list_config = list_config super(MyOrgApplicationsComponent, self).__init__(request, data)
def save(self, old_record, list_record, detail_record): if old_record is not None: # Street closures never change, so we don't have to # worry about changing applications that already exist. self.logger.debug('Closure already exists') return closure_type = self.get_or_create_lookup('closure_type', capfirst(list_record['closure_type'].lower()), list_record['closure_type'].upper()) # Calculate a "friendly" date range to avoid lameness like "from Oct. 3 to Oct. 3". if list_record['start_date'] == list_record['end_date']: friendly_date_range = 'on %s' % format(list_record['start_date'], 'F j') else: friendly_date_range = 'from %s to %s' % (format(list_record['start_date'], 'F j'), format(list_record['end_date'], 'F j')) attributes = { 'block_from': list_record['block_from'], 'block_to': list_record['block_to'], 'address': list_record['address'], 'street_dir': list_record['street_dir'], 'street_name': list_record['street_name'], 'street_suffix': list_record['street_suffix'], 'closure_type': closure_type.id, 'end_date': list_record['end_date'], 'details': list_record['details'], 'date_posted': list_record['date_posted'], } self.create_newsitem( attributes, title=u'%s %s' % (closure_type.name, friendly_date_range), url=SOURCE_URL, pub_date=list_record['date_posted'], item_date=list_record['start_date'], location_name=list_record['address'], )
def serialize(self, dt_format=None, zone=None): """ Serializes datetimes using given format or default format if None, in given or original time zone Returns formatted strings as dict for both datetime fields if present TimeWarp class now has built in time formats Serializer can use given format or you can choose from built in formats Builtin formats use Django's date formatter and argument format uses Python's own Also, datetimes are cast to given time zone or the original_timezone is used :param dt_format: a key in class formats or a Python format string :type dt_format: string :return: a dict with object's used datetime fields formatted :rtype: dict[string, string] """ if not zone: zone = self.original_timezone else: zone = pytz.timezone(zone) resp = {} for key in ("dt", "end_dt"): field = getattr(self, key) if field: field = field.astimezone(zone) if not dt_format: resp[key] = format(field, self.SERIALIZATION_FORMATS["finnish"]) else: try: resp[key] = format(field, self.SERIALIZATION_FORMATS[dt_format]) except KeyError: resp[key] = dt_format.format(field) return resp
def _format(self, value, label, cast=None, null='(None)', empty='(Empty)', places=2, map=None, max_length=100, truncate='...'): """Intelligently format typed data""" if value is None: value = null % {'label': label} if cast is not None: value = cast(value) if isinstance(value, (datetime.datetime, datetime.time, datetime.date)): if isinstance(value, datetime.datetime): result_repr = capfirst(dateformat.format(value, settings.DATE_FORMAT)) elif isinstance(value, datetime.time): result_repr = capfirst(dateformat.time_format(value, settings.TIME_FORMAT)) else: result_repr = capfirst(dateformat.format(value, settings.DATE_FORMAT)) elif isinstance(value, bool): BOOLEAN_MAPPING = {True: 'yes', False: 'no', None: 'unknown'} result_repr = E.IMG(src="%sadmin/img/icon-%s.gif" % (settings.ADMIN_MEDIA_PREFIX, BOOLEAN_MAPPING[value]), alt="%s" % value) elif isinstance(value, (float, Decimal)): result_repr = (u'%%.%sf' % places) % value elif map: result_repr = map.get(value, '--') elif isinstance(value, (SafeUnicode, SafeString)): try: return etree.fromstring(value) except etree.XMLSyntaxError: result_repr = value else: result_repr = unicode(value) if empty and result_repr == '': result_repr = empty % {'label': label} if not isinstance(result_repr, (SafeUnicode, SafeString)) and max_length and len(result_repr) > max_length: result_repr = E.ABBR(result_repr[:max_length-len(truncate)] + truncate, title=result_repr) return result_repr
def get_context_data(self, **kwargs): context = super(IndexJsonView, self).get_context_data(**kwargs) stories = context['stories'] context = self.clean_context(context) context['stories'] = [] for story in stories: story_json = { 'id': story.id, 'title': story.title, 'selfpost': story.selfpost, 'poll': story.poll, 'username': story.username, 'score': story.score, 'comments': story.comments, 'story_type': story.story_type, 'time': format(story.time, 'r'), 'time_unix': format(story.time, 'U'), 'cache': format(story.cache, 'r'), 'cache_unix': format(story.cache, 'U') } if not story.selfpost: story_json['url'] = story.url story_json['domain'] = domain(story.url) context['stories'].append(story_json) context['page'] = {'current': stories.number, 'total': stories.paginator.num_pages} return context
def _create_date_range_label(self, start, end): """ Create a label to display a date range. The dates are formatter such that: - If either start or end include hours/minutes/seconds that are not 00:00:00 then the full date time is displayed; - If both start and end have zero hours/minutes/seconds then only the day is displayed, and the end day is set to the previous day (to show an inclusive range); Args: start (datetime): Start date time end (datetime): End date time Returns: str: Label to use for the date range. """ if not start.time() and not end.time(): start_str = dateformat.format(start, settings.SHORT_DATE_FORMAT) end_str = dateformat.format(end - timedelta(days=1), settings.SHORT_DATE_FORMAT) else: start_str = dateformat.format(start, settings.SHORT_DATETIME_FORMAT), end_str = dateformat.format(end, settings.SHORT_DATETIME_FORMAT) if start_str == end_str: return _('%(date)s') % {'date': start_str} else: return _('%(start)s - %(end)s') % { 'start': start_str, 'end': end_str }
def iso_time_tag(date): return { 'timestamp': format(date, 'c'), 'month': format(date, 'm'), 'day': format(date, 'd'), 'year': format(date, 'Y'), }
def report_date_hierarchy(cl): if cl.date_hierarchy: model, field_name = get_date_model_field(cl.model, cl.date_hierarchy) rel_query_set = model.objects.all() year_field = "%s__year" % cl.date_hierarchy month_field = "%s__month" % cl.date_hierarchy day_field = "%s__day" % cl.date_hierarchy field_generic = "%s__" % cl.date_hierarchy year_lookup = cl.params.get(year_field) month_lookup = cl.params.get(month_field) day_lookup = cl.params.get(day_field) year_month_format, month_day_format = get_partial_date_formats() link = lambda d: mark_safe(cl.get_query_string(d, [field_generic])) if year_lookup and month_lookup and day_lookup: day = datetime.date(int(year_lookup), int(month_lookup), int(day_lookup)) return { "show": True, "back": { "link": link({year_field: year_lookup, month_field: month_lookup}), "title": dateformat.format(day, year_month_format), }, "choices": [{"title": dateformat.format(day, month_day_format)}], } elif year_lookup and month_lookup: days = rel_query_set.filter( **{"%s__year" % field_name: year_lookup, "%s__month" % field_name: month_lookup} ).dates(field_name, "day") return { "show": True, "back": {"link": link({year_field: year_lookup}), "title": year_lookup}, "choices": [ { "link": link({year_field: year_lookup, month_field: month_lookup, day_field: day.day}), "title": dateformat.format(day, month_day_format), } for day in days ], } elif year_lookup: months = rel_query_set.filter(**{"%s__year" % field_name: year_lookup}).dates(field_name, "month") return { "show": True, "back": {"link": link({}), "title": _("All dates")}, "choices": [ { "link": link({year_field: year_lookup, month_field: month.month}), "title": dateformat.format(month, year_month_format), } for month in months ], } else: years = rel_query_set.dates(field_name, "year") return { "show": True, "choices": [{"link": link({year_field: year.year}), "title": year.year} for year in years], }
def get_archive(): categories = [] tags = [] archive = [] entries = Entry.objects.filter(status__exact = 'publish').order_by('-pub_date') months = entries.dates('pub_date','month',order='DESC') for mon in months: m = Archive() m.link = "/archive/" + format(mon,'Y/m') + "/" m.title = format(mon,'b,Y') archive.append(m) for entry in entries: if entry.category not in categories: categories.append(entry.category) t = entry.tags.all() for tag in t: if tag not in tags: tags.append(tag) if tags: min_count = max_count = tags[0].count for tag in tags: if tag.count < min_count: min_count = tag.count if max_count < tag.count: max_count = tag.count range = float(max_count - min_count) if range == 0.0: range = 1.0 for tag in tags: tag.weight = int(MAX_WEIGHT * (tag.count - min_count) / range) return {'entries':entries,'categories':categories,'tags':tags,'archive':archive}
def smart_date(start_date=None, end_date=None, date_format='j.n.'): from datetime import datetime from django.utils import dateformat now = datetime.now() components = [] if start_date: components.append(dateformat.format(start_date, date_format)) if start_date.year != now.year: components.append(str(start_date.year)) start_time = start_date.time() if start_time.hour > 0 or start_time.minute > 0: components.append(dateformat.time_format(start_time,r',&\n\b\s\p;G:i')) if end_date: components.append(' – ') if (not start_date) or end_date.date() != start_date.date(): components.append(dateformat.format(end_date, date_format)) if end_date.year != now.year: components.append(str(end_date.year)) end_time = end_date.time() if end_time.hour > 0 or end_time.minute > 0: components.append(dateformat.time_format(end_time,r',&\n\b\s\p;G:i')) return ''.join(components)
def __init__(self, user): self.s_date = format(datetime.date.today(), 'Y-m-d') self.f_date = format(datetime.date.today(), 'l, M d, Y') self.user = user self.flights = Flight.objects\ .user(user)\ .order_by('date')\ .select_related() cd = 'attachment; filename=logbook{0}.pdf'.format(self.s_date) self.response = HttpResponse(mimetype='application/pdf') self.response['Content-Disposition'] = cd self.doc = SimpleDocTemplate(self.response, pagesize=landscape(letter), showBoundary=1, leftMargin=inch/4, rightMargin=inch/4, topMargin=inch/4, bottomMargin=inch/4, title="FlightLogg.in Logbook", author="FlightLogg.in")
def generate_image_filename(instance, filename): if instance.cjr_id is None and instance.is_cal_image: cjr_id = 0 elif instance.cjr is None and not instance.is_cal_image: raise Exception("The CJR must be set on non-calibration images before setting the image " + "so that the filename can be generated.") else: cjr_id = instance.cjr.id if not all([bool(x) for x in (instance, instance.xp_id, instance.capture_timestamp)]): raise Exception("The xp and capture_timestamp must be set before setting the image " + "so that the filename can be generated.") utc_ts = round(float(dud.format(instance.capture_timestamp, 'U.u')), 2) temp_dt = datetime.datetime.utcfromtimestamp(utc_ts).replace(tzinfo=dut.utc) return ( u'experiment_imagery/stills/{dtg}'.format( dtg=dud.format(instance.capture_timestamp, 'Y.m.d') ) + u'/XP-{instance.xp_id}_CJR-{cjr_id}_{instance.xp.species.shortname}_'.format( instance=instance, cjr_id=cjr_id ) + u'{file_dtg}_{file_ts}.jpg'.format( file_dtg=temp_dt.astimezone(dut.LocalTimezone()).strftime( settings.FILENAME_DATE_FORMAT), file_ts=utc_ts ) )
def date_hierarchy(cl): if cl.lookup_opts.admin.date_hierarchy: field_name = cl.lookup_opts.admin.date_hierarchy year_field = '%s__year' % field_name month_field = '%s__month' % field_name day_field = '%s__day' % field_name field_generic = '%s__' % field_name year_lookup = cl.params.get(year_field) month_lookup = cl.params.get(month_field) day_lookup = cl.params.get(day_field) year_month_format, month_day_format = get_partial_date_formats() link = lambda d: cl.get_query_string(d, [field_generic]) if year_lookup and month_lookup and day_lookup: day = datetime.date(int(year_lookup), int(month_lookup), int(day_lookup)) return { 'show': True, 'back': { 'link': link({year_field: year_lookup, month_field: month_lookup}), 'title': dateformat.format(day, year_month_format) }, 'choices': [{'title': dateformat.format(day, month_day_format)}] } elif year_lookup and month_lookup: days = cl.query_set.filter(**{year_field: year_lookup, month_field: month_lookup}).dates(field_name, 'day') return { 'show': True, 'back': { 'link': link({year_field: year_lookup}), 'title': year_lookup }, 'choices': [{ 'link': link({year_field: year_lookup, month_field: month_lookup, day_field: day.day}), 'title': dateformat.format(day, month_day_format) } for day in days] } elif year_lookup: months = cl.query_set.filter(**{year_field: year_lookup}).dates(field_name, 'month') return { 'show' : True, 'back': { 'link' : link({}), 'title': _('All dates') }, 'choices': [{ 'link': link({year_field: year_lookup, month_field: month.month}), 'title': dateformat.format(month, year_month_format) } for month in months] } else: years = cl.query_set.dates(field_name, 'year') return { 'show': True, 'choices': [{ 'link': link({year_field: year.year}), 'title': year.year } for year in years] }
def datetime_to_unix(datetime_): return int(dateformat.format(datetime_, "U"))
def unix_time(self): return format(self.created_on, 'U')
def get_timeuntil(self, obj): fmt = get_format('DATETIME_FORMAT') next_run = obj.next_run or timezone.now() value = capfirst(dateformat.format(utils.localtime(next_run), fmt)) return mark_safe("%s<br /><span class='mini'>(%s)</span>" % (value, obj.get_timeuntil()))
def _get_pretty_published_date(self, datetime_string): dt = parse_datetime(datetime_string) return dateformat.format(dt, 'd E Y г.')
def test_futuredates(self): the_future = datetime.datetime(2100, 10, 25, 0, 00) self.assertEquals(dateformat.format(the_future, r'Y'), u'2100')
def test_am_pm(self): my_birthday = datetime.datetime(1979, 7, 8, 22, 00) self.assertEquals(dateformat.format(my_birthday, 'a'), u'p.m.')
def test_empty_format(self): my_birthday = datetime.datetime(1979, 7, 8, 22, 00) self.assertEquals(dateformat.format(my_birthday, ''), u'')
def save(self, force_retrieve=False, *args, **kwargs): """ Use the force_retrieve parameter to create a new StripeCoupon object from an existing coupon created at Stripe API or update the local object with data fetched from Stripe. """ stripe.api_key = stripe_settings.API_KEY if self._previous_is_deleted != self.is_deleted and self.is_deleted: try: stripe_coupon = stripe.Coupon.retrieve(self.coupon_id) # make sure to delete correct coupon if self.created == timestamp_to_timezone_aware_date( stripe_coupon["created"]): stripe_coupon.delete() except stripe.error.InvalidRequestError: # means that the coupon has already been removed from stripe pass return super(StripeCoupon, self).save(*args, **kwargs) if self.pk or force_retrieve: try: stripe_coupon = stripe.Coupon.retrieve(self.coupon_id) if not force_retrieve: stripe_coupon.metadata = self.metadata stripe_coupon.save() if force_retrieve: # make sure we are not creating a duplicate coupon_qs = StripeCoupon.objects.filter( coupon_id=self.coupon_id) if coupon_qs.filter( created=timestamp_to_timezone_aware_date( stripe_coupon["created"])).exists(): raise StripeCouponAlreadyExists # all old coupons should be deleted for coupon in coupon_qs: coupon.is_deleted = True super(StripeCoupon, coupon).save( ) # use super save() to call pre/post save signals # update all fields in the local object in case someone tried to change them self.update_from_stripe_data( stripe_coupon, exclude_fields=["metadata"] if not force_retrieve else []) self.stripe_response = stripe_coupon except stripe.error.InvalidRequestError: if force_retrieve: raise self.is_deleted = True else: self.stripe_response = stripe.Coupon.create( id=self.coupon_id, duration=self.duration, amount_off=int(self.amount_off * 100) if self.amount_off else None, currency=self.currency, duration_in_months=self.duration_in_months, max_redemptions=self.max_redemptions, metadata=self.metadata, percent_off=self.percent_off, redeem_by=int(dateformat.format(self.redeem_by, "U")) if self.redeem_by else None, ) # stripe will generate coupon_id if none was specified in the request if not self.coupon_id: self.coupon_id = self.stripe_response["id"] self.created = timestamp_to_timezone_aware_date( self.stripe_response["created"]) # for future self.is_created_at_stripe = True return super(StripeCoupon, self).save(*args, **kwargs)
def __str__(self): return "notification: " + self.content + "(" + format( self.modified_at, 'U') + ")"
def referenced_case_attribute(case, field_name): if not case.indices[0]['referenced_id']: return "" referenced_case = CommCareCase.get(case.indices[0]['referenced_id']) if hasattr(referenced_case, field_name): return getattr(referenced_case, field_name) else: return "" def get_datepart(case, t='n'): child_date_of_death = case.get_case_property('child_date_of_death') if child_date_of_death: return format(force_to_datetime(child_date_of_death), t) else: return "" def calculate_weight(case): weight_birth = case.get_case_property('weight_birth') if weight_birth: #Probably measured in grams. Should be converted to kilograms if float(weight_birth) > 10: return str(float(weight_birth) / 1000.0) else: return weight_birth return ""
def items_for_result(cl, result): first = True pk = cl.lookup_opts.pk.attname for field_name in cl.list_display: row_class = '' try: f = cl.lookup_opts.get_field(field_name) except models.FieldDoesNotExist: # For non-field list_display values, the value is either a method # or a property. try: attr = getattr(result, field_name) allow_tags = getattr(attr, 'allow_tags', False) boolean = getattr(attr, 'boolean', False) if isinstance(attr, collections.Callable): attr = attr() if boolean: allow_tags = True result_repr = _boolean_icon(attr) else: result_repr = smart_unicode(attr) except (AttributeError, ObjectDoesNotExist): result_repr = EMPTY_CHANGELIST_VALUE else: # Strip HTML tags in the resulting text, except if the # function has an "allow_tags" attribute set to True. if not allow_tags: result_repr = escape(result_repr) else: result_repr = mark_safe(result_repr) else: field_val = getattr(result, f.attname) if isinstance(f.rel, models.ManyToOneRel): if field_val is not None: result_repr = escape(getattr(result, f.name)) else: result_repr = EMPTY_CHANGELIST_VALUE # Dates and times are special: They're formatted in a certain way. elif isinstance(f, models.DateField) or isinstance( f, models.TimeField): if field_val: (date_format, datetime_format, time_format) = get_date_formats() if isinstance(f, models.DateTimeField): result_repr = capfirst( dateformat.format(field_val, datetime_format)) elif isinstance(f, models.TimeField): result_repr = capfirst( dateformat.time_format(field_val, time_format)) else: result_repr = capfirst( dateformat.format(field_val, date_format)) else: result_repr = EMPTY_CHANGELIST_VALUE row_class = ' class="nowrap"' # Booleans are special: We use images. elif isinstance(f, models.BooleanField) or isinstance( f, models.NullBooleanField): result_repr = _boolean_icon(field_val) # DecimalFields are special: Zero-pad the decimals. elif isinstance(f, models.DecimalField): if field_val is not None: result_repr = ('%%.%sf' % f.decimal_places) % field_val else: result_repr = EMPTY_CHANGELIST_VALUE # Fields with choices are special: Use the representation # of the choice. elif f.choices: result_repr = dict(f.choices).get(field_val, EMPTY_CHANGELIST_VALUE) else: result_repr = escape(field_val) if force_unicode(result_repr) == '': result_repr = mark_safe(' ') # If list_display_links not defined, add the link tag to the first field if (first and not cl.list_display_links ) or field_name in cl.list_display_links: table_tag = {True: 'th', False: 'td'}[first] first = False url = cl.url_for_result(result) # Convert the pk to something that can be used in Javascript. # Problem cases are long ints (23L) and non-ASCII strings. result_id = repr(force_unicode(getattr(result, pk)))[1:] yield mark_safe('<%s%s><a href="%s"%s>%s</a></%s>' % \ (table_tag, row_class, url, (cl.is_popup and ' onclick="opener.dismissRelatedLookupPopup(window, %s); return false;"' % result_id or ''), conditional_escape(result_repr), table_tag)) else: yield mark_safe('<td%s>%s</td>' % (row_class, conditional_escape(result_repr)))
def date_hierarchy(cl): if cl.date_hierarchy: field_name = cl.date_hierarchy year_field = '%s__year' % field_name month_field = '%s__month' % field_name day_field = '%s__day' % field_name field_generic = '%s__' % field_name year_lookup = cl.params.get(year_field) month_lookup = cl.params.get(month_field) day_lookup = cl.params.get(day_field) year_month_format, month_day_format = get_partial_date_formats() link = lambda d: mark_safe(cl.get_query_string(d, [field_generic])) if year_lookup and month_lookup and day_lookup: day = datetime.date(int(year_lookup), int(month_lookup), int(day_lookup)) return { 'show': True, 'back': { 'link': link({ year_field: year_lookup, month_field: month_lookup }), 'title': dateformat.format(day, year_month_format) }, 'choices': [{ 'title': dateformat.format(day, month_day_format) }] } elif year_lookup and month_lookup: days = cl.query_set.filter(**{ year_field: year_lookup, month_field: month_lookup }).dates(field_name, 'day') return { 'show': True, 'back': { 'link': link({year_field: year_lookup}), 'title': year_lookup }, 'choices': [{ 'link': link({ year_field: year_lookup, month_field: month_lookup, day_field: day.day }), 'title': dateformat.format(day, month_day_format) } for day in days] } elif year_lookup: months = cl.query_set.filter(**{ year_field: year_lookup }).dates(field_name, 'month') return { 'show': True, 'back': { 'link': link({}), 'title': _('All dates') }, 'choices': [{ 'link': link({ year_field: year_lookup, month_field: month.month }), 'title': dateformat.format(month, year_month_format) } for month in months] } else: years = cl.query_set.dates(field_name, 'year') return { 'show': True, 'choices': [{ 'link': link({year_field: year.year}), 'title': year.year } for year in years] }
def f_get_date_time_format(str_format): return dateformat.format(CommonUtil().f_get_date_time(), str_format)
def csv_date(dt): return dateformat.format(timezone.make_naive(dt), DATETIME_FORMAT)
def items_for_result(cl, result, form): first = True pk = cl.lookup_opts.pk.attname for field_name in cl.list_display: row_class = '' try: f = cl.lookup_opts.get_field(field_name) except models.FieldDoesNotExist: # For non-field list_display values, the value is either a method, # property or returned via a callable. try: if callable(field_name): attr = field_name value = attr(result) elif hasattr(cl.model_admin, field_name) and \ not field_name == '__str__' and not field_name == '__unicode__': attr = getattr(cl.model_admin, field_name) value = attr(result) else: attr = getattr(result, field_name) if callable(attr): value = attr() else: value = attr allow_tags = getattr(attr, 'allow_tags', False) boolean = getattr(attr, 'boolean', False) if boolean: allow_tags = True result_repr = _boolean_icon(value) else: result_repr = smart_unicode(value) except (AttributeError, ObjectDoesNotExist): result_repr = EMPTY_CHANGELIST_VALUE else: # Strip HTML tags in the resulting text, except if the # function has an "allow_tags" attribute set to True. if not allow_tags: result_repr = escape(result_repr) else: result_repr = mark_safe(result_repr) else: field_val = getattr(result, f.attname) if isinstance(f.rel, models.ManyToOneRel): if field_val is not None: result_repr = escape(getattr(result, f.name)) else: result_repr = EMPTY_CHANGELIST_VALUE # Dates and times are special: They're formatted in a certain way. elif isinstance(f, models.DateField) or isinstance( f, models.TimeField): if field_val: (date_format, datetime_format, time_format) = get_date_formats() if isinstance(f, models.DateTimeField): result_repr = capfirst( dateformat.format(field_val, datetime_format)) elif isinstance(f, models.TimeField): result_repr = capfirst( dateformat.time_format(field_val, time_format)) else: result_repr = capfirst( dateformat.format(field_val, date_format)) else: result_repr = EMPTY_CHANGELIST_VALUE row_class = ' class="nowrap"' # Booleans are special: We use images. elif isinstance(f, models.BooleanField) or isinstance( f, models.NullBooleanField): result_repr = _boolean_icon(field_val) # DecimalFields are special: Zero-pad the decimals. elif isinstance(f, models.DecimalField): if field_val is not None: result_repr = ('%%.%sf' % f.decimal_places) % field_val else: result_repr = EMPTY_CHANGELIST_VALUE # Fields with choices are special: Use the representation # of the choice. elif f.choices: result_repr = dict(f.choices).get(field_val, EMPTY_CHANGELIST_VALUE) else: result_repr = escape(field_val) if force_unicode(result_repr) == '': result_repr = mark_safe(' ') # If list_display_links not defined, add the link tag to the first field if (first and not cl.list_display_links ) or field_name in cl.list_display_links: table_tag = {True: 'th', False: 'td'}[first] first = False url = cl.url_for_result(result) # Convert the pk to something that can be used in Javascript. # Problem cases are long ints (23L) and non-ASCII strings. if cl.to_field: attr = str(cl.to_field) else: attr = pk value = result.serializable_value(attr) result_id = repr(force_unicode(value))[1:] yield mark_safe(u'<%s%s><a href="%s"%s>%s</a></%s>' % \ (table_tag, row_class, url, (cl.is_popup and ' onclick="opener.dismissRelatedLookupPopup(window, %s); return false;"' % result_id or ''), conditional_escape(result_repr), table_tag)) else: # By default the fields come from ModelAdmin.list_editable, but if we pull # the fields out of the form instead of list_editable custom admins # can provide fields on a per request basis if form and field_name in form.fields: bf = form[field_name] result_repr = mark_safe( force_unicode(bf.errors) + force_unicode(bf)) else: result_repr = conditional_escape(result_repr) yield mark_safe(u'<td%s>%s</td>' % (row_class, result_repr)) if form: yield mark_safe(force_unicode(form[cl.model._meta.pk.attname]))
def challenge_new(request): if request.method == 'POST': form = ChallengeForm(request.POST, request.FILES) if form.is_valid(): #No validation here (should already be done .is_valid) #need to save to assign id new_challenge = form.save() #parse dockerfile for list of ports if new_challenge.upload: if new_challenge.hosted: try: ports = list() for line in new_challenge.upload.file: line = line.decode('utf-8') start = 'EXPOSE ' if (start in line): possible_port = (line[line.find(start) + len(start):]) ports.append(possible_port.split()) # flatten list flattened_ports = list( set([val for sublist in ports for val in sublist])) print(flattened_ports) if len(flattened_ports): new_challenge.ports = flattened_ports else: new_challenge.ports = '****no exposed ports****' except Exception as e: #raise Exception('Error parsing uploaded Dockerfile: ', e) print('Error parsing uploaded Dockerfile: ', e) new_challenge.ports = '****error parsing ports****' #set var for pathPrefix and tag #path_tag = str(new_challenge.id) + '_' + re.sub('[^A-Za-z0-9]+', '', new_challenge.category.name.lower()) + str(new_challenge.points) path_tag = 'chall_' + str(new_challenge.id) new_challenge.pathPrefix = path_tag if new_challenge.upload: if new_challenge.hosted: image_name = path_tag + ':latest' new_challenge.imageName = image_name #build image build = d.buildImage( fileobj=form.cleaned_data['upload'].file, tag=path_tag) #if build fails set vars as such if not build: error_msg = "****build image failed****" new_challenge.pathPrefix = error_msg new_challenge.imageName = error_msg new_challenge.upload.save(form.cleaned_data['upload'].name, new_challenge.upload) rethink_data = { 'sid': new_challenge.id, 'category': new_challenge.category.id, 'title': new_challenge.title, 'points': new_challenge.points, 'description': new_challenge.description, 'hosted': new_challenge.hosted, 'fileUpload': new_challenge.fileUpload, 'imageName': new_challenge.imageName, 'ports': new_challenge.ports, 'pathPrefix': new_challenge.pathPrefix, 'created': format(new_challenge.created, 'U') } elif new_challenge.fileUpload: print('fileUpload') new_challenge.upload.save(form.cleaned_data['upload'].name, new_challenge.upload) rethink_data = { 'sid': new_challenge.id, 'category': new_challenge.category.id, 'title': new_challenge.title, 'points': new_challenge.points, 'description': new_challenge.description, 'hosted': new_challenge.hosted, 'fileUpload': new_challenge.fileUpload, 'pathPrefix': new_challenge.pathPrefix, 'downloadPath': new_challenge.upload.url, 'created': format(new_challenge.created, 'U') } else: #doesn't have a file uploaded rethink_data = { 'sid': new_challenge.id, 'category': new_challenge.category.id, 'title': new_challenge.title, 'points': new_challenge.points, 'description': new_challenge.description, 'hosted': new_challenge.hosted, 'fileUpload': new_challenge.fileUpload, 'imageName': new_challenge.imageName, 'ports': new_challenge.ports, 'pathPrefix': new_challenge.pathPrefix, 'created': format(new_challenge.created, 'U') } new_challenge.save() # Push the realtime data to rethinkdb connection = r.connect(host=RDB_HOST, port=RDB_PORT) try: r.db(CTF_DB).table('challenges').insert(rethink_data).run( connection) except RqlRuntimeError as e: #raise Exception('Error adding challenge to realtime database: %s' % (e)) print('Error adding challenge to realtime database: %s' % (e)) finally: connection.close() return redirect('challenge_detail', pk=new_challenge.pk) # if a GET (or any other method) we'll create a blank form else: form = ChallengeForm() return render(request, 'adminpanel/challenges/challenge_edit.html', {'form': form})
def test_microsecond(self): # Regression test for #18951 dt = datetime(2009, 5, 16, microsecond=123) self.assertEqual(dateformat.format(dt, 'u'), '000123')
def test_date_formats(self): my_birthday = datetime(1979, 7, 8, 22, 00) timestamp = datetime(2008, 5, 19, 11, 45, 23, 123456) self.assertEqual(dateformat.format(my_birthday, 'A'), 'PM') self.assertEqual(dateformat.format(timestamp, 'c'), '2008-05-19T11:45:23.123456') self.assertEqual(dateformat.format(my_birthday, 'd'), '08') self.assertEqual(dateformat.format(my_birthday, 'j'), '8') self.assertEqual(dateformat.format(my_birthday, 'l'), 'Sunday') self.assertEqual(dateformat.format(my_birthday, 'L'), 'False') self.assertEqual(dateformat.format(my_birthday, 'm'), '07') self.assertEqual(dateformat.format(my_birthday, 'M'), 'Jul') self.assertEqual(dateformat.format(my_birthday, 'b'), 'jul') self.assertEqual(dateformat.format(my_birthday, 'n'), '7') self.assertEqual(dateformat.format(my_birthday, 'N'), 'July')
def test_datetime_with_local_tzinfo(self): ltz = get_default_timezone() dt = make_aware(datetime(2009, 5, 16, 5, 30, 30), ltz) self.assertEqual(datetime.fromtimestamp(int(format(dt, 'U')), ltz), dt) self.assertEqual(datetime.fromtimestamp(int(format(dt, 'U'))), dt.replace(tzinfo=None))
def test_epoch(self): udt = datetime(1970, 1, 1, tzinfo=utc) self.assertEqual(format(udt, 'U'), '0')
def test_date(self): d = date(2009, 5, 16) self.assertEqual(date.fromtimestamp(int(format(d, 'U'))), d)
def test_naive_datetime(self): dt = datetime(2009, 5, 16, 5, 30, 30) self.assertEqual(datetime.fromtimestamp(int(format(dt, 'U'))), dt)
def getCurrentTimeStamp(): return dateformat.format(timezone.now(), 'U')
def test_timezones(self): my_birthday = datetime(1979, 7, 8, 22, 00) summertime = datetime(2005, 10, 30, 1, 00) wintertime = datetime(2005, 10, 30, 4, 00) timestamp = datetime(2008, 5, 19, 11, 45, 23, 123456) # 3h30m to the west of UTC tz = get_fixed_timezone(-210) aware_dt = datetime(2009, 5, 16, 5, 30, 30, tzinfo=tz) if TZ_SUPPORT: self.assertEqual(dateformat.format(my_birthday, 'O'), '+0100') self.assertEqual(dateformat.format(my_birthday, 'r'), 'Sun, 8 Jul 1979 22:00:00 +0100') self.assertEqual(dateformat.format(my_birthday, 'T'), 'CET') self.assertEqual(dateformat.format(my_birthday, 'e'), '') self.assertEqual(dateformat.format(aware_dt, 'e'), '-0330') self.assertEqual(dateformat.format(my_birthday, 'U'), '300315600') self.assertEqual(dateformat.format(timestamp, 'u'), '123456') self.assertEqual(dateformat.format(my_birthday, 'Z'), '3600') self.assertEqual(dateformat.format(summertime, 'I'), '1') self.assertEqual(dateformat.format(summertime, 'O'), '+0200') self.assertEqual(dateformat.format(wintertime, 'I'), '0') self.assertEqual(dateformat.format(wintertime, 'O'), '+0100') # Ticket #16924 -- We don't need timezone support to test this self.assertEqual(dateformat.format(aware_dt, 'O'), '-0330')
def export_as_xls3( queryset, fields=None, header=None, # noqa filename=None, options=None, out=None): # pragma: no cover # sheet_name=None, header_alt=None, # formatting=None, out=None): """ Exports a queryset as xls from a queryset with the given fields. :param queryset: queryset to export (can also be list of namedtuples) :param fields: list of fields names to export. None for all fields :param header: if True, the exported file will have the first row as column names :param out: object that implements File protocol. :param header_alt: if is not None, and header is True, the first row will be as header_alt (same nr columns) :param formatting: if is None will use formatting_default :return: HttpResponse instance if out not supplied, otherwise out """ import xlsxwriter def _get_qs_formats(queryset): formats = {'_general_': book.add_format()} if hasattr(queryset, 'model'): for i, fieldname in enumerate(fields): try: f, __, __, __, = queryset.model._meta.get_field_by_name( fieldname) pattern = xlsxwriter_options.get( f.name, xlsxwriter_options.get(f.__class__.__name__, 'general')) fmt = book.add_format({'num_format': pattern}) formats[fieldname] = fmt except FieldDoesNotExist: pass # styles[i] = xlwt.easyxf(num_format_str=xls_options_default.get(col_class, 'general')) # styles[i] = xls_options_default.get(col_class, 'general') return formats http_response = out is None if out is None: # if filename is None: # filename = filename or "%s.xls" % queryset.model._meta.verbose_name_plural.lower().replace(" ", "_") # response = HttpResponse(content_type='application/vnd.ms-excel') # response['Content-Disposition'] = 'attachment;filename="%s"' % filename.encode('us-ascii', 'replace') # out = io.BytesIO() if six.PY2: out = six.StringIO() elif six.PY3: out = six.StringIO() # out = io.BytesIO() else: raise EnvironmentError('Python version not supported') config = xlsxwriter_options.copy() if options: config.update(options) if fields is None: fields = [ f.name for f in queryset.model._meta.fields + queryset.model._meta.many_to_many ] book = xlsxwriter.Workbook(out, {'in_memory': True}) sheet_name = config.pop('sheet_name') use_display = config.get('use_display', False) sheet = book.add_worksheet(sheet_name) book.close() formats = _get_qs_formats(queryset) row = 0 sheet.write(row, 0, force_text('#'), formats['_general_']) if header: if not isinstance(header, (list, tuple)): header = [ force_text(f.verbose_name) for f in queryset.model._meta.fields + queryset.model._meta.many_to_many if f.name in fields ] for col, fieldname in enumerate(header, start=1): sheet.write(row, col, force_text(fieldname), formats['_general_']) settingstime_zone = get_default_timezone() for rownum, row in enumerate(queryset): sheet.write(rownum + 1, 0, rownum + 1) for idx, fieldname in enumerate(fields): fmt = formats.get(fieldname, formats['_general_']) try: value = get_field_value(row, fieldname, usedisplay=use_display, raw_callable=False) if callable(fmt): value = fmt(value) if isinstance(value, (list, tuple)): value = smart_text(u"".join(value)) if isinstance(value, datetime.datetime): try: value = dateformat.format( value.astimezone(settingstime_zone), config['datetime_format']) except ValueError: value = dateformat.format(value, config['datetime_format']) if isinstance(value, six.binary_type): value = smart_text(value) sheet.write(rownum + 1, idx + 1, smart_text(value), fmt) except Exception as e: raise sheet.write(rownum + 1, idx + 1, smart_text(e), fmt) book.close() out.seek(0) if http_response: if filename is None: filename = filename or "%s.xls" % queryset.model._meta.verbose_name_plural.lower( ).replace(" ", "_") response = HttpResponse( out.read(), content_type= "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" ) # content_type='application/vnd.ms-excel') # response['Content-Disposition'] = six.b('attachment;filename="%s"') % six.b(filename.encode('us-ascii', 'replace')) response['Content-Disposition'] = six.b('attachment;filename="%s"' % filename) return response return out
def getTimeStamp(dateTimeObject): return dateformat.format(dateTimeObject, 'U')
def __unicode__(self): return ', '.join( (dateformat.format(self.date, 'd E Y'), self.product.name, self.address))
def rule_to_text(rule, short=False): """ Render the given `Rule` as natural text. :Parameters: `short` : bool Use abbreviated labels, i.e. 'Fri' instead of 'Friday'. """ frequencies = ( _('annually'), _('monthly'), _('weekly'), _('daily'), _('hourly'), _('minutely'), _('secondly'), ) timeintervals = ( _('years'), _('months'), _('weeks'), _('days'), _('hours'), _('minutes'), _('seconds'), ) if short: positional_display = { 1: _('1st %(weekday)s'), 2: _('2nd %(weekday)s'), 3: _('3rd %(weekday)s'), -1: _('last %(weekday)s'), -2: _('2nd last %(weekday)s'), -3: _('3rd last %(weekday)s'), } weekdays_display = ( _('Mon'), _('Tue'), _('Wed'), _('Thu'), _('Fri'), _('Sat'), _('Sun'), ) months_display = ( _('Jan'), _('Feb'), _('Mar'), _('Apr'), _p('month name', 'May'), _('Jun'), _('Jul'), _('Aug'), _('Sep'), _('Oct'), _('Nov'), _('Dec'), ) else: positional_display = { 1: _('first %(weekday)s'), 2: _('second %(weekday)s'), 3: _('third %(weekday)s'), 4: _('fourth %(weekday)s'), -1: _('last %(weekday)s'), -2: _('second last %(weekday)s'), -3: _('third last %(weekday)s'), } weekdays_display = ( _('Monday'), _('Tuesday'), _('Wednesday'), _('Thursday'), _('Friday'), _('Saturday'), _('Sunday'), ) months_display = ( _('January'), _('February'), _('March'), _('April'), _p('month name', 'May'), _('June'), _('July'), _('August'), _('September'), _('October'), _('November'), _('December'), ) def get_positional_weekdays(rule): items = [] if rule.bysetpos and rule.byday: for setpos in rule.bysetpos: for byday in rule.byday: byday = to_weekday(byday) items.append( positional_display.get(setpos) % {'weekday': weekdays_display[byday.number]}) elif rule.byday: for byday in rule.byday: byday = to_weekday(byday) items.append( positional_display.get(byday.index, '%(weekday)s') % {'weekday': weekdays_display[byday.number]}) return _(', ').join(items) parts = [] if rule.interval > 1: parts.append( _('every %(number)s %(freq)s') % { 'number': rule.interval, 'freq': timeintervals[rule.freq] }) else: parts.append(frequencies[rule.freq]) if rule.freq == YEARLY: if rule.bymonth: # bymonths are 1-indexed (January is 1), months_display # are 0-indexed (January is 0). items = _(', ').join([ months_display[month] for month in [month_index - 1 for month_index in rule.bymonth] ]) parts.append(_('each %(items)s') % {'items': items}) if rule.byday or rule.bysetpos: parts.append( _('on the %(items)s') % {'items': get_positional_weekdays(rule)}) if rule.freq == MONTHLY: if rule.bymonthday: items = _(', ').join([ dateformat.format(datetime.datetime(1, 1, day), 'jS') for day in rule.bymonthday ]) parts.append(_('on the %(items)s') % {'items': items}) elif rule.byday: if rule.byday or rule.bysetpos: parts.append( _('on the %(items)s') % {'items': get_positional_weekdays(rule)}) if rule.freq == WEEKLY: if rule.byday: items = _(', ').join([ weekdays_display[to_weekday(day).number] for day in rule.byday ]) parts.append(_('each %(items)s') % {'items': items}) # daily freqencies has no additional formatting, # hour/minute/second formatting not supported if rule.count: if rule.count == 1: parts.append(_('occuring once')) else: parts.append( _('occuring %(number)s times') % {'number': rule.count}) elif rule.until: parts.append( _('until %(date)s') % {'date': dateformat.format(rule.until, 'Y-m-d')}) return _(', ').join(parts)
def log_to(querydict): # 日付ごとのログ抽出時の対象日付 log_to = querydict.get('log_to') if log_to is None or log_to == "/": log_to = dateformat.format(datetime.now(), 'Y-m-d') return log_to
def render_finalized(self, value): if value in [None, u'']: return u'' return format_html(u'{0}', format(value, self.final_format))