www.ravenbrook.com - dates.cpython-36.pyc

3

X'ícGã'@sdZddlZddlZddlZddlmZmZmZmZddl	m
Z
ddlmZm
Z
mZddlmZmZdZedZeZeZeZd	d
ZddZd
dZdpddZdqddZdrddZdsddZGdddZddefddZddefddZ ddefd d!Z!ddefd"d#Z"defd$d%Z#d&efd'd(Z$d&efd)d*Z%d&efd+d,Z&dd-ed.fd/d0Z'ded.fd1d2Z(dd-d.edd.fd3d4Z)dd&efd5d6Z*dd&defd7d8Z+dd&defd9d:Z,ddd;efd<d=Z-dZ.dJdLd.d-efdMdNZ/dOdPZ0ddd;efdQdRZ1ddefdSdTZ2GdUdVdVe3Z4ed&fdWdXZ5ed&fdYdZZ6Gd[d\d\Z7Gd]d^d^Z8dKd_d`dadbgddddKd_d`dadbgdKd_d`dadbgdKd_d`dadbgdKd_d`dadbgdKd_gdKgdKd_gdKd_d`gdKgddKd_d`dadbdcgdKd_d`dadbdcgdKd`dadbdcgdKd_d`dadbgdKd_d`dadbgdKd_d`dadbgdKd_gdKd_gdKd_gdKd_gdKd_gdKd_gdddKd_d`dagdKd_d`dadbgdKdagdKdagdKd_d`dagdKd_d`dadbgdKd_d`dadbgdd#Z9deZ:iZ;dfdgZ<dhdiZ=djdkZ>dldmZ?ddndoZ@dS)a
    babel.dates
    ~~~~~~~~~~~

    Locale dependent formatting and parsing of dates and times.

    The default locale for the functions in this module is determined by the
    following environment variables, in that order:

     * ``LC_TIME``,
     * ``LC_ALL``, and
     * ``LANG``

    :copyright: (c) 2013-2022 by the Babel Team.
    :license: BSD, see LICENSE for more details.
éN)ÚdateÚdatetimeÚtimeÚ	timedelta)Úbisect_right)Údefault_localeÚ
get_globalÚLocale)ÚUTCÚLOCALTZu	âââÚLC_TIMEcCs|dkrtj}t}nbt|tr.d}t|}nJt|trBd}t}n6t|ttfrpt	|}|j
dk	rj|j
}qxt}nd}|}||fS)z¦
    Parse a `dt_or_tzinfo` value into a datetime and a tzinfo.

    See the docs for this function's callers for semantics.

    :rtype: tuple[datetime, tzinfo]
    N)rÚnowrÚ
isinstanceÚstrÚget_timezoneÚintr
rÚ
_get_datetimeÚtzinfo)Údt_or_tzinfoÚdtr©rú,/tmp/pip-build-gk9425m9/babel/babel/dates.pyÚ_get_dt_and_tzinfo/s"



rcCsLt|\}}t|dr|jSt|dr6|jdk	r6|jS|j|pDtjSdS)z[
    Get the timezone name out of a time, datetime, or tzinfo object.

    :rtype: str
    ÚzoneÚkeyN)rÚhasattrrrÚtznamerÚutcnow)rrrrrrÚ_get_tz_nameLs
rcCsp|dkrtjSt|ts$t|tr.tj|St|trHtjtj	|St|trlt|t
rltj|tS|S)aX
    Get a datetime out of an "instant" (date, time, datetime, number).

    .. warning:: The return values of this function may depend on the system clock.

    If the instant is None, the current moment is used.
    If the instant is a time, it's augmented with today's date.

    Dates are converted to naive datetimes with midnight as the time component.

    >>> _get_datetime(date(2015, 1, 1))
    datetime.datetime(2015, 1, 1, 0, 0)

    UNIX timestamps are converted to datetimes.

    >>> _get_datetime(1400000000)
    datetime.datetime(2014, 5, 13, 16, 53, 20)

    Other values are passed through as-is.

    >>> x = datetime(2015, 1, 1)
    >>> _get_datetime(x) is x
    True

    :param instant: date, time, datetime, integer, float or None
    :type instant: date|time|datetime|int|float|None
    :return: a datetime
    :rtype: datetime
    N)Ú	datetime_rrrÚfloatÚutcfromtimestamprÚcombinerÚtodayr)Úinstantrrrr[s

rcCsD|jdkr|jtd}|dk	r@|jt|}t|dr@|j|}|S)a+
    Ensure the datetime passed has an attached tzinfo.

    If the datetime is tz-naive to begin with, UTC is attached.

    If a tzinfo is passed in, the datetime is normalized to that timezone.

    >>> _ensure_datetime_tzinfo(datetime(2015, 1, 1)).tzinfo.zone
    'UTC'

    >>> tz = get_timezone("Europe/Stockholm")
    >>> _ensure_datetime_tzinfo(datetime(2015, 1, 1, 13, 15, tzinfo=UTC), tzinfo=tz).hour
    14

    :param datetime: Datetime to augment.
    :param tzinfo: Optional tznfo.
    :return: datetime with tzinfo
    :rtype: datetime
    N)rÚ	normalize)rÚreplacer
Ú
astimezonerrr%)rrrrrÚ_ensure_datetime_tzinfos


r(cCs|dkrtj}nt|ttfr*tj|}|jdkr@|jtd}t|trz|dk	rp|j	|}t
|drp|j|}|j}n|dk	r|j|d}|S)zÃ
    Get a timezoned time from a given instant.

    .. warning:: The return values of this function may depend on the system clock.

    :param time: time, datetime or None
    :rtype: time
    N)rr%)
rrrrr r!rr&r
r'rr%Útimetz)rrrrrÚ	_get_time¢s	







r*cCsL|dkrtSt|ts|Sy
tj|Stjk
rFtd|YnXdS)aéLooks up a timezone by name and returns it.  The timezone object
    returned comes from ``pytz`` and corresponds to the `tzinfo` interface and
    can be used with all of the functions of Babel that operate with dates.

    If a timezone is not known a :exc:`LookupError` is raised.  If `zone`
    is ``None`` a local zone object is returned.

    :param zone: the name of the timezone to look up.  If a timezone object
                 itself is passed in, mit's returned unchanged.
    NzUnknown timezone %s)rrrÚ_pytzÚtimezoneZUnknownTimeZoneErrorÚLookupError)rrrrr¼s

rcCsªtjdtdt|}t|jdd}t|ds8tdyBtdt	|j
|}|j|d}|j|}|j|}|j|}Wnt
tfk
rdSXt|j
||||d	S)
a¼Given a timezone it will return a :class:`TimezoneTransition` object
    that holds the information about the next timezone transition that's going
    to happen.  For instance this can be used to detect when the next DST
    change is going to happen and how it looks like.

    The transition is calculated relative to the given datetime object.  The
    next transition that follows the date is used.  If a transition cannot
    be found the return value will be `None`.

    Transition information can only be provided for timezones returned by
    the :func:`get_timezone` function.

    This function is pending deprecation with no replacement planned in the
    Babel library.

    :param zone: the timezone for which the transition should be looked up.
                 If not provided the local timezone is used.
    :param dt: the date after which the next transition should be found.
               If not given the current time is assumed.
    zªget_next_timezone_transition() is deprecated and will be removed in the next version of Babel. Please see https://github.com/python-babel/babel/issues/716 for discussion.)ÚcategoryN)rÚ_utc_transition_timeszGiven timezone does not have UTC transition times.  This can happen because the operating system fallback local timezone is used or a custom timezone objectré)Ú	activatesÚfrom_tzinfoÚ	to_tzinfoÚreference_date)ÚwarningsÚwarnÚDeprecationWarningrrr&rÚ	TypeErrorÚmaxrr/Z_transition_infoZ_tzinfosr-Ú
