changed to full name

.gitignore.txt

@@ -1 +0,0 @@
-.venv/

.venv/.gitignore

@@ -1,4 +0,0 @@
-.venv/
-# Created by venv; see https://docs.python.org/3/library/venv.html
-output.txt
-

.venv/Lib/site-packages/dateutil/__init__.py

@@ -1,24 +0,0 @@
-# -*- coding: utf-8 -*-
-import sys
-
-try:
-    from ._version import version as __version__
-except ImportError:
-    __version__ = 'unknown'
-
-__all__ = ['easter', 'parser', 'relativedelta', 'rrule', 'tz',
-           'utils', 'zoneinfo']
-
-def __getattr__(name):
-    import importlib
-
-    if name in __all__:
-        return importlib.import_module("." + name, __name__)
-    raise AttributeError(
-        "module {!r} has not attribute {!r}".format(__name__, name)
-    )
-
-
-def __dir__():
-    # __dir__ should include all the lazy-importable modules as well.
-    return [x for x in globals() if x not in sys.modules] + __all__

.venv/Lib/site-packages/dateutil/_common.py

@@ -1,43 +0,0 @@
-"""
-Common code used in multiple modules.
-"""
-
-
-class weekday(object):
-    __slots__ = ["weekday", "n"]
-
-    def __init__(self, weekday, n=None):
-        self.weekday = weekday
-        self.n = n
-
-    def __call__(self, n):
-        if n == self.n:
-            return self
-        else:
-            return self.__class__(self.weekday, n)
-
-    def __eq__(self, other):
-        try:
-            if self.weekday != other.weekday or self.n != other.n:
-                return False
-        except AttributeError:
-            return False
-        return True
-
-    def __hash__(self):
-        return hash((
-          self.weekday,
-          self.n,
-        ))
-
-    def __ne__(self, other):
-        return not (self == other)
-
-    def __repr__(self):
-        s = ("MO", "TU", "WE", "TH", "FR", "SA", "SU")[self.weekday]
-        if not self.n:
-            return s
-        else:
-            return "%s(%+d)" % (s, self.n)
-
-# vim:ts=4:sw=4:et

.venv/Lib/site-packages/dateutil/_version.py

@@ -1,4 +0,0 @@
-# file generated by setuptools_scm
-# don't change, don't track in version control
-__version__ = version = '2.9.0.post0'
-__version_tuple__ = version_tuple = (2, 9, 0)

.venv/Lib/site-packages/dateutil/easter.py

@@ -1,89 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-This module offers a generic Easter computing method for any given year, using
-Western, Orthodox or Julian algorithms.
-"""
-
-import datetime
-
-__all__ = ["easter", "EASTER_JULIAN", "EASTER_ORTHODOX", "EASTER_WESTERN"]
-
-EASTER_JULIAN = 1
-EASTER_ORTHODOX = 2
-EASTER_WESTERN = 3
-
-
-def easter(year, method=EASTER_WESTERN):
-    """
-    This method was ported from the work done by GM Arts,
-    on top of the algorithm by Claus Tondering, which was
-    based in part on the algorithm of Ouding (1940), as
-    quoted in "Explanatory Supplement to the Astronomical
-    Almanac", P.  Kenneth Seidelmann, editor.
-
-    This algorithm implements three different Easter
-    calculation methods:
-
-    1. Original calculation in Julian calendar, valid in
-       dates after 326 AD
-    2. Original method, with date converted to Gregorian
-       calendar, valid in years 1583 to 4099
-    3. Revised method, in Gregorian calendar, valid in
-       years 1583 to 4099 as well
-
-    These methods are represented by the constants:
-
-    * ``EASTER_JULIAN   = 1``
-    * ``EASTER_ORTHODOX = 2``
-    * ``EASTER_WESTERN  = 3``
-
-    The default method is method 3.
-
-    More about the algorithm may be found at:
-
-    `GM Arts: Easter Algorithms <http://www.gmarts.org/index.php?go=415>`_
-
-    and
-
-    `The Calendar FAQ: Easter <https://www.tondering.dk/claus/cal/easter.php>`_
-
-    """
-
-    if not (1 <= method <= 3):
-        raise ValueError("invalid method")
-
-    # g - Golden year - 1
-    # c - Century
-    # h - (23 - Epact) mod 30
-    # i - Number of days from March 21 to Paschal Full Moon
-    # j - Weekday for PFM (0=Sunday, etc)
-    # p - Number of days from March 21 to Sunday on or before PFM
-    #     (-6 to 28 methods 1 & 3, to 56 for method 2)
-    # e - Extra days to add for method 2 (converting Julian
-    #     date to Gregorian date)
-
-    y = year
-    g = y % 19
-    e = 0
-    if method < 3:
-        # Old method
-        i = (19*g + 15) % 30
-        j = (y + y//4 + i) % 7
-        if method == 2:
-            # Extra dates to convert Julian to Gregorian date
-            e = 10
-            if y > 1600:
-                e = e + y//100 - 16 - (y//100 - 16)//4
-    else:
-        # New method
-        c = y//100
-        h = (c - c//4 - (8*c + 13)//25 + 19*g + 15) % 30
-        i = h - (h//28)*(1 - (h//28)*(29//(h + 1))*((21 - g)//11))
-        j = (y + y//4 + i + 2 - c + c//4) % 7
-
-    # p can be from -6 to 56 corresponding to dates 22 March to 23 May
-    # (later dates apply to method 2, although 23 May never actually occurs)
-    p = i - j + e
-    d = 1 + (p + 27 + (p + 6)//40) % 31
-    m = 3 + (p + 26)//30
-    return datetime.date(int(y), int(m), int(d))

.venv/Lib/site-packages/dateutil/parser/__init__.py

@@ -1,61 +0,0 @@
-# -*- coding: utf-8 -*-
-from ._parser import parse, parser, parserinfo, ParserError
-from ._parser import DEFAULTPARSER, DEFAULTTZPARSER
-from ._parser import UnknownTimezoneWarning
-
-from ._parser import __doc__
-
-from .isoparser import isoparser, isoparse
-
-__all__ = ['parse', 'parser', 'parserinfo',
-           'isoparse', 'isoparser',
-           'ParserError',
-           'UnknownTimezoneWarning']
-
-
-###
-# Deprecate portions of the private interface so that downstream code that
-# is improperly relying on it is given *some* notice.
-
-
-def __deprecated_private_func(f):
-    from functools import wraps
-    import warnings
-
-    msg = ('{name} is a private function and may break without warning, '
-           'it will be moved and or renamed in future versions.')
-    msg = msg.format(name=f.__name__)
-
-    @wraps(f)
-    def deprecated_func(*args, **kwargs):
-        warnings.warn(msg, DeprecationWarning)
-        return f(*args, **kwargs)
-
-    return deprecated_func
-
-def __deprecate_private_class(c):
-    import warnings
-
-    msg = ('{name} is a private class and may break without warning, '
-           'it will be moved and or renamed in future versions.')
-    msg = msg.format(name=c.__name__)
-
-    class private_class(c):
-        __doc__ = c.__doc__
-
-        def __init__(self, *args, **kwargs):
-            warnings.warn(msg, DeprecationWarning)
-            super(private_class, self).__init__(*args, **kwargs)
-
-    private_class.__name__ = c.__name__
-
-    return private_class
-
-
-from ._parser import _timelex, _resultbase
-from ._parser import _tzparser, _parsetz
-
-_timelex = __deprecate_private_class(_timelex)
-_tzparser = __deprecate_private_class(_tzparser)
-_resultbase = __deprecate_private_class(_resultbase)
-_parsetz = __deprecated_private_func(_parsetz)

.venv/Lib/site-packages/dateutil/parser/isoparser.py

@@ -1,416 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-This module offers a parser for ISO-8601 strings
-
-It is intended to support all valid date, time and datetime formats per the
-ISO-8601 specification.
-
-..versionadded:: 2.7.0
-"""
-from datetime import datetime, timedelta, time, date
-import calendar
-from dateutil import tz
-
-from functools import wraps
-
-import re
-import six
-
-__all__ = ["isoparse", "isoparser"]
-
-
-def _takes_ascii(f):
-    @wraps(f)
-    def func(self, str_in, *args, **kwargs):
-        # If it's a stream, read the whole thing
-        str_in = getattr(str_in, 'read', lambda: str_in)()
-
-        # If it's unicode, turn it into bytes, since ISO-8601 only covers ASCII
-        if isinstance(str_in, six.text_type):
-            # ASCII is the same in UTF-8
-            try:
-                str_in = str_in.encode('ascii')
-            except UnicodeEncodeError as e:
-                msg = 'ISO-8601 strings should contain only ASCII characters'
-                six.raise_from(ValueError(msg), e)
-
-        return f(self, str_in, *args, **kwargs)
-
-    return func
-
-
-class isoparser(object):
-    def __init__(self, sep=None):
-        """
-        :param sep:
-            A single character that separates date and time portions. If
-            ``None``, the parser will accept any single character.
-            For strict ISO-8601 adherence, pass ``'T'``.
-        """
-        if sep is not None:
-            if (len(sep) != 1 or ord(sep) >= 128 or sep in '0123456789'):
-                raise ValueError('Separator must be a single, non-numeric ' +
-                                 'ASCII character')
-
-            sep = sep.encode('ascii')
-
-        self._sep = sep
-
-    @_takes_ascii
-    def isoparse(self, dt_str):
-        """
-        Parse an ISO-8601 datetime string into a :class:`datetime.datetime`.
-
-        An ISO-8601 datetime string consists of a date portion, followed
-        optionally by a time portion - the date and time portions are separated
-        by a single character separator, which is ``T`` in the official
-        standard. Incomplete date formats (such as ``YYYY-MM``) may *not* be
-        combined with a time portion.
-
-        Supported date formats are:
-
-        Common:
-
-        - ``YYYY``
-        - ``YYYY-MM``
-        - ``YYYY-MM-DD`` or ``YYYYMMDD``
-
-        Uncommon:
-
-        - ``YYYY-Www`` or ``YYYYWww`` - ISO week (day defaults to 0)
-        - ``YYYY-Www-D`` or ``YYYYWwwD`` - ISO week and day
-
-        The ISO week and day numbering follows the same logic as
-        :func:`datetime.date.isocalendar`.
-
-        Supported time formats are:
-
-        - ``hh``
-        - ``hh:mm`` or ``hhmm``
-        - ``hh:mm:ss`` or ``hhmmss``
-        - ``hh:mm:ss.ssssss`` (Up to 6 sub-second digits)
-
-        Midnight is a special case for `hh`, as the standard supports both
-        00:00 and 24:00 as a representation. The decimal separator can be
-        either a dot or a comma.
-
-
-        .. caution::
-
-            Support for fractional components other than seconds is part of the
-            ISO-8601 standard, but is not currently implemented in this parser.
-
-        Supported time zone offset formats are:
-
-        - `Z` (UTC)
-        - `±HH:MM`
-        - `±HHMM`
-        - `±HH`
-
-        Offsets will be represented as :class:`dateutil.tz.tzoffset` objects,
-        with the exception of UTC, which will be represented as
-        :class:`dateutil.tz.tzutc`. Time zone offsets equivalent to UTC (such
-        as `+00:00`) will also be represented as :class:`dateutil.tz.tzutc`.
-
-        :param dt_str:
-            A string or stream containing only an ISO-8601 datetime string
-
-        :return:
-            Returns a :class:`datetime.datetime` representing the string.
-            Unspecified components default to their lowest value.
-
-        .. warning::
-
-            As of version 2.7.0, the strictness of the parser should not be
-            considered a stable part of the contract. Any valid ISO-8601 string
-            that parses correctly with the default settings will continue to
-            parse correctly in future versions, but invalid strings that
-            currently fail (e.g. ``2017-01-01T00:00+00:00:00``) are not
-            guaranteed to continue failing in future versions if they encode
-            a valid date.
-
-        .. versionadded:: 2.7.0
-        """
-        components, pos = self._parse_isodate(dt_str)
-
-        if len(dt_str) > pos:
-            if self._sep is None or dt_str[pos:pos + 1] == self._sep:
-                components += self._parse_isotime(dt_str[pos + 1:])
-            else:
-                raise ValueError('String contains unknown ISO components')
-
-        if len(components) > 3 and components[3] == 24:
-            components[3] = 0
-            return datetime(*components) + timedelta(days=1)
-
-        return datetime(*components)
-
-    @_takes_ascii
-    def parse_isodate(self, datestr):
-        """
-        Parse the date portion of an ISO string.
-
-        :param datestr:
-            The string portion of an ISO string, without a separator
-
-        :return:
-            Returns a :class:`datetime.date` object
-        """
-        components, pos = self._parse_isodate(datestr)
-        if pos < len(datestr):
-            raise ValueError('String contains unknown ISO ' +
-                             'components: {!r}'.format(datestr.decode('ascii')))
-        return date(*components)
-
-    @_takes_ascii
-    def parse_isotime(self, timestr):
-        """
-        Parse the time portion of an ISO string.
-
-        :param timestr:
-            The time portion of an ISO string, without a separator
-
-        :return:
-            Returns a :class:`datetime.time` object
-        """
-        components = self._parse_isotime(timestr)
-        if components[0] == 24:
-            components[0] = 0
-        return time(*components)
-
-    @_takes_ascii
-    def parse_tzstr(self, tzstr, zero_as_utc=True):
-        """
-        Parse a valid ISO time zone string.
-
-        See :func:`isoparser.isoparse` for details on supported formats.
-
-        :param tzstr:
-            A string representing an ISO time zone offset
-
-        :param zero_as_utc:
-            Whether to return :class:`dateutil.tz.tzutc` for zero-offset zones
-
-        :return:
-            Returns :class:`dateutil.tz.tzoffset` for offsets and
-            :class:`dateutil.tz.tzutc` for ``Z`` and (if ``zero_as_utc`` is
-            specified) offsets equivalent to UTC.
-        """
-        return self._parse_tzstr(tzstr, zero_as_utc=zero_as_utc)
-
-    # Constants
-    _DATE_SEP = b'-'
-    _TIME_SEP = b':'
-    _FRACTION_REGEX = re.compile(b'[\\.,]([0-9]+)')
-
-    def _parse_isodate(self, dt_str):
-        try:
-            return self._parse_isodate_common(dt_str)
-        except ValueError:
-            return self._parse_isodate_uncommon(dt_str)
-
-    def _parse_isodate_common(self, dt_str):
-        len_str = len(dt_str)
-        components = [1, 1, 1]
-
-        if len_str < 4:
-            raise ValueError('ISO string too short')
-
-        # Year
-        components[0] = int(dt_str[0:4])
-        pos = 4
-        if pos >= len_str:
-            return components, pos
-
-        has_sep = dt_str[pos:pos + 1] == self._DATE_SEP
-        if has_sep:
-            pos += 1
-
-        # Month
-        if len_str - pos < 2:
-            raise ValueError('Invalid common month')
-
-        components[1] = int(dt_str[pos:pos + 2])
-        pos += 2
-
-        if pos >= len_str:
-            if has_sep:
-                return components, pos
-            else:
-                raise ValueError('Invalid ISO format')
-
-        if has_sep:
-            if dt_str[pos:pos + 1] != self._DATE_SEP:
-                raise ValueError('Invalid separator in ISO string')
-            pos += 1
-
-        # Day
-        if len_str - pos < 2:
-            raise ValueError('Invalid common day')
-        components[2] = int(dt_str[pos:pos + 2])
-        return components, pos + 2
-
-    def _parse_isodate_uncommon(self, dt_str):
-        if len(dt_str) < 4:
-            raise ValueError('ISO string too short')
-
-        # All ISO formats start with the year
-        year = int(dt_str[0:4])
-
-        has_sep = dt_str[4:5] == self._DATE_SEP
-
-        pos = 4 + has_sep       # Skip '-' if it's there
-        if dt_str[pos:pos + 1] == b'W':
-            # YYYY-?Www-?D?
-            pos += 1
-            weekno = int(dt_str[pos:pos + 2])
-            pos += 2
-
-            dayno = 1
-            if len(dt_str) > pos:
-                if (dt_str[pos:pos + 1] == self._DATE_SEP) != has_sep:
-                    raise ValueError('Inconsistent use of dash separator')
-
-                pos += has_sep
-
-                dayno = int(dt_str[pos:pos + 1])
-                pos += 1
-
-            base_date = self._calculate_weekdate(year, weekno, dayno)
-        else:
-            # YYYYDDD or YYYY-DDD
-            if len(dt_str) - pos < 3:
-                raise ValueError('Invalid ordinal day')
-
-            ordinal_day = int(dt_str[pos:pos + 3])
-            pos += 3
-
-            if ordinal_day < 1 or ordinal_day > (365 + calendar.isleap(year)):
-                raise ValueError('Invalid ordinal day' +
-                                 ' {} for year {}'.format(ordinal_day, year))
-
-            base_date = date(year, 1, 1) + timedelta(days=ordinal_day - 1)
-
-        components = [base_date.year, base_date.month, base_date.day]
-        return components, pos
-
-    def _calculate_weekdate(self, year, week, day):
-        """
-        Calculate the day of corresponding to the ISO year-week-day calendar.
-
-        This function is effectively the inverse of
-        :func:`datetime.date.isocalendar`.
-
-        :param year:
-            The year in the ISO calendar
-
-        :param week:
-            The week in the ISO calendar - range is [1, 53]
-
-        :param day:
-            The day in the ISO calendar - range is [1 (MON), 7 (SUN)]
-
-        :return:
-            Returns a :class:`datetime.date`
-        """
-        if not 0 < week < 54:
-            raise ValueError('Invalid week: {}'.format(week))
-
-        if not 0 < day < 8:     # Range is 1-7
-            raise ValueError('Invalid weekday: {}'.format(day))
-
-        # Get week 1 for the specific year:
-        jan_4 = date(year, 1, 4)   # Week 1 always has January 4th in it
-        week_1 = jan_4 - timedelta(days=jan_4.isocalendar()[2] - 1)
-
-        # Now add the specific number of weeks and days to get what we want
-        week_offset = (week - 1) * 7 + (day - 1)
-        return week_1 + timedelta(days=week_offset)
-
-    def _parse_isotime(self, timestr):
-        len_str = len(timestr)
-        components = [0, 0, 0, 0, None]
-        pos = 0
-        comp = -1
-
-        if len_str < 2:
-            raise ValueError('ISO time too short')
-
-        has_sep = False
-
-        while pos < len_str and comp < 5:
-            comp += 1
-
-            if timestr[pos:pos + 1] in b'-+Zz':
-                # Detect time zone boundary
-                components[-1] = self._parse_tzstr(timestr[pos:])
-                pos = len_str
-                break
-
-            if comp == 1 and timestr[pos:pos+1] == self._TIME_SEP:
-                has_sep = True
-                pos += 1
-            elif comp == 2 and has_sep:
-                if timestr[pos:pos+1] != self._TIME_SEP:
-                    raise ValueError('Inconsistent use of colon separator')
-                pos += 1
-
-            if comp < 3:
-                # Hour, minute, second
-                components[comp] = int(timestr[pos:pos + 2])
-                pos += 2
-
-            if comp == 3:
-                # Fraction of a second
-                frac = self._FRACTION_REGEX.match(timestr[pos:])
-                if not frac:
-                    continue
-
-                us_str = frac.group(1)[:6]  # Truncate to microseconds
-                components[comp] = int(us_str) * 10**(6 - len(us_str))
-                pos += len(frac.group())
-
-        if pos < len_str:
-            raise ValueError('Unused components in ISO string')
-
-        if components[0] == 24:
-            # Standard supports 00:00 and 24:00 as representations of midnight
-            if any(component != 0 for component in components[1:4]):
-                raise ValueError('Hour may only be 24 at 24:00:00.000')
-
-        return components
-
-    def _parse_tzstr(self, tzstr, zero_as_utc=True):
-        if tzstr == b'Z' or tzstr == b'z':
-            return tz.UTC
-
-        if len(tzstr) not in {3, 5, 6}:
-            raise ValueError('Time zone offset must be 1, 3, 5 or 6 characters')
-
-        if tzstr[0:1] == b'-':
-            mult = -1
-        elif tzstr[0:1] == b'+':
-            mult = 1
-        else:
-            raise ValueError('Time zone offset requires sign')
-
-        hours = int(tzstr[1:3])
-        if len(tzstr) == 3:
-            minutes = 0
-        else:
-            minutes = int(tzstr[(4 if tzstr[3:4] == self._TIME_SEP else 3):])
-
-        if zero_as_utc and hours == 0 and minutes == 0:
-            return tz.UTC
-        else:
-            if minutes > 59:
-                raise ValueError('Invalid minutes in time zone offset')
-
-            if hours > 23:
-                raise ValueError('Invalid hours in time zone offset')
-
-            return tz.tzoffset(None, mult * (hours * 60 + minutes) * 60)
-
-
-DEFAULT_ISOPARSER = isoparser()
-isoparse = DEFAULT_ISOPARSER.isoparse

.venv/Lib/site-packages/dateutil/relativedelta.py

