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 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 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 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_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 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))
