#!/usr/bin/env python3
"""One interpreter start for the whole of 99-python3-aniso8601.

Emits `key=value' lines, one per line, in file order; the suite reads them back
with grep.  A python3 start on this arm is tens of seconds and every
measurement below is string work over inputs under 40 bytes, so the start is
the entire cost and taking it once is the difference between a half-minute
suite and an hour.

THREE RULES THE VALUES OBEY.

The runner parses its input LINE BY LINE, so no value may contain a newline.
Every value here is a scalar or a comma-joined list of scalars.

No value may be ENCODING-DEPENDENT.  The guest runs under the C locale, so
whether CPython coerces stdout to UTF-8 is a property of the platform rather
than of this package.  Every fixture is ASCII, and the two places this library
could produce something else -- a `datetime.time' carrying a `UTCOffset' and a
`timedelta' repr -- are reported through `isoformat()' and through the
INTEGER FIELDS respectively, never through `repr'.

And no value may be a REPR THAT CARRIES AN ADDRESS.  `UTCOffset' defines
`__repr__' without one, but a generator does not, so a repeating interval is
reported as its `type(...).__name__' and as the isoformat of the values drawn
from it -- never as the object.

WHY A DURATION IS REPORTED FIELD BY FIELD RATHER THAN AS A repr.
`datetime.timedelta' normalises into (days, seconds, microseconds) and its
repr suppresses whichever of the three is zero, so `P1Y' and `P365D' have the
same repr and a release that changed DAYS_PER_YEAR could not be told from one
that changed nothing.  Each duration below emits its three fields separately,
which is also what makes the years-and-months conversion assertable at all.

WHY THIS FILE IS NOT NAMED aniso8601.py.  It sits in
${libdir}/brintos-tests/data and the interpreter puts a script's own directory
FIRST on sys.path, so a probe named after the module would shadow the module it
is measuring.  `module_file' below is the case that would catch it if that ever
stopped being true.
"""

import sys

emitted = []


def emit(key, value):
    emitted.append(key)
    print('%s=%s' % (key, value))


def emit_call(key, fn, *a, **kw):
    """Emit what `fn' returned, or the TYPE of the exception it raised.

    A raise is a first-class expected value here -- the whole `err_*' group
    below asserts ABOUT raising -- so it is reported as `<TypeName>' rather
    than killing the probe and leaving every case after it reading got:''.
    """
    try:
        emit(key, fn(*a, **kw))
    except Exception as exc:                                    # noqa: BLE001
        emit(key, '<%s>' % type(exc).__name__)


def raises(fn, *a, **kw):
    """The name of the exception type `fn' raised, or `<no-raise>'."""
    try:
        fn(*a, **kw)
    except Exception as exc:                                    # noqa: BLE001
        return type(exc).__name__
    return '<no-raise>'


# THE sys.modules BASELINE, TAKEN BEFORE THE IMPORT.  `unexpected_modules' at
# the foot of this file reports the DELTA across the import, not the contents of
# sys.modules -- an interpreter arrives with `encodings', `site' and whatever a
# sitecustomize dragged in already loaded, and a set measured after the fact is
# a statement about the platform rather than about this package.  Measured: on
# an Ubuntu control the absolute set carries 39 names this package never
# mentions (apport_python_hook, zope, zipfile); the delta carries 21, all of
# them stdlib and all of them reachable from the source.
_BASELINE = {m.split('.')[0] for m in sys.modules}

try:
    import aniso8601
except Exception as exc:                                        # pragma: no cover
    print('import_error=%s: %s' % (type(exc).__name__, exc))
    sys.exit(1)

# ...and the set again IMMEDIATELY after it.  It has to be taken here rather
# than at the foot of the file: everything this probe does afterwards --
# `importlib.metadata' most of all, which reaches email, zipfile and csv --
# would otherwise land in a delta that claims to be about aniso8601.  Measured:
# 21 names taken here against 60 taken at the end.
_AFTER_IMPORT = {m.split('.')[0] for m in sys.modules}

from aniso8601 import exceptions as ex

