nix-archive-1(type directoryentry(namelibnode(type directoryentry(name python3.10node(type directoryentry(name site-packagesnode(type directoryentry(nameiso8601node(type directoryentry(name __init__.pynode(typeregularcontents|from .iso8601 import UTC, FixedOffset, ParseError, parse_date __all__ = ["parse_date", "ParseError", "UTC", "FixedOffset"] ))entry(name __pycache__node(type directoryentry(name__init__.cpython-310.pycnode(typeregularcontentsZo 8\a5{@s$ddlmZmZmZmZgdZdS))UTC FixedOffset ParseError parse_date)rrrrN)Ziso8601rrrr__all__rrq/gnu/store/phmi052xsj2b515mp7x2hhr9xnn8gwbn-python-iso8601-1.0.2/lib/python3.10/site-packages/iso8601/__init__.pys ))entry(nameiso8601.cpython-310.pycnode(typeregularcontentsBo J"LO@sdZddlZddlZddlZddlmZgdZedejZ Gddde Z ej j Zded ed ed ej fd d Zefdejeefdejej d ejej fddZefdedejej d ejfddZdS)zISO 8601 date time string parsing Basic usage: >>> import iso8601 >>> iso8601.parse_date("2007-01-25T12:00:00Z") datetime.datetime(2007, 1, 25, 12, 0, tzinfo=) >>> N)Decimal) parse_date ParseErrorUTC FixedOffsetaB (?P[0-9]{4}) ( ( (-(?P[0-9]{1,2})) | (?P[0-9]{2}) (?!$) # Don't allow YYYYMM ) ( ( (-(?P[0-9]{1,2})) | (?P[0-9]{2}) ) ( ( (?P[ T]) (?P[0-9]{2}) (:{0,1}(?P[0-9]{2})){0,1} ( :{0,1}(?P[0-9]{1,2}) ([.,](?P[0-9]+)){0,1} ){0,1} (?P Z | ( (?P[-+]) (?P[0-9]{2}) :{0,1} (?P[0-9]{2}){0,1} ) ){0,1} ){0,1} ) ){0,1} # YYYY-MM ){0,1} # YYYY only $ c@seZdZdZdS)rz4Raised when there is a problem parsing a date stringN)__name__ __module__ __qualname____doc__r r p/gnu/store/phmi052xsj2b515mp7x2hhr9xnn8gwbn-python-iso8601-1.0.2/lib/python3.10/site-packages/iso8601/iso8601.pyr@sr offset_hoursoffset_minutesnamereturncCsttj||d|S)N)hoursminutes)datetimetimezoneZ timedelta)r rrr r r rGsrmatchesdefault_timezonecCs|dd}|dkr tS|dur|S|dd}t|dd}t|dd}||dd |d}|d kr=| }| }t|||S) z3Parses ISO 8601 time zone specs into tzinfo offsetsrNZZtz_signZtz_hourrZ tz_minuteZ02d:-)getrintr)rrZtzsignrr descriptionr r r parse_timezoneOs   r datestringcCszt|}Wnty}zt|d}~ww|s!td|dd|D}zMtjt|ddt|d|dd t|d |d d t|d dt|d dt|ddtt d|ddt dt ||ddWSty}zt|d}~ww)aParses ISO 8601 dates into datetime objects The timezone is parsed from the date string. However it is quite common to have dates without a timezone (not strictly correct). In this case the default timezone specified in default_timezone is used. This is UTC by default. :param datestring: The date to parse as a string :param default_timezone: A datetime tzinfo instance to use when no timezone is specified in the datestring. If this is set to None then a naive datetime object is returned. :returns: A datetime.datetime instance :raises: ParseError when there is a problem parsing the date or constructing the datetime instance. NzUnable to parse date string cSsi|] \}}|dur||qS)Nr ).0kvr r r s  zparse_date..yearrmonthZ monthdashdayZdaydashhourminutesecondz0.Zsecond_fractionz 1000000.0)r)r$r%r'r(r)r*Z microsecondZtzinfo) ISO8601_REGEXmatch Exceptionr groupdictitemsrrrrr)rrmegroupsr r r rfs8   r)r rretypingZdecimalr__all__compileVERBOSEr+ ValueErrorrrZutcrfloatstrrZDictZOptionalrrr r r r sJ  (-       ))entry(nametest_iso8601.cpython-310.pycnode(typeregularcontentsTo T7i*@sddlmZddlZddlZddlZddlZddlZddlZddlZddl m Z dddZ ddd Z dd d Z dd d ZejdgddededdfddZejddeddddddde jdfdedddd d!dde ddd"d#fd$edddd%ddde jd&fd'ed(d)d!d*dd+d,e d-d.d/dfd0ed(d)d!d*dd+de jd1fd2edd3dd4d5d6d7e jd8fd9ed(d)d!d*dd+d,e jd:fd;edfd?edfd\ed]d^d dd_d`dae dddbd\fdced(d)d!d*dd+d,e d-d.d/ddfdeejdfd-dAe jdgdhfdiedjdd!d*dkdldme dddbdnfdoejdjdd^e jdgdpfdqedrdAd^dd!dsdte dudOdvdwfdxedd%dyddzdd{e jd|fd}ed~d-ddddde jdfded~dddddde jdfdedd%dyddzdd{e jd|fgdedejdeddfddZejejddejddfddZejejjejjdddejddfddZdS))absolute_importN)iso8601returncCstjdsJdS)Nz2006-10-11T00:14:33Z)rZ ISO8601_REGEXmatchrru/gnu/store/phmi052xsj2b515mp7x2hhr9xnn8gwbn-python-iso8601-1.0.2/lib/python3.10/site-packages/iso8601/test_iso8601.pytest_iso8601_regexsr cCsttdddkdS)Nrz+2:00)datetimetzinfor FixedOffsetrrrrtest_fixedoffset_eqsrc CsNtddd}tjd|d}|tddddddd|ksJ|j|ks%JdS) Nr r test offset2007-01-01T08:00:00Zdefault_timezoner)rr parse_dater r Ztzdrrr(test_parse_no_timezone_different_defaults rc CsBtddd}tjd|d}|tdddddddtjksJd S) z#Z should mean 'UTC', not 'default'.r rrz2007-01-01T08:00:00ZrrrrN)rr rr UTCrrrr test_parse_utc_different_default s&rzinvalid_date, error_string) )z2013-10-Unable to parse date string)z2013-r)r)Zwibbler)Z23r)Z131015T142533Zr)Z131015r)Z20141r)Z201402r)z2007-06-23X06:40:34.00Zr)z2007-06-23 06:40:34.00Zrubbishr)z20114-01-03T01:45:49r invalid_date error_stringcCs^ttj }t|Wdn1swY|tjs#Jt|j|s-JdSN) pytestZraisesrZ ParseErrorrZ errisinstancestrvalue startswith)rrexcrrrtest_parse_invalid_date's  r$z&valid_date,expected_datetime,isoformatz2007-06-23 06:40:34.00Zr("z2007-06-23T06:40:34+00:00z1997-07-16T19:20+01:00iz+01:00z1997-07-16T19:20:00+01:00rrz2007-01-01T08:00:00+00:00z2006-10-20T15:34:56.123+02:30i 8ixr z+02:30z2006-10-20T15:34:56Zz2006-10-20T15:34:56+00:00z2007-5-7T11:43:55.328Z +7i@z 2007-05-07T11:43:55.328000+00:00z2006-10-20T15:34:56.123Zz 2006-10-20T15:34:56.123000+00:00z2013-10-15T18:30Ziz2013-10-15T18:30:00+00:00z2013-10-15T22:30+04z+04:00z2013-10-15T22:30:00+04:00z2013-10-15T1130-0700iz-07:00z2013-10-15T11:30:00-07:00z2013-10-15T1130+0700z+07:00z2013-10-15T11:30:00+07:00z2013-10-15T1130+07z2013-10-15T1130-07z2013-10-15T15:00-03:30iz-03:30z2013-10-15T15:00:00-03:30z2013-10-15T183123Zz2013-10-15T18:31:23+00:00z2013-10-15T1831Zz2013-10-15T18:31:00+00:00z2013-10-15T18Zz2013-10-15T18:00:00+00:00z 2013-10-15z2013-10-15T00:00:00+00:00z20131015T18:30Zz 2012-12-19T23:21:28.512400+00:00i iz+00:00z2006-10-20T15:34:56.123+0230z 2006-10-20T15:34:56.123000+02:30Z19950204i)r z1995-02-04T00:00:00+00:00z 2010-07-20 15:25:52.520701+00:00i4iz 2010-07-20T15:25:52.520701+00:00z 2010-06-12z2010-06-12T00:00:00+00:00z1985-04-12T23:20:50.52-05:30i2i@z-05:30z 1985-04-12T23:20:50.520000-05:30z1997-08-29T06:14:00.000123Z{z 1997-08-29T06:14:00.000123+00:00z2014-02iz2014-02-01T00:00:00+00:00Z2014z2014-01-01T00:00:00+00:00z1997-08-29T06:14:00,000123Z valid_dateexpected_datetime isoformatcCst|}|j|jks J|j|jksJ|j|jksJ|j|jks%J|j|jks-J|j|jks5J|j|jks=J|j |j ksEJ||ksKJ| | ksUJt |t ||ri| |ksiJt| |kstJdSr)rrZyearZmonthZdayZhourZminutesecondZ microsecondr rFcopyZdeepcopypickledumps)rDrErFparsedrrrtest_parse_valid_dateEs" 2   rL)srMcCs>|}tj|dd}t|d|d|||ksJdS)Nr rFrrprintrMZ as_stringrKrrr%test_hypothesis_valid_naive_datetimessrR) timezonescCs:|}t|}t|d|d|||ksJdS)NrNrOrQrrr-test_hypothesis_valid_datetimes_with_timezones rT)rN)Z __future__rrHr rIZ hypothesisZhypothesis.extra.pytzZhypothesis.strategiesrrrr rrrZmarkZ parametrizer r$rr rLZgivenZ strategiesZ datetimesrRZextraZpytzrSrTrrrrsf      / ))))entry(name iso8601.pynode(typeregularcontents"""ISO 8601 date time string parsing Basic usage: >>> import iso8601 >>> iso8601.parse_date("2007-01-25T12:00:00Z") datetime.datetime(2007, 1, 25, 12, 0, tzinfo=) >>> """ import datetime import re import typing from decimal import Decimal __all__ = ["parse_date", "ParseError", "UTC", "FixedOffset"] # Adapted from http://delete.me.uk/2005/03/iso8601.html ISO8601_REGEX = re.compile( r""" (?P[0-9]{4}) ( ( (-(?P[0-9]{1,2})) | (?P[0-9]{2}) (?!$) # Don't allow YYYYMM ) ( ( (-(?P[0-9]{1,2})) | (?P[0-9]{2}) ) ( ( (?P[ T]) (?P[0-9]{2}) (:{0,1}(?P[0-9]{2})){0,1} ( :{0,1}(?P[0-9]{1,2}) ([.,](?P[0-9]+)){0,1} ){0,1} (?P Z | ( (?P[-+]) (?P[0-9]{2}) :{0,1} (?P[0-9]{2}){0,1} ) ){0,1} ){0,1} ) ){0,1} # YYYY-MM ){0,1} # YYYY only $ """, re.VERBOSE, ) class ParseError(ValueError): """Raised when there is a problem parsing a date string""" UTC = datetime.timezone.utc def FixedOffset( offset_hours: float, offset_minutes: float, name: str ) -> datetime.timezone: return datetime.timezone( datetime.timedelta(hours=offset_hours, minutes=offset_minutes), name ) def parse_timezone( matches: typing.Dict[str, str], default_timezone: typing.Optional[datetime.timezone] = UTC, ) -> typing.Optional[datetime.timezone]: """Parses ISO 8601 time zone specs into tzinfo offsets""" tz = matches.get("timezone", None) if tz == "Z": return UTC # This isn't strictly correct, but it's common to encounter dates without # timezones so I'll assume the default (which defaults to UTC). # Addresses issue 4. if tz is None: return default_timezone sign = matches.get("tz_sign", None) hours = int(matches.get("tz_hour", 0)) minutes = int(matches.get("tz_minute", 0)) description = f"{sign}{hours:02d}:{minutes:02d}" if sign == "-": hours = -hours minutes = -minutes return FixedOffset(hours, minutes, description) def parse_date( datestring: str, default_timezone: typing.Optional[datetime.timezone] = UTC ) -> datetime.datetime: """Parses ISO 8601 dates into datetime objects The timezone is parsed from the date string. However it is quite common to have dates without a timezone (not strictly correct). In this case the default timezone specified in default_timezone is used. This is UTC by default. :param datestring: The date to parse as a string :param default_timezone: A datetime tzinfo instance to use when no timezone is specified in the datestring. If this is set to None then a naive datetime object is returned. :returns: A datetime.datetime instance :raises: ParseError when there is a problem parsing the date or constructing the datetime instance. """ try: m = ISO8601_REGEX.match(datestring) except Exception as e: raise ParseError(e) if not m: raise ParseError(f"Unable to parse date string {datestring!r}") # Drop any Nones from the regex matches # TODO: check if there's a way to omit results in regexes groups: typing.Dict[str, str] = { k: v for k, v in m.groupdict().items() if v is not None } try: return datetime.datetime( year=int(groups.get("year", 0)), month=int(groups.get("month", groups.get("monthdash", 1))), day=int(groups.get("day", groups.get("daydash", 1))), hour=int(groups.get("hour", 0)), minute=int(groups.get("minute", 0)), second=int(groups.get("second", 0)), microsecond=int( Decimal(f"0.{groups.get('second_fraction', 0)}") * Decimal("1000000.0") ), tzinfo=parse_timezone(groups, default_timezone=default_timezone), ) except Exception as e: raise ParseError(e) ))entry(namepy.typednode(typeregularcontents))entry(nametest_iso8601.pynode(typeregularcontents(# coding=UTF-8 from __future__ import absolute_import import copy import datetime import pickle import hypothesis import hypothesis.extra.pytz import hypothesis.strategies import pytest from . import iso8601 def test_iso8601_regex() -> None: assert iso8601.ISO8601_REGEX.match("2006-10-11T00:14:33Z") def test_fixedoffset_eq() -> None: # See https://bitbucket.org/micktwomey/pyiso8601/issues/19 datetime.tzinfo() == iso8601.FixedOffset(2, 0, "+2:00") def test_parse_no_timezone_different_default() -> None: tz = iso8601.FixedOffset(2, 0, "test offset") d = iso8601.parse_date("2007-01-01T08:00:00", default_timezone=tz) assert d == datetime.datetime(2007, 1, 1, 8, 0, 0, 0, tz) assert d.tzinfo == tz def test_parse_utc_different_default() -> None: """Z should mean 'UTC', not 'default'.""" tz = iso8601.FixedOffset(2, 0, "test offset") d = iso8601.parse_date("2007-01-01T08:00:00Z", default_timezone=tz) assert d == datetime.datetime(2007, 1, 1, 8, 0, 0, 0, iso8601.UTC) @pytest.mark.parametrize( "invalid_date, error_string", [ ("2013-10-", "Unable to parse date string"), ("2013-", "Unable to parse date string"), ("", "Unable to parse date string"), ("wibble", "Unable to parse date string"), ("23", "Unable to parse date string"), ("131015T142533Z", "Unable to parse date string"), ("131015", "Unable to parse date string"), ("20141", "Unable to parse date string"), ("201402", "Unable to parse date string"), ( "2007-06-23X06:40:34.00Z", "Unable to parse date string", ), # https://code.google.com/p/pyiso8601/issues/detail?id=14 ( "2007-06-23 06:40:34.00Zrubbish", "Unable to parse date string", ), # https://code.google.com/p/pyiso8601/issues/detail?id=14 ("20114-01-03T01:45:49", "Unable to parse date string"), ], ) def test_parse_invalid_date(invalid_date: str, error_string: str) -> None: with pytest.raises(iso8601.ParseError) as exc: iso8601.parse_date(invalid_date) assert exc.errisinstance(iso8601.ParseError) assert str(exc.value).startswith(error_string) @pytest.mark.parametrize( "valid_date,expected_datetime,isoformat", [ ( "2007-06-23 06:40:34.00Z", datetime.datetime(2007, 6, 23, 6, 40, 34, 0, iso8601.UTC), "2007-06-23T06:40:34+00:00", ), # Handle a separator other than T ( "1997-07-16T19:20+01:00", datetime.datetime( 1997, 7, 16, 19, 20, 0, 0, iso8601.FixedOffset(1, 0, "+01:00") ), "1997-07-16T19:20:00+01:00", ), # Parse with no seconds ( "2007-01-01T08:00:00", datetime.datetime(2007, 1, 1, 8, 0, 0, 0, iso8601.UTC), "2007-01-01T08:00:00+00:00", ), # Handle timezone-less dates. Assumes UTC. http://code.google.com/p/pyiso8601/issues/detail?id=4 ( "2006-10-20T15:34:56.123+02:30", datetime.datetime( 2006, 10, 20, 15, 34, 56, 123000, iso8601.FixedOffset(2, 30, "+02:30") ), None, ), ( "2006-10-20T15:34:56Z", datetime.datetime(2006, 10, 20, 15, 34, 56, 0, iso8601.UTC), "2006-10-20T15:34:56+00:00", ), ( "2007-5-7T11:43:55.328Z", datetime.datetime(2007, 5, 7, 11, 43, 55, 328000, iso8601.UTC), "2007-05-07T11:43:55.328000+00:00", ), # http://code.google.com/p/pyiso8601/issues/detail?id=6 ( "2006-10-20T15:34:56.123Z", datetime.datetime(2006, 10, 20, 15, 34, 56, 123000, iso8601.UTC), "2006-10-20T15:34:56.123000+00:00", ), ( "2013-10-15T18:30Z", datetime.datetime(2013, 10, 15, 18, 30, 0, 0, iso8601.UTC), "2013-10-15T18:30:00+00:00", ), ( "2013-10-15T22:30+04", datetime.datetime( 2013, 10, 15, 22, 30, 0, 0, iso8601.FixedOffset(4, 0, "+04:00") ), "2013-10-15T22:30:00+04:00", ), #