ValueErrorÚTimezoneTransition)rrÚidxZ	old_transZ	new_transZold_tzZnew_tzrrrÚget_next_timezone_transitionÑs(


r=c@sReZdZdZdddZeddZeddZed	d
ZeddZ	d
dZ
dS)r;aLA helper object that represents the return value from
    :func:`get_next_timezone_transition`.

    This class is pending deprecation with no replacement planned in the
    Babel library.

    :field activates:
        The time of the activation of the timezone transition in UTC.
    :field from_tzinfo:
        The timezone from where the transition starts.
    :field to_tzinfo:
        The timezone for after the transition.
    :field reference_date:
        The reference date that was provided.  This is the `dt` parameter
        to the :func:`get_next_timezone_transition`.
    NcCs*tjdtd||_||_||_||_dS)NzTimezoneTransition is deprecated and will be removed in the next version of Babel. Please see https://github.com/python-babel/babel/issues/716 for discussion.)r.)r5r6r7r1r2r3r4)Úselfr1r2r3r4rrrÚ__init__szTimezoneTransition.__init__cCs|jjS)z/The name of the timezone before the transition.)r2Ú_tzname)r>rrrÚfrom_tz&szTimezoneTransition.from_tzcCs|jjS)z.The name of the timezone after the transition.)r3r@)r>rrrÚto_tz+szTimezoneTransition.to_tzcCst|jjjS)z0The UTC offset in seconds before the transition.)rr2Ú
_utcoffsetÚ
total_seconds)r>rrrÚfrom_offset0szTimezoneTransition.from_offsetcCst|jjjS)z/The UTC offset in seconds after the transition.)rr3rCrD)r>rrrÚ	to_offset5szTimezoneTransition.to_offsetcCsd|j|j|jfS)Nz"<TimezoneTransition %s -> %s (%s)>)rArBr1)r>rrrÚ__repr__:szTimezoneTransition.__repr__)N)Ú__name__Ú
__module__Ú__qualname__Ú__doc__r?ÚpropertyrArBrErFrGrrrrr;s

r;Úwidezstand-alonecCstj|j||S)aGReturn the names for day periods (AM/PM) used by the locale.

    >>> get_period_names(locale='en_US')['am']
    u'AM'

    :param width: the width to use, one of "abbreviated", "narrow", or "wide"
    :param context: the context, either "format" or "stand-alone"
    :param locale: the `Locale` object, or a locale string
    )r	ÚparseZday_periods)ÚwidthÚcontextÚlocalerrrÚget_period_namesBs
rRÚformatcCstj|j||S)a*Return the day names used by the locale for the specified format.

    >>> get_day_names('wide', locale='en_US')[1]
    u'Tuesday'
    >>> get_day_names('short', locale='en_US')[1]
    u'Tu'
    >>> get_day_names('abbreviated', locale='es')[1]
    u'mar'
    >>> get_day_names('narrow', context='stand-alone', locale='de_DE')[1]
    u'D'

    :param width: the width to use, one of "wide", "abbreviated", "short" or "narrow"
    :param context: the context, either "format" or "stand-alone"
    :param locale: the `Locale` object, or a locale string
    )r	rNÚdays)rOrPrQrrrÚ
get_day_namesOsrUcCstj|j||S)aîReturn the month names used by the locale for the specified format.

    >>> get_month_names('wide', locale='en_US')[1]
    u'January'
    >>> get_month_names('abbreviated', locale='es')[1]
    u'ene'
    >>> get_month_names('narrow', context='stand-alone', locale='de_DE')[1]
    u'J'

    :param width: the width to use, one of "wide", "abbreviated", or "narrow"
    :param context: the context, either "format" or "stand-alone"
    :param locale: the `Locale` object, or a locale string
    )r	rNÚmonths)rOrPrQrrrÚget_month_namesbsrWcCstj|j||S)aåReturn the quarter names used by the locale for the specified format.

    >>> get_quarter_names('wide', locale='en_US')[1]
    u'1st quarter'
    >>> get_quarter_names('abbreviated', locale='de_DE')[1]
    u'Q1'
    >>> get_quarter_names('narrow', locale='de_DE')[1]
    u'1'

    :param width: the width to use, one of "wide", "abbreviated", or "narrow"
    :param context: the context, either "format" or "stand-alone"
    :param locale: the `Locale` object, or a locale string
    )r	rNZquarters)rOrPrQrrrÚget_quarter_namesssrXcCstj|j|S)a\Return the era names used by the locale for the specified format.

    >>> get_era_names('wide', locale='en_US')[1]
    u'Anno Domini'
    >>> get_era_names('abbreviated', locale='de_DE')[1]
    u'n. Chr.'

    :param width: the width to use, either "wide", "abbreviated", or "narrow"
    :param locale: the `Locale` object, or a locale string
    )r	rNZeras)rOrQrrrÚ
get_era_namessrYÚmediumcCstj|j|S)aReturn the date formatting patterns used by the locale for the specified
    format.

    >>> get_date_format(locale='en_US')
    <DateTimePattern u'MMM d, y'>
    >>> get_date_format('full', locale='de_DE')
    <DateTimePattern u'EEEE, d. MMMM y'>

    :param format: the format to use, one of "full", "long", "medium", or
                   "short"
    :param locale: the `Locale` object, or a locale string
    )r	rNZdate_formats)rSrQrrrÚget_date_formats
r[cCs tj|j}||krd}||S)a;Return the datetime formatting patterns used by the locale for the
    specified format.

    >>> get_datetime_format(locale='en_US')
    u'{1}, {0}'

    :param format: the format to use, one of "full", "long", "medium", or
                   "short"
    :param locale: the `Locale` object, or a locale string
    N)r	rNZdatetime_formats)rSrQÚpatternsrrrÚget_datetime_format¢sr]cCstj|j|S)aReturn the time formatting patterns used by the locale for the specified
    format.

    >>> get_time_format(locale='en_US')
    <DateTimePattern u'h:mm:ss a'>
    >>> get_time_format('full', locale='de_DE')
    <DateTimePattern u'HH:mm:ss zzzz'>

    :param format: the format to use, one of "full", "long", "medium", or
                   "short"
    :param locale: the `Locale` object, or a locale string
    )r	rNZtime_formats)rSrQrrrÚget_time_format³s