# ---------------------------------------------------------------- identity ---
# WHICH COPY ANSWERED.  Every behavioural case below is a statement about the
# tree named here; without this one they would be statements about whatever was
# first on sys.path.
emit('module_file', getattr(aniso8601, '__file__', ''))
# ...and it is a PACKAGE, not a module.  setup.py uses `find_packages()', so a
# DIRECTORY lands in site-packages -- the opposite shape from python3-parse's
# single file.  A release that flattened to one module would still import and
# still pass every behavioural case below.
emit('is_package', 'yes' if hasattr(aniso8601, '__path__') else 'no')
emit('version_attr', getattr(aniso8601, '__version__', ''))

try:
    from importlib.metadata import version as _dist_version
    emit('dist_version', _dist_version('aniso8601'))
except Exception as exc:                                        # noqa: BLE001
    emit('dist_version', '<%s>' % type(exc).__name__)

# THE PUBLIC SURFACE.  `__init__.py' re-exports ten names and declares no
# `__all__' at all, so `from aniso8601 import *' takes the submodules with it.
# The ten are pinned by name because they are the whole documented API and a
# release that moved one behind a submodule breaks a caller who never touched
# the submodule.
for _n in ('parse_date', 'parse_time', 'parse_datetime', 'parse_duration',
           'parse_interval', 'parse_repeating_interval',
           'get_date_resolution', 'get_time_resolution',
           'get_datetime_resolution', 'get_duration_resolution',
           'get_interval_resolution', 'get_repeating_interval_resolution'):
    emit('has_' + _n, 'yes' if getattr(aniso8601, _n, None) is not None else 'no')
emit('has_all_attr', 'yes' if hasattr(aniso8601, '__all__') else 'no')

# THE SUBMODULES, which are what a caller reaches for `parse_timezone' and for
# the exception classes -- neither is re-exported at package level.
emit('submodules', ','.join(sorted(
    n for n in ('builders', 'compat', 'date', 'decimalfraction', 'duration',
                'exceptions', 'interval', 'resolution', 'time', 'timezone',
                'utcoffset')
    if getattr(aniso8601, n, None) is not None)))

# ------------------------------------------------------- the exception tree ---
# THE SHAPE OF THE ERROR HIERARCHY, WHICH IS NOT THE SHAPE THE NAME SUGGESTS.
# See the suite header: `ISOFormatError' has NO subclasses, and the nine
# range errors descend from `RangeCheckError' instead.  The two meet only at
# ValueError.  Each half is emitted separately so a red says WHICH belief broke.
emit('isoformat_is_valueerror',
     'yes' if issubclass(ex.ISOFormatError, ValueError) else 'no')
emit('rangecheck_is_valueerror',
     'yes' if issubclass(ex.RangeCheckError, ValueError) else 'no')
emit('isoformat_subclasses',
     ','.join(sorted(c.__name__ for c in ex.ISOFormatError.__subclasses__())) or '<none>')
emit('rangecheck_subclasses',
     ','.join(sorted(c.__name__ for c in ex.RangeCheckError.__subclasses__())))
emit('range_under_isoformat',
     'yes' if issubclass(ex.YearOutOfBoundsError, ex.ISOFormatError) else 'no')

# ------------------------------------------------------------- parse_date ---
# THE CALENDAR FORMS, extended and basic, and the reduced precisions.  A
# component the string omits defaults to 1 -- `1984-05' is the first of May and
# `1984' is New Year's Day -- which is a documented behaviour rather than an
# error, and is the one a caller who wanted "just the year" has to know about.
emit_call('date_extended', lambda: aniso8601.parse_date('1984-05-07').isoformat())
emit_call('date_basic', lambda: aniso8601.parse_date('19840507').isoformat())
emit_call('date_month_only', lambda: aniso8601.parse_date('1984-05').isoformat())
emit_call('date_year_only', lambda: aniso8601.parse_date('1984').isoformat())
# A TRUNCATED YEAR IS LEFT-JUSTIFIED WITH ZEROS, not centred on a century:
# `19' is 1900, not 2019 and not 1919.  `year_range_check' pads the string on
# the RIGHT (`valuestr.ljust(4, "0")'), which is the surprising half.
emit_call('date_trunc_year', lambda: aniso8601.parse_date('19').isoformat())

