def post(self, resource_id = None): data = request.get_json() verify_request_contains_mandatory_fields(data, self.mandatory_fields) # Resource id might also be part of the incoming json. resource_uri = None if not resource_id: resource_uri = data["resource_uri"] resource = self.get_resource_with_id_or_uri(resource_id, resource_uri) start_date, end_date = self.parse_date_range_from_dict(data) start_time = parse_time(data["start_time"]) end_time = parse_time(data["end_time"]) week_day = data["week_day"] if data["note"]: note = data["note"] if not (len(note) <= 50): abort(400, __error__=[u'Maks lengde for merknad er 50 tegn']) else: note= "" self.validate_start_and_end_times(start_date, end_date, start_time, end_time) # Check that the time has correct minute interval, only 30-minute intervals allowed invalid_minutes = filter(lambda my_time: my_time.minute not in [0, 30], [start_time, end_time]) if invalid_minutes: abort(400, __error__=[u'Tidene må angis i hele halvtimer'] ) weekly_blocked_time = WeeklyBlockedTime(resource, week_day, start_date, end_date, start_time, end_time, note) ensure(POST, weekly_blocked_time) if self.is_conflict_slot_time(resource, start_date, end_date, week_day, start_time, end_time) or \ self.is_conflict_rammetid(resource, start_date, end_date, week_day, start_time, end_time): abort( 400, __error__=[u'Tiden er ikke tilgjengelig for blokkering'] ) if self.is_conflict_blocked_time(resource, start_date, end_date, week_day, start_time, end_time): abort( 400, __error__=[u'Tiden er allerede blokkert'] ) current_app.db_session.add(weekly_blocked_time) current_app.db_session.commit() current_app.db_session.refresh(weekly_blocked_time) return marshal(weekly_blocked_time, self.fields), 201
def test_001_trmm_3b42_daily_v6_v7(self): # Testing Phase # -------------------------------------------------------------- data = [ ('d/001/scrubbed.TRMM_3B42_daily_precipitation_V6.20050101.nc', 'd/001/scrubbed.TRMM_3B42_daily_precipitation_V7.20050101.nc') ] with open(self.opt_f, 'w') as fh: for x_file, y_file in data: fh.write(os.path.join(cur_dir, x_file)) fh.write(' ') fh.write(os.path.join(cur_dir, y_file)) fh.write('\n') S.main([ S.__name__, '-b', '-102.6562,23.3203,-73.8281,43.0078', '-s', '2005-01-01T00:00:00Z', '-e', '2005-01-01T23:59:59Z', '-x', 'TRMM_3B42_daily_precipitation_V6', '-y', 'TRMM_3B42_daily_precipitation_V7', '-f', self.opt_f, '-o', self.opt_o, '-l', self.opt_l, ], open('/dev/null', 'w')) # Verification Phase # -------------------------------------------------------------- self.assertTrue(os.path.exists(self.opt_o)) dataset = netCDF4.Dataset(self.opt_o) var_x = dataset.variables.get('x_TRMM_3B42_daily_precipitation_V6') var_y = dataset.variables.get('y_TRMM_3B42_daily_precipitation_V7') self.assertTrue(var_x) self.assertTrue(var_y) self.assertTrue('lon' in dataset.variables) self.assertTrue('lat' in dataset.variables) self.assertTrue('sum_x' not in dataset.variables) self.assertTrue('sum_y' not in dataset.variables) self.assertTrue('correlation' not in dataset.variables) self.assertTrue('time_matched_difference' not in dataset.variables) self.assertTrue('offset' not in dataset.variables) self.assertTrue('slope' not in dataset.variables) self.assertTrue('n_samples' not in dataset.variables) assert_almost_equal(var_x[:].mean(), 0.85407738666696897) assert_almost_equal(var_y[:].mean(), 0.62942020454917991) isodate.parse_time(dataset.matched_start_time) isodate.parse_time(dataset.matched_end_time) self.assertEqual('daily', dataset.input_temporal_resolution)
def parse_slot_request(self, data): start_date = parse_date(data["start_date"]) end_date = parse_date(data["end_date"]) start_time = parse_time(data["start_time"]) end_time = parse_time(data["end_time"]) week_day = data["week_day"] return RepeatingSlotRequest( week_day, start_date, end_date, start_time, end_time )
def parse_repeating_slot(data): start_date = parse_date(data["start_date"]) end_date = parse_date(data["end_date"]) start_time = parse_time(data["start_time"]) end_time = parse_time(data["end_time"]) week_day = data["week_day"] return RammetidSlot( week_day, start_date, end_date, start_time, end_time )
def from_data(cls, data): schedule_validator.validate(data) data.setdefault("minute", "*") data.setdefault("hour", "*") data.setdefault("day-of-month", "*") data.setdefault("month", "*") data.setdefault("day-of-week", "*") data.setdefault("begin", "00:00") data.setdefault("end", "23:59") return cls(data["minute"], data["hour"], data["day-of-month"], data["month"], data["day-of-week"], isodate.parse_time(data["begin"]), isodate.parse_time(data["end"]))
def parse_slot(self, data, application): start_date = parse_date(data["start_date"]) end_date = parse_date(data["end_date"]) start_time = parse_time(data["start_time"]) end_time = parse_time(data["end_time"]) week_day = data["week_day"] return RepeatingSlot( application, week_day, start_date, end_date, start_time, end_time )
def _validate_type_iso_time(self, time_value): is_valid = True if time_value == '24:00': return is_valid try: isodate.parse_time(time_value) if not re.match( r'^([01]\d|2[0-3])\D?([0-5]\d)\D?([0-5]\d)?\D?(\d{3})?$', time_value): is_valid = False except isodate.ISO8601Error as ex: is_valid = False if is_valid: return True
def _bind_processor(self, value): if value is None: return None if isinstance(value, str): value = isodate.parse_time(value) return value.isoformat()
def test_parse(self): ''' Parse an ISO time string and compare it to the expected value. ''' if expectation is None: self.assertRaises(ISO8601Error, parse_time, timestring) else: result = parse_time(timestring) self.assertEqual(result, expectation)
def from_time(value): if isinstance(value, six.string_types): value = isodate.parse_time(value) if isinstance(value, datetime.time): return value.isoformat() else: raise ValueError('To create a proper string representation for a time,' ' either a datetime.time or str has to be supplied!')
def test_pythonvalue(self): instance = builtins.Time() value = datetime.time(21, 14, 42) assert instance.pythonvalue('21:14:42') == value value = datetime.time(21, 14, 42, 120000) assert instance.pythonvalue('21:14:42.120') == value value = isodate.parse_time('21:14:42.120+0200') assert instance.pythonvalue('21:14:42.120+0200') == value
def _from(self, s): t = None try: t = isodate.parse_time(s) except ValueError: pass if not t: t = datetime.datetime.strptime(s, '%H:%M:%S') t = t.time() return t
def validate_time(text): """ Based on http://tools.ietf.org/html/rfc2425#section-5.8.4 and the fact that it specifies a subset of ISO 8601. @param text: String Examples: >>> validate_time('00:00:00') >>> validate_time('000000') >>> validate_time('01:02:03Z') >>> validate_time('01:02:03+01:30') >>> validate_time('01:02:60') Traceback (most recent call last): VCardFormatError: Invalid time (See RFC 2425 section 5.8.4 for time syntax) String: 01:02:60 >>> validate_time('01:60:59') Traceback (most recent call last): VCardFormatError: Invalid time (See RFC 2425 section 5.8.4 for time syntax) String: 01:60:59 >>> validate_time('24:00:00') Traceback (most recent call last): VCardFormatError: Invalid time (See RFC 2425 section 5.8.4 for time syntax) String: 24:00:00 >>> validate_time('00:00:00Z+01') # doctest: +ELLIPSIS Traceback (most recent call last): VCardFormatError: Invalid time zone ... String: Z+01 """ time_timezone = VALID_TIME_TZ.match(text) if time_timezone is None: raise VCardFormatError(MSG_INVALID_TIME, {'String': text}) time_str, timezone_str = time_timezone.groups() try: isodate.parse_time(time_str) except (isodate.ISO8601Error, ValueError): raise VCardFormatError(MSG_INVALID_TIME, {'String': text}) if timezone_str == '': return validate_time_zone(timezone_str)
def validate_time(text): """ Based on http://tools.ietf.org/html/rfc2425#section-5.8.4 and the fact that it specifies a subset of ISO 8601. @param text: String Examples: >>> validate_time('00:00:00') >>> validate_time('000000') >>> validate_time('01:02:03Z') >>> validate_time('01:02:03+01:30') >>> validate_time('01:02:60') # doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): VCardValueError: Invalid time (See RFC 2425 section 5.8.4 for time syntax) String: 01:02:60 >>> validate_time('01:60:59') # doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): VCardValueError: Invalid time (See RFC 2425 section 5.8.4 for time syntax) String: 01:60:59 >>> validate_time('24:00:00') # doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): VCardValueError: Invalid time (See RFC 2425 section 5.8.4 for time syntax) String: 24:00:00 >>> validate_time('00:00:00Z+01') # doctest: +ELLIPSIS +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): VCardValueError: Invalid time zone ... String: Z+01 """ time_timezone = VALID_TIME_WITH_TIMEZONE.match(text) if time_timezone is None: raise VCardValueError(NOTE_INVALID_TIME, {'String': text}) time_str, timezone_str = time_timezone.groups() try: isodate.parse_time(time_str) except (isodate.ISO8601Error, ValueError): raise VCardValueError(NOTE_INVALID_TIME, {'String': text}) if timezone_str == '': return validate_time_zone(timezone_str)
def to_python(self, value, context=None): if isinstance(value, datetime.time): return value try: return isodate.parse_time(value) except (isodate.ISO8601Error, TypeError): raise exceptions.ValidationError("Invalid time value '%s'" % value, value=value, invalid='format', against='time')
def to_python(self, value, context=None): if isinstance(value, datetime.time): return value try: return isodate.parse_time(value) except (isodate.ISO8601Error, TypeError): raise exceptions.ValidationError( "Invalid time value '%s'" % value, value=value, invalid='format', against='time' )
def add_entries_for_repeating_booking(result, repeating_bookings, start_date, end_date): for soknad in repeating_bookings: for slot in soknad['slots']: start_date_object = parse_date(slot['start_date']) end_date_object = parse_date(slot['end_date']) start_time = parse_time(slot['start_time']) end_time = parse_time(slot['end_time']) if start_date_object < start_date: start_date_object = start_date if end_date_object > end_date: end_date_object = end_date tmp_date = get_start_date_for_period(start_date_object, slot['week_day']) while tmp_date <= end_date_object: new_entry = get_soknad_fields_for_overview(soknad=soknad, date_object=tmp_date, start_time=start_time.strftime("%H:%M"), end_time=end_time.strftime("%H:%M")) result.append(new_entry) tmp_date += timedelta(weeks=1)
def to_python(self, value): """ Validates that the input can be converted to a time. Returns a Python time.time object. """ if value in forms.fields.EMPTY_VALUES: return None if isinstance(value, time): return value try: return isodate.parse_time(value) except (isodate.ISO8601Error, ValueError, TypeError): raise forms.ValidationError(self.error_messages['invalid'])
def from_datetimes(value, prop_type): if type(value) in constants.DATE_TYPES: return value if type(value) not in constants.BASE_STRING_TYPES: return None if prop_type == ndb.DateProperty: return isodate.parse_date(value) elif prop_type == ndb.DateTimeProperty: return isodate.parse_datetime(value).replace(tzinfo=None) elif prop_type == ndb.TimeProperty: return isodate.parse_time(value).replace(tzinfo=None)
def deserialize(self, value): """ Deserialize the given string as a `~datetime.time`. Args: value (str): the string to deserialize. Returns: ~datetime.time: the deserialized date. """ if self.format == 'iso8601': return isodate.parse_time(value) else: return datetime.datetime.strptime(value, self.format).time()
def parse_datetime(datetimestring): ''' Parses ISO 8601 date-times into datetime.datetime objects. This function uses parse_date and parse_time to do the job, so it allows more combinations of date and time representations, than the actual ISO 8601:2004 standard allows. ''' try: datestring, timestring = re.split('T| ', datetimestring) except ValueError: raise isodate.ISO8601Error( "ISO 8601 time designator 'T' or ' ' missing. Unable to parse " "datetime string %r" % datetimestring) tmpdate = isodate.parse_date(datestring) tmptime = isodate.parse_time(timestring) return datetime.datetime.combine(tmpdate, tmptime)
def process_item(self, raw_item, spider): # map lastModified item = ItemAdapter(raw_item) if "lastModified" in item: try: item["lastModified"] = float(item["lastModified"]) except: try: date = dateutil.parser.parse(item["lastModified"]) item["lastModified"] = int(date.timestamp()) except: log.warning("Unable to parse given lastModified date " + item["lastModified"]) del item["lastModified"] if "typicalLearningTime" in item["lom"]["educational"]: t = item["lom"]["educational"]["typicalLearningTime"] mapped = None splitted = t.split(":") if len(splitted) == 3: mapped = (int(splitted[0]) * 60 * 60 + int(splitted[1]) * 60 + int(splitted[2])) if mapped is None: log.warning("Unable to map given typicalLearningTime " + t + " to numeric value") item["lom"]["educational"]["typicalLearningTime"] = mapped if "technical" in item["lom"]: if "duration" in item["lom"]["technical"]: raw_duration = item["lom"]["technical"]["duration"] duration = raw_duration.strip() if duration: if len(duration.split(":")) == 3: duration = isodate.parse_time(duration) duration = duration.hour * 60 * 60 + duration.minute * 60 + duration.second elif duration.startswith("PT"): duration = int( isodate.parse_duration(duration).total_seconds()) else: try: duration = int(duration) except: duration = None logging.warning( "duration {} could not be normalized to seconds" .format(raw_duration)) item["lom"]["technical"]["duration"] = duration return raw_item
def iso8601_str_to_time(value, state=None): """Convert a clean string in ISO 8601 format to a time. .. note:: For a converter that doesn't require a clean string, see :func:`iso8601_input_to_time`. >>> iso8601_str_to_time(u'05:06:07') (datetime.time(5, 6, 7), None) >>> iso8601_str_to_time(u'T05:06:07') (datetime.time(5, 6, 7), None) >>> iso8601_str_to_time(u'05:06:07+01:00') (datetime.time(4, 6, 7), None) >>> iso8601_str_to_time(u'05:06:07-02:00') (datetime.time(7, 6, 7), None) >>> iso8601_str_to_time(u'05:06:07 +01:00') (datetime.time(4, 6, 7), None) >>> iso8601_str_to_time(u'05:06:07 -02:00') (datetime.time(7, 6, 7), None) >>> iso8601_str_to_time(u'05:06:07') (datetime.time(5, 6, 7), None) >>> iso8601_str_to_time(u'now') (u'now', u'Value must be a time in ISO 8601 format') >>> iso8601_str_to_time(u'') (u'', u'Value must be a time in ISO 8601 format') >>> iso8601_str_to_time(None) (None, None) """ if value is None: return value, None if state is None: state = states.default_state # Parsing fails when time zone is preceded with a space. So we remove space before "+" and "-". while u' +' in value: value = value.replace(u' +', '+') while u' -' in value: value = value.replace(u' -', '-') try: value = isodate.parse_time(value) except isodate.ISO8601Error: return value, state._(u'Value must be a time in ISO 8601 format') if value.tzinfo is not None: # Convert time to UTC (using a temporary datetime). datetime_value = datetime.datetime.combine(datetime.date(2, 2, 2), value) datetime_value = datetime_value.astimezone( pytz.utc).replace(tzinfo=None) value = datetime_value.time() return value, None
def deserialize(self, value): """ Deserialize the given string as a `~datetime.time`. """ if self.format == 'iso8601': try: return isodate.parse_time(value) except isodate.ISO8601Error: raise ValidationError('invalid ISO 8601 time', value=value) else: try: return datetime.datetime.strptime(value, self.format).time() except (TypeError, ValueError): raise ValidationError( 'invalid time, expected format {!r}'.format(self.format), value=value, )
def parse_datetime(datetimestring): ''' Parses ISO 8601 date-times into datetime.datetime objects. This function uses parse_date and parse_time to do the job, so it allows more combinations of date and time representations, than the actual ISO 8601:2004 standard allows. ''' try: datestring, timestring = re.split('T| ', datetimestring) except ValueError: raise isodate.ISO8601Error( "ISO 8601 time designator 'T' or ' ' missing. Unable to parse " "datetime string %r" % datetimestring ) tmpdate = isodate.parse_date(datestring) tmptime = isodate.parse_time(timestring) return datetime.datetime.combine(tmpdate, tmptime)
def userformdata_decode(s): if s.startswith(u'__date__@'): return isodate.parse_date(s[9:19]) if s.startswith(u'__datetime__@'): return isodate.parse_datetime(s[13:32]) if s.startswith(u'__time__@'): return isodate.parse_time(s[9:18]) if s.startswith(u'__richtext__@'): data = json.loads(base64.b64decode(s[13:])) return RichTextValue(raw=data['raw'], mimeType=data['mime'], outputMimeType=data['output_mime'], encoding=data['encoding']) return None
def userformdata_decode(s): if s.startswith(u'__date__@'): return isodate.parse_date(s[9:19]) if s.startswith(u'__datetime__@'): return isodate.parse_datetime(s[13:32]) if s.startswith(u'__time__@'): return isodate.parse_time(s[9:18]) if s.startswith(u'__richtext__@'): data = json.loads(base64.b64decode(s[13:])) return RichTextValue( raw=data['raw'], mimeType=data['mime'], outputMimeType=data['output_mime'], encoding=data['encoding'] ) return None
def deserialize_data(o): if isinstance(o, dict) and set(o.keys()) == {'@type', '@value'}: o_type, o_value = o['@type'], o['@value'] if o_type == 'uuid': return uuid.UUID(o_value) elif o_type == 'decimal': return decimal.Decimal(o_value) elif o_type == 'timedelta': return isodate.parse_duration(o_value) elif o_type == 'time': return isodate.parse_time(o_value) elif o_type == 'date': return isodate.parse_date(o_value) elif o_type == 'datetime': return isodate.parse_datetime(o_value) elif isinstance(o, dict): return {k: deserialize_data(v) for k, v in o.items()} elif isinstance(o, list): return [deserialize_data(v) for v in o] else: return o
def userformdata_decode(string): if not isinstance(string, six.string_types): return string if string.startswith(u'__date__@'): return isodate.parse_date(string[9:]) if string.startswith(u'__datetime__@'): return isodate.parse_datetime(string[13:]) if string.startswith(u'__time__@'): return isodate.parse_time(string[9:]) if string.startswith(u'__richtext__@'): data = json.loads(base64.b64decode(string[13:])) return RichTextValue(raw=data['raw'], mimeType=data['mime'], outputMimeType=data['output_mime'], encoding=data['encoding']) return string
def getDatetime(self, attr): if not attr in self._datetime: content = self.getContent(attr) if content: try: content = content.replace(' ', 'T') if not 'T' in content: if ':' in content: value = isodate.parse_time(content) else: value = isodate.parse_date(content) else: value = isodate.parse_datetime(content) if type(value) is datetime.time: self._datetime[attr] = datetime.datetime.min.replace(hour=value.hour, minute=value.minute, second=value.second, microsecond=value.microsecond, tzinfo=value.tzinfo) elif type(value) is datetime.date: self._datetime[attr] = datetime.datetime(value.year, value.month, value.day, tzinfo=isodate.parse_tzinfo('Z')) else: self._datetime[attr] = value except isodate.ISO8601Error: self._datetime[attr] = None elif attr in self.ATTR_DATETIME_FALLBACK: fallback_attr = self.ATTR_DATETIME_FALLBACK[attr] fallback_value = getattr(self, fallback_attr) if fallback_value and fallback_attr in self.ATTR_DATETIME_RELATION: relation_attr = self.ATTR_DATETIME_RELATION[fallback_attr] if relation_attr.startswith('+'): relation_value = getattr(self, relation_attr[1:]) fallback_value = relation_value + fallback_value elif relation_attr.startswith('-'): relation_value = getattr(self, relation_attr[1:]) fallback_value = relation_value - fallback_value else: relation_value = getattr(self, relation_attr) fallback_value += relation_value self._datetime[attr] = fallback_value else: self._datetime[attr] = None return self._datetime[attr]
def userformdata_decode(string): if not isinstance(string, six.string_types): return string if string.startswith(u'__date__@'): return isodate.parse_date(string[9:]) if string.startswith(u'__datetime__@'): return isodate.parse_datetime(string[13:]) if string.startswith(u'__time__@'): return isodate.parse_time(string[9:]) if string.startswith(u'__richtext__@'): data = json.loads(base64.b64decode(string[13:])) return RichTextValue( raw=data['raw'], mimeType=data['mime'], outputMimeType=data['output_mime'], encoding=data['encoding'] ) return string
def is_iso8601_time(self, to_validate: str) -> bool: try: return bool(isodate.parse_time(to_validate)) except Exception: return False
def time_format_checker(instance): if isinstance(instance, datetime.datetime): return True if isinstance(instance, six.string_types): return isodate.parse_time(instance)
def pythonvalue(self, value): return isodate.parse_time(value)
def end_time(self): if self.request.get('end_time'): return parse_time(self.request.get('end_time')) else: return None
def _from_xml(self, e): s = str(e.text) t = isodate.parse_time(s) return t
def start_time(self): if self.request.get("start_time"): return parse_time(self.request.get("start_time")) else: return None
def put(self, slot_id): try: slot = current_app.db_session.query(RepeatingSlot).filter(RepeatingSlot.id == slot_id).one() except NoResultFound: abort(404, __error__=[u"No slot found with id %d." % slot_id]) ensure(PUT, slot) args = request.get_json() if slot.application.status != 'Granted': abort(400, __error__=[u'Kan ikke frigi tid når søknaden ikke er godkjent']) if slot.end_date <= date.today(): abort(400, __error__=[u'Kan ikke frigi allerede brukt tid']) repeating_slots = [] if "release_from_date" in args or "release_to_date" in args: release_from_date = parse_date(args["release_from_date"]) release_to_date = parse_date(args["release_to_date"]) if release_from_date > release_to_date: abort(400, __error__=[u'Startdato er etter sluttdato']) if release_from_date <= date.today(): abort(400, __error__=[u'Kan kun frigi tid frem i tid']) if release_from_date <= slot.start_date and release_to_date >= slot.end_date: abort(400, __error__=[u'Du kan ikke frigi hele perioden']) intervals = [{ "start": release_from_date - timedelta(days=1), "end": release_to_date + timedelta(days=1) }] periods = self.split_range_by_intervals(slot.start_date, slot.end_date, intervals) for period in periods: repeating_slots.append(RepeatingSlot(slot.application, slot.week_day, period['start'], period['end'], slot.start_time, slot.end_time, )) if "release_from_time" in args or "release_to_time" in args: release_from_time = parse_time(args["release_from_time"]) release_to_time = parse_time(args["release_to_time"]) if release_from_time > release_to_time: abort(400, __error__=[u'Starttidspunkt er etter slutttidspunkt']) if release_from_time <= slot.start_time and release_to_time >= slot.end_time: abort(400, __error__=[u'Du kan ikke frigi hele tidsperioden']) split_slot = slot if slot.start_date <= date.today(): intervals = [{ "start": date.today(), "end": date.today() }] periods = self.split_range_by_intervals(slot.start_date, slot.end_date, intervals) # add period for past repeating_slots.append(RepeatingSlot(slot.application, slot.week_day, periods[0]['start'], periods[0]['end'], slot.start_time, slot.end_time)) # continue splitting the future split_slot = RepeatingSlot(slot.application, slot.week_day, periods[1]['start'], periods[1]['end'], slot.start_time, slot.end_time) intervals = [{ "start": release_from_time, "end": release_to_time }] periods = self.split_range_by_intervals(split_slot.start_time, split_slot.end_time, intervals) for period in periods: repeating_slots.append(RepeatingSlot(split_slot.application, split_slot.week_day, split_slot.start_date + timedelta(days=1), split_slot.end_date, period['start'], period['end'])) # Remove old slot if new slots are generated if len(repeating_slots) > 0: current_app.db_session.delete(slot) # Add new slot(s) for repeating_slot in repeating_slots: current_app.db_session.add(repeating_slot) current_app.db_session.commit() return repeating_slots, 200
def new_duracion(clip): t = parse_time(clip['duracion']) return timedelta(hours=t.hour, minutes=t.minute, seconds=t.second)
def to_time(value): return isodate.parse_time(value)
def to_python(self) -> float: """ """ self._validate() return isodate.parse_time(self)
def start_time(self): if self.request.get('start_time'): return parse_time(self.request.get('start_time')) else: return None
def end_time(self): if self.request.get("end_time"): return parse_time(self.request.get("end_time")) else: return None
def validate_Time(self, value, context=''): try: isodate.parse_time(value) return True except: return False
def _result_processor(self, value): try: return isodate.parse_time(value) except Exception: return datetime.time()
def _parse(self, val): return isodate.parse_time(val)