r^ÚlongFcCsºtt|}tj|}|jj|}|jddd|j}t|d\}}|r`|dkr`|dkr`dS|dkrx|dkrxd|S|dks|dkrd	}n|d
krd}n|j	dd}|||dfS)
açReturn the timezone associated with the given `datetime` object formatted
    as string indicating the offset from GMT.

    >>> dt = datetime(2007, 4, 1, 15, 30)
    >>> get_timezone_gmt(dt, locale='en')
    u'GMT+00:00'
    >>> get_timezone_gmt(dt, locale='en', return_z=True)
    'Z'
    >>> get_timezone_gmt(dt, locale='en', width='iso8601_short')
    u'+00'
    >>> tz = get_timezone('America/Los_Angeles')
    >>> dt = tz.localize(datetime(2007, 4, 1, 15, 30))
    >>> get_timezone_gmt(dt, locale='en')
    u'GMT-07:00'
    >>> get_timezone_gmt(dt, 'short', locale='en')
    u'-0700'
    >>> get_timezone_gmt(dt, locale='en', width='iso8601_short')
    u'-07'

    The long format depends on the locale, for example in France the acronym
    UTC string is used instead of GMT:

    >>> get_timezone_gmt(dt, 'long', locale='fr_FR')
    u'UTC-07:00'

    .. versionadded:: 0.9

    :param datetime: the ``datetime`` object; if `None`, the current date and
                     time in UTC is used
    :param width: either "long" or "short" or "iso8601" or "iso8601_short"
    :param locale: the `Locale` object, or a locale string
    :param return_z: True or False; Function returns indicator "Z"
                     when local time offset is 0
    éé<irÚZÚ
iso8601_shortz%+03dÚshortz	%+03d%02dÚiso8601z
%+03d:%02dZgmt)
r(rr	rNrÚ	utcoffsetrTÚsecondsÚdivmodÚzone_formats)rrOrQÚreturn_zÚoffsetrgÚhoursÚpatternrrrÚget_timezone_gmtÃs#
rncCstj|}t|}tdj||}|jj|i}|jd}tdj|}||jkrVd}|j|}|r|rttdj|gdkr||S|jd}d|kr¦|d}	n\td	j|}
|j	j|
i}d|krÔ|d}	n.d
|krö|j
d
ddjdd}	n|jdd}	|r|	S|||	|d
S)uVReturn a representation of the given timezone using "location format".

    The result depends on both the local display name of the country and the
    city associated with the time zone:

    >>> tz = get_timezone('America/St_Johns')
    >>> print(get_timezone_location(tz, locale='de_DE'))
    Kanada (St. Johnâs) Zeit
    >>> print(get_timezone_location(tz, locale='en'))
    Canada (St. Johnâs) Time
    >>> print(get_timezone_location(tz, locale='en', return_city=True))
    St. Johnâs
    >>> tz = get_timezone('America/Mexico_City')
    >>> get_timezone_location(tz, locale='de_DE')
    u'Mexiko (Mexiko-Stadt) Zeit'

    If the timezone is associated with a country that uses only a single
    timezone, just the localized country name is returned:

    >>> tz = get_timezone('Europe/Berlin')
    >>> get_timezone_name(tz, locale='de_DE')
    u'Mitteleurop\xe4ische Zeit'

    .. versionadded:: 0.9

    :param dt_or_tzinfo: the ``datetime`` or ``tzinfo`` object that determines
                         the timezone; if `None`, the current date and time in
                         UTC is assumed
    :param locale: the `Locale` object, or a locale string
    :param return_city: True or False, if True then return exemplar city (location)
                        for the time zone
    :return: the localized timezone name using location format

    Úzone_aliasesZregionZzone_territoriesZZZZterritory_zonesr0ÚfallbackZcityÚ
meta_zonesú/Ú_ú )Ú0Ú1)r	rNrrÚgetÚ
time_zonesriZterritoriesÚlenrqÚsplitr&)rrQÚreturn_cityrÚinfoZ
region_formatÚ	territoryZterritory_nameZfallback_formatZ	city_nameÚmetazoneÚ
metazone_inforrrÚget_timezone_locationùs4#



"


rcCs0t|\}}tj|}t|}|dkrN|dkr4d}q^|j|}	|	rHd}q^d}n|dkr^tdtdj||}|rv|S|jj|i}
||
kr¤||
|kr¤|
||Stdj|}|r|j	j|i}||kr||j|}
|dkoì|
t
kr|jd	ij|}
|
r|
S|dk	r$t|||d
St||dS)
aReturn the localized display name for the given timezone. The timezone
    may be specified using a ``datetime`` or `tzinfo` object.

    >>> dt = time(15, 30, tzinfo=get_timezone('America/Los_Angeles'))
    >>> get_timezone_name(dt, locale='en_US')
    u'Pacific Standard Time'
    >>> get_timezone_name(dt, locale='en_US', return_zone=True)
    'America/Los_Angeles'
    >>> get_timezone_name(dt, width='short', locale='en_US')
    u'PST'

    If this function gets passed only a `tzinfo` object and no concrete
    `datetime`,  the returned display name is indenpendent of daylight savings
    time. This can be used for example for selecting timezones, or to set the
    time of events that recur across DST changes:

    >>> tz = get_timezone('America/Los_Angeles')
    >>> get_timezone_name(tz, locale='en_US')
    u'Pacific Time'
    >>> get_timezone_name(tz, 'short', locale='en_US')
    u'PT'

    If no localized display name for the timezone is available, and the timezone
    is associated with a country that uses only a single timezone, the name of
    that country is returned, formatted according to the locale:

    >>> tz = get_timezone('Europe/Berlin')
    >>> get_timezone_name(tz, locale='de_DE')
    u'Mitteleurop\xe4ische Zeit'
    >>> get_timezone_name(tz, locale='pt_BR')
    u'Hor\xe1rio da Europa Central'

    On the other hand, if the country uses multiple timezones, the city is also
    included in the representation:

    >>> tz = get_timezone('America/St_Johns')
    >>> get_timezone_name(tz, locale='de_DE')
    u'Neufundland-Zeit'

    Note that short format is currently not supported for all timezones and
    all locales.  This is partially because not every timezone has a short
    code in every locale.  In that case it currently falls back to the long
    format.

    For more information see `LDML Appendix J: Time Zone Display Names
    <https://www.unicode.org/reports/tr35/#Time_Zone_Fallback>`_

    .. versionadded:: 0.9

    .. versionchanged:: 1.0
       Added `zone_variant` support.

    :param dt_or_tzinfo: the ``datetime`` or ``tzinfo`` object that determines
                         the timezone; if a ``tzinfo`` object is used, the
                         resulting display name will be generic, i.e.
                         independent of daylight savings time; if `None`, the
                         current date in UTC is assumed
    :param width: either "long" or "short"
    :param uncommon: deprecated and ignored
    :param zone_variant: defines the zone variation to return.  By default the
                           variation is defined from the datetime object
                           passed in.  If no datetime object is passed in, the
                           ``'generic'`` variation is assumed.  The following
                           values are valid: ``'generic'``, ``'daylight'`` and
                           ``'standard'``.
    :param locale: the `Locale` object, or a locale string
    :param return_zone: True or False. If true then function
                        returns long time zone ID
    NÚgenericÚdaylightÚstandardzInvalid zone variationrorqrdr_)rOrQ)rQ)rrr)