# THE ORDINAL FORM, YYYY-DDD -- day-of-year, which the calendar forms cannot
# express and which is the first of the three the ticket names.
emit_call('date_ordinal', lambda: aniso8601.parse_date('1981-095').isoformat())
emit_call('date_ordinal_basic', lambda: aniso8601.parse_date('1981095').isoformat())
# Day 366 is a statement about the year, not about the format: it parses in a
# leap year and is a DayOutOfBoundsError in any other.  Both directions.
emit_call('date_ordinal_leap', lambda: aniso8601.parse_date('2000-366').isoformat())
emit('date_ordinal_nonleap', raises(aniso8601.parse_date, '1999-366'))

# THE WEEK FORMS, and the reason they are here at all: THE WEEK-NUMBERING YEAR
# IS NOT THE CALENDAR YEAR.  Each of the three below names a year in the string
# and lands in a DIFFERENT year on the calendar, in both directions across a
# New Year boundary.  A caller who reads `YYYY' as the calendar year is wrong
# by up to three days, silently, and only on some years.
emit_call('date_week_start', lambda: aniso8601.parse_date('2004-W53').isoformat())
emit_call('date_weekday', lambda: aniso8601.parse_date('2004-W53-6').isoformat())
emit_call('date_weekday_basic', lambda: aniso8601.parse_date('2004W536').isoformat())
# 2004-W01-1 is in 2003.  2009-W53-7 is in 2010.  2010-W01-1 is in 2010 but is
# the 4th, not the 1st.
emit_call('date_week_back', lambda: aniso8601.parse_date('2004-W01-1').isoformat())
emit_call('date_week_fwd', lambda: aniso8601.parse_date('2009-W53-7').isoformat())
emit_call('date_week_2010', lambda: aniso8601.parse_date('2010-W01-1').isoformat())
# ...and the library's answer agrees with the interpreter's own ISO calendar,
# which is the strongest available statement that the week arithmetic is right
# rather than merely stable.  Computed here rather than written as a literal:
# the point is the AGREEMENT, and a literal would assert only one side of it.
try:
    _wk = aniso8601.parse_date('2004-W53-6').isocalendar()
    emit('date_week_isocalendar', '%d-W%02d-%d' % (_wk[0], _wk[1], _wk[2]))
except Exception as exc:                                        # noqa: BLE001
    emit('date_week_isocalendar', '<%s>' % type(exc).__name__)

# THE RESOLUTION ENUM, which is how a caller learns WHICH form it was handed.
# The values are small ints and the names are what a caller writes, so both are
# emitted: an enum whose members were reordered would keep every parse_date
# case above green.
emit_call('res_date_year', lambda: aniso8601.get_date_resolution('1984'))
emit_call('res_date_month', lambda: aniso8601.get_date_resolution('1984-05'))
emit_call('res_date_week', lambda: aniso8601.get_date_resolution('2004-W53'))
emit_call('res_date_weekday', lambda: aniso8601.get_date_resolution('2004-W53-6'))
emit_call('res_date_day', lambda: aniso8601.get_date_resolution('1984-05-07'))
emit_call('res_date_ordinal', lambda: aniso8601.get_date_resolution('1981-095'))
from aniso8601.resolution import DateResolution as _DR
emit('res_date_names', ','.join('%s=%d' % (n, getattr(_DR, n)) for n in
                                ('Year', 'Month', 'Week', 'Weekday', 'Day', 'Ordinal')))

# ------------------------------------------------------------- parse_time ---
# THE FOUR PRECISIONS, extended and basic.  `hh' alone is a legal time and
# yields minute and second zero.
emit_call('time_hms', lambda: aniso8601.parse_time('11:31:14').isoformat())
emit_call('time_hms_basic', lambda: aniso8601.parse_time('113114').isoformat())
emit_call('time_hm', lambda: aniso8601.parse_time('11:31').isoformat())
emit_call('time_h', lambda: aniso8601.parse_time('11').isoformat())

