def build_api_model() -> Model:
"""
Returns a Flask-RESTX Api Model based on the sample dict returned by the trained model wrapper.
This will be used to validate input and automatically generate the Swagger prototype.
"""
fields_classes_map: Dict = {
"str": fields.String,
"int": fields.Integer,
"float": fields.Float,
"bool": fields.Boolean,
"datetime": fields.DateTime,
"date": fields.Date,
}
model_dict: Dict = {}
model_sample: Dict = trained_model_wrapper.sample()
if model_sample:
for key, value in model_sample.items():
fields_class: fields.Raw = fields_classes_map.get(
type(value).__name__, fields.String)
if type(value).__name__ == "str":
try:
parse_date(value)
fields_class = fields.Date
except ValueError:
pass
try:
parse_datetime(value)
fields_class = fields.DateTime
except ValueError:
pass
model_dict[key] = fields_class(example=value,
readonly=True,
required=True)
return api.model("input_vector", model_dict)
def get_application_periods(json):
result = []
if 'application_period_patterns' in json and json['application_period_patterns']:
for json_one_pattern in json['application_period_patterns']:
start_date = parse_date(json_one_pattern['start_date'])
end_date = parse_date(json_one_pattern['end_date'])
weekly_pattern = json_one_pattern['weekly_pattern']
time_slots = json_one_pattern['time_slots']
time_zone = json_one_pattern['time_zone']
result += get_application_periods_by_pattern(start_date, end_date, weekly_pattern, time_slots, time_zone)
else:
if 'application_periods' in json:
result = get_application_periods_by_periods(json['application_periods'])
return result
def get_application_periods(json):
result = []
if 'application_period_patterns' in json and json['application_period_patterns']:
for json_one_pattern in json['application_period_patterns']:
start_date = parse_date(json_one_pattern['start_date'])
end_date = parse_date(json_one_pattern['end_date'])
weekly_pattern = json_one_pattern['weekly_pattern']
time_slots = json_one_pattern['time_slots']
time_zone = json_one_pattern['time_zone']
result += get_application_periods_by_pattern(start_date, end_date, weekly_pattern, time_slots, time_zone)
else:
if 'application_periods' in json:
result = get_application_periods_by_periods(json['application_periods'])
return result
def _deserialize(self, value, attr, data):
"""
不对 value 进行类型转换, 保持字符类型
:param value:
:param attr:
:param data:
:return:
"""
if not value:
self.fail('invalid')
try:
parse_date(value)
except (AttributeError, TypeError, ValueError, ISOFormatError):
self.fail('invalid')
else:
return value
def _parse_datetime(value):
try:
return aniso8601.parse_datetime(value)
except ValueError:
return aniso8601.parse_date(value)
return None
def str_to_date(value):
if not value:
return None
try:
return parse_date(value)
except:
logging.getLogger(__name__).info("[{value} invalid date.".format(value=value))
return None
def parse_value(value):
try:
if isinstance(value, datetime.date):
return value
elif isinstance(value, str):
return parse_date(value)
except ValueError:
return INVALID
def iso8601date(ctx, param, value):
"""
Accept an ISO8601 date (YYYY-MM-DD), or use today's date if a value is not
given.
"""
if value is None:
return date.today()
return parse_date(value)
def parse_literal_date(ast, _variables=None):
if not isinstance(ast, StringValueNode):
return INVALID
try:
return parse_date(ast.value)
except ValueError:
return INVALID
def _to_python(self):
# don't parse data that is already native
if isinstance(self.data, datetime.date):
return self.data
elif self.format is None:
return aniso8601.parse_date(self.data)
return super(DateField, self)._to_python().date()
def str_to_date(value: str) -> Optional[date]:
if not value:
return None
try:
return parse_date(value)
except Exception:
logging.getLogger(__name__).info("{value} invalid date.".format(value=value))
return None
def str_to_date(value):
if not value:
return None
try:
return parse_date(value)
except:
logging.getLogger(__name__).info('[{value} invalid date.'.format(value=value))
return None
def parse_value(value):
try:
if isinstance(value, datetime.date):
return value
elif isinstance(value, string_types):
return parse_date(value)
except ValueError:
return None
def convert_date_time_iso8601(d, t):
# in the hurricane data date and time are 2 seperate fields,
# formatted <YYYYMMDD> and <HHMM>
# this function returns a string in ISO8601 format:
# <YYYY>-<MM>-<DD>T<HH>:<MM>:<SS>
dt = datetime.datetime.combine(aniso8601.parse_date(d),
aniso8601.parse_time(t))
return dt.isoformat()
def parse_value(value):
if isinstance(value, datetime.date):
return value
if not isinstance(value, str):
raise GraphQLError(
f"Date cannot represent non-string value: {repr(value)}")
try:
return parse_date(value)
except ValueError:
raise GraphQLError(f"Date cannot represent value: {repr(value)}")
def parse_date(dtstr):
"""
Parse an ISO8601 date string.
:param dtstr: An ISO8601 formatted date string
:rtype: datetime.date
:return: A date object.
"""
return aniso8601.parse_date(dtstr)
def update_values(self, request, pk=None):
indicator = Indicator.objects.get(pk=pk)
data = request.data['data']
min_date = max_date = None
values = []
for sample in data:
date_str = sample.get('date', '')
try:
date = aniso8601.parse_date(date_str)
except ValueError:
raise ValidationError(
"You must give 'date' in ISO 8601 format (YYYY-mm-dd)")
if indicator.time_resolution == 'year':
if date.day != 31 or date.month != 12:
raise ValidationError(
"Indicator has a yearly resolution, so '%s' must be '%d-12-31"
% (date_str, date.year))
elif indicator.time_resolution == 'month':
if date.day != 1:
raise ValidationError(
"Indicator has a monthly resolution, so '%s' must be '%d-%02d-01"
% (date_str, date.year, date.month))
try:
value = float(sample.get('value'))
except TypeError:
raise ValidationError(
"You must give 'value' as a floating point number")
if min_date is None or date < min_date:
min_date = date
if max_date is None or date > max_date:
max_date = date
values.append(
IndicatorValue(indicator=indicator, date=date, value=value))
dates = {}
for value in values:
date = value.date
if date in dates:
raise ValidationError("Duplicate 'date' entry: %s" %
(date.isoformat()))
dates[date] = True
n_deleted, _ = indicator.values.filter(date__gte=min_date,
date__lte=max_date).delete()
created = IndicatorValue.objects.bulk_create(values)
latest_value = indicator.values.latest()
if indicator.latest_value_id != latest_value.id:
indicator.latest_value = latest_value
indicator.save(update_fields=['latest_value'])
return Response(dict(deleted=n_deleted, created=len(created)))
def _parse_interval(value):
"""Do some nasty try/except voodoo to get some sort of datetime
object(s) out of the string.
"""
try:
return sorted(aniso8601.parse_interval(value))
except ValueError:
try:
return aniso8601.parse_datetime(value), None
except ValueError:
return aniso8601.parse_date(value), None
def _parse_interval(value):
"""Do some nasty try/except voodoo to get some sort of datetime
object(s) out of the string.
"""
try:
return sorted(aniso8601.parse_interval(value))
except ValueError:
try:
return aniso8601.parse_datetime(value), None
except ValueError:
return aniso8601.parse_date(value), None
def mandate_period_start(e):
start = e['mandate_period'].get('start', '--01-01')
if start.startswith('--'):
# aniso8601 does not support extended year representation.
# Let's try to fix that:
start = str(now.year) + start[1:]
date = aniso8601.parse_date(start)
if date < now.date():
date = date.replace(year=(now.year + 1))
return date
def parse_date(amzdate):
if SEASON_PATTERN.search(amzdate):
start = aniso8601.parse_date('{}-{}-01'.format(
amzdate[:4], SEASON_DICT[amzdate[-2:]]))
yd = (start.month + 3) // 12
md = (start.month + 3) % 12
end = datetime.datetime(year=start.year + yd,
month=start.month + md,
day=1) - datetime.timedelta(days=1)
return start, end
elif WEEKEND_PATTERN.search(amzdate):
return aniso8601.parse_date(amzdate[:-3] +
"-6"), aniso8601.parse_date(amzdate[:-3] +
"-7")
elif amzdate.endswith('XX'):
start = aniso8601.parse_date('{}{}'.format(amzdate[:2], '00'))
end = datetime.datetime(year=start.year + 100, month=1,
day=1) - datetime.timedelta(days=1)
return start, end
elif amzdate.endswith('X'):
start = aniso8601.parse_date('{}{}'.format(amzdate[:3], '0'))
end = datetime.datetime(year=start.year + 10, month=1,
day=1) - datetime.timedelta(days=1)
return start, end
elif amzdate == 'PRESENT_REF':
start = datetime.datetime.today().replace(hour=0,
minute=0,
second=0,
microsecond=0)
end = start + datetime.timedelta(days=1)
return start, end
return aniso8601.parse_date(amzdate)
def parse_as_iso(string):
try:
return aniso8601.parse_datetime(string)
except Exception:
try:
return aniso8601.parse_date(string)
except Exception as err:
printf(
'Can\'t interpret "{}" as an ISO-8601 time: {}',
string, err,
file=sys.stderr,
)
sys.exit(1)
def dialog_tide(city, date):
if city is not None:
if city.lower() not in STATIONS:
return supported_cities()
if SESSION_DATE not in session.attributes:
session.attributes[SESSION_CITY] = city
return _dialog_date(city)
date = aniso8601.parse_date(session.attributes[SESSION_DATE])
return _make_tide_request(city, date)
elif date is not None:
if SESSION_CITY not in session.attributes:
session.attributes[SESSION_DATE] = date.isoformat()
return _dialog_city(date)
city = session.attributes[SESSION_CITY]
return _make_tide_request(city, date)
else:
return _dialog_no_slot()
def dialog_tide(city, date):
if city is not None:
if city.lower() not in STATIONS:
return supported_cities()
if SESSION_DATE not in session.attributes:
session.attributes[SESSION_CITY] = city
return _dialog_date(city)
date = aniso8601.parse_date(session.attributes[SESSION_DATE])
return _make_tide_request(city, date)
elif date is not None:
if SESSION_CITY not in session.attributes:
session.attributes[SESSION_DATE] = date.isoformat()
return _dialog_city(date)
city = session.attributes[SESSION_CITY]
return _make_tide_request(city, date)
else:
return _dialog_no_slot()
def parse_date(date_string):
d, resolution = (
iso8601.parse_date(date_string),
iso8601.get_date_resolution(date_string),
)
dMin = datetime.combine(d, time.min)
if resolution == DateResolution.Year:
dMax = d.replace(month=12, day=31)
elif resolution == DateResolution.Month:
lastDayOfMonth = calendar.monthrange(d.year, d.month)[1]
dMax = d.replace(day=lastDayOfMonth)
elif resolution == DateResolution.Day:
dMax = d
else:
raise NotImplementedError(f'Unable to deal with input "{dt_string}".')
dMax = datetime.combine(dMax, time.max)
return dMin, dMax
def get_logins_stats(self, clientid, end_date, num_days, authsource):
if end_date:
try:
end_date = parse_date(end_date)
except Exception:
raise ValidationError('end_date not a valid date: {}'.format(end_date))
else:
end_date = datetime.date.today()
try:
num_days = int(num_days)
except ValueError:
raise ValidationError('num_days not an integer: {}'.format(num_days))
if num_days < 1 or num_days > MAX_DAYS:
msg = 'num_days should be an integer: 1 <= num_days <= {}'.format(MAX_DAYS)
raise ValidationError(msg)
start_date = end_date - datetime.timedelta(num_days - 1)
dates = [start_date + datetime.timedelta(i) for i in range(num_days)]
return list(self.session.get_logins_stats(clientid, dates, authsource, None))
def test_import(self):
#Just some tests repeated from other places to make sure the
#imports work
time = aniso8601.parse_time('01:23:45')
self.assertEqual(time.hour, 1)
self.assertEqual(time.minute, 23)
self.assertEqual(time.second, 45)
resultdatetime = aniso8601.parse_datetime(
'1981-04-05T23:21:28.512400Z')
self.assertEqual(resultdatetime.year, 1981)
self.assertEqual(resultdatetime.month, 4)
self.assertEqual(resultdatetime.day, 5)
self.assertEqual(resultdatetime.hour, 23)
self.assertEqual(resultdatetime.minute, 21)
self.assertEqual(resultdatetime.second, 28)
self.assertEqual(resultdatetime.microsecond, 512400)
tzinfoobject = resultdatetime.tzinfo
self.assertEqual(tzinfoobject.utcoffset(None),
datetime.timedelta(hours=0))
self.assertEqual(tzinfoobject.tzname(None), 'UTC')
date = aniso8601.parse_date('19810405')
self.assertEqual(date.year, 1981)
self.assertEqual(date.month, 4)
self.assertEqual(date.day, 5)
resultduration = aniso8601.parse_duration('P1Y2M3DT4H54M6S')
self.assertEqual(resultduration.days, 428)
self.assertEqual(resultduration.seconds, 17646)
resultinterval = aniso8601.parse_interval(
'1980-03-05T01:01:00/1981-04-05T01:01:00')
self.assertEqual(
resultinterval[0],
datetime.datetime(year=1980, month=3, day=5, hour=1, minute=1))
self.assertEqual(
resultinterval[1],
datetime.datetime(year=1981, month=4, day=5, hour=1, minute=1))
results = list(aniso8601.parse_repeating_interval('R3/1981-04-05/P1D'))
self.assertEqual(results[0], datetime.date(year=1981, month=4, day=5))
self.assertEqual(results[1], datetime.date(year=1981, month=4, day=6))
self.assertEqual(results[2], datetime.date(year=1981, month=4, day=7))
def datetime_from_iso8601(value):
'''
Turns an ISO8601 formatted date into a datetime object.
Example::
inputs.datetime_from_iso8601("2012-01-01T23:30:00+02:00")
:param str value: The ISO8601-complying string to transform
:return: A datetime
:rtype: datetime
:raises ValueError: if value is an invalid date literal
'''
try:
try:
return aniso8601.parse_datetime(value)
except ValueError:
date = aniso8601.parse_date(value)
return datetime(date.year, date.month, date.day)
except:
raise ValueError('Invalid date literal "{0}"'.format(value))
def datetime_from_iso8601(value):
'''
Turns an ISO8601 formatted date into a datetime object.
Example::
inputs.datetime_from_iso8601("2012-01-01T23:30:00+02:00")
:param str value: The ISO8601-complying string to transform
:return: A datetime
:rtype: datetime
:raises ValueError: if value is an invalid date literal
'''
try:
try:
return aniso8601.parse_datetime(value)
except ValueError:
date = aniso8601.parse_date(value)
return datetime(date.year, date.month, date.day)
except Exception:
raise ValueError('Invalid date literal "{0}"'.format(value))
def test_import(self):
#Just some tests repeated from other places to make sure the
#imports work
time = aniso8601.parse_time('01:23:45')
self.assertEqual(time.hour, 1)
self.assertEqual(time.minute, 23)
self.assertEqual(time.second, 45)
resultdatetime = aniso8601.parse_datetime('1981-04-05T23:21:28.512400Z')
self.assertEqual(resultdatetime.year, 1981)
self.assertEqual(resultdatetime.month, 4)
self.assertEqual(resultdatetime.day, 5)
self.assertEqual(resultdatetime.hour, 23)
self.assertEqual(resultdatetime.minute, 21)
self.assertEqual(resultdatetime.second, 28)
self.assertEqual(resultdatetime.microsecond, 512400)
tzinfoobject = resultdatetime.tzinfo
self.assertEqual(tzinfoobject.utcoffset(None), datetime.timedelta(hours=0))
self.assertEqual(tzinfoobject.tzname(None), 'UTC')
date = aniso8601.parse_date('19810405')
self.assertEqual(date.year, 1981)
self.assertEqual(date.month, 4)
self.assertEqual(date.day, 5)
resultduration = aniso8601.parse_duration('P1Y2M3DT4H54M6S')
self.assertEqual(resultduration.days, 428)
self.assertEqual(resultduration.seconds, 17646)
resultinterval = aniso8601.parse_interval('1980-03-05T01:01:00/1981-04-05T01:01:00')
self.assertEqual(resultinterval[0], datetime.datetime(year=1980, month=3, day=5, hour=1, minute=1))
self.assertEqual(resultinterval[1], datetime.datetime(year=1981, month=4, day=5, hour=1, minute=1))
results = list(aniso8601.parse_repeating_interval('R3/1981-04-05/P1D'))
self.assertEqual(results[0], datetime.date(year=1981, month=4, day=5))
self.assertEqual(results[1], datetime.date(year=1981, month=4, day=6))
self.assertEqual(results[2], datetime.date(year=1981, month=4, day=7))
def converter(self, value):
return aniso8601.parse_date(value)
def parse_value_date(value):
return parse_date(value)
def f(v):
try:
return aniso8601.parse_date(v)
except:
raise good.Invalid('invalid date {}'.format(v))
def _parse_date(datestr):
""" Parse an ISO8601 date value. """
return aniso8601.parse_date(datestr)
def date_from_iso8601(date_str):
return aniso8601.parse_date(date_str)
def get_date(row, get_field, default_date):
try:
return parse_date(get_field(row))
except ValueError:
return default_date
def get_date_from_json_attr(json, attr):
return parse_date(json[attr])
def f(v):
try:
return aniso8601.parse_date(v)
except:
raise good.Invalid('invalid date {}'.format(v))
def __call__(self, item, field, value):
if value:
setattr(item, self.attribute, parse_date(value))
else:
setattr(item, self.attribute, None)
def converter(self, value):
return aniso8601.parse_date(value)
def parse_value(value):
try:
return parse_date(value)
except ValueError:
return None
def add_feeding(name, side, date, time, length):
if name is not None:
if SESSION_SIDE not in session.attributes or session.attributes[SESSION_SIDE] is None:
return _save_and_prompt("side",
**{SESSION_NAME: name, SESSION_DATE: date, SESSION_TIME: time, SESSION_LENGTH: length})
elif SESSION_DATE not in session.attributes or session.attributes[SESSION_DATE] is None:
return _save_and_prompt("date",
**{SESSION_NAME: name, SESSION_SIDE: side, SESSION_TIME: time, SESSION_LENGTH: length})
elif SESSION_TIME not in session.attributes or session.attributes[SESSION_TIME] is None:
return _save_and_prompt("time",
**{SESSION_NAME: name, SESSION_SIDE: side, SESSION_DATE: date, SESSION_LENGTH: length})
elif SESSION_LENGTH not in session.attributes or session.attributes[SESSION_LENGTH] is None:
return _save_and_prompt("length",
**{SESSION_NAME: name, SESSION_SIDE: side, SESSION_DATE: date, SESSION_TIME: time})
elif side is not None:
if SESSION_NAME not in session.attributes or session.attributes[SESSION_NAME] is None:
return _save_and_prompt("name",
**{SESSION_TIME: time, SESSION_SIDE: side, SESSION_DATE: date, SESSION_LENGTH: length})
elif SESSION_DATE not in session.attributes or session.attributes[SESSION_DATE] is None:
return _save_and_prompt("date",
**{SESSION_NAME: name, SESSION_SIDE: side, SESSION_TIME: time, SESSION_LENGTH: length})
elif SESSION_TIME not in session.attributes or session.attributes[SESSION_TIME] is None:
return _save_and_prompt("time",
**{SESSION_NAME: name, SESSION_SIDE: side, SESSION_DATE: date, SESSION_LENGTH: length})
elif SESSION_LENGTH not in session.attributes or session.attributes[SESSION_LENGTH] is None:
return _save_and_prompt("length",
**{SESSION_NAME: name, SESSION_SIDE: side, SESSION_DATE: date, SESSION_TIME: time})
elif date is not None:
if SESSION_SIDE not in session.attributes or session.attributes[SESSION_SIDE] is None:
return _save_and_prompt("side",
**{SESSION_NAME: name, SESSION_DATE: date, SESSION_TIME: time, SESSION_LENGTH: length})
elif SESSION_NAME not in session.attributes or session.attributes[SESSION_NAME] is None:
return _save_and_prompt("name",
**{SESSION_TIME: time, SESSION_SIDE: side, SESSION_DATE: date, SESSION_LENGTH: length})
elif SESSION_TIME not in session.attributes or session.attributes[SESSION_TIME] is None:
return _save_and_prompt("time",
**{SESSION_NAME: name, SESSION_SIDE: side, SESSION_DATE: date, SESSION_LENGTH: length})
elif SESSION_LENGTH not in session.attributes or session.attributes[SESSION_LENGTH] is None:
return _save_and_prompt("length",
**{SESSION_NAME: name, SESSION_SIDE: side, SESSION_DATE: date, SESSION_TIME: time})
elif time is not None:
if SESSION_SIDE not in session.attributes or session.attributes[SESSION_SIDE] is None:
return _save_and_prompt("side",
**{SESSION_NAME: name, SESSION_DATE: date, SESSION_TIME: time, SESSION_LENGTH: length})
elif SESSION_DATE not in session.attributes or session.attributes[SESSION_DATE] is None:
return _save_and_prompt("date",
**{SESSION_NAME: name, SESSION_SIDE: side, SESSION_TIME: time, SESSION_LENGTH: length})
elif SESSION_NAME not in session.attributes or session.attributes[SESSION_NAME] is None:
return _save_and_prompt("name",
**{SESSION_TIME: time, SESSION_SIDE: side, SESSION_DATE: date, SESSION_LENGTH: length})
elif SESSION_LENGTH not in session.attributes or session.attributes[SESSION_LENGTH] is None:
return _save_and_prompt("length",
**{SESSION_NAME: name, SESSION_SIDE: side, SESSION_DATE: date, SESSION_TIME: time})
elif length is not None:
if SESSION_SIDE not in session.attributes or session.attributes[SESSION_SIDE] is None:
return _save_and_prompt("side",
**{SESSION_NAME: name, SESSION_DATE: date, SESSION_TIME: time, SESSION_LENGTH: length})
elif SESSION_DATE not in session.attributes or session.attributes[SESSION_DATE] is None:
return _save_and_prompt("date",
**{SESSION_NAME: name, SESSION_SIDE: side, SESSION_TIME: time, SESSION_LENGTH: length})
elif SESSION_NAME not in session.attributes or session.attributes[SESSION_NAME] is None:
return _save_and_prompt("name",
**{SESSION_TIME: time, SESSION_SIDE: side, SESSION_DATE: date, SESSION_LENGTH: length})
elif SESSION_TIME not in session.attributes or session.attributes[SESSION_TIME] is None:
return _save_and_prompt("time",
**{SESSION_NAME: name, SESSION_SIDE: side, SESSION_DATE: date, SESSION_LENGTH: length})
else:
return _gather("name")
# the first 5 blocks will always fall through to here while the else will not
endpoint = "/api/feeding"
user_token = session.user.accessToken
if name is None:
name = session.attributes[SESSION_NAME]
child = name_to_id(name, user_token)
if "children" in child:
text = render_template("multiple_name")
return statement(text).simple_card(text)
child_id = child["_id"]
side = session.attributes[SESSION_SIDE]
length = session.attributes[SESSION_LENGTH]
date = aniso8601.parse_date(session.attributes[SESSION_DATE])
time = aniso8601.parse_time(session.attributes[SESSION_TIME])
dt = datetime.datime.combine(date, time)
r = requests.post(BASE+endpoint,
headers={'Authorization': 'Basic %s' % b64encode(bytes(user_token+":"))},
data={'child_id': child_id, 'side': side, 'datetime': to_rfc822(dt), 'duration': length})
if r.status_code != 200:
return statement(render_template("failed_request")) # TODO handle 400
return statement("Feeding added.").simple_card("Feeding added")
def parse_value(value):
try:
return parse_date(value)
except ValueError:
return None
def date_parse_value(value):
try:
return aniso8601.parse_date(value)
except ValueError:
return None
def add_diaper(name, kind, date, time):
if name is not None:
if SESSION_KIND not in session.attributes or session.attributes[SESSION_KIND] is None:
return _save_and_prompt("kind",
**{SESSION_NAME: name, SESSION_DATE: date, SESSION_TIME: time})
elif SESSION_DATE not in session.attributes or session.attributes[SESSION_DATE] is None:
return _save_and_prompt("date",
**{SESSION_NAME: name, SESSION_SIDE: side, SESSION_TIME: time})
elif SESSION_TIME not in session.attributes or session.attributes[SESSION_TIME] is None:
return _save_and_prompt("time",
**{SESSION_NAME: name, SESSION_SIDE: side, SESSION_DATE: date})
elif kind is not None:
if SESSION_NAME not in session.attributes or session.attributes[SESSION_NAME] is None:
return _save_and_prompt("name",
**{SESSION_KIND: kind, SESSION_DATE: date, SESSION_TIME: time})
elif SESSION_DATE not in session.attributes or session.attributes[SESSION_DATE] is None:
return _save_and_prompt("date",
**{SESSION_NAME: name, SESSION_SIDE: side, SESSION_TIME: time})
elif SESSION_TIME not in session.attributes or session.attributes[SESSION_TIME] is None:
return _save_and_prompt("time",
**{SESSION_NAME: name, SESSION_SIDE: side, SESSION_DATE: date})
elif date is not None:
if SESSION_NAME not in session.attributes or session.attributes[SESSION_NAME] is None:
return _save_and_prompt("name",
**{SESSION_KIND: kind, SESSION_DATE: date, SESSION_TIME: time})
elif SESSION_KIND not in session.attributes or session.attributes[SESSION_KIND] is None:
return _save_and_prompt("kind",
**{SESSION_NAME: name, SESSION_DATE: date, SESSION_TIME: time})
elif SESSION_TIME not in session.attributes or session.attributes[SESSION_TIME] is None:
return _save_and_prompt("time",
**{SESSION_NAME: name, SESSION_SIDE: side, SESSION_DATE: date})
elif time is not None:
if SESSION_NAME not in session.attributes or session.attributes[SESSION_NAME] is None:
return _save_and_prompt("name",
**{SESSION_KIND: kind, SESSION_DATE: date, SESSION_TIME: time})
elif SESSION_KIND not in session.attributes or session.attributes[SESSION_KIND] is None:
return _save_and_prompt("kind",
**{SESSION_NAME: name, SESSION_DATE: date, SESSION_TIME: time})
elif SESSION_DATE not in session.attributes or session.attributes[SESSION_DATE] is None:
return _save_and_prompt("date",
**{SESSION_NAME: name, SESSION_SIDE: side, SESSION_TIME: time})
else:
return _gather("name")
# the first 4 blocks will always fall through to here while the else will not
endpoint = "/api/diaper"
user_token = session.user.accessToken
child = name_to_id(name, user_token)
if "children" in child:
text = render_template("multiple_name")
return statement(text).simple_card(text)
child_id = child["_id"]
kind = session.attributes[SESSION_KIND]
date = aniso8601.parse_date(session.attributes[SESSION_DATE])
time = aniso8601.parse_time(session.attributes[SESSION_TIME])
dt = datetime.datime.combine(date, time)
r = requests.post(BASE+endpoint,
headers={'Authorization': 'Basic %s' % b64encode(bytes(user_token+":"))},
data={'child_id': child_id, 'kind': kind, 'datetime': to_rfc822(dt)})
if r.status_code != 200:
return statement(render_template("failed_request")) # TODO handle 400
return statement("Diaper added.").simple_card("Diaper added")
logging.info('Page: {}'.format(page))
data = requests.get(
'http://api.tvmaze.com/shows?page={}'.format(page)).json()
for show in data:
if not show['externals']:
continue
if 'imdb' not in show['externals']:
continue
if not show['externals']['imdb']:
continue
if str(show['externals']['imdb']) in imdbids:
continue
if show['language'] != 'English':
continue
if show['premiered']:
if aniso8601.parse_date(show['premiered']) < date(2020, 1, 1):
continue
else:
continue
try:
client.post(
'/shows', {
'externals': {
'imdb': show['externals']['imdb'],
'tvmaze': show['id'],
'thetvdb': show['externals']['thetvdb'],
},
'importers': {
'info': 'tvmaze',
'episodes': 'tvmaze',
}
def __call__(self, item, field, value):
if value:
setattr(item, self.attribute, parse_date(value))
else:
setattr(item, self.attribute, None)
def clean(self, data):
date_string = super(DateField, self).clean(data)
try:
return aniso8601.parse_date(date_string)
except ValueError:
raise self.error('invalid_format')