rr	rNrÚdstr:rrwrxrqÚNO_INHERITANCE_MARKERrnr)rrOÚuncommonrQZzone_variantÚreturn_zonerrrrr|r~rÚnamerrrÚget_timezone_nameEs>G



rcCsV|dkrtj}nt|tr$|j}tj|}|dkrBt||d}t|}|j	||S)a¶Return a date formatted according to the given pattern.

    >>> d = date(2007, 4, 1)
    >>> format_date(d, locale='en_US')
    u'Apr 1, 2007'
    >>> format_date(d, format='full', locale='de_DE')
    u'Sonntag, 1. April 2007'

    If you don't want to use the locale default formats, you can specify a
    custom date pattern:

    >>> format_date(d, "EEE, MMM d, ''yy", locale='en')
    u"Sun, Apr 1, '07"

    :param date: the ``date`` or ``datetime`` object; if `None`, the current
                 date is used
    :param format: one of "full", "long", "medium", or "short", or a custom
                   date/time pattern
    :param locale: a `Locale` object or a locale identifier
    NÚfullr_rZrd)rQ)rr_rZrd)
Údate_r#rrrr	rNr[Ú
parse_patternÚapply)rrSrQrmrrrÚformat_date¼s


rcCsntt||}tj|}|dkrZt||djddjdt||d	|d
jdt|||dSt|j	||Sd	S)
aReturn a date formatted according to the given pattern.

    >>> dt = datetime(2007, 4, 1, 15, 30)
    >>> format_datetime(dt, locale='en_US')
    u'Apr 1, 2007, 3:30:00 PM'

    For any pattern requiring the display of the time-zone, the third-party
    ``pytz`` package is needed to explicitly specify the time-zone:

    >>> format_datetime(dt, 'full', tzinfo=get_timezone('Europe/Paris'),
    ...                 locale='fr_FR')
    u'dimanche 1 avril 2007 \xe0 17:30:00 heure d\u2019\xe9t\xe9 d\u2019Europe centrale'
    >>> format_datetime(dt, "yyyy.MM.dd G 'at' HH:mm:ss zzz",
    ...                 tzinfo=get_timezone('US/Eastern'), locale='en')
    u'2007.04.01 AD at 11:30:00 EDT'

    :param datetime: the `datetime` object; if `None`, the current date and
                     time is used
    :param format: one of "full", "long", "medium", or "short", or a custom
                   date/time pattern
    :param tzinfo: the timezone to apply to the time for display
    :param locale: a `Locale` object or a locale identifier
    rr_rZrd)rQú'Úz{0}N)rrQz{1})rr_rZrd)
r(rr	rNr]r&Úformat_timerrr)rrSrrQrrrÚformat_datetimeÝs


rcCs8t||}tj|}|dkr(t||d}t|j||S)a@	Return a time formatted according to the given pattern.

    >>> t = time(15, 30)
    >>> format_time(t, locale='en_US')
    u'3:30:00 PM'
    >>> format_time(t, format='short', locale='de_DE')
    u'15:30'

    If you don't want to use the locale default formats, you can specify a
    custom time pattern:

    >>> format_time(t, "hh 'o''clock' a", locale='en')
    u"03 o'clock PM"

    For any pattern requiring the display of the time-zone a
    timezone has to be specified explicitly:

    >>> t = datetime(2007, 4, 1, 15, 30)
    >>> tzinfo = get_timezone('Europe/Paris')
    >>> t = tzinfo.localize(t)
    >>> format_time(t, format='full', tzinfo=tzinfo, locale='fr_FR')
    u'15:30:00 heure d\u2019\xe9t\xe9 d\u2019Europe centrale'
    >>> format_time(t, "hh 'o''clock' a, zzzz", tzinfo=get_timezone('US/Eastern'),
    ...             locale='en')
    u"09 o'clock AM, Eastern Daylight Time"

    As that example shows, when this function gets passed a
    ``datetime.datetime`` value, the actual time in the formatted string is
    adjusted to the timezone specified by the `tzinfo` parameter. If the
    ``datetime`` is "naive" (i.e. it has no associated timezone information),
    it is assumed to be in UTC.

    These timezone calculations are **not** performed if the value is of type
    ``datetime.time``, as without date information there's no way to determine
    what a given time would translate to in a different timezone without
    information about whether daylight savings time is in effect or not. This
    means that time values are left as-is, and the value of the `tzinfo`
    parameter is only used to display the timezone name if needed:

    >>> t = time(15, 30)
    >>> format_time(t, format='full', tzinfo=get_timezone('Europe/Paris'),
    ...             locale='fr_FR')
    u'15:30:00 heure normale d\u2019Europe centrale'
    >>> format_time(t, format='full', tzinfo=get_timezone('US/Eastern'),
    ...             locale='en_US')
    u'3:30:00 PM Eastern Standard Time'

    :param time: the ``time`` or ``datetime`` object; if `None`, the current
                 time in UTC is used
    :param format: one of "full", "long", "medium", or "short", or a custom
                   date/time pattern
    :param tzinfo: the time-zone to apply to the time for display
    :param locale: a `Locale` object or a locale identifier
    rr_rZrd)rQ)rr_rZrd)r*r	rNr^rr)rrSrrQrrrrs
7

rTcCs<tj|}|r$||jkr$t||j}|j|}t||||S)aReturn a time and/or date formatted according to the given pattern.

    The skeletons are defined in the CLDR data and provide more flexibility
    than the simple short/long/medium formats, but are a bit harder to use.
    The are defined using the date/time symbols without order or punctuation
    and map to a suitable format for the given locale.

    >>> t = datetime(2007, 4, 1, 15, 30)
    >>> format_skeleton('MMMEd', t, locale='fr')
    u'dim. 1 avr.'
    >>> format_skeleton('MMMEd', t, locale='en')
    u'Sun, Apr 1'
    >>> format_skeleton('yMMd', t, locale='fi')  # yMMd is not in the Finnish locale; yMd gets used
    u'1.4.2007'
    >>> format_skeleton('yMMd', t, fuzzy=False, locale='fi')  # yMMd is not in the Finnish locale, an error is thrown
    Traceback (most recent call last):
        ...
    KeyError: yMMd

    After the skeleton is resolved to a pattern `format_datetime` is called so
    all timezone processing etc is the same as for that.

    :param skeleton: A date time skeleton as defined in the cldr data.
    :param datetime: the ``time`` or ``datetime`` object; if `None`, the current
                 time in UTC is used
    :param tzinfo: the time-zone to apply to the time for display
    :param fuzzy: If the skeleton is not found, allow choosing a skeleton that's
                  close enough to it.
    :param locale: a `Locale` object or a locale identifier
    )r	rNÚdatetime_skeletonsÚmatch_skeletonr)ÚskeletonrrÚfuzzyrQrSrrrÚformat_skeletonBs