# THE FRACTIONAL COMPONENT, which may appear on the LOWEST-ORDER element only
# and is carried DOWNWARD into the fields below it.  A fractional hour becomes
# minutes, a fractional minute becomes seconds -- `datetime.time' has no
# fractional hour to put it in.  Three separate cases because they exercise
# three different arms of `_distribute_microseconds'.
emit_call('time_frac_sec', lambda: aniso8601.parse_time('11:31:14.5').isoformat())
emit_call('time_frac_min', lambda: aniso8601.parse_time('11:31.5').isoformat())
emit_call('time_frac_hour', lambda: aniso8601.parse_time('11.5').isoformat())
# THE COMMA IS THE OTHER DECIMAL SEPARATOR, and ISO 8601 prefers it.
# `decimalfraction.normalize' rewrites it, so the two spellings must agree.
emit_call('time_comma_frac', lambda: aniso8601.parse_time('11:31:14,5').isoformat())

# THE UTC OFFSETS, in all four spellings the module accepts.  Reported through
# `isoformat()', which renders the offset itself, so each case is a statement
# about the tzinfo rather than only about the wall-clock fields.
emit_call('time_utc_z', lambda: aniso8601.parse_time('11:31:14Z').isoformat())
emit_call('time_off_ext', lambda: aniso8601.parse_time('11:31:14+04:00').isoformat())
emit_call('time_off_basic', lambda: aniso8601.parse_time('11:31:14-0530').isoformat())
emit_call('time_off_hour', lambda: aniso8601.parse_time('11:31:14+04').isoformat())
# The tzinfo is this library's OWN `UTCOffset', not `datetime.timezone', and
# `Z' is given the name "UTC" rather than the string that produced it.
emit_call('time_tz_class',
          lambda: type(aniso8601.parse_time('11:31:14Z').tzinfo).__name__)
emit_call('time_tz_name', lambda: aniso8601.parse_time('11:31:14Z').tzinfo.tzname(None))
emit_call('time_tz_offset_s',
          lambda: int(aniso8601.parse_time('11:31:14+04:00').utcoffset().total_seconds()))
# `dst()' is always zero by design -- ISO 8601 has offsets, not daylight rules.
emit_call('time_tz_dst_s',
          lambda: int(aniso8601.parse_time('11:31:14+04:00').tzinfo.dst(None).total_seconds()))

# HOUR 24 IS MIDNIGHT AND IS MOVED TO 0, so `24:00:00' does not round-trip as
# the string it came from.  Anything else at hour 24 is a MidnightBoundsError.
emit_call('time_midnight', lambda: aniso8601.parse_time('24:00:00').isoformat())
emit('time_midnight_bad', raises(aniso8601.parse_time, '24:00:01'))
# A LEAP SECOND IS REFUSED.  The hour/minute/second range check admits second
# 60 -- the limit says so -- and the builder then raises anyway, so this is a
# deliberate refusal rather than a range that stops at 59.
emit('time_leap_second', raises(aniso8601.parse_time, '23:59:60'))

emit_call('res_time_sec', lambda: aniso8601.get_time_resolution('11:31:14'))
emit_call('res_time_min', lambda: aniso8601.get_time_resolution('11:31'))
emit_call('res_time_hour', lambda: aniso8601.get_time_resolution('11'))

# --------------------------------------------------------- parse_datetime ---
emit_call('dt_plain',
          lambda: aniso8601.parse_datetime('1981-04-05T23:21:28.512400').isoformat())
emit_call('dt_utc',
          lambda: aniso8601.parse_datetime('1981-04-05T23:21:28.512400Z').isoformat())
emit_call('dt_offset',
          lambda: aniso8601.parse_datetime('1981-04-05T23:21:28.512400+11:15').isoformat())
# THE DELIMITER IS A PARAMETER, not a constant: a space is the other spelling
# in the wild, and it is accepted only when asked for.
emit_call('dt_space',
          lambda: aniso8601.parse_datetime('1981-04-05 23:21:28', delimiter=' ').isoformat())
emit('dt_space_default', raises(aniso8601.parse_datetime, '1981-04-05 23:21:28'))
# THE DATE HALF TAKES ANY DATE FORM, so the week and ordinal forms compose with
# a time.  This is the case that says parse_datetime delegates rather than
# carrying its own date parser.
emit_call('dt_ordinal',
          lambda: aniso8601.parse_datetime('1981-095T23:21:28').isoformat())
