def validate_date(self, _date, param):
"""Valida y parsea la fecha pasada.
Args:
_date (str): date string, ISO 8601
param (str): Parámetro siendo parseado
Returns:
date con la fecha parseada
Raises:
ValueError: si el formato no es válido
"""
try:
parsed_date = iso8601.parse_date(_date)
except iso8601.ParseError:
self._append_error(strings.INVALID_DATE.format(param, _date))
raise ValueError
return parsed_date
python类ParseError()的实例源码
def get_times(request):
"""Gets start and endtime from request
As we use no timezone in NAV, remove it from parsed timestamps
:param request: django.http.HttpRequest
"""
starttime = request.GET.get('starttime')
endtime = request.GET.get('endtime')
try:
if starttime:
starttime = iso8601.parse_date(starttime).replace(tzinfo=None)
if endtime:
endtime = iso8601.parse_date(endtime).replace(tzinfo=None)
except iso8601.ParseError:
raise Iso8601ParseError
return starttime, endtime
def to_python(self, value, timezone_in_use):
if isinstance(value, datetime.datetime):
return value.astimezone(pytz.utc) if value.tzinfo else value.replace(tzinfo=pytz.utc)
if isinstance(value, datetime.date):
return datetime.datetime(value.year, value.month, value.day, tzinfo=pytz.utc)
if isinstance(value, int):
return datetime.datetime.utcfromtimestamp(value).replace(tzinfo=pytz.utc)
if isinstance(value, string_types):
if value == '0000-00-00 00:00:00':
return self.class_default
if len(value) == 10:
try:
value = int(value)
return datetime.datetime.utcfromtimestamp(value).replace(tzinfo=pytz.utc)
except ValueError:
pass
try:
# left the date naive in case of no tzinfo set
dt = iso8601.parse_date(value, default_timezone=None)
except iso8601.ParseError as e:
raise ValueError(text_type(e))
# convert naive to aware
if dt.tzinfo is None or dt.tzinfo.utcoffset(dt) is None:
dt = timezone_in_use.localize(dt)
return dt.astimezone(pytz.utc)
raise ValueError('Invalid value for %s - %r' % (self.__class__.__name__, value))
def parse_isotime(timestr, default=None):
"""This duplicates oslo timeutils parse_isotime but with a
@register.filter annotation and a silent fallback on error.
"""
try:
return iso8601.parse_date(timestr)
except (iso8601.ParseError, TypeError):
return default or ''
def parse_isotime(timestr):
"""Parse time from ISO 8601 format"""
try:
return iso8601.parse_date(timestr)
except iso8601.ParseError as e:
raise ValueError(e.message)
except TypeError as e:
raise ValueError(e.message)
def parse_isotime(timestr):
"""Parse time from ISO 8601 format."""
try:
return iso8601.parse_date(timestr)
except iso8601.ParseError as e:
raise ValueError(six.text_type(e))
except TypeError as e:
raise ValueError(six.text_type(e))
def parse_date_utc(date, milliseconds=True):
"""Parses dates from ISO8601 or Epoch formats to a standard datetime object.
This is particularly useful since Habitica returns dates in two
formats::
- iso8601 encoded strings
- Long integer Epoch times
Args:
date (str): A date string in either iso8601 or Epoch format.
milliseconds (bool): If True, then epoch times are treated as
millisecond values, otherwise they are evaluated as seconds.
Returns:
datetime: The parsed date time in UTC.
"""
parsed_date = None
try:
parsed_date = iso8601.parse_date(date)
except iso8601.ParseError:
value = int(date)
# utcfromtimestamp expects values in seconds
if milliseconds:
value /= 1000
parsed_date = datetime.utcfromtimestamp(value)
return parsed_date.replace(tzinfo=pytz.utc)
def parse_date_utc(date, milliseconds=True):
"""Parses dates from ISO8601 or Epoch formats to a standard datetime object.
This is particularly useful since Habitica returns dates in two
formats::
- iso8601 encoded strings
- Long integer Epoch times
Args:
date (str): A date string in either iso8601 or Epoch format.
milliseconds (bool): If True, then epoch times are treated as
millisecond values, otherwise they are evaluated as seconds.
Returns:
datetime: The parsed date time in UTC.
"""
parsed_date = None
try:
parsed_date = iso8601.parse_date(date)
except iso8601.ParseError:
value = int(date)
# utcfromtimestamp expects values in seconds
if milliseconds:
value /= 1000
parsed_date = datetime.utcfromtimestamp(value)
return parsed_date.replace(tzinfo=pytz.utc)
def to_native(self, value, context=None):
if isinstance(value, datetime):
return value
try:
date = parse_date(value, None)
if not date.tzinfo:
date = TZ.localize(date)
return date
except ParseError:
raise ConversionError(self.messages['parse'].format(value))
except OverflowError as e:
raise ConversionError(e.message)
def parse_iso_datetime(value):
# Prevent iso8601 over-zealous datetime parsing
if '-' in value and ':' in value:
try:
value = iso8601.parse_date(value)
except iso8601.ParseError:
pass
return value
def validate_token(token_payload):
'''check for token expiration, secret-key expiration.'''
now = now_utc()
# check token expiration date
issued_at = token_payload.get('issuedAt', None)
ttl = token_payload.get('ttl', None)
if issued_at is None or ttl is None:
return 'missing `issuedAt` or `ttl` in auth token'
try:
iat = iso8601.parse_date(issued_at)
ttl = int(ttl)
except iso8601.ParseError as e:
return 'invalid `issuedAt` date format, expected iso8601. {}'.format(e)
except ValueError:
return 'invaild `ttl` value, expected integer'
token_exp = iat + timedelta(seconds=ttl)
if token_exp < now:
return 'token has expired'
# check for issuing at future - trying to cheat expiration?
# taking timedrift into account
if iat > (now + timedelta(minutes=65)):
return 'invalid `issuedAt` in the future.'
return None
def _parse_date(date):
'''
Parse a date string and return a datetime object.
'''
try:
return iso8601.parse_date(date)
except iso8601.ParseError:
raise S3ViewDateParseError('Unable to parse date: {}'.format(date))
# Service routes.
def datetime(value, default_tzinfo=iso8601.UTC, context=None):
"""validates that a a field is an ISO 8601 string, and converts it to a datetime object."""
if not value:
return
try:
return iso8601.parse_date(value, default_timezone=default_tzinfo)
except iso8601.ParseError as e:
raise ValidationException('Invalid date: %s' % (e))
def parse_date(value):
if isinstance(value, date):
return value
elif isinstance(value, basestring):
try:
return iso8601.parse_date(value).date()
except iso8601.ParseError:
raise ValueError('Not a date.')
else:
raise ValueError('Not a date.')
def parse_datetime(value):
if isinstance(value, datetime):
return value
elif isinstance(value, basestring):
try:
return iso8601.parse_date(value)
except iso8601.ParseError:
raise ValueError('Not a datetime.')
else:
raise ValueError('Not a datetime.')
def parse_isotime(timestr):
"""Parse time from ISO 8601 format."""
try:
return iso8601.parse_date(timestr)
except iso8601.ParseError as e:
raise ValueError(six.text_type(e))
except TypeError as e:
raise ValueError(six.text_type(e))
def parse_datetime(date_string):
try:
date = iso8601.parse_date(date_string)
except iso8601.ParseError:
return None
return date.astimezone(pytz.utc).replace(tzinfo=None)
def do_iso8601_to_str(s, format):
try:
return iso8601.parse_date(s).strftime(format)
except iso8601.ParseError:
return u''
def test_parse_invalid_date():
try:
iso8601.parse_date(None)
except iso8601.ParseError:
pass
else:
assert 1 == 2
def test_parse_invalid_date2():
try:
iso8601.parse_date("23")
except iso8601.ParseError:
pass
else:
assert 1 == 2
def get(self):
reviewee = self.get_query_argument('reviewee', None)
reviewer = self.get_query_argument('reviewer', None)
oldest = self.get_query_argument('oldest', None)
try:
offset = int(self.get_query_argument('offset', 0))
limit = int(self.get_query_argument('limit', 10))
except ValueError:
raise JSONHTTPError(400, body={'errors': [{'id': 'bad_arguments', 'message': 'Bad Arguments'}]})
if reviewee is None and reviewer is None:
raise JSONHTTPError(400, body={'errors': [{'id': 'bad arguments', 'message': 'Bad Arguments'}]})
wheres = []
sql_args = []
if reviewee is not None:
# lowercase the address
reviewee = reviewee.lower()
if not validate_address(reviewee):
raise JSONHTTPError(400, body={'errors': [{'id': 'invalid_address', 'message': 'Invalid Address for `reviewee`'}]})
wheres.append("reviewee_id = ${}".format(len(wheres) + 1))
sql_args.append(reviewee)
if reviewer is not None:
# lowercase the address
reviewer = reviewer.lower()
if not validate_address(reviewer):
raise JSONHTTPError(400, body={'errors': [{'id': 'invalid_address', 'message': 'Invalid Address for `reviewer`'}]})
wheres.append("reviewer_id = ${}".format(len(wheres) + 1))
sql_args.append(reviewer)
if oldest is not None:
try:
oldest = iso8601.parse_date(oldest)
# remove the tzinfo so asyncpg can handle them
# fromutc adds the utc offset to the date, but doesn't remove the tzinfo
# so the final replace is to wipe that out (which doesn't adjust anything else)
oldest = oldest.tzinfo.fromutc(oldest).replace(tzinfo=None)
except iso8601.ParseError:
raise JSONHTTPError(400, body={'errors': [{'id': 'invalid_date', 'message': 'Invalid date for `oldest`'}]})
wheres.append("updated >= ${}".format(len(wheres) + 1))
sql_args.append(oldest)
cnt_sql = "SELECT COUNT(*) FROM reviews WHERE {}".format(" AND ".join(wheres))
sql = "SELECT * FROM reviews WHERE {} ORDER BY updated DESC OFFSET ${} LIMIT ${}".format(
" AND ".join(wheres), len(wheres) + 1, len(wheres) + 2)
async with self.db:
reviews = await self.db.fetch(sql, *sql_args + [offset, limit])
stats = await self.db.fetchrow(cnt_sql, *sql_args)
self.write({
"query": self.request.query,
"total": stats['count'],
"reviews": [render_review(r) for r in reviews],
"offset": offset,
"limit": limit
})
def get(self, org_id, location_id, role_id):
parser = reqparse.RequestParser()
parser.add_argument("start", type=str, required=True)
parser.add_argument("stop", type=str, required=True)
parameters = parser.parse_args()
allow_past = g.current_user.is_sudo(
) or g.current_user.is_org_admin_or_location_manager(org_id,
location_id)
# start time
try:
start = iso8601.parse_date(parameters.get("start"))
except iso8601.ParseError:
return {
"message": "Start time needs to be in ISO 8601 format"
}, 400
else:
start = (start + start.utcoffset()).replace(tzinfo=None)
# stop time
try:
stop = iso8601.parse_date(parameters.get("stop"))
except iso8601.ParseError:
return {"message": "Stop time needs to be in ISO 8601 format"}, 400
else:
stop = (stop + stop.utcoffset()).replace(tzinfo=None)
# stop can't be before start
if start >= stop:
return {"message": "Stop time must be after start time"}, 400
# shifts are limited to 23 hours in length
if int((stop - start).total_seconds()) > MAX_SHIFT_LENGTH:
return {
"message":
"Shifts cannot be more than %s hours long" %
(MAX_SHIFT_LENGTH / SECONDS_PER_HOUR)
}, 400
# create a shift object - do NOT add to db session though
shift = Shift2(role_id=role_id, start=start, stop=stop)
within_caps, exceeds_caps = shift.get_all_eligible_users(
allow_past=allow_past)
marshal_within = [marshal(user, user_fields) for user in within_caps]
marshal_exceeds = [marshal(user, user_fields) for user in exceeds_caps]
for user in marshal_within:
user["within_caps"] = True
for user in marshal_exceeds:
user["within_caps"] = False
return {API_ENVELOPE: marshal_within + marshal_exceeds}