rÚyearér`imÚmonthéÚweekéÚdayÚhourÚminuteraÚsecondr0g333333ë?c
sdkrtddkr*tjdtddt|trJt|jd|jn|t	j
fd	d
}x®tD]¦\}}t|}	|	|ks||krp||kr®|	dkr®t
d|	}	tt|	}	j|	}
d
}x.||D]"}|d
k	rÒ|j|
pð|jd}PqÒW|d
krdS|jdt|	SqpWdS)aå	Return a time delta according to the rules of the given locale.

    >>> format_timedelta(timedelta(weeks=12), locale='en_US')
    u'3 months'
    >>> format_timedelta(timedelta(seconds=1), locale='es')
    u'1 segundo'

    The granularity parameter can be provided to alter the lowest unit
    presented, which defaults to a second.

    >>> format_timedelta(timedelta(hours=3), granularity='day',
    ...                  locale='en_US')
    u'1 day'

    The threshold parameter can be used to determine at which value the
    presentation switches to the next higher unit. A higher threshold factor
    means the presentation will switch later. For example:

    >>> format_timedelta(timedelta(hours=23), threshold=0.9, locale='en_US')
    u'1 day'
    >>> format_timedelta(timedelta(hours=23), threshold=1.1, locale='en_US')
    u'23 hours'

    In addition directional information can be provided that informs
    the user if the date is in the past or in the future:

    >>> format_timedelta(timedelta(hours=1), add_direction=True, locale='en')
    u'in 1 hour'
    >>> format_timedelta(timedelta(hours=-1), add_direction=True, locale='en')
    u'1 hour ago'

    The format parameter controls how compact or wide the presentation is:

    >>> format_timedelta(timedelta(hours=3), format='short', locale='en')
    u'3 hr'
    >>> format_timedelta(timedelta(hours=3), format='narrow', locale='en')
    u'3h'

    :param delta: a ``timedelta`` object representing the time difference to
                  format, or the delta in seconds as an `int` value
    :param granularity: determines the smallest unit that should be displayed,
                        the value can be one of "year", "month", "week", "day",
                        "hour", "minute" or "second"
    :param threshold: factor that determines at which point the presentation
                      switches to the next higher unit
    :param add_direction: if this flag is set to `True` the return value will
                          include directional information.  For instance a
                          positive timedelta will include the information about
                          it being in the future, a negative will be information
                          about the value being in the past.
    :param format: the format, can be "narrow", "short" or "long". (
                   "medium" is deprecated, currently converted to "long" to
                   maintain compatibility)
    :param locale: a `Locale` object or a locale identifier
    ÚnarrowrdrZr_z1Format must be one of "narrow", "short" or "long"zU"medium" value for format param of format_timedelta is deprecated. Use "long" instead)r.iQc3sVr0jd|}dkr&|dVn
|dVd|}jdj|ijVdS)NZdate_fieldsrÚfutureZpastz	duration-Z
unit_patterns)Ú_datarw)Za_unitZunit_rel_patterns)Ú
add_directionrSrQrgrrÚ_iter_patternsºs
z(format_timedelta.<locals>._iter_patternsrr0NÚotherrz{0})r¢rdrZr_)r8r5r6r7rrrrTrgr	rNÚTIMEDELTA_UNITSÚabsr9ÚroundÚplural_formrwr&r)
ÚdeltaZgranularityÚ	thresholdr¥rSrQr¦ÚunitZ
secs_per_unitÚvaluer«rmr\r)r¥rSrQrgrÚformat_timedeltass6:





r°cs²jkrfdd}nXtdd||fDr@fdd}n4tdd||fDrffdd}nfdd}||}||}||kr||Sjjdd	jd
|jd|S)Ncst|dS)N)rQ)r)r)rQrrrrÚ<lambda>Úsz+_format_fallback_interval.<locals>.<lambda>css$|]}t|tot|tVqdS)N)rrr)Ú.0Údrrrú	<genexpr>Ûsz,_format_fallback_interval.<locals>.<genexpr>cst|dS)N)rQ)r)r)rQrrr±Üscss$|]}t|tot|tVqdS)N)rrr)r²r³rrrr´Ýscst|dS)N)rrQ)r)r)rQrrrr±Þscst|dS)N)rrQ)r)r)rQrrrr±àsz{0}-{1}z{0}z{1})rÚallÚinterval_formatsrwr&)ÚstartÚendrrrQrSZformatted_startZ
formatted_endr)rQrrrÚ_format_fallback_intervalØs
r¹cstjj}||ks|rJ|r2|r2t||}nd}|sJt||||S||}||krlt||||dStt||d}tt||d}t|d}t|d}	xNt	D]F}
|
|krª|j
|
|	j
|
krªdjfddt||
||fDSqªWt||||S)uÀ
    Format an interval between two instants according to the locale's rules.

    >>> format_interval(date(2016, 1, 15), date(2016, 1, 17), "yMd", locale="fi")
    u'15.â17.1.2016'

    >>> format_interval(time(12, 12), time(16, 16), "Hm", locale="en_GB")
    '12:12â16:16'

    >>> format_interval(time(5, 12), time(16, 16), "hm", locale="en_US")
    '5:12 AM â 4:16 PM'

    >>> format_interval(time(16, 18), time(16, 24), "Hm", locale="it")
    '16:18â16:24'

    If the start instant equals the end instant, the interval is formatted like the instant.

    >>> format_interval(time(16, 18), time(16, 18), "Hm", locale="it")
    '16:18'

    Unknown skeletons fall back to "default" formatting.

    >>> format_interval(date(2015, 1, 1), date(2017, 1, 1), "wzq", locale="ja")
    '2015/01/01ï½2017/01/01'

    >>> format_interval(time(16, 18), time(16, 24), "xxx", locale="ja")
    '16:18:00ï½16:24:00'

    >>> format_interval(date(2016, 1, 15), date(2016, 1, 17), "xxx", locale="de")
    '15.01.2016 â 17.01.2016'

    :param start: First instant (datetime/date/time)
    :param end: Second instant (datetime/date/time)
    :param skeleton: The "skeleton format" to use for formatting.
    :param tzinfo: tzinfo to use (if none is already attached)
    :param fuzzy: If the skeleton is not found, allow choosing a skeleton that's
                  close enough to it.
    :param locale: A locale object or identifier.
    :return: Formatted interval
    N)rrQ)r)rQrc3s"|]\}}t|j|VqdS)N)rr)r²rmr$)rQrrr´Gsz"format_interval.<locals>.<genexpr>)
r	rNr¶rr¹rr(rÚDateTimeFormatÚPATTERN_CHAR_ORDERÚextractÚjoinÚzip)r·r¸rrrrQr¶Zskel_formatsZ	start_fmtZend_fmtÚfieldr)rQrÚformat_intervalïs,)
	

rÀcCsÂt||}t|jdd|jd|j}tj|}|jj|ij	}x6|D].\}}x$|D]}d|kr\|d|kr\|Sq\WqNWx(|D]\}}x|D]}d|ko®d|kr*|d|dkrè|d|koÜ|dknræ|SnB|d|koþdkns&d|ko|dknr*|Sd}	}
d|krN||dkrNd}	d	|krj||d	krjd}
d|kr||dkrd}
d
|krt
d|	r|
r|SqWqW|dkrºd
SdSdS)uW
    Get the day period ID for a given time.

    This ID can be used as a key for the period name dictionary.

    >>> get_period_names(locale="de")[get_period_id(time(7, 42), locale="de")]
    u'Morgen'

    >>> get_period_id(time(0), locale="en_US")
    u'midnight'

    >>> get_period_id(time(0), type="selection", locale="en_US")
    u'night1'

    :param time: The time to inspect.
    :param tzinfo: The timezone for the time. See ``format_time``.
    :param type: The period type to use. Either "selection" or None.
                 The selection type is used for selecting among phrases such as
                 âYour email arrived yesterday eveningâ or âYour email arrived last nightâ.
    :param locale: the `Locale` object, or a locale string
    :return: period ID. Something is always returned -- even if it's just "am" or "pm".
    raZatÚfromZbeforeiQrFTZtoÚafterz$'after' is deprecated as of CLDR 29.iÀ¨ÚamÚpmN)r*rrr r¡r	rNZday_period_rulesrwÚitemsÚNotImplementedError)rrÚtyperQZseconds_past_midnightZrulesetsZrule_idÚrulesZruleZstart_okZend_okrrrÚ
get_period_idQs>
"

  

rÉc@seZdZdS)Ú
ParseErrorN)rHrIrJrrrrrÊsrÊc
Cs6tjd|}|stdtjd|tjd}|rVyttt|jSt	k
rTYnXt
||djj}|j
d}|j
d}|dkr|j
d	}|j
d
}|df|df|d
fg}	|	jddt|	D}	||	d}
t|
dkrîdt|
}
nt|
}
t||	d}t||	d
}|dkr*||}}t|
||S)aØParse a date from a string.

    This function first tries to interpret the string as ISO-8601
    date format, then uses the date format for the locale as a hint to
    determine the order in which the date fields appear in the string.

    >>> parse_date('4/1/04', locale='en_US')
    datetime.date(2004, 4, 1)
    >>> parse_date('01.04.2004', locale='de_DE')
    datetime.date(2004, 4, 1)
    >>> parse_date('2004-04-01', locale='en_US')
    datetime.date(2004, 4, 1)
    >>> parse_date('2004-04-01', locale='de_DE')
    datetime.date(2004, 4, 1)

    :param string: the string containing the date
    :param locale: a `Locale` object or a locale identifier
    :param format: the format to use (see ``get_date_format``)
    z(\d+)zNo numbers were found in inputz^(\d{4})-?([01]\d)-?([0-3]\d)$)Úflags)rSrQÚyÚmrÚlr³ÚYÚMÚDcSsi|]\}}||dqS)r0r)r²r<Úitemrrrú
<dictcomp>Æszparse_date.<locals>.<dictcomp>éiÐé)ÚreÚfindallrÊÚmatchÚASCIIrÚmaprÚgroupsr:r[rmÚlowerÚindexÚsortÚ	enumeratery)
ÚstringrQrSÚnumbersZ	iso_alikeÚ
format_strZyear_idxZ	month_idxZday_idxÚindexesrrrrrrÚ
parse_dates8





räc
Cstjd|}|stdt||djj}|jd}|dkrF|jd}|jd}|jd}|d	f|d
f|dfg}|jdd
t|D}d}	d|kr¦d|jkr¦d}	d}
}t	||d	|	}t
|dkrút	||d
}
t
|dkrút	||d}t||
|S)aÓParse a time from a string.

    This function uses the time format for the locale as a hint to determine
    the order in which the time fields appear in the string.

    >>> parse_time('15:30:00', locale='en_US')
    datetime.time(15, 30)

    :param string: the string containing the time
    :param locale: a `Locale` object or a locale identifier
    :param format: the format to use (see ``get_time_format``)
    :return: the parsed time
    :rtype: `time`
    z(\d+)zNo numbers were found in input)rSrQÚhrÚkrÍÚsÚHrÐÚScSsi|]\}}||dqS)r0r)r²r<rÒrrrrÓôszparse_time.<locals>.<dictcomp>ÚarÄrÕr0rÔ)rÖr×rÊr^rmrÜrÝrÞrßrryr)
ràrQrSrárâZhour_idxÚmin_idxZsec_idxrãZhour_offsetr r¡rrrrÚ
parse_time×s.



rìc@s4eZdZddZddZddZddZd	d
ZdS)ÚDateTimePatterncCs||_||_dS)N)rmrS)r>rmrSrrrr?szDateTimePattern.__init__cCsdt|j|jfS)Nz<%s %r>)rÇrHrm)r>rrrrGszDateTimePattern.__repr__cCs
|j}|S)N)rm)r>ÚpatrrrÚ__str__szDateTimePattern.__str__cCst|tk	rtS|j|S)N)rÇrºÚNotImplementedrS)r>r§rrrÚ__mod__szDateTimePattern.__mod__cCs|t||S)N)rº)r>rrQrrrrszDateTimePattern.applyN)rHrIrJr?rGrïrñrrrrrrí	s
ríc@s¢eZdZddZddZddZddZd	d
ZddZd
dZ	ddZ
d(ddZddZddZ
ddZddZddZdd Zd!d"Zd)d$d%Zd*d&d'Zd#S)+rºcCsNt|tttfstt|ttfr8|jdkr8|jtd}||_t	j
||_dS)N)r)rrrrÚAssertionErrorrr&r
r¯r	rNrQ)r>r¯rQrrrr?!s
zDateTimeFormat.__init__cCs|d}t|}|dkr$|j||S|d'kr8|j||S|d(krL|j||S|d)kr`|j||S|d*krt|j||S|dkr|j|jj|S|d
kr|j	|S|dkr®|j
S|d+krÂ|j||S|d,krØ|j||S|dkr|jj
ddkr|jd|S|j|jj
d|Snì|dkr2|j|jj
|S|dkrP|j|jj
d|S|dkr|jj
dkrt|jd|S|j|jj
|Sn~|dkr |j|jj|S|dkrº|j|jj|S|dkrÎ|j|S|dkrâ|j|S|d-krø|j||Std&|dS).NrÚGrÌrÏÚuÚQÚqrÐÚLÚwÚWr³rÑÚFÚEÚeÚcrêÚbÚBrårÕrèÚKrær`rÍrçréÚAÚzrbÚvÚVÚxÚXÚOzUnsupported date/time field %r)rÌrÏrô)rõrö)rÐr÷)rørù)rûrürý)rêrþrÿ)rrbrrrrr)ryÚ
format_eraÚformat_yearÚformat_quarterÚformat_monthÚformat_weekrSr¯rÚformat_day_of_yearÚformat_day_of_week_in_monthÚformat_weekdayÚ
format_periodrr r¡Úformat_frac_secondsÚformat_milliseconds_in_dayÚformat_timezoneÚKeyError)r>rÚcharÚnumrrrÚ__getitem__(sZ












zDateTimeFormat.__getitem__cCs¢t|d}|dkr|jjS|dkr,|jjS|dkr<|jjS|dkrL|jjS|dkrd|jjdpbdS|dkrt|jjS|d	krt|jjdkStd
||jfdS)NrrÌrÐr³rèrårÕrÍrêz&Not implemented: extracting %r from %r)	rr¯rrrrr rrÆ)r>rrrrr¼Zs zDateTimeFormat.extractcCs6ddddtd|}t|jjdk}t||j|S)NÚabbreviatedrMr¢)ééérr)r9rr¯rrYrQ)r>rrrOZerarrrrmszDateTimeFormat.format_eracCsB|jj}|jr|jjd}|j||}|dkr>|dd}|S)NrrÔéþÿÿÿ)r¯rÚisupperÚisocalendarrS)r>rrr¯rrrrr	rszDateTimeFormat.format_yearcCsX|jjddd}|dkr(d||fSdddd|}d	d
d|}t|||j|S)Nr0rrÔz%0*drrMr¢)rrrrSzstand-alone)rõrö)r¯rrXrQ)r>rrZquarterrOrPrrrr
{szDateTimeFormat.format_quartercCsL|dkrd||jjfSdddd|}ddd	|}t|||j|jjS)
NrÔz%0*drrMr¢)rrrrSzstand-alone)rÐr÷)r¯rrWrQ)r>rrrOrPrrrrs
zDateTimeFormat.format_monthcCs|jrT|j}|j|}|dkrH|jt|d}|j|j||j}|j||S|j|jj}|dkr|jt|jjd}|j|j|j}d|SdS)Nr)rTz%d)ÚislowerÚget_day_of_yearÚget_week_numberr¯rÚweekdayrSr)r>rrZday_of_yearrrrrrrs

zDateTimeFormat.format_weekrûrcCs~|dkr>|jr:d|jj|jj}|j|dd|Sd}|jj}ddddd|}|d	krhd
}nd}t|||j|S)ai
        Return weekday from parsed datetime according to format pattern.

        >>> format = DateTimeFormat(date(2016, 2, 28), Locale.parse('en_US'))
        >>> format.format_weekday()
        u'Sunday'

        'E': Day of week - Use one through three letters for the abbreviated day name, four for the full (wide) name,
             five for the narrow name, or six for the short name.
        >>> format.format_weekday('E',2)
        u'Sun'

        'e': Local day of week. Same as E except adds a numeric value that will depend on the local starting day of the
             week, using one or two letters. For this example, Monday is the first day of the week.
        >>> format.format_weekday('e',2)
        '01'

        'c': Stand-Alone local day of week - Use one letter for the local numeric value (same as 'e'), three for the
             abbreviated day name, four for the full (wide) name, five for the narrow name, or six for the short name.
        >>> format.format_weekday('c',1)
        '1'

        :param char: pattern format character ('e','E','c')
        :param num: count of format character

        rrr0rrMr¢rd)rrrérýzstand-alonerS)rrQÚfirst_week_dayr¯r"rSrU)r>rrr¯r"rOrPrrrrs
zDateTimeFormat.format_weekdaycCs|j|j|S)N)rSr )r>rrrrr
Âsz!DateTimeFormat.format_day_of_yearcCsd|jjdddS)Nz%dr0r)r¯r)r>rrrrÅsz*DateTimeFormat.format_day_of_week_in_monthcCs¤ddddtd|dddg}|dkr@|jjdkr6dnd	}d
}n t|j|jd}|dkr\d
nd
}x,|D]$}t|||jd}||krf||SqfWtd||jfdS)u)
        Return period from parsed datetime according to format pattern.

        >>> format = DateTimeFormat(time(13, 42), 'fi_FI')
        >>> format.format_period('a', 1)
        u'ip.'
        >>> format.format_period('b', 1)
        u'iltap.'
        >>> format.format_period('b', 4)
        u'iltapÃ¤ivÃ¤'
        >>> format.format_period('B', 4)
        u'iltapÃ¤ivÃ¤llÃ¤'
        >>> format.format_period('B', 5)
        u'ip.'

        >>> format = DateTimeFormat(datetime(2022, 4, 28, 6, 27), 'zh_Hant')
        >>> format.format_period('a', 1)
        u'ä¸å'
        >>> format.format_period('b', 1)
        u'æ¸æ¨'
        >>> format.format_period('B', 1)
        u'æ¸æ¨'

        :param char: pattern format character ('a', 'b', 'B')
        :param num: count of format character

        rrMr¢)rrrrrêrÕrÄrÃrS)rQrÿzstand-alone)rPrOrQz Could not format period %s in %sN)r9r¯rrÉrQrRr:)r>rrZwidthsZperiodrPrOZperiod_namesrrrrÈs

zDateTimeFormat.format_periodcCs&|jjd}|jt||d||S)z Return fractional seconds.

        Rounds the time's microseconds to the precision given by the number         of digits passed in.
        i@Bé
)r¯ÚmicrosecondrSrª)r>rr¯rrrròsz"DateTimeFormat.format_frac_secondscCs<|jjd|jjd|jjd|jjd}|j||S)Nièi`êiî6)r¯r&r¡r rrS)r>rÚmsecsrrrrûs0z)DateTimeFormat.format_milliseconds_in_daycCsäddddtd|}|dkr0t|j||jdS|dkrf|d	krTt|j||jd
dSt|j||jdS|dkr|d
krt|j||jdSnT|dkr¨t|jj||jdS|dkr|dkrÐt|jj|d
|jdS|dkrìt|jj|jd
dS|dkr
t|jj|jd
dSt|jj|jdS|dkr|dkrDt|jd|jd
dS|dkrbt|jd|jd
dS|dkràt|jd|jd
dSn^|dkrà|dkr¨t|jd|jdS|dkrÄt|jd|jdS|dkràt|jd|jdSdS)Nrdr_re)rrrrr)rQrbrT)rQrjrrrrr0)rrQrÔ)rQr)rQr{rrc)rOrQrjr)rOrQ)rÔr)rr)rÔr)rr)r9rr¯rQrnrr)r>rrrOrrrrsN