emit_call('dt_week',
          lambda: aniso8601.parse_datetime('2004-W53-6T23:21:28').isoformat())
emit_call('res_datetime', lambda: aniso8601.get_datetime_resolution('1981-04-05T23:21:28'))


# --------------------------------------------------------- parse_duration ---
# A timedelta reported FIELD BY FIELD -- see the header for why never as a repr.
def dur(key, s):
    try:
        d = aniso8601.parse_duration(s)
    except Exception as exc:                                    # noqa: BLE001
        emit(key + '_days', '<%s>' % type(exc).__name__)
        emit(key + '_seconds', '<%s>' % type(exc).__name__)
        emit(key + '_micro', '<%s>' % type(exc).__name__)
        return
    emit(key + '_days', d.days)
    emit(key + '_seconds', d.seconds)
    emit(key + '_micro', d.microseconds)


# THE DESIGNATOR FORM, the ticket's own fixture.  3 years + 6 months + 4 days
# is 1279 days only because of the two constants below; every other reading of
# "3 years" gives a different number.
dur('dur_full', 'P3Y6M4DT12H30M5S')
# THE COMBINED DATE-AND-TIME FORM, P<date>T<time>, expressing the SAME duration
# through the date parser instead of the designators.  The two must agree, and
# `dur_combined_agrees' below asserts that directly rather than by comparing two
# literals -- a release that changed the constants would move both together.
dur('dur_combined', 'P0003-06-04T12:30:05')
emit('dur_combined_agrees',
     'yes' if aniso8601.parse_duration('P3Y6M4DT12H30M5S')
     == aniso8601.parse_duration('P0003-06-04T12:30:05') else 'no')

# YEARS AND MONTHS HAVE NO FIXED LENGTH, AND THIS LIBRARY GIVES THEM ONE.
# `datetime.timedelta' cannot carry a calendar year, so the builder converts
# with DAYS_PER_YEAR = 365 and DAYS_PER_MONTH = 30 -- flat, leap years ignored,
# February and July the same length.  Asserted explicitly and on its own,
# because it is the single most likely wrong assumption a caller brings and
# because every arithmetic result above depends on it.
dur('dur_year', 'P1Y')
dur('dur_month', 'P1M')
dur('dur_week', 'P1W')
dur('dur_day', 'P1D')
dur('dur_hour', 'PT1H')
dur('dur_minute', 'PT1M')
dur('dur_second', 'PT1S')
# ...and the constants themselves, read off the builder, so a release that
# changed one is named here rather than only implied by an arithmetic red.
from aniso8601.builders.python import (DAYS_PER_MONTH, DAYS_PER_WEEK,
                                       DAYS_PER_YEAR)
emit('const_days_per_year', DAYS_PER_YEAR)
emit('const_days_per_month', DAYS_PER_MONTH)
emit('const_days_per_week', DAYS_PER_WEEK)
# A YEAR IS NOT A CALENDAR YEAR, stated as the comparison a caller would make.
emit('year_is_365_not_366',
     'yes' if aniso8601.parse_duration('P1Y').days == 365 else 'no')
# ...and twelve months is NOT one year here, which is the corollary nobody
# expects: 12 * 30 = 360.
emit('twelve_months_vs_year',
     'yes' if aniso8601.parse_duration('P12M') == aniso8601.parse_duration('P1Y')
     else 'no')

# FRACTIONAL DURATIONS distribute downward exactly as fractional times do.
dur('dur_frac_sec', 'PT0.5S')
dur('dur_frac_year', 'P0.5Y')
dur('dur_mixed_time', 'PT4H54M6.5S')
# THE COMMA SEPARATOR AGAIN, on the duration side.
emit('dur_comma_agrees',
     'yes' if aniso8601.parse_duration('PT0,5S')
     == aniso8601.parse_duration('PT0.5S') else 'no')
# THE WEEK DESIGNATOR STANDS ALONE and may not be combined with any other.
emit('dur_week_combined', raises(aniso8601.parse_duration, 'P1Y2W'))