@@ -1,599 +0,0 @@
-# -*- coding: utf-8 -*-
-import datetime
-import calendar
-
-import operator
-from math import copysign
-
-from six import integer_types
-from warnings import warn
-
-from ._common import weekday
-
-MO, TU, WE, TH, FR, SA, SU = weekdays = tuple(weekday(x) for x in range(7))
-
-__all__ = ["relativedelta", "MO", "TU", "WE", "TH", "FR", "SA", "SU"]
-
-
-class relativedelta(object):
-    """
-    The relativedelta type is designed to be applied to an existing datetime and
-    can replace specific components of that datetime, or represents an interval
-    of time.
-
-    It is based on the specification of the excellent work done by M.-A. Lemburg
-    in his
-    `mx.DateTime <https://www.egenix.com/products/python/mxBase/mxDateTime/>`_ extension.
-    However, notice that this type does *NOT* implement the same algorithm as
-    his work. Do *NOT* expect it to behave like mx.DateTime's counterpart.
-
-    There are two different ways to build a relativedelta instance. The
-    first one is passing it two date/datetime classes::
-
-        relativedelta(datetime1, datetime2)
-
-    The second one is passing it any number of the following keyword arguments::
-
-        relativedelta(arg1=x,arg2=y,arg3=z...)
-
-        year, month, day, hour, minute, second, microsecond:
-            Absolute information (argument is singular); adding or subtracting a
-            relativedelta with absolute information does not perform an arithmetic
-            operation, but rather REPLACES the corresponding value in the
-            original datetime with the value(s) in relativedelta.
-
-        years, months, weeks, days, hours, minutes, seconds, microseconds:
-            Relative information, may be negative (argument is plural); adding
-            or subtracting a relativedelta with relative information performs
-            the corresponding arithmetic operation on the original datetime value
-            with the information in the relativedelta.
-
-        weekday:
-            One of the weekday instances (MO, TU, etc) available in the
-            relativedelta module. These instances may receive a parameter N,
-            specifying the Nth weekday, which could be positive or negative
-            (like MO(+1) or MO(-2)). Not specifying it is the same as specifying
-            +1. You can also use an integer, where 0=MO. This argument is always
-            relative e.g. if the calculated date is already Monday, using MO(1)
-            or MO(-1) won't change the day. To effectively make it absolute, use
-            it in combination with the day argument (e.g. day=1, MO(1) for first
-            Monday of the month).
-
-        leapdays:
-            Will add given days to the date found, if year is a leap
-            year, and the date found is post 28 of february.
-
-        yearday, nlyearday:
-            Set the yearday or the non-leap year day (jump leap days).
-            These are converted to day/month/leapdays information.
-
-    There are relative and absolute forms of the keyword
-    arguments. The plural is relative, and the singular is
-    absolute. For each argument in the order below, the absolute form
-    is applied first (by setting each attribute to that value) and
-    then the relative form (by adding the value to the attribute).
-
-    The order of attributes considered when this relativedelta is
-    added to a datetime is:
-
-    1. Year
-    2. Month
-    3. Day
-    4. Hours
-    5. Minutes
-    6. Seconds
-    7. Microseconds
-
-    Finally, weekday is applied, using the rule described above.
-
-    For example
-
-    >>> from datetime import datetime
-    >>> from dateutil.relativedelta import relativedelta, MO
-    >>> dt = datetime(2018, 4, 9, 13, 37, 0)
-    >>> delta = relativedelta(hours=25, day=1, weekday=MO(1))
-    >>> dt + delta
-    datetime.datetime(2018, 4, 2, 14, 37)
-
-    First, the day is set to 1 (the first of the month), then 25 hours
-    are added, to get to the 2nd day and 14th hour, finally the
-    weekday is applied, but since the 2nd is already a Monday there is
-    no effect.
-
-    """
-
-    def __init__(self, dt1=None, dt2=None,
-                 years=0, months=0, days=0, leapdays=0, weeks=0,
-                 hours=0, minutes=0, seconds=0, microseconds=0,
-                 year=None, month=None, day=None, weekday=None,
-                 yearday=None, nlyearday=None,
-                 hour=None, minute=None, second=None, microsecond=None):
-
-        if dt1 and dt2:
-            # datetime is a subclass of date. So both must be date
-            if not (isinstance(dt1, datetime.date) and
-                    isinstance(dt2, datetime.date)):
-                raise TypeError("relativedelta only diffs datetime/date")
-
-            # We allow two dates, or two datetimes, so we coerce them to be
-            # of the same type
-            if (isinstance(dt1, datetime.datetime) !=
-                    isinstance(dt2, datetime.datetime)):
-                if not isinstance(dt1, datetime.datetime):
-                    dt1 = datetime.datetime.fromordinal(dt1.toordinal())
-                elif not isinstance(dt2, datetime.datetime):
-                    dt2 = datetime.datetime.fromordinal(dt2.toordinal())
-
-            self.years = 0
-            self.months = 0
-            self.days = 0
-            self.leapdays = 0
-            self.hours = 0
-            self.minutes = 0
-            self.seconds = 0
-            self.microseconds = 0
-            self.year = None
-            self.month = None
-            self.day = None
-            self.weekday = None
-            self.hour = None
-            self.minute = None
-            self.second = None
-            self.microsecond = None
-            self._has_time = 0
-
-            # Get year / month delta between the two
-            months = (dt1.year - dt2.year) * 12 + (dt1.month - dt2.month)
-            self._set_months(months)
-
-            # Remove the year/month delta so the timedelta is just well-defined
-            # time units (seconds, days and microseconds)
-            dtm = self.__radd__(dt2)
-
-            # If we've overshot our target, make an adjustment
-            if dt1 < dt2:
-                compare = operator.gt
-                increment = 1
-            else:
-                compare = operator.lt
-                increment = -1
-
-            while compare(dt1, dtm):
-                months += increment
-                self._set_months(months)
-                dtm = self.__radd__(dt2)
-
-            # Get the timedelta between the "months-adjusted" date and dt1
-            delta = dt1 - dtm
-            self.seconds = delta.seconds + delta.days * 86400
-            self.microseconds = delta.microseconds
-        else:
-            # Check for non-integer values in integer-only quantities
-            if any(x is not None and x != int(x) for x in (years, months)):
-                raise ValueError("Non-integer years and months are "
-                                 "ambiguous and not currently supported.")
-
-            # Relative information
-            self.years = int(years)
-            self.months = int(months)
-            self.days = days + weeks * 7
-            self.leapdays = leapdays
-            self.hours = hours
-            self.minutes = minutes
-            self.seconds = seconds
-            self.microseconds = microseconds
-
-            # Absolute information
-            self.year = year
-            self.month = month
-            self.day = day
-            self.hour = hour
-            self.minute = minute
-            self.second = second
-            self.microsecond = microsecond
-
-            if any(x is not None and int(x) != x
-                   for x in (year, month, day, hour,
-                             minute, second, microsecond)):
-                # For now we'll deprecate floats - later it'll be an error.
-                warn("Non-integer value passed as absolute information. " +
-                     "This is not a well-defined condition and will raise " +
-                     "errors in future versions.", DeprecationWarning)
-
-            if isinstance(weekday, integer_types):
-                self.weekday = weekdays[weekday]
-            else:
-                self.weekday = weekday
-
-            yday = 0
-            if nlyearday:
-                yday = nlyearday
-            elif yearday:
-                yday = yearday
-                if yearday > 59:
-                    self.leapdays = -1
-            if yday:
-                ydayidx = [31, 59, 90, 120, 151, 181, 212,
-                           243, 273, 304, 334, 366]
-                for idx, ydays in enumerate(ydayidx):
-                    if yday <= ydays:
-                        self.month = idx+1
-                        if idx == 0:
-                            self.day = yday
-                        else:
-                            self.day = yday-ydayidx[idx-1]
-                        break
-                else:
-                    raise ValueError("invalid year day (%d)" % yday)
-
-        self._fix()
-
-    def _fix(self):
-        if abs(self.microseconds) > 999999:
-            s = _sign(self.microseconds)
-            div, mod = divmod(self.microseconds * s, 1000000)
-            self.microseconds = mod * s
-            self.seconds += div * s
-        if abs(self.seconds) > 59:
-            s = _sign(self.seconds)
-            div, mod = divmod(self.seconds * s, 60)
-            self.seconds = mod * s
-            self.minutes += div * s
-        if abs(self.minutes) > 59:
-            s = _sign(self.minutes)
-            div, mod = divmod(self.minutes * s, 60)
-            self.minutes = mod * s
-            self.hours += div * s
-        if abs(self.hours) > 23:
-            s = _sign(self.hours)
-            div, mod = divmod(self.hours * s, 24)
-            self.hours = mod * s
-            self.days += div * s
-        if abs(self.months) > 11:
-            s = _sign(self.months)
-            div, mod = divmod(self.months * s, 12)
-            self.months = mod * s
-            self.years += div * s
-        if (self.hours or self.minutes or self.seconds or self.microseconds
-                or self.hour is not None or self.minute is not None or
-                self.second is not None or self.microsecond is not None):
-            self._has_time = 1
-        else:
-            self._has_time = 0
-
-    @property
-    def weeks(self):
-        return int(self.days / 7.0)
-
-    @weeks.setter
-    def weeks(self, value):
-        self.days = self.days - (self.weeks * 7) + value * 7
-
-    def _set_months(self, months):
-        self.months = months
-        if abs(self.months) > 11:
-            s = _sign(self.months)
-            div, mod = divmod(self.months * s, 12)
-            self.months = mod * s
-            self.years = div * s
-        else:
-            self.years = 0
-
-    def normalized(self):
-        """
-        Return a version of this object represented entirely using integer
-        values for the relative attributes.
-
-        >>> relativedelta(days=1.5, hours=2).normalized()
-        relativedelta(days=+1, hours=+14)
-
-        :return:
-            Returns a :class:`dateutil.relativedelta.relativedelta` object.
-        """
-        # Cascade remainders down (rounding each to roughly nearest microsecond)
-        days = int(self.days)
-
-        hours_f = round(self.hours + 24 * (self.days - days), 11)
-        hours = int(hours_f)
-
-        minutes_f = round(self.minutes + 60 * (hours_f - hours), 10)
-        minutes = int(minutes_f)
-
-        seconds_f = round(self.seconds + 60 * (minutes_f - minutes), 8)
-        seconds = int(seconds_f)
-
-        microseconds = round(self.microseconds + 1e6 * (seconds_f - seconds))
-
-        # Constructor carries overflow back up with call to _fix()
-        return self.__class__(years=self.years, months=self.months,
-                              days=days, hours=hours, minutes=minutes,
-                              seconds=seconds, microseconds=microseconds,
-                              leapdays=self.leapdays, year=self.year,
-                              month=self.month, day=self.day,
-                              weekday=self.weekday, hour=self.hour,
-                              minute=self.minute, second=self.second,
-                              microsecond=self.microsecond)
-
-    def __add__(self, other):
-        if isinstance(other, relativedelta):
-            return self.__class__(years=other.years + self.years,
-                                 months=other.months + self.months,
-                                 days=other.days + self.days,
-                                 hours=other.hours + self.hours,
-                                 minutes=other.minutes + self.minutes,
-                                 seconds=other.seconds + self.seconds,
-                                 microseconds=(other.microseconds +
-                                               self.microseconds),
-                                 leapdays=other.leapdays or self.leapdays,
-                                 year=(other.year if other.year is not None
-                                       else self.year),
-                                 month=(other.month if other.month is not None
-                                        else self.month),
-                                 day=(other.day if other.day is not None
-                                      else self.day),
-                                 weekday=(other.weekday if other.weekday is not None
-                                          else self.weekday),
-                                 hour=(other.hour if other.hour is not None
-                                       else self.hour),
-                                 minute=(other.minute if other.minute is not None
-                                         else self.minute),
-                                 second=(other.second if other.second is not None
-                                         else self.second),
-                                 microsecond=(other.microsecond if other.microsecond
-                                              is not None else
-                                              self.microsecond))
-        if isinstance(other, datetime.timedelta):
-            return self.__class__(years=self.years,
-                                  months=self.months,
-                                  days=self.days + other.days,
-                                  hours=self.hours,
-                                  minutes=self.minutes,
-                                  seconds=self.seconds + other.seconds,
-                                  microseconds=self.microseconds + other.microseconds,
-                                  leapdays=self.leapdays,
-                                  year=self.year,
-                                  month=self.month,
-                                  day=self.day,
-                                  weekday=self.weekday,
-                                  hour=self.hour,
-                                  minute=self.minute,
-                                  second=self.second,
-                                  microsecond=self.microsecond)
-        if not isinstance(other, datetime.date):
-            return NotImplemented
-        elif self._has_time and not isinstance(other, datetime.datetime):
-            other = datetime.datetime.fromordinal(other.toordinal())
-        year = (self.year or other.year)+self.years
-        month = self.month or other.month
-        if self.months:
-            assert 1 <= abs(self.months) <= 12
-            month += self.months
-            if month > 12:
-                year += 1
-                month -= 12
-            elif month < 1:
-                year -= 1
-                month += 12
-        day = min(calendar.monthrange(year, month)[1],
-                  self.day or other.day)
-        repl = {"year": year, "month": month, "day": day}
-        for attr in ["hour", "minute", "second", "microsecond"]:
-            value = getattr(self, attr)
-            if value is not None:
-                repl[attr] = value
-        days = self.days
-        if self.leapdays and month > 2 and calendar.isleap(year):
-            days += self.leapdays
-        ret = (other.replace(**repl)
-               + datetime.timedelta(days=days,
-                                    hours=self.hours,
-                                    minutes=self.minutes,
-                                    seconds=self.seconds,
-                                    microseconds=self.microseconds))
-        if self.weekday:
-            weekday, nth = self.weekday.weekday, self.weekday.n or 1
-            jumpdays = (abs(nth) - 1) * 7
-            if nth > 0:
-                jumpdays += (7 - ret.weekday() + weekday) % 7
-            else:
-                jumpdays += (ret.weekday() - weekday) % 7
-                jumpdays *= -1
-            ret += datetime.timedelta(days=jumpdays)
-        return ret
-
-    def __radd__(self, other):
-        return self.__add__(other)
-
-    def __rsub__(self, other):
-        return self.__neg__().__radd__(other)
-
-    def __sub__(self, other):
-        if not isinstance(other, relativedelta):
-            return NotImplemented   # In case the other object defines __rsub__
-        return self.__class__(years=self.years - other.years,
-                             months=self.months - other.months,
-                             days=self.days - other.days,
-                             hours=self.hours - other.hours,
-                             minutes=self.minutes - other.minutes,
-                             seconds=self.seconds - other.seconds,
-                             microseconds=self.microseconds - other.microseconds,
-                             leapdays=self.leapdays or other.leapdays,
-                             year=(self.year if self.year is not None
-                                   else other.year),
-                             month=(self.month if self.month is not None else
-                                    other.month),
-                             day=(self.day if self.day is not None else
-                                  other.day),
-                             weekday=(self.weekday if self.weekday is not None else
-                                      other.weekday),
-                             hour=(self.hour if self.hour is not None else
-                                   other.hour),
-                             minute=(self.minute if self.minute is not None else
-                                     other.minute),
-                             second=(self.second if self.second is not None else
-                                     other.second),
-                             microsecond=(self.microsecond if self.microsecond
-                                          is not None else
-                                          other.microsecond))
-
-    def __abs__(self):
-        return self.__class__(years=abs(self.years),
-                              months=abs(self.months),
-                              days=abs(self.days),
-                              hours=abs(self.hours),
-                              minutes=abs(self.minutes),
-                              seconds=abs(self.seconds),
-                              microseconds=abs(self.microseconds),
-                              leapdays=self.leapdays,
-                              year=self.year,
-                              month=self.month,
-                              day=self.day,
-                              weekday=self.weekday,
-                              hour=self.hour,
-                              minute=self.minute,
-                              second=self.second,
-                              microsecond=self.microsecond)
-
-    def __neg__(self):
-        return self.__class__(years=-self.years,
-                             months=-self.months,
-                             days=-self.days,
-                             hours=-self.hours,
-                             minutes=-self.minutes,
-                             seconds=-self.seconds,
-                             microseconds=-self.microseconds,
-                             leapdays=self.leapdays,
-                             year=self.year,
-                             month=self.month,
-                             day=self.day,
-                             weekday=self.weekday,
-                             hour=self.hour,
-                             minute=self.minute,
-                             second=self.second,
-                             microsecond=self.microsecond)
-
-    def __bool__(self):
-        return not (not self.years and
-                    not self.months and
-                    not self.days and
-                    not self.hours and
-                    not self.minutes and
-                    not self.seconds and
-                    not self.microseconds and
-                    not self.leapdays and
-                    self.year is None and
-                    self.month is None and
-                    self.day is None and
-                    self.weekday is None and
-                    self.hour is None and
-                    self.minute is None and
-                    self.second is None and
-                    self.microsecond is None)
-    # Compatibility with Python 2.x
-    __nonzero__ = __bool__
-
-    def __mul__(self, other):
-        try:
-            f = float(other)
-        except TypeError:
-            return NotImplemented
-
-        return self.__class__(years=int(self.years * f),
-                             months=int(self.months * f),
-                             days=int(self.days * f),
-                             hours=int(self.hours * f),
-                             minutes=int(self.minutes * f),
-                             seconds=int(self.seconds * f),
-                             microseconds=int(self.microseconds * f),
-                             leapdays=self.leapdays,
-                             year=self.year,
-                             month=self.month,
-                             day=self.day,
-                             weekday=self.weekday,
-                             hour=self.hour,
-                             minute=self.minute,
-                             second=self.second,
-                             microsecond=self.microsecond)
-
-    __rmul__ = __mul__
-
-    def __eq__(self, other):
-        if not isinstance(other, relativedelta):
-            return NotImplemented
-        if self.weekday or other.weekday:
-            if not self.weekday or not other.weekday:
-                return False
-            if self.weekday.weekday != other.weekday.weekday:
-                return False
-            n1, n2 = self.weekday.n, other.weekday.n
-            if n1 != n2 and not ((not n1 or n1 == 1) and (not n2 or n2 == 1)):
-                return False
-        return (self.years == other.years and
-                self.months == other.months and
-                self.days == other.days and
-                self.hours == other.hours and
-                self.minutes == other.minutes and
-                self.seconds == other.seconds and
-                self.microseconds == other.microseconds and
-                self.leapdays == other.leapdays and
-                self.year == other.year and
-                self.month == other.month and
-                self.day == other.day and
-                self.hour == other.hour and
-                self.minute == other.minute and
-                self.second == other.second and
-                self.microsecond == other.microsecond)
-
-    def __hash__(self):
-        return hash((
-            self.weekday,
-            self.years,
-            self.months,
-            self.days,
-            self.hours,
-            self.minutes,
-            self.seconds,
-            self.microseconds,
-            self.leapdays,
-            self.year,
-            self.month,
-            self.day,
-            self.hour,
-            self.minute,
-            self.second,
-            self.microsecond,
-        ))
-
-    def __ne__(self, other):
-        return not self.__eq__(other)
-
-    def __div__(self, other):
-        try:
-            reciprocal = 1 / float(other)
-        except TypeError:
-            return NotImplemented
-
-        return self.__mul__(reciprocal)
-
-    __truediv__ = __div__
-
-    def __repr__(self):
-        l = []
-        for attr in ["years", "months", "days", "leapdays",
-                     "hours", "minutes", "seconds", "microseconds"]:
-            value = getattr(self, attr)
-            if value:
-                l.append("{attr}={value:+g}".format(attr=attr, value=value))
-        for attr in ["year", "month", "day", "weekday",
-                     "hour", "minute", "second", "microsecond"]:
-            value = getattr(self, attr)
-            if value is not None:
-                l.append("{attr}={value}".format(attr=attr, value=repr(value)))
-        return "{classname}({attrs})".format(classname=self.__class__.__name__,
-                                             attrs=", ".join(l))
-
-
-def _sign(x):
-    return int(copysign(1, x))
-
-# vim:ts=4:sw=4:et

.venv/Lib/site-packages/dateutil/tz/__init__.py

@@ -1,12 +0,0 @@
-# -*- coding: utf-8 -*-
-from .tz import *
-from .tz import __doc__
-
-__all__ = ["tzutc", "tzoffset", "tzlocal", "tzfile", "tzrange",
-           "tzstr", "tzical", "tzwin", "tzwinlocal", "gettz",
-           "enfold", "datetime_ambiguous", "datetime_exists",
-           "resolve_imaginary", "UTC", "DeprecatedTzFormatWarning"]
-
-
-class DeprecatedTzFormatWarning(Warning):
-    """Warning raised when time zones are parsed from deprecated formats."""

.venv/Lib/site-packages/dateutil/tz/_common.py