zDateTimeFormat.format_timezonecCsd||fS)Nz%0*dr)r>r¯ÚlengthrrrrS+szDateTimeFormat.formatNcCs&|dkr|j}||jdddjdS)Nr0)rr)r¯r&rT)r>rrrrr .szDateTimeFormat.get_day_of_yearcCs|dkr|jj}||jj|dd}|dkr:|d7}||dd}d||jjkrb|d7}|jjdkrt|jjdddjd}||kr||8}|S)aReturn the number of the week of a day within a period. This may be
        the week number in a year or the week number in a month.

        Usually this will return a value equal to or greater than 1, but if the
        first week of the period is so short that it actually counts as the last
        week of the previous period, this function will return 0.

        >>> format = DateTimeFormat(date(2006, 1, 8), Locale.parse('de_DE'))
        >>> format.get_week_number(6)
        1

        >>> format = DateTimeFormat(date(2006, 1, 8), Locale.parse('en_US'))
        >>> format.get_week_number(6)
        2

        :param day_of_period: the number of the day in the period (usually
                              either the day of month or the day of year)
        :param day_of_week: the week day; if ommitted, the week day of the
                            current date is assumed
        Nr0rrérÕ)rrr)r¯r"rQr$Z
min_week_daysrrr)r>Z
day_of_periodZday_of_weekZ	first_dayZweek_numberZ	max_weeksrrrr!3s
zDateTimeFormat.get_week_number)rûr)N)N)rHrIrJr?rr¼rr	r
rrrr
rrrrrrSr r!rrrrrºs$2	
(*	+
rºrÔrrrr#)#rórÌrÏrôrõrörÐr÷rørùr³rÑrúÚgrûrürýrêrþrÿrårèrrærÍrçrérrrbrrrrrZ(GyYuUQqMLlwWdDFgEecabBChHKkjJmsSAzZOvVXxcCsÆt|tkr|S|tkr t|Sg}xt|D]x\}}|dkrR|j|jddq.|dkr|\}}t|}|r||krtd|||jd||q.td|q.Wt|dj	|t|<}|S)	aParse date, time, and datetime format patterns.

    >>> parse_pattern("MMMMd").format
    u'%(MMMM)s%(d)s'
    >>> parse_pattern("MMM d, yyyy").format
    u'%(MMM)s %(d)s, %(yyyy)s'

    Pattern can contain literal strings in single quotes:

    >>> parse_pattern("H:mm' Uhr 'z").format
    u'%(H)s:%(mm)s Uhr %(z)s'

    An actual single quote can be used by using two adjacent single quote
    characters:

    >>> parse_pattern("hh' o''clock'").format
    u"%(hh)s o'clock"

    :param pattern: the formatting pattern to parse
    Úcharsú%z%%r¿zInvalid length for field: %rz%%(%s)szUnknown token type: %sr)