emit_call('res_dur_years', lambda: aniso8601.get_duration_resolution('P1Y'))
emit_call('res_dur_months', lambda: aniso8601.get_duration_resolution('P1M'))
emit_call('res_dur_weeks', lambda: aniso8601.get_duration_resolution('P1W'))
emit_call('res_dur_days', lambda: aniso8601.get_duration_resolution('P1D'))
emit_call('res_dur_seconds',
          lambda: aniso8601.get_duration_resolution('P3Y6M4DT12H30M5S'))


# --------------------------------------------------------- parse_interval ---
# An interval is a 2-TUPLE, and each half is reported separately: which end is
# which is the whole point of the `duration/end' case below.
def iv(key, s, **kw):
    try:
        a, b = aniso8601.parse_interval(s, **kw)
    except Exception as exc:                                    # noqa: BLE001
        emit(key + '_0', '<%s>' % type(exc).__name__)
        emit(key + '_1', '<%s>' % type(exc).__name__)
        emit(key + '_types', '<%s>' % type(exc).__name__)
        return
    emit(key + '_0', a.isoformat())
    emit(key + '_1', b.isoformat())
    emit(key + '_types', '%s,%s' % (type(a).__name__, type(b).__name__))


# <start>/<end>, in both the date and the datetime spelling.
iv('iv_start_end', '1980-03-05/1981-04-05')
iv('iv_start_end_dt', '1980-03-05T01:01:00/1981-04-05T01:01:00')
# <start>/<duration> -- the end is computed, and 1980-03-05 + P1M is the 4th of
# April rather than the 5th, because a month is 30 days.
iv('iv_start_dur', '1980-03-05T01:01:00/P1M')
# <duration>/<end>, AND THE TUPLE IS NOT IN CHRONOLOGICAL ORDER.  Upstream
# returns (end, start) here deliberately, "to maintain consistency with parsing
# <start>/<end> durations"; a caller who unpacks it as (start, end) gets the
# two backwards and the code still runs.  `sorted()' is upstream's own advice.
iv('iv_dur_end', 'P1M/1981-04-05T01:01:00')
iv('iv_dur_end_date', 'P1M/1981-04-05')
emit('iv_dur_end_reversed',
     'yes' if aniso8601.parse_interval('P1M/1981-04-05')[0]
     > aniso8601.parse_interval('P1M/1981-04-05')[1] else 'no')
# A DATE START AND A DURATION WITH TIME IN IT GIVES A HETEROGENEOUS TUPLE:
# `date' on one side and `datetime' on the other, because the end needs a
# resolution the start does not have.  A caller subtracting the two gets a
# TypeError, which is why the pair of type names is asserted and not only the
# values.
iv('iv_date_promote', '1980-03-05/P1DT4H')
# THE CONCISE END FORM, where the end omits what it shares with the start --
# both the day-only and the month-day spellings, which must land on the same
# instant.
iv('iv_concise_day', '2007-03-01T13:00:00/15T17:00:00')
iv('iv_concise_monthday', '2007-03-01T13:00:00/03-15T17:00:00')
emit_call('res_interval', lambda: aniso8601.get_interval_resolution('1980-03-05/1981-04-05'))
emit_call('res_interval_dt',
          lambda: aniso8601.get_interval_resolution('1980-03-05T01:01:00/1981-04-05T01:01:00'))

# ----------------------------------------------- parse_repeating_interval ---
# BOTH FORMS RETURN A GENERATOR, the bounded one included -- so `Rnn' is not a
# list, `len()' on it raises, and a caller who indexes it gets a TypeError.
# That is the shape assertion; the values follow.
emit_call('rep_bounded_type',
          lambda: type(aniso8601.parse_repeating_interval('R3/1981-04-05T01:01:00/P1D')).__name__)
emit_call('rep_unbounded_type',
          lambda: type(aniso8601.parse_repeating_interval('R/1981-04-05T01:01:00/P1D')).__name__)
emit('rep_bounded_len',
     raises(len, aniso8601.parse_repeating_interval('R3/1981-04-05T01:01:00/P1D')))