@@ -1,419 +0,0 @@
-from six import PY2
-
-from functools import wraps
-
-from datetime import datetime, timedelta, tzinfo
-
-
-ZERO = timedelta(0)
-
-__all__ = ['tzname_in_python2', 'enfold']
-
-
-def tzname_in_python2(namefunc):
-    """Change unicode output into bytestrings in Python 2
-
-    tzname() API changed in Python 3. It used to return bytes, but was changed
-    to unicode strings
-    """
-    if PY2:
-        @wraps(namefunc)
-        def adjust_encoding(*args, **kwargs):
-            name = namefunc(*args, **kwargs)
-            if name is not None:
-                name = name.encode()
-
-            return name
-
-        return adjust_encoding
-    else:
-        return namefunc
-
-
-# The following is adapted from Alexander Belopolsky's tz library
-# https://github.com/abalkin/tz
-if hasattr(datetime, 'fold'):
-    # This is the pre-python 3.6 fold situation
-    def enfold(dt, fold=1):
-        """
-        Provides a unified interface for assigning the ``fold`` attribute to
-        datetimes both before and after the implementation of PEP-495.
-
-        :param fold:
-            The value for the ``fold`` attribute in the returned datetime. This
-            should be either 0 or 1.
-
-        :return:
-            Returns an object for which ``getattr(dt, 'fold', 0)`` returns
-            ``fold`` for all versions of Python. In versions prior to
-            Python 3.6, this is a ``_DatetimeWithFold`` object, which is a
-            subclass of :py:class:`datetime.datetime` with the ``fold``
-            attribute added, if ``fold`` is 1.
-
-        .. versionadded:: 2.6.0
-        """
-        return dt.replace(fold=fold)
-
-else:
-    class _DatetimeWithFold(datetime):
-        """
-        This is a class designed to provide a PEP 495-compliant interface for
-        Python versions before 3.6. It is used only for dates in a fold, so
-        the ``fold`` attribute is fixed at ``1``.
-
-        .. versionadded:: 2.6.0
-        """
-        __slots__ = ()
-
-        def replace(self, *args, **kwargs):
-            """
-            Return a datetime with the same attributes, except for those
-            attributes given new values by whichever keyword arguments are
-            specified. Note that tzinfo=None can be specified to create a naive
-            datetime from an aware datetime with no conversion of date and time
-            data.
-
-            This is reimplemented in ``_DatetimeWithFold`` because pypy3 will
-            return a ``datetime.datetime`` even if ``fold`` is unchanged.
-            """
-            argnames = (
-                'year', 'month', 'day', 'hour', 'minute', 'second',
-                'microsecond', 'tzinfo'
-            )
-
-            for arg, argname in zip(args, argnames):
-                if argname in kwargs:
-                    raise TypeError('Duplicate argument: {}'.format(argname))
-
-                kwargs[argname] = arg
-
-            for argname in argnames:
-                if argname not in kwargs:
-                    kwargs[argname] = getattr(self, argname)
-
-            dt_class = self.__class__ if kwargs.get('fold', 1) else datetime
-
-            return dt_class(**kwargs)
-
-        @property
-        def fold(self):
-            return 1
-
-    def enfold(dt, fold=1):
-        """
-        Provides a unified interface for assigning the ``fold`` attribute to
-        datetimes both before and after the implementation of PEP-495.
-
-        :param fold:
-            The value for the ``fold`` attribute in the returned datetime. This
-            should be either 0 or 1.
-
-        :return:
-            Returns an object for which ``getattr(dt, 'fold', 0)`` returns
-            ``fold`` for all versions of Python. In versions prior to
-            Python 3.6, this is a ``_DatetimeWithFold`` object, which is a
-            subclass of :py:class:`datetime.datetime` with the ``fold``
-            attribute added, if ``fold`` is 1.
-
-        .. versionadded:: 2.6.0
-        """
-        if getattr(dt, 'fold', 0) == fold:
-            return dt
-
-        args = dt.timetuple()[:6]
-        args += (dt.microsecond, dt.tzinfo)
-
-        if fold:
-            return _DatetimeWithFold(*args)
-        else:
-            return datetime(*args)
-
-
-def _validate_fromutc_inputs(f):
-    """
-    The CPython version of ``fromutc`` checks that the input is a ``datetime``
-    object and that ``self`` is attached as its ``tzinfo``.
-    """
-    @wraps(f)
-    def fromutc(self, dt):
-        if not isinstance(dt, datetime):
-            raise TypeError("fromutc() requires a datetime argument")
-        if dt.tzinfo is not self:
-            raise ValueError("dt.tzinfo is not self")
-
-        return f(self, dt)
-
-    return fromutc
-
-
-class _tzinfo(tzinfo):
-    """
-    Base class for all ``dateutil`` ``tzinfo`` objects.
-    """
-
-    def is_ambiguous(self, dt):
-        """
-        Whether or not the "wall time" of a given datetime is ambiguous in this
-        zone.
-
-        :param dt:
-            A :py:class:`datetime.datetime`, naive or time zone aware.
-
-
-        :return:
-            Returns ``True`` if ambiguous, ``False`` otherwise.
-
-        .. versionadded:: 2.6.0
-        """
-
-        dt = dt.replace(tzinfo=self)
-
-        wall_0 = enfold(dt, fold=0)
-        wall_1 = enfold(dt, fold=1)
-
-        same_offset = wall_0.utcoffset() == wall_1.utcoffset()
-        same_dt = wall_0.replace(tzinfo=None) == wall_1.replace(tzinfo=None)
-
-        return same_dt and not same_offset
-
-    def _fold_status(self, dt_utc, dt_wall):
-        """
-        Determine the fold status of a "wall" datetime, given a representation
-        of the same datetime as a (naive) UTC datetime. This is calculated based
-        on the assumption that ``dt.utcoffset() - dt.dst()`` is constant for all
-        datetimes, and that this offset is the actual number of hours separating
-        ``dt_utc`` and ``dt_wall``.
-
-        :param dt_utc:
-            Representation of the datetime as UTC
-
-        :param dt_wall:
-            Representation of the datetime as "wall time". This parameter must
-            either have a `fold` attribute or have a fold-naive
-            :class:`datetime.tzinfo` attached, otherwise the calculation may
-            fail.
-        """
-        if self.is_ambiguous(dt_wall):
-            delta_wall = dt_wall - dt_utc
-            _fold = int(delta_wall == (dt_utc.utcoffset() - dt_utc.dst()))
-        else:
-            _fold = 0
-
-        return _fold
-
-    def _fold(self, dt):
-        return getattr(dt, 'fold', 0)
-
-    def _fromutc(self, dt):
-        """
-        Given a timezone-aware datetime in a given timezone, calculates a
-        timezone-aware datetime in a new timezone.
-
-        Since this is the one time that we *know* we have an unambiguous
-        datetime object, we take this opportunity to determine whether the
-        datetime is ambiguous and in a "fold" state (e.g. if it's the first
-        occurrence, chronologically, of the ambiguous datetime).
-
-        :param dt:
-            A timezone-aware :class:`datetime.datetime` object.
-        """
-
-        # Re-implement the algorithm from Python's datetime.py
-        dtoff = dt.utcoffset()
-        if dtoff is None:
-            raise ValueError("fromutc() requires a non-None utcoffset() "
-                             "result")
-
-        # The original datetime.py code assumes that `dst()` defaults to
-        # zero during ambiguous times. PEP 495 inverts this presumption, so
-        # for pre-PEP 495 versions of python, we need to tweak the algorithm.
-        dtdst = dt.dst()
-        if dtdst is None:
-            raise ValueError("fromutc() requires a non-None dst() result")
-        delta = dtoff - dtdst
-
-        dt += delta
-        # Set fold=1 so we can default to being in the fold for
-        # ambiguous dates.
-        dtdst = enfold(dt, fold=1).dst()
-        if dtdst is None:
-            raise ValueError("fromutc(): dt.dst gave inconsistent "
-                             "results; cannot convert")
-        return dt + dtdst
-
-    @_validate_fromutc_inputs
-    def fromutc(self, dt):
-        """
-        Given a timezone-aware datetime in a given timezone, calculates a
-        timezone-aware datetime in a new timezone.
-
-        Since this is the one time that we *know* we have an unambiguous
-        datetime object, we take this opportunity to determine whether the
-        datetime is ambiguous and in a "fold" state (e.g. if it's the first
-        occurrence, chronologically, of the ambiguous datetime).
-
-        :param dt:
-            A timezone-aware :class:`datetime.datetime` object.
-        """
-        dt_wall = self._fromutc(dt)
-
-        # Calculate the fold status given the two datetimes.
-        _fold = self._fold_status(dt, dt_wall)
-
-        # Set the default fold value for ambiguous dates
-        return enfold(dt_wall, fold=_fold)
-
-
-class tzrangebase(_tzinfo):
-    """
-    This is an abstract base class for time zones represented by an annual
-    transition into and out of DST. Child classes should implement the following
-    methods:
-
-        * ``__init__(self, *args, **kwargs)``
-        * ``transitions(self, year)`` - this is expected to return a tuple of
-          datetimes representing the DST on and off transitions in standard
-          time.
-
-    A fully initialized ``tzrangebase`` subclass should also provide the
-    following attributes:
-        * ``hasdst``: Boolean whether or not the zone uses DST.
-        * ``_dst_offset`` / ``_std_offset``: :class:`datetime.timedelta` objects
-          representing the respective UTC offsets.
-        * ``_dst_abbr`` / ``_std_abbr``: Strings representing the timezone short
-          abbreviations in DST and STD, respectively.
-        * ``_hasdst``: Whether or not the zone has DST.
-
-    .. versionadded:: 2.6.0
-    """
-    def __init__(self):
-        raise NotImplementedError('tzrangebase is an abstract base class')
-
-    def utcoffset(self, dt):
-        isdst = self._isdst(dt)
-
-        if isdst is None:
-            return None
-        elif isdst:
-            return self._dst_offset
-        else:
-            return self._std_offset
-
-    def dst(self, dt):
-        isdst = self._isdst(dt)
-
-        if isdst is None:
-            return None
-        elif isdst:
-            return self._dst_base_offset
-        else:
-            return ZERO
-
-    @tzname_in_python2
-    def tzname(self, dt):
-        if self._isdst(dt):
-            return self._dst_abbr
-        else:
-            return self._std_abbr
-
-    def fromutc(self, dt):
-        """ Given a datetime in UTC, return local time """
-        if not isinstance(dt, datetime):
-            raise TypeError("fromutc() requires a datetime argument")
-
-        if dt.tzinfo is not self:
-            raise ValueError("dt.tzinfo is not self")
-
-        # Get transitions - if there are none, fixed offset
-        transitions = self.transitions(dt.year)
-        if transitions is None:
-            return dt + self.utcoffset(dt)
-
-        # Get the transition times in UTC
-        dston, dstoff = transitions
-
-        dston -= self._std_offset
-        dstoff -= self._std_offset
-
-        utc_transitions = (dston, dstoff)
-        dt_utc = dt.replace(tzinfo=None)
-
-        isdst = self._naive_isdst(dt_utc, utc_transitions)
-
-        if isdst:
-            dt_wall = dt + self._dst_offset
-        else:
-            dt_wall = dt + self._std_offset
-
-        _fold = int(not isdst and self.is_ambiguous(dt_wall))
-
-        return enfold(dt_wall, fold=_fold)
-
-    def is_ambiguous(self, dt):
-        """
-        Whether or not the "wall time" of a given datetime is ambiguous in this
-        zone.
-
-        :param dt:
-            A :py:class:`datetime.datetime`, naive or time zone aware.
-
-
-        :return:
-            Returns ``True`` if ambiguous, ``False`` otherwise.
-
-        .. versionadded:: 2.6.0
-        """
-        if not self.hasdst:
-            return False
-
-        start, end = self.transitions(dt.year)
-
-        dt = dt.replace(tzinfo=None)
-        return (end <= dt < end + self._dst_base_offset)
-
-    def _isdst(self, dt):
-        if not self.hasdst:
-            return False
-        elif dt is None:
-            return None
-
-        transitions = self.transitions(dt.year)
-
-        if transitions is None:
-            return False
-
-        dt = dt.replace(tzinfo=None)
-
-        isdst = self._naive_isdst(dt, transitions)
-
-        # Handle ambiguous dates
-        if not isdst and self.is_ambiguous(dt):
-            return not self._fold(dt)
-        else:
-            return isdst
-
-    def _naive_isdst(self, dt, transitions):
-        dston, dstoff = transitions
-
-        dt = dt.replace(tzinfo=None)
-
-        if dston < dstoff:
-            isdst = dston <= dt < dstoff
-        else:
-            isdst = not dstoff <= dt < dston
-
-        return isdst
-
-    @property
-    def _dst_base_offset(self):
-        return self._dst_offset - self._std_offset
-
-    __hash__ = None
-
-    def __ne__(self, other):
-        return not (self == other)
-
-    def __repr__(self):
-        return "%s(...)" % self.__class__.__name__
-
-    __reduce__ = object.__reduce__

.venv/Lib/site-packages/dateutil/tz/_factories.py

@@ -1,80 +0,0 @@
-from datetime import timedelta
-import weakref
-from collections import OrderedDict
-
-from six.moves import _thread
-
-
-class _TzSingleton(type):
-    def __init__(cls, *args, **kwargs):
-        cls.__instance = None
-        super(_TzSingleton, cls).__init__(*args, **kwargs)
-
-    def __call__(cls):
-        if cls.__instance is None:
-            cls.__instance = super(_TzSingleton, cls).__call__()
-        return cls.__instance
-
-
-class _TzFactory(type):
-    def instance(cls, *args, **kwargs):
-        """Alternate constructor that returns a fresh instance"""
-        return type.__call__(cls, *args, **kwargs)
-
-
-class _TzOffsetFactory(_TzFactory):
-    def __init__(cls, *args, **kwargs):
-        cls.__instances = weakref.WeakValueDictionary()
-        cls.__strong_cache = OrderedDict()
-        cls.__strong_cache_size = 8
-
-        cls._cache_lock = _thread.allocate_lock()
-
-    def __call__(cls, name, offset):
-        if isinstance(offset, timedelta):
-            key = (name, offset.total_seconds())
-        else:
-            key = (name, offset)
-
-        instance = cls.__instances.get(key, None)
-        if instance is None:
-            instance = cls.__instances.setdefault(key,
-                                                  cls.instance(name, offset))
-
-        # This lock may not be necessary in Python 3. See GH issue #901
-        with cls._cache_lock:
-            cls.__strong_cache[key] = cls.__strong_cache.pop(key, instance)
-
-            # Remove an item if the strong cache is overpopulated
-            if len(cls.__strong_cache) > cls.__strong_cache_size:
-                cls.__strong_cache.popitem(last=False)
-
-        return instance
-
-
-class _TzStrFactory(_TzFactory):
-    def __init__(cls, *args, **kwargs):
-        cls.__instances = weakref.WeakValueDictionary()
-        cls.__strong_cache = OrderedDict()
-        cls.__strong_cache_size = 8
-
-        cls.__cache_lock = _thread.allocate_lock()
-
-    def __call__(cls, s, posix_offset=False):
-        key = (s, posix_offset)
-        instance = cls.__instances.get(key, None)
-
-        if instance is None:
-            instance = cls.__instances.setdefault(key,
-                cls.instance(s, posix_offset))
-
-        # This lock may not be necessary in Python 3. See GH issue #901
-        with cls.__cache_lock:
-            cls.__strong_cache[key] = cls.__strong_cache.pop(key, instance)
-
-            # Remove an item if the strong cache is overpopulated
-            if len(cls.__strong_cache) > cls.__strong_cache_size:
-                cls.__strong_cache.popitem(last=False)
-
-        return instance
-

.venv/Lib/site-packages/dateutil/tz/win.py

@@ -1,370 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-This module provides an interface to the native time zone data on Windows,
-including :py:class:`datetime.tzinfo` implementations.
-
-Attempting to import this module on a non-Windows platform will raise an
-:py:obj:`ImportError`.
-"""
-# This code was originally contributed by Jeffrey Harris.
-import datetime
-import struct
-
-from six.moves import winreg
-from six import text_type
-
-try:
-    import ctypes
-    from ctypes import wintypes
-except ValueError:
-    # ValueError is raised on non-Windows systems for some horrible reason.
-    raise ImportError("Running tzwin on non-Windows system")
-
-from ._common import tzrangebase
-
-__all__ = ["tzwin", "tzwinlocal", "tzres"]
-
-ONEWEEK = datetime.timedelta(7)
-
-TZKEYNAMENT = r"SOFTWARE\Microsoft\Windows NT\CurrentVersion\Time Zones"
-TZKEYNAME9X = r"SOFTWARE\Microsoft\Windows\CurrentVersion\Time Zones"
-TZLOCALKEYNAME = r"SYSTEM\CurrentControlSet\Control\TimeZoneInformation"
-
-
-def _settzkeyname():
-    handle = winreg.ConnectRegistry(None, winreg.HKEY_LOCAL_MACHINE)
-    try:
-        winreg.OpenKey(handle, TZKEYNAMENT).Close()
-        TZKEYNAME = TZKEYNAMENT
-    except WindowsError:
-        TZKEYNAME = TZKEYNAME9X
-    handle.Close()
-    return TZKEYNAME
-
-
-TZKEYNAME = _settzkeyname()
-
-
-class tzres(object):
-    """
-    Class for accessing ``tzres.dll``, which contains timezone name related
-    resources.
-
-    .. versionadded:: 2.5.0
-    """
-    p_wchar = ctypes.POINTER(wintypes.WCHAR)        # Pointer to a wide char
-
-    def __init__(self, tzres_loc='tzres.dll'):
-        # Load the user32 DLL so we can load strings from tzres
-        user32 = ctypes.WinDLL('user32')
-
-        # Specify the LoadStringW function
-        user32.LoadStringW.argtypes = (wintypes.HINSTANCE,
-                                       wintypes.UINT,
-                                       wintypes.LPWSTR,
-                                       ctypes.c_int)
-
-        self.LoadStringW = user32.LoadStringW
-        self._tzres = ctypes.WinDLL(tzres_loc)
-        self.tzres_loc = tzres_loc
-
-    def load_name(self, offset):
-        """
-        Load a timezone name from a DLL offset (integer).
-
-        >>> from dateutil.tzwin import tzres
-        >>> tzr = tzres()
-        >>> print(tzr.load_name(112))
-        'Eastern Standard Time'
-
-        :param offset:
-            A positive integer value referring to a string from the tzres dll.
-
-        .. note::
-
-            Offsets found in the registry are generally of the form
-            ``@tzres.dll,-114``. The offset in this case is 114, not -114.
-
-        """
-        resource = self.p_wchar()
-        lpBuffer = ctypes.cast(ctypes.byref(resource), wintypes.LPWSTR)
-        nchar = self.LoadStringW(self._tzres._handle, offset, lpBuffer, 0)
-        return resource[:nchar]
-
-    def name_from_string(self, tzname_str):
-        """
-        Parse strings as returned from the Windows registry into the time zone
-        name as defined in the registry.
-
-        >>> from dateutil.tzwin import tzres
-        >>> tzr = tzres()
-        >>> print(tzr.name_from_string('@tzres.dll,-251'))
-        'Dateline Daylight Time'
-        >>> print(tzr.name_from_string('Eastern Standard Time'))
-        'Eastern Standard Time'
-
-        :param tzname_str:
-            A timezone name string as returned from a Windows registry key.
-
-        :return:
-            Returns the localized timezone string from tzres.dll if the string
-            is of the form `@tzres.dll,-offset`, else returns the input string.
-        """
-        if not tzname_str.startswith('@'):
-            return tzname_str
-
-        name_splt = tzname_str.split(',-')
-        try:
-            offset = int(name_splt[1])
-        except:
-            raise ValueError("Malformed timezone string.")
-
-        return self.load_name(offset)
-
-
-class tzwinbase(tzrangebase):
-    """tzinfo class based on win32's timezones available in the registry."""
-    def __init__(self):
-        raise NotImplementedError('tzwinbase is an abstract base class')
-
-    def __eq__(self, other):
-        # Compare on all relevant dimensions, including name.
-        if not isinstance(other, tzwinbase):
-            return NotImplemented
-
-        return  (self._std_offset == other._std_offset and
-                 self._dst_offset == other._dst_offset and
-                 self._stddayofweek == other._stddayofweek and
-                 self._dstdayofweek == other._dstdayofweek and
-                 self._stdweeknumber == other._stdweeknumber and
-                 self._dstweeknumber == other._dstweeknumber and
-                 self._stdhour == other._stdhour and
-                 self._dsthour == other._dsthour and
-                 self._stdminute == other._stdminute and
-                 self._dstminute == other._dstminute and
-                 self._std_abbr == other._std_abbr and
-                 self._dst_abbr == other._dst_abbr)
-
-    @staticmethod
-    def list():
-        """Return a list of all time zones known to the system."""
-        with winreg.ConnectRegistry(None, winreg.HKEY_LOCAL_MACHINE) as handle:
-            with winreg.OpenKey(handle, TZKEYNAME) as tzkey:
-                result = [winreg.EnumKey(tzkey, i)
-                          for i in range(winreg.QueryInfoKey(tzkey)[0])]
-        return result
-
-    def display(self):
-        """
-        Return the display name of the time zone.
-        """
-        return self._display
-
-    def transitions(self, year):
-        """
-        For a given year, get the DST on and off transition times, expressed
-        always on the standard time side. For zones with no transitions, this
-        function returns ``None``.
-
-        :param year:
-            The year whose transitions you would like to query.
-
-        :return:
-            Returns a :class:`tuple` of :class:`datetime.datetime` objects,
-            ``(dston, dstoff)`` for zones with an annual DST transition, or
-            ``None`` for fixed offset zones.
-        """
-
-        if not self.hasdst:
-            return None
-
-        dston = picknthweekday(year, self._dstmonth, self._dstdayofweek,
-                               self._dsthour, self._dstminute,
-                               self._dstweeknumber)
-
-        dstoff = picknthweekday(year, self._stdmonth, self._stddayofweek,
-                                self._stdhour, self._stdminute,
-                                self._stdweeknumber)
-
-        # Ambiguous dates default to the STD side
-        dstoff -= self._dst_base_offset
-
-        return dston, dstoff
-
-    def _get_hasdst(self):
-        return self._dstmonth != 0
-
-    @property
-    def _dst_base_offset(self):
-        return self._dst_base_offset_
-
-
-class tzwin(tzwinbase):
-    """
-    Time zone object created from the zone info in the Windows registry
-
-    These are similar to :py:class:`dateutil.tz.tzrange` objects in that
-    the time zone data is provided in the format of a single offset rule
-    for either 0 or 2 time zone transitions per year.
-
-    :param: name
-        The name of a Windows time zone key, e.g. "Eastern Standard Time".
-        The full list of keys can be retrieved with :func:`tzwin.list`.
-    """
-
-    def __init__(self, name):
-        self._name = name
-
-        with winreg.ConnectRegistry(None, winreg.HKEY_LOCAL_MACHINE) as handle:
-            tzkeyname = text_type("{kn}\\{name}").format(kn=TZKEYNAME, name=name)
-            with winreg.OpenKey(handle, tzkeyname) as tzkey:
-                keydict = valuestodict(tzkey)
-
-        self._std_abbr = keydict["Std"]
-        self._dst_abbr = keydict["Dlt"]
-
-        self._display = keydict["Display"]
-
-        # See http://ww_winreg.jsiinc.com/SUBA/tip0300/rh0398.htm
-        tup = struct.unpack("=3l16h", keydict["TZI"])
-        stdoffset = -tup[0]-tup[1]          # Bias + StandardBias * -1
-        dstoffset = stdoffset-tup[2]        # + DaylightBias * -1
-        self._std_offset = datetime.timedelta(minutes=stdoffset)
-        self._dst_offset = datetime.timedelta(minutes=dstoffset)
-
-        # for the meaning see the win32 TIME_ZONE_INFORMATION structure docs
-        # http://msdn.microsoft.com/en-us/library/windows/desktop/ms725481(v=vs.85).aspx
-        (self._stdmonth,
-         self._stddayofweek,   # Sunday = 0
-         self._stdweeknumber,  # Last = 5
-         self._stdhour,
-         self._stdminute) = tup[4:9]
-
-        (self._dstmonth,
-         self._dstdayofweek,   # Sunday = 0
-         self._dstweeknumber,  # Last = 5
-         self._dsthour,
-         self._dstminute) = tup[12:17]
-
-        self._dst_base_offset_ = self._dst_offset - self._std_offset
-        self.hasdst = self._get_hasdst()
-
-    def __repr__(self):
-        return "tzwin(%s)" % repr(self._name)
-
-    def __reduce__(self):
-        return (self.__class__, (self._name,))
-
-
-class tzwinlocal(tzwinbase):
-    """
-    Class representing the local time zone information in the Windows registry
-
-    While :class:`dateutil.tz.tzlocal` makes system calls (via the :mod:`time`
-    module) to retrieve time zone information, ``tzwinlocal`` retrieves the
-    rules directly from the Windows registry and creates an object like
-    :class:`dateutil.tz.tzwin`.
-
-    Because Windows does not have an equivalent of :func:`time.tzset`, on
-    Windows, :class:`dateutil.tz.tzlocal` instances will always reflect the
-    time zone settings *at the time that the process was started*, meaning
-    changes to the machine's time zone settings during the run of a program
-    on Windows will **not** be reflected by :class:`dateutil.tz.tzlocal`.
-    Because ``tzwinlocal`` reads the registry directly, it is unaffected by
-    this issue.
-    """
-    def __init__(self):
-        with winreg.ConnectRegistry(None, winreg.HKEY_LOCAL_MACHINE) as handle:
-            with winreg.OpenKey(handle, TZLOCALKEYNAME) as tzlocalkey:
-                keydict = valuestodict(tzlocalkey)
-
-            self._std_abbr = keydict["StandardName"]
-            self._dst_abbr = keydict["DaylightName"]
-
-            try:
-                tzkeyname = text_type('{kn}\\{sn}').format(kn=TZKEYNAME,
-                                                          sn=self._std_abbr)
-                with winreg.OpenKey(handle, tzkeyname) as tzkey:
-                    _keydict = valuestodict(tzkey)
-                    self._display = _keydict["Display"]
-            except OSError:
-                self._display = None
-
-        stdoffset = -keydict["Bias"]-keydict["StandardBias"]
-        dstoffset = stdoffset-keydict["DaylightBias"]
-
-        self._std_offset = datetime.timedelta(minutes=stdoffset)
-        self._dst_offset = datetime.timedelta(minutes=dstoffset)
-
-        # For reasons unclear, in this particular key, the day of week has been
-        # moved to the END of the SYSTEMTIME structure.
-        tup = struct.unpack("=8h", keydict["StandardStart"])
-
-        (self._stdmonth,
-         self._stdweeknumber,  # Last = 5
-         self._stdhour,
-         self._stdminute) = tup[1:5]
-
-        self._stddayofweek = tup[7]
-
-        tup = struct.unpack("=8h", keydict["DaylightStart"])
-
-        (self._dstmonth,
-         self._dstweeknumber,  # Last = 5
-         self._dsthour,
-         self._dstminute) = tup[1:5]
-
-        self._dstdayofweek = tup[7]
-
-        self._dst_base_offset_ = self._dst_offset - self._std_offset
-        self.hasdst = self._get_hasdst()
-
-    def __repr__(self):
-        return "tzwinlocal()"
-
-    def __str__(self):
-        # str will return the standard name, not the daylight name.
-        return "tzwinlocal(%s)" % repr(self._std_abbr)
-
-    def __reduce__(self):
-        return (self.__class__, ())
-
-
-def picknthweekday(year, month, dayofweek, hour, minute, whichweek):
-    """ dayofweek == 0 means Sunday, whichweek 5 means last instance """
-    first = datetime.datetime(year, month, 1, hour, minute)
-
-    # This will work if dayofweek is ISO weekday (1-7) or Microsoft-style (0-6),
-    # Because 7 % 7 = 0
-    weekdayone = first.replace(day=((dayofweek - first.isoweekday()) % 7) + 1)
-    wd = weekdayone + ((whichweek - 1) * ONEWEEK)
-    if (wd.month != month):
-        wd -= ONEWEEK
-
-    return wd
-
-
-def valuestodict(key):
-    """Convert a registry key's values to a dictionary."""
-    dout = {}
-    size = winreg.QueryInfoKey(key)[1]
-    tz_res = None
-
-    for i in range(size):
-        key_name, value, dtype = winreg.EnumValue(key, i)
-        if dtype == winreg.REG_DWORD or dtype == winreg.REG_DWORD_LITTLE_ENDIAN:
-            # If it's a DWORD (32-bit integer), it's stored as unsigned - convert
-            # that to a proper signed integer
-            if value & (1 << 31):
-                value = value - (1 << 32)
-        elif dtype == winreg.REG_SZ:
-            # If it's a reference to the tzres DLL, load the actual string
-            if value.startswith('@tzres'):
-                tz_res = tz_res or tzres()
-                value = tz_res.name_from_string(value)
-
-            value = value.rstrip('\x00')    # Remove trailing nulls
-
-        dout[key_name] = value
-
-    return dout

