def _sqlite_format_dtdelta(conn, lhs, rhs): """ LHS and RHS can be either: - An integer number of microseconds - A string representing a timedelta object - A string representing a datetime """ try: if isinstance(lhs, six.integer_types): lhs = str(decimal.Decimal(lhs) / decimal.Decimal(1000000)) real_lhs = parse_duration(lhs) if real_lhs is None: real_lhs = backend_utils.typecast_timestamp(lhs) if isinstance(rhs, six.integer_types): rhs = str(decimal.Decimal(rhs) / decimal.Decimal(1000000)) real_rhs = parse_duration(rhs) if real_rhs is None: real_rhs = backend_utils.typecast_timestamp(rhs) if conn.strip() == '+': out = real_lhs + real_rhs else: out = real_lhs - real_rhs except (ValueError, TypeError): return None # typecast_timestamp returns a date or a datetime without timezone. # It will be formatted as "%Y-%m-%d" or "%Y-%m-%d %H:%M:%S[.%f]" return str(out)
def check15min(): global i i = 0 query = Tracking.objects.values('nome_ativo').distinct() for nome in query: ativo = Ativo(nome_ativo=nome['nome_ativo'], valor=si.get_live_price(nome['nome_ativo'])) ativo.save() trackings2 = list() trackings3 = list() trackings1 = Tracking.objects.all().filter( nome_ativo=ativo.nome_ativo, periodicidade=parse_duration('00:15:00')) if i % 2 == 0: trackings2 = Tracking.objects.all().filter( nome_ativo=ativo.nome_ativo, periodicidade=parse_duration('00:30:00')) if i % 3 == 0: trackings3 = Tracking.objects.all().filter( nome_ativo=ativo.nome_ativo, periodicidade=parse_duration('00:45:00')) trackings = list(chain(trackings1, trackings2, trackings3)) for tracking in trackings: if tracking.upper_bound < ativo.valor: upper_bound_trigger(tracking.user, ativo.nome_ativo) elif tracking.lower_bound > ativo.valor: lower_bound_trigger(tracking.user, ativo.nome_ativo) i = i + 1
def test_hours_minutes_seconds(self): self.assertEqual(parse_duration('10:15:30'), timedelta(hours=10, minutes=15, seconds=30)) self.assertEqual(parse_duration('1:15:30'), timedelta(hours=1, minutes=15, seconds=30)) self.assertEqual(parse_duration('100:200:300'), timedelta(hours=100, minutes=200, seconds=300))
def _timestamps_for_tweets(conference, starttime, interval, randint, num): if isinstance(starttime, datetime.datetime): t = starttime else: t = parse_datetime(starttime) if not timezone.is_aware(t): t = timezone.make_aware(t, conference.tzobj) if isinstance(interval, datetime.time): ival = datetime.timedelta(hours=interval.hour, minutes=interval.minute, seconds=interval.second) else: ival = parse_duration(interval) if isinstance(randint, datetime.time): rsec = datetime.timedelta(hours=randint.hour, minutes=randint.minute, seconds=randint.second).total_seconds() else: rsec = parse_duration(randint).total_seconds() for i in range(num): yield t t += ival t += datetime.timedelta(seconds=rsec * random.random()) if t.time() > conference.twitter_timewindow_end: # Past the end of the day, so move it to the start time the next day t = timezone.make_aware( datetime.datetime.combine(t + datetime.timedelta(days=1), conference.twitter_timewindow_start), conference.tzobj, )
def test_days(self): self.assertEqual(parse_duration("4 15:30"), timedelta(days=4, minutes=15, seconds=30)) self.assertEqual( parse_duration("4 10:15:30"), timedelta(days=4, hours=10, minutes=15, seconds=30), )
def _sqlite_format_dtdelta(conn, lhs, rhs): """ LHS and RHS can be either: - An integer number of microseconds - A string representing a timedelta object - A string representing a datetime """ try: if isinstance(lhs, int): lhs = str(decimal.Decimal(lhs) / decimal.Decimal(1000000)) real_lhs = parse_duration(lhs) if real_lhs is None: real_lhs = backend_utils.typecast_timestamp(lhs) if isinstance(rhs, int): rhs = str(decimal.Decimal(rhs) / decimal.Decimal(1000000)) real_rhs = parse_duration(rhs) if real_rhs is None: real_rhs = backend_utils.typecast_timestamp(rhs) if conn.strip() == '+': out = real_lhs + real_rhs else: out = real_lhs - real_rhs except (ValueError, TypeError): return None # typecast_timestamp returns a date or a datetime without timezone. # It will be formatted as "%Y-%m-%d" or "%Y-%m-%d %H:%M:%S[.%f]" return str(out)
def _timestamps_for_tweets(conference, starttime, interval, randint, num): if isinstance(starttime, datetime.datetime): t = starttime else: t = parse_datetime(starttime) if isinstance(interval, datetime.time): ival = datetime.timedelta(hours=interval.hour, minutes=interval.minute, seconds=interval.second) else: ival = parse_duration(interval) if isinstance(randint, datetime.time): rsec = datetime.timedelta(hours=randint.hour, minutes=randint.minute, seconds=randint.second).total_seconds() else: rsec = parse_duration(randint).total_seconds() for i in range(num): yield t t += ival t += datetime.timedelta(seconds=rsec * random.random()) if t.time() > conference.twitter_timewindow_end: t = datetime.datetime.combine( t.date() + datetime.timedelta(days=1), conference.twitter_timewindow_start)
def test_negative(self): self.assertEqual(parse_duration('-4 15:30'), timedelta(days=-4, minutes=15, seconds=30)) self.assertEqual(parse_duration('-172800'), timedelta(days=-2)) self.assertEqual(parse_duration('-15:30'), timedelta(minutes=-15, seconds=30)) self.assertEqual(parse_duration('-1:15:30'), timedelta(hours=-1, minutes=15, seconds=30)) self.assertEqual(parse_duration('-30.1'), timedelta(seconds=-30, milliseconds=-100))
def parse_duration(self, value): value = value.lstrip('+') duration = parse_duration(value) if duration is None: if not ',' in value: # django parse_duration requires 'x days, S' duration = parse_duration(value + ', 0') if duration is None: raise ValueError("Could not parse %s" % value) return duration
def test_iso_8601(self): self.assertIsNone(parse_duration('P4Y')) self.assertIsNone(parse_duration('P4M')) self.assertIsNone(parse_duration('P4W')) self.assertEqual(parse_duration('P4D'), timedelta(days=4)) self.assertEqual(parse_duration('P0.5D'), timedelta(hours=12)) self.assertEqual(parse_duration('PT5H'), timedelta(hours=5)) self.assertEqual(parse_duration('PT5M'), timedelta(minutes=5)) self.assertEqual(parse_duration('PT5S'), timedelta(seconds=5)) self.assertEqual(parse_duration('PT0.000005S'), timedelta(microseconds=5))
def test_iso_8601(self): self.assertEqual(parse_duration('P4Y'), None) self.assertEqual(parse_duration('P4M'), None) self.assertEqual(parse_duration('P4W'), None) self.assertEqual(parse_duration('P4D'), timedelta(days=4)) self.assertEqual(parse_duration('P0.5D'), timedelta(hours=12)) self.assertEqual(parse_duration('PT5H'), timedelta(hours=5)) self.assertEqual(parse_duration('PT5M'), timedelta(minutes=5)) self.assertEqual(parse_duration('PT5S'), timedelta(seconds=5)) self.assertEqual(parse_duration('PT0.000005S'), timedelta(microseconds=5))
def __init__(self, element): self.id = element.attrib.get('id') self.journeypatterntiminglinkref = element.find('JourneyPatternTimingLinkRef').text self.run_time = element.find('RunTime') if self.run_time is not None: self.run_time = parse_duration(self.run_time.text) self.from_wait_time = element.find('From/WaitTime') if self.from_wait_time is not None: self.from_wait_time = parse_duration(self.from_wait_time.text) self.to_wait_time = element.find('To/WaitTime') if self.to_wait_time is not None: self.to_wait_time = parse_duration(self.to_wait_time.text)
def test_iso_8601(self): test_values = ( ("P4Y", None), ("P4M", None), ("P4W", None), ("P4D", timedelta(days=4)), ("-P1D", timedelta(days=-1)), ("P0.5D", timedelta(hours=12)), ("P0,5D", timedelta(hours=12)), ("-P0.5D", timedelta(hours=-12)), ("-P0,5D", timedelta(hours=-12)), ("PT5H", timedelta(hours=5)), ("-PT5H", timedelta(hours=-5)), ("PT5M", timedelta(minutes=5)), ("-PT5M", timedelta(minutes=-5)), ("PT5S", timedelta(seconds=5)), ("-PT5S", timedelta(seconds=-5)), ("PT0.000005S", timedelta(microseconds=5)), ("PT0,000005S", timedelta(microseconds=5)), ("-PT0.000005S", timedelta(microseconds=-5)), ("-PT0,000005S", timedelta(microseconds=-5)), ("-P4DT1H", timedelta(days=-4, hours=-1)), # Invalid separators for decimal fractions. ("P3(3D", None), ("PT3)3H", None), ("PT3|3M", None), ("PT3/3S", None), ) for source, expected in test_values: with self.subTest(source=source): self.assertEqual(parse_duration(source), expected)
def _get_or_create_track(track_dict, artist_dict): track_name = track_dict["name"].strip() main_artists, feat_artists = get_track_artists(track_dict["artist"], artist_dict) db_tracks = Track.objects.filter(name=track_name) if db_tracks: track_artists_ids = {a.id for a in (main_artists + feat_artists)} for track in db_tracks: db_track_set_id = {a.id for a in track.artists} if db_track_set_id == track_artists_ids: # This is a duplicate track. return created=False, track return False, track duration_str = track_dict["duration"].strip() duration = parse_duration(duration_str) if duration is None: raise ValueError("Could not parse duration - '{}'n found in {}".format( duration_str, track_dict)) track = Track.objects.create( name=track_name, duration=duration, released_year=track_dict["released_year"], ) track.artist.add(*main_artists) if feat_artists: track.featuring.add(*feat_artists) track.save() # return created=True, track return True, track
def addAtivos(request): if request.method == 'GET': form = FormsAddAtivo() return render(request, 'addAtivos.html', {'form': form}) else: form = FormsAddAtivo(request.POST) print(request.user) if form.is_valid(): nome_ativo = form.cleaned_data.get('nome_ativo') + '.SA' periodicidade = parse_duration( form.cleaned_data.get('periodicidade')) upper_bound = form.cleaned_data.get('upper_bound') lower_bound = form.cleaned_data.get('lower_bound') ativo = Tracking(user=request.user, nome_ativo=nome_ativo, periodicidade=periodicidade, upper_bound=upper_bound, lower_bound=lower_bound) ativo.save() return redirect('homePage') else: ctx = {} return render( request, 'addAtivos.html', )
def __init__(self, element, stops): self.origin = JourneyPatternStopUsage(element.find('txc:From', NS), stops) self.destination = JourneyPatternStopUsage(element.find('txc:To', NS), stops) self.origin.parent = self.destination.parent = self self.runtime = parse_duration(element.find('txc:RunTime', NS).text) self.id = element.get('id') if self.id: if self.id.startswith( 'JPL_21-9-A-y08-1'): # Carters Coaches North Elmham stop self.replace_atco_code('2900E074', '2900E0714', stops) elif self.id.startswith( 'JPL_8-229-B-y11-1-'): # Ensignbus Snitterfield self.replace_atco_code('4200F063300', '4200F147412', stops) elif self.id.startswith( 'JPL_18-X52-_-y08-1-2-R'): # Notts & Derby Alton Towers self.replace_atco_code('3390S9', '3390S10', stops) elif self.id.startswith( 'JPL_4-X52-_-y11-1-'): # Notts & Derby Alton Towers self.replace_atco_code('3390BB01', '3390S10', stops) elif self.id.startswith('JPTL'): if self.origin.sequencenumber == 1 or self.origin.sequencenumber == 66: # x1-ruthin-chester-via-mold self.replace_atco_code('0610CH19065', '0610CH2395', stops)
def get_tracks(self) -> Tuple[Iterable[Track], int]: qs = self.get_base_queryset() if self.kwargs.get('mode') == 'pro': qs = self.pro_queryset(qs) elif self.kwargs.get('mode') == 'hipster': qs = qs.filter(play=None) elif self.kwargs.get('mode') == 'almost-100': qs = qs.exclude( play__date__gt=Show.current().end - datetime.timedelta(days=(7 * 80)), ).exclude(play=None) elif self.kwargs.get('mode') == 'decade': qs = qs.for_decade( int(self.kwargs.get('decade', self.default_decade))) elif self.kwargs.get('mode') == 'staple': # Staple track: having been played more than once per year(ish) # since the track was made available. Exclude tracks that don't # yet have enough plays to be reasonably called a "staple". qs = (qs.annotate(plays=Count('play')).filter( plays__gt=2).annotate(time_per_play=Cast( ((Now() - F('revealed')) / F('plays')), output_field=DurationField())).filter( time_per_play__lt=parse_duration('365 days'))) # order_by('?') fails when annotate() has been used return (sample(list(qs), 5), qs.count()) elif self.kwargs.get('mode') == 'short': length_msec = int( self.kwargs.get('minutes', self.default_minutes_count)) * 60 * 1000 qs = qs.filter(msec__gt=length_msec - 60_000, msec__lte=length_msec) return (qs.order_by('?')[:5], qs.count())
def test_get_play_duration(self): started = timezone.now() ended = started + datetime.timedelta(hours=1) play = factories.PlayFactory(started=started, ended=ended) request = self.client.get("/api/v1/plays/%s" % play.id) self.assertEqual(parse_duration(request.data["duration"]), ended - started)
def create(values): """ .. function:: XML-RPC TestRun.create(values) Create new TestRun object and store it in the database. :param values: Field values for :class:`tcms.testruns.models.TestRun` :type values: dict :return: Serialized :class:`tcms.testruns.models.TestRun` object :raises: PermissionDenied if missing *testruns.add_testrun* permission :raises: ValueError if data validations fail Example:: values = {'build': 384, 'manager': 137, 'plan': 137, 'product': 61, 'product_version': 93, 'summary': 'Testing XML-RPC for TCMS', } TestRun.create(values) """ if not values.get('product'): raise ValueError('Value of product is required') # TODO: XMLRPC only accept HH:MM:SS rather than DdHhMm if values.get('estimated_time'): values['estimated_time'] = parse_duration( values.get('estimated_time')) form = XMLRPCNewRunForm(values) form.populate(product_id=values['product']) if form.is_valid(): test_run = TestRun.objects.create( product_version=form.cleaned_data['product_version'], plan_text_version=form.cleaned_data['plan_text_version'], stop_date=form.cleaned_data['status'] and datetime.now() or None, summary=form.cleaned_data['summary'], notes=form.cleaned_data['notes'], estimated_time=form.cleaned_data['estimated_time'], plan=form.cleaned_data['plan'], build=form.cleaned_data['build'], manager=form.cleaned_data['manager'], default_tester=form.cleaned_data['default_tester'], ) if form.cleaned_data['tag']: tag_names = form.cleaned_data['tag'] if isinstance(tag_names, str): tag_names = [c.strip() for c in tag_names.split(',') if c] for tag_name in tag_names: tag, _ = Tag.objects.get_or_create(name=tag_name) test_run.add_tag(tag=tag) else: raise ValueError(form_errors_to_list(form)) return test_run.serialize()
def edit(request, pk): user = request.user if not_joined_family(user): return redirect('home') if request.method == 'POST': record = FitnessRecord.objects.get(pk=pk) old_calories = record.calories old_duration = record.duration form = FitnessRecordForm(request.POST, instance=record) if form.is_valid(): category = request.POST.get('category') calories = int(request.POST.get('calories')) duration = dateparse.parse_duration(request.POST.get('duration')) difference_calories = calories - old_calories difference_duration = duration - old_duration record.category = category record.calories = calories record.duration = duration record.save() return redirect('records') else: record = FitnessRecord.objects.get(pk=pk) form = FitnessRecordForm(instance=record) context = { 'form': form } return render(request, 'main/edit.html', context)
def get_custom_field_instances(self, form_element_plugin, request=None, form_entry=None, form_element_entries=None, **kwargs): """Get form field instances.""" field_kwargs = { 'required': form_element_plugin.data.required, # 'initial': form_element_plugin.data.initial, 'label': form_element_plugin.data.label, 'help_text': form_element_plugin.data.help_text, } if form_element_plugin.data.initial: data_initial = force_text(form_element_plugin.data.initial) if not isinstance(data_initial, datetime.timedelta): parsed_initial = parse_duration(data_initial) if parsed_initial is not None: data_initial = parsed_initial field_kwargs.update({'initial': data_initial}) field_metadata = { 'placeholder': form_element_plugin.data.placeholder } return [ DRFIntegrationFormElementPluginProcessor( field_class=DurationField, field_kwargs=field_kwargs, field_metadata=field_metadata ) ]
def add(self, request, pk): """ --- method_path: /groups/{id}/add/ method_action: POST desc: Adicionar conteúdo no grupo. input: - name: media desc: Id da mídia. type: integer required: True location: form - name: duration desc: Duração da exibição type: str required: True location: form """ group = self.get_object() media_pk, duration = get_fields(request.data, ['media', 'duration']) media = get_object_or_404(Media, pk=media_pk) content = Content.objects.create( media=media, duration=dateparse.parse_duration(duration), group=group, order=group.group_contents.count() + 1) Log.objects.create(user=request.user, action='create', content_object=content) serializer = ContentSerializer(content) return Response(serializer.data)
def test_get_task_duration(self): started = timezone.now() ended = started + datetime.timedelta(hours=1) task = factories.TaskFactory(started=started, ended=ended) request = self.client.get("/api/v1/tasks/%s" % task.id) self.assertEqual(parse_duration(request.data["duration"]), ended - started)
def insert(request): timestamp = datetime.fromtimestamp(int(request.POST["timestamp"])) duration = parse_duration(request.POST["duration"]) clip = Clip(timestamp=timestamp, anomaly=request.POST["anomaly"], duration=duration, file_name=request.POST["filename"]) clip.save() return HttpResponse('Inserted')
def get_custom_field_instances(self, form_element_plugin, request=None, form_entry=None, form_element_entries=None, **kwargs): """Get form field instances.""" field_kwargs = { 'required': form_element_plugin.data.required, # 'initial': form_element_plugin.data.initial, 'label': form_element_plugin.data.label, 'help_text': form_element_plugin.data.help_text, } if form_element_plugin.data.initial: data_initial = force_text(form_element_plugin.data.initial) if not isinstance(data_initial, datetime.timedelta): parsed_initial = parse_duration(data_initial) if parsed_initial is not None: data_initial = parsed_initial field_kwargs.update({'initial': data_initial}) field_metadata = {'placeholder': form_element_plugin.data.placeholder} return [ DRFIntegrationFormElementPluginProcessor( field_class=DurationField, field_kwargs=field_kwargs, field_metadata=field_metadata) ]
def _parse(value, choices): if value.count(":") == 1: value += ":0" res = dateparse.parse_duration(value) assert res is not None, "Duration value should be 'DD HH:MM:SS'" return res
def test_microseconds(self): duration = datetime.timedelta(hours=1, minutes=3, seconds=5, microseconds=12345) self.assertEqual(parse_duration(duration_iso_string(duration)), duration)
def test_schedule_item_full_length(self): music_dir = baker.make( "libretime_api.MusicDir", directory=os.path.join(os.path.dirname(__file__), "resources"), ) f = baker.make( "libretime_api.File", directory=music_dir, mime="audio/mp3", filepath="song.mp3", length=timedelta(seconds=40.86), cuein=timedelta(seconds=0), cueout=timedelta(seconds=40.8131), ) show = baker.make( "libretime_api.ShowInstance", starts=datetime.now(tz=timezone.utc) - timedelta(minutes=5), ends=datetime.now(tz=timezone.utc) + timedelta(minutes=5), ) scheduleItem = baker.make( "libretime_api.Schedule", starts=datetime.now(tz=timezone.utc), ends=datetime.now(tz=timezone.utc) + f.length, cue_out=f.cueout, instance=show, file=f, ) self.client.credentials(HTTP_AUTHORIZATION=f"Api-Key {self.token}") response = self.client.get(self.path) self.assertEqual(response.status_code, 200) result = response.json() self.assertEqual(dateparse.parse_datetime(result[0]["ends"]), scheduleItem.ends) self.assertEqual(dateparse.parse_duration(result[0]["cue_out"]), f.cueout)
def test_iso_8601(self): test_values = ( ('P4Y', None), ('P4M', None), ('P4W', None), ('P4D', timedelta(days=4)), ('-P1D', timedelta(days=-1)), ('P0.5D', timedelta(hours=12)), ('P0,5D', timedelta(hours=12)), ('-P0.5D', timedelta(hours=-12)), ('-P0,5D', timedelta(hours=-12)), ('PT5H', timedelta(hours=5)), ('-PT5H', timedelta(hours=-5)), ('PT5M', timedelta(minutes=5)), ('-PT5M', timedelta(minutes=-5)), ('PT5S', timedelta(seconds=5)), ('-PT5S', timedelta(seconds=-5)), ('PT0.000005S', timedelta(microseconds=5)), ('PT0,000005S', timedelta(microseconds=5)), ('-PT0.000005S', timedelta(microseconds=-5)), ('-PT0,000005S', timedelta(microseconds=-5)), ('-P4DT1H', timedelta(days=-4, hours=-1)), # Invalid separators for decimal fractions. ('P3(3D', None), ('PT3)3H', None), ('PT3|3M', None), ('PT3/3S', None), ) for source, expected in test_values: with self.subTest(source=source): self.assertEqual(parse_duration(source), expected)
def test_schedule_item_full_length(self): music_dir = baker.make( "storage.MusicDir", directory=str(fixture_path), ) file = baker.make( "storage.File", directory=music_dir, mime="audio/mp3", filepath=AUDIO_FILENAME, length=timedelta(seconds=40.86), cuein=timedelta(seconds=0), cueout=timedelta(seconds=40.8131), ) show = baker.make( "schedule.ShowInstance", starts=datetime.now(tz=timezone.utc) - timedelta(minutes=5), ends=datetime.now(tz=timezone.utc) + timedelta(minutes=5), ) schedule_item = baker.make( "schedule.Schedule", starts=datetime.now(tz=timezone.utc), ends=datetime.now(tz=timezone.utc) + file.length, cue_out=file.cueout, instance=show, file=file, ) self.client.credentials(HTTP_AUTHORIZATION=f"Api-Key {self.token}") response = self.client.get(self.path) self.assertEqual(response.status_code, 200) result = response.json() self.assertEqual(dateparse.parse_datetime(result[0]["ends"]), schedule_item.ends) self.assertEqual(dateparse.parse_duration(result[0]["cue_out"]), file.cueout)
def parse(self, response): stop = response.meta['stop'] action = response.meta['action'] string = response.body.decode('gbk') string = re.match(r'^\s+(\S+)\s+$', string) if not string: self.logger.warning( "scrape %s of %s error, result is empty, can't extract prompt string" % (stop.train.name, stop.station.name)) return string = string.group(1) (status, result) = self.parseStr(string) # Result corrections - support for cross-day delays. if result: scheduledTime = stop.scheduledStop[ 'departureTime'] if action is models.TrainAction.Departure else stop.scheduledStop[ 'arrivalTime'] scheduledTime = parse_duration(scheduledTime) result += datetime.timedelta(days=scheduledTime.days) diff = scheduledTime - result if diff > datetime.timedelta(hours=4): result += datetime.timedelta(days=1) elif diff < -datetime.timedelta(hours=4): result -= datetime.timedelta(days=1) if status is self.TrainStatus.Actual: stop.update(action, result, False) elif status is self.TrainStatus.Anticipated: stop.update(action, result, True) elif status is self.TrainStatus.TimeNotInRange or status is self.TrainStatus.NotImplemented: stop.update(action=action, anticipated=None) else: self.logger.info(string)
def test_get_result_duration(self): started = timezone.now() ended = started + datetime.timedelta(hours=1) result = factories.ResultFactory(started=started, ended=ended) request = self.client.get("/api/v1/results/%s" % result.id) self.assertEqual(parse_duration(request.data["duration"]), ended - started)
def __init__(self, element, stops): self.origin = JourneyPatternStopUsage(element.find('From'), stops) self.destination = JourneyPatternStopUsage(element.find('To'), stops) self.origin.parent = self.destination.parent = self self.runtime = parse_duration(element.find('RunTime').text) self.id = element.get('id') self.route_link_ref = element.findtext('RouteLinkRef')
def clean(self, value, row=None, *args, **kwargs): if not value: return None try: return parse_duration(value) except (ValueError, TypeError): raise ValueError("Enter a valid duration.")
def to_python(self, value): if value in self.empty_values: return None if isinstance(value, datetime.timedelta): return value value = parse_duration(force_text(value)) if value is None: raise ValidationError(self.error_messages['invalid'], code='invalid') return value
def test_negative(self): test_values = ( ('-4 15:30', timedelta(days=-4, minutes=15, seconds=30)), ('-172800', timedelta(days=-2)), ('-15:30', timedelta(minutes=-15, seconds=30)), ('-1:15:30', timedelta(hours=-1, minutes=15, seconds=30)), ('-30.1', timedelta(seconds=-30, milliseconds=-100)), ) for source, expected in test_values: with self.subTest(source=source): self.assertEqual(parse_duration(source), expected)
def clean(self, value, row=None, *args, **kwargs): if not value: return None try: return parse_duration(value) except NameError: # Duration fields were added in Django 1.8 raise RuntimeError("Duration parsing not supported.") except (ValueError, TypeError): raise ValueError("Enter a valid duration.")
def to_python(self, value): if value in self.empty_values: return None if isinstance(value, datetime.timedelta): return value try: value = parse_duration(str(value)) except OverflowError: raise ValidationError(self.error_messages['overflow'], code='overflow') if value is None: raise ValidationError(self.error_messages['invalid'], code='invalid') return value
def test_fractions_of_seconds(self): test_values = ( ('15:30.1', timedelta(minutes=15, seconds=30, milliseconds=100)), ('15:30.01', timedelta(minutes=15, seconds=30, milliseconds=10)), ('15:30.001', timedelta(minutes=15, seconds=30, milliseconds=1)), ('15:30.0001', timedelta(minutes=15, seconds=30, microseconds=100)), ('15:30.00001', timedelta(minutes=15, seconds=30, microseconds=10)), ('15:30.000001', timedelta(minutes=15, seconds=30, microseconds=1)), ) for source, expected in test_values: with self.subTest(source=source): self.assertEqual(parse_duration(source), expected)
def test_parse_python_format(self): timedeltas = [ timedelta(days=4, minutes=15, seconds=30, milliseconds=100), # fractions of seconds timedelta(hours=10, minutes=15, seconds=30), # hours, minutes, seconds timedelta(days=4, minutes=15, seconds=30), # multiple days timedelta(days=1, minutes=00, seconds=00), # single day timedelta(days=-4, minutes=15, seconds=30), # negative durations timedelta(minutes=15, seconds=30), # minute & seconds timedelta(seconds=30), # seconds ] for delta in timedeltas: self.assertEqual(parse_duration(format(delta)), delta)
def test_fractions_of_seconds(self): self.assertEqual(parse_duration('15:30.1'), timedelta(minutes=15, seconds=30, milliseconds=100)) self.assertEqual(parse_duration('15:30.01'), timedelta(minutes=15, seconds=30, milliseconds=10)) self.assertEqual(parse_duration('15:30.001'), timedelta(minutes=15, seconds=30, milliseconds=1)) self.assertEqual(parse_duration('15:30.0001'), timedelta(minutes=15, seconds=30, microseconds=100)) self.assertEqual(parse_duration('15:30.00001'), timedelta(minutes=15, seconds=30, microseconds=10)) self.assertEqual(parse_duration('15:30.000001'), timedelta(minutes=15, seconds=30, microseconds=1))
def test_parse_postgresql_format(self): test_values = ( ('1 day', timedelta(1)), ('1 day 0:00:01', timedelta(days=1, seconds=1)), ('1 day -0:00:01', timedelta(days=1, seconds=-1)), ('-1 day -0:00:01', timedelta(days=-1, seconds=-1)), ('-1 day +0:00:01', timedelta(days=-1, seconds=1)), ('4 days 0:15:30.1', timedelta(days=4, minutes=15, seconds=30, milliseconds=100)), ('4 days 0:15:30.0001', timedelta(days=4, minutes=15, seconds=30, microseconds=100)), ('-4 days -15:00:30', timedelta(days=-4, hours=-15, seconds=-30)), ) for source, expected in test_values: with self.subTest(source=source): self.assertEqual(parse_duration(source), expected)
def handle(self, *args, **options): now = timezone.now() expdate = now - parse_duration(options['exp_time']) self.stdout.write("Now: " + now.isoformat()) self.stdout.write("Exp: " + expdate.isoformat()) expired = Payment.objects.filter(created__lte=expdate, status='new', paid_amount=0) for p in expired: self.stdout.write("Payment #%d (%s): %s" % (p.id, p.user.username, p.created)) if not options['sim']: p.status = 'cancelled' p.save()
def test_iso_8601(self): test_values = ( ('P4Y', None), ('P4M', None), ('P4W', None), ('P4D', timedelta(days=4)), ('P0.5D', timedelta(hours=12)), ('PT5H', timedelta(hours=5)), ('PT5M', timedelta(minutes=5)), ('PT5S', timedelta(seconds=5)), ('PT0.000005S', timedelta(microseconds=5)), ) for source, expected in test_values: with self.subTest(source=source): self.assertEqual(parse_duration(source), expected)
def do_pull(self, subcmd, opts, file, collection): """${cmd_name}: pull image ${cmd_usage} ${cmd_option_list} """ duration = parse_duration(opts.interval) filetype = FileFactory().resolve(file) while True: try: self.client.upload(filetype(file), collection, opts.retention_policy) except Exception as e: if not opts.quite: sys.stderr.write(str(e) + "\n") sys.stderr.flush() time.sleep(duration.total_seconds())
def clean(self): """Validation.""" cleaned_data = super(DurationInputForm, self).clean() initial = cleaned_data.get('initial') if initial not in forms.Field.empty_values: if not isinstance(initial, datetime.timedelta): if parse_duration(force_text(initial)) is None: self.add_error( 'initial', _("Enter a valid duration.") ) else: cleaned_data['initial'] = duration_string(initial) return cleaned_data
def _draw_word(self): if self.current_word() is not None: return self.current_word() from .models import Word, Draw last_draw = self.last_draw() duration = parse_duration(settings.DRAW_TIME) if last_draw is not None \ and (last_draw.accepted is None or last_draw.accepted == True) \ and last_draw.timestamp + duration > timezone.now(): return last_draw.word # Find all words # Exclude all words that has an accepted draw for this user # Choose a random one # If there are no more words, return None if last_draw is not None: last_word = last_draw.word else: last_word = None all_words = Word.objects.exclude(draws__accepted=True, draws__user=self) all_count = all_words.count() # If there are no more words, return None if all_count == 0: return None # If there is only one word, return it, regardless if it’s the # same as the last one if all_count == 1: word = all_words.first() # Otherwise, choose a word different from the last one else: word = last_word while last_word == word: word = all_words.order_by('?').first() Draw.objects.create(user=self, word=word, accepted=None) return word
def to_python(self, value): if value in self.empty_values: return None if isinstance(value, timedelta): return value value = value.strip() if not value: return None # handle values like " " if self.default_units: try: intvalue = int(value) return self.default_units * intvalue except ValueError: pass try: floatvalue = float(value) return timedelta( seconds=floatvalue * self.default_units.total_seconds() ) except ValueError: pass td = parse_duration(value) if td is not None: return td # The default parser got it. Yay. # remove niceties value = re.sub(r'(\.(?!\d)|&|and|,)', " ", value, flags=re.I) td = timedelta() for unit in UNITS: regex = r"((\d+\.\d+)|\d+|(?=\s|\d|\b)a(n(?=\s|\d|\b))?)\s?(" \ + unit \ + r"s?(?=\s|\d|\b))" matches = re.finditer(regex, value, flags=re.I | re.U) for match in matches: td = td + self.to_td(match, unit) value = re.sub(regex, "", value, flags=re.I | re.U) if value.strip(): # there's stuff left. KILL IT raise ValidationError(self.default_error_messages['invalid']) return td
def __init__(self, element, stops): self.origin = JourneyPatternStopUsage(element.find('txc:From', NS), stops) self.destination = JourneyPatternStopUsage(element.find('txc:To', NS), stops) self.origin.parent = self.destination.parent = self self.runtime = parse_duration(element.find('txc:RunTime', NS).text) self.id = element.get('id') if self.id: if self.id.startswith('JPL_21-9-A-y08-1'): # Carters Coaches North Elmham stop self.replace_atco_code('2900E074', '2900E0714', stops) elif self.id.startswith('JPL_8-229-B-y11-1-'): # Ensignbus Snitterfield self.replace_atco_code('4200F063300', '4200F147412', stops) elif self.id.startswith('JPL_18-X52-_-y08-1-2-R'): # Notts & Derby Alton Towers self.replace_atco_code('3390S9', '3390S10', stops) elif self.id.startswith('JPL_4-X52-_-y11-1-'): # Notts & Derby Alton Towers self.replace_atco_code('3390BB01', '3390S10', stops) elif self.id.startswith('JPTL'): if self.origin.sequencenumber == 1 or self.origin.sequencenumber == 66: # x1-ruthin-chester-via-mold self.replace_atco_code('0610CH19065', '0610CH2395', stops)
def successful(self): max_duration = parse_duration(settings.DRAW_TIME) try: work = self.work except Work.DoesNotExist: work = None if work is None: elapsed_time = timezone.now() - self.timestamp if elapsed_time >= max_duration: return False return None if self.work.upload_time - self.timestamp > max_duration: return False return True
def __init__(self, element, stops): self.activity = element.find('txc:Activity', NS) if self.activity is not None: self.activity = self.activity.text self.sequencenumber = element.get('SequenceNumber') if self.sequencenumber is not None: self.sequencenumber = int(self.sequencenumber) self.stop = stops.get(element.find('txc:StopPointRef', NS).text) if self.stop is None: self.stop = Stop(element) # for Ellenvale Coaches if self.stop.atco_code == '090002492728': self.activity = 'pickUpAndSetDown' self.timingstatus = element.find('txc:TimingStatus', NS).text self.wait_time = element.find('txc:WaitTime', NS) if self.wait_time is not None: self.wait_time = parse_duration(self.wait_time.text) self.row = None self.parent = None
def convert_durationfield_value(self, value, expression, connection): if value is not None: value = str(decimal.Decimal(value) / decimal.Decimal(1000000)) value = parse_duration(value) return value
def test_seconds(self): self.assertEqual(parse_duration('30'), timedelta(seconds=30))
def test_minutes_seconds(self): self.assertEqual(parse_duration('15:30'), timedelta(minutes=15, seconds=30)) self.assertEqual(parse_duration('5:30'), timedelta(minutes=5, seconds=30))
def test_negative(self): self.assertEqual(parse_duration('-4 15:30'), timedelta(days=-4, minutes=15, seconds=30))
def __call__(self, value): if not isinstance(value, dict): self._raise_error('invalid') #check for valid keys: if len(set(value.keys()) - {'vendor', 'id', 'startTime', 'endTime', 'meta',}): self._raise_error('invalid') #check vendor is allowed: video_vendor = value.get('vendor', '') if self.allowed_vendors is not None: if video_vendor not in self.allowed_vendors: self._raise_error('vendor_not_allowed', (video_vendor,)) #check vendor id: vendor_id_validator = self.vendor_id_validators.get(video_vendor) video_id = value.get('id', '') if vendor_id_validator: if not vendor_id_validator(video_id): self._raise_error('invalid_vendor_id') #check startTime: video_start_time = value.get('startTime') video_start_timedelta = None if video_start_time: #validate and clean time string: video_start_timedelta = dateparse.parse_duration(video_start_time) if video_start_timedelta is None: self._raise_error('invalid_time', ('startTime',)) video_start_time = self._duration_to_str(video_start_timedelta) value['startTime'] = video_start_time #check endTime: video_end_time = value.get('endTime') if video_end_time: #validate and clean time string: video_end_timedelta = dateparse.parse_duration(video_end_time) if video_end_timedelta is None: self._raise_error('invalid_time', ('endTime',)) video_end_time = self._duration_to_str(video_end_timedelta) value['endTime'] = video_end_time #validate timedelta between end and start times: if video_start_timedelta and video_end_timedelta: if video_end_timedelta <= video_start_timedelta: self._raise_error('invalid_time_delta') #check meta, in case exists: if 'meta' in value: if len(set(value['meta'].keys()) - {'published', 'author', 'title', 'duration',}): self._raise_error('invalid') if 'published' in value['meta'] and not dateparse.parse_datetime(value['meta']['published']): self._raise_error('invalid_meta_field', ('published',)) for f in ['author', 'title']: if f in value['meta'] and (not isinstance(value['meta'][f], basestring) or len(value['meta'][f]) > 255): self._raise_error('invalid_meta_field', (f,)) if 'duration' in value['meta']: video_duration_timedelta = dateparse.parse_duration(value['meta']['duration']) if video_duration_timedelta is None: self._raise_error('invalid_meta_field', ('duration',)) value['meta']['duration'] = self._duration_to_str(video_duration_timedelta)
def test_days(self): self.assertEqual(parse_duration('4 15:30'), timedelta(days=4, minutes=15, seconds=30)) self.assertEqual(parse_duration('4 10:15:30'), timedelta(days=4, hours=10, minutes=15, seconds=30))