def get_local_day_min(dt=None, year=None, month=None, day=None, utc=True): """讲时间转换成 本地时0点 并转换成UTC :param dt: :param navie: :return: """ if dt is None: tm = timezone.now() elif timezone.is_aware(dt): tm = timezone.make_naive(dt) else: tm = dt if year is not None: tm = tm.replace(year=year) if month is not None: tm = tm.replace(month=month) if day is not None: tm = tm.replace(day=day) tm = datetime.datetime.combine(tm, datetime.time.min) # 计算后的tm没有tzinfo tm = timezone.make_aware(tm) if utc: tm = timezone.make_naive(tm, timezone.utc) return tm.replace(tzinfo=timezone.utc) else: return tm
def clean(self): """Clean form.""" cleaned_data = super(EventForm, self).clean() start_date = cleaned_data.get('start_date') start_time = cleaned_data.get('start_time') end_date = cleaned_data.get('end_date') end_time = cleaned_data.get('end_time') space = cleaned_data.get('space') if space is not None and space.timezone is not None: tz = timezone(space.timezone) else: tz = timezone(settings.TIME_ZONE) # We need to handle a special case here, because midnight is incorrectly # considered as False in Python < 3.5. This test allows users to set a "00:00" # value for start_time and end_time fields. if start_date and (start_time or start_time == time(0,0,0)): start = make_aware(datetime.combine(start_date, start_time), tz) cleaned_data['start'] = make_naive(start, timezone(settings.TIME_ZONE)) if end_date and (end_time or end_time == time(0,0,0)): end = make_aware(datetime.combine(end_date, end_time), tz) cleaned_data['end'] = make_naive(end, timezone(settings.TIME_ZONE)) return cleaned_data
def clean(self): """Clean form.""" super(EventForm, self).clean() cdata = self.cleaned_data cdata["budget_bug"] = cdata.get("budget_bug_form", None) cdata["swag_bug"] = cdata.get("swag_bug_form", None) if self.editable_owner: cdata["owner"] = cdata.get("owner_form", None) else: cdata["owner"] = self.instance.owner # Set timezone t = timezone(cdata["timezone"]) if "start_form" in cdata: start = make_naive(cdata["start_form"], timezone(settings.TIME_ZONE)) cdata["start"] = t.localize(start) if "end_form" in cdata: end = make_naive(cdata["end_form"], timezone(settings.TIME_ZONE)) cdata["end"] = t.localize(end) # Directly write to self.errors as # ValidationError({'start_form': ['Error message']}) doesn't # seem to work. if cdata["start"] >= cdata["end"]: self.errors["start_form"] = u"Start date should come " "before end date." raise ValidationError({"start_form": ["Error"]}) return cdata
def get_calendar(self, start, end, target_date, end_date): calendar = self.get_raw_calendar() search_start = start.replace(':', '') search_end = end.replace(':', '') events = self.event_set.filter(room=self, start_ts__gte=target_date, end_ts__lte=end_date) print for event in events: start_wtz = timezone.make_naive(event.start_ts, timezone.get_current_timezone()) end_wtz = timezone.make_naive(event.end_ts, timezone.get_current_timezone()) starts = start_wtz.strftime('%H%M') ends = end_wtz.strftime('%H%M') for block in calendar: id = block['mil_hour'] + block['minutes'] if int(starts) <= int(id) and int(id) <= int(ends): block['status'] = 'reserved' else: block['status'] = 'available' for block in calendar: id = block['mil_hour'] + block['minutes'] if int(search_start) <= int(id) and int(id) <= int(search_end): block['status'] = 'searched' return calendar
def save(self): if not self._id: query = ('INSERT INTO `issues_issues` (' '`title`, `description`, `create_time`, `update_time`, ' '`assigned_to_user_id`, `created_by_user_id`, `priority_id`, `status_id`) ' 'VALUES (%s, %s, %s, %s, %s, %s, %s, %s)') args = ( self._title, self._description, timezone.make_naive(self._create_time, timezone.utc), timezone.make_naive(self._update_time, timezone.utc) if self._update_time else None, self._assigned_to.id if self._assigned_to else None, self._created_by.id, self._priority.id, self._status.id ) elif not self._changes: return else: query = 'UPDATE `issues_issues` SET `{}` = %s WHERE `id` = %s'.format( '` = %s, `'.join(self._changes.keys()) ) args = tuple(self._changes.values()) + (self.id,) self._changes.clear() c = db.cursor() c.execute(query, args) c.close() if not self._id: self._id = db.insert_id() db.commit()
def ajax_send_cur_time(request): def timedelta_to_seconds(td): return td.seconds + td.days*24*60*60 if request.is_ajax() and 't_id' in request.GET and request.GET['t_id']: D = {} # Текущее время для текущего часового пояса (make_naive) tmn = timezone.make_naive(timezone.now()) D['ctm'] = '%02i:%02i:%02i' % (tmn.hour, tmn.minute, tmn.second) # Достать время начала теста и определить, сколько осталось lm = LogMaster.objects.get(pk=request.GET['t_id']) # Ожидаемое время завершения (время начала + заданный интервал из Settings) endtime = timezone.make_naive(lm.dt) + lm.tst_id.max_time # Оставшееся время if endtime >= tmn: elapsed = endtime - tmn if timedelta_to_seconds(elapsed) > 0: D['etm'] = str(elapsed).split('.')[0] else: D['etm'] = 0 else: D['etm'] = 0 return JsonResponse(D) else: return JsonResponse({}, status=400)
def clean(self): """Clean form.""" super(EventForm, self).clean() cdata = self.cleaned_data cdata['budget_bug'] = cdata.get('budget_bug_form', None) cdata['swag_bug'] = cdata.get('swag_bug_form', None) if self.editable_owner: cdata['owner'] = cdata.get('owner_form', None) else: cdata['owner'] = self.instance.owner # Check if keys exists in cleaned data. if not all(k in cdata for k in ('start_form', 'end_form')): raise ValidationError('Please correct the form errors.') # Set timezone t = timezone(cdata['timezone']) start = make_naive(cdata['start_form'], timezone(settings.TIME_ZONE)) cdata['start'] = t.localize(start) end = make_naive(cdata['end_form'], timezone(settings.TIME_ZONE)) cdata['end'] = t.localize(end) if cdata['start'] >= cdata['end']: msg = 'Start date should come before end date.' self._errors['start_form'] = self.error_class([msg]) return cdata
def get_filtered(min_date=None, max_date=None, reporter_is_blocked=None, keywords=None): c = db.cursor() query = Issue._select_query filter = [] filter_args = [] if min_date: filter.append('`issues`.`create_time` >= TIMESTAMP(%s)') filter_args.append(timezone.make_naive(min_date, timezone.utc)) if max_date: filter.append('`issues`.`create_time` <= TIMESTAMP(%s)') filter_args.append(timezone.make_naive(max_date, timezone.utc)) if reporter_is_blocked is not None: filter.append('`c_u`.`is_blocked` = %s') filter_args.append(int(reporter_is_blocked)) if keywords: filter.append('MATCH (`title`, `description`) AGAINST (%s IN BOOLEAN MODE)') filter_args.append(keywords) if filter: query += ' WHERE ' + ' AND '.join(filter) c.execute(query, filter_args) issues = [] while True: e = c.fetchone() if not e: break i = Issue.from_query_result(e) issues.append(i) return issues
def ack_task(request, task_id): """Acknowledge a task, from a reminder. This is the page that reminder emails link to. It allows the user to set when the task was done, and when it is due next. """ try: task = Task.objects.get(id=task_id) except ObjectDoesNotExist: task = None if not task or task.user.id != request.cym_user.id: return HttpResponseNotFound(_("Couldn't find this task!")) if task and request.method == 'POST': task_done = request.POST.get('done', '') task_due = request.POST.get('due', '') valid = True if task_done: try: task_done = dateutil.parser.parse(task_done).date() except ValueError: task_done = None if not task_done: messages.add_message(request, messages.ERROR, _("Please enter the date you performed the " "task")) task_done = timezone.make_naive(timezone.now()).date() valid = False if task_due: try: task_due = dateutil.parser.parse(task_due).date() except ValueError: task_due = None if not task_due: messages.add_message(request, messages.ERROR, _("Please enter the date this task is due " "next")) task_due = task_done + datetime.timedelta(days=task.interval_days) valid = False if valid: done = TaskDone(task=task, done=task_done) done.save() task.due = task_due task.save() return redirect('profile') else: task_done = timezone.make_naive(timezone.now()).date() task_due = task_done + datetime.timedelta(days=task.interval_days) return render(request, 'call_your_mom/ack_task.html', {'task': task, 'task_done': task_done, 'task_due': task_due, 'task_is_due': task.is_due(request.cym_user.timezone)})
def _generate_date_clause(self,start,end=None): """ Helper function to generate time constraint on influx query to handle if using epoch time or datetime """ query_str = "time >= {start}s" if end: query_str = query_str + " AND time <= {end}s" try: start = int(start) except: start = start pass if isinstance(start,datetime): start = timezone.make_naive(start) if end: end = timezone.make_naive(end) if isinstance(start,date) or isinstance(start,datetime): query_str = query_str.replace("{start}s","\'{start}\'") if end: query_str = query_str.replace("{end}s","\'{end}\'") query_str_formatted = query_str.format(start=start, end=end) return query_str_formatted
def __init__(self, *args, **kwargs): """Initialize form. Dynamically set choices for country field. """ if 'editable_owner' in kwargs: self.editable_owner = kwargs['editable_owner'] del(kwargs['editable_owner']) super(EventForm, self).__init__(*args, **kwargs) # Dynamic countries field. countries = product_details.get_regions('en').values() countries.sort() country_choices = ([('', "Country")] + [(country, country) for country in countries]) self.fields['country'].choices = country_choices # Dynamic owner field. if self.editable_owner: self.fields['owner_form'] = forms.ModelChoiceField( queryset=User.objects.filter( userprofile__registration_complete=True, groups__name='Rep'), empty_label='Owner', initial=self.instance.owner.pk) else: self.fields['owner_form'] = forms.CharField( required=False, initial=get_full_name(self.instance.owner), widget=forms.TextInput(attrs={'readonly': 'readonly', 'class': 'input-text big'})) instance = self.instance # Dynamically set the year portion of the datetime widget now = datetime.now() start_year = getattr(self.instance.start, 'year', now.year) end_year = getattr(self.instance.end, 'year', now.year) self.fields['start_form'] = forms.DateTimeField( widget=SplitSelectDateTimeWidget( years=range(start_year, now.year + 10), minute_step=5), validators=[validate_datetime]) self.fields['end_form'] = forms.DateTimeField( widget=SplitSelectDateTimeWidget( years=range(end_year, now.year + 10), minute_step=5), validators=[validate_datetime]) # Make times local to venue if self.instance.start: start = make_naive(instance.local_start, timezone(instance.timezone)) self.fields['start_form'].initial = start if self.instance.end: end = make_naive(instance.local_end, timezone(instance.timezone)) self.fields['end_form'].initial = end # Use of intermediate fields to translate between bug.id and # bug.bug_id if instance.budget_bug: self.fields['budget_bug_form'].initial = instance.budget_bug.bug_id if instance.swag_bug: self.fields['swag_bug_form'].initial = instance.swag_bug.bug_id
def summarize(self, start, end): if not api.nova.extension_supported('SimpleTenantUsage', self.request): return if start <= end and start <= self.today: # The API can't handle timezone aware datetime, so convert back # to naive UTC just for this last step. start = timezone.make_naive(start, timezone.utc) end = timezone.make_naive(end, timezone.utc) try: self.usage_list = self.get_usage_list(start, end) except Exception: exceptions.handle(self.request, _('Unable to retrieve usage information.')) elif end < start: messages.error(self.request, _("Invalid time period. The end date should be " "more recent than the start date.")) elif start > self.today: messages.error(self.request, _("Invalid time period. You are requesting " "data from the future which may not exist.")) for project_usage in self.usage_list: project_summary = project_usage.get_summary() for key, value in project_summary.items(): self.summary.setdefault(key, 0) self.summary[key] += value
def clean(self): """Clean form.""" super(EventForm, self).clean() cdata = self.cleaned_data cdata['budget_bug'] = cdata.get('budget_bug_form', None) cdata['swag_bug'] = cdata.get('swag_bug_form', None) if self.editable_owner: cdata['owner'] = cdata.get('owner_form', None) else: cdata['owner'] = self.instance.owner # Set timezone t = timezone(cdata['timezone']) if 'start_form' in cdata: start = make_naive(cdata['start_form'], timezone(settings.TIME_ZONE)) cdata['start'] = t.localize(start) if 'end_form' in cdata: end = make_naive(cdata['end_form'], timezone(settings.TIME_ZONE)) cdata['end'] = t.localize(end) # Directly write to self.errors as # ValidationError({'start_form': ['Error message']}) doesn't # seem to work. if cdata['start'] >= cdata['end']: self.errors['start_form'] = (u'Start date should come ' 'before end date.') raise ValidationError({'start_form': ['Error']}) return cdata
def _match_aware(cls, old, new): tz = timezone.get_default_timezone() if timezone.is_naive(old) and timezone.is_aware(new): return (old, timezone.make_naive(new, tz)) elif timezone.is_aware(old) and timezone.is_naive(new): return (timezone.make_naive(old, tz), new) else: return (old, new)
def backwards(self, orm): "Write your backwards methods here." for s in orm['sleep.Sleep'].objects.all(): if timezone.is_aware(s.start_time): s.start_time = timezone.make_naive(s.start_time, t) if timezone.is_aware(s.end_time): s.end_time = timezone.make_naive(s.start_time, t) s.save()
def strdate(dt): tz = timezone.get_current_timezone() if type(dt) == datetime: return timezone.make_naive(dt, tz).strftime("%d/%m/%Y %H:%M") elif type(dt) == date: return timezone.make_naive(dt, tz).strftime("%d/%m/%Y") else: return dt
def test_make_naive(self): self.assertEqual( timezone.make_naive(datetime.datetime(2011, 9, 1, 13, 20, 30, tzinfo=EAT), EAT), datetime.datetime(2011, 9, 1, 13, 20, 30)) self.assertEqual( timezone.make_naive(datetime.datetime(2011, 9, 1, 17, 20, 30, tzinfo=ICT), EAT), datetime.datetime(2011, 9, 1, 13, 20, 30)) with self.assertRaises(ValueError): timezone.make_naive(datetime.datetime(2011, 9, 1, 13, 20, 30), EAT)
def test_make_aware_pytz(self): self.assertEqual( timezone.make_naive(CET.localize(datetime.datetime(2011, 9, 1, 12, 20, 30)), CET), datetime.datetime(2011, 9, 1, 12, 20, 30)) self.assertEqual( timezone.make_naive(pytz.timezone("Asia/Bangkok").localize(datetime.datetime(2011, 9, 1, 17, 20, 30)), CET), datetime.datetime(2011, 9, 1, 12, 20, 30)) with self.assertRaises(ValueError): timezone.make_naive(datetime.datetime(2011, 9, 1, 12, 20, 30), CET)
def _get_column_period_args(begin_time, end_time): begin_naive = make_naive(begin_time.value) end_naive = make_naive(end_time.value) return ( begin_naive.hour, begin_naive.strftime('%M'), end_naive.hour, end_naive.strftime('%M'), )
def render_attached_period(begin, end): begin = make_naive(begin.value) end = make_naive(end.value) return format_html( '<div class="attached time-table__time">' '{begin_h}:{begin_m} – {end_h}:{end_m}</div>', begin_h=begin.hour, begin_m=begin.strftime(r'%M'), end_h=end.hour, end_m=end.strftime(r'%M'), )
def test_make_naive(self): self.assertEqual( timezone.make_naive(datetime.datetime(2011, 9, 1, 13, 20, 30, tzinfo=EAT), EAT), datetime.datetime(2011, 9, 1, 13, 20, 30)) self.assertEqual( timezone.make_naive(datetime.datetime(2011, 9, 1, 17, 20, 30, tzinfo=ICT), EAT), datetime.datetime(2011, 9, 1, 13, 20, 30)) with self.assertRaisesMessage(ValueError, 'make_naive() cannot be applied to a naive datetime'): timezone.make_naive(datetime.datetime(2011, 9, 1, 13, 20, 30), EAT)
def test_make_aware_pytz(self): self.assertEqual( timezone.make_naive(CET.localize(datetime.datetime(2011, 9, 1, 12, 20, 30)), CET), datetime.datetime(2011, 9, 1, 12, 20, 30)) self.assertEqual( timezone.make_naive( pytz.timezone("Asia/Bangkok").localize(datetime.datetime(2011, 9, 1, 17, 20, 30)), CET ), datetime.datetime(2011, 9, 1, 12, 20, 30)) with self.assertRaisesMessage(ValueError, 'make_naive() cannot be applied to a naive datetime'): timezone.make_naive(datetime.datetime(2011, 9, 1, 12, 20, 30), CET)
def between(self, after, before, **kwargs): if timezone.is_aware(after): after = timezone.make_naive(after) if timezone.is_aware(before): before = timezone.make_naive(before) for dt in self._between(after, before, **kwargs): try: yield timezone.make_aware(dt) except NonExistentTimeError: pass
def save_extra_sessions(self): data = [] for session in self.type.sessions.all(): for extra in session.orig_sessions.all(): prev = self.get_extra_session(extra.extra.id) data.append({ 'session': extra.extra.id, 'start': timezone.make_naive(extra.start).strftime(settings.DATETIME_FORMAT), 'end': timezone.make_naive(extra.end).strftime(settings.DATETIME_FORMAT), 'used': prev['used'] if prev else extra.used }) self.set_extra_data('extra_sessions', data)
def fetch_from_source(pk):#self, pk): #self.update_state(state='PROGRESS') source = OaiSource.objects.get(pk=pk) baseStatus = 'records' # Set up the OAI fetcher format, created = OaiFormat.objects.get_or_create(name=source.format) client = source.getClient() client._metadata_registry.registerReader('oai_dc', oai_dc_reader) client._metadata_registry.registerReader('base_dc', base_dc_reader) # Limit queries to records in a time range of 7 days (by default) time_chunk = QUERY_TIME_RANGE start_date = make_naive(source.last_update, UTC()) current_date = make_naive(now(), UTC()) until_date = start_date + time_chunk # Restrict to a set ? restrict_set = source.restrict_set if not restrict_set: restrict_set = None while start_date <= current_date: source.status = baseStatus+' between '+str(start_date)+' and '+str(until_date) source.save() real_until_date = until_date if source.day_granularity and until_date < (current_date - timedelta(days=1)): real_until_date -= timedelta(days=1) try: if restrict_set: listRecords = client.listRecords( metadataPrefix=format.name, from_=start_date, until=real_until_date, set=restrict_set) else: listRecords = client.listRecords( metadataPrefix=format.name, from_=start_date, until=real_until_date) except NoRecordsMatchError: listRecords = [] saveRecordList(source, format, listRecords) source.last_update = make_aware(min(until_date, current_date), UTC()) source.save() until_date += time_chunk start_date += time_chunk
def resume_request(context, request, queryType, key): token = ResumptionToken.objects.get(queryType=queryType, key=key) if not token: return OaiRequestError("badResumptionToken", "This resumption token is invalid.") parameters = dict() parameters["format"] = token.metadataPrefix if token.set: parameters["sets"] = token.set if token.fro: parameters["timestamp__gte"] = make_naive(token.fro, UTC()) if token.until: parameters["timestamp__lte"] = make_naive(token.until, UTC()) return handle_list_query(request, context, queryType, parameters, token.offset)
def save_extra_sessions(self): data = [] for extra in self.session.orig_sessions.all(): prev = self.get_extra_session(extra.extra.id) data.append( { "session": extra.extra.id, "start": timezone.make_naive(extra.start).strftime(settings.DATETIME_FORMAT), "end": timezone.make_naive(extra.end).strftime(settings.DATETIME_FORMAT), "used": prev["used"] if prev else extra.used, } ) self.set_extra_data("extra_sessions", data)
def _test_datetimes_equality(self, inst, response_dict): ''' Ensures dtstart/dtend objects stored in inst match the serialized versions in response_dict. NOTE: Tastypie's out-of-the-box behavior returns naive ISO- formatted datetimes relative to settings.DATE_TIME. Thus, we have to convert our instance's datetimes first. ''' iso_dtstart = make_naive(inst.dtstart, get_current_timezone()).isoformat() iso_dtend = make_naive(inst.dtend, get_current_timezone()).isoformat() self.assertEquals(iso_dtstart, response_dict.get('dtstart')) self.assertEquals(iso_dtend, response_dict.get('dtend'))
def value_to_db_time(self, value): if value is None: return None if djangoVersion[:2] <= (1, 3): # SQL Anywhere doesn't support tz-aware datetimes if value.tzinfo is not None: raise ValueError("SQL Anywhere backend does not support timezone-aware datetimes.") else: if is_aware(value): make_naive(value, get_default_timezone()) return str(value)
def test_make_naive(self): self.assertEqual( timezone.make_naive(datetime.datetime(2011, 9, 1, 13, 20, 30, tzinfo=EAT), EAT), datetime.datetime(2011, 9, 1, 13, 20, 30) ) self.assertEqual( timezone.make_naive(datetime.datetime(2011, 9, 1, 13, 20, 30, tzinfo=EAT), UTC), datetime.datetime(2011, 9, 1, 10, 20, 30) ) self.assertEqual( timezone.make_naive(datetime.datetime(2011, 9, 1, 10, 20, 30, tzinfo=UTC), UTC), datetime.datetime(2011, 9, 1, 10, 20, 30) )
def get_other_stats(request): if not request.is_ajax(): return JsonResponse({'error': 'Unauthorized access'}, status=401) tracks = get_tracks_from_request(request) if not tracks.exists(): return JsonResponse({}) hours = {} for i in range(24): hours[str(i)] = 0 weekdays = { 0: 'Lundi', 1: 'Mardi', 2: 'Mercredi', 3: 'Jeudi', 4: 'Vendredi', 5: 'Samedi', 6: 'Dimanche' } days = {} for weekday in weekdays.values(): days[weekday] = 0 deltas = [] prev = minimum = maximum = None min_1 = min_2 = max_1 = max_2 = None for track in tracks: dt = make_naive(track.datetime) hours[str(dt.hour)] += 1 days[weekdays[dt.weekday()]] += 1 if prev: # Store the diff between the previous track and this one delta = prev.datetime - track.datetime deltas.append(delta) # Keep min and max with their respective datetime if not minimum or delta < minimum: minimum = delta min_1 = track.datetime min_2 = prev.datetime if not maximum or delta > maximum: maximum = delta max_1 = track.datetime max_2 = prev.datetime prev = track delta_stats = None if deltas: format = '%d/%m/%y %H:%M' delta_stats = { 'deltaMin': format_html('<b>{}</b> <br><small>Entre le {} et le {}</small>', minimum, min_1.strftime(format), min_2.strftime(format)), 'deltaAvg': str(sum(deltas, timedelta(0)) / len(deltas)), 'deltaMax': format_html('<b>{}</b> <br><small>Entre le {} et le {}</small>', maximum, max_1.strftime(format), max_2.strftime(format)) } return JsonResponse({ 'trackByHourChart': { 'labels': list(x + 'h' for x in hours.keys()), 'values': list(hours.values()) }, 'trackByDayChart': { 'labels': list(days.keys()), 'values': list(days.values()) }, 'deltaStats': delta_stats })
def import_registrations(f): """Import registration data from Google Forms csv. Usage f = open('my_data.csv', newline='') import_registrations(f) The date of the last registration is cached in the SIGNUP_IMPORT_LAST_TSTAMP setting to make it safe to repeatedly import the same data without creating duplicate registrations. Input stream should be opened with newline='' or muti-line entries will not be parsed correctly. .. todo:: Pay attention to timezones when parsing dates. See https://docs.djangoproject.com/en/1.11/topics/i18n/timezones/ """ import csv from collections import namedtuple import datetime R = namedtuple('CsvMap', field_names='name') csv_map = { 'tstamp': R('Timestamp', ), 'first_name': R('First Name', ), 'last_name': R('Last Name', ), 'gender': R('Gender', ), # Male, Female 'age': R('Age', ), 'rank': R('Rank', ), 'instructor': R('Instructor', ), 'phone_number': R("Phone number", ), 'email': R(['Email Address', 'Username'], ), 'parent': R('Name of parent or guardian (competitors under 18 years)'), 'events': R('Events', ), 'teammates': R('Teammates for Team Kata'), 'reg_date': R('Timestamp', ), #paid = models.BooleanField(default=False) #paidDate = models.DateField('Date paid', blank=True, null=True) 'notes': R('Notes', ), } #'City': 'Cambridge' #'Name of parent or guardian (competitors under 18 years)': 'Ann Pratt' #'Address': '', 'Postal Code': 'N1R 5J8' #'Province': 'Ontario', 'Email': '', 'Rank': 'Purple (4th kyu)' c = csv.DictReader(f) t_min = config.SIGNUP_IMPORT_LAST_TSTAMP if timezone.is_aware(t_min): t_min = timezone.make_naive(t_min) t_max = t_min added = 0 skipped = 0 line = 1 # Since first row is header for row in c: line += 1 err_str = " while parsing line {}:\n{}".format(line, row) # Parse datestamp. tstamp = dateutil.parser.parse(row[csv_map['tstamp'].name]) if timezone.is_aware(tstamp): tstamp = timezone.make_naive(tstamp) if tstamp <= t_min: skipped += 1 continue t_max = max(t_max, tstamp) p = Person() events = [] for (field, field_info) in csv_map.items(): found = False field_names = field_info.name if isinstance(field_names, str): field_names = [field_names] for fn in field_names: if fn in row: v = row[fn] found = True break if not found: if field in ('teammates', ): continue else: raise ValueError('Unable to find ' + field_info.name + err_str) if field == 'rank': v = Rank.parse(v) elif field == 'events': # Delimiter used to be ", ", now ":" if ';' in v: v = v.split(';') else: v = v.split(", ") events = [Event.objects.get(name=e) for e in v] continue elif field == 'reg_date': v = tstamp elif field == 'gender': if v == 'Male': v = 'M' elif v == 'Female': v = 'F' else: raise ValueError("Unexpected gender {}{}".format( v, err_str)) else: pass setattr(p, field, v) try: p.full_clean() except ValidationError as e: raise ValueError("Validation error{}:\n{}".format(err_str, e)) p.save() for e in events: el = EventLink(person=p, event=e) el.update_division() el.save() added += 1 config.SIGNUP_IMPORT_LAST_TSTAMP = t_max return {"added": added, "skipped": skipped}
def event_date(self, obj): event_date = timezone.make_naive(obj.start) return _date(event_date, "l d b Y, G:i")
def _fix_value(value): if isinstance(value, datetime.datetime): if timezone.is_aware(value): value = timezone.make_naive(value, timezone.utc) return value
def get_minute(self, instance): return make_naive(instance.value).strftime(r'%M')
def get_hour(self, instance): return make_naive(instance.value).strftime(r'%H')
def get_day(self, instance): return make_naive(instance.value).strftime(r'%d')
def get_month(self, instance): return make_naive(instance.value).strftime(r'%m')
def modified_time(self, name): return make_naive(self.meta(name)["LastModified"], utc)
def get_modified_time(self, name): timestamp = self.meta(name)["LastModified"] return timestamp if settings.USE_TZ else make_naive(timestamp)
def __str__(self): return str(make_naive(self.value))
def modified_time(self, name): """Returns a naive datetime object containing the last modified time.""" # If USE_TZ=False then get_modified_time will return a naive datetime # so we just return that, else we have to localize and strip the tz mtime = self.get_modified_time(name) return mtime if is_naive(mtime) else make_naive(mtime)
def modified_time(self, name): name = self._normalize_name(clean_name(name)) blob = self._get_blob(self._encode_name(name)) return timezone.make_naive(blob.updated)
def set_value(self, value): """ Sets the parameter value, converting into the appropriate data type. Deals with date/time strings that are timezone naive or aware, based on the USE_TZ setting. :param value: a string (or string-like) representing the value :return: """ if self.name.isNumeric(): self.numerical_value = float(value) elif self.name.isDateTime(): # We convert the value string into datetime object. # dateutil.parser detects and converts many date formats and is # quite permissive in what it accepts (form validation and API # input validation happens elsewhere and may be less permissive) datevalue = dateutil.parser.parse(value) if settings.USE_TZ and is_naive(datevalue): datevalue = make_aware(datevalue, LOCAL_TZ) elif not settings.USE_TZ and is_aware(datevalue): datevalue = make_naive(datevalue, LOCAL_TZ) self.datetime_value = datevalue elif self.name.isLink(): # Always store the raw value as a string, even if setting # the GenericForeignKey via link_id/link_ct if str(value) == '' or value is None: return self.string_value = unicode(value) try: # We detect experiment or dataset view URLs # (eg, /experiment/view/12345/ or /api/v1/dataset/456) # and extract values to populate link_ct and link_id. This # covers two common cases, allowing LINK Parameters to be # properly created via the REST API. match = resolve(value) if match.view_name == u'api_dispatch_detail': model_name = match.kwargs.get(u'resource_name', None) if model_name not in ('experiment', 'dataset'): model_name, pk = None, None else: pk = match.kwargs.get('pk', None) elif match.view_name.endswith('view_experiment'): model_name = 'experiment' pk = match.kwargs.get('experiment_id') elif match.view_name.endswith('view_dataset'): model_name = 'dataset' pk = match.kwargs.get('dataset_id') else: model_name, pk = None, None if pk is not None and model_name is not None: self.link_id = pk self.link_ct = ContentType.objects.get( app_label='tardis_portal', model=model_name.lower()) except (ValueError, IndexError, Resolver404): # If we were unable to successfully match the url to model # instance, return an error. For any URL the URL Parameter # type should be used. raise SuspiciousOperation('Link parameter could not be set ' 'from string: %s' % str(value)) else: self.string_value = unicode(value)
def localize_datetime(self, val): if val is not None: event_tz = pytz.timezone(self.tz) return timezone.make_naive(val.astimezone(event_tz), event_tz) else: return None
def value_clean(value, options={}): "Takes a value and cleans it up (so e.g. it has timezone working right)" # Lazy-eval functions get eval'd. if isinstance(value, Promise): value = text_type(value) # Callables get called. if not options.get('is_django_function', False) and callable(value) and not isinstance(value, ModelBase): # Datetime.datetime.now is special, as we can access it from the eval # context (and because it changes all the time; people will file bugs otherwise). if value == datetime.datetime.now: return "datetime.datetime.now" elif value == datetime.datetime.utcnow: return "datetime.datetime.utcnow" elif value == datetime.date.today: return "datetime.date.today" # In case we use Django's own now function, revert to datetime's # original one since we'll deal with timezones on our own. elif timezone and value == timezone.now: return "datetime.datetime.now" # All other callables get called. value = value() # Models get their own special repr() if isinstance(value, ModelBase): # If it's a proxy model, follow it back to its non-proxy parent if getattr(value._meta, "proxy", False): value = value._meta.proxy_for_model return "orm['%s.%s']" % (value._meta.app_label, value._meta.object_name) # As do model instances if isinstance(value, Model): if options.get("ignore_dynamics", False): raise IsDefault return "orm['%s.%s'].objects.get(pk=%r)" % (value.__class__._meta.app_label, value.__class__._meta.object_name, value.pk) # Make sure Decimal is converted down into a string if isinstance(value, decimal.Decimal): value = str(value) # in case the value is timezone aware datetime_types = ( datetime.datetime, datetime.time, datetime_safe.datetime, ) if (timezone and isinstance(value, datetime_types) and getattr(settings, 'USE_TZ', False) and value is not None and timezone.is_aware(value)): default_timezone = timezone.get_default_timezone() value = timezone.make_naive(value, default_timezone) # datetime_safe has an improper repr value if isinstance(value, datetime_safe.datetime): value = datetime.datetime(*value.utctimetuple()[:7]) # converting a date value to a datetime to be able to handle # timezones later gracefully elif isinstance(value, (datetime.date, datetime_safe.date)): value = datetime.datetime(*value.timetuple()[:3]) # Now, apply the converter func if there is one if "converter" in options: value = options['converter'](value) # Return the final value if options.get('is_django_function', False): return value else: return repr(value)
def get_modified_time(self, name): name = self._normalize_name(clean_name(name)) blob = self._get_blob(name) updated = blob.updated return updated if setting('USE_TZ') else timezone.make_naive(updated)
def test_make_naive_no_tz(self): self.assertEqual( timezone.make_naive( datetime.datetime(2011, 9, 1, 13, 20, 30, tzinfo=EAT)), datetime.datetime(2011, 9, 1, 5, 20, 30))
def _make_naive(value): if settings.USE_TZ and timezone.is_aware(value): default_timezone = timezone.get_default_timezone() value = timezone.make_naive(value, default_timezone) return value
from django.utils import timezone t = timezone.get_current_timezone() for s in Sleep.objects.all(): if timezone.is_aware(s.start_time): s.start_time = timezone.make_naive(s.start_time, t) if timezone.is_aware(s.end_time): s.end_time = timezone.make_naive(s.end_time,t) s.save()
def get_json_data(self): q = {'event_type': self.event_type.value} try: # filter out old entries date_from = int(self.request.GET['from'] ) + 1 # offset because of timestamp rounding q['date_created__gt'] = timezone.make_aware( datetime.datetime.fromtimestamp(date_from), timezone.utc) except (ValueError, KeyError): pass contestant = self.object try: latest_date = contestant.corrections.filter( event_type=self.event_type.value).latest().date_created_utc except contest.models.ContestantCorrection.DoesNotExist: latest_date = None # we order by date_created *asc* as it will be *prepended* on the frontend corrections_qs = contestant.corrections.select_related( 'author').filter(**q).order_by('date_created').distinct() corr_tpl = get_template('correction/chunk-correction.html') corrections = [ corr_tpl.render({'corr': corr}) for corr in corrections_qs ] changes = {} latest_correction = corrections_qs.last() if latest_correction and latest_correction.changes: changes = latest_correction.changes # presence, through redis online_users = [self.request.user] online_alive = False try: self_pk = self.request.user.pk timeout = settings.CORRECTION_LIVE_UPDATE_TIMEOUT now = timezone.make_naive(timezone.now(), timezone.utc).timestamp() moments_ago = now - timeout key = settings.CORRECTION_LIVE_UPDATE_REDIS_KEY.format( key=contestant.pk) client = StrictRedis(**settings.PROLOGIN_UTILITY_REDIS_STORE) client.expire( key, timeout * 2 ) # garbage collect the whole set after a bit if no further updates client.zadd(key, {self_pk: now}) # add self to the set members = client.zrangebyscore( key, moments_ago, '+inf') # list people that are recent enough members = set(int(pk) for pk in members) - {self_pk} # exclude self online_users.extend( User.objects.filter(pk__in=members).order_by('pk')) online_alive = True except Exception: # it's not worth trying harder pass user_tpl = get_template('correction/chunk-online-user.html') online_users = [(user.pk, user_tpl.render({'user': user})) for user in online_users] return { 'changes': changes, 'corrections': corrections, 'online': online_users, 'online_alive': online_alive, 'from': latest_date, 'delay': 1000 * settings.CORRECTION_LIVE_UPDATE_POLL_INTERVAL, }
def activity_time(self): atime = self.created_at if is_aware(self.created_at): atime = make_naive(atime, pytz.utc) return atime
def get_initial(self): return {'publish_at': make_naive(self.object.publish_at)\ .strftime(BROWSER_DATETIME_FORMAT)}
def modified_time(self, name): """Returns a naive datetime object containing the last modified time.""" mtime = self.get_modified_time(name) if timezone.is_naive(mtime): return mtime return timezone.make_naive(mtime)
def make_naive(value): if getattr(settings, "USE_TZ", False): default_tz = timezone.get_default_timezone() value = timezone.make_naive(value, default_tz) return value
def get_modified_time(self, name): dt = tz.make_aware(parse_ts(self._get_key(name).last_modified), tz.utc) return dt if setting('USE_TZ') else tz.make_naive(dt)
def details(request, id): event = get_object_or_404(SuggestedEvent, pk=id) if event.user != request.user: return http.HttpResponseBadRequest('Not your event') try: discussion = SuggestedDiscussion.objects.get(event=event) except SuggestedDiscussion.DoesNotExist: discussion = None if request.method == 'POST': form = forms.DetailsForm(request.POST, instance=event) if form.is_valid(): event = form.save() # the start_time comes to us as a string, e.g. '2014-01-01 # 12:00:00' and that'll be converted into '2014-01-01 # 12:00:00 tzinfo=UTC' automatically. But that's not what we want # so we change it first. event.start_time = tz_apply(event.start_time, pytz.timezone(event.location.timezone)) event.save() next_url = reverse('suggest:placeholder', args=(event.pk, )) if form.cleaned_data['enable_discussion']: if discussion: # make sure it's enabled discussion.enabled = True # discussion.moderate_all = ( # event.privacy != Event.PRIVACY_COMPANY # ) discussion.save() else: discussion = SuggestedDiscussion.objects.create( event=event, enabled=True, notify_all=True, # moderate_all=event.privacy != Event.PRIVACY_COMPANY ) if request.user not in discussion.moderators.all(): discussion.moderators.add(request.user) next_url = reverse('suggest:discussion', args=(event.pk, )) elif SuggestedDiscussion.objects.filter(event=event): discussion = SuggestedDiscussion.objects.get(event=event) discussion.enabled = False discussion.save() return redirect(next_url) else: if event.location and event.start_time: # Because the modelform is going present our user # without input widgets' that are datetimes in # naive format, when it does this is does so using the # settings.TIME_ZONE and when saved it applies the # settings.TIME_ZONE back again. # Normally in Django templates, this is solved with # {% timezone "Europe/Paris" %} # {{ form.as_p }} # {% endtimezone %} # But that's not going to work when working with jinja # so we do it manually from the view code. event.start_time = make_naive( event.start_time, pytz.timezone(event.location.timezone)) initial = {'enable_discussion': not (event and not discussion)} form = forms.DetailsForm(instance=event, initial=initial) data = {'form': form, 'event': event} return render(request, 'suggest/details.html', data)
def modified_time(self, name): dt = tz.make_aware(parse_ts(self._get_key(name).last_modified), tz.utc) return tz.make_naive(dt)
def date_time_format_form(datetime_var): return str( datetime.datetime.strftime( make_naive(datetime_var, get_default_timezone()), "%d de %B de %Y a las %I:%M %p"))