.venv/Lib/site-packages/dateutil/tzwin.py

@@ -1,2 +0,0 @@
-# tzwin has moved to dateutil.tz.win
-from .tz.win import *

.venv/Lib/site-packages/dateutil/utils.py

@@ -1,71 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-This module offers general convenience and utility functions for dealing with
-datetimes.
-
-.. versionadded:: 2.7.0
-"""
-from __future__ import unicode_literals
-
-from datetime import datetime, time
-
-
-def today(tzinfo=None):
-    """
-    Returns a :py:class:`datetime` representing the current day at midnight
-
-    :param tzinfo:
-        The time zone to attach (also used to determine the current day).
-
-    :return:
-        A :py:class:`datetime.datetime` object representing the current day
-        at midnight.
-    """
-
-    dt = datetime.now(tzinfo)
-    return datetime.combine(dt.date(), time(0, tzinfo=tzinfo))
-
-
-def default_tzinfo(dt, tzinfo):
-    """
-    Sets the ``tzinfo`` parameter on naive datetimes only
-
-    This is useful for example when you are provided a datetime that may have
-    either an implicit or explicit time zone, such as when parsing a time zone
-    string.
-
-    .. doctest::
-
-        >>> from dateutil.tz import tzoffset
-        >>> from dateutil.parser import parse
-        >>> from dateutil.utils import default_tzinfo
-        >>> dflt_tz = tzoffset("EST", -18000)
-        >>> print(default_tzinfo(parse('2014-01-01 12:30 UTC'), dflt_tz))
-        2014-01-01 12:30:00+00:00
-        >>> print(default_tzinfo(parse('2014-01-01 12:30'), dflt_tz))
-        2014-01-01 12:30:00-05:00
-
-    :param dt:
-        The datetime on which to replace the time zone
-
-    :param tzinfo:
-        The :py:class:`datetime.tzinfo` subclass instance to assign to
-        ``dt`` if (and only if) it is naive.
-
-    :return:
-        Returns an aware :py:class:`datetime.datetime`.
-    """
-    if dt.tzinfo is not None:
-        return dt
-    else:
-        return dt.replace(tzinfo=tzinfo)
-
-
-def within_delta(dt1, dt2, delta):
-    """
-    Useful for comparing two datetimes that may have a negligible difference
-    to be considered equal.
-    """
-    delta = abs(delta)
-    difference = dt1 - dt2
-    return -delta <= difference <= delta

.venv/Lib/site-packages/dateutil/zoneinfo/__init__.py

@@ -1,167 +0,0 @@
-# -*- coding: utf-8 -*-
-import warnings
-import json
-
-from tarfile import TarFile
-from pkgutil import get_data
-from io import BytesIO
-
-from dateutil.tz import tzfile as _tzfile
-
-__all__ = ["get_zonefile_instance", "gettz", "gettz_db_metadata"]
-
-ZONEFILENAME = "dateutil-zoneinfo.tar.gz"
-METADATA_FN = 'METADATA'
-
-
-class tzfile(_tzfile):
-    def __reduce__(self):
-        return (gettz, (self._filename,))
-
-
-def getzoneinfofile_stream():
-    try:
-        return BytesIO(get_data(__name__, ZONEFILENAME))
-    except IOError as e:  # TODO  switch to FileNotFoundError?
-        warnings.warn("I/O error({0}): {1}".format(e.errno, e.strerror))
-        return None
-
-
-class ZoneInfoFile(object):
-    def __init__(self, zonefile_stream=None):
-        if zonefile_stream is not None:
-            with TarFile.open(fileobj=zonefile_stream) as tf:
-                self.zones = {zf.name: tzfile(tf.extractfile(zf), filename=zf.name)
-                              for zf in tf.getmembers()
-                              if zf.isfile() and zf.name != METADATA_FN}
-                # deal with links: They'll point to their parent object. Less
-                # waste of memory
-                links = {zl.name: self.zones[zl.linkname]
-                         for zl in tf.getmembers() if
-                         zl.islnk() or zl.issym()}
-                self.zones.update(links)
-                try:
-                    metadata_json = tf.extractfile(tf.getmember(METADATA_FN))
-                    metadata_str = metadata_json.read().decode('UTF-8')
-                    self.metadata = json.loads(metadata_str)
-                except KeyError:
-                    # no metadata in tar file
-                    self.metadata = None
-        else:
-            self.zones = {}
-            self.metadata = None
-
-    def get(self, name, default=None):
-        """
-        Wrapper for :func:`ZoneInfoFile.zones.get`. This is a convenience method
-        for retrieving zones from the zone dictionary.
-
-        :param name:
-            The name of the zone to retrieve. (Generally IANA zone names)
-
-        :param default:
-            The value to return in the event of a missing key.
-
-        .. versionadded:: 2.6.0
-
-        """
-        return self.zones.get(name, default)
-
-
-# The current API has gettz as a module function, although in fact it taps into
-# a stateful class. So as a workaround for now, without changing the API, we
-# will create a new "global" class instance the first time a user requests a
-# timezone. Ugly, but adheres to the api.
-#
-# TODO: Remove after deprecation period.
-_CLASS_ZONE_INSTANCE = []
-
-
-def get_zonefile_instance(new_instance=False):
-    """
-    This is a convenience function which provides a :class:`ZoneInfoFile`
-    instance using the data provided by the ``dateutil`` package. By default, it
-    caches a single instance of the ZoneInfoFile object and returns that.
-
-    :param new_instance:
-        If ``True``, a new instance of :class:`ZoneInfoFile` is instantiated and
-        used as the cached instance for the next call. Otherwise, new instances
-        are created only as necessary.
-
-    :return:
-        Returns a :class:`ZoneInfoFile` object.
-
-    .. versionadded:: 2.6
-    """
-    if new_instance:
-        zif = None
-    else:
-        zif = getattr(get_zonefile_instance, '_cached_instance', None)
-
-    if zif is None:
-        zif = ZoneInfoFile(getzoneinfofile_stream())
-
-        get_zonefile_instance._cached_instance = zif
-
-    return zif
-
-
-def gettz(name):
-    """
-    This retrieves a time zone from the local zoneinfo tarball that is packaged
-    with dateutil.
-
-    :param name:
-        An IANA-style time zone name, as found in the zoneinfo file.
-
-    :return:
-        Returns a :class:`dateutil.tz.tzfile` time zone object.
-
-    .. warning::
-        It is generally inadvisable to use this function, and it is only
-        provided for API compatibility with earlier versions. This is *not*
-        equivalent to ``dateutil.tz.gettz()``, which selects an appropriate
-        time zone based on the inputs, favoring system zoneinfo. This is ONLY
-        for accessing the dateutil-specific zoneinfo (which may be out of
-        date compared to the system zoneinfo).
-
-    .. deprecated:: 2.6
-        If you need to use a specific zoneinfofile over the system zoneinfo,
-        instantiate a :class:`dateutil.zoneinfo.ZoneInfoFile` object and call
-        :func:`dateutil.zoneinfo.ZoneInfoFile.get(name)` instead.
-
-        Use :func:`get_zonefile_instance` to retrieve an instance of the
-        dateutil-provided zoneinfo.
-    """
-    warnings.warn("zoneinfo.gettz() will be removed in future versions, "
-                  "to use the dateutil-provided zoneinfo files, instantiate a "
-                  "ZoneInfoFile object and use ZoneInfoFile.zones.get() "
-                  "instead. See the documentation for details.",
-                  DeprecationWarning)
-
-    if len(_CLASS_ZONE_INSTANCE) == 0:
-        _CLASS_ZONE_INSTANCE.append(ZoneInfoFile(getzoneinfofile_stream()))
-    return _CLASS_ZONE_INSTANCE[0].zones.get(name)
-
-
-def gettz_db_metadata():
-    """ Get the zonefile metadata
-
-    See `zonefile_metadata`_
-
-    :returns:
-        A dictionary with the database metadata
-
-    .. deprecated:: 2.6
-        See deprecation warning in :func:`zoneinfo.gettz`. To get metadata,
-        query the attribute ``zoneinfo.ZoneInfoFile.metadata``.
-    """
-    warnings.warn("zoneinfo.gettz_db_metadata() will be removed in future "
-                  "versions, to use the dateutil-provided zoneinfo files, "
-                  "ZoneInfoFile object and query the 'metadata' attribute "
-                  "instead. See the documentation for details.",
-                  DeprecationWarning)
-
-    if len(_CLASS_ZONE_INSTANCE) == 0:
-        _CLASS_ZONE_INSTANCE.append(ZoneInfoFile(getzoneinfofile_stream()))
-    return _CLASS_ZONE_INSTANCE[0].metadata

.venv/Lib/site-packages/dateutil/zoneinfo/rebuild.py

@@ -1,75 +0,0 @@
-import logging
-import os
-import tempfile
-import shutil
-import json
-from subprocess import check_call, check_output
-from tarfile import TarFile
-
-from dateutil.zoneinfo import METADATA_FN, ZONEFILENAME
-
-
-def rebuild(filename, tag=None, format="gz", zonegroups=[], metadata=None):
-    """Rebuild the internal timezone info in dateutil/zoneinfo/zoneinfo*tar*
-
-    filename is the timezone tarball from ``ftp.iana.org/tz``.
-
-    """
-    tmpdir = tempfile.mkdtemp()
-    zonedir = os.path.join(tmpdir, "zoneinfo")
-    moduledir = os.path.dirname(__file__)
-    try:
-        with TarFile.open(filename) as tf:
-            for name in zonegroups:
-                tf.extract(name, tmpdir)
-            filepaths = [os.path.join(tmpdir, n) for n in zonegroups]
-
-            _run_zic(zonedir, filepaths)
-
-        # write metadata file
-        with open(os.path.join(zonedir, METADATA_FN), 'w') as f:
-            json.dump(metadata, f, indent=4, sort_keys=True)
-        target = os.path.join(moduledir, ZONEFILENAME)
-        with TarFile.open(target, "w:%s" % format) as tf:
-            for entry in os.listdir(zonedir):
-                entrypath = os.path.join(zonedir, entry)
-                tf.add(entrypath, entry)
-    finally:
-        shutil.rmtree(tmpdir)
-
-
-def _run_zic(zonedir, filepaths):
-    """Calls the ``zic`` compiler in a compatible way to get a "fat" binary.
-
-    Recent versions of ``zic`` default to ``-b slim``, while older versions
-    don't even have the ``-b`` option (but default to "fat" binaries). The
-    current version of dateutil does not support Version 2+ TZif files, which
-    causes problems when used in conjunction with "slim" binaries, so this
-    function is used to ensure that we always get a "fat" binary.
-    """
-
-    try:
-        help_text = check_output(["zic", "--help"])
-    except OSError as e:
-        _print_on_nosuchfile(e)
-        raise
-
-    if b"-b " in help_text:
-        bloat_args = ["-b", "fat"]
-    else:
-        bloat_args = []
-
-    check_call(["zic"] + bloat_args + ["-d", zonedir] + filepaths)
-
-
-def _print_on_nosuchfile(e):
-    """Print helpful troubleshooting message
-
-    e is an exception raised by subprocess.check_call()
-
-    """
-    if e.errno == 2:
-        logging.error(
-            "Could not find zic. Perhaps you need to install "
-            "libc-bin or some other package that provides it, "
-            "or it's not in your PATH?")

.venv/Lib/site-packages/numpy-2.3.3.dist-info/DELVEWHEEL

@@ -1,2 +0,0 @@
-Version: 1.11.1
-Arguments: ['C:\\Users\\runneradmin\\AppData\\Local\\Temp\\cibw-run-5t0hy_xh\\cp313-win_amd64\\build\\venv\\Scripts\\delvewheel', 'repair', '--add-path', 'D:/a/numpy-release/numpy-release/.openblas/lib', '-w', 'C:\\Users\\runneradmin\\AppData\\Local\\Temp\\cibw-run-5t0hy_xh\\cp313-win_amd64\\repaired_wheel', 'C:\\Users\\runneradmin\\AppData\\Local\\Temp\\cibw-run-5t0hy_xh\\cp313-win_amd64\\built_wheel\\numpy-2.3.3-cp313-cp313-win_amd64.whl']

.venv/Lib/site-packages/numpy-2.3.3.dist-info/INSTALLER

@@ -1 +0,0 @@
-pip

.venv/Lib/site-packages/numpy-2.3.3.dist-info/LICENSE.txt

@@ -1,950 +0,0 @@
-Copyright (c) 2005-2025, NumPy Developers.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
-    * Redistributions of source code must retain the above copyright
-       notice, this list of conditions and the following disclaimer.
-
-    * Redistributions in binary form must reproduce the above
-       copyright notice, this list of conditions and the following
-       disclaimer in the documentation and/or other materials provided
-       with the distribution.
-
-    * Neither the name of the NumPy Developers nor the names of any
-       contributors may be used to endorse or promote products derived
-       from this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----
-
-The NumPy repository and source distributions bundle several libraries that are
-compatibly licensed.  We list these here.
-
-Name: lapack-lite
-Files: numpy/linalg/lapack_lite/*
-License: BSD-3-Clause
-  For details, see numpy/linalg/lapack_lite/LICENSE.txt
-
-Name: dragon4
-Files: numpy/_core/src/multiarray/dragon4.c
-License: MIT
-  For license text, see numpy/_core/src/multiarray/dragon4.c
-
-Name: libdivide
-Files: numpy/_core/include/numpy/libdivide/*
-License: Zlib
-  For license text, see numpy/_core/include/numpy/libdivide/LICENSE.txt
-
-
-Note that the following files are vendored in the repository and sdist but not
-installed in built numpy packages:
-
-Name: Meson
-Files: vendored-meson/meson/*
-License: Apache 2.0
-  For license text, see vendored-meson/meson/COPYING
-
-Name: spin
-Files: .spin/cmds.py
-License: BSD-3
-  For license text, see .spin/LICENSE
-
-Name: tempita
-Files: numpy/_build_utils/tempita/*
-License: MIT
-  For details, see numpy/_build_utils/tempita/LICENCE.txt
-
-----
-
-This binary distribution of NumPy also bundles the following software:
-
-
-Name: OpenBLAS
-Files: numpy.libs\libscipy_openblas*.dll
-Description: bundled as a dynamically linked library
-Availability: https://github.com/OpenMathLib/OpenBLAS/
-License: BSD-3-Clause
-  Copyright (c) 2011-2014, The OpenBLAS Project
-  All rights reserved.
-
-  Redistribution and use in source and binary forms, with or without
-  modification, are permitted provided that the following conditions are
-  met:
-
-     1. Redistributions of source code must retain the above copyright
-        notice, this list of conditions and the following disclaimer.
-
-     2. Redistributions in binary form must reproduce the above copyright
-        notice, this list of conditions and the following disclaimer in
-        the documentation and/or other materials provided with the
-        distribution.
-     3. Neither the name of the OpenBLAS project nor the names of
-        its contributors may be used to endorse or promote products
-        derived from this software without specific prior written
-        permission.
-
-  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
-  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-  DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-  SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-  OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
-  USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-
-Name: LAPACK
-Files: numpy.libs\libscipy_openblas*.dll
-Description: bundled in OpenBLAS
-Availability: https://github.com/OpenMathLib/OpenBLAS/
-License: BSD-3-Clause-Open-MPI
-  Copyright (c) 1992-2013 The University of Tennessee and The University
-                          of Tennessee Research Foundation.  All rights
-                          reserved.
-  Copyright (c) 2000-2013 The University of California Berkeley. All
-                          rights reserved.
-  Copyright (c) 2006-2013 The University of Colorado Denver.  All rights
-                          reserved.
-
-  $COPYRIGHT$
-
-  Additional copyrights may follow
-
-  $HEADER$
-
-  Redistribution and use in source and binary forms, with or without
-  modification, are permitted provided that the following conditions are
-  met:
-
-  - Redistributions of source code must retain the above copyright
-    notice, this list of conditions and the following disclaimer.
-
-  - Redistributions in binary form must reproduce the above copyright
-    notice, this list of conditions and the following disclaimer listed
-    in this license in the documentation and/or other materials
-    provided with the distribution.
-
-  - Neither the name of the copyright holders nor the names of its
-    contributors may be used to endorse or promote products derived from
-    this software without specific prior written permission.
-
-  The copyright holders provide no reassurances that the source code
-  provided does not infringe any patent, copyright, or any other
-  intellectual property rights of third parties.  The copyright holders
-  disclaim any liability to any recipient for claims brought against
-  recipient by any third party for infringement of that parties
-  intellectual property rights.
-
-  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-
-Name: GCC runtime library
-Files: numpy.libs\libscipy_openblas*.dll
-Description: statically linked to files compiled with gcc
-Availability: https://gcc.gnu.org/git/?p=gcc.git;a=tree;f=libgfortran
-License: GPL-3.0-or-later WITH GCC-exception-3.1
-  Copyright (C) 2002-2017 Free Software Foundation, Inc.
-
-  Libgfortran is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 3, or (at your option)
-  any later version.
-
-  Libgfortran is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  Under Section 7 of GPL version 3, you are granted additional
-  permissions described in the GCC Runtime Library Exception, version
-  3.1, as published by the Free Software Foundation.
-
-  You should have received a copy of the GNU General Public License and
-  a copy of the GCC Runtime Library Exception along with this program;
-  see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
-  <http://www.gnu.org/licenses/>.
-
-----
-
-Full text of license texts referred to above follows (that they are
-listed below does not necessarily imply the conditions apply to the
-present binary release):
-
-----
-
-GCC RUNTIME LIBRARY EXCEPTION
-
-Version 3.1, 31 March 2009
-
-Copyright (C) 2009 Free Software Foundation, Inc. <https://fsf.org/>
-
-Everyone is permitted to copy and distribute verbatim copies of this
-license document, but changing it is not allowed.
-
-This GCC Runtime Library Exception ("Exception") is an additional
-permission under section 7 of the GNU General Public License, version
-3 ("GPLv3"). It applies to a given file (the "Runtime Library") that
-bears a notice placed by the copyright holder of the file stating that
-the file is governed by GPLv3 along with this Exception.
-
-When you use GCC to compile a program, GCC may combine portions of
-certain GCC header files and runtime libraries with the compiled
-program. The purpose of this Exception is to allow compilation of
-non-GPL (including proprietary) programs to use, in this way, the
-header files and runtime libraries covered by this Exception.
-
-0. Definitions.
-
-A file is an "Independent Module" if it either requires the Runtime
-Library for execution after a Compilation Process, or makes use of an
-interface provided by the Runtime Library, but is not otherwise based
-on the Runtime Library.
-
-"GCC" means a version of the GNU Compiler Collection, with or without
-modifications, governed by version 3 (or a specified later version) of
-the GNU General Public License (GPL) with the option of using any
-subsequent versions published by the FSF.
-
-"GPL-compatible Software" is software whose conditions of propagation,
-modification and use would permit combination with GCC in accord with
-the license of GCC.
-
-"Target Code" refers to output from any compiler for a real or virtual
-target processor architecture, in executable form or suitable for
-input to an assembler, loader, linker and/or execution
-phase. Notwithstanding that, Target Code does not include data in any
-format that is used as a compiler intermediate representation, or used
-for producing a compiler intermediate representation.
-
-The "Compilation Process" transforms code entirely represented in
-non-intermediate languages designed for human-written code, and/or in
-Java Virtual Machine byte code, into Target Code. Thus, for example,
-use of source code generators and preprocessors need not be considered
-part of the Compilation Process, since the Compilation Process can be
-understood as starting with the output of the generators or
-preprocessors.
-
-A Compilation Process is "Eligible" if it is done using GCC, alone or
-with other GPL-compatible software, or if it is done without using any
-work based on GCC. For example, using non-GPL-compatible Software to
-optimize any GCC intermediate representations would not qualify as an
-Eligible Compilation Process.
-
-1. Grant of Additional Permission.
-
-You have permission to propagate a work of Target Code formed by
-combining the Runtime Library with Independent Modules, even if such
-propagation would otherwise violate the terms of GPLv3, provided that
-all Target Code was generated by Eligible Compilation Processes. You
-may then convey such a combination under terms of your choice,
-consistent with the licensing of the Independent Modules.
-
-2. No Weakening of GCC Copyleft.
-
-The availability of this Exception does not imply any general
-presumption that third-party software is unaffected by the copyleft
-requirements of the license of GCC.
-
-----
-
-                    GNU GENERAL PUBLIC LICENSE
-                       Version 3, 29 June 2007
-
- Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-                            Preamble
-
-  The GNU General Public License is a free, copyleft license for
-software and other kinds of works.
-
-  The licenses for most software and other practical works are designed
-to take away your freedom to share and change the works.  By contrast,
-the GNU General Public License is intended to guarantee your freedom to
-share and change all versions of a program--to make sure it remains free
-software for all its users.  We, the Free Software Foundation, use the
-GNU General Public License for most of our software; it applies also to
-any other work released this way by its authors.  You can apply it to
-your programs, too.
-
-  When we speak of free software, we are referring to freedom, not
-price.  Our General Public Licenses are designed to make sure that you
-have the freedom to distribute copies of free software (and charge for
-them if you wish), that you receive source code or can get it if you
-want it, that you can change the software or use pieces of it in new
-free programs, and that you know you can do these things.
-
-  To protect your rights, we need to prevent others from denying you
-these rights or asking you to surrender the rights.  Therefore, you have
-certain responsibilities if you distribute copies of the software, or if
-you modify it: responsibilities to respect the freedom of others.
-
-  For example, if you distribute copies of such a program, whether
-gratis or for a fee, you must pass on to the recipients the same
-freedoms that you received.  You must make sure that they, too, receive
-or can get the source code.  And you must show them these terms so they
-know their rights.
-
-  Developers that use the GNU GPL protect your rights with two steps:
-(1) assert copyright on the software, and (2) offer you this License
-giving you legal permission to copy, distribute and/or modify it.
-
-  For the developers' and authors' protection, the GPL clearly explains
-that there is no warranty for this free software.  For both users' and
-authors' sake, the GPL requires that modified versions be marked as
-changed, so that their problems will not be attributed erroneously to
-authors of previous versions.
-
-  Some devices are designed to deny users access to install or run
-modified versions of the software inside them, although the manufacturer
-can do so.  This is fundamentally incompatible with the aim of
-protecting users' freedom to change the software.  The systematic
-pattern of such abuse occurs in the area of products for individuals to
-use, which is precisely where it is most unacceptable.  Therefore, we
-have designed this version of the GPL to prohibit the practice for those
-products.  If such problems arise substantially in other domains, we
-stand ready to extend this provision to those domains in future versions
-of the GPL, as needed to protect the freedom of users.
-
-  Finally, every program is threatened constantly by software patents.
-States should not allow patents to restrict development and use of
-software on general-purpose computers, but in those that do, we wish to
-avoid the special danger that patents applied to a free program could
-make it effectively proprietary.  To prevent this, the GPL assures that
-patents cannot be used to render the program non-free.
-
-  The precise terms and conditions for copying, distribution and
-modification follow.
-
-                       TERMS AND CONDITIONS
-
-  0. Definitions.
-
-  "This License" refers to version 3 of the GNU General Public License.
-
-  "Copyright" also means copyright-like laws that apply to other kinds of
-works, such as semiconductor masks.
-
-  "The Program" refers to any copyrightable work licensed under this
-License.  Each licensee is addressed as "you".  "Licensees" and
-"recipients" may be individuals or organizations.
-
-  To "modify" a work means to copy from or adapt all or part of the work
-in a fashion requiring copyright permission, other than the making of an
-exact copy.  The resulting work is called a "modified version" of the
-earlier work or a work "based on" the earlier work.
-
-  A "covered work" means either the unmodified Program or a work based
-on the Program.
-
-  To "propagate" a work means to do anything with it that, without
-permission, would make you directly or secondarily liable for
-infringement under applicable copyright law, except executing it on a
-computer or modifying a private copy.  Propagation includes copying,
-distribution (with or without modification), making available to the
-public, and in some countries other activities as well.
-
-  To "convey" a work means any kind of propagation that enables other
-parties to make or receive copies.  Mere interaction with a user through
-a computer network, with no transfer of a copy, is not conveying.
-
-  An interactive user interface displays "Appropriate Legal Notices"
-to the extent that it includes a convenient and prominently visible
-feature that (1) displays an appropriate copyright notice, and (2)
-tells the user that there is no warranty for the work (except to the
-extent that warranties are provided), that licensees may convey the
-work under this License, and how to view a copy of this License.  If
-the interface presents a list of user commands or options, such as a
-menu, a prominent item in the list meets this criterion.
-
-  1. Source Code.
-
-  The "source code" for a work means the preferred form of the work
-for making modifications to it.  "Object code" means any non-source
-form of a work.
-
-  A "Standard Interface" means an interface that either is an official
-standard defined by a recognized standards body, or, in the case of
-interfaces specified for a particular programming language, one that
-is widely used among developers working in that language.
-
-  The "System Libraries" of an executable work include anything, other
-than the work as a whole, that (a) is included in the normal form of
-packaging a Major Component, but which is not part of that Major
-Component, and (b) serves only to enable use of the work with that
-Major Component, or to implement a Standard Interface for which an
-implementation is available to the public in source code form.  A
-"Major Component", in this context, means a major essential component
-(kernel, window system, and so on) of the specific operating system
-(if any) on which the executable work runs, or a compiler used to
-produce the work, or an object code interpreter used to run it.
-
-  The "Corresponding Source" for a work in object code form means all
-the source code needed to generate, install, and (for an executable
-work) run the object code and to modify the work, including scripts to
-control those activities.  However, it does not include the work's
-System Libraries, or general-purpose tools or generally available free
-programs which are used unmodified in performing those activities but
-which are not part of the work.  For example, Corresponding Source
-includes interface definition files associated with source files for
-the work, and the source code for shared libraries and dynamically
-linked subprograms that the work is specifically designed to require,
-such as by intimate data communication or control flow between those
-subprograms and other parts of the work.
-
-  The Corresponding Source need not include anything that users
-can regenerate automatically from other parts of the Corresponding
-Source.
-
-  The Corresponding Source for a work in source code form is that
-same work.
-
-  2. Basic Permissions.
-
-  All rights granted under this License are granted for the term of
-copyright on the Program, and are irrevocable provided the stated
-conditions are met.  This License explicitly affirms your unlimited
-permission to run the unmodified Program.  The output from running a
-covered work is covered by this License only if the output, given its
-content, constitutes a covered work.  This License acknowledges your
-rights of fair use or other equivalent, as provided by copyright law.
-
-  You may make, run and propagate covered works that you do not
-convey, without conditions so long as your license otherwise remains
-in force.  You may convey covered works to others for the sole purpose
-of having them make modifications exclusively for you, or provide you
-with facilities for running those works, provided that you comply with
-the terms of this License in conveying all material for which you do
-not control copyright.  Those thus making or running the covered works
-for you must do so exclusively on your behalf, under your direction
-and control, on terms that prohibit them from making any copies of
-your copyrighted material outside their relationship with you.
-
-  Conveying under any other circumstances is permitted solely under
-the conditions stated below.  Sublicensing is not allowed; section 10
-makes it unnecessary.
-
-  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
-
-  No covered work shall be deemed part of an effective technological
-measure under any applicable law fulfilling obligations under article
-11 of the WIPO copyright treaty adopted on 20 December 1996, or
-similar laws prohibiting or restricting circumvention of such
-measures.
-
-  When you convey a covered work, you waive any legal power to forbid
-circumvention of technological measures to the extent such circumvention
-is effected by exercising rights under this License with respect to
-the covered work, and you disclaim any intention to limit operation or
-modification of the work as a means of enforcing, against the work's
-users, your or third parties' legal rights to forbid circumvention of
-technological measures.
-
-  4. Conveying Verbatim Copies.
-
-  You may convey verbatim copies of the Program's source code as you
-receive it, in any medium, provided that you conspicuously and
-appropriately publish on each copy an appropriate copyright notice;
-keep intact all notices stating that this License and any
-non-permissive terms added in accord with section 7 apply to the code;
-keep intact all notices of the absence of any warranty; and give all
-recipients a copy of this License along with the Program.
-
-  You may charge any price or no price for each copy that you convey,
-and you may offer support or warranty protection for a fee.
-
-  5. Conveying Modified Source Versions.
-
-  You may convey a work based on the Program, or the modifications to
-produce it from the Program, in the form of source code under the
-terms of section 4, provided that you also meet all of these conditions:
-
-    a) The work must carry prominent notices stating that you modified
-    it, and giving a relevant date.
-
-    b) The work must carry prominent notices stating that it is
-    released under this License and any conditions added under section
-    7.  This requirement modifies the requirement in section 4 to
-    "keep intact all notices".
-
-    c) You must license the entire work, as a whole, under this
-    License to anyone who comes into possession of a copy.  This
-    License will therefore apply, along with any applicable section 7
-    additional terms, to the whole of the work, and all its parts,
-    regardless of how they are packaged.  This License gives no
-    permission to license the work in any other way, but it does not
-    invalidate such permission if you have separately received it.
-
-    d) If the work has interactive user interfaces, each must display
-    Appropriate Legal Notices; however, if the Program has interactive
-    interfaces that do not display Appropriate Legal Notices, your
-    work need not make them do so.
-
-  A compilation of a covered work with other separate and independent
-works, which are not by their nature extensions of the covered work,
-and which are not combined with it such as to form a larger program,
-in or on a volume of a storage or distribution medium, is called an
-"aggregate" if the compilation and its resulting copyright are not
-used to limit the access or legal rights of the compilation's users
-beyond what the individual works permit.  Inclusion of a covered work
-in an aggregate does not cause this License to apply to the other
-parts of the aggregate.
-
-  6. Conveying Non-Source Forms.
-
-  You may convey a covered work in object code form under the terms
-of sections 4 and 5, provided that you also convey the
-machine-readable Corresponding Source under the terms of this License,
-in one of these ways:
-
-    a) Convey the object code in, or embodied in, a physical product
-    (including a physical distribution medium), accompanied by the
-    Corresponding Source fixed on a durable physical medium
-    customarily used for software interchange.
-
-    b) Convey the object code in, or embodied in, a physical product
-    (including a physical distribution medium), accompanied by a
-    written offer, valid for at least three years and valid for as
-    long as you offer spare parts or customer support for that product
-    model, to give anyone who possesses the object code either (1) a
-    copy of the Corresponding Source for all the software in the
-    product that is covered by this License, on a durable physical
-    medium customarily used for software interchange, for a price no
-    more than your reasonable cost of physically performing this
-    conveying of source, or (2) access to copy the
-    Corresponding Source from a network server at no charge.
-
-    c) Convey individual copies of the object code with a copy of the
-    written offer to provide the Corresponding Source.  This
-    alternative is allowed only occasionally and noncommercially, and
-    only if you received the object code with such an offer, in accord
-    with subsection 6b.
-
-    d) Convey the object code by offering access from a designated
-    place (gratis or for a charge), and offer equivalent access to the
-    Corresponding Source in the same way through the same place at no
-    further charge.  You need not require recipients to copy the
-    Corresponding Source along with the object code.  If the place to
-    copy the object code is a network server, the Corresponding Source
-    may be on a different server (operated by you or a third party)
-    that supports equivalent copying facilities, provided you maintain
-    clear directions next to the object code saying where to find the
-    Corresponding Source.  Regardless of what server hosts the
-    Corresponding Source, you remain obligated to ensure that it is
-    available for as long as needed to satisfy these requirements.
-
-    e) Convey the object code using peer-to-peer transmission, provided
-    you inform other peers where the object code and Corresponding
-    Source of the work are being offered to the general public at no
-    charge under subsection 6d.
-
-  A separable portion of the object code, whose source code is excluded
-from the Corresponding Source as a System Library, need not be
-included in conveying the object code work.
-
-  A "User Product" is either (1) a "consumer product", which means any
-tangible personal property which is normally used for personal, family,
-or household purposes, or (2) anything designed or sold for incorporation
-into a dwelling.  In determining whether a product is a consumer product,
-doubtful cases shall be resolved in favor of coverage.  For a particular
-product received by a particular user, "normally used" refers to a
-typical or common use of that class of product, regardless of the status
-of the particular user or of the way in which the particular user
-actually uses, or expects or is expected to use, the product.  A product
-is a consumer product regardless of whether the product has substantial
-commercial, industrial or non-consumer uses, unless such uses represent
-the only significant mode of use of the product.
-
-  "Installation Information" for a User Product means any methods,
-procedures, authorization keys, or other information required to install
-and execute modified versions of a covered work in that User Product from
-a modified version of its Corresponding Source.  The information must
-suffice to ensure that the continued functioning of the modified object
-code is in no case prevented or interfered with solely because
-modification has been made.
-
-  If you convey an object code work under this section in, or with, or
-specifically for use in, a User Product, and the conveying occurs as
-part of a transaction in which the right of possession and use of the
-User Product is transferred to the recipient in perpetuity or for a
-fixed term (regardless of how the transaction is characterized), the
-Corresponding Source conveyed under this section must be accompanied
-by the Installation Information.  But this requirement does not apply
-if neither you nor any third party retains the ability to install
-modified object code on the User Product (for example, the work has
-been installed in ROM).
-
-  The requirement to provide Installation Information does not include a
-requirement to continue to provide support service, warranty, or updates
-for a work that has been modified or installed by the recipient, or for
-the User Product in which it has been modified or installed.  Access to a
-network may be denied when the modification itself materially and
-adversely affects the operation of the network or violates the rules and
-protocols for communication across the network.
-
-  Corresponding Source conveyed, and Installation Information provided,
-in accord with this section must be in a format that is publicly
-documented (and with an implementation available to the public in
-source code form), and must require no special password or key for
-unpacking, reading or copying.
-
-  7. Additional Terms.
-
-  "Additional permissions" are terms that supplement the terms of this
-License by making exceptions from one or more of its conditions.
-Additional permissions that are applicable to the entire Program shall
-be treated as though they were included in this License, to the extent
-that they are valid under applicable law.  If additional permissions
-apply only to part of the Program, that part may be used separately
-under those permissions, but the entire Program remains governed by
-this License without regard to the additional permissions.
-
-  When you convey a copy of a covered work, you may at your option
-remove any additional permissions from that copy, or from any part of
-it.  (Additional permissions may be written to require their own
-removal in certain cases when you modify the work.)  You may place
-additional permissions on material, added by you to a covered work,
-for which you have or can give appropriate copyright permission.
-
-  Notwithstanding any other provision of this License, for material you
-add to a covered work, you may (if authorized by the copyright holders of
-that material) supplement the terms of this License with terms:
-
-    a) Disclaiming warranty or limiting liability differently from the
-    terms of sections 15 and 16 of this License; or
-
-    b) Requiring preservation of specified reasonable legal notices or
-    author attributions in that material or in the Appropriate Legal
-    Notices displayed by works containing it; or
-
-    c) Prohibiting misrepresentation of the origin of that material, or
-    requiring that modified versions of such material be marked in
-    reasonable ways as different from the original version; or
-
-    d) Limiting the use for publicity purposes of names of licensors or
-    authors of the material; or
-
-    e) Declining to grant rights under trademark law for use of some
-    trade names, trademarks, or service marks; or
-
-    f) Requiring indemnification of licensors and authors of that
-    material by anyone who conveys the material (or modified versions of
-    it) with contractual assumptions of liability to the recipient, for
-    any liability that these contractual assumptions directly impose on
-    those licensors and authors.
-
-  All other non-permissive additional terms are considered "further
-restrictions" within the meaning of section 10.  If the Program as you
-received it, or any part of it, contains a notice stating that it is
-governed by this License along with a term that is a further
-restriction, you may remove that term.  If a license document contains
-a further restriction but permits relicensing or conveying under this
-License, you may add to a covered work material governed by the terms
-of that license document, provided that the further restriction does
-not survive such relicensing or conveying.
-
-  If you add terms to a covered work in accord with this section, you
-must place, in the relevant source files, a statement of the
-additional terms that apply to those files, or a notice indicating
-where to find the applicable terms.
-
-  Additional terms, permissive or non-permissive, may be stated in the
-form of a separately written license, or stated as exceptions;
-the above requirements apply either way.
-
-  8. Termination.
-
-  You may not propagate or modify a covered work except as expressly
-provided under this License.  Any attempt otherwise to propagate or
-modify it is void, and will automatically terminate your rights under
-this License (including any patent licenses granted under the third
-paragraph of section 11).
-
-  However, if you cease all violation of this License, then your
-license from a particular copyright holder is reinstated (a)
-provisionally, unless and until the copyright holder explicitly and
-finally terminates your license, and (b) permanently, if the copyright
-holder fails to notify you of the violation by some reasonable means
-prior to 60 days after the cessation.
-
-  Moreover, your license from a particular copyright holder is
-reinstated permanently if the copyright holder notifies you of the
-violation by some reasonable means, this is the first time you have
-received notice of violation of this License (for any work) from that
-copyright holder, and you cure the violation prior to 30 days after
-your receipt of the notice.
-
-  Termination of your rights under this section does not terminate the
-licenses of parties who have received copies or rights from you under
-this License.  If your rights have been terminated and not permanently
-reinstated, you do not qualify to receive new licenses for the same
-material under section 10.
-
-  9. Acceptance Not Required for Having Copies.
-
-  You are not required to accept this License in order to receive or
-run a copy of the Program.  Ancillary propagation of a covered work
-occurring solely as a consequence of using peer-to-peer transmission
-to receive a copy likewise does not require acceptance.  However,
-nothing other than this License grants you permission to propagate or
-modify any covered work.  These actions infringe copyright if you do
-not accept this License.  Therefore, by modifying or propagating a
-covered work, you indicate your acceptance of this License to do so.
-
-  10. Automatic Licensing of Downstream Recipients.
-
-  Each time you convey a covered work, the recipient automatically
-receives a license from the original licensors, to run, modify and
-propagate that work, subject to this License.  You are not responsible
-for enforcing compliance by third parties with this License.
-
-  An "entity transaction" is a transaction transferring control of an
-organization, or substantially all assets of one, or subdividing an
-organization, or merging organizations.  If propagation of a covered
-work results from an entity transaction, each party to that
-transaction who receives a copy of the work also receives whatever
-licenses to the work the party's predecessor in interest had or could
-give under the previous paragraph, plus a right to possession of the
-Corresponding Source of the work from the predecessor in interest, if
-the predecessor has it or can get it with reasonable efforts.
-
-  You may not impose any further restrictions on the exercise of the
-rights granted or affirmed under this License.  For example, you may
-not impose a license fee, royalty, or other charge for exercise of
-rights granted under this License, and you may not initiate litigation
-(including a cross-claim or counterclaim in a lawsuit) alleging that
-any patent claim is infringed by making, using, selling, offering for
-sale, or importing the Program or any portion of it.
-
-  11. Patents.
-
-  A "contributor" is a copyright holder who authorizes use under this
-License of the Program or a work on which the Program is based.  The
-work thus licensed is called the contributor's "contributor version".
-
-  A contributor's "essential patent claims" are all patent claims
-owned or controlled by the contributor, whether already acquired or
-hereafter acquired, that would be infringed by some manner, permitted
-by this License, of making, using, or selling its contributor version,
-but do not include claims that would be infringed only as a
-consequence of further modification of the contributor version.  For
-purposes of this definition, "control" includes the right to grant
-patent sublicenses in a manner consistent with the requirements of
-this License.
-
-  Each contributor grants you a non-exclusive, worldwide, royalty-free
-patent license under the contributor's essential patent claims, to
-make, use, sell, offer for sale, import and otherwise run, modify and
-propagate the contents of its contributor version.
-
-  In the following three paragraphs, a "patent license" is any express
-agreement or commitment, however denominated, not to enforce a patent
-(such as an express permission to practice a patent or covenant not to
-sue for patent infringement).  To "grant" such a patent license to a
-party means to make such an agreement or commitment not to enforce a
-patent against the party.
-
-  If you convey a covered work, knowingly relying on a patent license,
-and the Corresponding Source of the work is not available for anyone
-to copy, free of charge and under the terms of this License, through a
-publicly available network server or other readily accessible means,
-then you must either (1) cause the Corresponding Source to be so
-available, or (2) arrange to deprive yourself of the benefit of the
-patent license for this particular work, or (3) arrange, in a manner
-consistent with the requirements of this License, to extend the patent
-license to downstream recipients.  "Knowingly relying" means you have
-actual knowledge that, but for the patent license, your conveying the
-covered work in a country, or your recipient's use of the covered work
-in a country, would infringe one or more identifiable patents in that
-country that you have reason to believe are valid.
-
-  If, pursuant to or in connection with a single transaction or
-arrangement, you convey, or propagate by procuring conveyance of, a
-covered work, and grant a patent license to some of the parties
-receiving the covered work authorizing them to use, propagate, modify
-or convey a specific copy of the covered work, then the patent license
-you grant is automatically extended to all recipients of the covered
-work and works based on it.
-
-  A patent license is "discriminatory" if it does not include within
-the scope of its coverage, prohibits the exercise of, or is
-conditioned on the non-exercise of one or more of the rights that are
-specifically granted under this License.  You may not convey a covered
-work if you are a party to an arrangement with a third party that is
-in the business of distributing software, under which you make payment
-to the third party based on the extent of your activity of conveying
-the work, and under which the third party grants, to any of the
-parties who would receive the covered work from you, a discriminatory
-patent license (a) in connection with copies of the covered work
-conveyed by you (or copies made from those copies), or (b) primarily
-for and in connection with specific products or compilations that
-contain the covered work, unless you entered into that arrangement,
-or that patent license was granted, prior to 28 March 2007.
-
-  Nothing in this License shall be construed as excluding or limiting
-any implied license or other defenses to infringement that may
-otherwise be available to you under applicable patent law.
-
-  12. No Surrender of Others' Freedom.
-
-  If conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License.  If you cannot convey a
-covered work so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you may
-not convey it at all.  For example, if you agree to terms that obligate you
-to collect a royalty for further conveying from those to whom you convey
-the Program, the only way you could satisfy both those terms and this
-License would be to refrain entirely from conveying the Program.
-
-  13. Use with the GNU Affero General Public License.
-
-  Notwithstanding any other provision of this License, you have
-permission to link or combine any covered work with a work licensed
-under version 3 of the GNU Affero General Public License into a single
-combined work, and to convey the resulting work.  The terms of this
-License will continue to apply to the part which is the covered work,
-but the special requirements of the GNU Affero General Public License,
-section 13, concerning interaction through a network will apply to the
-combination as such.
-
-  14. Revised Versions of this License.
-
-  The Free Software Foundation may publish revised and/or new versions of
-the GNU General Public License from time to time.  Such new versions will
-be similar in spirit to the present version, but may differ in detail to
-address new problems or concerns.
-
-  Each version is given a distinguishing version number.  If the
-Program specifies that a certain numbered version of the GNU General
-Public License "or any later version" applies to it, you have the
-option of following the terms and conditions either of that numbered
-version or of any later version published by the Free Software
-Foundation.  If the Program does not specify a version number of the
-GNU General Public License, you may choose any version ever published
-by the Free Software Foundation.
-
-  If the Program specifies that a proxy can decide which future
-versions of the GNU General Public License can be used, that proxy's
-public statement of acceptance of a version permanently authorizes you
-to choose that version for the Program.
-
-  Later license versions may give you additional or different
-permissions.  However, no additional obligations are imposed on any
-author or copyright holder as a result of your choosing to follow a
-later version.
-
-  15. Disclaimer of Warranty.
-
-  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
-APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
-HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
-OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
-THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
-IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
-ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
-
-  16. Limitation of Liability.
-
-  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
-WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
-THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
-GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
-USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
-DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
-PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
-EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
-SUCH DAMAGES.
-
-  17. Interpretation of Sections 15 and 16.
-
-  If the disclaimer of warranty and limitation of liability provided
-above cannot be given local legal effect according to their terms,
-reviewing courts shall apply local law that most closely approximates
-an absolute waiver of all civil liability in connection with the
-Program, unless a warranty or assumption of liability accompanies a
-copy of the Program in return for a fee.
-
-                     END OF TERMS AND CONDITIONS
-
-            How to Apply These Terms to Your New Programs
-
-  If you develop a new program, and you want it to be of the greatest
-possible use to the public, the best way to achieve this is to make it
-free software which everyone can redistribute and change under these terms.
-
-  To do so, attach the following notices to the program.  It is safest
-to attach them to the start of each source file to most effectively
-state the exclusion of warranty; and each file should have at least
-the "copyright" line and a pointer to where the full notice is found.
-
-    <one line to give the program's name and a brief idea of what it does.>
-    Copyright (C) <year>  <name of author>
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-Also add information on how to contact you by electronic and paper mail.
-
-  If the program does terminal interaction, make it output a short
-notice like this when it starts in an interactive mode:
-
-    <program>  Copyright (C) <year>  <name of author>
-    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
-    This is free software, and you are welcome to redistribute it
-    under certain conditions; type `show c' for details.
-
-The hypothetical commands `show w' and `show c' should show the appropriate
-parts of the General Public License.  Of course, your program's commands
-might be different; for a GUI interface, you would use an "about box".
-
-  You should also get your employer (if you work as a programmer) or school,
-if any, to sign a "copyright disclaimer" for the program, if necessary.
-For more information on this, and how to apply and follow the GNU GPL, see
-<https://www.gnu.org/licenses/>.
-
-  The GNU General Public License does not permit incorporating your program
-into proprietary programs.  If your program is a subroutine library, you
-may consider it more useful to permit linking proprietary applications with
-the library.  If this is what you want to do, use the GNU Lesser General
-Public License instead of this License.  But first, please read
-<https://www.gnu.org/licenses/why-not-lgpl.html>.
-

.venv/Lib/site-packages/numpy-2.3.3.dist-info/WHEEL

@@ -1,4 +0,0 @@
-Wheel-Version: 1.0
-Generator: meson
-Root-Is-Purelib: false
-Tag: cp313-cp313-win_amd64

.venv/Lib/site-packages/numpy-2.3.3.dist-info/entry_points.txt

@@ -1,13 +0,0 @@
-[pkg_config]
-numpy = numpy._core.lib.pkgconfig
-
-[array_api]
-numpy = numpy
-
-[pyinstaller40]
-hook-dirs = numpy:_pyinstaller_hooks_dir
-
-[console_scripts]
-f2py = numpy.f2py.f2py2e:main
-numpy-config = numpy._configtool:main
-

.venv/Lib/site-packages/numpy/__config__.py

@@ -1,170 +0,0 @@
-# This file is generated by numpy's build process
-# It contains system_info results at the time of building this package.
-from enum import Enum
-from numpy._core._multiarray_umath import (
-    __cpu_features__,
-    __cpu_baseline__,
-    __cpu_dispatch__,
-)
-
-__all__ = ["show_config"]
-_built_with_meson = True
-
-
-class DisplayModes(Enum):
-    stdout = "stdout"
-    dicts = "dicts"
-
-
-def _cleanup(d):
-    """
-    Removes empty values in a `dict` recursively
-    This ensures we remove values that Meson could not provide to CONFIG
-    """
-    if isinstance(d, dict):
-        return {k: _cleanup(v) for k, v in d.items() if v and _cleanup(v)}
-    else:
-        return d
-
-
-CONFIG = _cleanup(
-    {
-        "Compilers": {
-            "c": {
-                "name": "msvc",
-                "linker": r"link",
-                "version": "19.44.35215",
-                "commands": r"cl",
-                "args": r"",
-                "linker args": r"",
-            },
-            "cython": {
-                "name": "cython",
-                "linker": r"cython",
-                "version": "3.1.3",
-                "commands": r"cython",
-                "args": r"",
-                "linker args": r"",
-            },
-            "c++": {
-                "name": "msvc",
-                "linker": r"link",
-                "version": "19.44.35215",
-                "commands": r"cl",
-                "args": r"",
-                "linker args": r"",
-            },
-        },
-        "Machine Information": {
-            "host": {
-                "cpu": "x86_64",
-                "family": "x86_64",
-                "endian": "little",
-                "system": "windows",
-            },
-            "build": {
-                "cpu": "x86_64",
-                "family": "x86_64",
-                "endian": "little",
-                "system": "windows",
-            },
-            "cross-compiled": bool("False".lower().replace("false", "")),
-        },
-        "Build Dependencies": {
-            "blas": {
-                "name": "scipy-openblas",
-                "found": bool("True".lower().replace("false", "")),
-                "version": "0.3.30",
-                "detection method": "pkgconfig",
-                "include directory": r"C:/Users/runneradmin/AppData/Local/Temp/cibw-run-5t0hy_xh/cp313-win_amd64/build/venv/Lib/site-packages/scipy_openblas64/include",
-                "lib directory": r"C:/Users/runneradmin/AppData/Local/Temp/cibw-run-5t0hy_xh/cp313-win_amd64/build/venv/Lib/site-packages/scipy_openblas64/lib",
-                "openblas configuration": r"OpenBLAS 0.3.30  USE64BITINT DYNAMIC_ARCH NO_AFFINITY Haswell MAX_THREADS=24",
-                "pc file directory": r"D:/a/numpy-release/numpy-release/.openblas",
-            },
-            "lapack": {
-                "name": "scipy-openblas",
-                "found": bool("True".lower().replace("false", "")),
-                "version": "0.3.30",
-                "detection method": "pkgconfig",
-                "include directory": r"C:/Users/runneradmin/AppData/Local/Temp/cibw-run-5t0hy_xh/cp313-win_amd64/build/venv/Lib/site-packages/scipy_openblas64/include",
-                "lib directory": r"C:/Users/runneradmin/AppData/Local/Temp/cibw-run-5t0hy_xh/cp313-win_amd64/build/venv/Lib/site-packages/scipy_openblas64/lib",
-                "openblas configuration": r"OpenBLAS 0.3.30  USE64BITINT DYNAMIC_ARCH NO_AFFINITY Haswell MAX_THREADS=24",
-                "pc file directory": r"D:/a/numpy-release/numpy-release/.openblas",
-            },
-        },
-        "Python Information": {
-            "path": r"C:\Users\runneradmin\AppData\Local\Temp\build-env-q3zde7n4\Scripts\python.exe",
-            "version": "3.13",
-        },
-        "SIMD Extensions": {
-            "baseline": __cpu_baseline__,
-            "found": [
-                feature for feature in __cpu_dispatch__ if __cpu_features__[feature]
-            ],
-            "not found": [
-                feature for feature in __cpu_dispatch__ if not __cpu_features__[feature]
-            ],
-        },
-    }
-)
-
-
-def _check_pyyaml():
-    import yaml
-
-    return yaml
-
-
-def show(mode=DisplayModes.stdout.value):
-    """
-    Show libraries and system information on which NumPy was built
-    and is being used
-
-    Parameters
-    ----------
-    mode : {`'stdout'`, `'dicts'`}, optional.
-        Indicates how to display the config information.
-        `'stdout'` prints to console, `'dicts'` returns a dictionary
-        of the configuration.
-
-    Returns
-    -------
-    out : {`dict`, `None`}
-        If mode is `'dicts'`, a dict is returned, else None
-
-    See Also
-    --------
-    get_include : Returns the directory containing NumPy C
-                  header files.
-
-    Notes
-    -----
-    1. The `'stdout'` mode will give more readable
-       output if ``pyyaml`` is installed
-
-    """
-    if mode == DisplayModes.stdout.value:
-        try:  # Non-standard library, check import
-            yaml = _check_pyyaml()
-
-            print(yaml.dump(CONFIG))
-        except ModuleNotFoundError:
-            import warnings
-            import json
-
-            warnings.warn("Install `pyyaml` for better output", stacklevel=1)
-            print(json.dumps(CONFIG, indent=2))
-    elif mode == DisplayModes.dicts.value:
-        return CONFIG
-    else:
-        raise AttributeError(
-            f"Invalid `mode`, use one of: {', '.join([e.value for e in DisplayModes])}"
-        )
-
-
-def show_config(mode=DisplayModes.stdout.value):
-    return show(mode)
-
-
-show_config.__doc__ = show.__doc__
-show_config.__module__ = "numpy"

.venv/Lib/site-packages/numpy/__config__.pyi

@@ -1,102 +0,0 @@
-from enum import Enum
-from types import ModuleType
-from typing import Final, NotRequired, TypedDict, overload, type_check_only
-from typing import Literal as L
-
-_CompilerConfigDictValue = TypedDict(
-    "_CompilerConfigDictValue",
-    {
-        "name": str,
-        "linker": str,
-        "version": str,
-        "commands": str,
-        "args": str,
-        "linker args": str,
-    },
-)
-_CompilerConfigDict = TypedDict(
-    "_CompilerConfigDict",
-    {
-        "c": _CompilerConfigDictValue,
-        "cython": _CompilerConfigDictValue,
-        "c++": _CompilerConfigDictValue,
-    },
-)
-_MachineInformationDict = TypedDict(
-    "_MachineInformationDict",
-    {
-        "host": _MachineInformationDictValue,
-        "build": _MachineInformationDictValue,
-        "cross-compiled": NotRequired[L[True]],
-    },
-)
-
-@type_check_only
-class _MachineInformationDictValue(TypedDict):
-    cpu: str
-    family: str
-    endian: L["little", "big"]
-    system: str
-
-_BuildDependenciesDictValue = TypedDict(
-    "_BuildDependenciesDictValue",
-    {
-        "name": str,
-        "found": NotRequired[L[True]],
-        "version": str,
-        "include directory": str,
-        "lib directory": str,
-        "openblas configuration": str,
-        "pc file directory": str,
-    },
-)
-
-class _BuildDependenciesDict(TypedDict):
-    blas: _BuildDependenciesDictValue
-    lapack: _BuildDependenciesDictValue
-
-class _PythonInformationDict(TypedDict):
-    path: str
-    version: str
-
-_SIMDExtensionsDict = TypedDict(
-    "_SIMDExtensionsDict",
-    {
-        "baseline": list[str],
-        "found": list[str],
-        "not found": list[str],
-    },
-)
-
-_ConfigDict = TypedDict(
-    "_ConfigDict",
-    {
-        "Compilers": _CompilerConfigDict,
-        "Machine Information": _MachineInformationDict,
-        "Build Dependencies": _BuildDependenciesDict,
-        "Python Information": _PythonInformationDict,
-        "SIMD Extensions": _SIMDExtensionsDict,
-    },
-)
-
-###
-
-__all__ = ["show_config"]
-
-CONFIG: Final[_ConfigDict] = ...
-
-class DisplayModes(Enum):
-    stdout = "stdout"
-    dicts = "dicts"
-
-def _check_pyyaml() -> ModuleType: ...
-
-@overload
-def show(mode: L["stdout"] = "stdout") -> None: ...
-@overload
-def show(mode: L["dicts"]) -> _ConfigDict: ...
-
-@overload
-def show_config(mode: L["stdout"] = "stdout") -> None: ...
-@overload
-def show_config(mode: L["dicts"]) -> _ConfigDict: ...

.venv/Lib/site-packages/numpy/__init__.py

@@ -1,941 +0,0 @@
-"""
-NumPy
-=====
-
-Provides
-  1. An array object of arbitrary homogeneous items
-  2. Fast mathematical operations over arrays
-  3. Linear Algebra, Fourier Transforms, Random Number Generation
-
-How to use the documentation
-----------------------------
-Documentation is available in two forms: docstrings provided
-with the code, and a loose standing reference guide, available from
-`the NumPy homepage <https://numpy.org>`_.
-
-We recommend exploring the docstrings using
-`IPython <https://ipython.org>`_, an advanced Python shell with
-TAB-completion and introspection capabilities.  See below for further
-instructions.
-
-The docstring examples assume that `numpy` has been imported as ``np``::
-
-  >>> import numpy as np
-
-Code snippets are indicated by three greater-than signs::
-
-  >>> x = 42
-  >>> x = x + 1
-
-Use the built-in ``help`` function to view a function's docstring::
-
-  >>> help(np.sort)
-  ... # doctest: +SKIP
-
-For some objects, ``np.info(obj)`` may provide additional help.  This is
-particularly true if you see the line "Help on ufunc object:" at the top
-of the help() page.  Ufuncs are implemented in C, not Python, for speed.
-The native Python help() does not know how to view their help, but our
-np.info() function does.
-
-Available subpackages
----------------------
-lib
-    Basic functions used by several sub-packages.
-random
-    Core Random Tools
-linalg
-    Core Linear Algebra Tools
-fft
-    Core FFT routines
-polynomial
-    Polynomial tools
-testing
-    NumPy testing tools
-distutils
-    Enhancements to distutils with support for
-    Fortran compilers support and more (for Python <= 3.11)
-
-Utilities
----------
-test
-    Run numpy unittests
-show_config
-    Show numpy build configuration
-__version__
-    NumPy version string
-
-Viewing documentation using IPython
------------------------------------
-
-Start IPython and import `numpy` usually under the alias ``np``: `import
-numpy as np`.  Then, directly past or use the ``%cpaste`` magic to paste
-examples into the shell.  To see which functions are available in `numpy`,
-type ``np.<TAB>`` (where ``<TAB>`` refers to the TAB key), or use
-``np.*cos*?<ENTER>`` (where ``<ENTER>`` refers to the ENTER key) to narrow
-down the list.  To view the docstring for a function, use
-``np.cos?<ENTER>`` (to view the docstring) and ``np.cos??<ENTER>`` (to view
-the source code).
-
-Copies vs. in-place operation
------------------------------
-Most of the functions in `numpy` return a copy of the array argument
-(e.g., `np.sort`).  In-place versions of these functions are often
-available as array methods, i.e. ``x = np.array([1,2,3]); x.sort()``.
-Exceptions to this rule are documented.
-
-"""
-
-
-# start delvewheel patch
-def _delvewheel_patch_1_11_1():
-    import os
-    if os.path.isdir(libs_dir := os.path.abspath(os.path.join(os.path.dirname(__file__), os.pardir, 'numpy.libs'))):
-        os.add_dll_directory(libs_dir)
-
-
-_delvewheel_patch_1_11_1()
-del _delvewheel_patch_1_11_1
-# end delvewheel patch
-
-import os
-import sys
-import warnings
-
-# If a version with git hash was stored, use that instead
-from . import version
-from ._expired_attrs_2_0 import __expired_attributes__
-from ._globals import _CopyMode, _NoValue
-from .version import __version__
-
-# We first need to detect if we're being called as part of the numpy setup
-# procedure itself in a reliable manner.
-try:
-    __NUMPY_SETUP__  # noqa: B018
-except NameError:
-    __NUMPY_SETUP__ = False
-
-if __NUMPY_SETUP__:
-    sys.stderr.write('Running from numpy source directory.\n')
-else:
-    # Allow distributors to run custom init code before importing numpy._core
-    from . import _distributor_init
-
-    try:
-        from numpy.__config__ import show_config
-    except ImportError as e:
-        msg = """Error importing numpy: you should not try to import numpy from
-        its source directory; please exit the numpy source tree, and relaunch
-        your python interpreter from there."""
-        raise ImportError(msg) from e
-
-    from . import _core
-    from ._core import (
-        False_,
-        ScalarType,
-        True_,
-        abs,
-        absolute,
-        acos,
-        acosh,
-        add,
-        all,
-        allclose,
-        amax,
-        amin,
-        any,
-        arange,
-        arccos,
-        arccosh,
-        arcsin,
-        arcsinh,
-        arctan,
-        arctan2,
-        arctanh,
-        argmax,
-        argmin,
-        argpartition,
-        argsort,
-        argwhere,
-        around,
-        array,
-        array2string,
-        array_equal,
-        array_equiv,
-        array_repr,
-        array_str,
-        asanyarray,
-        asarray,
-        ascontiguousarray,
-        asfortranarray,
-        asin,
-        asinh,
-        astype,
-        atan,
-        atan2,
-        atanh,
-        atleast_1d,
-        atleast_2d,
-        atleast_3d,
-        base_repr,
-        binary_repr,
-        bitwise_and,
-        bitwise_count,
-        bitwise_invert,
-        bitwise_left_shift,
-        bitwise_not,
-        bitwise_or,
-        bitwise_right_shift,
-        bitwise_xor,
-        block,
-        bool,
-        bool_,
-        broadcast,
-        busday_count,
-        busday_offset,
-        busdaycalendar,
-        byte,
-        bytes_,
-        can_cast,
-        cbrt,
-        cdouble,
-        ceil,
-        character,
-        choose,
-        clip,
-        clongdouble,
-        complex64,
-        complex128,
-        complexfloating,
-        compress,
-        concat,
-        concatenate,
-        conj,
-        conjugate,
-        convolve,
-        copysign,
-        copyto,
-        correlate,
-        cos,
-        cosh,
-        count_nonzero,
-        cross,
-        csingle,
-        cumprod,
-        cumsum,
-        cumulative_prod,
-        cumulative_sum,
-        datetime64,
-        datetime_as_string,
-        datetime_data,
-        deg2rad,
-        degrees,
-        diagonal,
-        divide,
-        divmod,
-        dot,
-        double,
-        dtype,
-        e,
-        einsum,
-        einsum_path,
-        empty,
-        empty_like,
-        equal,
-        errstate,
-        euler_gamma,
-        exp,
-        exp2,
-        expm1,
-        fabs,
-        finfo,
-        flatiter,
-        flatnonzero,
-        flexible,
-        float16,
-        float32,
-        float64,
-        float_power,
-        floating,
-        floor,
-        floor_divide,
-        fmax,
-        fmin,
-        fmod,
-        format_float_positional,
-        format_float_scientific,
-        frexp,
-        from_dlpack,
-        frombuffer,
-        fromfile,
-        fromfunction,
-        fromiter,
-        frompyfunc,
-        fromstring,
-        full,
-        full_like,
-        gcd,
-        generic,
-        geomspace,
-        get_printoptions,
-        getbufsize,
-        geterr,
-        geterrcall,
-        greater,
-        greater_equal,
-        half,
-        heaviside,
-        hstack,
-        hypot,
-        identity,
-        iinfo,
-        indices,
-        inexact,
-        inf,
-        inner,
-        int8,
-        int16,
-        int32,
-        int64,
-        int_,
-        intc,
-        integer,
-        intp,
-        invert,
-        is_busday,
-        isclose,
-        isdtype,
-        isfinite,
-        isfortran,
-        isinf,
-        isnan,
-        isnat,
-        isscalar,
-        issubdtype,
-        lcm,
-        ldexp,
-        left_shift,
-        less,
-        less_equal,
-        lexsort,
-        linspace,
-        little_endian,
-        log,
-        log1p,
-        log2,
-        log10,
-        logaddexp,
-        logaddexp2,
-        logical_and,
-        logical_not,
-        logical_or,
-        logical_xor,
-        logspace,
-        long,
-        longdouble,
-        longlong,
-        matmul,
-        matrix_transpose,
-        matvec,
-        max,
-        maximum,
-        may_share_memory,
-        mean,
-        memmap,
-        min,
-        min_scalar_type,
-        minimum,
-        mod,
-        modf,
-        moveaxis,
-        multiply,
-        nan,
-        ndarray,
-        ndim,
-        nditer,
-        negative,
-        nested_iters,
-        newaxis,
-        nextafter,
-        nonzero,
-        not_equal,
-        number,
-        object_,
-        ones,
-        ones_like,
-        outer,
-        partition,
-        permute_dims,
-        pi,
-        positive,
-        pow,
-        power,
-        printoptions,
-        prod,
-        promote_types,
-        ptp,
-        put,
-        putmask,
-        rad2deg,
-        radians,
-        ravel,
-        recarray,
-        reciprocal,
-        record,
-        remainder,
-        repeat,
-        require,
-        reshape,
-        resize,
-        result_type,
-        right_shift,
-        rint,
-        roll,
-        rollaxis,
-        round,
-        sctypeDict,
-        searchsorted,
-        set_printoptions,
-        setbufsize,
-        seterr,
-        seterrcall,
-        shape,
-        shares_memory,
-        short,
-        sign,
-        signbit,
-        signedinteger,
-        sin,
-        single,
-        sinh,
-        size,
-        sort,
-        spacing,
-        sqrt,
-        square,
-        squeeze,
-        stack,
-        std,
-        str_,
-        subtract,
-        sum,
-        swapaxes,
-        take,
-        tan,
-        tanh,
-        tensordot,
-        timedelta64,
-        trace,
-        transpose,
-        true_divide,
-        trunc,
-        typecodes,
-        ubyte,
-        ufunc,
-        uint,
-        uint8,
-        uint16,
-        uint32,
-        uint64,
-        uintc,
-        uintp,
-        ulong,
-        ulonglong,
-        unsignedinteger,
-        unstack,
-        ushort,
-        var,
-        vdot,
-        vecdot,
-        vecmat,
-        void,
-        vstack,
-        where,
-        zeros,
-        zeros_like,
-    )
-
-    # NOTE: It's still under discussion whether these aliases
-    # should be removed.
-    for ta in ["float96", "float128", "complex192", "complex256"]:
-        try:
-            globals()[ta] = getattr(_core, ta)
-        except AttributeError:
-            pass
-    del ta
-
-    from . import lib
-    from . import matrixlib as _mat
-    from .lib import scimath as emath
-    from .lib._arraypad_impl import pad
-    from .lib._arraysetops_impl import (
-        ediff1d,
-        in1d,
-        intersect1d,
-        isin,
-        setdiff1d,
-        setxor1d,
-        union1d,
-        unique,
-        unique_all,
-        unique_counts,
-        unique_inverse,
-        unique_values,
-    )
-    from .lib._function_base_impl import (
-        angle,
-        append,
-        asarray_chkfinite,
-        average,
-        bartlett,
-        bincount,
-        blackman,
-        copy,
-        corrcoef,
-        cov,
-        delete,
-        diff,
-        digitize,
-        extract,
-        flip,
-        gradient,
-        hamming,
-        hanning,
-        i0,
-        insert,
-        interp,
-        iterable,
-        kaiser,
-        median,
-        meshgrid,
-        percentile,
-        piecewise,
-        place,
-        quantile,
-        rot90,
-        select,
-        sinc,
-        sort_complex,
-        trapezoid,
-        trapz,
-        trim_zeros,
-        unwrap,
-        vectorize,
-    )
-    from .lib._histograms_impl import histogram, histogram_bin_edges, histogramdd
-    from .lib._index_tricks_impl import (
-        c_,
-        diag_indices,
-        diag_indices_from,
-        fill_diagonal,
-        index_exp,
-        ix_,
-        mgrid,
-        ndenumerate,
-        ndindex,
-        ogrid,
-        r_,
-        ravel_multi_index,
-        s_,
-        unravel_index,
-    )
-    from .lib._nanfunctions_impl import (
-        nanargmax,
-        nanargmin,
-        nancumprod,
-        nancumsum,
-        nanmax,
-        nanmean,
-        nanmedian,
-        nanmin,
-        nanpercentile,
-        nanprod,
-        nanquantile,
-        nanstd,
-        nansum,
-        nanvar,
-    )
-    from .lib._npyio_impl import (
-        fromregex,
-        genfromtxt,
-        load,
-        loadtxt,
-        packbits,
-        save,
-        savetxt,
-        savez,
-        savez_compressed,
-        unpackbits,
-    )
-    from .lib._polynomial_impl import (
-        poly,
-        poly1d,
-        polyadd,
-        polyder,
-        polydiv,
-        polyfit,
-        polyint,
-        polymul,
-        polysub,
-        polyval,
-        roots,
-    )
-    from .lib._shape_base_impl import (
-        apply_along_axis,
-        apply_over_axes,
-        array_split,
-        column_stack,
-        dsplit,
-        dstack,
-        expand_dims,
-        hsplit,
-        kron,
-        put_along_axis,
-        row_stack,
-        split,
-        take_along_axis,
-        tile,
-        vsplit,
-    )
-    from .lib._stride_tricks_impl import (
-        broadcast_arrays,
-        broadcast_shapes,
-        broadcast_to,
-    )
-    from .lib._twodim_base_impl import (
-        diag,
-        diagflat,
-        eye,
-        fliplr,
-        flipud,
-        histogram2d,
-        mask_indices,
-        tri,
-        tril,
-        tril_indices,
-        tril_indices_from,
-        triu,
-        triu_indices,
-        triu_indices_from,
-        vander,
-    )
-    from .lib._type_check_impl import (
-        common_type,
-        imag,
-        iscomplex,
-        iscomplexobj,
-        isreal,
-        isrealobj,
-        mintypecode,
-        nan_to_num,
-        real,
-        real_if_close,
-        typename,
-    )
-    from .lib._ufunclike_impl import fix, isneginf, isposinf
-    from .lib._utils_impl import get_include, info, show_runtime
-    from .matrixlib import asmatrix, bmat, matrix
-
-    # public submodules are imported lazily, therefore are accessible from
-    # __getattr__. Note that `distutils` (deprecated) and `array_api`
-    # (experimental label) are not added here, because `from numpy import *`
-    # must not raise any warnings - that's too disruptive.
-    __numpy_submodules__ = {
-        "linalg", "fft", "dtypes", "random", "polynomial", "ma",
-        "exceptions", "lib", "ctypeslib", "testing", "typing",
-        "f2py", "test", "rec", "char", "core", "strings",
-    }
-
-    # We build warning messages for former attributes
-    _msg = (
-        "module 'numpy' has no attribute '{n}'.\n"
-        "`np.{n}` was a deprecated alias for the builtin `{n}`. "
-        "To avoid this error in existing code, use `{n}` by itself. "
-        "Doing this will not modify any behavior and is safe. {extended_msg}\n"
-        "The aliases was originally deprecated in NumPy 1.20; for more "
-        "details and guidance see the original release note at:\n"
-        "    https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations")
-
-    _specific_msg = (
-        "If you specifically wanted the numpy scalar type, use `np.{}` here.")
-
-    _int_extended_msg = (
-        "When replacing `np.{}`, you may wish to use e.g. `np.int64` "
-        "or `np.int32` to specify the precision. If you wish to review "
-        "your current use, check the release note link for "
-        "additional information.")
-
-    _type_info = [
-        ("object", ""),  # The NumPy scalar only exists by name.
-        ("float", _specific_msg.format("float64")),
-        ("complex", _specific_msg.format("complex128")),
-        ("str", _specific_msg.format("str_")),
-        ("int", _int_extended_msg.format("int"))]
-
-    __former_attrs__ = {
-         n: _msg.format(n=n, extended_msg=extended_msg)
-         for n, extended_msg in _type_info
-     }
-
-    # Some of these could be defined right away, but most were aliases to
-    # the Python objects and only removed in NumPy 1.24.  Defining them should
-    # probably wait for NumPy 1.26 or 2.0.
-    # When defined, these should possibly not be added to `__all__` to avoid
-    # import with `from numpy import *`.
-    __future_scalars__ = {"str", "bytes", "object"}
-
-    __array_api_version__ = "2024.12"
-
-    from ._array_api_info import __array_namespace_info__
-
-    # now that numpy core module is imported, can initialize limits
-    _core.getlimits._register_known_types()
-
-    __all__ = list(
-        __numpy_submodules__ |
-        set(_core.__all__) |
-        set(_mat.__all__) |
-        set(lib._histograms_impl.__all__) |
-        set(lib._nanfunctions_impl.__all__) |
-        set(lib._function_base_impl.__all__) |
-        set(lib._twodim_base_impl.__all__) |
-        set(lib._shape_base_impl.__all__) |
-        set(lib._type_check_impl.__all__) |
-        set(lib._arraysetops_impl.__all__) |
-        set(lib._ufunclike_impl.__all__) |
-        set(lib._arraypad_impl.__all__) |
-        set(lib._utils_impl.__all__) |
-        set(lib._stride_tricks_impl.__all__) |
-        set(lib._polynomial_impl.__all__) |
-        set(lib._npyio_impl.__all__) |
-        set(lib._index_tricks_impl.__all__) |
-        {"emath", "show_config", "__version__", "__array_namespace_info__"}
-    )
-
-    # Filter out Cython harmless warnings
-    warnings.filterwarnings("ignore", message="numpy.dtype size changed")
-    warnings.filterwarnings("ignore", message="numpy.ufunc size changed")
-    warnings.filterwarnings("ignore", message="numpy.ndarray size changed")
-
-    def __getattr__(attr):
-        # Warn for expired attributes
-        import warnings
-
-        if attr == "linalg":
-            import numpy.linalg as linalg
-            return linalg
-        elif attr == "fft":
-            import numpy.fft as fft
-            return fft
-        elif attr == "dtypes":
-            import numpy.dtypes as dtypes
-            return dtypes
-        elif attr == "random":
-            import numpy.random as random
-            return random
-        elif attr == "polynomial":
-            import numpy.polynomial as polynomial
-            return polynomial
-        elif attr == "ma":
-            import numpy.ma as ma
-            return ma
-        elif attr == "ctypeslib":
-            import numpy.ctypeslib as ctypeslib
-            return ctypeslib
-        elif attr == "exceptions":
-            import numpy.exceptions as exceptions
-            return exceptions
-        elif attr == "testing":
-            import numpy.testing as testing
-            return testing
-        elif attr == "matlib":
-            import numpy.matlib as matlib
-            return matlib
-        elif attr == "f2py":
-            import numpy.f2py as f2py
-            return f2py
-        elif attr == "typing":
-            import numpy.typing as typing
-            return typing
-        elif attr == "rec":
-            import numpy.rec as rec
-            return rec
-        elif attr == "char":
-            import numpy.char as char
-            return char
-        elif attr == "array_api":
-            raise AttributeError("`numpy.array_api` is not available from "
-                                 "numpy 2.0 onwards", name=None)
-        elif attr == "core":
-            import numpy.core as core
-            return core
-        elif attr == "strings":
-            import numpy.strings as strings
-            return strings
-        elif attr == "distutils":
-            if 'distutils' in __numpy_submodules__:
-                import numpy.distutils as distutils
-                return distutils
-            else:
-                raise AttributeError("`numpy.distutils` is not available from "
-                                     "Python 3.12 onwards", name=None)
-
-        if attr in __future_scalars__:
-            # And future warnings for those that will change, but also give
-            # the AttributeError
-            warnings.warn(
-                f"In the future `np.{attr}` will be defined as the "
-                "corresponding NumPy scalar.", FutureWarning, stacklevel=2)
-
-        if attr in __former_attrs__:
-            raise AttributeError(__former_attrs__[attr], name=None)
-
-        if attr in __expired_attributes__:
-            raise AttributeError(
-                f"`np.{attr}` was removed in the NumPy 2.0 release. "
-                f"{__expired_attributes__[attr]}",
-                name=None
-            )
-
-        if attr == "chararray":
-            warnings.warn(
-                "`np.chararray` is deprecated and will be removed from "
-                "the main namespace in the future. Use an array with a string "
-                "or bytes dtype instead.", DeprecationWarning, stacklevel=2)
-            import numpy.char as char
-            return char.chararray
-
-        raise AttributeError(f"module {__name__!r} has no attribute {attr!r}")
-
-    def __dir__():
-        public_symbols = (
-            globals().keys() | __numpy_submodules__
-        )
-        public_symbols -= {
-            "matrixlib", "matlib", "tests", "conftest", "version",
-            "distutils", "array_api"
-        }
-        return list(public_symbols)
-
-    # Pytest testing
-    from numpy._pytesttester import PytestTester
-    test = PytestTester(__name__)
-    del PytestTester
-
-    def _sanity_check():
-        """
-        Quick sanity checks for common bugs caused by environment.
-        There are some cases e.g. with wrong BLAS ABI that cause wrong
-        results under specific runtime conditions that are not necessarily
-        achieved during test suite runs, and it is useful to catch those early.
-
-        See https://github.com/numpy/numpy/issues/8577 and other
-        similar bug reports.
-
-        """
-        try:
-            x = ones(2, dtype=float32)
-            if not abs(x.dot(x) - float32(2.0)) < 1e-5:
-                raise AssertionError
-        except AssertionError:
-            msg = ("The current Numpy installation ({!r}) fails to "
-                   "pass simple sanity checks. This can be caused for example "
-                   "by incorrect BLAS library being linked in, or by mixing "
-                   "package managers (pip, conda, apt, ...). Search closed "
-                   "numpy issues for similar problems.")
-            raise RuntimeError(msg.format(__file__)) from None
-
-    _sanity_check()
-    del _sanity_check
-
-    def _mac_os_check():
-        """
-        Quick Sanity check for Mac OS look for accelerate build bugs.
-        Testing numpy polyfit calls init_dgelsd(LAPACK)
-        """
-        try:
-            c = array([3., 2., 1.])
-            x = linspace(0, 2, 5)
-            y = polyval(c, x)
-            _ = polyfit(x, y, 2, cov=True)
-        except ValueError:
-            pass
-
-    if sys.platform == "darwin":
-        from . import exceptions
-        with warnings.catch_warnings(record=True) as w:
-            _mac_os_check()
-            # Throw runtime error, if the test failed
-            # Check for warning and report the error_message
-            if len(w) > 0:
-                for _wn in w:
-                    if _wn.category is exceptions.RankWarning:
-                        # Ignore other warnings, they may not be relevant (see gh-25433)
-                        error_message = (
-                            f"{_wn.category.__name__}: {_wn.message}"
-                        )
-                        msg = (
-                            "Polyfit sanity test emitted a warning, most likely due "
-                            "to using a buggy Accelerate backend."
-                            "\nIf you compiled yourself, more information is available at:"  # noqa: E501
-                            "\nhttps://numpy.org/devdocs/building/index.html"
-                            "\nOtherwise report this to the vendor "
-                            f"that provided NumPy.\n\n{error_message}\n")
-                        raise RuntimeError(msg)
-                del _wn
-            del w
-    del _mac_os_check
-
-    def hugepage_setup():
-        """
-        We usually use madvise hugepages support, but on some old kernels it
-        is slow and thus better avoided. Specifically kernel version 4.6
-        had a bug fix which probably fixed this:
-        https://github.com/torvalds/linux/commit/7cf91a98e607c2f935dbcc177d70011e95b8faff
-        """
-        use_hugepage = os.environ.get("NUMPY_MADVISE_HUGEPAGE", None)
-        if sys.platform == "linux" and use_hugepage is None:
-            # If there is an issue with parsing the kernel version,
-            # set use_hugepage to 0. Usage of LooseVersion will handle
-            # the kernel version parsing better, but avoided since it
-            # will increase the import time.
-            # See: #16679 for related discussion.
-            try:
-                use_hugepage = 1
-                kernel_version = os.uname().release.split(".")[:2]
-                kernel_version = tuple(int(v) for v in kernel_version)
-                if kernel_version < (4, 6):
-                    use_hugepage = 0
-            except ValueError:
-                use_hugepage = 0
-        elif use_hugepage is None:
-            # This is not Linux, so it should not matter, just enable anyway
-            use_hugepage = 1
-        else:
-            use_hugepage = int(use_hugepage)
-        return use_hugepage
-
-    # Note that this will currently only make a difference on Linux
-    _core.multiarray._set_madvise_hugepage(hugepage_setup())
-    del hugepage_setup
-
-    # Give a warning if NumPy is reloaded or imported on a sub-interpreter
-    # We do this from python, since the C-module may not be reloaded and
-    # it is tidier organized.
-    _core.multiarray._multiarray_umath._reload_guard()
-
-    # TODO: Remove the environment variable entirely now that it is "weak"
-    if (os.environ.get("NPY_PROMOTION_STATE", "weak") != "weak"):
-        warnings.warn(
-            "NPY_PROMOTION_STATE was a temporary feature for NumPy 2.0 "
-            "transition and is ignored after NumPy 2.2.",
-            UserWarning, stacklevel=2)
-
-    # Tell PyInstaller where to find hook-numpy.py
-    def _pyinstaller_hooks_dir():
-        from pathlib import Path
-        return [str(Path(__file__).with_name("_pyinstaller").resolve())]
-
-
-# Remove symbols imported for internal use
-del os, sys, warnings

.venv/Lib/site-packages/numpy/_array_api_info.py

@@ -1,346 +0,0 @@
-"""
-Array API Inspection namespace
-
-This is the namespace for inspection functions as defined by the array API
-standard. See
-https://data-apis.org/array-api/latest/API_specification/inspection.html for
-more details.
-
-"""
-from numpy._core import (
-    bool,
-    complex64,
-    complex128,
-    dtype,
-    float32,
-    float64,
-    int8,
-    int16,
-    int32,
-    int64,
-    intp,
-    uint8,
-    uint16,
-    uint32,
-    uint64,
-)
-
-
-class __array_namespace_info__:
-    """
-    Get the array API inspection namespace for NumPy.
-
-    The array API inspection namespace defines the following functions:
-
-    - capabilities()
-    - default_device()
-    - default_dtypes()
-    - dtypes()
-    - devices()
-
-    See
-    https://data-apis.org/array-api/latest/API_specification/inspection.html
-    for more details.
-
-    Returns
-    -------
-    info : ModuleType
-        The array API inspection namespace for NumPy.
-
-    Examples
-    --------
-    >>> info = np.__array_namespace_info__()
-    >>> info.default_dtypes()
-    {'real floating': numpy.float64,
-     'complex floating': numpy.complex128,
-     'integral': numpy.int64,
-     'indexing': numpy.int64}
-
-    """
-
-    __module__ = 'numpy'
-
-    def capabilities(self):
-        """
-        Return a dictionary of array API library capabilities.
-
-        The resulting dictionary has the following keys:
-
-        - **"boolean indexing"**: boolean indicating whether an array library
-          supports boolean indexing. Always ``True`` for NumPy.
-
-        - **"data-dependent shapes"**: boolean indicating whether an array
-          library supports data-dependent output shapes. Always ``True`` for
-          NumPy.
-
-        See
-        https://data-apis.org/array-api/latest/API_specification/generated/array_api.info.capabilities.html
-        for more details.
-
-        See Also
-        --------
-        __array_namespace_info__.default_device,
-        __array_namespace_info__.default_dtypes,
-        __array_namespace_info__.dtypes,
-        __array_namespace_info__.devices
-
-        Returns
-        -------
-        capabilities : dict
-            A dictionary of array API library capabilities.
-
-        Examples
-        --------
-        >>> info = np.__array_namespace_info__()
-        >>> info.capabilities()
-        {'boolean indexing': True,
-         'data-dependent shapes': True,
-         'max dimensions': 64}
-
-        """
-        return {
-            "boolean indexing": True,
-            "data-dependent shapes": True,
-            "max dimensions": 64,
-        }
-
-    def default_device(self):
-        """
-        The default device used for new NumPy arrays.
-
-        For NumPy, this always returns ``'cpu'``.
-
-        See Also
-        --------
-        __array_namespace_info__.capabilities,
-        __array_namespace_info__.default_dtypes,
-        __array_namespace_info__.dtypes,
-        __array_namespace_info__.devices
-
-        Returns
-        -------
-        device : str
-            The default device used for new NumPy arrays.
-
-        Examples
-        --------
-        >>> info = np.__array_namespace_info__()
-        >>> info.default_device()
-        'cpu'
-
-        """
-        return "cpu"
-
-    def default_dtypes(self, *, device=None):
-        """
-        The default data types used for new NumPy arrays.
-
-        For NumPy, this always returns the following dictionary:
-
-        - **"real floating"**: ``numpy.float64``
-        - **"complex floating"**: ``numpy.complex128``
-        - **"integral"**: ``numpy.intp``
-        - **"indexing"**: ``numpy.intp``
-
-        Parameters
-        ----------
-        device : str, optional
-            The device to get the default data types for. For NumPy, only
-            ``'cpu'`` is allowed.
-
-        Returns
-        -------
-        dtypes : dict
-            A dictionary describing the default data types used for new NumPy
-            arrays.
-
-        See Also
-        --------
-        __array_namespace_info__.capabilities,
-        __array_namespace_info__.default_device,
-        __array_namespace_info__.dtypes,
-        __array_namespace_info__.devices
-
-        Examples
-        --------
-        >>> info = np.__array_namespace_info__()
-        >>> info.default_dtypes()
-        {'real floating': numpy.float64,
-         'complex floating': numpy.complex128,
-         'integral': numpy.int64,
-         'indexing': numpy.int64}
-
-        """
-        if device not in ["cpu", None]:
-            raise ValueError(
-                'Device not understood. Only "cpu" is allowed, but received:'
-                f' {device}'
-            )
-        return {
-            "real floating": dtype(float64),
-            "complex floating": dtype(complex128),
-            "integral": dtype(intp),
-            "indexing": dtype(intp),
-        }
-
-    def dtypes(self, *, device=None, kind=None):
-        """
-        The array API data types supported by NumPy.
-
-        Note that this function only returns data types that are defined by
-        the array API.
-
-        Parameters
-        ----------
-        device : str, optional
-            The device to get the data types for. For NumPy, only ``'cpu'`` is
-            allowed.
-        kind : str or tuple of str, optional
-            The kind of data types to return. If ``None``, all data types are
-            returned. If a string, only data types of that kind are returned.
-            If a tuple, a dictionary containing the union of the given kinds
-            is returned. The following kinds are supported:
-
-            - ``'bool'``: boolean data types (i.e., ``bool``).
-            - ``'signed integer'``: signed integer data types (i.e., ``int8``,
-              ``int16``, ``int32``, ``int64``).
-            - ``'unsigned integer'``: unsigned integer data types (i.e.,
-              ``uint8``, ``uint16``, ``uint32``, ``uint64``).
-            - ``'integral'``: integer data types. Shorthand for ``('signed
-              integer', 'unsigned integer')``.
-            - ``'real floating'``: real-valued floating-point data types
-              (i.e., ``float32``, ``float64``).
-            - ``'complex floating'``: complex floating-point data types (i.e.,
-              ``complex64``, ``complex128``).
-            - ``'numeric'``: numeric data types. Shorthand for ``('integral',
-              'real floating', 'complex floating')``.
-
-        Returns
-        -------
-        dtypes : dict
-            A dictionary mapping the names of data types to the corresponding
-            NumPy data types.
-
-        See Also
-        --------
-        __array_namespace_info__.capabilities,
-        __array_namespace_info__.default_device,
-        __array_namespace_info__.default_dtypes,
-        __array_namespace_info__.devices
-
-        Examples
-        --------
-        >>> info = np.__array_namespace_info__()
-        >>> info.dtypes(kind='signed integer')
-        {'int8': numpy.int8,
-         'int16': numpy.int16,
-         'int32': numpy.int32,
-         'int64': numpy.int64}
-
-        """
-        if device not in ["cpu", None]:
-            raise ValueError(
-                'Device not understood. Only "cpu" is allowed, but received:'
-                f' {device}'
-            )
-        if kind is None:
-            return {
-                "bool": dtype(bool),
-                "int8": dtype(int8),
-                "int16": dtype(int16),
-                "int32": dtype(int32),
-                "int64": dtype(int64),
-                "uint8": dtype(uint8),
-                "uint16": dtype(uint16),
-                "uint32": dtype(uint32),
-                "uint64": dtype(uint64),
-                "float32": dtype(float32),
-                "float64": dtype(float64),
-                "complex64": dtype(complex64),
-                "complex128": dtype(complex128),
-            }
-        if kind == "bool":
-            return {"bool": bool}
-        if kind == "signed integer":
-            return {
-                "int8": dtype(int8),
-                "int16": dtype(int16),
-                "int32": dtype(int32),
-                "int64": dtype(int64),
-            }
-        if kind == "unsigned integer":
-            return {
-                "uint8": dtype(uint8),
-                "uint16": dtype(uint16),
-                "uint32": dtype(uint32),
-                "uint64": dtype(uint64),
-            }
-        if kind == "integral":
-            return {
-                "int8": dtype(int8),
-                "int16": dtype(int16),
-                "int32": dtype(int32),
-                "int64": dtype(int64),
-                "uint8": dtype(uint8),
-                "uint16": dtype(uint16),
-                "uint32": dtype(uint32),
-                "uint64": dtype(uint64),
-            }
-        if kind == "real floating":
-            return {
-                "float32": dtype(float32),
-                "float64": dtype(float64),
-            }
-        if kind == "complex floating":
-            return {
-                "complex64": dtype(complex64),
-                "complex128": dtype(complex128),
-            }
-        if kind == "numeric":
-            return {
-                "int8": dtype(int8),
-                "int16": dtype(int16),
-                "int32": dtype(int32),
-                "int64": dtype(int64),
-                "uint8": dtype(uint8),
-                "uint16": dtype(uint16),
-                "uint32": dtype(uint32),
-                "uint64": dtype(uint64),
-                "float32": dtype(float32),
-                "float64": dtype(float64),
-                "complex64": dtype(complex64),
-                "complex128": dtype(complex128),
-            }
-        if isinstance(kind, tuple):
-            res = {}
-            for k in kind:
-                res.update(self.dtypes(kind=k))
-            return res
-        raise ValueError(f"unsupported kind: {kind!r}")
-
-    def devices(self):
-        """
-        The devices supported by NumPy.
-
-        For NumPy, this always returns ``['cpu']``.
-
-        Returns
-        -------
-        devices : list of str
-            The devices supported by NumPy.
-
-        See Also
-        --------
-        __array_namespace_info__.capabilities,
-        __array_namespace_info__.default_device,
-        __array_namespace_info__.default_dtypes,
-        __array_namespace_info__.dtypes
-
-        Examples
-        --------
-        >>> info = np.__array_namespace_info__()
-        >>> info.devices()
-        ['cpu']
-
-        """
-        return ["cpu"]

.venv/Lib/site-packages/numpy/_array_api_info.pyi

@@ -1,207 +0,0 @@
-from typing import (
-    ClassVar,
-    Literal,
-    Never,
-    TypeAlias,
-    TypedDict,
-    TypeVar,
-    final,
-    overload,
-    type_check_only,
-)
-
-import numpy as np
-
-_Device: TypeAlias = Literal["cpu"]
-_DeviceLike: TypeAlias = _Device | None
-
-_Capabilities = TypedDict(
-    "_Capabilities",
-    {
-        "boolean indexing": Literal[True],
-        "data-dependent shapes": Literal[True],
-    },
-)
-
-_DefaultDTypes = TypedDict(
-    "_DefaultDTypes",
-    {
-        "real floating": np.dtype[np.float64],
-        "complex floating": np.dtype[np.complex128],
-        "integral": np.dtype[np.intp],
-        "indexing": np.dtype[np.intp],
-    },
-)
-
-_KindBool: TypeAlias = Literal["bool"]
-_KindInt: TypeAlias = Literal["signed integer"]
-_KindUInt: TypeAlias = Literal["unsigned integer"]
-_KindInteger: TypeAlias = Literal["integral"]
-_KindFloat: TypeAlias = Literal["real floating"]
-_KindComplex: TypeAlias = Literal["complex floating"]
-_KindNumber: TypeAlias = Literal["numeric"]
-_Kind: TypeAlias = (
-    _KindBool
-    | _KindInt
-    | _KindUInt
-    | _KindInteger
-    | _KindFloat
-    | _KindComplex
-    | _KindNumber
-)
-
-_T1 = TypeVar("_T1")
-_T2 = TypeVar("_T2")
-_T3 = TypeVar("_T3")
-_Permute1: TypeAlias = _T1 | tuple[_T1]
-_Permute2: TypeAlias = tuple[_T1, _T2] | tuple[_T2, _T1]
-_Permute3: TypeAlias = (
-    tuple[_T1, _T2, _T3] | tuple[_T1, _T3, _T2]
-    | tuple[_T2, _T1, _T3] | tuple[_T2, _T3, _T1]
-    | tuple[_T3, _T1, _T2] | tuple[_T3, _T2, _T1]
-)
-
-@type_check_only
-class _DTypesBool(TypedDict):
-    bool: np.dtype[np.bool]
-
-@type_check_only
-class _DTypesInt(TypedDict):
-    int8: np.dtype[np.int8]
-    int16: np.dtype[np.int16]
-    int32: np.dtype[np.int32]
-    int64: np.dtype[np.int64]
-
-@type_check_only
-class _DTypesUInt(TypedDict):
-    uint8: np.dtype[np.uint8]
-    uint16: np.dtype[np.uint16]
-    uint32: np.dtype[np.uint32]
-    uint64: np.dtype[np.uint64]
-
-@type_check_only
-class _DTypesInteger(_DTypesInt, _DTypesUInt): ...
-
-@type_check_only
-class _DTypesFloat(TypedDict):
-    float32: np.dtype[np.float32]
-    float64: np.dtype[np.float64]
-
-@type_check_only
-class _DTypesComplex(TypedDict):
-    complex64: np.dtype[np.complex64]
-    complex128: np.dtype[np.complex128]
-
-@type_check_only
-class _DTypesNumber(_DTypesInteger, _DTypesFloat, _DTypesComplex): ...
-
-@type_check_only
-class _DTypes(_DTypesBool, _DTypesNumber): ...
-
-@type_check_only
-class _DTypesUnion(TypedDict, total=False):
-    bool: np.dtype[np.bool]
-    int8: np.dtype[np.int8]
-    int16: np.dtype[np.int16]
-    int32: np.dtype[np.int32]
-    int64: np.dtype[np.int64]
-    uint8: np.dtype[np.uint8]
-    uint16: np.dtype[np.uint16]
-    uint32: np.dtype[np.uint32]
-    uint64: np.dtype[np.uint64]
-    float32: np.dtype[np.float32]
-    float64: np.dtype[np.float64]
-    complex64: np.dtype[np.complex64]
-    complex128: np.dtype[np.complex128]
-
-_EmptyDict: TypeAlias = dict[Never, Never]
-
-@final
-class __array_namespace_info__:
-    __module__: ClassVar[Literal['numpy']]
-
-    def capabilities(self) -> _Capabilities: ...
-    def default_device(self) -> _Device: ...
-    def default_dtypes(
-        self,
-        *,
-        device: _DeviceLike = ...,
-    ) -> _DefaultDTypes: ...
-    def devices(self) -> list[_Device]: ...
-
-    @overload
-    def dtypes(
-        self,
-        *,
-        device: _DeviceLike = ...,
-        kind: None = ...,
-    ) -> _DTypes: ...
-    @overload
-    def dtypes(
-        self,
-        *,
-        device: _DeviceLike = ...,
-        kind: _Permute1[_KindBool],
-    ) -> _DTypesBool: ...
-    @overload
-    def dtypes(
-        self,
-        *,
-        device: _DeviceLike = ...,
-        kind: _Permute1[_KindInt],
-    ) -> _DTypesInt: ...
-    @overload
-    def dtypes(
-        self,
-        *,
-        device: _DeviceLike = ...,
-        kind: _Permute1[_KindUInt],
-    ) -> _DTypesUInt: ...
-    @overload
-    def dtypes(
-        self,
-        *,
-        device: _DeviceLike = ...,
-        kind: _Permute1[_KindFloat],
-    ) -> _DTypesFloat: ...
-    @overload
-    def dtypes(
-        self,
-        *,
-        device: _DeviceLike = ...,
-        kind: _Permute1[_KindComplex],
-    ) -> _DTypesComplex: ...
-    @overload
-    def dtypes(
-        self,
-        *,
-        device: _DeviceLike = ...,
-        kind: (
-            _Permute1[_KindInteger]
-            | _Permute2[_KindInt, _KindUInt]
-        ),
-    ) -> _DTypesInteger: ...
-    @overload
-    def dtypes(
-        self,
-        *,
-        device: _DeviceLike = ...,
-        kind: (
-            _Permute1[_KindNumber]
-            | _Permute3[_KindInteger, _KindFloat, _KindComplex]
-        ),
-    ) -> _DTypesNumber: ...
-    @overload
-    def dtypes(
-        self,
-        *,
-        device: _DeviceLike = ...,
-        kind: tuple[()],
-    ) -> _EmptyDict: ...
-    @overload
-    def dtypes(
-        self,
-        *,
-        device: _DeviceLike = ...,
-        kind: tuple[_Kind, ...],
-    ) -> _DTypesUnion: ...

.venv/Lib/site-packages/numpy/_configtool.py

@@ -1,39 +0,0 @@
-import argparse
-import sys
-from pathlib import Path
-
-from .lib._utils_impl import get_include
-from .version import __version__
-
-
-def main() -> None:
-    parser = argparse.ArgumentParser()
-    parser.add_argument(
-        "--version",
-        action="version",
-        version=__version__,
-        help="Print the version and exit.",
-    )
-    parser.add_argument(
-        "--cflags",
-        action="store_true",
-        help="Compile flag needed when using the NumPy headers.",
-    )
-    parser.add_argument(
-        "--pkgconfigdir",
-        action="store_true",
-        help=("Print the pkgconfig directory in which `numpy.pc` is stored "
-              "(useful for setting $PKG_CONFIG_PATH)."),
-    )
-    args = parser.parse_args()
-    if not sys.argv[1:]:
-        parser.print_help()
-    if args.cflags:
-        print("-I" + get_include())
-    if args.pkgconfigdir:
-        _path = Path(get_include()) / '..' / 'lib' / 'pkgconfig'
-        print(_path.resolve())
-
-
-if __name__ == "__main__":
-    main()

.venv/Lib/site-packages/numpy/_configtool.pyi

@@ -1 +0,0 @@
-def main() -> None: ...

.venv/Lib/site-packages/numpy/_core/__init__.py

@@ -1,186 +0,0 @@
-"""
-Contains the core of NumPy: ndarray, ufuncs, dtypes, etc.
-
-Please note that this module is private.  All functions and objects
-are available in the main ``numpy`` namespace - use that instead.
-
-"""
-
-import os
-
-from numpy.version import version as __version__
-
-# disables OpenBLAS affinity setting of the main thread that limits
-# python threads or processes to one core
-env_added = []
-for envkey in ['OPENBLAS_MAIN_FREE', 'GOTOBLAS_MAIN_FREE']:
-    if envkey not in os.environ:
-        os.environ[envkey] = '1'
-        env_added.append(envkey)
-
-try:
-    from . import multiarray
-except ImportError as exc:
-    import sys
-    msg = """
-
-IMPORTANT: PLEASE READ THIS FOR ADVICE ON HOW TO SOLVE THIS ISSUE!
-
-Importing the numpy C-extensions failed. This error can happen for
-many reasons, often due to issues with your setup or how NumPy was
-installed.
-
-We have compiled some common reasons and troubleshooting tips at:
-
-    https://numpy.org/devdocs/user/troubleshooting-importerror.html
-
-Please note and check the following:
-
-  * The Python version is: Python%d.%d from "%s"
-  * The NumPy version is: "%s"
-
-and make sure that they are the versions you expect.
-Please carefully study the documentation linked above for further help.
-
-Original error was: %s
-""" % (sys.version_info[0], sys.version_info[1], sys.executable,
-        __version__, exc)
-    raise ImportError(msg) from exc
-finally:
-    for envkey in env_added:
-        del os.environ[envkey]
-del envkey
-del env_added
-del os
-
-from . import umath
-
-# Check that multiarray,umath are pure python modules wrapping
-# _multiarray_umath and not either of the old c-extension modules
-if not (hasattr(multiarray, '_multiarray_umath') and
-        hasattr(umath, '_multiarray_umath')):
-    import sys
-    path = sys.modules['numpy'].__path__
-    msg = ("Something is wrong with the numpy installation. "
-        "While importing we detected an older version of "
-        "numpy in {}. One method of fixing this is to repeatedly uninstall "
-        "numpy until none is found, then reinstall this version.")
-    raise ImportError(msg.format(path))
-
-from . import numerictypes as nt
-from .numerictypes import sctypeDict, sctypes
-
-multiarray.set_typeDict(nt.sctypeDict)
-from . import (
-    _machar,
-    einsumfunc,
-    fromnumeric,
-    function_base,
-    getlimits,
-    numeric,
-    shape_base,
-)
-from .einsumfunc import *
-from .fromnumeric import *
-from .function_base import *
-from .getlimits import *
-
-# Note: module name memmap is overwritten by a class with same name
-from .memmap import *
-from .numeric import *
-from .records import recarray, record
-from .shape_base import *
-
-del nt
-
-# do this after everything else, to minimize the chance of this misleadingly
-# appearing in an import-time traceback
-# add these for module-freeze analysis (like PyInstaller)
-from . import (
-    _add_newdocs,
-    _add_newdocs_scalars,
-    _dtype,
-    _dtype_ctypes,
-    _internal,
-    _methods,
-)
-from .numeric import absolute as abs
-
-acos = numeric.arccos
-acosh = numeric.arccosh
-asin = numeric.arcsin
-asinh = numeric.arcsinh
-atan = numeric.arctan
-atanh = numeric.arctanh
-atan2 = numeric.arctan2
-concat = numeric.concatenate
-bitwise_left_shift = numeric.left_shift
-bitwise_invert = numeric.invert
-bitwise_right_shift = numeric.right_shift
-permute_dims = numeric.transpose
-pow = numeric.power
-
-__all__ = [
-    "abs", "acos", "acosh", "asin", "asinh", "atan", "atanh", "atan2",
-    "bitwise_invert", "bitwise_left_shift", "bitwise_right_shift", "concat",
-    "pow", "permute_dims", "memmap", "sctypeDict", "record", "recarray"
-]
-__all__ += numeric.__all__
-__all__ += function_base.__all__
-__all__ += getlimits.__all__
-__all__ += shape_base.__all__
-__all__ += einsumfunc.__all__
-
-
-def _ufunc_reduce(func):
-    # Report the `__name__`. pickle will try to find the module. Note that
-    # pickle supports for this `__name__` to be a `__qualname__`. It may
-    # make sense to add a `__qualname__` to ufuncs, to allow this more
-    # explicitly (Numba has ufuncs as attributes).
-    # See also: https://github.com/dask/distributed/issues/3450
-    return func.__name__
-
-
-def _DType_reconstruct(scalar_type):
-    # This is a work-around to pickle type(np.dtype(np.float64)), etc.
-    # and it should eventually be replaced with a better solution, e.g. when
-    # DTypes become HeapTypes.
-    return type(dtype(scalar_type))
-
-
-def _DType_reduce(DType):
-    # As types/classes, most DTypes can simply be pickled by their name:
-    if not DType._legacy or DType.__module__ == "numpy.dtypes":
-        return DType.__name__
-
-    # However, user defined legacy dtypes (like rational) do not end up in
-    # `numpy.dtypes` as module and do not have a public class at all.
-    # For these, we pickle them by reconstructing them from the scalar type:
-    scalar_type = DType.type
-    return _DType_reconstruct, (scalar_type,)
-
-
-def __getattr__(name):
-    # Deprecated 2022-11-22, NumPy 1.25.
-    if name == "MachAr":
-        import warnings
-        warnings.warn(
-            "The `np._core.MachAr` is considered private API (NumPy 1.24)",
-            DeprecationWarning, stacklevel=2,
-        )
-        return _machar.MachAr
-    raise AttributeError(f"Module {__name__!r} has no attribute {name!r}")
-
-
-import copyreg
-
-copyreg.pickle(ufunc, _ufunc_reduce)
-copyreg.pickle(type(dtype), _DType_reduce, _DType_reconstruct)
-
-# Unclutter namespace (must keep _*_reconstruct for unpickling)
-del copyreg, _ufunc_reduce, _DType_reduce
-
-from numpy._pytesttester import PytestTester
-
-test = PytestTester(__name__)
-del PytestTester

.venv/Lib/site-packages/numpy/_core/__init__.pyi

@@ -1,2 +0,0 @@
-# NOTE: The `np._core` namespace is deliberately kept empty due to it
-# being private