rÇríÚ_pattern_cacheÚtokenize_patternÚappendr&Ú
PATTERN_CHARSr:rÆr½)rmÚresultÚtok_typeÚ	tok_valueÚ	fieldcharÚfieldnumÚlimitrîrrrrxs$rcs<gd}gdgdgfdd}fdd}xât|jdd	D]Î\}}|dkrê|d
krdrp|n
rz|g}nh|tkrÐr||dkr°dd7<qèdr¾||d<dd<ndrÞ|j|qH|dk	rH|d
krj|d}qH|j|qHWdr,|nr8|S)ay
    Tokenize date format patterns.

    Returns a list of (token_type, token_value) tuples.

    ``token_type`` may be either "chars" or "field".

    For "chars" tokens, the value is the literal value.

    For "field" tokens, the value is a tuple of (field character, repetition count).

    :param pattern: Pattern string
    :type pattern: str
    :rtype: list[tuple]
    Nrrcs*jddjjddfdd=dS)Nr+rúr)r/r½r&r)Úcharbufr1rrÚappend_chars¼sz&tokenize_pattern.<locals>.append_charscs.jdddffdd<dd<dS)Nr¿rr)r/r)r4r5r1rrÚappend_fieldÀsz&tokenize_pattern.<locals>.append_fieldz''r7rr0)rßr&r0r/Úextend)rmZquotebufr9r:r<rr)r8r4r5r1rr.¦sJ



