two version of R2R are here HEAD master

11 files changed, 1438 insertions, 0 deletions

diff --git a/.venv/lib/python3.12/site-packages/isodate/__init__.py b/.venv/lib/python3.12/site-packages/isodate/__init__.py
new file mode 100644
index 00000000..d9cca6a5
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/isodate/__init__.py
@@ -0,0 +1,103 @@
+"""
+Import all essential functions and constants to re-export them here for easy
+access.
+
+This module contains also various pre-defined ISO 8601 format strings.
+"""
+
+from isodate.duration import Duration
+from isodate.isodates import date_isoformat, parse_date
+from isodate.isodatetime import datetime_isoformat, parse_datetime
+from isodate.isoduration import duration_isoformat, parse_duration
+from isodate.isoerror import ISO8601Error
+from isodate.isostrf import (
+    D_ALT_BAS,
+    D_ALT_BAS_ORD,
+    D_ALT_EXT,
+    D_ALT_EXT_ORD,
+    D_DEFAULT,
+    D_WEEK,
+    DATE_BAS_COMPLETE,
+    DATE_BAS_MONTH,
+    DATE_BAS_ORD_COMPLETE,
+    DATE_BAS_WEEK,
+    DATE_BAS_WEEK_COMPLETE,
+    DATE_CENTURY,
+    DATE_EXT_COMPLETE,
+    DATE_EXT_MONTH,
+    DATE_EXT_ORD_COMPLETE,
+    DATE_EXT_WEEK,
+    DATE_EXT_WEEK_COMPLETE,
+    DATE_YEAR,
+    DT_BAS_COMPLETE,
+    DT_BAS_ORD_COMPLETE,
+    DT_BAS_WEEK_COMPLETE,
+    DT_EXT_COMPLETE,
+    DT_EXT_ORD_COMPLETE,
+    DT_EXT_WEEK_COMPLETE,
+    TIME_BAS_COMPLETE,
+    TIME_BAS_MINUTE,
+    TIME_EXT_COMPLETE,
+    TIME_EXT_MINUTE,
+    TIME_HOUR,
+    TZ_BAS,
+    TZ_EXT,
+    TZ_HOUR,
+    strftime,
+)
+from isodate.isotime import parse_time, time_isoformat
+from isodate.isotzinfo import parse_tzinfo, tz_isoformat
+from isodate.tzinfo import LOCAL, UTC, FixedOffset
+from isodate.version import version as __version__
+
+__all__ = [
+    "parse_date",
+    "date_isoformat",
+    "parse_time",
+    "time_isoformat",
+    "parse_datetime",
+    "datetime_isoformat",
+    "parse_duration",
+    "duration_isoformat",
+    "ISO8601Error",
+    "parse_tzinfo",
+    "tz_isoformat",
+    "UTC",
+    "FixedOffset",
+    "LOCAL",
+    "Duration",
+    "strftime",
+    "DATE_BAS_COMPLETE",
+    "DATE_BAS_ORD_COMPLETE",
+    "DATE_BAS_WEEK",
+    "DATE_BAS_WEEK_COMPLETE",
+    "DATE_CENTURY",
+    "DATE_EXT_COMPLETE",
+    "DATE_EXT_ORD_COMPLETE",
+    "DATE_EXT_WEEK",
+    "DATE_EXT_WEEK_COMPLETE",
+    "DATE_YEAR",
+    "DATE_BAS_MONTH",
+    "DATE_EXT_MONTH",
+    "TIME_BAS_COMPLETE",
+    "TIME_BAS_MINUTE",
+    "TIME_EXT_COMPLETE",
+    "TIME_EXT_MINUTE",
+    "TIME_HOUR",
+    "TZ_BAS",
+    "TZ_EXT",
+    "TZ_HOUR",
+    "DT_BAS_COMPLETE",
+    "DT_EXT_COMPLETE",
+    "DT_BAS_ORD_COMPLETE",
+    "DT_EXT_ORD_COMPLETE",
+    "DT_BAS_WEEK_COMPLETE",
+    "DT_EXT_WEEK_COMPLETE",
+    "D_DEFAULT",
+    "D_WEEK",
+    "D_ALT_EXT",
+    "D_ALT_BAS",
+    "D_ALT_BAS_ORD",
+    "D_ALT_EXT_ORD",
+    "__version__",
+]
diff --git a/.venv/lib/python3.12/site-packages/isodate/duration.py b/.venv/lib/python3.12/site-packages/isodate/duration.py
new file mode 100644
index 00000000..bc8a5cb9
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/isodate/duration.py
@@ -0,0 +1,316 @@
+"""
+This module defines a Duration class.
+
+The class Duration allows to define durations in years and months and can be
+used as limited replacement for timedelta objects.
+"""
+
+from datetime import timedelta
+from decimal import ROUND_FLOOR, Decimal
+
+
+def fquotmod(val, low, high):
+    """
+    A divmod function with boundaries.
+
+    """
+    # assumes that all the maths is done with Decimals.
+    # divmod for Decimal uses truncate instead of floor as builtin
+    # divmod, so we have to do it manually here.
+    a, b = val - low, high - low
+    div = (a / b).to_integral(ROUND_FLOOR)
+    mod = a - div * b
+    # if we were not using Decimal, it would look like this.
+    # div, mod = divmod(val - low, high - low)
+    mod += low
+    return int(div), mod
+
+
+def max_days_in_month(year, month):
+    """
+    Determines the number of days of a specific month in a specific year.
+    """
+    if month in (1, 3, 5, 7, 8, 10, 12):
+        return 31
+    if month in (4, 6, 9, 11):
+        return 30
+    if ((year % 400) == 0) or ((year % 100) != 0) and ((year % 4) == 0):
+        return 29
+    return 28
+
+
+class Duration:
+    """
+    A class which represents a duration.
+
+    The difference to datetime.timedelta is, that this class handles also
+    differences given in years and months.
+    A Duration treats differences given in year, months separately from all
+    other components.
+
+    A Duration can be used almost like any timedelta object, however there
+    are some restrictions:
+      * It is not really possible to compare Durations, because it is unclear,
+        whether a duration of 1 year is bigger than 365 days or not.
+      * Equality is only tested between the two (year, month vs. timedelta)
+        basic components.
+
+    A Duration can also be converted into a datetime object, but this requires
+    a start date or an end date.
+
+    The algorithm to add a duration to a date is defined at
+    http://www.w3.org/TR/xmlschema-2/#adding-durations-to-dateTimes
+    """
+
+    def __init__(
+        self,
+        days=0,
+        seconds=0,
+        microseconds=0,
+        milliseconds=0,
+        minutes=0,
+        hours=0,
+        weeks=0,
+        months=0,
+        years=0,
+    ):
+        """
+        Initialise this Duration instance with the given parameters.
+        """
+        if not isinstance(months, Decimal):
+            months = Decimal(str(months))
+        if not isinstance(years, Decimal):
+            years = Decimal(str(years))
+        self.months = months
+        self.years = years
+        self.tdelta = timedelta(
+            days, seconds, microseconds, milliseconds, minutes, hours, weeks
+        )
+
+    def __getstate__(self):
+        return self.__dict__
+
+    def __setstate__(self, state):
+        self.__dict__.update(state)
+
+    def __getattr__(self, name):
+        """
+        Provide direct access to attributes of included timedelta instance.
+        """
+        return getattr(self.tdelta, name)
+
+    def __str__(self):
+        """
+        Return a string representation of this duration similar to timedelta.
+        """
+        params = []
+        if self.years:
+            params.append("%d years" % self.years)
+        if self.months:
+            fmt = "%d months"
+            if self.months <= 1:
+                fmt = "%d month"
+            params.append(fmt % self.months)
+        params.append(str(self.tdelta))
+        return ", ".join(params)
+
+    def __repr__(self):
+        """
+        Return a string suitable for repr(x) calls.
+        """
+        return "%s.%s(%d, %d, %d, years=%d, months=%d)" % (
+            self.__class__.__module__,
+            self.__class__.__name__,
+            self.tdelta.days,
+            self.tdelta.seconds,
+            self.tdelta.microseconds,
+            self.years,
+            self.months,
+        )
+
+    def __hash__(self):
+        """
+        Return a hash of this instance so that it can be used in, for
+        example, dicts and sets.
+        """
+        return hash((self.tdelta, self.months, self.years))
+
+    def __neg__(self):
+        """
+        A simple unary minus.
+
+        Returns a new Duration instance with all it's negated.
+        """
+        negduration = Duration(years=-self.years, months=-self.months)
+        negduration.tdelta = -self.tdelta
+        return negduration
+
+    def __add__(self, other):
+        """
+        Durations can be added with Duration, timedelta, date and datetime
+        objects.
+        """
+        if isinstance(other, Duration):
+            newduration = Duration(
+                years=self.years + other.years, months=self.months + other.months
+            )
+            newduration.tdelta = self.tdelta + other.tdelta
+            return newduration
+        try:
+            # try anything that looks like a date or datetime
+            # 'other' has attributes year, month, day
+            # and relies on 'timedelta + other' being implemented
+            if not (float(self.years).is_integer() and float(self.months).is_integer()):
+                raise ValueError(
+                    "fractional years or months not supported" " for date calculations"
+                )
+            newmonth = other.month + self.months
+            carry, newmonth = fquotmod(newmonth, 1, 13)
+            newyear = other.year + self.years + carry
+            maxdays = max_days_in_month(newyear, newmonth)
+            if other.day > maxdays:
+                newday = maxdays
+            else:
+                newday = other.day
+            newdt = other.replace(
+                year=int(newyear), month=int(newmonth), day=int(newday)
+            )
+            # does a timedelta + date/datetime
+            return self.tdelta + newdt
+        except AttributeError:
+            # other probably was not a date/datetime compatible object
+            pass
+        try:
+            # try if other is a timedelta
+            # relies on timedelta + timedelta supported
+            newduration = Duration(years=self.years, months=self.months)
+            newduration.tdelta = self.tdelta + other
+            return newduration
+        except AttributeError:
+            # ignore ... other probably was not a timedelta compatible object
+            pass
+        # we have tried everything .... return a NotImplemented
+        return NotImplemented
+
+    __radd__ = __add__
+
+    def __mul__(self, other):
+        if isinstance(other, int):
+            newduration = Duration(years=self.years * other, months=self.months * other)
+            newduration.tdelta = self.tdelta * other
+            return newduration
+        return NotImplemented
+
+    __rmul__ = __mul__
+
+    def __sub__(self, other):
+        """
+        It is possible to subtract Duration and timedelta objects from Duration
+        objects.
+        """
+        if isinstance(other, Duration):
+            newduration = Duration(
+                years=self.years - other.years, months=self.months - other.months
+            )
+            newduration.tdelta = self.tdelta - other.tdelta
+            return newduration
+        try:
+            # do maths with our timedelta object ....
+            newduration = Duration(years=self.years, months=self.months)
+            newduration.tdelta = self.tdelta - other
+            return newduration
+        except TypeError:
+            # looks like timedelta - other is not implemented
+            pass
+        return NotImplemented
+
+    def __rsub__(self, other):
+        """
+        It is possible to subtract Duration objects from date, datetime and
+        timedelta objects.
+
+        TODO: there is some weird behaviour in date - timedelta ...
+              if timedelta has seconds or microseconds set, then
+              date - timedelta != date + (-timedelta)
+              for now we follow this behaviour to avoid surprises when mixing
+              timedeltas with Durations, but in case this ever changes in
+              the stdlib we can just do:
+                return -self + other
+              instead of all the current code
+        """
+        if isinstance(other, timedelta):
+            tmpdur = Duration()
+            tmpdur.tdelta = other
+            return tmpdur - self
+        try:
+            # check if other behaves like a date/datetime object
+            # does it have year, month, day and replace?
+            if not (float(self.years).is_integer() and float(self.months).is_integer()):
+                raise ValueError(
+                    "fractional years or months not supported" " for date calculations"
+                )
+            newmonth = other.month - self.months
+            carry, newmonth = fquotmod(newmonth, 1, 13)
+            newyear = other.year - self.years + carry
+            maxdays = max_days_in_month(newyear, newmonth)
+            if other.day > maxdays:
+                newday = maxdays
+            else:
+                newday = other.day
+            newdt = other.replace(
+                year=int(newyear), month=int(newmonth), day=int(newday)
+            )
+            return newdt - self.tdelta
+        except AttributeError:
+            # other probably was not compatible with data/datetime
+            pass
+        return NotImplemented
+
+    def __eq__(self, other):
+        """
+        If the years, month part and the timedelta part are both equal, then
+        the two Durations are considered equal.
+        """
+        if isinstance(other, Duration):
+            if (self.years * 12 + self.months) == (
+                other.years * 12 + other.months
+            ) and self.tdelta == other.tdelta:
+                return True
+            return False
+        # check if other con be compared against timedelta object
+        # will raise an AssertionError when optimisation is off
+        if self.years == 0 and self.months == 0:
+            return self.tdelta == other
+        return False
+
+    def __ne__(self, other):
+        """
+        If the years, month part or the timedelta part is not equal, then
+        the two Durations are considered not equal.
+        """
+        if isinstance(other, Duration):
+            if (self.years * 12 + self.months) != (
+                other.years * 12 + other.months
+            ) or self.tdelta != other.tdelta:
+                return True
+            return False
+        # check if other can be compared against timedelta object
+        # will raise an AssertionError when optimisation is off
+        if self.years == 0 and self.months == 0:
+            return self.tdelta != other
+        return True
+
+    def totimedelta(self, start=None, end=None):
+        """
+        Convert this duration into a timedelta object.
+
+        This method requires a start datetime or end datetimem, but raises
+        an exception if both are given.
+        """
+        if start is None and end is None:
+            raise ValueError("start or end required")
+        if start is not None and end is not None:
+            raise ValueError("only start or end allowed")
+        if start is not None:
+            return (start + self) - start
+        return end - (end - self)
diff --git a/.venv/lib/python3.12/site-packages/isodate/isodates.py b/.venv/lib/python3.12/site-packages/isodate/isodates.py
new file mode 100644
index 00000000..d32fe25e
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/isodate/isodates.py
@@ -0,0 +1,203 @@
+"""
+This modules provides a method to parse an ISO 8601:2004 date string to a
+python datetime.date instance.
+
+It supports all basic, extended and expanded formats as described in the ISO
+standard. The only limitations it has, are given by the Python datetime.date
+implementation, which does not support dates before 0001-01-01.
+"""
+
+import re
+from datetime import date, timedelta
+
+from isodate.isoerror import ISO8601Error
+from isodate.isostrf import DATE_EXT_COMPLETE, strftime
+
+DATE_REGEX_CACHE = {}
+# A dictionary to cache pre-compiled regular expressions.
+# A set of regular expressions is identified, by number of year digits allowed
+# and whether a plus/minus sign is required or not. (This option is changeable
+# only for 4 digit years).
+
+
+def build_date_regexps(yeardigits=4, expanded=False):
+    """
+    Compile set of regular expressions to parse ISO dates. The expressions will
+    be created only if they are not already in REGEX_CACHE.
+
+    It is necessary to fix the number of year digits, else it is not possible
+    to automatically distinguish between various ISO date formats.
+
+    ISO 8601 allows more than 4 digit years, on prior agreement, but then a +/-
+    sign is required (expanded format). To support +/- sign for 4 digit years,
+    the expanded parameter needs to be set to True.
+    """
+    if yeardigits != 4:
+        expanded = True
+    if (yeardigits, expanded) not in DATE_REGEX_CACHE:
+        cache_entry = []
+        # ISO 8601 expanded DATE formats allow an arbitrary number of year
+        # digits with a leading +/- sign.
+        if expanded:
+            sign = 1
+        else:
+            sign = 0
+
+        def add_re(regex_text):
+            cache_entry.append(re.compile(r"\A" + regex_text + r"\Z"))
+
+        # 1. complete dates:
+        #    YYYY-MM-DD or +- YYYYYY-MM-DD... extended date format
+        add_re(
+            r"(?P<sign>[+-]){%d}(?P<year>[0-9]{%d})"
+            r"-(?P<month>[0-9]{2})-(?P<day>[0-9]{2})" % (sign, yeardigits)
+        )
+        #    YYYYMMDD or +- YYYYYYMMDD... basic date format
+        add_re(
+            r"(?P<sign>[+-]){%d}(?P<year>[0-9]{%d})"
+            r"(?P<month>[0-9]{2})(?P<day>[0-9]{2})" % (sign, yeardigits)
+        )
+        # 2. complete week dates:
+        #    YYYY-Www-D or +-YYYYYY-Www-D ... extended week date
+        add_re(
+            r"(?P<sign>[+-]){%d}(?P<year>[0-9]{%d})"
+            r"-W(?P<week>[0-9]{2})-(?P<day>[0-9]{1})" % (sign, yeardigits)
+        )
+        #    YYYYWwwD or +-YYYYYYWwwD ... basic week date
+        add_re(
+            r"(?P<sign>[+-]){%d}(?P<year>[0-9]{%d})W"
+            r"(?P<week>[0-9]{2})(?P<day>[0-9]{1})" % (sign, yeardigits)
+        )
+        # 3. ordinal dates:
+        #    YYYY-DDD or +-YYYYYY-DDD ... extended format
+        add_re(
+            r"(?P<sign>[+-]){%d}(?P<year>[0-9]{%d})"
+            r"-(?P<day>[0-9]{3})" % (sign, yeardigits)
+        )
+        #    YYYYDDD or +-YYYYYYDDD ... basic format
+        add_re(
+            r"(?P<sign>[+-]){%d}(?P<year>[0-9]{%d})"
+            r"(?P<day>[0-9]{3})" % (sign, yeardigits)
+        )
+        # 4. week dates:
+        #    YYYY-Www or +-YYYYYY-Www ... extended reduced accuracy week date
+        # 4. week dates:
+        #    YYYY-Www or +-YYYYYY-Www ... extended reduced accuracy week date
+        add_re(
+            r"(?P<sign>[+-]){%d}(?P<year>[0-9]{%d})"
+            r"-W(?P<week>[0-9]{2})" % (sign, yeardigits)
+        )
+        #    YYYYWww or +-YYYYYYWww ... basic reduced accuracy week date
+        add_re(
+            r"(?P<sign>[+-]){%d}(?P<year>[0-9]{%d})W"
+            r"(?P<week>[0-9]{2})" % (sign, yeardigits)
+        )
+        # 5. month dates:
+        #    YYY-MM or +-YYYYYY-MM ... reduced accuracy specific month
+        # 5. month dates:
+        #    YYY-MM or +-YYYYYY-MM ... reduced accuracy specific month
+        add_re(
+            r"(?P<sign>[+-]){%d}(?P<year>[0-9]{%d})"
+            r"-(?P<month>[0-9]{2})" % (sign, yeardigits)
+        )
+        #    YYYMM or +-YYYYYYMM ... basic incomplete month date format
+        add_re(
+            r"(?P<sign>[+-]){%d}(?P<year>[0-9]{%d})"
+            r"(?P<month>[0-9]{2})" % (sign, yeardigits)
+        )
+        # 6. year dates:
+        #    YYYY or +-YYYYYY ... reduced accuracy specific year
+        add_re(r"(?P<sign>[+-]){%d}(?P<year>[0-9]{%d})" % (sign, yeardigits))
+        # 7. century dates:
+        #    YY or +-YYYY ... reduced accuracy specific century
+        add_re(r"(?P<sign>[+-]){%d}" r"(?P<century>[0-9]{%d})" % (sign, yeardigits - 2))
+
+        DATE_REGEX_CACHE[(yeardigits, expanded)] = cache_entry
+    return DATE_REGEX_CACHE[(yeardigits, expanded)]
+
+
+def parse_date(datestring, yeardigits=4, expanded=False, defaultmonth=1, defaultday=1):
+    """
+    Parse an ISO 8601 date string into a datetime.date object.
+
+    As the datetime.date implementation is limited to dates starting from
+    0001-01-01, negative dates (BC) and year 0 can not be parsed by this
+    method.
+
+    For incomplete dates, this method chooses the first day for it. For
+    instance if only a century is given, this method returns the 1st of
+    January in year 1 of this century.
+
+    supported formats: (expanded formats are shown with 6 digits for year)
+      YYYYMMDD    +-YYYYYYMMDD      basic complete date
+      YYYY-MM-DD  +-YYYYYY-MM-DD    extended complete date
+      YYYYWwwD    +-YYYYYYWwwD      basic complete week date
+      YYYY-Www-D  +-YYYYYY-Www-D    extended complete week date
+      YYYYDDD     +-YYYYYYDDD       basic ordinal date
+      YYYY-DDD    +-YYYYYY-DDD      extended ordinal date
+      YYYYWww     +-YYYYYYWww       basic incomplete week date
+      YYYY-Www    +-YYYYYY-Www      extended incomplete week date
+      YYYMM       +-YYYYYYMM        basic incomplete month date
+      YYY-MM      +-YYYYYY-MM       incomplete month date
+      YYYY        +-YYYYYY          incomplete year date
+      YY          +-YYYY            incomplete century date
+
+    @param datestring: the ISO date string to parse
+    @param yeardigits: how many digits are used to represent a year
+    @param expanded: if True then +/- signs are allowed. This parameter
+                     is forced to True, if yeardigits != 4
+
+    @return: a datetime.date instance represented by datestring
+    @raise ISO8601Error: if this function can not parse the datestring
+    @raise ValueError: if datestring can not be represented by datetime.date
+    """
+    if yeardigits != 4:
+        expanded = True
+    isodates = build_date_regexps(yeardigits, expanded)
+    for pattern in isodates:
+        match = pattern.match(datestring)
+        if match:
+            groups = match.groupdict()
+            # sign, century, year, month, week, day,
+            # FIXME: negative dates not possible with python standard types
+            sign = (groups["sign"] == "-" and -1) or 1
+            if "century" in groups:
+                return date(
+                    sign * (int(groups["century"]) * 100 + 1), defaultmonth, defaultday
+                )
+            if "month" not in groups:  # weekdate or ordinal date
+                ret = date(sign * int(groups["year"]), 1, 1)
+                if "week" in groups:
+                    isotuple = ret.isocalendar()
+                    if "day" in groups:
+                        days = int(groups["day"] or 1)
+                    else:
+                        days = 1
+                    # if first week in year, do weeks-1
+                    return ret + timedelta(
+                        weeks=int(groups["week"]) - (((isotuple[1] == 1) and 1) or 0),
+                        days=-isotuple[2] + days,
+                    )
+                elif "day" in groups:  # ordinal date
+                    return ret + timedelta(days=int(groups["day"]) - 1)
+                else:  # year date
+                    return ret.replace(month=defaultmonth, day=defaultday)
+            # year-, month-, or complete date
+            if "day" not in groups or groups["day"] is None:
+                day = defaultday
+            else:
+                day = int(groups["day"])
+            return date(
+                sign * int(groups["year"]), int(groups["month"]) or defaultmonth, day
+            )
+    raise ISO8601Error("Unrecognised ISO 8601 date format: %r" % datestring)
+
+
+def date_isoformat(tdate, format=DATE_EXT_COMPLETE, yeardigits=4):
+    """
+    Format date strings.
+
+    This method is just a wrapper around isodate.isostrf.strftime and uses
+    Date-Extended-Complete as default format.
+    """
+    return strftime(tdate, format, yeardigits)
diff --git a/.venv/lib/python3.12/site-packages/isodate/isodatetime.py b/.venv/lib/python3.12/site-packages/isodate/isodatetime.py
new file mode 100644
index 00000000..1b208053
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/isodate/isodatetime.py
@@ -0,0 +1,45 @@
+"""
+This module defines a method to parse an ISO 8601:2004 date time string.
+
+For this job it uses the parse_date and parse_time methods defined in date
+and time module.
+"""
+
+from datetime import datetime
+
+from isodate.isodates import parse_date
+from isodate.isoerror import ISO8601Error
+from isodate.isostrf import DATE_EXT_COMPLETE, TIME_EXT_COMPLETE, TZ_EXT, strftime
+from isodate.isotime import parse_time
+
+
+def parse_datetime(datetimestring):
+    """
+    Parses ISO 8601 date-times into datetime.datetime objects.
+
+    This function uses parse_date and parse_time to do the job, so it allows
+    more combinations of date and time representations, than the actual
+    ISO 8601:2004 standard allows.
+    """
+    try:
+        datestring, timestring = datetimestring.split("T")
+    except ValueError:
+        raise ISO8601Error(
+            "ISO 8601 time designator 'T' missing. Unable to"
+            " parse datetime string %r" % datetimestring
+        )
+    tmpdate = parse_date(datestring)
+    tmptime = parse_time(timestring)
+    return datetime.combine(tmpdate, tmptime)
+
+
+def datetime_isoformat(
+    tdt, format=DATE_EXT_COMPLETE + "T" + TIME_EXT_COMPLETE + TZ_EXT
+):
+    """
+    Format datetime strings.
+
+    This method is just a wrapper around isodate.isostrf.strftime and uses
+    Extended-Complete as default format.
+    """
+    return strftime(tdt, format)
diff --git a/.venv/lib/python3.12/site-packages/isodate/isoduration.py b/.venv/lib/python3.12/site-packages/isodate/isoduration.py
new file mode 100644
index 00000000..4f1755bf
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/isodate/isoduration.py
@@ -0,0 +1,147 @@
+"""
+This module provides an ISO 8601:2004 duration parser.
+
+It also provides a wrapper to strftime. This wrapper makes it easier to
+format timedelta or Duration instances as ISO conforming strings.
+"""
+
+import re
+from datetime import timedelta
+from decimal import Decimal
+
+from isodate.duration import Duration
+from isodate.isodatetime import parse_datetime
+from isodate.isoerror import ISO8601Error
+from isodate.isostrf import D_DEFAULT, strftime
+
+ISO8601_PERIOD_REGEX = re.compile(
+    r"^(?P<sign>[+-])?"
+    r"P(?!\b)"
+    r"(?P<years>[0-9]+([,.][0-9]+)?Y)?"
+    r"(?P<months>[0-9]+([,.][0-9]+)?M)?"
+    r"(?P<weeks>[0-9]+([,.][0-9]+)?W)?"
+    r"(?P<days>[0-9]+([,.][0-9]+)?D)?"
+    r"((?P<separator>T)(?P<hours>[0-9]+([,.][0-9]+)?H)?"
+    r"(?P<minutes>[0-9]+([,.][0-9]+)?M)?"
+    r"(?P<seconds>[0-9]+([,.][0-9]+)?S)?)?$"
+)
+# regular expression to parse ISO duration strings.
+
+
+def parse_duration(datestring, as_timedelta_if_possible=True):
+    """
+    Parses an ISO 8601 durations into datetime.timedelta or Duration objects.
+
+    If the ISO date string does not contain years or months, a timedelta
+    instance is returned, else a Duration instance is returned.
+
+    The following duration formats are supported:
+      -PnnW                  duration in weeks
+      -PnnYnnMnnDTnnHnnMnnS  complete duration specification
+      -PYYYYMMDDThhmmss      basic alternative complete date format
+      -PYYYY-MM-DDThh:mm:ss  extended alternative complete date format
+      -PYYYYDDDThhmmss       basic alternative ordinal date format
+      -PYYYY-DDDThh:mm:ss    extended alternative ordinal date format
+
+    The '-' is optional.
+
+    Limitations:  ISO standard defines some restrictions about where to use
+      fractional numbers and which component and format combinations are
+      allowed. This parser implementation ignores all those restrictions and
+      returns something when it is able to find all necessary components.
+      In detail:
+        it does not check, whether only the last component has fractions.
+        it allows weeks specified with all other combinations
+
+      The alternative format does not support durations with years, months or
+      days set to 0.
+    """
+    if not isinstance(datestring, str):
+        raise TypeError("Expecting a string %r" % datestring)
+    match = ISO8601_PERIOD_REGEX.match(datestring)
+    if not match:
+        # try alternative format:
+        if datestring.startswith("P"):
+            durdt = parse_datetime(datestring[1:])
+            if as_timedelta_if_possible and durdt.year == 0 and durdt.month == 0:
+                # FIXME: currently not possible in alternative format
+                # create timedelta
+                ret = timedelta(
+                    days=durdt.day,
+                    seconds=durdt.second,
+                    microseconds=durdt.microsecond,
+                    minutes=durdt.minute,
+                    hours=durdt.hour,
+                )
+            else:
+                # create Duration
+                ret = Duration(
+                    days=durdt.day,
+                    seconds=durdt.second,
+                    microseconds=durdt.microsecond,
+                    minutes=durdt.minute,
+                    hours=durdt.hour,
+                    months=durdt.month,
+                    years=durdt.year,
+                )
+            return ret
+        raise ISO8601Error("Unable to parse duration string %r" % datestring)
+    groups = match.groupdict()
+    for key, val in groups.items():
+        if key not in ("separator", "sign"):
+            if val is None:
+                groups[key] = "0n"
+            # print groups[key]
+            if key in ("years", "months"):
+                groups[key] = Decimal(groups[key][:-1].replace(",", "."))
+            else:
+                # these values are passed into a timedelta object,
+                # which works with floats.
+                groups[key] = float(groups[key][:-1].replace(",", "."))
+    if as_timedelta_if_possible and groups["years"] == 0 and groups["months"] == 0:
+        ret = timedelta(
+            days=groups["days"],
+            hours=groups["hours"],
+            minutes=groups["minutes"],
+            seconds=groups["seconds"],
+            weeks=groups["weeks"],
+        )
+        if groups["sign"] == "-":
+            ret = timedelta(0) - ret
+    else:
+        ret = Duration(
+            years=groups["years"],
+            months=groups["months"],
+            days=groups["days"],
+            hours=groups["hours"],
+            minutes=groups["minutes"],
+            seconds=groups["seconds"],
+            weeks=groups["weeks"],
+        )
+        if groups["sign"] == "-":
+            ret = Duration(0) - ret
+    return ret
+
+
+def duration_isoformat(tduration, format=D_DEFAULT):
+    """
+    Format duration strings.
+
+    This method is just a wrapper around isodate.isostrf.strftime and uses
+    P%P (D_DEFAULT) as default format.
+    """
+    # TODO: implement better decision for negative Durations.
+    #       should be done in Duration class in consistent way with timedelta.
+    if (
+        isinstance(tduration, Duration)
+        and (
+            tduration.years < 0
+            or tduration.months < 0
+            or tduration.tdelta < timedelta(0)
+        )
+    ) or (isinstance(tduration, timedelta) and (tduration < timedelta(0))):
+        ret = "-"
+    else:
+        ret = ""
+    ret += strftime(tduration, format)
+    return ret
diff --git a/.venv/lib/python3.12/site-packages/isodate/isoerror.py b/.venv/lib/python3.12/site-packages/isodate/isoerror.py
new file mode 100644
index 00000000..068429f2
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/isodate/isoerror.py
@@ -0,0 +1,7 @@
+"""
+This module defines all exception classes in the whole package.
+"""
+
+
+class ISO8601Error(ValueError):
+    """Raised when the given ISO string can not be parsed."""
diff --git a/.venv/lib/python3.12/site-packages/isodate/isostrf.py b/.venv/lib/python3.12/site-packages/isodate/isostrf.py
new file mode 100644
index 00000000..455ce97a
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/isodate/isostrf.py
@@ -0,0 +1,189 @@
+"""
+This module provides an alternative strftime method.
+
+The strftime method in this module allows only a subset of Python's strftime
+format codes, plus a few additional. It supports the full range of date values
+possible with standard Python date/time objects. Furthermore there are several
+pr-defined format strings in this module to make ease producing of ISO 8601
+conforming strings.
+"""
+
+import re
+from datetime import date, timedelta
+
+from isodate.duration import Duration
+from isodate.isotzinfo import tz_isoformat
+
+# Date specific format strings
+DATE_BAS_COMPLETE = "%Y%m%d"
+DATE_EXT_COMPLETE = "%Y-%m-%d"
+DATE_BAS_WEEK_COMPLETE = "%YW%W%w"
+DATE_EXT_WEEK_COMPLETE = "%Y-W%W-%w"
+DATE_BAS_ORD_COMPLETE = "%Y%j"
+DATE_EXT_ORD_COMPLETE = "%Y-%j"
+DATE_BAS_WEEK = "%YW%W"
+DATE_EXT_WEEK = "%Y-W%W"
+DATE_BAS_MONTH = "%Y%m"
+DATE_EXT_MONTH = "%Y-%m"
+DATE_YEAR = "%Y"
+DATE_CENTURY = "%C"
+
+# Time specific format strings
+TIME_BAS_COMPLETE = "%H%M%S"
+TIME_EXT_COMPLETE = "%H:%M:%S"
+TIME_BAS_MINUTE = "%H%M"
+TIME_EXT_MINUTE = "%H:%M"
+TIME_HOUR = "%H"
+
+# Time zone formats
+TZ_BAS = "%z"
+TZ_EXT = "%Z"
+TZ_HOUR = "%h"
+
+# DateTime formats
+DT_EXT_COMPLETE = DATE_EXT_COMPLETE + "T" + TIME_EXT_COMPLETE + TZ_EXT
+DT_BAS_COMPLETE = DATE_BAS_COMPLETE + "T" + TIME_BAS_COMPLETE + TZ_BAS
+DT_EXT_ORD_COMPLETE = DATE_EXT_ORD_COMPLETE + "T" + TIME_EXT_COMPLETE + TZ_EXT
+DT_BAS_ORD_COMPLETE = DATE_BAS_ORD_COMPLETE + "T" + TIME_BAS_COMPLETE + TZ_BAS
+DT_EXT_WEEK_COMPLETE = DATE_EXT_WEEK_COMPLETE + "T" + TIME_EXT_COMPLETE + TZ_EXT
+DT_BAS_WEEK_COMPLETE = DATE_BAS_WEEK_COMPLETE + "T" + TIME_BAS_COMPLETE + TZ_BAS
+
+# Duration formts
+D_DEFAULT = "P%P"
+D_WEEK = "P%p"
+D_ALT_EXT = "P" + DATE_EXT_COMPLETE + "T" + TIME_EXT_COMPLETE
+D_ALT_BAS = "P" + DATE_BAS_COMPLETE + "T" + TIME_BAS_COMPLETE
+D_ALT_EXT_ORD = "P" + DATE_EXT_ORD_COMPLETE + "T" + TIME_EXT_COMPLETE
+D_ALT_BAS_ORD = "P" + DATE_BAS_ORD_COMPLETE + "T" + TIME_BAS_COMPLETE
+
+STRF_DT_MAP = {
+    "%d": lambda tdt, yds: "%02d" % tdt.day,
+    "%f": lambda tdt, yds: "%06d" % tdt.microsecond,
+    "%H": lambda tdt, yds: "%02d" % tdt.hour,
+    "%j": lambda tdt, yds: "%03d"
+    % (tdt.toordinal() - date(tdt.year, 1, 1).toordinal() + 1),
+    "%m": lambda tdt, yds: "%02d" % tdt.month,
+    "%M": lambda tdt, yds: "%02d" % tdt.minute,
+    "%S": lambda tdt, yds: "%02d" % tdt.second,
+    "%w": lambda tdt, yds: "%1d" % tdt.isoweekday(),
+    "%W": lambda tdt, yds: "%02d" % tdt.isocalendar()[1],
+    "%Y": lambda tdt, yds: (((yds != 4) and "+") or "") + (("%%0%dd" % yds) % tdt.year),
+    "%C": lambda tdt, yds: (((yds != 4) and "+") or "")
+    + (("%%0%dd" % (yds - 2)) % (tdt.year / 100)),
+    "%h": lambda tdt, yds: tz_isoformat(tdt, "%h"),
+    "%Z": lambda tdt, yds: tz_isoformat(tdt, "%Z"),
+    "%z": lambda tdt, yds: tz_isoformat(tdt, "%z"),
+    "%%": lambda tdt, yds: "%",
+}
+
+STRF_D_MAP = {
+    "%d": lambda tdt, yds: "%02d" % tdt.days,
+    "%f": lambda tdt, yds: "%06d" % tdt.microseconds,
+    "%H": lambda tdt, yds: "%02d" % (tdt.seconds / 60 / 60),
+    "%m": lambda tdt, yds: "%02d" % tdt.months,
+    "%M": lambda tdt, yds: "%02d" % ((tdt.seconds / 60) % 60),
+    "%S": lambda tdt, yds: "%02d" % (tdt.seconds % 60),
+    "%W": lambda tdt, yds: "%02d" % (abs(tdt.days / 7)),
+    "%Y": lambda tdt, yds: (((yds != 4) and "+") or "")
+    + (("%%0%dd" % yds) % tdt.years),
+    "%C": lambda tdt, yds: (((yds != 4) and "+") or "")
+    + (("%%0%dd" % (yds - 2)) % (tdt.years / 100)),
+    "%%": lambda tdt, yds: "%",
+}
+
+
+def _strfduration(tdt, format, yeardigits=4):
+    """
+    this is the work method for timedelta and Duration instances.
+
+    see strftime for more details.
+    """
+
+    def repl(match):
+        """
+        lookup format command and return corresponding replacement.
+        """
+        if match.group(0) in STRF_D_MAP:
+            return STRF_D_MAP[match.group(0)](tdt, yeardigits)
+        elif match.group(0) == "%P":
+            ret = []
+            if isinstance(tdt, Duration):
+                if tdt.years:
+                    ret.append("%sY" % abs(tdt.years))
+                if tdt.months:
+                    ret.append("%sM" % abs(tdt.months))
+            usecs = abs(
+                (tdt.days * 24 * 60 * 60 + tdt.seconds) * 1000000 + tdt.microseconds
+            )
+            seconds, usecs = divmod(usecs, 1000000)
+            minutes, seconds = divmod(seconds, 60)
+            hours, minutes = divmod(minutes, 60)
+            days, hours = divmod(hours, 24)
+            if days:
+                ret.append("%sD" % days)
+            if hours or minutes or seconds or usecs:
+                ret.append("T")
+                if hours:
+                    ret.append("%sH" % hours)
+                if minutes:
+                    ret.append("%sM" % minutes)
+                if seconds or usecs:
+                    if usecs:
+                        ret.append(("%d.%06d" % (seconds, usecs)).rstrip("0"))
+                    else:
+                        ret.append("%d" % seconds)
+                    ret.append("S")
+            # at least one component has to be there.
+            return ret and "".join(ret) or "0D"
+        elif match.group(0) == "%p":
+            return str(abs(tdt.days // 7)) + "W"
+        return match.group(0)
+
+    return re.sub("%d|%f|%H|%m|%M|%S|%W|%Y|%C|%%|%P|%p", repl, format)
+
+
+def _strfdt(tdt, format, yeardigits=4):
+    """
+    this is the work method for time and date instances.
+
+    see strftime for more details.
+    """
+
+    def repl(match):
+        """
+        lookup format command and return corresponding replacement.
+        """
+        if match.group(0) in STRF_DT_MAP:
+            return STRF_DT_MAP[match.group(0)](tdt, yeardigits)
+        return match.group(0)
+
+    return re.sub("%d|%f|%H|%j|%m|%M|%S|%w|%W|%Y|%C|%z|%Z|%h|%%", repl, format)
+
+
+def strftime(tdt, format, yeardigits=4):
+    """Directive    Meaning    Notes
+    %d    Day of the month as a decimal number [01,31].
+    %f    Microsecond as a decimal number [0,999999], zero-padded
+          on the left (1)
+    %H    Hour (24-hour clock) as a decimal number [00,23].
+    %j    Day of the year as a decimal number [001,366].
+    %m    Month as a decimal number [01,12].
+    %M    Minute as a decimal number [00,59].
+    %S    Second as a decimal number [00,61].    (3)
+    %w    Weekday as a decimal number [0(Monday),6].
+    %W    Week number of the year (Monday as the first day of the week)
+          as a decimal number [00,53]. All days in a new year preceding the
+          first Monday are considered to be in week 0.  (4)
+    %Y    Year with century as a decimal number. [0000,9999]
+    %C    Century as a decimal number. [00,99]
+    %z    UTC offset in the form +HHMM or -HHMM (empty string if the
+          object is naive).    (5)
+    %Z    Time zone name (empty string if the object is naive).
+    %P    ISO8601 duration format.
+    %p    ISO8601 duration format in weeks.
+    %%    A literal '%' character.
+
+    """
+    if isinstance(tdt, (timedelta, Duration)):
+        return _strfduration(tdt, format, yeardigits)
+    return _strfdt(tdt, format, yeardigits)
diff --git a/.venv/lib/python3.12/site-packages/isodate/isotime.py b/.venv/lib/python3.12/site-packages/isodate/isotime.py
new file mode 100644
index 00000000..f74ef5dd
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/isodate/isotime.py
@@ -0,0 +1,155 @@
+"""
+This modules provides a method to parse an ISO 8601:2004 time string to a
+Python datetime.time instance.
+
+It supports all basic and extended formats including time zone specifications
+as described in the ISO standard.
+"""
+
+import re
+from datetime import time
+from decimal import ROUND_FLOOR, Decimal
+
+from isodate.isoerror import ISO8601Error
+from isodate.isostrf import TIME_EXT_COMPLETE, TZ_EXT, strftime
+from isodate.isotzinfo import TZ_REGEX, build_tzinfo
+
+TIME_REGEX_CACHE = []
+# used to cache regular expressions to parse ISO time strings.
+
+
+def build_time_regexps():
+    """
+    Build regular expressions to parse ISO time string.
+
+    The regular expressions are compiled and stored in TIME_REGEX_CACHE
+    for later reuse.
+    """
+    if not TIME_REGEX_CACHE:
+        # ISO 8601 time representations allow decimal fractions on least
+        #    significant time component. Command and Full Stop are both valid
+        #    fraction separators.
+        #    The letter 'T' is allowed as time designator in front of a time
+        #    expression.
+        #    Immediately after a time expression, a time zone definition is
+        #      allowed.
+        #    a TZ may be missing (local time), be a 'Z' for UTC or a string of
+        #    +-hh:mm where the ':mm' part can be skipped.
+        # TZ information patterns:
+        #    ''
+        #    Z
+        #    +-hh:mm
+        #    +-hhmm
+        #    +-hh =>
+        #    isotzinfo.TZ_REGEX
+        def add_re(regex_text):
+            TIME_REGEX_CACHE.append(re.compile(r"\A" + regex_text + TZ_REGEX + r"\Z"))
+
+        # 1. complete time:
+        #    hh:mm:ss.ss ... extended format
+        add_re(
+            r"T?(?P<hour>[0-9]{2}):"
+            r"(?P<minute>[0-9]{2}):"
+            r"(?P<second>[0-9]{2}"
+            r"([,.][0-9]+)?)"
+        )
+        #    hhmmss.ss ... basic format
+        add_re(
+            r"T?(?P<hour>[0-9]{2})"
+            r"(?P<minute>[0-9]{2})"
+            r"(?P<second>[0-9]{2}"
+            r"([,.][0-9]+)?)"
+        )
+        # 2. reduced accuracy:
+        #    hh:mm.mm ... extended format
+        add_re(r"T?(?P<hour>[0-9]{2}):" r"(?P<minute>[0-9]{2}" r"([,.][0-9]+)?)")
+        #    hhmm.mm ... basic format
+        add_re(r"T?(?P<hour>[0-9]{2})" r"(?P<minute>[0-9]{2}" r"([,.][0-9]+)?)")
+        #    hh.hh ... basic format
+        add_re(r"T?(?P<hour>[0-9]{2}" r"([,.][0-9]+)?)")
+    return TIME_REGEX_CACHE
+
+
+def parse_time(timestring):
+    """
+    Parses ISO 8601 times into datetime.time objects.
+
+    Following ISO 8601 formats are supported:
+      (as decimal separator a ',' or a '.' is allowed)
+      hhmmss.ssTZD    basic complete time
+      hh:mm:ss.ssTZD  extended complete time
+      hhmm.mmTZD      basic reduced accuracy time
+      hh:mm.mmTZD     extended reduced accuracy time
+      hh.hhTZD        basic reduced accuracy time
+    TZD is the time zone designator which can be in the following format:
+              no designator indicates local time zone
+      Z       UTC
+      +-hhmm  basic hours and minutes
+      +-hh:mm extended hours and minutes
+      +-hh    hours
+    """
+    isotimes = build_time_regexps()
+    for pattern in isotimes:
+        match = pattern.match(timestring)
+        if match:
+            groups = match.groupdict()
+            for key, value in groups.items():
+                if value is not None:
+                    groups[key] = value.replace(",", ".")
+            tzinfo = build_tzinfo(
+                groups["tzname"],
+                groups["tzsign"],
+                int(groups["tzhour"] or 0),
+                int(groups["tzmin"] or 0),
+            )
+            if "second" in groups:
+                second = Decimal(groups["second"]).quantize(
+                    Decimal(".000001"), rounding=ROUND_FLOOR
+                )
+                microsecond = (second - int(second)) * int(1e6)
+                # int(...) ... no rounding
+                # to_integral() ... rounding
+                return time(
+                    int(groups["hour"]),
+                    int(groups["minute"]),
+                    int(second),
+                    int(microsecond.to_integral()),
+                    tzinfo,
+                )
+            if "minute" in groups:
+                minute = Decimal(groups["minute"])
+                second = Decimal((minute - int(minute)) * 60).quantize(
+                    Decimal(".000001"), rounding=ROUND_FLOOR
+                )
+                microsecond = (second - int(second)) * int(1e6)
+                return time(
+                    int(groups["hour"]),
+                    int(minute),
+                    int(second),
+                    int(microsecond.to_integral()),
+                    tzinfo,
+                )
+            else:
+                microsecond, second, minute = 0, 0, 0
+            hour = Decimal(groups["hour"])
+            minute = (hour - int(hour)) * 60
+            second = (minute - int(minute)) * 60
+            microsecond = (second - int(second)) * int(1e6)
+            return time(
+                int(hour),
+                int(minute),
+                int(second),
+                int(microsecond.to_integral()),
+                tzinfo,
+            )
+    raise ISO8601Error("Unrecognised ISO 8601 time format: %r" % timestring)
+
+
+def time_isoformat(ttime, format=TIME_EXT_COMPLETE + TZ_EXT):
+    """
+    Format time strings.
+
+    This method is just a wrapper around isodate.isostrf.strftime and uses
+    Time-Extended-Complete with extended time zone as default format.
+    """
+    return strftime(ttime, format)
diff --git a/.venv/lib/python3.12/site-packages/isodate/isotzinfo.py b/.venv/lib/python3.12/site-packages/isodate/isotzinfo.py
new file mode 100644
index 00000000..54f36de0
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/isodate/isotzinfo.py
@@ -0,0 +1,91 @@
+"""
+This module provides an ISO 8601:2004 time zone info parser.
+
+It offers a function to parse the time zone offset as specified by ISO 8601.
+"""
+
+import re
+
+from isodate.isoerror import ISO8601Error
+from isodate.tzinfo import UTC, ZERO, FixedOffset
+
+TZ_REGEX = (
+    r"(?P<tzname>(Z|(?P<tzsign>[+-])" r"(?P<tzhour>[0-9]{2})(:?(?P<tzmin>[0-9]{2}))?)?)"
+)
+
+TZ_RE = re.compile(TZ_REGEX)
+
+
+def build_tzinfo(tzname, tzsign="+", tzhour=0, tzmin=0):
+    """
+    create a tzinfo instance according to given parameters.
+
+    tzname:
+      'Z'       ... return UTC
+      '' | None ... return None
+      other     ... return FixedOffset
+    """
+    if tzname is None or tzname == "":
+        return None
+    if tzname == "Z":
+        return UTC
+    tzsign = ((tzsign == "-") and -1) or 1
+    return FixedOffset(tzsign * tzhour, tzsign * tzmin, tzname)
+
+
+def parse_tzinfo(tzstring):
+    """
+    Parses ISO 8601 time zone designators to tzinfo objects.
+
+    A time zone designator can be in the following format:
+              no designator indicates local time zone
+      Z       UTC
+      +-hhmm  basic hours and minutes
+      +-hh:mm extended hours and minutes
+      +-hh    hours
+    """
+    match = TZ_RE.match(tzstring)
+    if match:
+        groups = match.groupdict()
+        return build_tzinfo(
+            groups["tzname"],
+            groups["tzsign"],
+            int(groups["tzhour"] or 0),
+            int(groups["tzmin"] or 0),
+        )
+    raise ISO8601Error("%s not a valid time zone info" % tzstring)
+
+
+def tz_isoformat(dt, format="%Z"):
+    """
+    return time zone offset ISO 8601 formatted.
+    The various ISO formats can be chosen with the format parameter.
+
+    if tzinfo is None returns ''
+    if tzinfo is UTC returns 'Z'
+    else the offset is rendered to the given format.
+    format:
+        %h ... +-HH
+        %z ... +-HHMM
+        %Z ... +-HH:MM
+    """
+    tzinfo = dt.tzinfo
+    if (tzinfo is None) or (tzinfo.utcoffset(dt) is None):
+        return ""
+    if tzinfo.utcoffset(dt) == ZERO and tzinfo.dst(dt) == ZERO:
+        return "Z"
+    tdelta = tzinfo.utcoffset(dt)
+    seconds = tdelta.days * 24 * 60 * 60 + tdelta.seconds
+    sign = ((seconds < 0) and "-") or "+"
+    seconds = abs(seconds)
+    minutes, seconds = divmod(seconds, 60)
+    hours, minutes = divmod(minutes, 60)
+    if hours > 99:
+        raise OverflowError("can not handle differences > 99 hours")
+    if format == "%Z":
+        return "%s%02d:%02d" % (sign, hours, minutes)
+    elif format == "%z":
+        return "%s%02d%02d" % (sign, hours, minutes)
+    elif format == "%h":
+        return "%s%02d" % (sign, hours)
+    raise ValueError('unknown format string "%s"' % format)
diff --git a/.venv/lib/python3.12/site-packages/isodate/tzinfo.py b/.venv/lib/python3.12/site-packages/isodate/tzinfo.py
new file mode 100644
index 00000000..726c54a3
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/isodate/tzinfo.py
@@ -0,0 +1,166 @@
+"""
+This module provides some datetime.tzinfo implementations.
+
+All those classes are taken from the Python documentation.
+"""
+
+import time
+from datetime import timedelta, tzinfo
+
+ZERO = timedelta(0)
+# constant for zero time offset.
+
+
+class Utc(tzinfo):
+    """UTC
+
+    Universal time coordinated time zone.
+    """
+
+    def utcoffset(self, dt):
+        """
+        Return offset from UTC in minutes east of UTC, which is ZERO for UTC.
+        """
+        return ZERO
+
+    def tzname(self, dt):
+        """
+        Return the time zone name corresponding to the datetime object dt,
+        as a string.
+        """
+        return "UTC"
+
+    def dst(self, dt):
+        """
+        Return the daylight saving time (DST) adjustment, in minutes east
+        of UTC.
+        """
+        return ZERO
+
+    def __reduce__(self):
+        """
+        When unpickling a Utc object, return the default instance below, UTC.
+        """
+        return _Utc, ()
+
+
+UTC = Utc()
+# the default instance for UTC.
+
+
+def _Utc():
+    """
+    Helper function for unpickling a Utc object.
+    """
+    return UTC
+
+
+class FixedOffset(tzinfo):
+    """
+    A class building tzinfo objects for fixed-offset time zones.
+
+    Note that FixedOffset(0, 0, "UTC") or FixedOffset() is a different way to
+    build a UTC tzinfo object.
+    """
+
+    def __init__(self, offset_hours=0, offset_minutes=0, name="UTC"):
+        """
+        Initialise an instance with time offset and name.
+        The time offset should be positive for time zones east of UTC
+        and negate for time zones west of UTC.
+        """
+        self.__offset = timedelta(hours=offset_hours, minutes=offset_minutes)
+        self.__name = name
+
+    def utcoffset(self, dt):
+        """
+        Return offset from UTC in minutes of UTC.
+        """
+        return self.__offset
+
+    def tzname(self, dt):
+        """
+        Return the time zone name corresponding to the datetime object dt, as a
+        string.
+        """
+        return self.__name
+
+    def dst(self, dt):
+        """
+        Return the daylight saving time (DST) adjustment, in minutes east of
+        UTC.
+        """
+        return ZERO
+
+    def __repr__(self):
+        """
+        Return nicely formatted repr string.
+        """
+        return "<FixedOffset %r>" % self.__name
+
+
+STDOFFSET = timedelta(seconds=-time.timezone)
+# locale time zone offset
+
+# calculate local daylight saving offset if any.
+if time.daylight:
+    DSTOFFSET = timedelta(seconds=-time.altzone)
+else:
+    DSTOFFSET = STDOFFSET
+
+DSTDIFF = DSTOFFSET - STDOFFSET
+# difference between local time zone and local DST time zone
+
+
+class LocalTimezone(tzinfo):
+    """
+    A class capturing the platform's idea of local time.
+    """
+
+    def utcoffset(self, dt):
+        """
+        Return offset from UTC in minutes of UTC.
+        """
+        if self._isdst(dt):
+            return DSTOFFSET
+        else:
+            return STDOFFSET
+
+    def dst(self, dt):
+        """
+        Return daylight saving offset.
+        """
+        if self._isdst(dt):
+            return DSTDIFF
+        else:
+            return ZERO
+
+    def tzname(self, dt):
+        """
+        Return the time zone name corresponding to the datetime object dt, as a
+        string.
+        """
+        return time.tzname[self._isdst(dt)]
+
+    def _isdst(self, dt):
+        """
+        Returns true if DST is active for given datetime object dt.
+        """
+        tt = (
+            dt.year,
+            dt.month,
+            dt.day,
+            dt.hour,
+            dt.minute,
+            dt.second,
+            dt.weekday(),
+            0,
+            -1,
+        )
+        stamp = time.mktime(tt)
+        tt = time.localtime(stamp)
+        return tt.tm_isdst > 0
+
+
+# the default instance for local time zone.
+LOCAL = LocalTimezone()
diff --git a/.venv/lib/python3.12/site-packages/isodate/version.py b/.venv/lib/python3.12/site-packages/isodate/version.py
new file mode 100644
index 00000000..393e7229
--- /dev/null
+++ b/.venv/lib/python3.12/site-packages/isodate/version.py
@@ -0,0 +1,16 @@
+# file generated by setuptools_scm
+# don't change, don't track in version control
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple, Union
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '0.7.2'
+__version_tuple__ = version_tuple = (0, 7, 2)