# THE BOUNDED FORM IS TAKEN WHOLE -- three values, and it stops.
emit_call('rep_bounded_values',
          lambda: ','.join(x.isoformat() for x in
                           aniso8601.parse_repeating_interval('R3/1981-04-05T01:01:00/P1D')))
# THE UNBOUNDED FORM NEVER STOPS, so it is taken THREE VALUES AT A TIME and
# never with `list()'.  This is the case that would hang the suite if the
# generator were materialised anywhere.
_g = aniso8601.parse_repeating_interval('R/1981-04-05T01:01:00/P1D')
emit('rep_unbounded_first3', ','.join(next(_g).isoformat() for _ in range(3)))
# ...and it is still going after those three, which is the difference between
# "unbounded" and "happens to have three".
emit_call('rep_unbounded_fourth', lambda: next(_g).isoformat())
# A DURATION-AND-END REPEAT RUNS BACKWARDS, for the same reason the plain
# interval comes back reversed: the anchor is the end and the step is negated.
emit_call('rep_backwards',
          lambda: ','.join(x.isoformat() for x in
                           aniso8601.parse_repeating_interval('R3/P1D/1981-04-05T01:01:00')))
# R1 is one value, and R0 is NONE -- an empty generator rather than an error,
# which is the boundary a caller looping over the result meets first.
emit_call('rep_one',
          lambda: ','.join(x.isoformat() for x in
                           aniso8601.parse_repeating_interval('R1/1981-04-05T01:01:00/P1D')))
emit_call('rep_zero',
          lambda: ','.join(x.isoformat() for x in
                           aniso8601.parse_repeating_interval('R0/1981-04-05T01:01:00/P1D')) or '<empty>')
emit_call('res_rep_interval',
          lambda: aniso8601.get_repeating_interval_resolution('R3/1981-04-05T01:01:00/P1D'))

# ------------------------------------------------------- the failure path ---
# EVERY ENTRY POINT, ASSERTED BY EXCEPTION TYPE RATHER THAN BY MESSAGE.  The
# messages are English prose and a release may reword any of them; the type is
# what a caller's `except' clause names.
#
# MALFORMED INPUT IS `ISOFormatError' AT EVERY ONE OF THE SIX ENTRY POINTS.
emit('err_date_garbage', raises(aniso8601.parse_date, 'asdf'))
emit('err_date_empty', raises(aniso8601.parse_date, ''))
emit('err_time_garbage', raises(aniso8601.parse_time, 'asdf'))
emit('err_time_empty', raises(aniso8601.parse_time, ''))
emit('err_datetime_no_delim', raises(aniso8601.parse_datetime, '1981-04-05'))
emit('err_duration_no_p', raises(aniso8601.parse_duration, '1Y'))
emit('err_duration_bad_end', raises(aniso8601.parse_duration, 'P1YX'))
emit('err_duration_two_decimals', raises(aniso8601.parse_duration, 'P1.5Y1.5M'))
emit('err_interval_no_delim', raises(aniso8601.parse_interval, '1980-03-05'))
emit('err_interval_two_delims', raises(aniso8601.parse_interval, '1/2/3'))
emit('err_interval_empty_half', raises(aniso8601.parse_interval, '1980-03-05/'))
# ...and the two entry points refuse EACH OTHER'S input by name, which is the
# mistake a caller makes first.
emit('err_interval_takes_r', raises(aniso8601.parse_interval, 'R3/1981-04-05/P1D'))
emit('err_repeat_needs_r', raises(aniso8601.parse_repeating_interval, '1981-04-05/P1D'))
emit('err_repeat_no_delim', raises(aniso8601.parse_repeating_interval, 'R3'))

# OUT-OF-RANGE INPUT IS A `RangeCheckError' SUBCLASS -- a different branch of
# the tree, NOT an ISOFormatError.  One case per class, so a red names which.
emit('err_year_zero', raises(aniso8601.parse_date, '0000'))
emit('err_month_13', raises(aniso8601.parse_date, '1981-13-01'))
emit('err_day_32', raises(aniso8601.parse_date, '1981-01-32'))
emit('err_week_54', raises(aniso8601.parse_date, '2004-W54'))
emit('err_hours_25', raises(aniso8601.parse_time, '25:00:00'))
emit('err_minutes_60', raises(aniso8601.parse_time, '11:60:00'))
emit('err_seconds_60', raises(aniso8601.parse_time, '11:31:60'))
# ...and `-00:00' is refused as an OFFSET rather than as a range: ISO 8601 has
# no negative zero offset, and the refusal is an ISOFormatError.
emit('err_negative_zero_tz', raises(aniso8601.parse_time, '11:31:14-00:00'))