r.cCs|g}xl|D]d\}}|dkr2|j|d|dq
|dkr
tdd|DsX|j|q
|jd|jdd	q
Wd
j|S)z´
    Turn a date format pattern token stream back into a string.

    This is the reverse operation of ``tokenize_pattern``.

    :type tokens: Iterable[tuple]
    :rtype: str
    r¿rr0r+css|]}|tkVqdS)N)r0)r²Úchrrrr´ùsz%untokenize_pattern.<locals>.<genexpr>z'%s'rz''r)r/Úanyr&r½)ÚtokensÚoutputr2r3rrrÚuntokenize_patternës	r@cCsvt}gg}xZt|D]N\}}|dkrR|d|krD|jg|j|j|d|dj||fqWdd|DS)u
    Split an interval-describing datetime pattern into multiple pieces.

    > The pattern is then designed to be broken up into two pieces by determining the first repeating field.
    - https://www.unicode.org/reports/tr35/tr35-dates.html#intervalFormats

    >>> split_interval_pattern(u'E d.M. â E d.M.')
    [u'E d.M. â ', 'E d.M.']
    >>> split_interval_pattern("Y 'text' Y 'more text'")
    ["Y 'text '", "Y 'more text'"]
    >>> split_interval_pattern(u"E, MMM d â E")
    [u'E, MMM d â ', u'E']
    >>> split_interval_pattern("MMM d")
    ['MMM d']
    >>> split_interval_pattern("y G")
    ['y G']
    >>> split_interval_pattern(u"MMM d â d")
    [u'MMM d â ', u'd']

    :param pattern: Interval pattern string
    :return: list of "subpatterns"
    r¿rr0cSsg|]}t|qSr)r@)r²r>rrrú
<listcomp>#sz*split_interval_pattern.<locals>.<listcomp>éÿÿÿÿ)Úsetr.r/ÚclearÚadd)rmZseen_fieldsÚpartsr2r3rrrÚsplit_interval_patterns
rGcCsHtdd|D}d|kr:tdd|Dr:|jdd}tddt|Dj}d}d}xè|D]à}tddt|Dj}d	}xtD]}	||	d	}
||	d	}|
|kr¨q|d	ks¸|
d	krÌ|sÂd}P|d
7}q|	dkoò|
dkrä|dksö|
dkoò|dkr|d
7}q|t|
|7}qW|sq`|s.||kr6|}|}|d	kr`Pq`W|S)a¦
    Find the closest match for the given datetime skeleton among the options given.

    This uses the rules outlined in the TR35 document.

    >>> match_skeleton('yMMd', ('yMd', 'yMMMd'))
    'yMd'

    >>> match_skeleton('yMMd', ('jyMMd',), allow_different_fields=True)
    'jyMMd'

    >>> match_skeleton('yMMd', ('qyMMd',), allow_different_fields=False)

    >>> match_skeleton('hmz', ('hmv',))
    'hmv'

    :param skeleton: The skeleton to match
    :type skeleton: str
    :param options: An iterable of other skeletons to match against
    :type options: Iterable[str]
    :return: The closest skeleton match, or if no match was found, None.
    :rtype: str|None
    css|]}|r|VqdS)Nr)r²Úoptionrrrr´Esz!match_skeleton.<locals>.<genexpr>rcss|]}d|kVqdS)rNr)r²rHrrrr´Gsrcss"|]}|ddkr|dVqdS)rr¿r0Nr)r²Útrrrr´JsNcss"|]}|ddkr|dVqdS)rr¿r0Nr)r²rIrrrr´NsrirÐrÔé)Úsortedr=r&Údictr.rwr0r©)rÚoptionsZallow_different_fieldsZget_input_field_widthZ
best_skeletonZ
best_distancerHZget_opt_field_widthZdistancer¿Zinput_widthÚ	opt_widthrrrr&s<




*
r)N)N)N)NNiQé3á©rrOiQé'©rrQiQé:	©rrSéQ©rrU©rr©r ra©r¡r0)rPrRrTrVrWrXrY)F)ArKrÖr5Zpytzr+rrrrÚbisectrZ
babel.corerrr	Z
babel.utilr
rrrrrZtime_rrrr(r*rr=r;rRrUrWrXrYr[r]r^rnrrrrrrr¨r°r¹rÀrÉr:rÊrärìrírºr0r»r-rr.r@rGrrrrrÚ<module>s	*



6;
6Lv!%?'cbF<2D
($
"(.E&