# TWO REFUSALS THAT ARE NEITHER, AND THAT `except ISOFormatError' MISSES.
# A non-string argument is a bare `ValueError' -- deliberate, and raised before
# any parsing begins.
emit('err_nonstring_date', raises(aniso8601.parse_date, 4))
emit('err_nonstring_duration', raises(aniso8601.parse_duration, 4))
emit('err_nonstring_interval', raises(aniso8601.parse_interval, 4))
# The EXTENDED YEAR representation (`+2000', `-2000') is `NotImplementedError',
# which is not a ValueError at all -- so a caller wrapping the parse in
# `except ValueError' does not catch it and the process dies on input that is
# perfectly well-formed ISO 8601.
emit('err_extended_year', raises(aniso8601.parse_date, '+2000'))
emit('err_extended_year_neg', raises(aniso8601.parse_date, '-2000'))
emit('err_extended_is_valueerror',
     'yes' if issubclass(NotImplementedError, ValueError) else 'no')

# ------------------------------------------------------ the builder plumbing ---
# `TupleBuilder' IS THE DOCUMENTED WAY TO GET THE PARSE WITHOUT THE DATETIME,
# and it is what every entry point uses internally.  One case, because a caller
# reaching for it is reaching past the six public functions.
try:
    from aniso8601.builders import TupleBuilder
    _t = aniso8601.parse_date('1984-05-07', builder=TupleBuilder)
    emit('tuple_builder_fields', '%s,%s,%s' % (_t.YYYY, _t.MM, _t.DD))
except Exception as exc:                                        # noqa: BLE001
    emit('tuple_builder_fields', '<%s>' % type(exc).__name__)

# ------------------------------------------------------------- the closure ---
# NO COMPILED EXTENSION IS REACHED, AND NOTHING OUTSIDE THE STDLIB IS.  This
# image's python3 is ONE STATIC BINARY with an empty lib-dynload and no dynamic
# loader (BRINTOS-1476), so a release that grew a dependency on a third-party
# module would fail at import here rather than resolve it.  The set is measured
# from THIS interpreter's sys.modules and reported sorted, so the suite asserts
# a name rather than a count.
# THE DELTA IS SCORED AGAINST THE STDLIB, NOT AGAINST A LITERAL.  What the
# absolute delta contains depends on what the interpreter had already loaded
# before this probe started -- measured 9 names under Ubuntu's `site' and 21
# under `python3 -S', for the same package -- so a literal list here would red
# on target for a reason that has nothing to do with aniso8601.  What IS
# baseline-independent, and is the thing worth asserting, is that NOTHING the
# import pulled in comes from outside the standard library: this image's python3
# is ONE STATIC BINARY with an empty lib-dynload and no dynamic loader
# (BRINTOS-1476), so a release that grew a third-party dependency would fail at
# `import' here rather than resolve it.
#
# `sys.stdlib_module_names' is the interpreter's own answer and exists from
# CPython 3.10; it is checked for rather than assumed, so an interpreter without
# it says so instead of reporting a spuriously clean list.
_pulled = sorted(_AFTER_IMPORT - _BASELINE - {'aniso8601'})
_stdlib = getattr(sys, 'stdlib_module_names', None)
if _stdlib is None:
    emit('pulled_nonstdlib', '<no-stdlib-module-names>')
else:
    emit('pulled_nonstdlib',
         ','.join(n for n in _pulled if n not in _stdlib) or '<none>')
emit('needs_datetime', 'yes' if 'datetime' in sys.modules else 'no')
emit('needs_calendar', 'yes' if 'calendar' in sys.modules else 'no')

emit('probe_done', 'yes')
emit('emitted_count', len(emitted) + 1)