diff --git a/.gitattributes b/.gitattributes index 5626fa7118fe063b5fc82d54aa2c0b69651c323b..f66af179c1fb2419a1fc3b86babebe69c08b9a5c 100644 --- a/.gitattributes +++ b/.gitattributes @@ -273,3 +273,9 @@ my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/h5py/h5l.cp my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/torchvision.libs/libpng16.7f72a3c5.so.16 filter=lfs diff=lfs merge=lfs -text my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/h5py/_errors.cpython-38-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/matplotlib/_path.cpython-38-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text +my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/torchaudio/_torchaudio_decoder.so filter=lfs diff=lfs merge=lfs -text +my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/h5py/h5a.cpython-38-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text +my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/h5py/h5p.cpython-38-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text +my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/h5py/h5i.cpython-38-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text +my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/h5py/_conv.cpython-38-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text +my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/zstandard/_cffi.cpython-38-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/PySocks-1.7.1.dist-info/INSTALLER b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/PySocks-1.7.1.dist-info/INSTALLER new file mode 100644 index 0000000000000000000000000000000000000000..f79e4cb9aaf0b2d9e8ba78861e2071317b2384b3 --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/PySocks-1.7.1.dist-info/INSTALLER @@ -0,0 +1 @@ +conda \ No newline at end of file diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/attr/__init__.py b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/attr/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f95c96dd5795b9c958adfebbd36ffad99cf23cc9 --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/attr/__init__.py @@ -0,0 +1,80 @@ +# SPDX-License-Identifier: MIT + +from __future__ import absolute_import, division, print_function + +import sys + +from functools import partial + +from . import converters, exceptions, filters, setters, validators +from ._cmp import cmp_using +from ._config import get_run_validators, set_run_validators +from ._funcs import asdict, assoc, astuple, evolve, has, resolve_types +from ._make import ( + NOTHING, + Attribute, + Factory, + attrib, + attrs, + fields, + fields_dict, + make_class, + validate, +) +from ._version_info import VersionInfo + + +__version__ = "21.4.0" +__version_info__ = VersionInfo._from_version_string(__version__) + +__title__ = "attrs" +__description__ = "Classes Without Boilerplate" +__url__ = "https://www.attrs.org/" +__uri__ = __url__ +__doc__ = __description__ + " <" + __uri__ + ">" + +__author__ = "Hynek Schlawack" +__email__ = "hs@ox.cx" + +__license__ = "MIT" +__copyright__ = "Copyright (c) 2015 Hynek Schlawack" + + +s = attributes = attrs +ib = attr = attrib +dataclass = partial(attrs, auto_attribs=True) # happy Easter ;) + +__all__ = [ + "Attribute", + "Factory", + "NOTHING", + "asdict", + "assoc", + "astuple", + "attr", + "attrib", + "attributes", + "attrs", + "cmp_using", + "converters", + "evolve", + "exceptions", + "fields", + "fields_dict", + "filters", + "get_run_validators", + "has", + "ib", + "make_class", + "resolve_types", + "s", + "set_run_validators", + "setters", + "validate", + "validators", +] + +if sys.version_info[:2] >= (3, 6): + from ._next_gen import define, field, frozen, mutable # noqa: F401 + + __all__.extend(("define", "field", "frozen", "mutable")) diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/attr/_cmp.py b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/attr/_cmp.py new file mode 100644 index 0000000000000000000000000000000000000000..6cffa4dbabda22d3f2921af3d66456006a382b32 --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/attr/_cmp.py @@ -0,0 +1,154 @@ +# SPDX-License-Identifier: MIT + +from __future__ import absolute_import, division, print_function + +import functools + +from ._compat import new_class +from ._make import _make_ne + + +_operation_names = {"eq": "==", "lt": "<", "le": "<=", "gt": ">", "ge": ">="} + + +def cmp_using( + eq=None, + lt=None, + le=None, + gt=None, + ge=None, + require_same_type=True, + class_name="Comparable", +): + """ + Create a class that can be passed into `attr.ib`'s ``eq``, ``order``, and + ``cmp`` arguments to customize field comparison. + + The resulting class will have a full set of ordering methods if + at least one of ``{lt, le, gt, ge}`` and ``eq`` are provided. + + :param Optional[callable] eq: `callable` used to evaluate equality + of two objects. + :param Optional[callable] lt: `callable` used to evaluate whether + one object is less than another object. + :param Optional[callable] le: `callable` used to evaluate whether + one object is less than or equal to another object. + :param Optional[callable] gt: `callable` used to evaluate whether + one object is greater than another object. + :param Optional[callable] ge: `callable` used to evaluate whether + one object is greater than or equal to another object. + + :param bool require_same_type: When `True`, equality and ordering methods + will return `NotImplemented` if objects are not of the same type. + + :param Optional[str] class_name: Name of class. Defaults to 'Comparable'. + + See `comparison` for more details. + + .. versionadded:: 21.1.0 + """ + + body = { + "__slots__": ["value"], + "__init__": _make_init(), + "_requirements": [], + "_is_comparable_to": _is_comparable_to, + } + + # Add operations. + num_order_functions = 0 + has_eq_function = False + + if eq is not None: + has_eq_function = True + body["__eq__"] = _make_operator("eq", eq) + body["__ne__"] = _make_ne() + + if lt is not None: + num_order_functions += 1 + body["__lt__"] = _make_operator("lt", lt) + + if le is not None: + num_order_functions += 1 + body["__le__"] = _make_operator("le", le) + + if gt is not None: + num_order_functions += 1 + body["__gt__"] = _make_operator("gt", gt) + + if ge is not None: + num_order_functions += 1 + body["__ge__"] = _make_operator("ge", ge) + + type_ = new_class(class_name, (object,), {}, lambda ns: ns.update(body)) + + # Add same type requirement. + if require_same_type: + type_._requirements.append(_check_same_type) + + # Add total ordering if at least one operation was defined. + if 0 < num_order_functions < 4: + if not has_eq_function: + # functools.total_ordering requires __eq__ to be defined, + # so raise early error here to keep a nice stack. + raise ValueError( + "eq must be define is order to complete ordering from " + "lt, le, gt, ge." + ) + type_ = functools.total_ordering(type_) + + return type_ + + +def _make_init(): + """ + Create __init__ method. + """ + + def __init__(self, value): + """ + Initialize object with *value*. + """ + self.value = value + + return __init__ + + +def _make_operator(name, func): + """ + Create operator method. + """ + + def method(self, other): + if not self._is_comparable_to(other): + return NotImplemented + + result = func(self.value, other.value) + if result is NotImplemented: + return NotImplemented + + return result + + method.__name__ = "__%s__" % (name,) + method.__doc__ = "Return a %s b. Computed by attrs." % ( + _operation_names[name], + ) + + return method + + +def _is_comparable_to(self, other): + """ + Check whether `other` is comparable to `self`. + """ + for func in self._requirements: + if not func(self, other): + return False + return True + + +def _check_same_type(self, other): + """ + Return True if *self* and *other* are of the same type, False otherwise. + """ + return other.value.__class__ is self.value.__class__ diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/attr/_compat.py b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/attr/_compat.py new file mode 100644 index 0000000000000000000000000000000000000000..dc0cb02b6435bb4cb90f1d9645150d32286379a5 --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/attr/_compat.py @@ -0,0 +1,261 @@ +# SPDX-License-Identifier: MIT + +from __future__ import absolute_import, division, print_function + +import platform +import sys +import threading +import types +import warnings + + +PY2 = sys.version_info[0] == 2 +PYPY = platform.python_implementation() == "PyPy" +PY36 = sys.version_info[:2] >= (3, 6) +HAS_F_STRINGS = PY36 +PY310 = sys.version_info[:2] >= (3, 10) + + +if PYPY or PY36: + ordered_dict = dict +else: + from collections import OrderedDict + + ordered_dict = OrderedDict + + +if PY2: + from collections import Mapping, Sequence + + from UserDict import IterableUserDict + + # We 'bundle' isclass instead of using inspect as importing inspect is + # fairly expensive (order of 10-15 ms for a modern machine in 2016) + def isclass(klass): + return isinstance(klass, (type, types.ClassType)) + + def new_class(name, bases, kwds, exec_body): + """ + A minimal stub of types.new_class that we need for make_class. + """ + ns = {} + exec_body(ns) + + return type(name, bases, ns) + + # TYPE is used in exceptions, repr(int) is different on Python 2 and 3. + TYPE = "type" + + def iteritems(d): + return d.iteritems() + + # Python 2 is bereft of a read-only dict proxy, so we make one! + class ReadOnlyDict(IterableUserDict): + """ + Best-effort read-only dict wrapper. + """ + + def __setitem__(self, key, val): + # We gently pretend we're a Python 3 mappingproxy. + raise TypeError( + "'mappingproxy' object does not support item assignment" + ) + + def update(self, _): + # We gently pretend we're a Python 3 mappingproxy. + raise AttributeError( + "'mappingproxy' object has no attribute 'update'" + ) + + def __delitem__(self, _): + # We gently pretend we're a Python 3 mappingproxy. + raise TypeError( + "'mappingproxy' object does not support item deletion" + ) + + def clear(self): + # We gently pretend we're a Python 3 mappingproxy. + raise AttributeError( + "'mappingproxy' object has no attribute 'clear'" + ) + + def pop(self, key, default=None): + # We gently pretend we're a Python 3 mappingproxy. + raise AttributeError( + "'mappingproxy' object has no attribute 'pop'" + ) + + def popitem(self): + # We gently pretend we're a Python 3 mappingproxy. + raise AttributeError( + "'mappingproxy' object has no attribute 'popitem'" + ) + + def setdefault(self, key, default=None): + # We gently pretend we're a Python 3 mappingproxy. + raise AttributeError( + "'mappingproxy' object has no attribute 'setdefault'" + ) + + def __repr__(self): + # Override to be identical to the Python 3 version. + return "mappingproxy(" + repr(self.data) + ")" + + def metadata_proxy(d): + res = ReadOnlyDict() + res.data.update(d) # We blocked update, so we have to do it like this. + return res + + def just_warn(*args, **kw): # pragma: no cover + """ + We only warn on Python 3 because we are not aware of any concrete + consequences of not setting the cell on Python 2. + """ + +else: # Python 3 and later. + from collections.abc import Mapping, Sequence # noqa + + def just_warn(*args, **kw): + """ + We only warn on Python 3 because we are not aware of any concrete + consequences of not setting the cell on Python 2. + """ + warnings.warn( + "Running interpreter doesn't sufficiently support code object " + "introspection. Some features like bare super() or accessing " + "__class__ will not work with slotted classes.", + RuntimeWarning, + stacklevel=2, + ) + + def isclass(klass): + return isinstance(klass, type) + + TYPE = "class" + + def iteritems(d): + return d.items() + + new_class = types.new_class + + def metadata_proxy(d): + return types.MappingProxyType(dict(d)) + + +def make_set_closure_cell(): + """Return a function of two arguments (cell, value) which sets + the value stored in the closure cell `cell` to `value`. + """ + # pypy makes this easy. (It also supports the logic below, but + # why not do the easy/fast thing?) + if PYPY: + + def set_closure_cell(cell, value): + cell.__setstate__((value,)) + + return set_closure_cell + + # Otherwise gotta do it the hard way. + + # Create a function that will set its first cellvar to `value`. + def set_first_cellvar_to(value): + x = value + return + + # This function will be eliminated as dead code, but + # not before its reference to `x` forces `x` to be + # represented as a closure cell rather than a local. + def force_x_to_be_a_cell(): # pragma: no cover + return x + + try: + # Extract the code object and make sure our assumptions about + # the closure behavior are correct. + if PY2: + co = set_first_cellvar_to.func_code + else: + co = set_first_cellvar_to.__code__ + if co.co_cellvars != ("x",) or co.co_freevars != (): + raise AssertionError # pragma: no cover + + # Convert this code object to a code object that sets the + # function's first _freevar_ (not cellvar) to the argument. + if sys.version_info >= (3, 8): + # CPython 3.8+ has an incompatible CodeType signature + # (added a posonlyargcount argument) but also added + # CodeType.replace() to do this without counting parameters. + set_first_freevar_code = co.replace( + co_cellvars=co.co_freevars, co_freevars=co.co_cellvars + ) + else: + args = [co.co_argcount] + if not PY2: + args.append(co.co_kwonlyargcount) + args.extend( + [ + co.co_nlocals, + co.co_stacksize, + co.co_flags, + co.co_code, + co.co_consts, + co.co_names, + co.co_varnames, + co.co_filename, + co.co_name, + co.co_firstlineno, + co.co_lnotab, + # These two arguments are reversed: + co.co_cellvars, + co.co_freevars, + ] + ) + set_first_freevar_code = types.CodeType(*args) + + def set_closure_cell(cell, value): + # Create a function using the set_first_freevar_code, + # whose first closure cell is `cell`. Calling it will + # change the value of that cell. + setter = types.FunctionType( + set_first_freevar_code, {}, "setter", (), (cell,) + ) + # And call it to set the cell. + setter(value) + + # Make sure it works on this interpreter: + def make_func_with_cell(): + x = None + + def func(): + return x # pragma: no cover + + return func + + if PY2: + cell = make_func_with_cell().func_closure[0] + else: + cell = make_func_with_cell().__closure__[0] + set_closure_cell(cell, 100) + if cell.cell_contents != 100: + raise AssertionError # pragma: no cover + + except Exception: + return just_warn + else: + return set_closure_cell + + +set_closure_cell = make_set_closure_cell() + +# Thread-local global to track attrs instances which are already being repr'd. +# This is needed because there is no other (thread-safe) way to pass info +# about the instances that are already being repr'd through the call stack +# in order to ensure we don't perform infinite recursion. +# +# For instance, if an instance contains a dict which contains that instance, +# we need to know that we're already repr'ing the outside instance from within +# the dict's repr() call. +# +# This lives here rather than in _make.py so that the functions in _make.py +# don't have a direct reference to the thread-local in their globals dict. +# If they have such a reference, it breaks cloudpickle. +repr_context = threading.local() diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/attr/_funcs.py b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/attr/_funcs.py new file mode 100644 index 0000000000000000000000000000000000000000..4c90085a4013bf906a726597f52b206d4c842b22 --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/attr/_funcs.py @@ -0,0 +1,422 @@ +# SPDX-License-Identifier: MIT + +from __future__ import absolute_import, division, print_function + +import copy + +from ._compat import iteritems +from ._make import NOTHING, _obj_setattr, fields +from .exceptions import AttrsAttributeNotFoundError + + +def asdict( + inst, + recurse=True, + filter=None, + dict_factory=dict, + retain_collection_types=False, + value_serializer=None, +): + """ + Return the ``attrs`` attribute values of *inst* as a dict. + + Optionally recurse into other ``attrs``-decorated classes. + + :param inst: Instance of an ``attrs``-decorated class. + :param bool recurse: Recurse into classes that are also + ``attrs``-decorated. + :param callable filter: A callable whose return code determines whether an + attribute or element is included (``True``) or dropped (``False``). Is + called with the `attrs.Attribute` as the first argument and the + value as the second argument. + :param callable dict_factory: A callable to produce dictionaries from. For + example, to produce ordered dictionaries instead of normal Python + dictionaries, pass in ``collections.OrderedDict``. + :param bool retain_collection_types: Do not convert to ``list`` when + encountering an attribute whose type is ``tuple`` or ``set``. Only + meaningful if ``recurse`` is ``True``. + :param Optional[callable] value_serializer: A hook that is called for every + attribute or dict key/value. It receives the current instance, field + and value and must return the (updated) value. The hook is run *after* + the optional *filter* has been applied. + + :rtype: return type of *dict_factory* + + :raise attr.exceptions.NotAnAttrsClassError: If *cls* is not an ``attrs`` + class. + + .. versionadded:: 16.0.0 *dict_factory* + .. versionadded:: 16.1.0 *retain_collection_types* + .. versionadded:: 20.3.0 *value_serializer* + .. versionadded:: 21.3.0 If a dict has a collection for a key, it is + serialized as a tuple. + """ + attrs = fields(inst.__class__) + rv = dict_factory() + for a in attrs: + v = getattr(inst, a.name) + if filter is not None and not filter(a, v): + continue + + if value_serializer is not None: + v = value_serializer(inst, a, v) + + if recurse is True: + if has(v.__class__): + rv[a.name] = asdict( + v, + recurse=True, + filter=filter, + dict_factory=dict_factory, + retain_collection_types=retain_collection_types, + value_serializer=value_serializer, + ) + elif isinstance(v, (tuple, list, set, frozenset)): + cf = v.__class__ if retain_collection_types is True else list + rv[a.name] = cf( + [ + _asdict_anything( + i, + is_key=False, + filter=filter, + dict_factory=dict_factory, + retain_collection_types=retain_collection_types, + value_serializer=value_serializer, + ) + for i in v + ] + ) + elif isinstance(v, dict): + df = dict_factory + rv[a.name] = df( + ( + _asdict_anything( + kk, + is_key=True, + filter=filter, + dict_factory=df, + retain_collection_types=retain_collection_types, + value_serializer=value_serializer, + ), + _asdict_anything( + vv, + is_key=False, + filter=filter, + dict_factory=df, + retain_collection_types=retain_collection_types, + value_serializer=value_serializer, + ), + ) + for kk, vv in iteritems(v) + ) + else: + rv[a.name] = v + else: + rv[a.name] = v + return rv + + +def _asdict_anything( + val, + is_key, + filter, + dict_factory, + retain_collection_types, + value_serializer, +): + """ + ``asdict`` only works on attrs instances, this works on anything. + """ + if getattr(val.__class__, "__attrs_attrs__", None) is not None: + # Attrs class. + rv = asdict( + val, + recurse=True, + filter=filter, + dict_factory=dict_factory, + retain_collection_types=retain_collection_types, + value_serializer=value_serializer, + ) + elif isinstance(val, (tuple, list, set, frozenset)): + if retain_collection_types is True: + cf = val.__class__ + elif is_key: + cf = tuple + else: + cf = list + + rv = cf( + [ + _asdict_anything( + i, + is_key=False, + filter=filter, + dict_factory=dict_factory, + retain_collection_types=retain_collection_types, + value_serializer=value_serializer, + ) + for i in val + ] + ) + elif isinstance(val, dict): + df = dict_factory + rv = df( + ( + _asdict_anything( + kk, + is_key=True, + filter=filter, + dict_factory=df, + retain_collection_types=retain_collection_types, + value_serializer=value_serializer, + ), + _asdict_anything( + vv, + is_key=False, + filter=filter, + dict_factory=df, + retain_collection_types=retain_collection_types, + value_serializer=value_serializer, + ), + ) + for kk, vv in iteritems(val) + ) + else: + rv = val + if value_serializer is not None: + rv = value_serializer(None, None, rv) + + return rv + + +def astuple( + inst, + recurse=True, + filter=None, + tuple_factory=tuple, + retain_collection_types=False, +): + """ + Return the ``attrs`` attribute values of *inst* as a tuple. + + Optionally recurse into other ``attrs``-decorated classes. + + :param inst: Instance of an ``attrs``-decorated class. + :param bool recurse: Recurse into classes that are also + ``attrs``-decorated. + :param callable filter: A callable whose return code determines whether an + attribute or element is included (``True``) or dropped (``False``). Is + called with the `attrs.Attribute` as the first argument and the + value as the second argument. + :param callable tuple_factory: A callable to produce tuples from. For + example, to produce lists instead of tuples. + :param bool retain_collection_types: Do not convert to ``list`` + or ``dict`` when encountering an attribute which type is + ``tuple``, ``dict`` or ``set``. Only meaningful if ``recurse`` is + ``True``. + + :rtype: return type of *tuple_factory* + + :raise attr.exceptions.NotAnAttrsClassError: If *cls* is not an ``attrs`` + class. + + .. versionadded:: 16.2.0 + """ + attrs = fields(inst.__class__) + rv = [] + retain = retain_collection_types # Very long. :/ + for a in attrs: + v = getattr(inst, a.name) + if filter is not None and not filter(a, v): + continue + if recurse is True: + if has(v.__class__): + rv.append( + astuple( + v, + recurse=True, + filter=filter, + tuple_factory=tuple_factory, + retain_collection_types=retain, + ) + ) + elif isinstance(v, (tuple, list, set, frozenset)): + cf = v.__class__ if retain is True else list + rv.append( + cf( + [ + astuple( + j, + recurse=True, + filter=filter, + tuple_factory=tuple_factory, + retain_collection_types=retain, + ) + if has(j.__class__) + else j + for j in v + ] + ) + ) + elif isinstance(v, dict): + df = v.__class__ if retain is True else dict + rv.append( + df( + ( + astuple( + kk, + tuple_factory=tuple_factory, + retain_collection_types=retain, + ) + if has(kk.__class__) + else kk, + astuple( + vv, + tuple_factory=tuple_factory, + retain_collection_types=retain, + ) + if has(vv.__class__) + else vv, + ) + for kk, vv in iteritems(v) + ) + ) + else: + rv.append(v) + else: + rv.append(v) + + return rv if tuple_factory is list else tuple_factory(rv) + + +def has(cls): + """ + Check whether *cls* is a class with ``attrs`` attributes. + + :param type cls: Class to introspect. + :raise TypeError: If *cls* is not a class. + + :rtype: bool + """ + return getattr(cls, "__attrs_attrs__", None) is not None + + +def assoc(inst, **changes): + """ + Copy *inst* and apply *changes*. + + :param inst: Instance of a class with ``attrs`` attributes. + :param changes: Keyword changes in the new copy. + + :return: A copy of inst with *changes* incorporated. + + :raise attr.exceptions.AttrsAttributeNotFoundError: If *attr_name* couldn't + be found on *cls*. + :raise attr.exceptions.NotAnAttrsClassError: If *cls* is not an ``attrs`` + class. + + .. deprecated:: 17.1.0 + Use `attrs.evolve` instead if you can. + This function will not be removed du to the slightly different approach + compared to `attrs.evolve`. + """ + import warnings + + warnings.warn( + "assoc is deprecated and will be removed after 2018/01.", + DeprecationWarning, + stacklevel=2, + ) + new = copy.copy(inst) + attrs = fields(inst.__class__) + for k, v in iteritems(changes): + a = getattr(attrs, k, NOTHING) + if a is NOTHING: + raise AttrsAttributeNotFoundError( + "{k} is not an attrs attribute on {cl}.".format( + k=k, cl=new.__class__ + ) + ) + _obj_setattr(new, k, v) + return new + + +def evolve(inst, **changes): + """ + Create a new instance, based on *inst* with *changes* applied. + + :param inst: Instance of a class with ``attrs`` attributes. + :param changes: Keyword changes in the new copy. + + :return: A copy of inst with *changes* incorporated. + + :raise TypeError: If *attr_name* couldn't be found in the class + ``__init__``. + :raise attr.exceptions.NotAnAttrsClassError: If *cls* is not an ``attrs`` + class. + + .. versionadded:: 17.1.0 + """ + cls = inst.__class__ + attrs = fields(cls) + for a in attrs: + if not a.init: + continue + attr_name = a.name # To deal with private attributes. + init_name = attr_name if attr_name[0] != "_" else attr_name[1:] + if init_name not in changes: + changes[init_name] = getattr(inst, attr_name) + + return cls(**changes) + + +def resolve_types(cls, globalns=None, localns=None, attribs=None): + """ + Resolve any strings and forward annotations in type annotations. + + This is only required if you need concrete types in `Attribute`'s *type* + field. In other words, you don't need to resolve your types if you only + use them for static type checking. + + With no arguments, names will be looked up in the module in which the class + was created. If this is not what you want, e.g. if the name only exists + inside a method, you may pass *globalns* or *localns* to specify other + dictionaries in which to look up these names. See the docs of + `typing.get_type_hints` for more details. + + :param type cls: Class to resolve. + :param Optional[dict] globalns: Dictionary containing global variables. + :param Optional[dict] localns: Dictionary containing local variables. + :param Optional[list] attribs: List of attribs for the given class. + This is necessary when calling from inside a ``field_transformer`` + since *cls* is not an ``attrs`` class yet. + + :raise TypeError: If *cls* is not a class. + :raise attr.exceptions.NotAnAttrsClassError: If *cls* is not an ``attrs`` + class and you didn't pass any attribs. + :raise NameError: If types cannot be resolved because of missing variables. + + :returns: *cls* so you can use this function also as a class decorator. + Please note that you have to apply it **after** `attrs.define`. That + means the decorator has to come in the line **before** `attrs.define`. + + .. versionadded:: 20.1.0 + .. versionadded:: 21.1.0 *attribs* + + """ + # Since calling get_type_hints is expensive we cache whether we've + # done it already. + if getattr(cls, "__attrs_types_resolved__", None) != cls: + import typing + + hints = typing.get_type_hints(cls, globalns=globalns, localns=localns) + for field in fields(cls) if attribs is None else attribs: + if field.name in hints: + # Since fields have been frozen we must work around it. + _obj_setattr(field, "type", hints[field.name]) + # We store the class we resolved so that subclasses know they haven't + # been resolved. + cls.__attrs_types_resolved__ = cls + + # Return the class so you can use it as a decorator too. + return cls diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/attr/_next_gen.py b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/attr/_next_gen.py new file mode 100644 index 0000000000000000000000000000000000000000..068253688caf890fa997fa81bfed38cbeffd4c45 --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/attr/_next_gen.py @@ -0,0 +1,216 @@ +# SPDX-License-Identifier: MIT + +""" +These are Python 3.6+-only and keyword-only APIs that call `attr.s` and +`attr.ib` with different default values. +""" + + +from functools import partial + +from . import setters +from ._funcs import asdict as _asdict +from ._funcs import astuple as _astuple +from ._make import ( + NOTHING, + _frozen_setattrs, + _ng_default_on_setattr, + attrib, + attrs, +) +from .exceptions import UnannotatedAttributeError + + +def define( + maybe_cls=None, + *, + these=None, + repr=None, + hash=None, + init=None, + slots=True, + frozen=False, + weakref_slot=True, + str=False, + auto_attribs=None, + kw_only=False, + cache_hash=False, + auto_exc=True, + eq=None, + order=False, + auto_detect=True, + getstate_setstate=None, + on_setattr=None, + field_transformer=None, + match_args=True, +): + r""" + Define an ``attrs`` class. + + Differences to the classic `attr.s` that it uses underneath: + + - Automatically detect whether or not *auto_attribs* should be `True` + (c.f. *auto_attribs* parameter). + - If *frozen* is `False`, run converters and validators when setting an + attribute by default. + - *slots=True* (see :term:`slotted classes` for potentially surprising + behaviors) + - *auto_exc=True* + - *auto_detect=True* + - *order=False* + - *match_args=True* + - Some options that were only relevant on Python 2 or were kept around for + backwards-compatibility have been removed. + + Please note that these are all defaults and you can change them as you + wish. + + :param Optional[bool] auto_attribs: If set to `True` or `False`, it behaves + exactly like `attr.s`. If left `None`, `attr.s` will try to guess: + + 1. If any attributes are annotated and no unannotated `attrs.fields`\ s + are found, it assumes *auto_attribs=True*. + 2. Otherwise it assumes *auto_attribs=False* and tries to collect + `attrs.fields`\ s. + + For now, please refer to `attr.s` for the rest of the parameters. + + .. versionadded:: 20.1.0 + .. versionchanged:: 21.3.0 Converters are also run ``on_setattr``. + """ + + def do_it(cls, auto_attribs): + return attrs( + maybe_cls=cls, + these=these, + repr=repr, + hash=hash, + init=init, + slots=slots, + frozen=frozen, + weakref_slot=weakref_slot, + str=str, + auto_attribs=auto_attribs, + kw_only=kw_only, + cache_hash=cache_hash, + auto_exc=auto_exc, + eq=eq, + order=order, + auto_detect=auto_detect, + collect_by_mro=True, + getstate_setstate=getstate_setstate, + on_setattr=on_setattr, + field_transformer=field_transformer, + match_args=match_args, + ) + + def wrap(cls): + """ + Making this a wrapper ensures this code runs during class creation. + + We also ensure that frozen-ness of classes is inherited. + """ + nonlocal frozen, on_setattr + + had_on_setattr = on_setattr not in (None, setters.NO_OP) + + # By default, mutable classes convert & validate on setattr. + if frozen is False and on_setattr is None: + on_setattr = _ng_default_on_setattr + + # However, if we subclass a frozen class, we inherit the immutability + # and disable on_setattr. + for base_cls in cls.__bases__: + if base_cls.__setattr__ is _frozen_setattrs: + if had_on_setattr: + raise ValueError( + "Frozen classes can't use on_setattr " + "(frozen-ness was inherited)." + ) + + on_setattr = setters.NO_OP + break + + if auto_attribs is not None: + return do_it(cls, auto_attribs) + + try: + return do_it(cls, True) + except UnannotatedAttributeError: + return do_it(cls, False) + + # maybe_cls's type depends on the usage of the decorator. It's a class + # if it's used as `@attrs` but ``None`` if used as `@attrs()`. + if maybe_cls is None: + return wrap + else: + return wrap(maybe_cls) + + +mutable = define +frozen = partial(define, frozen=True, on_setattr=None) + + +def field( + *, + default=NOTHING, + validator=None, + repr=True, + hash=None, + init=True, + metadata=None, + converter=None, + factory=None, + kw_only=False, + eq=None, + order=None, + on_setattr=None, +): + """ + Identical to `attr.ib`, except keyword-only and with some arguments + removed. + + .. versionadded:: 20.1.0 + """ + return attrib( + default=default, + validator=validator, + repr=repr, + hash=hash, + init=init, + metadata=metadata, + converter=converter, + factory=factory, + kw_only=kw_only, + eq=eq, + order=order, + on_setattr=on_setattr, + ) + + +def asdict(inst, *, recurse=True, filter=None, value_serializer=None): + """ + Same as `attr.asdict`, except that collections types are always retained + and dict is always used as *dict_factory*. + + .. versionadded:: 21.3.0 + """ + return _asdict( + inst=inst, + recurse=recurse, + filter=filter, + value_serializer=value_serializer, + retain_collection_types=True, + ) + + +def astuple(inst, *, recurse=True, filter=None): + """ + Same as `attr.astuple`, except that collections types are always retained + and `tuple` is always used as the *tuple_factory*. + + .. versionadded:: 21.3.0 + """ + return _astuple( + inst=inst, recurse=recurse, filter=filter, retain_collection_types=True + ) diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/attr/_version_info.py b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/attr/_version_info.py new file mode 100644 index 0000000000000000000000000000000000000000..cdaeec37a1ad988cafb7e202967f48829c9d85ba --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/attr/_version_info.py @@ -0,0 +1,87 @@ +# SPDX-License-Identifier: MIT + +from __future__ import absolute_import, division, print_function + +from functools import total_ordering + +from ._funcs import astuple +from ._make import attrib, attrs + + +@total_ordering +@attrs(eq=False, order=False, slots=True, frozen=True) +class VersionInfo(object): + """ + A version object that can be compared to tuple of length 1--4: + + >>> attr.VersionInfo(19, 1, 0, "final") <= (19, 2) + True + >>> attr.VersionInfo(19, 1, 0, "final") < (19, 1, 1) + True + >>> vi = attr.VersionInfo(19, 2, 0, "final") + >>> vi < (19, 1, 1) + False + >>> vi < (19,) + False + >>> vi == (19, 2,) + True + >>> vi == (19, 2, 1) + False + + .. versionadded:: 19.2 + """ + + year = attrib(type=int) + minor = attrib(type=int) + micro = attrib(type=int) + releaselevel = attrib(type=str) + + @classmethod + def _from_version_string(cls, s): + """ + Parse *s* and return a _VersionInfo. + """ + v = s.split(".") + if len(v) == 3: + v.append("final") + + return cls( + year=int(v[0]), minor=int(v[1]), micro=int(v[2]), releaselevel=v[3] + ) + + def _ensure_tuple(self, other): + """ + Ensure *other* is a tuple of a valid length. + + Returns a possibly transformed *other* and ourselves as a tuple of + the same length as *other*. + """ + + if self.__class__ is other.__class__: + other = astuple(other) + + if not isinstance(other, tuple): + raise NotImplementedError + + if not (1 <= len(other) <= 4): + raise NotImplementedError + + return astuple(self)[: len(other)], other + + def __eq__(self, other): + try: + us, them = self._ensure_tuple(other) + except NotImplementedError: + return NotImplemented + + return us == them + + def __lt__(self, other): + try: + us, them = self._ensure_tuple(other) + except NotImplementedError: + return NotImplemented + + # Since alphabetically "dev0" < "final" < "post1" < "post2", we don't + # have to do anything special with releaselevel for now. + return us < them diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/attr/_version_info.pyi b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/attr/_version_info.pyi new file mode 100644 index 0000000000000000000000000000000000000000..45ced086337783c4b73b26cd17d2c1c260e24029 --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/attr/_version_info.pyi @@ -0,0 +1,9 @@ +class VersionInfo: + @property + def year(self) -> int: ... + @property + def minor(self) -> int: ... + @property + def micro(self) -> int: ... + @property + def releaselevel(self) -> str: ... diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/attr/converters.pyi b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/attr/converters.pyi new file mode 100644 index 0000000000000000000000000000000000000000..0f58088a37be31f413c0adf04af32feff584b740 --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/attr/converters.pyi @@ -0,0 +1,13 @@ +from typing import Callable, Optional, TypeVar, overload + +from . import _ConverterType + +_T = TypeVar("_T") + +def pipe(*validators: _ConverterType) -> _ConverterType: ... +def optional(converter: _ConverterType) -> _ConverterType: ... +@overload +def default_if_none(default: _T) -> _ConverterType: ... +@overload +def default_if_none(*, factory: Callable[[], _T]) -> _ConverterType: ... +def to_bool(val: str) -> bool: ... diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/attr/exceptions.py b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/attr/exceptions.py new file mode 100644 index 0000000000000000000000000000000000000000..b2f1edc32a941b3f05c708af43f5a1b284b72fc9 --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/attr/exceptions.py @@ -0,0 +1,94 @@ +# SPDX-License-Identifier: MIT + +from __future__ import absolute_import, division, print_function + + +class FrozenError(AttributeError): + """ + A frozen/immutable instance or attribute have been attempted to be + modified. + + It mirrors the behavior of ``namedtuples`` by using the same error message + and subclassing `AttributeError`. + + .. versionadded:: 20.1.0 + """ + + msg = "can't set attribute" + args = [msg] + + +class FrozenInstanceError(FrozenError): + """ + A frozen instance has been attempted to be modified. + + .. versionadded:: 16.1.0 + """ + + +class FrozenAttributeError(FrozenError): + """ + A frozen attribute has been attempted to be modified. + + .. versionadded:: 20.1.0 + """ + + +class AttrsAttributeNotFoundError(ValueError): + """ + An ``attrs`` function couldn't find an attribute that the user asked for. + + .. versionadded:: 16.2.0 + """ + + +class NotAnAttrsClassError(ValueError): + """ + A non-``attrs`` class has been passed into an ``attrs`` function. + + .. versionadded:: 16.2.0 + """ + + +class DefaultAlreadySetError(RuntimeError): + """ + A default has been set using ``attr.ib()`` and is attempted to be reset + using the decorator. + + .. versionadded:: 17.1.0 + """ + + +class UnannotatedAttributeError(RuntimeError): + """ + A class with ``auto_attribs=True`` has an ``attr.ib()`` without a type + annotation. + + .. versionadded:: 17.3.0 + """ + + +class PythonTooOldError(RuntimeError): + """ + It was attempted to use an ``attrs`` feature that requires a newer Python + version. + + .. versionadded:: 18.2.0 + """ + + +class NotCallableError(TypeError): + """ + A ``attr.ib()`` requiring a callable has been set with a value + that is not callable. + + .. versionadded:: 19.2.0 + """ + + def __init__(self, msg, value): + super(TypeError, self).__init__(msg, value) + self.msg = msg + self.value = value + + def __str__(self): + return str(self.msg) diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/attr/filters.py b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/attr/filters.py new file mode 100644 index 0000000000000000000000000000000000000000..a1978a87755ba454296a789161d044d2d51d10e0 --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/attr/filters.py @@ -0,0 +1,54 @@ +# SPDX-License-Identifier: MIT + +""" +Commonly useful filters for `attr.asdict`. +""" + +from __future__ import absolute_import, division, print_function + +from ._compat import isclass +from ._make import Attribute + + +def _split_what(what): + """ + Returns a tuple of `frozenset`s of classes and attributes. + """ + return ( + frozenset(cls for cls in what if isclass(cls)), + frozenset(cls for cls in what if isinstance(cls, Attribute)), + ) + + +def include(*what): + """ + Include *what*. + + :param what: What to include. + :type what: `list` of `type` or `attrs.Attribute`\\ s + + :rtype: `callable` + """ + cls, attrs = _split_what(what) + + def include_(attribute, value): + return value.__class__ in cls or attribute in attrs + + return include_ + + +def exclude(*what): + """ + Exclude *what*. + + :param what: What to exclude. + :type what: `list` of classes or `attrs.Attribute`\\ s. + + :rtype: `callable` + """ + cls, attrs = _split_what(what) + + def exclude_(attribute, value): + return value.__class__ not in cls and attribute not in attrs + + return exclude_ diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/attr/filters.pyi b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/attr/filters.pyi new file mode 100644 index 0000000000000000000000000000000000000000..993866865eab7ede46b6421c6f31c1e79c02fd6a --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/attr/filters.pyi @@ -0,0 +1,6 @@ +from typing import Any, Union + +from . import Attribute, _FilterType + +def include(*what: Union[type, Attribute[Any]]) -> _FilterType[Any]: ... +def exclude(*what: Union[type, Attribute[Any]]) -> _FilterType[Any]: ... diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/attr/py.typed b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/attr/py.typed new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/attr/setters.py b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/attr/setters.py new file mode 100644 index 0000000000000000000000000000000000000000..b1cbb5d83e744dc1a2a3012f6ebe7d4f6d72c740 --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/attr/setters.py @@ -0,0 +1,79 @@ +# SPDX-License-Identifier: MIT + +""" +Commonly used hooks for on_setattr. +""" + +from __future__ import absolute_import, division, print_function + +from . import _config +from .exceptions import FrozenAttributeError + + +def pipe(*setters): + """ + Run all *setters* and return the return value of the last one. + + .. versionadded:: 20.1.0 + """ + + def wrapped_pipe(instance, attrib, new_value): + rv = new_value + + for setter in setters: + rv = setter(instance, attrib, rv) + + return rv + + return wrapped_pipe + + +def frozen(_, __, ___): + """ + Prevent an attribute to be modified. + + .. versionadded:: 20.1.0 + """ + raise FrozenAttributeError() + + +def validate(instance, attrib, new_value): + """ + Run *attrib*'s validator on *new_value* if it has one. + + .. versionadded:: 20.1.0 + """ + if _config._run_validators is False: + return new_value + + v = attrib.validator + if not v: + return new_value + + v(instance, attrib, new_value) + + return new_value + + +def convert(instance, attrib, new_value): + """ + Run *attrib*'s converter -- if it has one -- on *new_value* and return the + result. + + .. versionadded:: 20.1.0 + """ + c = attrib.converter + if c: + return c(new_value) + + return new_value + + +NO_OP = object() +""" +Sentinel for disabling class-wide *on_setattr* hooks for certain attributes. + +Does not work in `pipe` or within lists. + +.. versionadded:: 20.1.0 +""" diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/attr/setters.pyi b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/attr/setters.pyi new file mode 100644 index 0000000000000000000000000000000000000000..3f5603c2b0cb7cd4afc3fc7ed53bbaed073f679f --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/attr/setters.pyi @@ -0,0 +1,19 @@ +from typing import Any, NewType, NoReturn, TypeVar, cast + +from . import Attribute, _OnSetAttrType + +_T = TypeVar("_T") + +def frozen( + instance: Any, attribute: Attribute[Any], new_value: Any +) -> NoReturn: ... +def pipe(*setters: _OnSetAttrType) -> _OnSetAttrType: ... +def validate(instance: Any, attribute: Attribute[_T], new_value: _T) -> _T: ... + +# convert is allowed to return Any, because they can be chained using pipe. +def convert( + instance: Any, attribute: Attribute[Any], new_value: Any +) -> Any: ... + +_NoOpType = NewType("_NoOpType", object) +NO_OP: _NoOpType diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/attr/validators.py b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/attr/validators.py new file mode 100644 index 0000000000000000000000000000000000000000..0b0c8342f2528678c1ab84b027abb12175f59fc7 --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/attr/validators.py @@ -0,0 +1,561 @@ +# SPDX-License-Identifier: MIT + +""" +Commonly useful validators. +""" + +from __future__ import absolute_import, division, print_function + +import operator +import re + +from contextlib import contextmanager + +from ._config import get_run_validators, set_run_validators +from ._make import _AndValidator, and_, attrib, attrs +from .exceptions import NotCallableError + + +try: + Pattern = re.Pattern +except AttributeError: # Python <3.7 lacks a Pattern type. + Pattern = type(re.compile("")) + + +__all__ = [ + "and_", + "deep_iterable", + "deep_mapping", + "disabled", + "ge", + "get_disabled", + "gt", + "in_", + "instance_of", + "is_callable", + "le", + "lt", + "matches_re", + "max_len", + "optional", + "provides", + "set_disabled", +] + + +def set_disabled(disabled): + """ + Globally disable or enable running validators. + + By default, they are run. + + :param disabled: If ``True``, disable running all validators. + :type disabled: bool + + .. warning:: + + This function is not thread-safe! + + .. versionadded:: 21.3.0 + """ + set_run_validators(not disabled) + + +def get_disabled(): + """ + Return a bool indicating whether validators are currently disabled or not. + + :return: ``True`` if validators are currently disabled. + :rtype: bool + + .. versionadded:: 21.3.0 + """ + return not get_run_validators() + + +@contextmanager +def disabled(): + """ + Context manager that disables running validators within its context. + + .. warning:: + + This context manager is not thread-safe! + + .. versionadded:: 21.3.0 + """ + set_run_validators(False) + try: + yield + finally: + set_run_validators(True) + + +@attrs(repr=False, slots=True, hash=True) +class _InstanceOfValidator(object): + type = attrib() + + def __call__(self, inst, attr, value): + """ + We use a callable class to be able to change the ``__repr__``. + """ + if not isinstance(value, self.type): + raise TypeError( + "'{name}' must be {type!r} (got {value!r} that is a " + "{actual!r}).".format( + name=attr.name, + type=self.type, + actual=value.__class__, + value=value, + ), + attr, + self.type, + value, + ) + + def __repr__(self): + return "".format( + type=self.type + ) + + +def instance_of(type): + """ + A validator that raises a `TypeError` if the initializer is called + with a wrong type for this particular attribute (checks are performed using + `isinstance` therefore it's also valid to pass a tuple of types). + + :param type: The type to check for. + :type type: type or tuple of types + + :raises TypeError: With a human readable error message, the attribute + (of type `attrs.Attribute`), the expected type, and the value it + got. + """ + return _InstanceOfValidator(type) + + +@attrs(repr=False, frozen=True, slots=True) +class _MatchesReValidator(object): + pattern = attrib() + match_func = attrib() + + def __call__(self, inst, attr, value): + """ + We use a callable class to be able to change the ``__repr__``. + """ + if not self.match_func(value): + raise ValueError( + "'{name}' must match regex {pattern!r}" + " ({value!r} doesn't)".format( + name=attr.name, pattern=self.pattern.pattern, value=value + ), + attr, + self.pattern, + value, + ) + + def __repr__(self): + return "".format( + pattern=self.pattern + ) + + +def matches_re(regex, flags=0, func=None): + r""" + A validator that raises `ValueError` if the initializer is called + with a string that doesn't match *regex*. + + :param regex: a regex string or precompiled pattern to match against + :param int flags: flags that will be passed to the underlying re function + (default 0) + :param callable func: which underlying `re` function to call (options + are `re.fullmatch`, `re.search`, `re.match`, default + is ``None`` which means either `re.fullmatch` or an emulation of + it on Python 2). For performance reasons, they won't be used directly + but on a pre-`re.compile`\ ed pattern. + + .. versionadded:: 19.2.0 + .. versionchanged:: 21.3.0 *regex* can be a pre-compiled pattern. + """ + fullmatch = getattr(re, "fullmatch", None) + valid_funcs = (fullmatch, None, re.search, re.match) + if func not in valid_funcs: + raise ValueError( + "'func' must be one of {}.".format( + ", ".join( + sorted( + e and e.__name__ or "None" for e in set(valid_funcs) + ) + ) + ) + ) + + if isinstance(regex, Pattern): + if flags: + raise TypeError( + "'flags' can only be used with a string pattern; " + "pass flags to re.compile() instead" + ) + pattern = regex + else: + pattern = re.compile(regex, flags) + + if func is re.match: + match_func = pattern.match + elif func is re.search: + match_func = pattern.search + elif fullmatch: + match_func = pattern.fullmatch + else: # Python 2 fullmatch emulation (https://bugs.python.org/issue16203) + pattern = re.compile( + r"(?:{})\Z".format(pattern.pattern), pattern.flags + ) + match_func = pattern.match + + return _MatchesReValidator(pattern, match_func) + + +@attrs(repr=False, slots=True, hash=True) +class _ProvidesValidator(object): + interface = attrib() + + def __call__(self, inst, attr, value): + """ + We use a callable class to be able to change the ``__repr__``. + """ + if not self.interface.providedBy(value): + raise TypeError( + "'{name}' must provide {interface!r} which {value!r} " + "doesn't.".format( + name=attr.name, interface=self.interface, value=value + ), + attr, + self.interface, + value, + ) + + def __repr__(self): + return "".format( + interface=self.interface + ) + + +def provides(interface): + """ + A validator that raises a `TypeError` if the initializer is called + with an object that does not provide the requested *interface* (checks are + performed using ``interface.providedBy(value)`` (see `zope.interface + `_). + + :param interface: The interface to check for. + :type interface: ``zope.interface.Interface`` + + :raises TypeError: With a human readable error message, the attribute + (of type `attrs.Attribute`), the expected interface, and the + value it got. + """ + return _ProvidesValidator(interface) + + +@attrs(repr=False, slots=True, hash=True) +class _OptionalValidator(object): + validator = attrib() + + def __call__(self, inst, attr, value): + if value is None: + return + + self.validator(inst, attr, value) + + def __repr__(self): + return "".format( + what=repr(self.validator) + ) + + +def optional(validator): + """ + A validator that makes an attribute optional. An optional attribute is one + which can be set to ``None`` in addition to satisfying the requirements of + the sub-validator. + + :param validator: A validator (or a list of validators) that is used for + non-``None`` values. + :type validator: callable or `list` of callables. + + .. versionadded:: 15.1.0 + .. versionchanged:: 17.1.0 *validator* can be a list of validators. + """ + if isinstance(validator, list): + return _OptionalValidator(_AndValidator(validator)) + return _OptionalValidator(validator) + + +@attrs(repr=False, slots=True, hash=True) +class _InValidator(object): + options = attrib() + + def __call__(self, inst, attr, value): + try: + in_options = value in self.options + except TypeError: # e.g. `1 in "abc"` + in_options = False + + if not in_options: + raise ValueError( + "'{name}' must be in {options!r} (got {value!r})".format( + name=attr.name, options=self.options, value=value + ) + ) + + def __repr__(self): + return "".format( + options=self.options + ) + + +def in_(options): + """ + A validator that raises a `ValueError` if the initializer is called + with a value that does not belong in the options provided. The check is + performed using ``value in options``. + + :param options: Allowed options. + :type options: list, tuple, `enum.Enum`, ... + + :raises ValueError: With a human readable error message, the attribute (of + type `attrs.Attribute`), the expected options, and the value it + got. + + .. versionadded:: 17.1.0 + """ + return _InValidator(options) + + +@attrs(repr=False, slots=False, hash=True) +class _IsCallableValidator(object): + def __call__(self, inst, attr, value): + """ + We use a callable class to be able to change the ``__repr__``. + """ + if not callable(value): + message = ( + "'{name}' must be callable " + "(got {value!r} that is a {actual!r})." + ) + raise NotCallableError( + msg=message.format( + name=attr.name, value=value, actual=value.__class__ + ), + value=value, + ) + + def __repr__(self): + return "" + + +def is_callable(): + """ + A validator that raises a `attr.exceptions.NotCallableError` if the + initializer is called with a value for this particular attribute + that is not callable. + + .. versionadded:: 19.1.0 + + :raises `attr.exceptions.NotCallableError`: With a human readable error + message containing the attribute (`attrs.Attribute`) name, + and the value it got. + """ + return _IsCallableValidator() + + +@attrs(repr=False, slots=True, hash=True) +class _DeepIterable(object): + member_validator = attrib(validator=is_callable()) + iterable_validator = attrib( + default=None, validator=optional(is_callable()) + ) + + def __call__(self, inst, attr, value): + """ + We use a callable class to be able to change the ``__repr__``. + """ + if self.iterable_validator is not None: + self.iterable_validator(inst, attr, value) + + for member in value: + self.member_validator(inst, attr, member) + + def __repr__(self): + iterable_identifier = ( + "" + if self.iterable_validator is None + else " {iterable!r}".format(iterable=self.iterable_validator) + ) + return ( + "" + ).format( + iterable_identifier=iterable_identifier, + member=self.member_validator, + ) + + +def deep_iterable(member_validator, iterable_validator=None): + """ + A validator that performs deep validation of an iterable. + + :param member_validator: Validator to apply to iterable members + :param iterable_validator: Validator to apply to iterable itself + (optional) + + .. versionadded:: 19.1.0 + + :raises TypeError: if any sub-validators fail + """ + return _DeepIterable(member_validator, iterable_validator) + + +@attrs(repr=False, slots=True, hash=True) +class _DeepMapping(object): + key_validator = attrib(validator=is_callable()) + value_validator = attrib(validator=is_callable()) + mapping_validator = attrib(default=None, validator=optional(is_callable())) + + def __call__(self, inst, attr, value): + """ + We use a callable class to be able to change the ``__repr__``. + """ + if self.mapping_validator is not None: + self.mapping_validator(inst, attr, value) + + for key in value: + self.key_validator(inst, attr, key) + self.value_validator(inst, attr, value[key]) + + def __repr__(self): + return ( + "" + ).format(key=self.key_validator, value=self.value_validator) + + +def deep_mapping(key_validator, value_validator, mapping_validator=None): + """ + A validator that performs deep validation of a dictionary. + + :param key_validator: Validator to apply to dictionary keys + :param value_validator: Validator to apply to dictionary values + :param mapping_validator: Validator to apply to top-level mapping + attribute (optional) + + .. versionadded:: 19.1.0 + + :raises TypeError: if any sub-validators fail + """ + return _DeepMapping(key_validator, value_validator, mapping_validator) + + +@attrs(repr=False, frozen=True, slots=True) +class _NumberValidator(object): + bound = attrib() + compare_op = attrib() + compare_func = attrib() + + def __call__(self, inst, attr, value): + """ + We use a callable class to be able to change the ``__repr__``. + """ + if not self.compare_func(value, self.bound): + raise ValueError( + "'{name}' must be {op} {bound}: {value}".format( + name=attr.name, + op=self.compare_op, + bound=self.bound, + value=value, + ) + ) + + def __repr__(self): + return "".format( + op=self.compare_op, bound=self.bound + ) + + +def lt(val): + """ + A validator that raises `ValueError` if the initializer is called + with a number larger or equal to *val*. + + :param val: Exclusive upper bound for values + + .. versionadded:: 21.3.0 + """ + return _NumberValidator(val, "<", operator.lt) + + +def le(val): + """ + A validator that raises `ValueError` if the initializer is called + with a number greater than *val*. + + :param val: Inclusive upper bound for values + + .. versionadded:: 21.3.0 + """ + return _NumberValidator(val, "<=", operator.le) + + +def ge(val): + """ + A validator that raises `ValueError` if the initializer is called + with a number smaller than *val*. + + :param val: Inclusive lower bound for values + + .. versionadded:: 21.3.0 + """ + return _NumberValidator(val, ">=", operator.ge) + + +def gt(val): + """ + A validator that raises `ValueError` if the initializer is called + with a number smaller or equal to *val*. + + :param val: Exclusive lower bound for values + + .. versionadded:: 21.3.0 + """ + return _NumberValidator(val, ">", operator.gt) + + +@attrs(repr=False, frozen=True, slots=True) +class _MaxLengthValidator(object): + max_length = attrib() + + def __call__(self, inst, attr, value): + """ + We use a callable class to be able to change the ``__repr__``. + """ + if len(value) > self.max_length: + raise ValueError( + "Length of '{name}' must be <= {max}: {len}".format( + name=attr.name, max=self.max_length, len=len(value) + ) + ) + + def __repr__(self): + return "".format(max=self.max_length) + + +def max_len(length): + """ + A validator that raises `ValueError` if the initializer is called + with a string or iterable that is longer than *length*. + + :param int length: Maximum length of the string or iterable + + .. versionadded:: 21.3.0 + """ + return _MaxLengthValidator(length) diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/attr/validators.pyi b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/attr/validators.pyi new file mode 100644 index 0000000000000000000000000000000000000000..5e00b8543397f8c9c353d7b7129db3dda13af469 --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/attr/validators.pyi @@ -0,0 +1,78 @@ +from typing import ( + Any, + AnyStr, + Callable, + Container, + ContextManager, + Iterable, + List, + Mapping, + Match, + Optional, + Pattern, + Tuple, + Type, + TypeVar, + Union, + overload, +) + +from . import _ValidatorType + +_T = TypeVar("_T") +_T1 = TypeVar("_T1") +_T2 = TypeVar("_T2") +_T3 = TypeVar("_T3") +_I = TypeVar("_I", bound=Iterable) +_K = TypeVar("_K") +_V = TypeVar("_V") +_M = TypeVar("_M", bound=Mapping) + +def set_disabled(run: bool) -> None: ... +def get_disabled() -> bool: ... +def disabled() -> ContextManager[None]: ... + +# To be more precise on instance_of use some overloads. +# If there are more than 3 items in the tuple then we fall back to Any +@overload +def instance_of(type: Type[_T]) -> _ValidatorType[_T]: ... +@overload +def instance_of(type: Tuple[Type[_T]]) -> _ValidatorType[_T]: ... +@overload +def instance_of( + type: Tuple[Type[_T1], Type[_T2]] +) -> _ValidatorType[Union[_T1, _T2]]: ... +@overload +def instance_of( + type: Tuple[Type[_T1], Type[_T2], Type[_T3]] +) -> _ValidatorType[Union[_T1, _T2, _T3]]: ... +@overload +def instance_of(type: Tuple[type, ...]) -> _ValidatorType[Any]: ... +def provides(interface: Any) -> _ValidatorType[Any]: ... +def optional( + validator: Union[_ValidatorType[_T], List[_ValidatorType[_T]]] +) -> _ValidatorType[Optional[_T]]: ... +def in_(options: Container[_T]) -> _ValidatorType[_T]: ... +def and_(*validators: _ValidatorType[_T]) -> _ValidatorType[_T]: ... +def matches_re( + regex: Union[Pattern[AnyStr], AnyStr], + flags: int = ..., + func: Optional[ + Callable[[AnyStr, AnyStr, int], Optional[Match[AnyStr]]] + ] = ..., +) -> _ValidatorType[AnyStr]: ... +def deep_iterable( + member_validator: _ValidatorType[_T], + iterable_validator: Optional[_ValidatorType[_I]] = ..., +) -> _ValidatorType[_I]: ... +def deep_mapping( + key_validator: _ValidatorType[_K], + value_validator: _ValidatorType[_V], + mapping_validator: Optional[_ValidatorType[_M]] = ..., +) -> _ValidatorType[_M]: ... +def is_callable() -> _ValidatorType[_T]: ... +def lt(val: _T) -> _ValidatorType[_T]: ... +def le(val: _T) -> _ValidatorType[_T]: ... +def ge(val: _T) -> _ValidatorType[_T]: ... +def gt(val: _T) -> _ValidatorType[_T]: ... +def max_len(length: int) -> _ValidatorType[_T]: ... diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/caffe2/__init__.py b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/caffe2/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..4096a98283857e0a4c9549dc4a7354b7876222ef --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/caffe2/__init__.py @@ -0,0 +1,6 @@ +import warnings +from torch.onnx import _CAFFE2_ATEN_FALLBACK + +if not _CAFFE2_ATEN_FALLBACK: + warnings.warn("Caffe2 support is not fully enabled in this PyTorch build. " + "Please enable Caffe2 by building PyTorch from source with `BUILD_CAFFE2=1` flag.") diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/cffi-1.16.0.dist-info/INSTALLER b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/cffi-1.16.0.dist-info/INSTALLER new file mode 100644 index 0000000000000000000000000000000000000000..f79e4cb9aaf0b2d9e8ba78861e2071317b2384b3 --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/cffi-1.16.0.dist-info/INSTALLER @@ -0,0 +1 @@ +conda \ No newline at end of file diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/cffi-1.16.0.dist-info/LICENSE b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/cffi-1.16.0.dist-info/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..29225eee9edcd72c6a354550a5a3bedf1932b2ef --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/cffi-1.16.0.dist-info/LICENSE @@ -0,0 +1,26 @@ + +Except when otherwise stated (look for LICENSE files in directories or +information at the beginning of each file) all software and +documentation is licensed as follows: + + The MIT License + + Permission is hereby granted, free of charge, to any person + obtaining a copy of this software and associated documentation + files (the "Software"), to deal in the Software without + restriction, including without limitation the rights to use, + copy, modify, merge, publish, distribute, sublicense, and/or + sell copies of the Software, and to permit persons to whom the + Software is furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included + in all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + DEALINGS IN THE SOFTWARE. + diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/cffi-1.16.0.dist-info/METADATA b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/cffi-1.16.0.dist-info/METADATA new file mode 100644 index 0000000000000000000000000000000000000000..f582bfbba8c686a734d15d5b04071e5c31d3eea0 --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/cffi-1.16.0.dist-info/METADATA @@ -0,0 +1,39 @@ +Metadata-Version: 2.1 +Name: cffi +Version: 1.16.0 +Summary: Foreign Function Interface for Python calling C code. +Home-page: http://cffi.readthedocs.org +Author: Armin Rigo, Maciej Fijalkowski +Author-email: python-cffi@googlegroups.com +License: MIT +Project-URL: Documentation, http://cffi.readthedocs.org/ +Project-URL: Source Code, https://github.com/python-cffi/cffi +Project-URL: Issue Tracker, https://github.com/python-cffi/cffi/issues +Project-URL: Changelog, https://cffi.readthedocs.io/en/latest/whatsnew.html +Project-URL: Downloads, https://github.com/python-cffi/cffi/releases +Project-URL: Contact, https://groups.google.com/forum/#!forum/python-cffi +Classifier: Programming Language :: Python +Classifier: Programming Language :: Python :: 3 +Classifier: Programming Language :: Python :: 3.8 +Classifier: Programming Language :: Python :: 3.9 +Classifier: Programming Language :: Python :: 3.10 +Classifier: Programming Language :: Python :: 3.11 +Classifier: Programming Language :: Python :: 3.12 +Classifier: Programming Language :: Python :: Implementation :: CPython +Classifier: Programming Language :: Python :: Implementation :: PyPy +Classifier: License :: OSI Approved :: MIT License +Requires-Python: >=3.8 +License-File: LICENSE +Requires-Dist: pycparser + + +CFFI +==== + +Foreign Function Interface for Python calling C code. +Please see the `Documentation `_. + +Contact +------- + +`Mailing list `_ diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/cffi-1.16.0.dist-info/RECORD b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/cffi-1.16.0.dist-info/RECORD new file mode 100644 index 0000000000000000000000000000000000000000..c48b0daad2b7ee00b183b6883f5058bdc0d152df --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/cffi-1.16.0.dist-info/RECORD @@ -0,0 +1,50 @@ +_cffi_backend.cpython-38-x86_64-linux-gnu.so,sha256=k8cFQrH4oy1ts6EVS4EKUkjZJGfR9lsoSs_Y719K79k,214720 +cffi-1.16.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +cffi-1.16.0.dist-info/LICENSE,sha256=BLgPWwd7vtaICM_rreteNSPyqMmpZJXFh72W3x6sKjM,1294 +cffi-1.16.0.dist-info/METADATA,sha256=qOBI2i0qSlLOKwmzNjbJfLmrTzHV_JFS7uKbcFj_p9Y,1480 +cffi-1.16.0.dist-info/RECORD,, +cffi-1.16.0.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +cffi-1.16.0.dist-info/WHEEL,sha256=bsTed55pnupMBzCO4birsRUZqi-B74u0toVjVzLw3F8,103 +cffi-1.16.0.dist-info/direct_url.json,sha256=cjIv8WEBK7ofFwunO7vGvLOzApMHE1dj9eFRbmhE58g,64 +cffi-1.16.0.dist-info/entry_points.txt,sha256=y6jTxnyeuLnL-XJcDv8uML3n6wyYiGRg8MTp_QGJ9Ho,75 +cffi-1.16.0.dist-info/top_level.txt,sha256=rE7WR3rZfNKxWI9-jn6hsHCAl7MDkB-FmuQbxWjFehQ,19 +cffi/__init__.py,sha256=uEnzaXlQndR9nc8ar1qk6_coNEfxfn4pA0sWPVg2MP8,513 +cffi/__pycache__/__init__.cpython-38.pyc,, +cffi/__pycache__/_imp_emulation.cpython-38.pyc,, +cffi/__pycache__/_shimmed_dist_utils.cpython-38.pyc,, +cffi/__pycache__/api.cpython-38.pyc,, +cffi/__pycache__/backend_ctypes.cpython-38.pyc,, +cffi/__pycache__/cffi_opcode.cpython-38.pyc,, +cffi/__pycache__/commontypes.cpython-38.pyc,, +cffi/__pycache__/cparser.cpython-38.pyc,, +cffi/__pycache__/error.cpython-38.pyc,, +cffi/__pycache__/ffiplatform.cpython-38.pyc,, +cffi/__pycache__/lock.cpython-38.pyc,, +cffi/__pycache__/model.cpython-38.pyc,, +cffi/__pycache__/pkgconfig.cpython-38.pyc,, +cffi/__pycache__/recompiler.cpython-38.pyc,, +cffi/__pycache__/setuptools_ext.cpython-38.pyc,, +cffi/__pycache__/vengine_cpy.cpython-38.pyc,, +cffi/__pycache__/vengine_gen.cpython-38.pyc,, +cffi/__pycache__/verifier.cpython-38.pyc,, +cffi/_cffi_errors.h,sha256=zQXt7uR_m8gUW-fI2hJg0KoSkJFwXv8RGUkEDZ177dQ,3908 +cffi/_cffi_include.h,sha256=tKnA1rdSoPHp23FnDL1mDGwFo-Uj6fXfA6vA6kcoEUc,14800 +cffi/_embedding.h,sha256=QEmrJKlB_W2VC601CjjyfMuxtgzPQwwEKFlwMCGHbT0,18787 +cffi/_imp_emulation.py,sha256=RxREG8zAbI2RPGBww90u_5fi8sWdahpdipOoPzkp7C0,2960 +cffi/_shimmed_dist_utils.py,sha256=mLuEtxw4gbuA2De_gD7zEhb6Q8Wm2lBPtwC68gd9XTs,2007 +cffi/api.py,sha256=wtJU0aGUC3TyYnjBIgsOIlv7drF19jV-y_srt7c8yhg,42085 +cffi/backend_ctypes.py,sha256=h5ZIzLc6BFVXnGyc9xPqZWUS7qGy7yFSDqXe68Sa8z4,42454 +cffi/cffi_opcode.py,sha256=v9RdD_ovA8rCtqsC95Ivki5V667rAOhGgs3fb2q9xpM,5724 +cffi/commontypes.py,sha256=QS4uxCDI7JhtTyjh1hlnCA-gynmaszWxJaRRLGkJa1A,2689 +cffi/cparser.py,sha256=rO_1pELRw1gI1DE1m4gi2ik5JMfpxouAACLXpRPlVEA,44231 +cffi/error.py,sha256=v6xTiS4U0kvDcy4h_BDRo5v39ZQuj-IMRYLv5ETddZs,877 +cffi/ffiplatform.py,sha256=avxFjdikYGJoEtmJO7ewVmwG_VEVl6EZ_WaNhZYCqv4,3584 +cffi/lock.py,sha256=l9TTdwMIMpi6jDkJGnQgE9cvTIR7CAntIJr8EGHt3pY,747 +cffi/model.py,sha256=RVsAb3h_u7VHWZJ-J_Z4kvB36pFyFG_MVIjPOQ8YhQ8,21790 +cffi/parse_c_type.h,sha256=OdwQfwM9ktq6vlCB43exFQmxDBtj2MBNdK8LYl15tjw,5976 +cffi/pkgconfig.py,sha256=LP1w7vmWvmKwyqLaU1Z243FOWGNQMrgMUZrvgFuOlco,4374 +cffi/recompiler.py,sha256=oTusgKQ02YY6LXhcmWcqpIlPrG178RMXXSBseSACRgg,64601 +cffi/setuptools_ext.py,sha256=-ebj79lO2_AUH-kRcaja2pKY1Z_5tloGwsJgzK8P3Cc,8871 +cffi/vengine_cpy.py,sha256=nK_im1DbdIGMMgxFgeo1MndFjaB-Qlkc2ZYlSquLjs0,43351 +cffi/vengine_gen.py,sha256=5dX7s1DU6pTBOMI6oTVn_8Bnmru_lj932B6b4v29Hlg,26684 +cffi/verifier.py,sha256=oX8jpaohg2Qm3aHcznidAdvrVm5N4sQYG0a3Eo5mIl4,11182 diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/cffi-1.16.0.dist-info/REQUESTED b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/cffi-1.16.0.dist-info/REQUESTED new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/cffi-1.16.0.dist-info/WHEEL b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/cffi-1.16.0.dist-info/WHEEL new file mode 100644 index 0000000000000000000000000000000000000000..7b858fc031cdbafeed137abe2c2cdcb3b8bb192a --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/cffi-1.16.0.dist-info/WHEEL @@ -0,0 +1,5 @@ +Wheel-Version: 1.0 +Generator: bdist_wheel (0.41.2) +Root-Is-Purelib: false +Tag: cp38-cp38-linux_x86_64 + diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/cffi-1.16.0.dist-info/direct_url.json b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/cffi-1.16.0.dist-info/direct_url.json new file mode 100644 index 0000000000000000000000000000000000000000..ca5055896afbd55bedb49947c689e897e74085d6 --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/cffi-1.16.0.dist-info/direct_url.json @@ -0,0 +1 @@ +{"dir_info": {}, "url": "file:///croot/cffi_1700254295673/work"} \ No newline at end of file diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/cffi-1.16.0.dist-info/entry_points.txt b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/cffi-1.16.0.dist-info/entry_points.txt new file mode 100644 index 0000000000000000000000000000000000000000..4b0274f2333a8cfadbe2d13922c47d0138e48141 --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/cffi-1.16.0.dist-info/entry_points.txt @@ -0,0 +1,2 @@ +[distutils.setup_keywords] +cffi_modules = cffi.setuptools_ext:cffi_modules diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/cffi-1.16.0.dist-info/top_level.txt b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/cffi-1.16.0.dist-info/top_level.txt new file mode 100644 index 0000000000000000000000000000000000000000..f64577957eb0d893196994ae517759f3fa8e48dd --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/cffi-1.16.0.dist-info/top_level.txt @@ -0,0 +1,2 @@ +_cffi_backend +cffi diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/conda_package_streaming-0.9.0.dist-info/INSTALLER b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/conda_package_streaming-0.9.0.dist-info/INSTALLER new file mode 100644 index 0000000000000000000000000000000000000000..f79e4cb9aaf0b2d9e8ba78861e2071317b2384b3 --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/conda_package_streaming-0.9.0.dist-info/INSTALLER @@ -0,0 +1 @@ +conda \ No newline at end of file diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/conda_package_streaming-0.9.0.dist-info/LICENSE b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/conda_package_streaming-0.9.0.dist-info/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..da262492a2f75f300ad89a447d7f39bc20b24f77 --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/conda_package_streaming-0.9.0.dist-info/LICENSE @@ -0,0 +1,53 @@ +BSD 3-Clause License + +Copyright (c) 2022, Anaconda, Inc. +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 copyright holder 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 HOLDER 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. + +lazy_wheel.py: + +Copyright (c) 2008-present The pip developers (see +https://github.com/pypa/pip/blob/main/AUTHORS.txt file) + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/conda_package_streaming-0.9.0.dist-info/METADATA b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/conda_package_streaming-0.9.0.dist-info/METADATA new file mode 100644 index 0000000000000000000000000000000000000000..bc3d788f5a573031b4bc2e7e5cc236aac88a5d6c --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/conda_package_streaming-0.9.0.dist-info/METADATA @@ -0,0 +1,123 @@ +Metadata-Version: 2.1 +Name: conda_package_streaming +Version: 0.9.0 +Summary: An efficient library to read from new and old format .conda and .tar.bz2 conda packages. +Author-email: "Anaconda, Inc. & Contributors" +Requires-Python: >=3.7 +Description-Content-Type: text/markdown +Classifier: License :: OSI Approved :: BSD License +Classifier: Programming Language :: Python :: 3 +Classifier: Programming Language :: Python :: Implementation :: CPython +Classifier: Programming Language :: Python :: Implementation :: PyPy +Requires-Dist: requests +Requires-Dist: zstandard >=0.15 +Requires-Dist: furo ; extra == "docs" +Requires-Dist: sphinx ; extra == "docs" +Requires-Dist: myst-parser ; extra == "docs" +Requires-Dist: mdit-py-plugins>=0.3.0 ; extra == "docs" +Requires-Dist: pytest >=7 ; extra == "test" +Requires-Dist: pytest-cov ; extra == "test" +Requires-Dist: pytest-mock ; extra == "test" +Requires-Dist: boto3 ; extra == "test" +Requires-Dist: boto3-stubs[essential] ; extra == "test" +Requires-Dist: bottle ; extra == "test" +Requires-Dist: conda ; extra == "test" +Requires-Dist: conda-package-handling >=2 ; extra == "test" +Project-URL: Documentation, https://conda.github.io/conda-package-streaming/ +Project-URL: Home, https://github.com/conda/conda-package-streaming +Provides-Extra: docs +Provides-Extra: test + +# conda-package-streaming + +[![pre-commit.ci status](https://results.pre-commit.ci/badge/github/conda/conda-package-streaming/main.svg)](https://results.pre-commit.ci/latest/github/conda/conda-package-streaming/main) + +An efficient library to read from new and old format .conda and .tar.bz2 conda +packages. + +Download conda metadata from packages without transferring entire file. Get +metadata from local `.tar.bz2` packages without reading entire files. + +Uses enhanced pip `lazy_wheel` to fetch a file out of `.conda` with no more than +3 range requests, but usually 2. + +Uses `tar = tarfile.open(fileobj=...)` to stream remote `.tar.bz2`. Closes the +HTTP request once desired files have been seen. + +# Quickstart + +The basic API yields (tarfile, member) tuples from conda files as tarfile is +needed to extract member. Note the `.tar.bz2` format yields all members, not +just `info/`, from `stream_conda_info` / `stream_conda_component`, while the +`.conda` format yields members from the requested inner archive — allowing the +caller to decide when to stop reading. + +From a url, +```python +from conda_package_streaming.url import stream_conda_info +# url = (ends with .conda or .tar.bz2) +for tar, member in stream_conda_info(url): + if member.name == "info/index.json": + index_json = json.load(tar.extractfile(member)) + break +``` + +From s3, +```python +client = boto3.client("s3") +from conda_package_streaming.s3 import stream_conda_info +# key = (ends with .conda or .tar.bz2) +for tar, member in stream_conda_info(client, bucket, key): + if member.name == "info/index.json": + index_json = json.load(tar.extractfile(member)) + break +``` + +From a filename, +```python +from conda_package_streaming import package_streaming +# filename = (ends with .conda or .tar.bz2) +for tar, member in package_streaming.stream_conda_info(filename): + if member.name == "info/index.json": + index_json = json.load(tar.extractfile(member)) + break +``` + +From a file-like object, +```python +from contextlib import closing + +from conda_package_streaming.url import conda_reader_for_url +from conda_package_streaming.package_streaming import stream_conda_component +filename, conda = conda_reader_for_url(url) + +# file object must be seekable for `.conda` format, but merely readable for `.tar.bz2` +with closing(conda): + for tar, member in stream_conda_component(filename, conda, component="info"): + if member.name == "info/index.json": + index_json = json.load(tar.extractfile(member)) + break +``` + +If you need the entire package, download it first and use the file-based APIs. +The URL-based APIs are more efficient if you only need to access package +metadata. + +# Package goals + +* Extract conda packages (both formats) +* Easy to install from pypi or conda +* Do the least amount of I/O possible (no temporary files, transfer partial packages) +* Open files from the network / standard HTTP / s3 + +* Continue using conda-package-handling to create .conda packages + +# Generating documentation + +Uses markdown, furo theme. Requires newer mdit-py-plugins. + +`pip install conda-package-streaming[docs]` + +One time: +`sphinx-apidoc -o docs .` + diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/conda_package_streaming-0.9.0.dist-info/RECORD b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/conda_package_streaming-0.9.0.dist-info/RECORD new file mode 100644 index 0000000000000000000000000000000000000000..59fa5dbcd536d79f68af3d1ab10c07c0baeb1f8f --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/conda_package_streaming-0.9.0.dist-info/RECORD @@ -0,0 +1,23 @@ +conda_package_streaming-0.9.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +conda_package_streaming-0.9.0.dist-info/LICENSE,sha256=WPOScO-I9aoJgXok_DebNZN-PZhtB13xi1WqU0iqrWY,2670 +conda_package_streaming-0.9.0.dist-info/METADATA,sha256=v6KAneLFl-5MMJ4Sseu_1IuzvqEbW7zO08jCUuTiNq0,4491 +conda_package_streaming-0.9.0.dist-info/RECORD,, +conda_package_streaming-0.9.0.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +conda_package_streaming-0.9.0.dist-info/WHEEL,sha256=EZbGkh7Ie4PoZfRQ8I0ZuP9VklN_TvcZ6DSE5Uar4z4,81 +conda_package_streaming-0.9.0.dist-info/direct_url.json,sha256=luamLXV5NvouU6jK1EUSW6FWq7xHhRDIDQzbPtPCrpg,119 +conda_package_streaming/__init__.py,sha256=H9NWRZb7NbeRRPLP_V1fARmLNXranorVM-OOY-8_2ug,22 +conda_package_streaming/__pycache__/__init__.cpython-311.pyc,, +conda_package_streaming/__pycache__/exceptions.cpython-311.pyc,, +conda_package_streaming/__pycache__/extract.cpython-311.pyc,, +conda_package_streaming/__pycache__/lazy_wheel.cpython-311.pyc,, +conda_package_streaming/__pycache__/package_streaming.cpython-311.pyc,, +conda_package_streaming/__pycache__/s3.cpython-311.pyc,, +conda_package_streaming/__pycache__/transmute.cpython-311.pyc,, +conda_package_streaming/__pycache__/url.cpython-311.pyc,, +conda_package_streaming/exceptions.py,sha256=7fG4CNtukkSRWAGh9Zg2DCNkhw-wNo-Oi35c2jf0VsQ,677 +conda_package_streaming/extract.py,sha256=quYBuhRA4TOdCvEXFyPXZKZOuJcBvazdQfL8nQnhYuk,2538 +conda_package_streaming/lazy_wheel.py,sha256=eqEtfzoQCWC8lc1wNzOtRfOTlqHnUUc4b5MllS3O1W0,9449 +conda_package_streaming/package_streaming.py,sha256=ApUpvoGQ4UGXOIvOTFIkfXx0-TnWsZxGRSMNvlwCQbQ,4819 +conda_package_streaming/s3.py,sha256=ygm59wSPpixvwkO4QqSgvalNUjAk1FzEXW0JNj45cgI,2286 +conda_package_streaming/transmute.py,sha256=JrpmR-_lRe1Zd-RLd_Tqr9Qjc8Xq-97Xjiy54VgInlQ,5718 +conda_package_streaming/url.py,sha256=WCpe8048F9hb_BgZRlNMvVyMugLNbty2MladRjvrvmo,2707 diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/conda_package_streaming-0.9.0.dist-info/REQUESTED b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/conda_package_streaming-0.9.0.dist-info/REQUESTED new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/conda_package_streaming-0.9.0.dist-info/WHEEL b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/conda_package_streaming-0.9.0.dist-info/WHEEL new file mode 100644 index 0000000000000000000000000000000000000000..3b5e64b5e6c4a210201d1676a891fd57b15cda99 --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/conda_package_streaming-0.9.0.dist-info/WHEEL @@ -0,0 +1,4 @@ +Wheel-Version: 1.0 +Generator: flit 3.9.0 +Root-Is-Purelib: true +Tag: py3-none-any diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/conda_package_streaming-0.9.0.dist-info/direct_url.json b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/conda_package_streaming-0.9.0.dist-info/direct_url.json new file mode 100644 index 0000000000000000000000000000000000000000..2d9a2eb23b60a800e3977864d6ca21656a3a95a3 --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/conda_package_streaming-0.9.0.dist-info/direct_url.json @@ -0,0 +1 @@ +{"dir_info": {}, "url": "file:///home/conda/feedstock_root/build_artifacts/conda-package-streaming_1691009212940/work"} \ No newline at end of file diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/ema_pytorch/__init__.py b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/ema_pytorch/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..efdae9559d3c57ee52b93b28f8694f6a77f2a739 --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/ema_pytorch/__init__.py @@ -0,0 +1 @@ +from ema_pytorch.ema_pytorch import EMA diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/ema_pytorch/ema_pytorch.py b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/ema_pytorch/ema_pytorch.py new file mode 100644 index 0000000000000000000000000000000000000000..3540a764620dc2d8c0df9a0b1091ff90a035629e --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/ema_pytorch/ema_pytorch.py @@ -0,0 +1,148 @@ +import copy +import torch +from torch import nn + +def exists(val): + return val is not None + +def is_float_dtype(dtype): + return any([dtype == float_dtype for float_dtype in (torch.float64, torch.float32, torch.float16, torch.bfloat16)]) + +def clamp(value, min_value = None, max_value = None): + assert exists(min_value) or exists(max_value) + if exists(min_value): + value = max(value, min_value) + + if exists(max_value): + value = min(value, max_value) + + return value + +class EMA(nn.Module): + """ + Implements exponential moving average shadowing for your model. + + Utilizes an inverse decay schedule to manage longer term training runs. + By adjusting the power, you can control how fast EMA will ramp up to your specified beta. + + @crowsonkb's notes on EMA Warmup: + + If gamma=1 and power=1, implements a simple average. gamma=1, power=2/3 are + good values for models you plan to train for a million or more steps (reaches decay + factor 0.999 at 31.6K steps, 0.9999 at 1M steps), gamma=1, power=3/4 for models + you plan to train for less (reaches decay factor 0.999 at 10K steps, 0.9999 at + 215.4k steps). + + Args: + inv_gamma (float): Inverse multiplicative factor of EMA warmup. Default: 1. + power (float): Exponential factor of EMA warmup. Default: 1. + min_value (float): The minimum EMA decay rate. Default: 0. + """ + def __init__( + self, + model, + beta = 0.9999, + update_after_step = 100, + update_every = 10, + inv_gamma = 1.0, + power = 2 / 3, + min_value = 0.0, + param_or_buffer_names_no_ema = set(), + ): + super().__init__() + self.beta = beta + self.online_model = model + + try: + self.ema_model = copy.deepcopy(model) + except: + print('Your model was not copyable. Please make sure you are not using any LazyLinear') + exit() + + self.ema_model.requires_grad_(False) + self.update_every = update_every + self.update_after_step = update_after_step + + self.inv_gamma = inv_gamma + self.power = power + self.min_value = min_value + + assert isinstance(param_or_buffer_names_no_ema, (set, list)) + self.param_or_buffer_names_no_ema = param_or_buffer_names_no_ema # parameter or buffer + + self.register_buffer('initted', torch.Tensor([False])) + self.register_buffer('step', torch.tensor([0])) + + def restore_ema_model_device(self): + device = self.initted.device + self.ema_model.to(device) + + def copy_params_from_model_to_ema(self): + for ma_params, current_params in zip(list(self.ema_model.parameters()), list(self.online_model.parameters())): + if not is_float_dtype(current_params.dtype): + continue + + ma_params.data.copy_(current_params.data) + + for ma_buffers, current_buffers in zip(list(self.ema_model.buffers()), list(self.online_model.buffers())): + if not is_float_dtype(current_buffers.dtype): + continue + + ma_buffers.data.copy_(current_buffers.data) + + def get_current_decay(self): + epoch = clamp(self.step.item() - self.update_after_step - 1, min_value = 0.) + value = 1 - (1 + epoch / self.inv_gamma) ** - self.power + + if epoch <= 0: + return 0. + + return clamp(value, min_value = self.min_value, max_value = self.beta) + + def update(self): + step = self.step.item() + self.step += 1 + + if (step % self.update_every) != 0: + return + + if step <= self.update_after_step: + self.copy_params_from_model_to_ema() + return + + if not self.initted.item(): + self.copy_params_from_model_to_ema() + self.initted.data.copy_(torch.Tensor([True])) + + self.update_moving_average(self.ema_model, self.online_model) + + @torch.no_grad() + def update_moving_average(self, ma_model, current_model): + current_decay = self.get_current_decay() + + for (name, current_params), (_, ma_params) in zip(list(current_model.named_parameters()), list(ma_model.named_parameters())): + if not is_float_dtype(current_params.dtype): + continue + + if name in self.param_or_buffer_names_no_ema: + ma_params.data.copy_(current_params.data) + continue + + difference = ma_params.data - current_params.data + difference.mul_(1.0 - current_decay) + ma_params.sub_(difference) + + for (name, current_buffer), (_, ma_buffer) in zip(list(current_model.named_buffers()), list(ma_model.named_buffers())): + if not is_float_dtype(current_buffer.dtype): + continue + + if name in self.param_or_buffer_names_no_ema: + ma_buffer.data.copy_(current_buffer.data) + continue + + difference = ma_buffer - current_buffer + difference.mul_(1.0 - current_decay) + ma_buffer.sub_(difference) + + def __call__(self, *args, **kwargs): + return self.ema_model(*args, **kwargs) diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/h5py/_conv.cpython-38-x86_64-linux-gnu.so b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/h5py/_conv.cpython-38-x86_64-linux-gnu.so new file mode 100644 index 0000000000000000000000000000000000000000..df5991308748ad69b86fa3fe31c51711cfeca55f --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/h5py/_conv.cpython-38-x86_64-linux-gnu.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c09e26f78982823056888fff0a4de1eee4592c7e0d761cf42614b554cb662958 +size 438392 diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/h5py/h5a.cpython-38-x86_64-linux-gnu.so b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/h5py/h5a.cpython-38-x86_64-linux-gnu.so new file mode 100644 index 0000000000000000000000000000000000000000..4c3596da27a70d8c378f6f41cd51768f1c917da8 --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/h5py/h5a.cpython-38-x86_64-linux-gnu.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2ef3e50ea264685a38710eacee6e8450f95e901aebd78fb070dd9f1507dbc9be +size 269232 diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/h5py/h5i.cpython-38-x86_64-linux-gnu.so b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/h5py/h5i.cpython-38-x86_64-linux-gnu.so new file mode 100644 index 0000000000000000000000000000000000000000..4964b5f1667e38c3fee9a57e5f5fc0eea9db8af9 --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/h5py/h5i.cpython-38-x86_64-linux-gnu.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2d0fd9c38db14f04502128315ac680733264c0feb11363ac129254c57c5915f2 +size 162200 diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/h5py/h5p.cpython-38-x86_64-linux-gnu.so b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/h5py/h5p.cpython-38-x86_64-linux-gnu.so new file mode 100644 index 0000000000000000000000000000000000000000..d9dd57cce05aca7468475656cebabeaa501bc4d3 --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/h5py/h5p.cpython-38-x86_64-linux-gnu.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c79540255031ac514b109e184ffd41dda2dc6c49c19be35d447f7803c3e9b14c +size 781880 diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/imageio_ffmpeg-0.4.7.dist-info/INSTALLER b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/imageio_ffmpeg-0.4.7.dist-info/INSTALLER new file mode 100644 index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68 --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/imageio_ffmpeg-0.4.7.dist-info/INSTALLER @@ -0,0 +1 @@ +pip diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/imageio_ffmpeg-0.4.7.dist-info/LICENSE b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/imageio_ffmpeg-0.4.7.dist-info/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..fc87aa36d5a15b67f694a2a8db5dfb9f7ec55e22 --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/imageio_ffmpeg-0.4.7.dist-info/LICENSE @@ -0,0 +1,25 @@ +BSD 2-Clause License + +Copyright (c) 2019, imageio +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. + +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 HOLDER 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. diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/imageio_ffmpeg-0.4.7.dist-info/METADATA b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/imageio_ffmpeg-0.4.7.dist-info/METADATA new file mode 100644 index 0000000000000000000000000000000000000000..de68b9949f5ff41550edb8a2eacd75d07a46c371 --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/imageio_ffmpeg-0.4.7.dist-info/METADATA @@ -0,0 +1,42 @@ +Metadata-Version: 2.1 +Name: imageio-ffmpeg +Version: 0.4.7 +Summary: FFMPEG wrapper for Python +Home-page: https://github.com/imageio/imageio-ffmpeg +Author: imageio contributors +Author-email: almar.klein@gmail.com +License: BSD-2-Clause +Download-URL: http://pypi.python.org/pypi/imageio-ffmpeg +Keywords: video ffmpeg +Platform: any +Classifier: Development Status :: 5 - Production/Stable +Classifier: Intended Audience :: Science/Research +Classifier: Intended Audience :: Education +Classifier: Intended Audience :: Developers +Classifier: License :: OSI Approved :: BSD License +Classifier: Operating System :: MacOS :: MacOS X +Classifier: Operating System :: Microsoft :: Windows +Classifier: Operating System :: POSIX +Classifier: Programming Language :: Python +Classifier: Programming Language :: Python :: 3 +Classifier: Programming Language :: Python :: 3.5 +Classifier: Programming Language :: Python :: 3.6 +Classifier: Programming Language :: Python :: 3.7 +Classifier: Programming Language :: Python :: 3.8 +Classifier: Programming Language :: Python :: 3.9 +Classifier: Programming Language :: Python :: 3.10 +Provides: imageio_ffmpeg +Requires-Python: >=3.5 +License-File: LICENSE + +FFMPEG wrapper for Python. + +Note that the platform-specific wheels contain the binary executable +of ffmpeg, which makes this package around 60 MiB in size. +I guess that's the cost for being able to read/write video files. + +For Linux users: the above is not the case when installing via your +Linux package manager (if that is possible), because this package would +simply depend on ffmpeg in that case. + + diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/imageio_ffmpeg-0.4.7.dist-info/RECORD b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/imageio_ffmpeg-0.4.7.dist-info/RECORD new file mode 100644 index 0000000000000000000000000000000000000000..b31f3ce1af71c2df8b7e75f673b6d61113d3fe04 --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/imageio_ffmpeg-0.4.7.dist-info/RECORD @@ -0,0 +1,19 @@ +imageio_ffmpeg-0.4.7.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +imageio_ffmpeg-0.4.7.dist-info/LICENSE,sha256=nJvpIbtQ7-Rkc86JE1sDcGHfXM3K6Xy_hKzhiw-onc4,1312 +imageio_ffmpeg-0.4.7.dist-info/METADATA,sha256=c4bjBqQEz98oBzD7ZlEGtNq7afquVLkfB4O190zhsU4,1577 +imageio_ffmpeg-0.4.7.dist-info/RECORD,, +imageio_ffmpeg-0.4.7.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +imageio_ffmpeg-0.4.7.dist-info/WHEEL,sha256=JG0f5q-l1tk3Qjvj5-c2Cu5nNOHyulBrZOKMxkgYopM,108 +imageio_ffmpeg-0.4.7.dist-info/top_level.txt,sha256=ODQYUYYbtj9I1SjASEMY7h8Q8haLrmMNURSCn0FEB18,15 +imageio_ffmpeg/__init__.py,sha256=AEGmAbioCkfhYPhDQNck7aLOyKUOZtOWOtGnoNjSAQQ,227 +imageio_ffmpeg/__pycache__/__init__.cpython-38.pyc,, +imageio_ffmpeg/__pycache__/_definitions.cpython-38.pyc,, +imageio_ffmpeg/__pycache__/_io.cpython-38.pyc,, +imageio_ffmpeg/__pycache__/_parsing.cpython-38.pyc,, +imageio_ffmpeg/__pycache__/_utils.cpython-38.pyc,, +imageio_ffmpeg/_definitions.py,sha256=IOY3ZT-OEd6tAl_VFlDJ5viwCaa6I9ySQTs06oTI_kA,1609 +imageio_ffmpeg/_io.py,sha256=TRNbg_-EF1pqPshxLedTxrvMq2diw5d13Nmm7_snP9Y,26824 +imageio_ffmpeg/_parsing.py,sha256=EiABt33ZrJUVb9yRHLlpiG6N4BGDut-_H9GbHn89KhY,6595 +imageio_ffmpeg/_utils.py,sha256=zr_xMHv6POlOkxobXIOcsXF8PcK1ifJpGzU1VdFdI30,3306 +imageio_ffmpeg/binaries/README.md,sha256=sNNt-xuh6lyoc6b228wilbenlErqh1Bx2RpqrRhw530,45 +imageio_ffmpeg/binaries/ffmpeg-linux64-v4.2.2,sha256=cABz2u9cI7vLGMLq5gVTpFSlIh7Bm0qIyMNnpmRnGnw,73807592 diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/imageio_ffmpeg-0.4.7.dist-info/REQUESTED b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/imageio_ffmpeg-0.4.7.dist-info/REQUESTED new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/imageio_ffmpeg-0.4.7.dist-info/WHEEL b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/imageio_ffmpeg-0.4.7.dist-info/WHEEL new file mode 100644 index 0000000000000000000000000000000000000000..34b73683eda8f9368623c74681c2a8c91a6102aa --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/imageio_ffmpeg-0.4.7.dist-info/WHEEL @@ -0,0 +1,4 @@ +Wheel-Version: 1.0 +Generator: bdist_wheel (0.37.1) +Root-Is-Purelib: true +Tag: py3-none-manylinux2010_x86_64 diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/imageio_ffmpeg-0.4.7.dist-info/top_level.txt b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/imageio_ffmpeg-0.4.7.dist-info/top_level.txt new file mode 100644 index 0000000000000000000000000000000000000000..8adec99ed476b9cbd472361d84ddb1224676762d --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/imageio_ffmpeg-0.4.7.dist-info/top_level.txt @@ -0,0 +1 @@ +imageio_ffmpeg diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/importlib_metadata/__init__.py b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/importlib_metadata/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..8761307ac24eba5d995389763e16bc706535c0f3 --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/importlib_metadata/__init__.py @@ -0,0 +1,1095 @@ +import os +import re +import abc +import csv +import sys +import zipp +import email +import pathlib +import operator +import textwrap +import warnings +import functools +import itertools +import posixpath +import collections + +from . import _adapters, _meta +from ._collections import FreezableDefaultDict, Pair +from ._compat import ( + NullFinder, + install, + pypy_partial, +) +from ._functools import method_cache, pass_none +from ._itertools import always_iterable, unique_everseen +from ._meta import PackageMetadata, SimplePath + +from contextlib import suppress +from importlib import import_module +from importlib.abc import MetaPathFinder +from itertools import starmap +from typing import List, Mapping, Optional, Union + + +__all__ = [ + 'Distribution', + 'DistributionFinder', + 'PackageMetadata', + 'PackageNotFoundError', + 'distribution', + 'distributions', + 'entry_points', + 'files', + 'metadata', + 'packages_distributions', + 'requires', + 'version', +] + + +class PackageNotFoundError(ModuleNotFoundError): + """The package was not found.""" + + def __str__(self): + return f"No package metadata was found for {self.name}" + + @property + def name(self): + (name,) = self.args + return name + + +class Sectioned: + """ + A simple entry point config parser for performance + + >>> for item in Sectioned.read(Sectioned._sample): + ... print(item) + Pair(name='sec1', value='# comments ignored') + Pair(name='sec1', value='a = 1') + Pair(name='sec1', value='b = 2') + Pair(name='sec2', value='a = 2') + + >>> res = Sectioned.section_pairs(Sectioned._sample) + >>> item = next(res) + >>> item.name + 'sec1' + >>> item.value + Pair(name='a', value='1') + >>> item = next(res) + >>> item.value + Pair(name='b', value='2') + >>> item = next(res) + >>> item.name + 'sec2' + >>> item.value + Pair(name='a', value='2') + >>> list(res) + [] + """ + + _sample = textwrap.dedent( + """ + [sec1] + # comments ignored + a = 1 + b = 2 + + [sec2] + a = 2 + """ + ).lstrip() + + @classmethod + def section_pairs(cls, text): + return ( + section._replace(value=Pair.parse(section.value)) + for section in cls.read(text, filter_=cls.valid) + if section.name is not None + ) + + @staticmethod + def read(text, filter_=None): + lines = filter(filter_, map(str.strip, text.splitlines())) + name = None + for value in lines: + section_match = value.startswith('[') and value.endswith(']') + if section_match: + name = value.strip('[]') + continue + yield Pair(name, value) + + @staticmethod + def valid(line): + return line and not line.startswith('#') + + +class DeprecatedTuple: + """ + Provide subscript item access for backward compatibility. + + >>> recwarn = getfixture('recwarn') + >>> ep = EntryPoint(name='name', value='value', group='group') + >>> ep[:] + ('name', 'value', 'group') + >>> ep[0] + 'name' + >>> len(recwarn) + 1 + """ + + _warn = functools.partial( + warnings.warn, + "EntryPoint tuple interface is deprecated. Access members by name.", + DeprecationWarning, + stacklevel=pypy_partial(2), + ) + + def __getitem__(self, item): + self._warn() + return self._key()[item] + + +class EntryPoint(DeprecatedTuple): + """An entry point as defined by Python packaging conventions. + + See `the packaging docs on entry points + `_ + for more information. + + >>> ep = EntryPoint( + ... name=None, group=None, value='package.module:attr [extra1, extra2]') + >>> ep.module + 'package.module' + >>> ep.attr + 'attr' + >>> ep.extras + ['extra1', 'extra2'] + """ + + pattern = re.compile( + r'(?P[\w.]+)\s*' + r'(:\s*(?P[\w.]+)\s*)?' + r'((?P\[.*\])\s*)?$' + ) + """ + A regular expression describing the syntax for an entry point, + which might look like: + + - module + - package.module + - package.module:attribute + - package.module:object.attribute + - package.module:attr [extra1, extra2] + + Other combinations are possible as well. + + The expression is lenient about whitespace around the ':', + following the attr, and following any extras. + """ + + dist: Optional['Distribution'] = None + + def __init__(self, name, value, group): + vars(self).update(name=name, value=value, group=group) + + def load(self): + """Load the entry point from its definition. If only a module + is indicated by the value, return that module. Otherwise, + return the named object. + """ + match = self.pattern.match(self.value) + module = import_module(match.group('module')) + attrs = filter(None, (match.group('attr') or '').split('.')) + return functools.reduce(getattr, attrs, module) + + @property + def module(self): + match = self.pattern.match(self.value) + return match.group('module') + + @property + def attr(self): + match = self.pattern.match(self.value) + return match.group('attr') + + @property + def extras(self): + match = self.pattern.match(self.value) + return re.findall(r'\w+', match.group('extras') or '') + + def _for(self, dist): + vars(self).update(dist=dist) + return self + + def __iter__(self): + """ + Supply iter so one may construct dicts of EntryPoints by name. + """ + msg = ( + "Construction of dict of EntryPoints is deprecated in " + "favor of EntryPoints." + ) + warnings.warn(msg, DeprecationWarning) + return iter((self.name, self)) + + def matches(self, **params): + """ + EntryPoint matches the given parameters. + + >>> ep = EntryPoint(group='foo', name='bar', value='bing:bong [extra1, extra2]') + >>> ep.matches(group='foo') + True + >>> ep.matches(name='bar', value='bing:bong [extra1, extra2]') + True + >>> ep.matches(group='foo', name='other') + False + >>> ep.matches() + True + >>> ep.matches(extras=['extra1', 'extra2']) + True + >>> ep.matches(module='bing') + True + >>> ep.matches(attr='bong') + True + """ + attrs = (getattr(self, param) for param in params) + return all(map(operator.eq, params.values(), attrs)) + + def _key(self): + return self.name, self.value, self.group + + def __lt__(self, other): + return self._key() < other._key() + + def __eq__(self, other): + return self._key() == other._key() + + def __setattr__(self, name, value): + raise AttributeError("EntryPoint objects are immutable.") + + def __repr__(self): + return ( + f'EntryPoint(name={self.name!r}, value={self.value!r}, ' + f'group={self.group!r})' + ) + + def __hash__(self): + return hash(self._key()) + + +class DeprecatedList(list): + """ + Allow an otherwise immutable object to implement mutability + for compatibility. + + >>> recwarn = getfixture('recwarn') + >>> dl = DeprecatedList(range(3)) + >>> dl[0] = 1 + >>> dl.append(3) + >>> del dl[3] + >>> dl.reverse() + >>> dl.sort() + >>> dl.extend([4]) + >>> dl.pop(-1) + 4 + >>> dl.remove(1) + >>> dl += [5] + >>> dl + [6] + [1, 2, 5, 6] + >>> dl + (6,) + [1, 2, 5, 6] + >>> dl.insert(0, 0) + >>> dl + [0, 1, 2, 5] + >>> dl == [0, 1, 2, 5] + True + >>> dl == (0, 1, 2, 5) + True + >>> len(recwarn) + 1 + """ + + __slots__ = () + + _warn = functools.partial( + warnings.warn, + "EntryPoints list interface is deprecated. Cast to list if needed.", + DeprecationWarning, + stacklevel=pypy_partial(2), + ) + + def _wrap_deprecated_method(method_name: str): # type: ignore + def wrapped(self, *args, **kwargs): + self._warn() + return getattr(super(), method_name)(*args, **kwargs) + + return method_name, wrapped + + locals().update( + map( + _wrap_deprecated_method, + '__setitem__ __delitem__ append reverse extend pop remove ' + '__iadd__ insert sort'.split(), + ) + ) + + def __add__(self, other): + if not isinstance(other, tuple): + self._warn() + other = tuple(other) + return self.__class__(tuple(self) + other) + + def __eq__(self, other): + if not isinstance(other, tuple): + self._warn() + other = tuple(other) + + return tuple(self).__eq__(other) + + +class EntryPoints(DeprecatedList): + """ + An immutable collection of selectable EntryPoint objects. + """ + + __slots__ = () + + def __getitem__(self, name): # -> EntryPoint: + """ + Get the EntryPoint in self matching name. + """ + if isinstance(name, int): + warnings.warn( + "Accessing entry points by index is deprecated. " + "Cast to tuple if needed.", + DeprecationWarning, + stacklevel=2, + ) + return super().__getitem__(name) + try: + return next(iter(self.select(name=name))) + except StopIteration: + raise KeyError(name) + + def select(self, **params): + """ + Select entry points from self that match the + given parameters (typically group and/or name). + """ + return EntryPoints(ep for ep in self if ep.matches(**params)) + + @property + def names(self): + """ + Return the set of all names of all entry points. + """ + return {ep.name for ep in self} + + @property + def groups(self): + """ + Return the set of all groups of all entry points. + + For coverage while SelectableGroups is present. + >>> EntryPoints().groups + set() + """ + return {ep.group for ep in self} + + @classmethod + def _from_text_for(cls, text, dist): + return cls(ep._for(dist) for ep in cls._from_text(text)) + + @staticmethod + def _from_text(text): + return ( + EntryPoint(name=item.value.name, value=item.value.value, group=item.name) + for item in Sectioned.section_pairs(text or '') + ) + + +class Deprecated: + """ + Compatibility add-in for mapping to indicate that + mapping behavior is deprecated. + + >>> recwarn = getfixture('recwarn') + >>> class DeprecatedDict(Deprecated, dict): pass + >>> dd = DeprecatedDict(foo='bar') + >>> dd.get('baz', None) + >>> dd['foo'] + 'bar' + >>> list(dd) + ['foo'] + >>> list(dd.keys()) + ['foo'] + >>> 'foo' in dd + True + >>> list(dd.values()) + ['bar'] + >>> len(recwarn) + 1 + """ + + _warn = functools.partial( + warnings.warn, + "SelectableGroups dict interface is deprecated. Use select.", + DeprecationWarning, + stacklevel=pypy_partial(2), + ) + + def __getitem__(self, name): + self._warn() + return super().__getitem__(name) + + def get(self, name, default=None): + self._warn() + return super().get(name, default) + + def __iter__(self): + self._warn() + return super().__iter__() + + def __contains__(self, *args): + self._warn() + return super().__contains__(*args) + + def keys(self): + self._warn() + return super().keys() + + def values(self): + self._warn() + return super().values() + + +class SelectableGroups(Deprecated, dict): + """ + A backward- and forward-compatible result from + entry_points that fully implements the dict interface. + """ + + @classmethod + def load(cls, eps): + by_group = operator.attrgetter('group') + ordered = sorted(eps, key=by_group) + grouped = itertools.groupby(ordered, by_group) + return cls((group, EntryPoints(eps)) for group, eps in grouped) + + @property + def _all(self): + """ + Reconstruct a list of all entrypoints from the groups. + """ + groups = super(Deprecated, self).values() + return EntryPoints(itertools.chain.from_iterable(groups)) + + @property + def groups(self): + return self._all.groups + + @property + def names(self): + """ + for coverage: + >>> SelectableGroups().names + set() + """ + return self._all.names + + def select(self, **params): + if not params: + return self + return self._all.select(**params) + + +class PackagePath(pathlib.PurePosixPath): + """A reference to a path in a package""" + + def read_text(self, encoding='utf-8'): + with self.locate().open(encoding=encoding) as stream: + return stream.read() + + def read_binary(self): + with self.locate().open('rb') as stream: + return stream.read() + + def locate(self): + """Return a path-like object for this path""" + return self.dist.locate_file(self) + + +class FileHash: + def __init__(self, spec): + self.mode, _, self.value = spec.partition('=') + + def __repr__(self): + return f'' + + +class Distribution: + """A Python distribution package.""" + + @abc.abstractmethod + def read_text(self, filename): + """Attempt to load metadata file given by the name. + + :param filename: The name of the file in the distribution info. + :return: The text if found, otherwise None. + """ + + @abc.abstractmethod + def locate_file(self, path): + """ + Given a path to a file in this distribution, return a path + to it. + """ + + @classmethod + def from_name(cls, name: str): + """Return the Distribution for the given package name. + + :param name: The name of the distribution package to search for. + :return: The Distribution instance (or subclass thereof) for the named + package, if found. + :raises PackageNotFoundError: When the named package's distribution + metadata cannot be found. + :raises ValueError: When an invalid value is supplied for name. + """ + if not name: + raise ValueError("A distribution name is required.") + try: + return next(cls.discover(name=name)) + except StopIteration: + raise PackageNotFoundError(name) + + @classmethod + def discover(cls, **kwargs): + """Return an iterable of Distribution objects for all packages. + + Pass a ``context`` or pass keyword arguments for constructing + a context. + + :context: A ``DistributionFinder.Context`` object. + :return: Iterable of Distribution objects for all packages. + """ + context = kwargs.pop('context', None) + if context and kwargs: + raise ValueError("cannot accept context and kwargs") + context = context or DistributionFinder.Context(**kwargs) + return itertools.chain.from_iterable( + resolver(context) for resolver in cls._discover_resolvers() + ) + + @staticmethod + def at(path): + """Return a Distribution for the indicated metadata path + + :param path: a string or path-like object + :return: a concrete Distribution instance for the path + """ + return PathDistribution(pathlib.Path(path)) + + @staticmethod + def _discover_resolvers(): + """Search the meta_path for resolvers.""" + declared = ( + getattr(finder, 'find_distributions', None) for finder in sys.meta_path + ) + return filter(None, declared) + + @property + def metadata(self) -> _meta.PackageMetadata: + """Return the parsed metadata for this Distribution. + + The returned object will have keys that name the various bits of + metadata. See PEP 566 for details. + """ + text = ( + self.read_text('METADATA') + or self.read_text('PKG-INFO') + # This last clause is here to support old egg-info files. Its + # effect is to just end up using the PathDistribution's self._path + # (which points to the egg-info file) attribute unchanged. + or self.read_text('') + ) + return _adapters.Message(email.message_from_string(text)) + + @property + def name(self): + """Return the 'Name' metadata for the distribution package.""" + return self.metadata['Name'] + + @property + def _normalized_name(self): + """Return a normalized version of the name.""" + return Prepared.normalize(self.name) + + @property + def version(self): + """Return the 'Version' metadata for the distribution package.""" + return self.metadata['Version'] + + @property + def entry_points(self): + return EntryPoints._from_text_for(self.read_text('entry_points.txt'), self) + + @property + def files(self): + """Files in this distribution. + + :return: List of PackagePath for this distribution or None + + Result is `None` if the metadata file that enumerates files + (i.e. RECORD for dist-info or SOURCES.txt for egg-info) is + missing. + Result may be empty if the metadata exists but is empty. + """ + + def make_file(name, hash=None, size_str=None): + result = PackagePath(name) + result.hash = FileHash(hash) if hash else None + result.size = int(size_str) if size_str else None + result.dist = self + return result + + @pass_none + def make_files(lines): + return list(starmap(make_file, csv.reader(lines))) + + return make_files(self._read_files_distinfo() or self._read_files_egginfo()) + + def _read_files_distinfo(self): + """ + Read the lines of RECORD + """ + text = self.read_text('RECORD') + return text and text.splitlines() + + def _read_files_egginfo(self): + """ + SOURCES.txt might contain literal commas, so wrap each line + in quotes. + """ + text = self.read_text('SOURCES.txt') + return text and map('"{}"'.format, text.splitlines()) + + @property + def requires(self): + """Generated requirements specified for this Distribution""" + reqs = self._read_dist_info_reqs() or self._read_egg_info_reqs() + return reqs and list(reqs) + + def _read_dist_info_reqs(self): + return self.metadata.get_all('Requires-Dist') + + def _read_egg_info_reqs(self): + source = self.read_text('requires.txt') + return pass_none(self._deps_from_requires_text)(source) + + @classmethod + def _deps_from_requires_text(cls, source): + return cls._convert_egg_info_reqs_to_simple_reqs(Sectioned.read(source)) + + @staticmethod + def _convert_egg_info_reqs_to_simple_reqs(sections): + """ + Historically, setuptools would solicit and store 'extra' + requirements, including those with environment markers, + in separate sections. More modern tools expect each + dependency to be defined separately, with any relevant + extras and environment markers attached directly to that + requirement. This method converts the former to the + latter. See _test_deps_from_requires_text for an example. + """ + + def make_condition(name): + return name and f'extra == "{name}"' + + def quoted_marker(section): + section = section or '' + extra, sep, markers = section.partition(':') + if extra and markers: + markers = f'({markers})' + conditions = list(filter(None, [markers, make_condition(extra)])) + return '; ' + ' and '.join(conditions) if conditions else '' + + def url_req_space(req): + """ + PEP 508 requires a space between the url_spec and the quoted_marker. + Ref python/importlib_metadata#357. + """ + # '@' is uniquely indicative of a url_req. + return ' ' * ('@' in req) + + for section in sections: + space = url_req_space(section.value) + yield section.value + space + quoted_marker(section.name) + + +class DistributionFinder(MetaPathFinder): + """ + A MetaPathFinder capable of discovering installed distributions. + """ + + class Context: + """ + Keyword arguments presented by the caller to + ``distributions()`` or ``Distribution.discover()`` + to narrow the scope of a search for distributions + in all DistributionFinders. + + Each DistributionFinder may expect any parameters + and should attempt to honor the canonical + parameters defined below when appropriate. + """ + + name = None + """ + Specific name for which a distribution finder should match. + A name of ``None`` matches all distributions. + """ + + def __init__(self, **kwargs): + vars(self).update(kwargs) + + @property + def path(self): + """ + The sequence of directory path that a distribution finder + should search. + + Typically refers to Python installed package paths such as + "site-packages" directories and defaults to ``sys.path``. + """ + return vars(self).get('path', sys.path) + + @abc.abstractmethod + def find_distributions(self, context=Context()): + """ + Find distributions. + + Return an iterable of all Distribution instances capable of + loading the metadata for packages matching the ``context``, + a DistributionFinder.Context instance. + """ + + +class FastPath: + """ + Micro-optimized class for searching a path for + children. + + >>> FastPath('').children() + ['...'] + """ + + @functools.lru_cache() # type: ignore + def __new__(cls, root): + return super().__new__(cls) + + def __init__(self, root): + self.root = root + + def joinpath(self, child): + return pathlib.Path(self.root, child) + + def children(self): + with suppress(Exception): + return os.listdir(self.root or '.') + with suppress(Exception): + return self.zip_children() + return [] + + def zip_children(self): + zip_path = zipp.Path(self.root) + names = zip_path.root.namelist() + self.joinpath = zip_path.joinpath + + return dict.fromkeys(child.split(posixpath.sep, 1)[0] for child in names) + + def search(self, name): + return self.lookup(self.mtime).search(name) + + @property + def mtime(self): + with suppress(OSError): + return os.stat(self.root).st_mtime + self.lookup.cache_clear() + + @method_cache + def lookup(self, mtime): + return Lookup(self) + + +class Lookup: + def __init__(self, path: FastPath): + base = os.path.basename(path.root).lower() + base_is_egg = base.endswith(".egg") + self.infos = FreezableDefaultDict(list) + self.eggs = FreezableDefaultDict(list) + + for child in path.children(): + low = child.lower() + if low.endswith((".dist-info", ".egg-info")): + # rpartition is faster than splitext and suitable for this purpose. + name = low.rpartition(".")[0].partition("-")[0] + normalized = Prepared.normalize(name) + self.infos[normalized].append(path.joinpath(child)) + elif base_is_egg and low == "egg-info": + name = base.rpartition(".")[0].partition("-")[0] + legacy_normalized = Prepared.legacy_normalize(name) + self.eggs[legacy_normalized].append(path.joinpath(child)) + + self.infos.freeze() + self.eggs.freeze() + + def search(self, prepared): + infos = ( + self.infos[prepared.normalized] + if prepared + else itertools.chain.from_iterable(self.infos.values()) + ) + eggs = ( + self.eggs[prepared.legacy_normalized] + if prepared + else itertools.chain.from_iterable(self.eggs.values()) + ) + return itertools.chain(infos, eggs) + + +class Prepared: + """ + A prepared search for metadata on a possibly-named package. + """ + + normalized = None + legacy_normalized = None + + def __init__(self, name): + self.name = name + if name is None: + return + self.normalized = self.normalize(name) + self.legacy_normalized = self.legacy_normalize(name) + + @staticmethod + def normalize(name): + """ + PEP 503 normalization plus dashes as underscores. + """ + return re.sub(r"[-_.]+", "-", name).lower().replace('-', '_') + + @staticmethod + def legacy_normalize(name): + """ + Normalize the package name as found in the convention in + older packaging tools versions and specs. + """ + return name.lower().replace('-', '_') + + def __bool__(self): + return bool(self.name) + + +@install +class MetadataPathFinder(NullFinder, DistributionFinder): + """A degenerate finder for distribution packages on the file system. + + This finder supplies only a find_distributions() method for versions + of Python that do not have a PathFinder find_distributions(). + """ + + def find_distributions(self, context=DistributionFinder.Context()): + """ + Find distributions. + + Return an iterable of all Distribution instances capable of + loading the metadata for packages matching ``context.name`` + (or all names if ``None`` indicated) along the paths in the list + of directories ``context.path``. + """ + found = self._search_paths(context.name, context.path) + return map(PathDistribution, found) + + @classmethod + def _search_paths(cls, name, paths): + """Find metadata directories in paths heuristically.""" + prepared = Prepared(name) + return itertools.chain.from_iterable( + path.search(prepared) for path in map(FastPath, paths) + ) + + def invalidate_caches(cls): + FastPath.__new__.cache_clear() + + +class PathDistribution(Distribution): + def __init__(self, path: SimplePath): + """Construct a distribution. + + :param path: SimplePath indicating the metadata directory. + """ + self._path = path + + def read_text(self, filename): + with suppress( + FileNotFoundError, + IsADirectoryError, + KeyError, + NotADirectoryError, + PermissionError, + ): + return self._path.joinpath(filename).read_text(encoding='utf-8') + + read_text.__doc__ = Distribution.read_text.__doc__ + + def locate_file(self, path): + return self._path.parent / path + + @property + def _normalized_name(self): + """ + Performance optimization: where possible, resolve the + normalized name from the file system path. + """ + stem = os.path.basename(str(self._path)) + return ( + pass_none(Prepared.normalize)(self._name_from_stem(stem)) + or super()._normalized_name + ) + + @staticmethod + def _name_from_stem(stem): + """ + >>> PathDistribution._name_from_stem('foo-3.0.egg-info') + 'foo' + >>> PathDistribution._name_from_stem('CherryPy-3.0.dist-info') + 'CherryPy' + >>> PathDistribution._name_from_stem('face.egg-info') + 'face' + >>> PathDistribution._name_from_stem('foo.bar') + """ + filename, ext = os.path.splitext(stem) + if ext not in ('.dist-info', '.egg-info'): + return + name, sep, rest = filename.partition('-') + return name + + +def distribution(distribution_name): + """Get the ``Distribution`` instance for the named package. + + :param distribution_name: The name of the distribution package as a string. + :return: A ``Distribution`` instance (or subclass thereof). + """ + return Distribution.from_name(distribution_name) + + +def distributions(**kwargs): + """Get all ``Distribution`` instances in the current environment. + + :return: An iterable of ``Distribution`` instances. + """ + return Distribution.discover(**kwargs) + + +def metadata(distribution_name) -> _meta.PackageMetadata: + """Get the metadata for the named package. + + :param distribution_name: The name of the distribution package to query. + :return: A PackageMetadata containing the parsed metadata. + """ + return Distribution.from_name(distribution_name).metadata + + +def version(distribution_name): + """Get the version string for the named package. + + :param distribution_name: The name of the distribution package to query. + :return: The version string for the package as defined in the package's + "Version" metadata key. + """ + return distribution(distribution_name).version + + +_unique = functools.partial( + unique_everseen, + key=operator.attrgetter('_normalized_name'), +) +""" +Wrapper for ``distributions`` to return unique distributions by name. +""" + + +def entry_points(**params) -> Union[EntryPoints, SelectableGroups]: + """Return EntryPoint objects for all installed packages. + + Pass selection parameters (group or name) to filter the + result to entry points matching those properties (see + EntryPoints.select()). + + For compatibility, returns ``SelectableGroups`` object unless + selection parameters are supplied. In the future, this function + will return ``EntryPoints`` instead of ``SelectableGroups`` + even when no selection parameters are supplied. + + For maximum future compatibility, pass selection parameters + or invoke ``.select`` with parameters on the result. + + :return: EntryPoints or SelectableGroups for all installed packages. + """ + eps = itertools.chain.from_iterable( + dist.entry_points for dist in _unique(distributions()) + ) + return SelectableGroups.load(eps).select(**params) + + +def files(distribution_name): + """Return a list of files for the named package. + + :param distribution_name: The name of the distribution package to query. + :return: List of files composing the distribution. + """ + return distribution(distribution_name).files + + +def requires(distribution_name): + """ + Return a list of requirements for the named package. + + :return: An iterator of requirements, suitable for + packaging.requirement.Requirement. + """ + return distribution(distribution_name).requires + + +def packages_distributions() -> Mapping[str, List[str]]: + """ + Return a mapping of top-level packages to their + distributions. + + >>> import collections.abc + >>> pkgs = packages_distributions() + >>> all(isinstance(dist, collections.abc.Sequence) for dist in pkgs.values()) + True + """ + pkg_to_dist = collections.defaultdict(list) + for dist in distributions(): + for pkg in _top_level_declared(dist) or _top_level_inferred(dist): + pkg_to_dist[pkg].append(dist.metadata['Name']) + return dict(pkg_to_dist) + + +def _top_level_declared(dist): + return (dist.read_text('top_level.txt') or '').split() + + +def _top_level_inferred(dist): + return { + f.parts[0] if len(f.parts) > 1 else f.with_suffix('').name + for f in always_iterable(dist.files) + if f.suffix == ".py" + } diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/importlib_metadata/_adapters.py b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/importlib_metadata/_adapters.py new file mode 100644 index 0000000000000000000000000000000000000000..aa460d3eda50fbb174623a1b5bbca54645fd588a --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/importlib_metadata/_adapters.py @@ -0,0 +1,68 @@ +import re +import textwrap +import email.message + +from ._text import FoldedCase + + +class Message(email.message.Message): + multiple_use_keys = set( + map( + FoldedCase, + [ + 'Classifier', + 'Obsoletes-Dist', + 'Platform', + 'Project-URL', + 'Provides-Dist', + 'Provides-Extra', + 'Requires-Dist', + 'Requires-External', + 'Supported-Platform', + 'Dynamic', + ], + ) + ) + """ + Keys that may be indicated multiple times per PEP 566. + """ + + def __new__(cls, orig: email.message.Message): + res = super().__new__(cls) + vars(res).update(vars(orig)) + return res + + def __init__(self, *args, **kwargs): + self._headers = self._repair_headers() + + # suppress spurious error from mypy + def __iter__(self): + return super().__iter__() + + def _repair_headers(self): + def redent(value): + "Correct for RFC822 indentation" + if not value or '\n' not in value: + return value + return textwrap.dedent(' ' * 8 + value) + + headers = [(key, redent(value)) for key, value in vars(self)['_headers']] + if self._payload: + headers.append(('Description', self.get_payload())) + return headers + + @property + def json(self): + """ + Convert PackageMetadata to a JSON-compatible format + per PEP 0566. + """ + + def transform(key): + value = self.get_all(key) if key in self.multiple_use_keys else self[key] + if key == 'Keywords': + value = re.split(r'\s+', value) + tk = key.lower().replace('-', '_') + return tk, value + + return dict(map(transform, map(FoldedCase, self))) diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/importlib_metadata/_collections.py b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/importlib_metadata/_collections.py new file mode 100644 index 0000000000000000000000000000000000000000..cf0954e1a30546d781bf25781ec716ef92a77e32 --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/importlib_metadata/_collections.py @@ -0,0 +1,30 @@ +import collections + + +# from jaraco.collections 3.3 +class FreezableDefaultDict(collections.defaultdict): + """ + Often it is desirable to prevent the mutation of + a default dict after its initial construction, such + as to prevent mutation during iteration. + + >>> dd = FreezableDefaultDict(list) + >>> dd[0].append('1') + >>> dd.freeze() + >>> dd[1] + [] + >>> len(dd) + 1 + """ + + def __missing__(self, key): + return getattr(self, '_frozen', super().__missing__)(key) + + def freeze(self): + self._frozen = lambda key: self.default_factory() + + +class Pair(collections.namedtuple('Pair', 'name value')): + @classmethod + def parse(cls, text): + return cls(*map(str.strip, text.split("=", 1))) diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/importlib_metadata/_compat.py b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/importlib_metadata/_compat.py new file mode 100644 index 0000000000000000000000000000000000000000..3d78566ea3a98d175c89a1992dadfaa61f2df27e --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/importlib_metadata/_compat.py @@ -0,0 +1,72 @@ +import sys +import platform + + +__all__ = ['install', 'NullFinder', 'Protocol'] + + +try: + from typing import Protocol +except ImportError: # pragma: no cover + # Python 3.7 compatibility + from typing_extensions import Protocol # type: ignore + + +def install(cls): + """ + Class decorator for installation on sys.meta_path. + + Adds the backport DistributionFinder to sys.meta_path and + attempts to disable the finder functionality of the stdlib + DistributionFinder. + """ + sys.meta_path.append(cls()) + disable_stdlib_finder() + return cls + + +def disable_stdlib_finder(): + """ + Give the backport primacy for discovering path-based distributions + by monkey-patching the stdlib O_O. + + See #91 for more background for rationale on this sketchy + behavior. + """ + + def matches(finder): + return getattr( + finder, '__module__', None + ) == '_frozen_importlib_external' and hasattr(finder, 'find_distributions') + + for finder in filter(matches, sys.meta_path): # pragma: nocover + del finder.find_distributions + + +class NullFinder: + """ + A "Finder" (aka "MetaClassFinder") that never finds any modules, + but may find distributions. + """ + + @staticmethod + def find_spec(*args, **kwargs): + return None + + # In Python 2, the import system requires finders + # to have a find_module() method, but this usage + # is deprecated in Python 3 in favor of find_spec(). + # For the purposes of this finder (i.e. being present + # on sys.meta_path but having no other import + # system functionality), the two methods are identical. + find_module = find_spec + + +def pypy_partial(val): + """ + Adjust for variable stacklevel on partial under PyPy. + + Workaround for #327. + """ + is_pypy = platform.python_implementation() == 'PyPy' + return val + is_pypy diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/importlib_metadata/_functools.py b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/importlib_metadata/_functools.py new file mode 100644 index 0000000000000000000000000000000000000000..71f66bd03cb713a2190853bdf7170c4ea80d2425 --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/importlib_metadata/_functools.py @@ -0,0 +1,104 @@ +import types +import functools + + +# from jaraco.functools 3.3 +def method_cache(method, cache_wrapper=None): + """ + Wrap lru_cache to support storing the cache data in the object instances. + + Abstracts the common paradigm where the method explicitly saves an + underscore-prefixed protected property on first call and returns that + subsequently. + + >>> class MyClass: + ... calls = 0 + ... + ... @method_cache + ... def method(self, value): + ... self.calls += 1 + ... return value + + >>> a = MyClass() + >>> a.method(3) + 3 + >>> for x in range(75): + ... res = a.method(x) + >>> a.calls + 75 + + Note that the apparent behavior will be exactly like that of lru_cache + except that the cache is stored on each instance, so values in one + instance will not flush values from another, and when an instance is + deleted, so are the cached values for that instance. + + >>> b = MyClass() + >>> for x in range(35): + ... res = b.method(x) + >>> b.calls + 35 + >>> a.method(0) + 0 + >>> a.calls + 75 + + Note that if method had been decorated with ``functools.lru_cache()``, + a.calls would have been 76 (due to the cached value of 0 having been + flushed by the 'b' instance). + + Clear the cache with ``.cache_clear()`` + + >>> a.method.cache_clear() + + Same for a method that hasn't yet been called. + + >>> c = MyClass() + >>> c.method.cache_clear() + + Another cache wrapper may be supplied: + + >>> cache = functools.lru_cache(maxsize=2) + >>> MyClass.method2 = method_cache(lambda self: 3, cache_wrapper=cache) + >>> a = MyClass() + >>> a.method2() + 3 + + Caution - do not subsequently wrap the method with another decorator, such + as ``@property``, which changes the semantics of the function. + + See also + http://code.activestate.com/recipes/577452-a-memoize-decorator-for-instance-methods/ + for another implementation and additional justification. + """ + cache_wrapper = cache_wrapper or functools.lru_cache() + + def wrapper(self, *args, **kwargs): + # it's the first call, replace the method with a cached, bound method + bound_method = types.MethodType(method, self) + cached_method = cache_wrapper(bound_method) + setattr(self, method.__name__, cached_method) + return cached_method(*args, **kwargs) + + # Support cache clear even before cache has been created. + wrapper.cache_clear = lambda: None + + return wrapper + + +# From jaraco.functools 3.3 +def pass_none(func): + """ + Wrap func so it's not called if its first param is None + + >>> print_text = pass_none(print) + >>> print_text('text') + text + >>> print_text(None) + """ + + @functools.wraps(func) + def wrapper(param, *args, **kwargs): + if param is not None: + return func(param, *args, **kwargs) + + return wrapper diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/importlib_metadata/_itertools.py b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/importlib_metadata/_itertools.py new file mode 100644 index 0000000000000000000000000000000000000000..d4ca9b9140e3f085b36609bb8dfdaea79c78e144 --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/importlib_metadata/_itertools.py @@ -0,0 +1,73 @@ +from itertools import filterfalse + + +def unique_everseen(iterable, key=None): + "List unique elements, preserving order. Remember all elements ever seen." + # unique_everseen('AAAABBBCCDAABBB') --> A B C D + # unique_everseen('ABBCcAD', str.lower) --> A B C D + seen = set() + seen_add = seen.add + if key is None: + for element in filterfalse(seen.__contains__, iterable): + seen_add(element) + yield element + else: + for element in iterable: + k = key(element) + if k not in seen: + seen_add(k) + yield element + + +# copied from more_itertools 8.8 +def always_iterable(obj, base_type=(str, bytes)): + """If *obj* is iterable, return an iterator over its items:: + + >>> obj = (1, 2, 3) + >>> list(always_iterable(obj)) + [1, 2, 3] + + If *obj* is not iterable, return a one-item iterable containing *obj*:: + + >>> obj = 1 + >>> list(always_iterable(obj)) + [1] + + If *obj* is ``None``, return an empty iterable: + + >>> obj = None + >>> list(always_iterable(None)) + [] + + By default, binary and text strings are not considered iterable:: + + >>> obj = 'foo' + >>> list(always_iterable(obj)) + ['foo'] + + If *base_type* is set, objects for which ``isinstance(obj, base_type)`` + returns ``True`` won't be considered iterable. + + >>> obj = {'a': 1} + >>> list(always_iterable(obj)) # Iterate over the dict's keys + ['a'] + >>> list(always_iterable(obj, base_type=dict)) # Treat dicts as a unit + [{'a': 1}] + + Set *base_type* to ``None`` to avoid any special handling and treat objects + Python considers iterable as iterable: + + >>> obj = 'foo' + >>> list(always_iterable(obj, base_type=None)) + ['f', 'o', 'o'] + """ + if obj is None: + return iter(()) + + if (base_type is not None) and isinstance(obj, base_type): + return iter((obj,)) + + try: + return iter(obj) + except TypeError: + return iter((obj,)) diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/importlib_metadata/_meta.py b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/importlib_metadata/_meta.py new file mode 100644 index 0000000000000000000000000000000000000000..37ee43e6ef447dfb4ae68f5f6c35597d12fdc5a1 --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/importlib_metadata/_meta.py @@ -0,0 +1,48 @@ +from ._compat import Protocol +from typing import Any, Dict, Iterator, List, TypeVar, Union + + +_T = TypeVar("_T") + + +class PackageMetadata(Protocol): + def __len__(self) -> int: + ... # pragma: no cover + + def __contains__(self, item: str) -> bool: + ... # pragma: no cover + + def __getitem__(self, key: str) -> str: + ... # pragma: no cover + + def __iter__(self) -> Iterator[str]: + ... # pragma: no cover + + def get_all(self, name: str, failobj: _T = ...) -> Union[List[Any], _T]: + """ + Return all values associated with a possibly multi-valued key. + """ + + @property + def json(self) -> Dict[str, Union[str, List[str]]]: + """ + A JSON-compatible form of the metadata. + """ + + +class SimplePath(Protocol): + """ + A minimal subset of pathlib.Path required by PathDistribution. + """ + + def joinpath(self) -> 'SimplePath': + ... # pragma: no cover + + def __truediv__(self) -> 'SimplePath': + ... # pragma: no cover + + def parent(self) -> 'SimplePath': + ... # pragma: no cover + + def read_text(self) -> str: + ... # pragma: no cover diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/importlib_metadata/_text.py b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/importlib_metadata/_text.py new file mode 100644 index 0000000000000000000000000000000000000000..c88cfbb2349c6401336bc5ba6623f51afd1eb59d --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/importlib_metadata/_text.py @@ -0,0 +1,99 @@ +import re + +from ._functools import method_cache + + +# from jaraco.text 3.5 +class FoldedCase(str): + """ + A case insensitive string class; behaves just like str + except compares equal when the only variation is case. + + >>> s = FoldedCase('hello world') + + >>> s == 'Hello World' + True + + >>> 'Hello World' == s + True + + >>> s != 'Hello World' + False + + >>> s.index('O') + 4 + + >>> s.split('O') + ['hell', ' w', 'rld'] + + >>> sorted(map(FoldedCase, ['GAMMA', 'alpha', 'Beta'])) + ['alpha', 'Beta', 'GAMMA'] + + Sequence membership is straightforward. + + >>> "Hello World" in [s] + True + >>> s in ["Hello World"] + True + + You may test for set inclusion, but candidate and elements + must both be folded. + + >>> FoldedCase("Hello World") in {s} + True + >>> s in {FoldedCase("Hello World")} + True + + String inclusion works as long as the FoldedCase object + is on the right. + + >>> "hello" in FoldedCase("Hello World") + True + + But not if the FoldedCase object is on the left: + + >>> FoldedCase('hello') in 'Hello World' + False + + In that case, use in_: + + >>> FoldedCase('hello').in_('Hello World') + True + + >>> FoldedCase('hello') > FoldedCase('Hello') + False + """ + + def __lt__(self, other): + return self.lower() < other.lower() + + def __gt__(self, other): + return self.lower() > other.lower() + + def __eq__(self, other): + return self.lower() == other.lower() + + def __ne__(self, other): + return self.lower() != other.lower() + + def __hash__(self): + return hash(self.lower()) + + def __contains__(self, other): + return super().lower().__contains__(other.lower()) + + def in_(self, other): + "Does self appear in other?" + return self in FoldedCase(other) + + # cache lower since it's likely to be called frequently. + @method_cache + def lower(self): + return super().lower() + + def index(self, sub): + return self.lower().index(sub.lower()) + + def split(self, splitter=' ', maxsplit=0): + pattern = re.compile(re.escape(splitter), re.I) + return pattern.split(self, maxsplit) diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/importlib_metadata/py.typed b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/importlib_metadata/py.typed new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/numpy-1.23.0.dist-info/INSTALLER b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/numpy-1.23.0.dist-info/INSTALLER new file mode 100644 index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68 --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/numpy-1.23.0.dist-info/INSTALLER @@ -0,0 +1 @@ +pip diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/numpy-1.23.0.dist-info/LICENSE.txt b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/numpy-1.23.0.dist-info/LICENSE.txt new file mode 100644 index 0000000000000000000000000000000000000000..7d18210bc55ab19347d7f8781222b89e5cda9c11 --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/numpy-1.23.0.dist-info/LICENSE.txt @@ -0,0 +1,910 @@ +Copyright (c) 2005-2022, 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. + +---- + +This binary distribution of NumPy also bundles the following software: + + +Name: OpenBLAS +Files: .libs/libopenb*.so +Description: bundled as a dynamically linked library +Availability: https://github.com/xianyi/OpenBLAS/ +License: 3-clause BSD + 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: .libs/libopenb*.so +Description: bundled in OpenBLAS +Availability: https://github.com/xianyi/OpenBLAS/ +License 3-clause BSD + 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: .libs/libgfortran*.so +Description: dynamically linked to files compiled with gcc +Availability: https://gcc.gnu.org/viewcvs/gcc/ +License: GPLv3 + runtime exception + 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 + . + +---- + +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. + +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. + 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. + + + Copyright (C) + + 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 . + +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: + + Copyright (C) + 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 +. + + 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 +. diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/numpy-1.23.0.dist-info/LICENSES_bundled.txt b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/numpy-1.23.0.dist-info/LICENSES_bundled.txt new file mode 100644 index 0000000000000000000000000000000000000000..26c7a7829361f509728fc4c53146377437588dde --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/numpy-1.23.0.dist-info/LICENSES_bundled.txt @@ -0,0 +1,22 @@ +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: tempita +Files: tools/npy_tempita/* +License: MIT + For details, see tools/npy_tempita/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 diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/numpy-1.23.0.dist-info/METADATA b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/numpy-1.23.0.dist-info/METADATA new file mode 100644 index 0000000000000000000000000000000000000000..a3f136fd8024c8c3e43544f01abd1d9a98fc8175 --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/numpy-1.23.0.dist-info/METADATA @@ -0,0 +1,63 @@ +Metadata-Version: 2.1 +Name: numpy +Version: 1.23.0 +Summary: NumPy is the fundamental package for array computing with Python. +Home-page: https://www.numpy.org +Author: Travis E. Oliphant et al. +Maintainer: NumPy Developers +Maintainer-email: numpy-discussion@python.org +License: BSD +Download-URL: https://pypi.python.org/pypi/numpy +Project-URL: Bug Tracker, https://github.com/numpy/numpy/issues +Project-URL: Documentation, https://numpy.org/doc/1.23 +Project-URL: Source Code, https://github.com/numpy/numpy +Platform: Windows +Platform: Linux +Platform: Solaris +Platform: Mac OS-X +Platform: Unix +Classifier: Development Status :: 5 - Production/Stable +Classifier: Intended Audience :: Science/Research +Classifier: Intended Audience :: Developers +Classifier: License :: OSI Approved :: BSD License +Classifier: Programming Language :: C +Classifier: Programming Language :: Python +Classifier: Programming Language :: Python :: 3 +Classifier: Programming Language :: Python :: 3.8 +Classifier: Programming Language :: Python :: 3.9 +Classifier: Programming Language :: Python :: 3.10 +Classifier: Programming Language :: Python :: 3 :: Only +Classifier: Programming Language :: Python :: Implementation :: CPython +Classifier: Topic :: Software Development +Classifier: Topic :: Scientific/Engineering +Classifier: Typing :: Typed +Classifier: Operating System :: Microsoft :: Windows +Classifier: Operating System :: POSIX +Classifier: Operating System :: Unix +Classifier: Operating System :: MacOS +Requires-Python: >=3.8 +License-File: LICENSE.txt +License-File: LICENSES_bundled.txt + +It provides: + +- a powerful N-dimensional array object +- sophisticated (broadcasting) functions +- tools for integrating C/C++ and Fortran code +- useful linear algebra, Fourier transform, and random number capabilities +- and much more + +Besides its obvious scientific uses, NumPy can also be used as an efficient +multi-dimensional container of generic data. Arbitrary data-types can be +defined. This allows NumPy to seamlessly and speedily integrate with a wide +variety of databases. + +All NumPy wheels distributed on PyPI are BSD licensed. + +NumPy requires ``pytest`` and ``hypothesis``. Tests can then be run after +installation with:: + + python -c 'import numpy; numpy.test()' + + + diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/numpy-1.23.0.dist-info/RECORD b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/numpy-1.23.0.dist-info/RECORD new file mode 100644 index 0000000000000000000000000000000000000000..8fa6eab9b0c41ad2f8fe9d55e94184b83d7e07a2 --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/numpy-1.23.0.dist-info/RECORD @@ -0,0 +1,1344 @@ +../../../bin/f2py,sha256=rcP6B_Y0_6RO0ZwGphBpPA8q8IjF8jbBYlERj33-cGc,234 +../../../bin/f2py3,sha256=rcP6B_Y0_6RO0ZwGphBpPA8q8IjF8jbBYlERj33-cGc,234 +../../../bin/f2py3.8,sha256=rcP6B_Y0_6RO0ZwGphBpPA8q8IjF8jbBYlERj33-cGc,234 +numpy-1.23.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +numpy-1.23.0.dist-info/LICENSE.txt,sha256=ATdhUdRkXvut-KobrcV16_CzXbH65FRWBNVF9cmzL94,45692 +numpy-1.23.0.dist-info/LICENSES_bundled.txt,sha256=VyI3ubJn_nVdgqKOIT9pF2vVavoWKlpkGzegbjAHKNE,634 +numpy-1.23.0.dist-info/METADATA,sha256=apTozUcOiQ3YBkHMwJzvvSZO6kVTH9PeWo1VOPujOgw,2245 +numpy-1.23.0.dist-info/RECORD,, +numpy-1.23.0.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +numpy-1.23.0.dist-info/WHEEL,sha256=paN2rHE-sLfyg0Z4YvQnentMRWXxZnkclRDH8E5J6qk,148 +numpy-1.23.0.dist-info/entry_points.txt,sha256=7wkWO3l4wq2AL2TSwwUgDlagIOnk2Vk2AIpeCQCgCgE,208 +numpy-1.23.0.dist-info/top_level.txt,sha256=4J9lbBMLnAiyxatxh8iRKV5Entd_6-oqbO7pzJjMsPw,6 +numpy.libs/libgfortran-040039e1.so.5.0.0,sha256=R6s7aClbCjzomQpEjef6sRq928Fg-IlZcsqapxLPhtA,2686064 +numpy.libs/libopenblas64_p-r0-742d56dc.3.20.so,sha256=OOcpiSH7XIZzSXJKoh5F0rb1HxZq2004q0AWqvxLDp4,32876856 +numpy.libs/libquadmath-96973f99.so.0.0.0,sha256=l82oXdtRY-Labh7bTh1rVXgzqZpA7aB5rjflA5Rltl0,247608 +numpy/LICENSE.txt,sha256=ATdhUdRkXvut-KobrcV16_CzXbH65FRWBNVF9cmzL94,45692 +numpy/__config__.py,sha256=TXvjW8PcKIkWSx3pLCYYC2SMqmRP-0gKkOOvckDq6Ao,5143 +numpy/__init__.cython-30.pxd,sha256=_i5eaLZlfHTIF8mDwNehqFvem0CZGtHmU6gIQ1tlDIw,36216 +numpy/__init__.pxd,sha256=0CIC53c2iCvgV5itsP73rUHiAjkJ85XIoBOzrul-L9Y,34584 +numpy/__init__.py,sha256=jL1d6ssSES4DE9uim82tR1FhaFC-9DmqutPAjR5YpX0,15398 +numpy/__init__.pyi,sha256=stlWhRdeH2OD7Aoc1v7kNTqDEivxX_w_yLGqP6QPZ4M,150441 +numpy/__pycache__/__config__.cpython-38.pyc,, +numpy/__pycache__/__init__.cpython-38.pyc,, +numpy/__pycache__/_distributor_init.cpython-38.pyc,, +numpy/__pycache__/_globals.cpython-38.pyc,, +numpy/__pycache__/_pytesttester.cpython-38.pyc,, +numpy/__pycache__/_version.cpython-38.pyc,, +numpy/__pycache__/conftest.cpython-38.pyc,, +numpy/__pycache__/ctypeslib.cpython-38.pyc,, +numpy/__pycache__/dual.cpython-38.pyc,, +numpy/__pycache__/matlib.cpython-38.pyc,, +numpy/__pycache__/setup.cpython-38.pyc,, +numpy/__pycache__/version.cpython-38.pyc,, +numpy/_distributor_init.py,sha256=IgPkSK3H9bgjFeUfWuXhjKrgetQl5ztUW-rTyjGHK3c,331 +numpy/_globals.py,sha256=7caMABrVnW1J0gEgXrEJM2EbuKVplZaKOsXnpLPuUG4,4012 +numpy/_pyinstaller/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +numpy/_pyinstaller/__pycache__/__init__.cpython-38.pyc,, +numpy/_pyinstaller/__pycache__/hook-numpy.cpython-38.pyc,, +numpy/_pyinstaller/__pycache__/pyinstaller-smoke.cpython-38.pyc,, +numpy/_pyinstaller/__pycache__/test_pyinstaller.cpython-38.pyc,, +numpy/_pyinstaller/hook-numpy.py,sha256=NiNJWF0o2g-vuyKTHGSe3UoDvDRmQPBBTeZfSMAFoJY,1422 +numpy/_pyinstaller/pyinstaller-smoke.py,sha256=2upSmDDbWg4hEy1nb6l_N08Dg0TxyLKooNwN7vVDAyw,1143 +numpy/_pyinstaller/test_pyinstaller.py,sha256=8K-7QxmfoXCG0NwR0bhIgCNrDjGlrTzWnrR1sR8btgU,1135 +numpy/_pytesttester.py,sha256=u2ESexAVeDbwRMIrmrnLXvJFTTyCTW02ZBL_pKKDTQg,6676 +numpy/_pytesttester.pyi,sha256=OtyXSiuSy8o_78w3QNQRjMLpvvNyEdC0aMsx6T-vRxU,489 +numpy/_typing/__init__.py,sha256=Zz6g7euFKslhDVa-Kj6W14ZXg9Wkc_SqyVTC0T-auBY,7030 +numpy/_typing/__pycache__/__init__.cpython-38.pyc,, +numpy/_typing/__pycache__/_add_docstring.cpython-38.pyc,, +numpy/_typing/__pycache__/_array_like.cpython-38.pyc,, +numpy/_typing/__pycache__/_char_codes.cpython-38.pyc,, +numpy/_typing/__pycache__/_dtype_like.cpython-38.pyc,, +numpy/_typing/__pycache__/_extended_precision.cpython-38.pyc,, +numpy/_typing/__pycache__/_generic_alias.cpython-38.pyc,, +numpy/_typing/__pycache__/_nbit.cpython-38.pyc,, +numpy/_typing/__pycache__/_nested_sequence.cpython-38.pyc,, +numpy/_typing/__pycache__/_scalars.cpython-38.pyc,, +numpy/_typing/__pycache__/_shape.cpython-38.pyc,, +numpy/_typing/__pycache__/setup.cpython-38.pyc,, +numpy/_typing/_add_docstring.py,sha256=fviZAxCBB5w1OY5PnnP9Hj2Da7krEs8ixpj8yk_0aLM,3925 +numpy/_typing/_array_like.py,sha256=rKIu7UzPiJNe5mm_HS8BRQYZlHka9_X0QVQEsK5epVU,3845 +numpy/_typing/_callable.pyi,sha256=VyXYdESp5TysRSevd9nki_CW5nKq-f_VFCRspLKQU1c,10754 +numpy/_typing/_char_codes.py,sha256=LR51O5AUBDbCmJvlMoxyUvsfvb1p7WHrexgtTGtuWTc,5916 +numpy/_typing/_dtype_like.py,sha256=-UG_oqXJAnxMHnI5z70rpfYaXri5pby2dqZOpSVjXiI,5586 +numpy/_typing/_extended_precision.py,sha256=PfQZUM8xlS7lFXPVQbJJX1quiMKobeJJP4S9TvtyTrE,1111 +numpy/_typing/_generic_alias.py,sha256=T0qMxVf21fx4eoew-DM5B9nd3v5E5JFU6HTXNeaieKo,7458 +numpy/_typing/_nbit.py,sha256=-EQOShHpB3r30b4RVEcruQRTcTaFAZwtqCJ4BsvpEzA,345 +numpy/_typing/_nested_sequence.py,sha256=BFb0kI6--Ns0WCErCG1uvqwDboYz520bsRWjknqPzlM,2657 +numpy/_typing/_scalars.py,sha256=CRoiNAYZqELubR2hbplA5qom-k4kUpWLNX4GgX8Hli0,957 +numpy/_typing/_shape.py,sha256=tsMDZ41GBVM9PiGa3GpGV2gEWxP57c7HqmPMWKrkCQo,191 +numpy/_typing/_ufunc.pyi,sha256=EerfHGcn9U2N1Jwd-e4hH_eWwDRqtWea855VNzavZKg,11416 +numpy/_typing/setup.py,sha256=SE0Q6HPqDjWUfceA4yXgkII8y3z7EiSF0Z-MNwOIyG4,337 +numpy/_version.py,sha256=uTawcB2hCQJCjaOAbLjU1i_t5fi5P6FnEyOwg0V5XNI,498 +numpy/array_api/__init__.py,sha256=XvTzhp2_rt1tEPc4IPERZFp-Ij3_fTL6UES8qk-4VmY,10163 +numpy/array_api/__pycache__/__init__.cpython-38.pyc,, +numpy/array_api/__pycache__/_array_object.cpython-38.pyc,, +numpy/array_api/__pycache__/_constants.cpython-38.pyc,, +numpy/array_api/__pycache__/_creation_functions.cpython-38.pyc,, +numpy/array_api/__pycache__/_data_type_functions.cpython-38.pyc,, +numpy/array_api/__pycache__/_dtypes.cpython-38.pyc,, +numpy/array_api/__pycache__/_elementwise_functions.cpython-38.pyc,, +numpy/array_api/__pycache__/_manipulation_functions.cpython-38.pyc,, +numpy/array_api/__pycache__/_searching_functions.cpython-38.pyc,, +numpy/array_api/__pycache__/_set_functions.cpython-38.pyc,, +numpy/array_api/__pycache__/_sorting_functions.cpython-38.pyc,, +numpy/array_api/__pycache__/_statistical_functions.cpython-38.pyc,, +numpy/array_api/__pycache__/_typing.cpython-38.pyc,, +numpy/array_api/__pycache__/_utility_functions.cpython-38.pyc,, +numpy/array_api/__pycache__/linalg.cpython-38.pyc,, +numpy/array_api/__pycache__/setup.cpython-38.pyc,, +numpy/array_api/_array_object.py,sha256=5YD915C7EH_UJ2S6RIIxllZNE7QTlPZXnJU9sTpkMY4,43226 +numpy/array_api/_constants.py,sha256=Z6bImx0puhVuCwc5dPXvZ6TZt46exiuuX1TubSyQ62E,66 +numpy/array_api/_creation_functions.py,sha256=6SqHdzZqHOJFEyWFtqnj6KIKRivrGXxROlgnez_3Mt0,10050 +numpy/array_api/_data_type_functions.py,sha256=Hk00nh4MxXHBCJHRR7fS3fZAW7B982REfp_oSUbnG_k,4480 +numpy/array_api/_dtypes.py,sha256=WEy1XztJIbSI9kosFqesv_Fzb_bHwH_nOlrVFlhbyx0,3707 +numpy/array_api/_elementwise_functions.py,sha256=arizOQ2iM3d_bOFpk_rwwCXZM3Zyhx9_fnyCki6Z8eY,24772 +numpy/array_api/_manipulation_functions.py,sha256=EqLf8ZILAV1Se6CttZ-DD271V1-PgjDK5Ae_TD-NmqQ,2944 +numpy/array_api/_searching_functions.py,sha256=M75BEj5b94Z5cya6_OzbgvhR9GGIDGdJ8eyydJHuWPQ,1457 +numpy/array_api/_set_functions.py,sha256=80INpLVP-4bunDXUxmxI3dFW-guu_7rgWlAwuNzdsZE,2848 +numpy/array_api/_sorting_functions.py,sha256=V0pmt1xALcAy76SDqwIHnMUzpFqU98x648tH02X-k44,1754 +numpy/array_api/_statistical_functions.py,sha256=AxiYkz-lW1k8uFaQfCDXJrXiDzG6Qhju-hrm5A9IFSE,3378 +numpy/array_api/_typing.py,sha256=HN0Ao-n6m1XAuIFNkGEUQ56REPmPJ-lKSAernfUxoDc,1376 +numpy/array_api/_utility_functions.py,sha256=HwycylbPAgRVz4nZvjvwqN3mQnJbqKA-NRMaAvIP-CE,824 +numpy/array_api/linalg.py,sha256=BFjmN142NSko5a0efgL4xyqJQmTXXihJf2wGwC-8z4E,16535 +numpy/array_api/setup.py,sha256=Wx6qD7GU_APiqKolYPO0OHv4eHGYrjPZmDAgjWhOEhM,341 +numpy/array_api/tests/__init__.py,sha256=t_2GZ3lKcsu4ec4GMKPUDYaeMUJyDquBlQAcPgj7kFE,282 +numpy/array_api/tests/__pycache__/__init__.cpython-38.pyc,, +numpy/array_api/tests/__pycache__/test_array_object.cpython-38.pyc,, +numpy/array_api/tests/__pycache__/test_creation_functions.cpython-38.pyc,, +numpy/array_api/tests/__pycache__/test_data_type_functions.cpython-38.pyc,, +numpy/array_api/tests/__pycache__/test_elementwise_functions.cpython-38.pyc,, +numpy/array_api/tests/__pycache__/test_set_functions.cpython-38.pyc,, +numpy/array_api/tests/__pycache__/test_sorting_functions.cpython-38.pyc,, +numpy/array_api/tests/__pycache__/test_validation.cpython-38.pyc,, +numpy/array_api/tests/test_array_object.py,sha256=ZL1MinwghgckH0sPugxC8EEccneh7xmn6DL1Irb17do,15770 +numpy/array_api/tests/test_creation_functions.py,sha256=s3A1COWmXIAJdhzd8v7VtL-jbiSspskTqwYy0BTpmpw,5023 +numpy/array_api/tests/test_data_type_functions.py,sha256=Ukkpb-qjORIYb8T1FrStiwciDWaEr27qRso7QJgIS0E,422 +numpy/array_api/tests/test_elementwise_functions.py,sha256=_DEB5r6VCDVhUos7VDaFzCId2_M5y7KoyK-HTGybdkc,3619 +numpy/array_api/tests/test_set_functions.py,sha256=D016G7v3ko49bND5sVERP8IqQXZiwr-2yrKbBPJ-oqg,546 +numpy/array_api/tests/test_sorting_functions.py,sha256=INPiYnuGBcsmWtYqdTTX3ENHmM4iUx4zs9KdwDaSmdA,602 +numpy/array_api/tests/test_validation.py,sha256=QUG9yWC3QhkPxNhbQeakwBbl-0Rr0iTuZ41_0sfVIGU,676 +numpy/compat/__init__.py,sha256=NzG_RvTyhvKby8p_wRHvw3m27gBrxH3tVPy6zPWDU_0,454 +numpy/compat/__pycache__/__init__.cpython-38.pyc,, +numpy/compat/__pycache__/_inspect.cpython-38.pyc,, +numpy/compat/__pycache__/_pep440.cpython-38.pyc,, +numpy/compat/__pycache__/py3k.cpython-38.pyc,, +numpy/compat/__pycache__/setup.cpython-38.pyc,, +numpy/compat/_inspect.py,sha256=8Ma7QBRwfSWKeK1ShJpFNc7CDhE6fkIE_wr1FxrG1A8,7447 +numpy/compat/_pep440.py,sha256=Vr7B3QsijR5p6h8YAz2LjNGUyzHUJ5gZ4v26NpZAKDc,14069 +numpy/compat/py3k.py,sha256=jbMNbn_cV3JDWDKJfYO78g6lCXkg-_95mgQJlh4qP80,3607 +numpy/compat/setup.py,sha256=36X1kF0C_NVROXfJ7w3SQeBm5AIDBuJbM5qT7cvSDgU,335 +numpy/compat/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +numpy/compat/tests/__pycache__/__init__.cpython-38.pyc,, +numpy/compat/tests/__pycache__/test_compat.cpython-38.pyc,, +numpy/compat/tests/test_compat.py,sha256=IB6xDjzHwWRmxKHwnFbESXul2ms2XjT6Hj-Dywdu2oM,476 +numpy/conftest.py,sha256=3lYJfyLGDyx-cyCq2Ox6GX6xw09nn97K4x2WSU-RAn0,4032 +numpy/core/__init__.py,sha256=6ezCGVC4TuvLlyYtBt6fXg0U-UEubw2XmzTqv5T-MOg,5660 +numpy/core/__init__.pyi,sha256=xtd9OFYza-ZG3jyEJrlzRPT-SkVoB_qYmVCe6FxRks0,126 +numpy/core/__pycache__/__init__.cpython-38.pyc,, +numpy/core/__pycache__/_add_newdocs.cpython-38.pyc,, +numpy/core/__pycache__/_add_newdocs_scalars.cpython-38.pyc,, +numpy/core/__pycache__/_asarray.cpython-38.pyc,, +numpy/core/__pycache__/_dtype.cpython-38.pyc,, +numpy/core/__pycache__/_dtype_ctypes.cpython-38.pyc,, +numpy/core/__pycache__/_exceptions.cpython-38.pyc,, +numpy/core/__pycache__/_internal.cpython-38.pyc,, +numpy/core/__pycache__/_machar.cpython-38.pyc,, +numpy/core/__pycache__/_methods.cpython-38.pyc,, +numpy/core/__pycache__/_string_helpers.cpython-38.pyc,, +numpy/core/__pycache__/_type_aliases.cpython-38.pyc,, +numpy/core/__pycache__/_ufunc_config.cpython-38.pyc,, +numpy/core/__pycache__/arrayprint.cpython-38.pyc,, +numpy/core/__pycache__/cversions.cpython-38.pyc,, +numpy/core/__pycache__/defchararray.cpython-38.pyc,, +numpy/core/__pycache__/einsumfunc.cpython-38.pyc,, +numpy/core/__pycache__/fromnumeric.cpython-38.pyc,, +numpy/core/__pycache__/function_base.cpython-38.pyc,, +numpy/core/__pycache__/generate_numpy_api.cpython-38.pyc,, +numpy/core/__pycache__/getlimits.cpython-38.pyc,, +numpy/core/__pycache__/memmap.cpython-38.pyc,, +numpy/core/__pycache__/multiarray.cpython-38.pyc,, +numpy/core/__pycache__/numeric.cpython-38.pyc,, +numpy/core/__pycache__/numerictypes.cpython-38.pyc,, +numpy/core/__pycache__/overrides.cpython-38.pyc,, +numpy/core/__pycache__/records.cpython-38.pyc,, +numpy/core/__pycache__/setup.cpython-38.pyc,, +numpy/core/__pycache__/setup_common.cpython-38.pyc,, +numpy/core/__pycache__/shape_base.cpython-38.pyc,, +numpy/core/__pycache__/umath.cpython-38.pyc,, +numpy/core/__pycache__/umath_tests.cpython-38.pyc,, +numpy/core/_add_newdocs.py,sha256=TZJ5iNdHMRJIUCB-vHBVpLNO3iKHLftlJRlS_H4Wm4w,201399 +numpy/core/_add_newdocs_scalars.py,sha256=xxU2hhMm4tFux-UNIKLMKHFU7bMelOCRAJ2lCX3bahI,10232 +numpy/core/_asarray.py,sha256=JxCiu_vhSBiicR6CzFFd8_emOChpUkIdOrO9MiBnLw0,4121 +numpy/core/_asarray.pyi,sha256=_A6h99LV-8BkgLxDKvG6i1NXBLB_Drxoq51Qz2F_gC4,1051 +numpy/core/_dtype.py,sha256=3eg6vYQtknrX4eBxEZF1yfRpU_uJzd03HnXtQHHPvzU,10495 +numpy/core/_dtype_ctypes.py,sha256=Vug4i7xKhznK2tdIjmn4ebclClpaCJwSZUlvEoYl0Eg,3673 +numpy/core/_exceptions.py,sha256=foa2dy_Nu3j6Pp_EiRwN6V_O7KOGugSk2XzzduRfbUg,8344 +numpy/core/_internal.py,sha256=_efKb3UpSk8WAtshbO1_7A0FZS576hv0lmAaUHoI48U,28220 +numpy/core/_internal.pyi,sha256=_mCTOX6Su8D4R9fV4HNeohPJx7515B-WOlv4uq6mry8,1032 +numpy/core/_machar.py,sha256=pzTBKBdlAducRDuYrrqkYtlVtNtFNSfFNERVGmGLUHo,11486 +numpy/core/_methods.py,sha256=s8_0sT91U0e2p_l98MiJpTaCY8GFtUy3j4VEAl4GWJY,10887 +numpy/core/_multiarray_tests.cpython-38-x86_64-linux-gnu.so,sha256=ZFSBsj1ivaRZQvuygZrnGHzy0TFANDp2tRo2bI-B3OA,186448 +numpy/core/_multiarray_umath.cpython-38-x86_64-linux-gnu.so,sha256=MFaXsjj0gwf-A3MshyxsvcaADBs5sqw51jkXWaEQuX0,5906384 +numpy/core/_operand_flag_tests.cpython-38-x86_64-linux-gnu.so,sha256=7d8NXmszaiiuZ7j7MxBvaq6qhnaUggB9NTmLEZiEpho,17072 +numpy/core/_rational_tests.cpython-38-x86_64-linux-gnu.so,sha256=SmZEWT4QZ-eZE9q7lKm7kf--Wv2rLRwungSHFRUyK7Y,59816 +numpy/core/_simd.cpython-38-x86_64-linux-gnu.so,sha256=-mrkaSaaP5WnDXRn_PqEn71HsiK9NHLGJuVoPSkhr2U,2042848 +numpy/core/_string_helpers.py,sha256=NGGGhaFdU5eGiUAj3GTIBoOgWs4r9aTNlsE2r9NgX6Q,2855 +numpy/core/_struct_ufunc_tests.cpython-38-x86_64-linux-gnu.so,sha256=aKJwzfHAh-XLMasAeKJEu4cPqw851IYw4qDzbAJb3DE,17176 +numpy/core/_type_aliases.py,sha256=Xyst9ix7LC3zPGh1AiqqzAe-aUWYioIPyB6VkIzI4Bk,7490 +numpy/core/_type_aliases.pyi,sha256=7A0M5_QvMCH8ZytWpz70-YJ6bLy7vqZxehrm0_GaXJ8,374 +numpy/core/_ufunc_config.py,sha256=KGME6Pf0V901djved3Dq3JD2iYQ4nFu_JDcQIWb2TBY,13382 +numpy/core/_ufunc_config.pyi,sha256=C6rLo4_DsCrKE6bo3eEkQ5S8epq44dF8b2czG6iiw7M,1043 +numpy/core/_umath_tests.cpython-38-x86_64-linux-gnu.so,sha256=aXHx7pqQDEfAy0HO2NUj-KVh_sCfgT-p7zb5ISh1ebQ,41856 +numpy/core/arrayprint.py,sha256=2ulEKXNysC2RAp2vIk7A1XLLKDKe-9Yd02Ix69wN_XM,62839 +numpy/core/arrayprint.pyi,sha256=21pOWjTSfJOBaKgOOPzRox1ERb3c9ydufqL0b11_P_Q,4428 +numpy/core/cversions.py,sha256=H_iNIpx9-hY1cQNxqjT2d_5SXZhJbMo_caq4_q6LB7I,347 +numpy/core/defchararray.py,sha256=ynAFiJONpssYUb1hTF1rvDoD1zSDi_r6gXc1lDBF_PE,69776 +numpy/core/defchararray.pyi,sha256=ib3aWFcM7F4KooU57mWUNi4GlosNjdfgrLKBVSIKDvU,9216 +numpy/core/einsumfunc.py,sha256=C12IJQmlUi1UgyCNwANqLAVwwojZPc1NAMi7ABzlzmk,51869 +numpy/core/einsumfunc.pyi,sha256=_BM7j_NYMvuv99B5nfI5N06ROkkGYxQnkH_3bv0OUOU,3607 +numpy/core/fromnumeric.py,sha256=EEAE0N64DUvIXsOtbboqS6_ga70OQZjHnZtzSXdp1kg,123483 +numpy/core/fromnumeric.pyi,sha256=fLvQT6mBX8IBO48mNziBs_o65fUFxItLrX124EINGUY,23472 +numpy/core/function_base.py,sha256=0aknBH-SwxLjc7f-3hmhxv0HxqTln9Ixa86Z9tOxLgc,19019 +numpy/core/function_base.pyi,sha256=3ZYad3cdaGwNEyP8VwK97IYMqk2PDoVjpjQzhIYHjk0,4725 +numpy/core/generate_numpy_api.py,sha256=kRyp-DBDU461R7-Hpd8EIG6WtcHwbXHbGjEsDZ5xDjg,7007 +numpy/core/getlimits.py,sha256=kAZb79mM59lvGvqLHYbZxkSlHJGANDFM9lX49kSF2Iw,24067 +numpy/core/getlimits.pyi,sha256=qeIXUEtognTHr_T-tv-VcZI7n8Z2VzAyIpIgKXzsLkc,82 +numpy/core/include/numpy/.doxyfile,sha256=goOZR7LcINt3snuBGH8Me-_aVTGm5f4u4wEaSpjM_W4,58 +numpy/core/include/numpy/__multiarray_api.h,sha256=g07fWp9Fe-CBg5QPEKAxdAgysVpylHC27SMwHIZyOwo,62314 +numpy/core/include/numpy/__ufunc_api.h,sha256=kOT0I320xLGHnuE8XSaomEiCmFaup8fTOTied514XiM,12614 +numpy/core/include/numpy/_neighborhood_iterator_imp.h,sha256=A6YPpQihUwscZYxz0oODrBjRSYZdJM2dG0vcdtJtY64,1877 +numpy/core/include/numpy/_numpyconfig.h,sha256=DYhvMSbnzi1OVUxC_e4qjpjq0PKGZdqiMwu8B3I43kI,971 +numpy/core/include/numpy/arrayobject.h,sha256=-BlWQ7kfVbzCqzHn0qaeMe0_08AbwliuG98XWG57lT8,282 +numpy/core/include/numpy/arrayscalars.h,sha256=h6MKjFHzguTZ5CQd7HATAVWHoZ7mkC-86R1uMHeLT04,3818 +numpy/core/include/numpy/experimental_dtype_api.h,sha256=U4gGFiivVt-975AVhEWtF7aGzufOJQivX1FmBarM2os,19915 +numpy/core/include/numpy/halffloat.h,sha256=TRZfXgipa-dFppX2uNgkrjrPli-1BfJtadWjAembJ4s,1959 +numpy/core/include/numpy/libdivide/LICENSE.txt,sha256=-8U59H0M-DvGE3gID7hz1cFGMBJsrL_nVANcOSbapew,1018 +numpy/core/include/numpy/libdivide/libdivide.h,sha256=ew9MNhPQd1LsCZiWiFmj9IZ7yOnA3HKOXffDeR9X1jw,80138 +numpy/core/include/numpy/multiarray_api.txt,sha256=lUu3-kmIThRGDbEyhz7avfa7gM6OwUuQhqt4JHa1gmE,57008 +numpy/core/include/numpy/ndarrayobject.h,sha256=Lvr0ljFumbLtDgepidCtA1V3fHoTRpL432B-t7sWVh0,10191 +numpy/core/include/numpy/ndarraytypes.h,sha256=BNnFGzO8_pnEA3T47ORSlGABK4MqfODvyb0P-IO_AwE,69078 +numpy/core/include/numpy/noprefix.h,sha256=d83l1QpCCVqMV2k29NMkL3Ld1qNjiC6hzOPWZAivEjQ,6830 +numpy/core/include/numpy/npy_1_7_deprecated_api.h,sha256=y0MJ8Qw7Bkt4H_4VxIzHzpkw5JqAdj5ECgtn08fZFrI,4327 +numpy/core/include/numpy/npy_3kcompat.h,sha256=kkHpOP0HozJwzKj6h7A2MLJLdJGDUL_pJjYbC1aq6Kc,15990 +numpy/core/include/numpy/npy_common.h,sha256=_INzM3hdWejf7egw0_FnzYl_wxf1PBfxifXI5X2wG8Y,39015 +numpy/core/include/numpy/npy_cpu.h,sha256=s5wuxe4hDuxffIlhstEd5k5bZtNdrGWwjUo0haegE0E,4603 +numpy/core/include/numpy/npy_endian.h,sha256=we7X9fPeWzNpo_YTh09MPGDwdE0Rw_WDM4c9y4nBj5I,2786 +numpy/core/include/numpy/npy_interrupt.h,sha256=DQZIxi6FycLXD8drdHn2SSmLoRhIpo6osvPv13vowUA,1948 +numpy/core/include/numpy/npy_math.h,sha256=IHi_QUlePyw-GgFSSrM6EeJnnkGZMT1u9fT9t_qOuV4,21370 +numpy/core/include/numpy/npy_no_deprecated_api.h,sha256=0yZrJcQEJ6MCHJInQk5TP9_qZ4t7EfBuoLOJ34IlJd4,678 +numpy/core/include/numpy/npy_os.h,sha256=l4OlIIc0snxwIZqJ4V7iKbIcTSk-aubsTSs0E2ZKvjM,1070 +numpy/core/include/numpy/numpyconfig.h,sha256=GxgJxPKS1gcG4vqp9BB_KpL_v4HwB7ZpMsHWWxZPLqw,2284 +numpy/core/include/numpy/old_defines.h,sha256=xuYQDDlMywu0Zsqm57hkgGwLsOFx6IvxzN2eiNF-gJY,6405 +numpy/core/include/numpy/oldnumeric.h,sha256=laP57STtFtJSs_fjRRDlrk34hqfqCwxP-BFEytR6lTM,899 +numpy/core/include/numpy/random/bitgen.h,sha256=49AwKOR552r-NkhuSOF1usb_URiMSRMvD22JF5pKIng,488 +numpy/core/include/numpy/random/distributions.h,sha256=uJVR8qB0LXdvRg7VZakVrZ8qDPRS9FWkxtLFfXzj-Jc,9865 +numpy/core/include/numpy/ufunc_api.txt,sha256=CMYRT5Wl36VufbEnjRR_yLg1vf0R3ydcNODyJY3WPCw,7198 +numpy/core/include/numpy/ufuncobject.h,sha256=PDpFN5loASykuAgmCEt2t38yt5RiNP54tDyQB33yT98,11895 +numpy/core/include/numpy/utils.h,sha256=wMNomSH3Dfj0q78PrjLVtFtN-FPo7UJ4o0ifCUO-6Es,1185 +numpy/core/lib/libnpymath.a,sha256=xIAk7QCDJ9UHeR8-DW_TGdlVcdaIDBd__NINVpMXaeA,474868 +numpy/core/lib/npy-pkg-config/mlib.ini,sha256=_LsWV1eStNqwhdiYPa2538GL46dnfVwT4MrI1zbsoFw,147 +numpy/core/lib/npy-pkg-config/npymath.ini,sha256=kamUNrYKAmXqQa8BcNv7D5sLqHh6bnChM0_5rZCsTfY,360 +numpy/core/memmap.py,sha256=tIDygBke18_QnYw2mZNw5pBilnDhydFoJS8alv8KmP8,11688 +numpy/core/memmap.pyi,sha256=sxIQ7T5hPLG-RBNndAc8JPvrsKEX1amBSH2HGg48Obo,55 +numpy/core/multiarray.py,sha256=iONmJdyVFf3ZDC1pb7icRq6ZOyipeLhYE7SV9whQQVs,55434 +numpy/core/multiarray.pyi,sha256=YUIfneT7HPe1moabOcXPHXscNBEoeTiKovjjW_20ix4,24386 +numpy/core/numeric.py,sha256=AraOnfdZcxzz0vMgkBmOsknn_xNDlnoUJYOkloysZBo,77444 +numpy/core/numeric.pyi,sha256=ZhLGBHxt1vXformFRfYmgrixkfFxGcef2cjtGheA9n4,13484 +numpy/core/numerictypes.py,sha256=lrdiD-TTcjG10K1JaBYr1uxNgR_vtNkb4s5cgz2s0ZE,17271 +numpy/core/numerictypes.pyi,sha256=nsQaevKSF_vVK6TIta8lr4tv_ZO1TuWt0icpkSRGkJs,3388 +numpy/core/overrides.py,sha256=D3gPb6ZmuJ6grq2hW4zq4MYV9wctFhCVjdXhs-etCo4,7297 +numpy/core/records.py,sha256=kIsUns_m8BQ40HTmB39S2ogY5WRphF0EK_PXSzwZ2tY,37545 +numpy/core/records.pyi,sha256=uYwE6cAoGKgN6U4ryfGZx_3m-3sY006jytjWLrDRRy0,5692 +numpy/core/setup.py,sha256=6WdWaNc9xuJDNz9KWeevTTSTaWNYfDNQ2GeAxMrN81I,52621 +numpy/core/setup_common.py,sha256=DRQEHf-zTzb1fXeZU-Yo010te2DW1PTeyZyHC8sZECI,20274 +numpy/core/shape_base.py,sha256=02GWU9VRvg6grzdqnk1duNizmOZtNQ28JHfhVA1b0yA,28985 +numpy/core/shape_base.pyi,sha256=QHMHOsLcR0wGJwMyexESlSOQqw0ifHyRs2WfV1VEW1E,1744 +numpy/core/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +numpy/core/tests/__pycache__/__init__.cpython-38.pyc,, +numpy/core/tests/__pycache__/_locales.cpython-38.pyc,, +numpy/core/tests/__pycache__/test__exceptions.cpython-38.pyc,, +numpy/core/tests/__pycache__/test_abc.cpython-38.pyc,, +numpy/core/tests/__pycache__/test_api.cpython-38.pyc,, +numpy/core/tests/__pycache__/test_argparse.cpython-38.pyc,, +numpy/core/tests/__pycache__/test_array_coercion.cpython-38.pyc,, +numpy/core/tests/__pycache__/test_array_interface.cpython-38.pyc,, +numpy/core/tests/__pycache__/test_arraymethod.cpython-38.pyc,, +numpy/core/tests/__pycache__/test_arrayprint.cpython-38.pyc,, +numpy/core/tests/__pycache__/test_casting_unittests.cpython-38.pyc,, +numpy/core/tests/__pycache__/test_conversion_utils.cpython-38.pyc,, +numpy/core/tests/__pycache__/test_cpu_dispatcher.cpython-38.pyc,, +numpy/core/tests/__pycache__/test_cpu_features.cpython-38.pyc,, +numpy/core/tests/__pycache__/test_custom_dtypes.cpython-38.pyc,, +numpy/core/tests/__pycache__/test_cython.cpython-38.pyc,, +numpy/core/tests/__pycache__/test_datetime.cpython-38.pyc,, +numpy/core/tests/__pycache__/test_defchararray.cpython-38.pyc,, +numpy/core/tests/__pycache__/test_deprecations.cpython-38.pyc,, +numpy/core/tests/__pycache__/test_dlpack.cpython-38.pyc,, +numpy/core/tests/__pycache__/test_dtype.cpython-38.pyc,, +numpy/core/tests/__pycache__/test_einsum.cpython-38.pyc,, +numpy/core/tests/__pycache__/test_errstate.cpython-38.pyc,, +numpy/core/tests/__pycache__/test_extint128.cpython-38.pyc,, +numpy/core/tests/__pycache__/test_function_base.cpython-38.pyc,, +numpy/core/tests/__pycache__/test_getlimits.cpython-38.pyc,, +numpy/core/tests/__pycache__/test_half.cpython-38.pyc,, +numpy/core/tests/__pycache__/test_hashtable.cpython-38.pyc,, +numpy/core/tests/__pycache__/test_indexerrors.cpython-38.pyc,, +numpy/core/tests/__pycache__/test_indexing.cpython-38.pyc,, +numpy/core/tests/__pycache__/test_item_selection.cpython-38.pyc,, +numpy/core/tests/__pycache__/test_limited_api.cpython-38.pyc,, +numpy/core/tests/__pycache__/test_longdouble.cpython-38.pyc,, +numpy/core/tests/__pycache__/test_machar.cpython-38.pyc,, +numpy/core/tests/__pycache__/test_mem_overlap.cpython-38.pyc,, +numpy/core/tests/__pycache__/test_mem_policy.cpython-38.pyc,, +numpy/core/tests/__pycache__/test_memmap.cpython-38.pyc,, +numpy/core/tests/__pycache__/test_multiarray.cpython-38.pyc,, +numpy/core/tests/__pycache__/test_nditer.cpython-38.pyc,, +numpy/core/tests/__pycache__/test_numeric.cpython-38.pyc,, +numpy/core/tests/__pycache__/test_numerictypes.cpython-38.pyc,, +numpy/core/tests/__pycache__/test_overrides.cpython-38.pyc,, +numpy/core/tests/__pycache__/test_print.cpython-38.pyc,, +numpy/core/tests/__pycache__/test_protocols.cpython-38.pyc,, +numpy/core/tests/__pycache__/test_records.cpython-38.pyc,, +numpy/core/tests/__pycache__/test_regression.cpython-38.pyc,, +numpy/core/tests/__pycache__/test_scalar_ctors.cpython-38.pyc,, +numpy/core/tests/__pycache__/test_scalar_methods.cpython-38.pyc,, +numpy/core/tests/__pycache__/test_scalarbuffer.cpython-38.pyc,, +numpy/core/tests/__pycache__/test_scalarinherit.cpython-38.pyc,, +numpy/core/tests/__pycache__/test_scalarmath.cpython-38.pyc,, +numpy/core/tests/__pycache__/test_scalarprint.cpython-38.pyc,, +numpy/core/tests/__pycache__/test_shape_base.cpython-38.pyc,, +numpy/core/tests/__pycache__/test_simd.cpython-38.pyc,, +numpy/core/tests/__pycache__/test_simd_module.cpython-38.pyc,, +numpy/core/tests/__pycache__/test_ufunc.cpython-38.pyc,, +numpy/core/tests/__pycache__/test_umath.cpython-38.pyc,, +numpy/core/tests/__pycache__/test_umath_accuracy.cpython-38.pyc,, +numpy/core/tests/__pycache__/test_umath_complex.cpython-38.pyc,, +numpy/core/tests/__pycache__/test_unicode.cpython-38.pyc,, +numpy/core/tests/_locales.py,sha256=R2tNBiBzY6h7zHqexpGsuM1QNd_2CR-JfqEXc4pFXYI,2192 +numpy/core/tests/data/astype_copy.pkl,sha256=lWSzCcvzRB_wpuRGj92spGIw-rNPFcd9hwJaRVvfWdk,716 +numpy/core/tests/data/generate_umath_validation_data.cpp,sha256=NQSRK6tJpdTsR6jxim5Ek4ty8J6HJ5JdAe0wBQlrACw,5840 +numpy/core/tests/data/recarray_from_file.fits,sha256=NA0kliz31FlLnYxv3ppzeruONqNYkuEvts5wzXEeIc4,8640 +numpy/core/tests/data/umath-validation-set-README.txt,sha256=pxWwOaGGahaRd-AlAidDfocLyrAiDp0whf5hC7hYwqM,967 +numpy/core/tests/data/umath-validation-set-arccos.csv,sha256=W_aL99bjzVjlVyd5omfDUORag8jHzx6uctedPVZgOHQ,61365 +numpy/core/tests/data/umath-validation-set-arccosh.csv,sha256=Uko_d0kDXr1YlN-6Ii-fQQxUvbXAhRfC7Un4gJ23GJk,61365 +numpy/core/tests/data/umath-validation-set-arcsin.csv,sha256=15Aenze4WD2a2dF2aOBXpv9B7u3wwAeUVJdEm4TjOkQ,61339 +numpy/core/tests/data/umath-validation-set-arcsinh.csv,sha256=uDwx4PStpfV21IaPF8pmzQpul6i72g7zDwlfcynWaVQ,60289 +numpy/core/tests/data/umath-validation-set-arctan.csv,sha256=mw5tYze_BMs6ugGEZfg5mcXoInGYdn7fvSCYSUi9Bqw,60305 +numpy/core/tests/data/umath-validation-set-arctanh.csv,sha256=95l4Uu5RmZajljabfqlv5U34RVrifCMhhkop6iLeNBo,61339 +numpy/core/tests/data/umath-validation-set-cbrt.csv,sha256=v855MTZih-fZp_GuEDst2qaIsxU4a7vlAbeIJy2xKpc,60846 +numpy/core/tests/data/umath-validation-set-cos.csv,sha256=yxd7BNaicgyEysvp8Tx2qEM-S4zVJA0f0ZXR_VG4y1E,59122 +numpy/core/tests/data/umath-validation-set-cosh.csv,sha256=FGCNeUSUTAeASsb_j18iRSsCxXLxmzF-_C7tq1elVrQ,60869 +numpy/core/tests/data/umath-validation-set-exp.csv,sha256=BKg1_cyrKD2GXYMX_EB0DnXua8DI2O1KWODXf_BRhrk,17491 +numpy/core/tests/data/umath-validation-set-exp2.csv,sha256=f1b05MRXPOXihC9M-yi52udKBzVXalhbTuIcqoDAk-g,58624 +numpy/core/tests/data/umath-validation-set-expm1.csv,sha256=_ghc1xiUECNsBGrKCFUAy2lvu01_lkpeYJN0zDtCYWk,60299 +numpy/core/tests/data/umath-validation-set-log.csv,sha256=z9ej1ykKUoMRqYMUIJENWXbYi_A_x_RKs7K_GuXZJus,11692 +numpy/core/tests/data/umath-validation-set-log10.csv,sha256=RJgpruL16FVPgUT3-3xW4eppS_tn6o5yEW79KnITn48,68922 +numpy/core/tests/data/umath-validation-set-log1p.csv,sha256=IZZI-hi55HGCOvBat3vSBVha_8Nt-5alf2fqz6QeTG0,60303 +numpy/core/tests/data/umath-validation-set-log2.csv,sha256=HL2rOCsrEi378rNrbsXHPqlWlEGkXQq8R4e63YeTksU,68917 +numpy/core/tests/data/umath-validation-set-sin.csv,sha256=5I2h5CI8Hv6L9o2mh6x5pttnL23VhhY1h5LA8cjIWTg,58611 +numpy/core/tests/data/umath-validation-set-sinh.csv,sha256=CYiibE8aX7MQnBatl__5k_PWc_9vHUifwS-sFZzzKk0,60293 +numpy/core/tests/data/umath-validation-set-tan.csv,sha256=Oq7gxMvblRVBrQ23kMxc8iT0bHnCWKg9EE4ZqzbJbOA,60299 +numpy/core/tests/data/umath-validation-set-tanh.csv,sha256=iolZF_MOyWRgYSa-SsD4df5mnyFK18zrICI740SWoTc,60299 +numpy/core/tests/examples/cython/__pycache__/setup.cpython-38.pyc,, +numpy/core/tests/examples/cython/checks.pyx,sha256=plK9y11kHceBfR6puFLDwU8H5RBGS6ZEmqSFVq-rzOE,615 +numpy/core/tests/examples/cython/setup.py,sha256=aAR-TvQabUabnCzuB6UdWdmRXaaPfIG7MzTIfMF-0tk,496 +numpy/core/tests/examples/limited_api/__pycache__/setup.cpython-38.pyc,, +numpy/core/tests/examples/limited_api/limited_api.c,sha256=mncE8TjjXmYpkwli433G0jB2zGQO_5NqWmGKdzRJZug,344 +numpy/core/tests/examples/limited_api/setup.py,sha256=p2w7F1ardi_GRXSrnNIR8W1oeH_pgmw_1P2wS0A2I6M,435 +numpy/core/tests/test__exceptions.py,sha256=QqxQSLXboPXEVwHz-TyE2JeIl_TC-rPugzfo25nbcns,2846 +numpy/core/tests/test_abc.py,sha256=k4zkrHjoRr4TXiVTCu34B8ZyRP5XJ7N8tPKKdPudOS0,2328 +numpy/core/tests/test_api.py,sha256=YS1T3TpXk9FOxKDPgMHuzeKrIBIxJZeudBGGAHthnzk,22474 +numpy/core/tests/test_argparse.py,sha256=rkbQloOqMiIGIdUsaZb20oHyBO3y9JFqSYr7FawdtDk,1977 +numpy/core/tests/test_array_coercion.py,sha256=ME4DN_ItPaP_bDUj5udjSE01LMuCfTY7l_1VibPNu-k,29075 +numpy/core/tests/test_array_interface.py,sha256=EBil1BzybVPu-sN7t8DJuSufdAOaa_B7pzmJIb4zoY0,7596 +numpy/core/tests/test_arraymethod.py,sha256=mYTChMoUZ3SsWHFPAuf7lHP8u3r7_CYPQMlBOnP1qoM,3567 +numpy/core/tests/test_arrayprint.py,sha256=y28q842bjQfmMCpFtxDn3mxwBd3bRmCEhVRTDWlAmHE,37152 +numpy/core/tests/test_casting_unittests.py,sha256=PvCjr9EWU358ZksMY2PYnMIr_d_TVZhrrUvUTrUZqys,33866 +numpy/core/tests/test_conversion_utils.py,sha256=jNhbNNI-T8qtQnsIMEax7KFN30kjh0ICntLMwTyxJ5Q,6559 +numpy/core/tests/test_cpu_dispatcher.py,sha256=JmYHyBedXNu8pPgGCegP4it6UXY0sifW4EjdM9C0f8M,1521 +numpy/core/tests/test_cpu_features.py,sha256=7CXENItSVtgjlAefnXRczQiC-VILowYHrqeeg4aGqgg,7169 +numpy/core/tests/test_custom_dtypes.py,sha256=JdvtCZNfL_KuZprE5tnZIRHmUNodCISYM7BRKOQ5QZQ,7677 +numpy/core/tests/test_cython.py,sha256=iyGFUGZ8OIVDW-jrFo4YroJJJ2zr9apVzcvZuoU3VHM,3536 +numpy/core/tests/test_datetime.py,sha256=fIwDrMOsig9GUsbJMdb29M2r1EAPeYh8pPl5ibtXFZ0,114957 +numpy/core/tests/test_defchararray.py,sha256=Lz7lE3-wzmdWK0wQp-uAInKsmda9IIhOixFq3AiTvq8,24583 +numpy/core/tests/test_deprecations.py,sha256=eOzEV-5KwSNhNF-wzNKL-vLawgxE3hMv4ZxXZtkrKXw,47562 +numpy/core/tests/test_dlpack.py,sha256=0eAX3gtIA13IXIDXOUwIaBDR3T8d55khQJmN2uF60pM,3502 +numpy/core/tests/test_dtype.py,sha256=j5oWgU50RPH_S9gQXyl_CdmAXZDkC2sdG4Ck6Bt-NJ4,69809 +numpy/core/tests/test_einsum.py,sha256=Qdabx4wNsWx5h_38pKo_TZh5Bkn2XHdauXydEX3EtVU,50113 +numpy/core/tests/test_errstate.py,sha256=19uzW3PSyQiQD-sGnaIcVle3h7P2LbzxCEZKt3tS678,2066 +numpy/core/tests/test_extint128.py,sha256=gCZfAwPOb-F1TLsEEeDI0amQYwHk-60-OXi0ccZrrZ8,5643 +numpy/core/tests/test_function_base.py,sha256=MyX8TSOh251NfC6M8LHFpc-ooVj_jfP-V6l00F5wb7M,14411 +numpy/core/tests/test_getlimits.py,sha256=RpbyjCEOII-7zLOBryg64E9M23T_dH8wJ15sdIyv_yw,5207 +numpy/core/tests/test_half.py,sha256=H91ZNjGPENPQNuDuXH0GnJlX2CG5z-KA0bA52ee177k,23816 +numpy/core/tests/test_hashtable.py,sha256=ZV8HL8NkDnoQZfnje7BP0fyIp4fSFqjKsQc40PaTggc,1011 +numpy/core/tests/test_indexerrors.py,sha256=kN9xLl6FVTzmI7fumn_cuZ3k0omXnTetgtCnPY44cvw,5130 +numpy/core/tests/test_indexing.py,sha256=l4lpSRSKmLWpfT6vfsI36EnTOAnU1utvTZies3gmhzI,54227 +numpy/core/tests/test_item_selection.py,sha256=DGJNZRtyOxXoyY67EFwUqmLhQ04v0Kqy_QAOpEL42M0,3579 +numpy/core/tests/test_limited_api.py,sha256=mREC-jEhNDDAKrOUcdJnfSQoZVB_bWnGt9PtWuSK6DU,1075 +numpy/core/tests/test_longdouble.py,sha256=nXQKxT10J4cQW27r3vXFAsrfuKryyWJzCZWTxMVS9WM,13042 +numpy/core/tests/test_machar.py,sha256=_5_TDUVtAJvJI5jBfEFKpCZtAfKCsCFt7tXlWSkWzzc,1067 +numpy/core/tests/test_mem_overlap.py,sha256=_oscEzTKRFVoV9Yl-XX1-NFu4a6ThX_fCEZa90R4TKs,29084 +numpy/core/tests/test_mem_policy.py,sha256=Om8dZ3YV-g_YJtbyJObqg2wNUo2dV0vkvwPJEw4Rhz4,15869 +numpy/core/tests/test_memmap.py,sha256=Szhfp-XCO-IFZIvfL4-h9hTxjnl7rg9c9vsiehmEEck,7469 +numpy/core/tests/test_multiarray.py,sha256=HHQjZ8Fqvh51lS1Gl-z8zWvYltUcl5iQXT0dOsfplBQ,364600 +numpy/core/tests/test_nditer.py,sha256=WL1bJQ3XXQjeHsCFOHOMyal5owZEoRUzEwkdduqwZ-4,127961 +numpy/core/tests/test_numeric.py,sha256=0tBD1zN_X0t4e-qDa9Ny2EcRzebPisHSTrzmRe-JZRs,136700 +numpy/core/tests/test_numerictypes.py,sha256=rqddCaGIXPTEv4ocQ9LzTcaHmLo4nXzXrEhcs89PiwM,21145 +numpy/core/tests/test_overrides.py,sha256=exmeeEBGVgMKdlVMEAMe6jzBBw99hGEIYtKsFVoKvPU,20193 +numpy/core/tests/test_print.py,sha256=URYIP2BX0uTkkCH_-YwYp6hhyYENaV4sarPaD2rRbZc,6737 +numpy/core/tests/test_protocols.py,sha256=fEXE9K9s22oiVWkX92BY-g00-uXCK-HxjZhZxxYAKFc,1168 +numpy/core/tests/test_records.py,sha256=Ffznf9-_C9qAvBhcE8_sdbMP8oWUFv5PC6ory0LC2rg,20262 +numpy/core/tests/test_regression.py,sha256=r4Isz3H0YG_pm8doWfbD0AICGqz0yjCK7PxSMqynsOg,91106 +numpy/core/tests/test_scalar_ctors.py,sha256=J0PGDHD6a6dCW1Wg4q-_C5FEccXcYgqLNTnh7AC1iB8,3688 +numpy/core/tests/test_scalar_methods.py,sha256=WtWMkWSsa8Ou0CCc5IXnhDgR1sEEc57gDYygnJXJBx8,7495 +numpy/core/tests/test_scalarbuffer.py,sha256=5urlHsgHE9H63Tp9mlM48iRh_A1VNxSZohBntl0RnqM,5588 +numpy/core/tests/test_scalarinherit.py,sha256=BSxN2JQYrxxp6tbysaj56m5HvLvCdfSv_X7GC0ab7bg,2381 +numpy/core/tests/test_scalarmath.py,sha256=dQuagDUURQIljqUTj48qe2dTvoux5zyFhZnipehsCHI,40778 +numpy/core/tests/test_scalarprint.py,sha256=8FkIQLdQmPH_SZ0Ps6D48T3MRTHVFZYgAKB_IxtNpaE,18694 +numpy/core/tests/test_shape_base.py,sha256=Xq9XrA55m-qhqi02GuEpn_uINsfGJh7sCnuMulvM9eU,27248 +numpy/core/tests/test_simd.py,sha256=ucji7Ky7vUm7kQ-l_Jg8vuQ8dAlO2AvPrSXDyrw6lzM,37478 +numpy/core/tests/test_simd_module.py,sha256=EBJbHm9GchVD_hkQvVQfC-A0GZrIUX-zZEx8jiZUQe8,3758 +numpy/core/tests/test_ufunc.py,sha256=-y_L6g6HTksCTu1Fj7qV6MCoDB4yFVnYJzImoWHkCAc,108151 +numpy/core/tests/test_umath.py,sha256=SvoqrgXOsbMkJ5axiyV6as65a2oWVzZzqH0sKbx_UW8,153827 +numpy/core/tests/test_umath_accuracy.py,sha256=Ee5atEbgW-6N0C2fADMu62l7-iJmDQR2pZ0xVT5cNBs,3229 +numpy/core/tests/test_umath_complex.py,sha256=Jn4bfX2QsXvKYyDXLo7S4-TT9GkLMrQOX-1IwDLyV2I,23215 +numpy/core/tests/test_unicode.py,sha256=bBqQCQk_UZATySI4HdiWTgfenmgQCm5ynLc6SLvKiiw,12553 +numpy/core/umath.py,sha256=JbT_SxnZ_3MEmjOI9UtX3CcAzX5Q-4RDlnnhDAEJ5Vo,2040 +numpy/core/umath_tests.py,sha256=TIzaDfrEHHgSc2J5kxFEibq8MOPhwSuyOZOUBsZNVSM,389 +numpy/ctypeslib.py,sha256=Ae4Lbhr_EJRzzXb2dNYdYPXzjAP6wS6X7XePD8Dx6kc,17460 +numpy/ctypeslib.pyi,sha256=xbs_DWIxXd9Hk4M7bfpNsCJTY_ZVMfJepuYqq7U26SM,7962 +numpy/distutils/__config__.py,sha256=TXvjW8PcKIkWSx3pLCYYC2SMqmRP-0gKkOOvckDq6Ao,5143 +numpy/distutils/__init__.py,sha256=BU1C21439HRo7yH1SsN9me6WCDPpOwRQ37ZpNwDMqCw,2074 +numpy/distutils/__init__.pyi,sha256=D8LRE6BNOmuBGO-oakJGnjT9UJTk9zSR5rxMfZzlX64,119 +numpy/distutils/__pycache__/__config__.cpython-38.pyc,, +numpy/distutils/__pycache__/__init__.cpython-38.pyc,, +numpy/distutils/__pycache__/_shell_utils.cpython-38.pyc,, +numpy/distutils/__pycache__/armccompiler.cpython-38.pyc,, +numpy/distutils/__pycache__/ccompiler.cpython-38.pyc,, +numpy/distutils/__pycache__/ccompiler_opt.cpython-38.pyc,, +numpy/distutils/__pycache__/conv_template.cpython-38.pyc,, +numpy/distutils/__pycache__/core.cpython-38.pyc,, +numpy/distutils/__pycache__/cpuinfo.cpython-38.pyc,, +numpy/distutils/__pycache__/exec_command.cpython-38.pyc,, +numpy/distutils/__pycache__/extension.cpython-38.pyc,, +numpy/distutils/__pycache__/from_template.cpython-38.pyc,, +numpy/distutils/__pycache__/intelccompiler.cpython-38.pyc,, +numpy/distutils/__pycache__/lib2def.cpython-38.pyc,, +numpy/distutils/__pycache__/line_endings.cpython-38.pyc,, +numpy/distutils/__pycache__/log.cpython-38.pyc,, +numpy/distutils/__pycache__/mingw32ccompiler.cpython-38.pyc,, +numpy/distutils/__pycache__/misc_util.cpython-38.pyc,, +numpy/distutils/__pycache__/msvc9compiler.cpython-38.pyc,, +numpy/distutils/__pycache__/msvccompiler.cpython-38.pyc,, +numpy/distutils/__pycache__/npy_pkg_config.cpython-38.pyc,, +numpy/distutils/__pycache__/numpy_distribution.cpython-38.pyc,, +numpy/distutils/__pycache__/pathccompiler.cpython-38.pyc,, +numpy/distutils/__pycache__/setup.cpython-38.pyc,, +numpy/distutils/__pycache__/system_info.cpython-38.pyc,, +numpy/distutils/__pycache__/unixccompiler.cpython-38.pyc,, +numpy/distutils/_shell_utils.py,sha256=kMLOIoimB7PdFRgoVxCIyCFsIl1pP3d0hkm_s3E9XdA,2613 +numpy/distutils/armccompiler.py,sha256=SW12IT7WCB3CLMG_U2K1WDbtYozwFF-DtMDArmpOTkc,1043 +numpy/distutils/ccompiler.py,sha256=oemDR6fQwIvW7DdpgM29JIUWwPi_YZPZsHDefhHFf90,27749 +numpy/distutils/ccompiler_opt.py,sha256=TJCncSrowJImwELGzAPw23uBfKVesf6nXyentNYTGXk,99751 +numpy/distutils/checks/cpu_asimd.c,sha256=nXUsTLrSlhRL-UzDM8zMqn1uqJnR7TRlJi3Ixqw539w,818 +numpy/distutils/checks/cpu_asimddp.c,sha256=E4b9zT1IdSfGR2ACZJiQoR-BqaeDtzFqRNW8lBOXAaY,432 +numpy/distutils/checks/cpu_asimdfhm.c,sha256=6tXINVEpmA-lYRSbL6CrBu2ejNFmd9WONFGgg-JFXZE,529 +numpy/distutils/checks/cpu_asimdhp.c,sha256=SfwrEEA_091tmyI4vN3BNLs7ypUnrF_VbTg6gPl-ocs,379 +numpy/distutils/checks/cpu_avx.c,sha256=LuZW8o93VZZi7cYEP30dvKWTm7Mw1TLmCt5UaXDxCJg,779 +numpy/distutils/checks/cpu_avx2.c,sha256=jlDlea393op0JOiMJgmmPyKmyAXztLcObPOp9F9FaS0,749 +numpy/distutils/checks/cpu_avx512_clx.c,sha256=P-YHjj2XE4SithBkPwDgShOxGWnVSNUXg72h8O3kpbs,842 +numpy/distutils/checks/cpu_avx512_cnl.c,sha256=f_c2Z0xwAKTJeK3RYMIp1dgXYV8QyeOxUgKkMht4qko,948 +numpy/distutils/checks/cpu_avx512_icl.c,sha256=isI35-gm7Hqn2Qink5hP1XHWlh52a5vwKhEdW_CRviE,1004 +numpy/distutils/checks/cpu_avx512_knl.c,sha256=Veq4zNRDDqABV1dPyYdpyPzqZnEBrRsPsTZU1ebPi_Y,956 +numpy/distutils/checks/cpu_avx512_knm.c,sha256=eszPGr3XC9Js7mQUB0gFxlrNjQwfucQFz_UwFyNLjes,1132 +numpy/distutils/checks/cpu_avx512_skx.c,sha256=59VD8ebEJJHLlbY-4dakZV34bmq_lr9mBKz8BAcsdYc,1010 +numpy/distutils/checks/cpu_avx512cd.c,sha256=Qfh5FJUv9ZWd_P5zxkvYYIkvqsPptgaDuKkeX_F8vyA,759 +numpy/distutils/checks/cpu_avx512f.c,sha256=d97NRcbJhqpvURnw7zyG0TOuEijKXvU0g4qOTWHbwxY,755 +numpy/distutils/checks/cpu_f16c.c,sha256=nzZzpUc8AfTtw-INR3KOxcjx9pyzVUM8OhsrdH2dO_w,868 +numpy/distutils/checks/cpu_fma3.c,sha256=YN6IDwuZALJHVVmpQ2tj-14HI_PcxH_giV8-XjzlmkU,817 +numpy/distutils/checks/cpu_fma4.c,sha256=qKdgTNNFg-n8vSB1Txco60HBLCcOi1aH23gZOX7yKqs,301 +numpy/distutils/checks/cpu_neon.c,sha256=Y0SjuVLzh3upcbY47igHjmKgjHbXxbvzncwB7acfjxw,600 +numpy/distutils/checks/cpu_neon_fp16.c,sha256=E7YOGyYP41u1sqiCHpCGGqjmo7Cs6yUkmJ46K7LZloc,251 +numpy/distutils/checks/cpu_neon_vfpv4.c,sha256=qFY1C_fQYz7M_a_8j0KTdn7vaE3NNVmWY2JGArDGM3w,609 +numpy/distutils/checks/cpu_popcnt.c,sha256=vRcXHVw2j1F9I_07eIZ_xzDX3fd3mqgiQXL1w3pULJk,1049 +numpy/distutils/checks/cpu_sse.c,sha256=6MHITtC76UpSR9uh0SiURpnkpPkLzT5tbrcXT4xBFxo,686 +numpy/distutils/checks/cpu_sse2.c,sha256=yUZzdjDtBS-vYlhfP-pEzj3m0UPmgZs-hA99TZAEACU,697 +numpy/distutils/checks/cpu_sse3.c,sha256=j5XRHumUuccgN9XPZyjWUUqkq8Nu8XCSWmvUhmJTJ08,689 +numpy/distutils/checks/cpu_sse41.c,sha256=y_k81P-1b-Hx8OeRVDE9V1O9JakS0zPvlFKJ3VbSmEw,675 +numpy/distutils/checks/cpu_sse42.c,sha256=3PXucdI2mII-txO7zFN99TlVveT_QUAETTGvRk-_hYw,692 +numpy/distutils/checks/cpu_ssse3.c,sha256=X6VWxIXMRpdSCBsHPXvot3yTZ4d5yK9Bi1ScQP3WC-Q,705 +numpy/distutils/checks/cpu_vsx.c,sha256=FVmR4iliKjcihzMCwloR1F2JYwSZK9P4f_hvIRLHSDQ,478 +numpy/distutils/checks/cpu_vsx2.c,sha256=yESs25Rt5ztb5-stuYbu3TbiyJKmllMpMLu01GOAHqE,263 +numpy/distutils/checks/cpu_vsx3.c,sha256=omC50tbEZNigsKMFPtE3zGRlIS2VuDTm3vZ9TBZWo4U,250 +numpy/distutils/checks/cpu_vsx4.c,sha256=ngezA1KuINqJkLAcMrZJR7bM0IeA25U6I-a5aISGXJo,305 +numpy/distutils/checks/cpu_vx.c,sha256=OpLU6jIfwvGJR4JPVVZLlUfvo7oAZ0YvsjafM2qtPlk,461 +numpy/distutils/checks/cpu_vxe.c,sha256=rYW_nKwXnlB0b8xCrJEr4TmvrEvS-NToxwyqqOHV8Bk,788 +numpy/distutils/checks/cpu_vxe2.c,sha256=Hv4wO23kwC2G6lqqercq4NE4K0nrvBxR7RIzr5HTXCc,624 +numpy/distutils/checks/cpu_xop.c,sha256=7uabsGeqvmVJQvuSEjs8-Sm8kpmvl6uZ9YHMF5h2opQ,234 +numpy/distutils/checks/extra_avx512bw_mask.c,sha256=pVPOhcu80yJVnIhOcHHXOlZ2proJ1MUf0XgccqhPoNk,636 +numpy/distutils/checks/extra_avx512dq_mask.c,sha256=nMfIvepISGFDexPrMYl5LWtdmt6Uy9TKPzF4BVayw2I,504 +numpy/distutils/checks/extra_avx512f_reduce.c,sha256=_NfbtfSAkm_A67umjR1oEb9yRnBL5EnTA76fvQIuNVk,1595 +numpy/distutils/checks/extra_vsx4_mma.c,sha256=GiQGZ9-6wYTgH42bJgSlXhWcTIrkjh5xv4uymj6rglk,499 +numpy/distutils/checks/extra_vsx_asm.c,sha256=BngiMVS9nyr22z6zMrOrHLeCloe_5luXhf5T5mYucgI,945 +numpy/distutils/checks/test_flags.c,sha256=uAIbhfAhyGe4nTdK_mZmoCefj9P0TGHNF9AUv_Cdx5A,16 +numpy/distutils/command/__init__.py,sha256=fW49zUB3syMFsKpf1oRBO0h8tmnTwRP3zUPrsB0R22M,1032 +numpy/distutils/command/__pycache__/__init__.cpython-38.pyc,, +numpy/distutils/command/__pycache__/autodist.cpython-38.pyc,, +numpy/distutils/command/__pycache__/bdist_rpm.cpython-38.pyc,, +numpy/distutils/command/__pycache__/build.cpython-38.pyc,, +numpy/distutils/command/__pycache__/build_clib.cpython-38.pyc,, +numpy/distutils/command/__pycache__/build_ext.cpython-38.pyc,, +numpy/distutils/command/__pycache__/build_py.cpython-38.pyc,, +numpy/distutils/command/__pycache__/build_scripts.cpython-38.pyc,, +numpy/distutils/command/__pycache__/build_src.cpython-38.pyc,, +numpy/distutils/command/__pycache__/config.cpython-38.pyc,, +numpy/distutils/command/__pycache__/config_compiler.cpython-38.pyc,, +numpy/distutils/command/__pycache__/develop.cpython-38.pyc,, +numpy/distutils/command/__pycache__/egg_info.cpython-38.pyc,, +numpy/distutils/command/__pycache__/install.cpython-38.pyc,, +numpy/distutils/command/__pycache__/install_clib.cpython-38.pyc,, +numpy/distutils/command/__pycache__/install_data.cpython-38.pyc,, +numpy/distutils/command/__pycache__/install_headers.cpython-38.pyc,, +numpy/distutils/command/__pycache__/sdist.cpython-38.pyc,, +numpy/distutils/command/autodist.py,sha256=8KWwr5mnjX20UpY4ITRDx-PreApyh9M7B92IwsEtTsQ,3718 +numpy/distutils/command/bdist_rpm.py,sha256=-tkZupIJr_jLqeX7xbRhE8-COXHRI0GoRpAKchVte54,709 +numpy/distutils/command/build.py,sha256=aj1SUGsDUTxs4Tch2ALLcPnuAVhaPjEPIZIobzMajm0,2613 +numpy/distutils/command/build_clib.py,sha256=qbxvwF5n8kfGSsL7H5BS7zguUYZss0X3kct8U20JQio,19235 +numpy/distutils/command/build_ext.py,sha256=WRGHAn2Z6NuV-DhS5_7L8KXjMOWmm8bRnR3KVYtT61E,31877 +numpy/distutils/command/build_py.py,sha256=XiLZ2d_tmCE8uG5VAU5OK2zlzQayBfeY4l8FFEltbig,1144 +numpy/distutils/command/build_scripts.py,sha256=P2ytmZb3UpwfmbMXkFB2iMQk15tNUCynzMATllmp-Gs,1665 +numpy/distutils/command/build_src.py,sha256=Lw3JsmSdi_DpWCtCxU4X5iYC6da5vkOhXzCrnlrgS98,31172 +numpy/distutils/command/config.py,sha256=v-nHMY-3gL7Q6PkM4K2XDVZM_GyUrAjpjNtsRT5-Y68,20724 +numpy/distutils/command/config_compiler.py,sha256=Cp9RTpW72gg8XC_3-9dCTlLYr352pBfBRZA8YBWvOoY,4369 +numpy/distutils/command/develop.py,sha256=9SbbnFnVbSJVZxTFoV9pwlOcM1D30GnOWm2QonQDvHI,575 +numpy/distutils/command/egg_info.py,sha256=i-Zk4sftK5cMQVQ2jqSxTMpVI-gYyXN16-p5TvmjURc,921 +numpy/distutils/command/install.py,sha256=wZfVabAMw-Y3tiAKcXTxC-So65RHo3zCy1ucoTmyECw,3078 +numpy/distutils/command/install_clib.py,sha256=1xv0_lPVu3g16GgICjjlh7T8zQ6PSlevCuq8Bocx5YM,1399 +numpy/distutils/command/install_data.py,sha256=Y59EBG61MWP_5C8XJvSCVfzYpMNVNVcH_Z6c0qgr9KA,848 +numpy/distutils/command/install_headers.py,sha256=tVpOGqkmh8AA_tam0K0SeCd4kvZj3UqSOjWKm6Kz4jY,919 +numpy/distutils/command/sdist.py,sha256=8Tsju1RwXNbPyQcjv8GRMFveFQqYlbNdSZh2X1OV-VU,733 +numpy/distutils/conv_template.py,sha256=F-4vkkfAjCb-fN79WYrXX3BMHMoiQO-W2u09q12OPuI,9536 +numpy/distutils/core.py,sha256=QBJNJdIE0a9Rr4lo-3QnmEaWyVV068l6HbVPdJ75iZg,8173 +numpy/distutils/cpuinfo.py,sha256=XuNhsx_-tyrui_AOgn10yfZ9p4YBM68vW2_bGmKj07I,22639 +numpy/distutils/exec_command.py,sha256=GDk5wRli-tV2ZLycbshnrGLcBgokvZmFMJntFwwT2l0,10343 +numpy/distutils/extension.py,sha256=YgeB8e2fVc2l_1etuRBv0P8c1NULOz4SaudHgsVBc30,3568 +numpy/distutils/fcompiler/__init__.py,sha256=m6ibfNuckW6cmHzpLgi7SJ8nLAyuOG5kV8IwtjbNyBU,40153 +numpy/distutils/fcompiler/__pycache__/__init__.cpython-38.pyc,, +numpy/distutils/fcompiler/__pycache__/absoft.cpython-38.pyc,, +numpy/distutils/fcompiler/__pycache__/arm.cpython-38.pyc,, +numpy/distutils/fcompiler/__pycache__/compaq.cpython-38.pyc,, +numpy/distutils/fcompiler/__pycache__/environment.cpython-38.pyc,, +numpy/distutils/fcompiler/__pycache__/fujitsu.cpython-38.pyc,, +numpy/distutils/fcompiler/__pycache__/g95.cpython-38.pyc,, +numpy/distutils/fcompiler/__pycache__/gnu.cpython-38.pyc,, +numpy/distutils/fcompiler/__pycache__/hpux.cpython-38.pyc,, +numpy/distutils/fcompiler/__pycache__/ibm.cpython-38.pyc,, +numpy/distutils/fcompiler/__pycache__/intel.cpython-38.pyc,, +numpy/distutils/fcompiler/__pycache__/lahey.cpython-38.pyc,, +numpy/distutils/fcompiler/__pycache__/mips.cpython-38.pyc,, +numpy/distutils/fcompiler/__pycache__/nag.cpython-38.pyc,, +numpy/distutils/fcompiler/__pycache__/none.cpython-38.pyc,, +numpy/distutils/fcompiler/__pycache__/nv.cpython-38.pyc,, +numpy/distutils/fcompiler/__pycache__/pathf95.cpython-38.pyc,, +numpy/distutils/fcompiler/__pycache__/pg.cpython-38.pyc,, +numpy/distutils/fcompiler/__pycache__/sun.cpython-38.pyc,, +numpy/distutils/fcompiler/__pycache__/vast.cpython-38.pyc,, +numpy/distutils/fcompiler/absoft.py,sha256=NJxm5Qpiv9F1Z5VClIXwXKGmJoCCEDSZmZthJQZS2Rs,5499 +numpy/distutils/fcompiler/arm.py,sha256=LTfIzpwMEsaAhQ7jtT-ROPontrCTd259-p_ZxEJLIT8,2235 +numpy/distutils/fcompiler/compaq.py,sha256=sjU2GKHJGuChtRb_MhnouMqvkIOQflmowFE6ErCWZhE,3903 +numpy/distutils/fcompiler/environment.py,sha256=DOD2FtKDk6O9k6U0h9UKWQ-65wU8z1tSPn3gUlRwCso,3080 +numpy/distutils/fcompiler/fujitsu.py,sha256=yK3wdHoF5qq25UcnIM6FzTXsJGJxdfKa_f__t04Ne7M,1333 +numpy/distutils/fcompiler/g95.py,sha256=FH4uww6re50OUT_BfdoWSLCDUqk8LvmQ2_j5RhF5nLQ,1330 +numpy/distutils/fcompiler/gnu.py,sha256=esfsKZCYUBK-o1UhP8YLEPa4rZU5oxmTaubJmMx5knY,20272 +numpy/distutils/fcompiler/hpux.py,sha256=gloUjWGo7MgJmukorDq7ZxDnnUKXx-C6AQfryQshVM4,1353 +numpy/distutils/fcompiler/ibm.py,sha256=W7r6W7kvGPBuWsrv-VsDHEUTq7bS73l4dVIU1ipm-IA,3539 +numpy/distutils/fcompiler/intel.py,sha256=XYF0GLVhJWjS8noEx4TJ704Eqt-JGBolRZEOkwgNItE,6570 +numpy/distutils/fcompiler/lahey.py,sha256=U63KMfN8zDAd_jnvMkS2N-dvP4UiSRB9Ces290qLNXw,1327 +numpy/distutils/fcompiler/mips.py,sha256=LAwT0DY5yqlYh20hNMYR1-OKu8A9GNw-TbUfI8pvglM,1714 +numpy/distutils/fcompiler/nag.py,sha256=9pQCMUlwjRVHGKwZxvwd4bW5p-9v7VXcflELEImHg1g,2777 +numpy/distutils/fcompiler/none.py,sha256=6RX2X-mV1HuhJZnVfQmDmLVhIUWseIT4P5wf3rdLq9Y,758 +numpy/distutils/fcompiler/nv.py,sha256=LGBQY417zibQ-fnPis5rNtP_I1Qk9OlhEFOnPvmwXHI,1560 +numpy/distutils/fcompiler/pathf95.py,sha256=MiHVar6-beUEYVEpqXORIX4f8G29I47D36kreltdfoQ,1061 +numpy/distutils/fcompiler/pg.py,sha256=NOB1stzrjvQMZS7bIPTgWTcAFe3cjNveA5-SztUZqD0,3568 +numpy/distutils/fcompiler/sun.py,sha256=mfS3RTj9uYT6K9Ikp8RjmsEPIWAtUTzMhX9sGjEyF6I,1577 +numpy/distutils/fcompiler/vast.py,sha256=Xuxa4sNraUPcQmt45SogAfN0kDHFb6C73uNZNmX3RBE,1667 +numpy/distutils/from_template.py,sha256=hpoFQortsLZdMSr_fJILzXzrIwFlZoFjsDSo6jNtvWs,7913 +numpy/distutils/intelccompiler.py,sha256=N_pvWjlLORdlH34cs97oU4LBNr_s9r5ddsmme7XEvs4,4234 +numpy/distutils/lib2def.py,sha256=NlfwSfYfUkW3bY4fRvvSgjUF7c6Gs99B6GoRsOrH6gI,3644 +numpy/distutils/line_endings.py,sha256=a8ZZECrPRffsbs0UygeR47_fOUlZppnx-QPssrIXtB0,2032 +numpy/distutils/log.py,sha256=m8caNBwPhIG7YTnD9iq9jjc6_yJOeU9FHuau2CSulds,2879 +numpy/distutils/mingw/gfortran_vs2003_hack.c,sha256=cbsN3Lk9Hkwzr9c-yOP2xEBg1_ml1X7nwAMDWxGjzc8,77 +numpy/distutils/mingw32ccompiler.py,sha256=gauMo6-R850v0zkh8O4YIOmLo1wQdGAYt8Gd60qbwWI,22284 +numpy/distutils/misc_util.py,sha256=2i49oIlLIfQhcWGzQn3dtBj8A6UVgKbrHWT_N3N2uTY,89383 +numpy/distutils/msvc9compiler.py,sha256=FCtP7g34AVuMIaqQlH8AV1ZBdIUXbk5G7eBeeTSr1zE,2192 +numpy/distutils/msvccompiler.py,sha256=tvTGpdK41L6yJe5W_o_TOFZV3p5IXtjSxmnVFaR52uU,1928 +numpy/distutils/npy_pkg_config.py,sha256=fIFyWLTqRySO3hn-0i0FNdHeblRN_hDv-wc68-sa3hQ,12972 +numpy/distutils/numpy_distribution.py,sha256=10Urolg1aDAG0EHYfcvObzOgqRV0ARh2GhDklEg4vS0,634 +numpy/distutils/pathccompiler.py,sha256=KnJEA5H4cXg7SLrMjwWtidD24VSvOdu72d17votiY9E,713 +numpy/distutils/setup.py,sha256=l9ke_Bws431UdBfysaq7ZeGtZ8dix76oh9Huq5qqbkU,634 +numpy/distutils/system_info.py,sha256=9jHSv4qtDjVbSqiy9eKmRpSKY7WRwzKL7AEcNctxY6g,111028 +numpy/distutils/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +numpy/distutils/tests/__pycache__/__init__.cpython-38.pyc,, +numpy/distutils/tests/__pycache__/test_build_ext.cpython-38.pyc,, +numpy/distutils/tests/__pycache__/test_ccompiler_opt.cpython-38.pyc,, +numpy/distutils/tests/__pycache__/test_ccompiler_opt_conf.cpython-38.pyc,, +numpy/distutils/tests/__pycache__/test_exec_command.cpython-38.pyc,, +numpy/distutils/tests/__pycache__/test_fcompiler.cpython-38.pyc,, +numpy/distutils/tests/__pycache__/test_fcompiler_gnu.cpython-38.pyc,, +numpy/distutils/tests/__pycache__/test_fcompiler_intel.cpython-38.pyc,, +numpy/distutils/tests/__pycache__/test_fcompiler_nagfor.cpython-38.pyc,, +numpy/distutils/tests/__pycache__/test_from_template.cpython-38.pyc,, +numpy/distutils/tests/__pycache__/test_log.cpython-38.pyc,, +numpy/distutils/tests/__pycache__/test_mingw32ccompiler.cpython-38.pyc,, +numpy/distutils/tests/__pycache__/test_misc_util.cpython-38.pyc,, +numpy/distutils/tests/__pycache__/test_npy_pkg_config.cpython-38.pyc,, +numpy/distutils/tests/__pycache__/test_shell_utils.cpython-38.pyc,, +numpy/distutils/tests/__pycache__/test_system_info.cpython-38.pyc,, +numpy/distutils/tests/test_build_ext.py,sha256=qX-j6UBmpigiwwZ9RMMkTcHXBrEB0QXYfejDlM2J-zc,2664 +numpy/distutils/tests/test_ccompiler_opt.py,sha256=7gwawxhjnI2h-8ErqQDgYYlNYI6MnNXhTEKczXFp5Ys,28751 +numpy/distutils/tests/test_ccompiler_opt_conf.py,sha256=vwUllmhwwgP6fyMqGUbIfDfUf2cLpQW4vudI6oWyuco,6345 +numpy/distutils/tests/test_exec_command.py,sha256=b2Vv5zCRnkH72vhQQRSeC3zWqJPdDBa1gcOzTyWnJ_g,7301 +numpy/distutils/tests/test_fcompiler.py,sha256=mJXezTXDUbduhCwVGAfABHpEARWhnj8hLW9EOU3rn84,1277 +numpy/distutils/tests/test_fcompiler_gnu.py,sha256=nmfaFCVzbViIOQ2-MjgXt-bN8Uj674hCgiwr5Iol-_U,2136 +numpy/distutils/tests/test_fcompiler_intel.py,sha256=mxkfFD2rNfg8nn1pp_413S0uCdYXydPWBcz9ilgGkA0,1058 +numpy/distutils/tests/test_fcompiler_nagfor.py,sha256=CKEjik7YVfSJGL4abuctkmlkIUhAhv-x2aUcXiTR9b0,1102 +numpy/distutils/tests/test_from_template.py,sha256=SDYoe0XUpAayyEQDq7ZhrvEEz7U9upJDLYzhcdoVifc,1103 +numpy/distutils/tests/test_log.py,sha256=0tSM4q-00CjbMIRb9QOJzI4A7GHUiRGOG1SOOLz8dnM,868 +numpy/distutils/tests/test_mingw32ccompiler.py,sha256=rMC8-IyBOiuZVfAoklV_KnD9qVeB_hFVvb5dStxfk08,1609 +numpy/distutils/tests/test_misc_util.py,sha256=Qs96vTr8GZSyVCWuamzcNlVMRa15vt0Y-T2yZSUm_QA,3218 +numpy/distutils/tests/test_npy_pkg_config.py,sha256=apGrmViPcXoPCEOgDthJgL13C9N0qQMs392QjZDxJd4,2557 +numpy/distutils/tests/test_shell_utils.py,sha256=OqwJrX9DsBjm4kXq2cBaioXle8FXEB70Ka8hk9sqfho,1954 +numpy/distutils/tests/test_system_info.py,sha256=3q3rJdD1dUUSsDXOXxqSU-Af-wwt56KnkmIQl4pLzvk,10996 +numpy/distutils/unixccompiler.py,sha256=fN4-LH6JJp44SLE7JkdG2kKQlK4LC8zuUpVC-RtmJ-U,5426 +numpy/doc/__init__.py,sha256=OYmE-F6x0CD05PCDY2MiW1HLlwB6i9vhDpk-a3r4lHY,508 +numpy/doc/__pycache__/__init__.cpython-38.pyc,, +numpy/doc/__pycache__/constants.cpython-38.pyc,, +numpy/doc/__pycache__/ufuncs.cpython-38.pyc,, +numpy/doc/constants.py,sha256=PlXoj7b4A8Aa9nADbg83uzTBRJaX8dvJmEdbn4FDPPo,9155 +numpy/doc/ufuncs.py,sha256=i1alLg19mNyCFZ2LYSOZGm--RsRN1x63U_UYU-N3x60,5357 +numpy/dual.py,sha256=aWZFc7rFVWLoWs9M4-nhf_S131RvsLRUdZrMIag_AzU,2214 +numpy/f2py/__init__.py,sha256=pz3o4B-f7ULADSfF1ml2Aij_dNAHv6l_UKMr9IyzH1s,5289 +numpy/f2py/__init__.pyi,sha256=Hg1AY3we-8hmhXq1fsFrTaUe5TD_FvIxkJIDiw5eI8Y,1107 +numpy/f2py/__main__.py,sha256=6i2jVH2fPriV1aocTY_dUFvWK18qa-zjpnISA-OpF3w,130 +numpy/f2py/__pycache__/__init__.cpython-38.pyc,, +numpy/f2py/__pycache__/__main__.cpython-38.pyc,, +numpy/f2py/__pycache__/__version__.cpython-38.pyc,, +numpy/f2py/__pycache__/auxfuncs.cpython-38.pyc,, +numpy/f2py/__pycache__/capi_maps.cpython-38.pyc,, +numpy/f2py/__pycache__/cb_rules.cpython-38.pyc,, +numpy/f2py/__pycache__/cfuncs.cpython-38.pyc,, +numpy/f2py/__pycache__/common_rules.cpython-38.pyc,, +numpy/f2py/__pycache__/crackfortran.cpython-38.pyc,, +numpy/f2py/__pycache__/diagnose.cpython-38.pyc,, +numpy/f2py/__pycache__/f2py2e.cpython-38.pyc,, +numpy/f2py/__pycache__/f90mod_rules.cpython-38.pyc,, +numpy/f2py/__pycache__/func2subr.cpython-38.pyc,, +numpy/f2py/__pycache__/rules.cpython-38.pyc,, +numpy/f2py/__pycache__/setup.cpython-38.pyc,, +numpy/f2py/__pycache__/symbolic.cpython-38.pyc,, +numpy/f2py/__pycache__/use_rules.cpython-38.pyc,, +numpy/f2py/__version__.py,sha256=7HHdjR82FCBmftwMRyrlhcEj-8mGQb6oCH-wlUPH4Nw,34 +numpy/f2py/auxfuncs.py,sha256=Arny8GrF89fqHngjxTPAKv9FoESZKC4eOJoF5JXm0Tk,21779 +numpy/f2py/capi_maps.py,sha256=dD0_oo40J6GysABX_XqcCSfZI2ElPAC0Q9QbVN2A3Oc,31388 +numpy/f2py/cb_rules.py,sha256=xXiiuGAmyJz-1KIOhkf5oGd4O2TUhqPPSL1L5Jexmw4,24854 +numpy/f2py/cfuncs.py,sha256=WSxrzhGjYFHyCWvgRCh2uVluHR9T7gfFlxtQkPf-XZo,49403 +numpy/f2py/common_rules.py,sha256=IWfRQfhlSCziDn-3hGoIpIHGQ7yC-EaC0WKx9YrXs6I,4925 +numpy/f2py/crackfortran.py,sha256=tqkpwa-jDnljbrRkmn6n8eteMMk_6sbQyumPsv4hqnc,132021 +numpy/f2py/diagnose.py,sha256=W59xcrGVf-1ed9FkQgCxgW0d9a2lENaxHUpYVAZ2w00,5230 +numpy/f2py/f2py2e.py,sha256=LYDZRmF4McQV68jOkjg-JHk1MhAU5z0YVgLEkFsE_5k,24626 +numpy/f2py/f90mod_rules.py,sha256=oLZtJ_T1QNCra3CACW8oULmQioYU4bOVchWtgQp1zL8,9811 +numpy/f2py/func2subr.py,sha256=7Gg17NbMA8TooCEv-4_XBnfkg6Jjt1TAYkFIl0y--e4,9355 +numpy/f2py/rules.py,sha256=pZb_NNh5ZiZdSu38eY2zYXPRKFnChmHqmDyYSEUJWtc,61517 +numpy/f2py/setup.py,sha256=9QD603_UEa1HAuJHtoNY2twKwDKoepk72ikyKQpwhjM,2335 +numpy/f2py/src/fortranobject.c,sha256=0UeS33f19zFtrZP4liHUTSqfh2pYW3ZtloLf-9epEjM,37535 +numpy/f2py/src/fortranobject.h,sha256=aF7ACqS_fdrqj4sWi2aYB_Nsf9mcVU6jPGy-G-0Z54M,4384 +numpy/f2py/symbolic.py,sha256=3ERySC3mYO8-NfAfTDmMOd0yfPuYs8kceqxTXKFbpZA,53004 +numpy/f2py/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +numpy/f2py/tests/__pycache__/__init__.cpython-38.pyc,, +numpy/f2py/tests/__pycache__/test_abstract_interface.cpython-38.pyc,, +numpy/f2py/tests/__pycache__/test_array_from_pyobj.cpython-38.pyc,, +numpy/f2py/tests/__pycache__/test_assumed_shape.cpython-38.pyc,, +numpy/f2py/tests/__pycache__/test_block_docstring.cpython-38.pyc,, +numpy/f2py/tests/__pycache__/test_callback.cpython-38.pyc,, +numpy/f2py/tests/__pycache__/test_common.cpython-38.pyc,, +numpy/f2py/tests/__pycache__/test_compile_function.cpython-38.pyc,, +numpy/f2py/tests/__pycache__/test_crackfortran.cpython-38.pyc,, +numpy/f2py/tests/__pycache__/test_f2cmap.cpython-38.pyc,, +numpy/f2py/tests/__pycache__/test_f2py2e.cpython-38.pyc,, +numpy/f2py/tests/__pycache__/test_kind.cpython-38.pyc,, +numpy/f2py/tests/__pycache__/test_mixed.cpython-38.pyc,, +numpy/f2py/tests/__pycache__/test_module_doc.cpython-38.pyc,, +numpy/f2py/tests/__pycache__/test_parameter.cpython-38.pyc,, +numpy/f2py/tests/__pycache__/test_quoted_character.cpython-38.pyc,, +numpy/f2py/tests/__pycache__/test_regression.cpython-38.pyc,, +numpy/f2py/tests/__pycache__/test_return_character.cpython-38.pyc,, +numpy/f2py/tests/__pycache__/test_return_complex.cpython-38.pyc,, +numpy/f2py/tests/__pycache__/test_return_integer.cpython-38.pyc,, +numpy/f2py/tests/__pycache__/test_return_logical.cpython-38.pyc,, +numpy/f2py/tests/__pycache__/test_return_real.cpython-38.pyc,, +numpy/f2py/tests/__pycache__/test_semicolon_split.cpython-38.pyc,, +numpy/f2py/tests/__pycache__/test_size.cpython-38.pyc,, +numpy/f2py/tests/__pycache__/test_string.cpython-38.pyc,, +numpy/f2py/tests/__pycache__/test_symbolic.cpython-38.pyc,, +numpy/f2py/tests/__pycache__/util.cpython-38.pyc,, +numpy/f2py/tests/src/abstract_interface/foo.f90,sha256=JFU2w98cB_XNwfrqNtI0yDTmpEdxYO_UEl2pgI_rnt8,658 +numpy/f2py/tests/src/abstract_interface/gh18403_mod.f90,sha256=gvQJIzNtvacWE0dhysxn30-iUeI65Hpq7DiE9oRauz8,105 +numpy/f2py/tests/src/array_from_pyobj/wrapmodule.c,sha256=OJNF4ukYGmiVSmzeA8uVU6D4Fwa4wUysYVQRdul1_AI,7244 +numpy/f2py/tests/src/assumed_shape/.f2py_f2cmap,sha256=But9r9m4iL7EGq_haMW8IiQ4VivH0TgUozxX4pPvdpE,29 +numpy/f2py/tests/src/assumed_shape/foo_free.f90,sha256=oBwbGSlbr9MkFyhVO2aldjc01dr9GHrMrSiRQek8U64,460 +numpy/f2py/tests/src/assumed_shape/foo_mod.f90,sha256=rfzw3QdI-eaDSl-hslCgGpd5tHftJOVhXvb21Y9Gf6M,499 +numpy/f2py/tests/src/assumed_shape/foo_use.f90,sha256=rmT9k4jP9Ru1PLcGqepw9Jc6P9XNXM0axY7o4hi9lUw,269 +numpy/f2py/tests/src/assumed_shape/precision.f90,sha256=r08JeTVmTTExA-hYZ6HzaxVwBn1GMbPAuuwBhBDtJUk,130 +numpy/f2py/tests/src/block_docstring/foo.f,sha256=y7lPCPu7_Fhs_Tf2hfdpDQo1bhtvNSKRaZAOpM_l3dg,97 +numpy/f2py/tests/src/callback/foo.f,sha256=C1hjfpRCQWiOVVzIHqnsYcnLrqQcixrnHCn8hd9GhVk,1254 +numpy/f2py/tests/src/callback/gh17797.f90,sha256=_Nrl0a2HgUbtymGU0twaJ--7rMa1Uco2A3swbWvHoMo,148 +numpy/f2py/tests/src/callback/gh18335.f90,sha256=NraOyKIXyvv_Y-3xGnmTjtNjW2Znsnlk8AViI8zfovc,506 +numpy/f2py/tests/src/cli/hi77.f,sha256=ttyI6vAP3qLnDqy82V04XmoqrXNM6uhMvvLri2p0dq0,71 +numpy/f2py/tests/src/cli/hiworld.f90,sha256=QWOLPrTxYQu1yrEtyQMbM0fE9M2RmXe7c185KnD5x3o,51 +numpy/f2py/tests/src/common/block.f,sha256=GQ0Pd-VMX3H3a-__f2SuosSdwNXHpBqoGnQDjf8aG9g,224 +numpy/f2py/tests/src/crackfortran/accesstype.f90,sha256=-5Din7YlY1TU7tUHD2p-_DSTxGBpDsWYNeT9WOwGhno,208 +numpy/f2py/tests/src/crackfortran/foo_deps.f90,sha256=CaH7mnWTG7FcnJe2vXN_0zDbMadw6NCqK-JJ2HmDjK8,128 +numpy/f2py/tests/src/crackfortran/gh15035.f,sha256=jJly1AzF5L9VxbVQ0vr-sf4LaUo4eQzJguhuemFxnvg,375 +numpy/f2py/tests/src/crackfortran/gh17859.f,sha256=7K5dtOXGuBDAENPNCt-tAGJqTfNKz5OsqVSk16_e7Es,340 +numpy/f2py/tests/src/crackfortran/gh2848.f90,sha256=gPNasx98SIf7Z9ibk_DHiGKCvl7ERtsfoGXiFDT7FbM,282 +numpy/f2py/tests/src/crackfortran/operators.f90,sha256=-Fc-qjW1wBr3Dkvdd5dMTrt0hnjnV-1AYo-NFWcwFSo,1184 +numpy/f2py/tests/src/crackfortran/privatemod.f90,sha256=7bubZGMIn7iD31wDkjF1TlXCUM7naCIK69M9d0e3y-U,174 +numpy/f2py/tests/src/crackfortran/publicmod.f90,sha256=Pnwyf56Qd6W3FUH-ZMgnXEYkb7gn18ptNTdwmGan0Jo,167 +numpy/f2py/tests/src/f2cmap/.f2py_f2cmap,sha256=iUOtfHd3OuT1Rz2-yiSgt4uPKGvCt5AzQ1iygJt_yjg,82 +numpy/f2py/tests/src/f2cmap/isoFortranEnvMap.f90,sha256=Jc20TOyOB4up6ZlPTgVX5qqfZFutYZ6rLKA7wSNNGw0,298 +numpy/f2py/tests/src/kind/foo.f90,sha256=zIHpw1KdkWbTzbXb73hPbCg4N2Htj3XL8DIwM7seXpo,347 +numpy/f2py/tests/src/mixed/foo.f,sha256=90zmbSHloY1XQYcPb8B5d9bv9mCZx8Z8AMTtgDwJDz8,85 +numpy/f2py/tests/src/mixed/foo_fixed.f90,sha256=pxKuPzxF3Kn5khyFq9ayCsQiolxB3SaNtcWaK5j6Rv4,179 +numpy/f2py/tests/src/mixed/foo_free.f90,sha256=fIQ71wrBc00JUAVUj_r3QF9SdeNniBiMw6Ly7CGgPWU,139 +numpy/f2py/tests/src/module_data/mod.mod,sha256=EkjrU7NTZrOH68yKrz6C_eyJMSFSxGgC2yMQT9Zscek,412 +numpy/f2py/tests/src/module_data/module_data_docstring.f90,sha256=tDZ3fUlazLL8ThJm3VwNGJ75QIlLcW70NnMFv-JA4W0,224 +numpy/f2py/tests/src/negative_bounds/issue_20853.f90,sha256=fdOPhRi7ipygwYCXcda7p_dlrws5Hd2GlpF9EZ-qnck,157 +numpy/f2py/tests/src/parameter/constant_both.f90,sha256=-bBf2eqHb-uFxgo6Q7iAtVUUQzrGFqzhHDNaxwSICfQ,1939 +numpy/f2py/tests/src/parameter/constant_compound.f90,sha256=re7pfzcuaquiOia53UT7qNNrTYu2euGKOF4IhoLmT6g,469 +numpy/f2py/tests/src/parameter/constant_integer.f90,sha256=nEmMLitKoSAG7gBBEQLWumogN-KS3DBZOAZJWcSDnFw,612 +numpy/f2py/tests/src/parameter/constant_non_compound.f90,sha256=IcxESVLKJUZ1k9uYKoSb8Hfm9-O_4rVnlkiUU2diy8Q,609 +numpy/f2py/tests/src/parameter/constant_real.f90,sha256=quNbDsM1Ts2rN4WtPO67S9Xi_8l2cXabWRO00CPQSSQ,610 +numpy/f2py/tests/src/quoted_character/foo.f,sha256=WjC9D9171fe2f7rkUAZUvik9bkIf9adByfRGzh6V0cM,482 +numpy/f2py/tests/src/regression/inout.f90,sha256=CpHpgMrf0bqA1W3Ozo3vInDz0RP904S7LkpdAH6ODck,277 +numpy/f2py/tests/src/return_character/foo77.f,sha256=WzDNF3d_hUDSSZjtxd3DtE-bSx1ilOMEviGyYHbcFgM,980 +numpy/f2py/tests/src/return_character/foo90.f90,sha256=ULcETDEt7gXHRzmsMhPsGG4o3lGrcx-FEFaJsPGFKyA,1248 +numpy/f2py/tests/src/return_complex/foo77.f,sha256=8ECRJkfX82oFvGWKbIrCvKjf5QQQClx4sSEvsbkB6A8,973 +numpy/f2py/tests/src/return_complex/foo90.f90,sha256=c1BnrtWwL2dkrTr7wvlEqNDg59SeNMo3gyJuGdRwcDw,1238 +numpy/f2py/tests/src/return_integer/foo77.f,sha256=_8k1evlzBwvgZ047ofpdcbwKdF8Bm3eQ7VYl2Y8b5kA,1178 +numpy/f2py/tests/src/return_integer/foo90.f90,sha256=bzxbYtofivGRYH35Ang9ScnbNsVERN8-6ub5-eI-LGQ,1531 +numpy/f2py/tests/src/return_logical/foo77.f,sha256=FxiF_X0HkyXHzJM2rLyTubZJu4JB-ObLnVqfZwAQFl8,1188 +numpy/f2py/tests/src/return_logical/foo90.f90,sha256=9KmCe7yJYpi4ftkKOM3BCDnPOdBPTbUNrKxY3p37O14,1531 +numpy/f2py/tests/src/return_real/foo77.f,sha256=ZTrzb6oDrIDPlrVWP3Bmtkbz3ffHaaSQoXkfTGtCuFE,933 +numpy/f2py/tests/src/return_real/foo90.f90,sha256=gZuH5lj2lG6gqHlH766KQ3J4-Ero-G4WpOOo2MG3ohU,1194 +numpy/f2py/tests/src/size/foo.f90,sha256=IlFAQazwBRr3zyT7v36-tV0-fXtB1d7WFp6S1JVMstg,815 +numpy/f2py/tests/src/string/char.f90,sha256=ihr_BH9lY7eXcQpHHDQhFoKcbu7VMOX5QP2Tlr7xlaM,618 +numpy/f2py/tests/src/string/fixed_string.f90,sha256=5n6IkuASFKgYICXY9foCVoqndfAY0AQZFEK8L8ARBGM,695 +numpy/f2py/tests/src/string/string.f,sha256=shr3fLVZaa6SyUJFYIF1OZuhff8v5lCwsVNBU2B-3pk,248 +numpy/f2py/tests/test_abstract_interface.py,sha256=qH97VaPKDPA5LekfA_0DYuE8_Wq8-d4Dqx-J5wJU3zU,721 +numpy/f2py/tests/test_array_from_pyobj.py,sha256=MyXMcHQbvBUyB-sxrEjnG_pkt5hNpTQlxYpWiVCirg4,22071 +numpy/f2py/tests/test_assumed_shape.py,sha256=gmaopkXIxIy6RqGF9mLLbFbcJ-ugPZIFZmGsw7WSo0M,1445 +numpy/f2py/tests/test_block_docstring.py,sha256=SEpuq73T9oVtHhRVilFf1xF7nb683d4-Kv7V0kfL4AA,564 +numpy/f2py/tests/test_callback.py,sha256=A2gdVQMQt8OxvIQo4dkoEqafi_k7IKGR_Z19eOJJe94,6087 +numpy/f2py/tests/test_common.py,sha256=SZlrUR1e_CbkUD4O6i99QgUmOctHQNP0MmyhMWpio5E,584 +numpy/f2py/tests/test_compile_function.py,sha256=9d_FZ8P2wbIlQ2qPDRrsFqPb4nMH8tiWqYZN-P_shCs,4186 +numpy/f2py/tests/test_crackfortran.py,sha256=-ShAU5BU-eBAIdTr5Pc699OR7TStkHz7RIQiUDEUM0Y,8934 +numpy/f2py/tests/test_f2cmap.py,sha256=p-Sylbr3ctdKT3UQV9FzpCuYPH5U7Vyn8weXFAjiI9o,391 +numpy/f2py/tests/test_f2py2e.py,sha256=B0nL4uL8kwqoDpMkur5juolUns7RoVSun0zh20mW6hk,19766 +numpy/f2py/tests/test_kind.py,sha256=PVTTv8_7JyYK-443Hsup0CY97nkK_5AVth-agnNG87g,847 +numpy/f2py/tests/test_mixed.py,sha256=Ctuw-H7DxhPjSt7wZdJ2xffawIoEBCPWc5F7PSkY4HY,848 +numpy/f2py/tests/test_module_doc.py,sha256=sjCXWIKrqMD1NQ1DUAzgQqkjS5w9h9gvM_Lj29Rdcrg,863 +numpy/f2py/tests/test_parameter.py,sha256=ADI7EV_CM4ztICpqHqeq8LI-WdB6cX0ttatdRdjbsUA,3941 +numpy/f2py/tests/test_quoted_character.py,sha256=cpjMdrHwimnkoJkXd_W_FSlh43oWytY5VHySW9oskO4,454 +numpy/f2py/tests/test_regression.py,sha256=19GNZxElsPX1HV0p5pXrh4_KWt0whjeZTLDEttA0aHI,2157 +numpy/f2py/tests/test_return_character.py,sha256=ivRGEMRYP_X0YX20YdflZRSui9QsywTyq6_oBZ5_IV8,1491 +numpy/f2py/tests/test_return_complex.py,sha256=2dKwE8719iJj-gn_N4zNy8Z2FFS3BYDPzcfNHJdbiqM,2390 +numpy/f2py/tests/test_return_integer.py,sha256=JwxT4obkr0PZsdJqJWIpdY0UiL0xa4xgVBlkWV0LqO4,1850 +numpy/f2py/tests/test_return_logical.py,sha256=ydbhcxkHPweakobMdM-N6m9PjMEUO3fFXjNyrMMLtWY,2017 +numpy/f2py/tests/test_return_real.py,sha256=03xCQfSUKUA7phf0CpjhsjyoD9CCbLyTk0w0SdWhkvA,3346 +numpy/f2py/tests/test_semicolon_split.py,sha256=_Mdsi84lES18pPjl9J-QsbGttV4tPFFjZvJvejNcqPc,1635 +numpy/f2py/tests/test_size.py,sha256=q6YqQvcyqdXJeWbGijTiCbxyEG3EkPcvT8AlAW6RCMo,1164 +numpy/f2py/tests/test_string.py,sha256=5xZOfdReoHnId0950XfmtfduPPfBbtMkzBoXMtygvMk,2962 +numpy/f2py/tests/test_symbolic.py,sha256=28quk2kTKfWhKe56n4vINJ8G9weKBfc7HysMlE9J3_g,18341 +numpy/f2py/tests/util.py,sha256=rq0GJwksZHQRG2kCtvtU6yyCJiXCZPQUr1P285mZuIM,10189 +numpy/f2py/use_rules.py,sha256=5t6X17rF6y42SwuUYe1LtNihJJEIgCU7f9jPqKphfgA,3587 +numpy/fft/__init__.py,sha256=HqjmF6s_dh0Ri4UZzUDtOKbNUyfAfJAWew3e3EL_KUk,8175 +numpy/fft/__init__.pyi,sha256=vD9Xzz5r13caF4AVL87Y4U9KOj9ic25Vci_wb3dmgpk,550 +numpy/fft/__pycache__/__init__.cpython-38.pyc,, +numpy/fft/__pycache__/_pocketfft.cpython-38.pyc,, +numpy/fft/__pycache__/helper.cpython-38.pyc,, +numpy/fft/__pycache__/setup.cpython-38.pyc,, +numpy/fft/_pocketfft.py,sha256=Xkm8wcP4JyBNMbp0ZoHIWhNDlgliX24RzrDuo29uRks,52897 +numpy/fft/_pocketfft.pyi,sha256=S6-ylUuHbgm8vNbh7tLru6K2R5SJzE81BC_Sllm6QrQ,2371 +numpy/fft/_pocketfft_internal.cpython-38-x86_64-linux-gnu.so,sha256=kpYUwsEzlh9B4ef2r9DsjcLtrRsV_JtbHVNY2qOtHi4,97032 +numpy/fft/helper.py,sha256=aNj1AcLvtfoX26RiLOwcR-k2QSMuBZkGj2Fu0CeFPJs,6154 +numpy/fft/helper.pyi,sha256=IyF_3Aj28khupENTnh6iXU6IqY7t0Me6POJWGTCrLMw,1152 +numpy/fft/setup.py,sha256=OJPeJK4PuEtWRw_yVTZj4dKxfu2y-w3ZtQ6EUaQjQyk,728 +numpy/fft/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +numpy/fft/tests/__pycache__/__init__.cpython-38.pyc,, +numpy/fft/tests/__pycache__/test_helper.cpython-38.pyc,, +numpy/fft/tests/__pycache__/test_pocketfft.cpython-38.pyc,, +numpy/fft/tests/test_helper.py,sha256=whgeaQ8PzFf3B1wkbXobGZ5sF4WxPp4gf1UPUVZest8,6148 +numpy/fft/tests/test_pocketfft.py,sha256=lG4NLMbHid5gAXe4HxpayUK08T5wNJnBOwbhW4vY5Lw,12827 +numpy/lib/__init__.py,sha256=FbFTdqaeZW-euF0vebpg1jE3MYEjB8tS9eoYIRtnUHg,1779 +numpy/lib/__init__.pyi,sha256=NL1R-fQAOrnEQ-eRd4mwSM-46gryLzyZWb3f7SFr84Q,5582 +numpy/lib/__pycache__/__init__.cpython-38.pyc,, +numpy/lib/__pycache__/_datasource.cpython-38.pyc,, +numpy/lib/__pycache__/_iotools.cpython-38.pyc,, +numpy/lib/__pycache__/_version.cpython-38.pyc,, +numpy/lib/__pycache__/arraypad.cpython-38.pyc,, +numpy/lib/__pycache__/arraysetops.cpython-38.pyc,, +numpy/lib/__pycache__/arrayterator.cpython-38.pyc,, +numpy/lib/__pycache__/format.cpython-38.pyc,, +numpy/lib/__pycache__/function_base.cpython-38.pyc,, +numpy/lib/__pycache__/histograms.cpython-38.pyc,, +numpy/lib/__pycache__/index_tricks.cpython-38.pyc,, +numpy/lib/__pycache__/mixins.cpython-38.pyc,, +numpy/lib/__pycache__/nanfunctions.cpython-38.pyc,, +numpy/lib/__pycache__/npyio.cpython-38.pyc,, +numpy/lib/__pycache__/polynomial.cpython-38.pyc,, +numpy/lib/__pycache__/recfunctions.cpython-38.pyc,, +numpy/lib/__pycache__/scimath.cpython-38.pyc,, +numpy/lib/__pycache__/setup.cpython-38.pyc,, +numpy/lib/__pycache__/shape_base.cpython-38.pyc,, +numpy/lib/__pycache__/stride_tricks.cpython-38.pyc,, +numpy/lib/__pycache__/twodim_base.cpython-38.pyc,, +numpy/lib/__pycache__/type_check.cpython-38.pyc,, +numpy/lib/__pycache__/ufunclike.cpython-38.pyc,, +numpy/lib/__pycache__/user_array.cpython-38.pyc,, +numpy/lib/__pycache__/utils.cpython-38.pyc,, +numpy/lib/_datasource.py,sha256=8S1FpiqOhaFkFW8dJw969p2i94eC7uz8ynqOel2-bNc,22643 +numpy/lib/_iotools.py,sha256=OL6MmiWabT1_g30YhGjYrNFuBoNSyDCHqiDgXuu_qFQ,30873 +numpy/lib/_version.py,sha256=6vK7czNSB_KrWx2rZJzJ1pyOc73Q07hAgfLB5ItUCnU,4855 +numpy/lib/_version.pyi,sha256=B572hyWrUWG-TAAAXrNNAT4AgyUAmJ4lvgpwMkDzunk,633 +numpy/lib/arraypad.py,sha256=PoLrImHYFt_V17_r0lDfDlYViZHOPbLEiqtomFAdlxU,31226 +numpy/lib/arraypad.pyi,sha256=ADXphtAORYl3EqvE5qs_u32B_TALKSOtF43jOLmoxRw,1728 +numpy/lib/arraysetops.py,sha256=g_YyVd8pTvzdLpVvEaK7gt6Aeleg8myJZl0mGgduqEA,26737 +numpy/lib/arraysetops.pyi,sha256=zFIbRBIx5FMqc86QIKFjHRcjukm5rQ60UOJzid0-kNs,8337 +numpy/lib/arrayterator.py,sha256=BQ97S00zvfURUZfes0GZo-5hydYNRuvwX1I1bLzeRik,7063 +numpy/lib/arrayterator.pyi,sha256=f7Pwp83_6DiMYmJGUsffncM-FRAynB1iYGvhmHM_SZE,1537 +numpy/lib/format.py,sha256=Ne4qD9sVdL-jC4KeBeAzzYK5AkglssJfQFsOfMLCURs,31377 +numpy/lib/format.pyi,sha256=YWBxC3GdsZ7SKBN8I7nMwWeVuFD1aT9d-VJ8zE4-P-o,748 +numpy/lib/function_base.py,sha256=XoOc84lRIM6jS-9NfK2qgmK-cVGnB8ZjhmBXTbqUyhQ,182881 +numpy/lib/function_base.pyi,sha256=i2pKVnN2_ohYqIjm_6vpT6rpYY1anQJq-RDBPncyyd4,16623 +numpy/lib/histograms.py,sha256=1ZYXjmD6D14VyjZvSpXTABASoz7fT0us22hgRtsZApQ,40212 +numpy/lib/histograms.pyi,sha256=O0vgZnCFsHG1WVIZXA4yLtpF9v6wpiOyrBAI6A_Q2wA,1050 +numpy/lib/index_tricks.py,sha256=27B5ZJl8pQcAkt_ICZEIjQsDwgt-gMt_GXPIhdQZtNk,30575 +numpy/lib/index_tricks.pyi,sha256=1zACf_X8lbHWOkfkxLJZ5o5Ig_wmRXT_EbA7wnqOlvw,4241 +numpy/lib/mixins.py,sha256=awJWn-wXkA6fg3TaPvMtXzUWaJVXKAn8fOt3XLPJ690,7052 +numpy/lib/mixins.pyi,sha256=h9N1kbZsUntF0zjOxPYeD_rCB2dMiG35TYYPl9ymkI4,3117 +numpy/lib/nanfunctions.py,sha256=GXsgklyf-H8TqnyJsXe504aFy8Ddl92Uqu6we96Mr38,65666 +numpy/lib/nanfunctions.pyi,sha256=oPqAfCinmBL85Ji7ko4QlzAzLAK9nZL0t2_CllEbCEU,606 +numpy/lib/npyio.py,sha256=Jm3AkhNMzN96_QbETy0gvU1n8SoEV4s1xvTP8Qg-aiM,94701 +numpy/lib/npyio.pyi,sha256=tw5eZd7Tk6ohtH2C7uBGgYjJbSHx0qSOnSeCUBSlKKI,9616 +numpy/lib/polynomial.py,sha256=tfqWBGIDhT9oCs9YU66Xv5UejeM1GliLVMhcCAKXVnc,44143 +numpy/lib/polynomial.pyi,sha256=GerIpQnf5LdtFMOy9AxhOTqUyfn57k4MxqEYrfdckWE,6958 +numpy/lib/recfunctions.py,sha256=lbGH6XM5k-M4yO6jUN7kRnPRCFeWHS2GqWViEehtzdM,56324 +numpy/lib/scimath.py,sha256=T4ITysZgqhY1J8IxyXCtioHjMTg2ci-4i3mr9TBF2UA,15037 +numpy/lib/scimath.pyi,sha256=E2roKJzMFwWSyhLu8UPUr54WOpxF8jp_pyXYBgsUSQ8,2883 +numpy/lib/setup.py,sha256=0K5NJKuvKvNEWp-EX7j0ODi3ZQQgIMHobzSFJq3G7yM,405 +numpy/lib/shape_base.py,sha256=SyP0QGyroBugy2n45sfV7aMDwxgO0KdhIGpuA8Pujng,39267 +numpy/lib/shape_base.pyi,sha256=t7koJnkOXLootnfoqtUsMC1r7kUMmWkNRpCMh34MTDg,5184 +numpy/lib/stride_tricks.py,sha256=brY5b-0YQJuIH2CavfpIinMolyTUv5k9DUvLoZ-imis,17911 +numpy/lib/stride_tricks.pyi,sha256=0pQ4DP9l6g21q2Ajv6dJFRWMr9auPGTNV9BmZUbogPY,1747 +numpy/lib/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +numpy/lib/tests/__pycache__/__init__.cpython-38.pyc,, +numpy/lib/tests/__pycache__/test__datasource.cpython-38.pyc,, +numpy/lib/tests/__pycache__/test__iotools.cpython-38.pyc,, +numpy/lib/tests/__pycache__/test__version.cpython-38.pyc,, +numpy/lib/tests/__pycache__/test_arraypad.cpython-38.pyc,, +numpy/lib/tests/__pycache__/test_arraysetops.cpython-38.pyc,, +numpy/lib/tests/__pycache__/test_arrayterator.cpython-38.pyc,, +numpy/lib/tests/__pycache__/test_financial_expired.cpython-38.pyc,, +numpy/lib/tests/__pycache__/test_format.cpython-38.pyc,, +numpy/lib/tests/__pycache__/test_function_base.cpython-38.pyc,, +numpy/lib/tests/__pycache__/test_histograms.cpython-38.pyc,, +numpy/lib/tests/__pycache__/test_index_tricks.cpython-38.pyc,, +numpy/lib/tests/__pycache__/test_io.cpython-38.pyc,, +numpy/lib/tests/__pycache__/test_loadtxt.cpython-38.pyc,, +numpy/lib/tests/__pycache__/test_mixins.cpython-38.pyc,, +numpy/lib/tests/__pycache__/test_nanfunctions.cpython-38.pyc,, +numpy/lib/tests/__pycache__/test_packbits.cpython-38.pyc,, +numpy/lib/tests/__pycache__/test_polynomial.cpython-38.pyc,, +numpy/lib/tests/__pycache__/test_recfunctions.cpython-38.pyc,, +numpy/lib/tests/__pycache__/test_regression.cpython-38.pyc,, +numpy/lib/tests/__pycache__/test_shape_base.cpython-38.pyc,, +numpy/lib/tests/__pycache__/test_stride_tricks.cpython-38.pyc,, +numpy/lib/tests/__pycache__/test_twodim_base.cpython-38.pyc,, +numpy/lib/tests/__pycache__/test_type_check.cpython-38.pyc,, +numpy/lib/tests/__pycache__/test_ufunclike.cpython-38.pyc,, +numpy/lib/tests/__pycache__/test_utils.cpython-38.pyc,, +numpy/lib/tests/data/py2-objarr.npy,sha256=F4cyUC-_TB9QSFLAo2c7c44rC6NUYIgrfGx9PqWPSKk,258 +numpy/lib/tests/data/py2-objarr.npz,sha256=xo13HBT0FbFZ2qvZz0LWGDb3SuQASSaXh7rKfVcJjx4,366 +numpy/lib/tests/data/py3-objarr.npy,sha256=pTTVh8ezp-lwAK3fkgvdKU8Arp5NMKznVD-M6Ex_uA0,341 +numpy/lib/tests/data/py3-objarr.npz,sha256=qQR0gS57e9ta16d_vCQjaaKM74gPdlwCPkp55P-qrdw,449 +numpy/lib/tests/data/python3.npy,sha256=X0ad3hAaLGXig9LtSHAo-BgOvLlFfPYMnZuVIxRmj-0,96 +numpy/lib/tests/data/win64python2.npy,sha256=agOcgHVYFJrV-nrRJDbGnUnF4ZTPYXuSeF-Mtg7GMpc,96 +numpy/lib/tests/test__datasource.py,sha256=HLhDpqI36qIWXdLmY9pPXpZSZdRccMKZ-h2U5jl62gE,10487 +numpy/lib/tests/test__iotools.py,sha256=HerCqvDE07JxjFQlWEfpZO7lC9z0Sbr3z20GSutoCPs,13743 +numpy/lib/tests/test__version.py,sha256=aO3YgkAohLsLzCNQ7vjIwdpFUMz0cPLbcuuxIkjuN74,1999 +numpy/lib/tests/test_arraypad.py,sha256=tk44LLvBuOMmcFN-_2ao8ykkqXHiuDyj-lRL1UL0A1I,54278 +numpy/lib/tests/test_arraysetops.py,sha256=_duBTnyplA4qlMPDcTUwH4ixl95g7ELOX8z9GUzCd8E,28747 +numpy/lib/tests/test_arrayterator.py,sha256=AYs2SwV5ankgwnvKI9RSO1jZck118nu3SyZ4ngzZNso,1291 +numpy/lib/tests/test_financial_expired.py,sha256=yq5mqGMvqpkiiw9CuZhJgrYa7Squj1mXr_G-IvAFgwI,247 +numpy/lib/tests/test_format.py,sha256=7olWpFK7Wt0y1XwhTaaGH67ncF9CLJvEH6T-qCZ5b-c,38457 +numpy/lib/tests/test_function_base.py,sha256=ODDM-mREuHuCGx05lJcVQVapSeSMPU3MuNOiJjX5oCw,146019 +numpy/lib/tests/test_histograms.py,sha256=HFCgnxK_UsiHyq1gSZPNYvDorMou2LDXDXndpe9589o,33672 +numpy/lib/tests/test_index_tricks.py,sha256=hufhkDwdubN-6wk0vghkE5vE9TC7Kc_gmw50b-r7sgU,18955 +numpy/lib/tests/test_io.py,sha256=AOHpfKd8hQ9rf7qTXYWVD1H698wNR5MDSTlHa-Ha-_8,106371 +numpy/lib/tests/test_loadtxt.py,sha256=MnTEgF7GzBeMf8Z9iJn0jNc4mxL1snQybse7Kt_eBfg,37404 +numpy/lib/tests/test_mixins.py,sha256=Wivwz3XBWsEozGzrzsyyvL3qAuE14t1BHk2LPm9Z9Zc,7030 +numpy/lib/tests/test_nanfunctions.py,sha256=dHUvkPoKr9pEqqpMQ-W4mtYPaUqNdyBEl7GRBZYUSzg,44591 +numpy/lib/tests/test_packbits.py,sha256=OWGAd5g5GG0gl7WHqNfwkZ7G-2rrtLt2sI854PG4nnw,17546 +numpy/lib/tests/test_polynomial.py,sha256=URouxJpr8FQ5hiKybqhtOcLA7e-3hj4kWzjLBROByyA,11395 +numpy/lib/tests/test_recfunctions.py,sha256=QioJDHHWUeOyTVQ9tqm6i-BvWkco77tgTBrHX7rm5eM,41099 +numpy/lib/tests/test_regression.py,sha256=KzGFkhTcvEG97mymoOQ2hP2CEr2nPZou0Ztf4-WaXCs,8257 +numpy/lib/tests/test_shape_base.py,sha256=2G1FCskYEfVk_1uu8qPSbWG59aF9zXzjVhztpZU-1NA,25739 +numpy/lib/tests/test_stride_tricks.py,sha256=wprpWWH5eq07DY7rzG0WDv5fMtLxzRQz6fm6TZWlScQ,22849 +numpy/lib/tests/test_twodim_base.py,sha256=zbTVB5bz9m1o1F1UKsSseF6BcfYoJPg_6n3HPNwp_BY,18951 +numpy/lib/tests/test_type_check.py,sha256=akjNP3V7IGIdvoA73cxrx6XdaNRTaUaKdAR-XPYm9tw,15119 +numpy/lib/tests/test_ufunclike.py,sha256=8umwt73iT_zIbk20MxQSoK5LWD6Bvv9gBUkaPXiRNEw,3278 +numpy/lib/tests/test_utils.py,sha256=XJH5jKw9VvX0iYeIZKwmAWSXKB_kxMU2xGDLet3i3Kc,4560 +numpy/lib/twodim_base.py,sha256=-kAclSeduaVth6csSLB48OPYu32FoEmL16nLjjYPjhc,31612 +numpy/lib/twodim_base.pyi,sha256=wXqIqsDiGg0HOfYJkYIsV1b4FBq_dI39yMrFfAKllNs,5463 +numpy/lib/type_check.py,sha256=fLW_HRLqV4zzsL0QHVgJ7axUtAghK90za-BweERX200,19931 +numpy/lib/type_check.pyi,sha256=LPvAvIxU-p5i_Qe-ic7hEvo4OTfSrNpplxMG7OAZe8Q,5571 +numpy/lib/ufunclike.py,sha256=8WVNpHtt5kOkPYDhvlmHql-Swg5zV0f09bJwnVJNpm0,8031 +numpy/lib/ufunclike.pyi,sha256=hLxcYfQprh1tTY_UO2QscA3Hd9Zd7cVGXIINZLhMFqY,1293 +numpy/lib/user_array.py,sha256=LE958--CMkBI2r3l1SQxmCHdCSw6HY6-RhWCnduzGA4,7721 +numpy/lib/utils.py,sha256=_WnlnawWLwy4Cat2K62chN-JYpDZfHDRGDux6C-VU1g,33284 +numpy/lib/utils.pyi,sha256=CoNNhy7uNgJiSwkLJVPwnZ3nZG9eod1ujgLHP1XbdRc,2327 +numpy/linalg/__init__.py,sha256=mpdlEXWtTvpF7In776ONLwp6RIyo4U_GLPT1L1eIJnw,1813 +numpy/linalg/__init__.pyi,sha256=XBy4ocuypsRVflw_mbSTUhR4N5Roemu6w5SfeVwbkAc,620 +numpy/linalg/__pycache__/__init__.cpython-38.pyc,, +numpy/linalg/__pycache__/linalg.cpython-38.pyc,, +numpy/linalg/__pycache__/setup.cpython-38.pyc,, +numpy/linalg/_umath_linalg.cpython-38-x86_64-linux-gnu.so,sha256=qgPz1DR_CyEzVc-BVKUq6W7BJeLT0xyoFKAM6NgSpaM,239200 +numpy/linalg/lapack_lite.cpython-38-x86_64-linux-gnu.so,sha256=e_bQe2jkFw_heS5aAtU7sS8CqJM7tJ4GJEJEiiUDWdk,30016 +numpy/linalg/linalg.py,sha256=7HCo_2mHB6Qh3pdyKjIFFzTPfZ4RzG9KfSb4Zh5U7m0,89813 +numpy/linalg/linalg.pyi,sha256=CzYJbM2F5LqUuGtIAQ3fztzMd4O9Fxz10ujmDgZxm4k,7440 +numpy/linalg/setup.py,sha256=FTkorAbmcuvh85pTwsSEAwT9jI1mbk6RXFjwz-cQpnA,2925 +numpy/linalg/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +numpy/linalg/tests/__pycache__/__init__.cpython-38.pyc,, +numpy/linalg/tests/__pycache__/test_deprecations.cpython-38.pyc,, +numpy/linalg/tests/__pycache__/test_linalg.cpython-38.pyc,, +numpy/linalg/tests/__pycache__/test_regression.cpython-38.pyc,, +numpy/linalg/tests/test_deprecations.py,sha256=9p_SRmtxj2zc1doY9Ie3dyy5JzWy-tCQWFoajcAJUmM,640 +numpy/linalg/tests/test_linalg.py,sha256=UEfjeD3WUibVNDikNa3AaGe_DKjkGXPve5jdFcLk-7E,77352 +numpy/linalg/tests/test_regression.py,sha256=wfJx2G8SeApiIta80xN2hzot-wvXSw-TF8TXXIYZwyE,5597 +numpy/ma/__init__.py,sha256=dgP0WdnOpph28Fd6UiqoyDKhfrct0H6QWqbCcETsk6M,1404 +numpy/ma/__init__.pyi,sha256=89bS3ZnV7UOFx0ioGZW79E_GQOgfBJ6Sa1DWsvbR7BQ,6085 +numpy/ma/__pycache__/__init__.cpython-38.pyc,, +numpy/ma/__pycache__/bench.cpython-38.pyc,, +numpy/ma/__pycache__/core.cpython-38.pyc,, +numpy/ma/__pycache__/extras.cpython-38.pyc,, +numpy/ma/__pycache__/mrecords.cpython-38.pyc,, +numpy/ma/__pycache__/setup.cpython-38.pyc,, +numpy/ma/__pycache__/testutils.cpython-38.pyc,, +numpy/ma/__pycache__/timer_comparison.cpython-38.pyc,, +numpy/ma/bench.py,sha256=tSsmn5f59rOx6e7UGU3kyAedPhJG2sp-8LZHeZPla6g,4859 +numpy/ma/core.py,sha256=-gn7nJAd2CLPTtRIfHfI_xO1ad9laarbdwOPlhwOK7A,269111 +numpy/ma/core.pyi,sha256=YvHW8hTuqiqMbsbWbFT8oN3ZUFagDJ37CB5UMYwuPt8,14181 +numpy/ma/extras.py,sha256=wV0b3V51LZXgsdUHnwPYEdxLMAj8ImgflJ2uI7kAgSQ,60895 +numpy/ma/extras.pyi,sha256=BBsiCZbaPpGCY506fkmqZdBkJNCXcglc3wcSBuAACNk,2646 +numpy/ma/mrecords.py,sha256=degd6dLaDEvEWNHmvSnUZXos1csIzaqjR_jAutm8JfI,27232 +numpy/ma/mrecords.pyi,sha256=r1a2I662ywnhGS6zvfcyK-9RHVvb4sHxiCx9Dhf5AE4,1934 +numpy/ma/setup.py,sha256=MqmMicr_xHkAGoG-T7NJ4YdUZIJLO4ZFp6AmEJDlyhw,418 +numpy/ma/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +numpy/ma/tests/__pycache__/__init__.cpython-38.pyc,, +numpy/ma/tests/__pycache__/test_core.cpython-38.pyc,, +numpy/ma/tests/__pycache__/test_deprecations.cpython-38.pyc,, +numpy/ma/tests/__pycache__/test_extras.cpython-38.pyc,, +numpy/ma/tests/__pycache__/test_mrecords.cpython-38.pyc,, +numpy/ma/tests/__pycache__/test_old_ma.cpython-38.pyc,, +numpy/ma/tests/__pycache__/test_regression.cpython-38.pyc,, +numpy/ma/tests/__pycache__/test_subclassing.cpython-38.pyc,, +numpy/ma/tests/test_core.py,sha256=uF62WE5XhAkDr4yDZfy-YdfSIWSznARYnQ9cx_ef4CU,205483 +numpy/ma/tests/test_deprecations.py,sha256=ylBZx-5tGNimMk4xqUl0R2YUL5DX297XzSdL46U4wRk,2777 +numpy/ma/tests/test_extras.py,sha256=QegLCWCUlcqOUu8KkEKm8EOf7pJExdw-OrhY3vC-Ryk,71529 +numpy/ma/tests/test_mrecords.py,sha256=3IbTkbbDJhHfbkf-oWgpATghrwnIKA3XMtVFtnx257w,19883 +numpy/ma/tests/test_old_ma.py,sha256=wkZM5NnvkJCDropQT5dYbL14qweNv6e1aLptQzV4xbY,32758 +numpy/ma/tests/test_regression.py,sha256=Gr5p91SxeKK3jA3Kl7OGKOLdg40nSSHaMSjeVqIuvMM,3079 +numpy/ma/tests/test_subclassing.py,sha256=CW2YojzuS24QvEiPOXDqki6WHYgUZuKCCxYwpkExXDk,14214 +numpy/ma/testutils.py,sha256=KOD9yEe6rUTZ_nMDcZyXphBP1vpfV1vzvbmIhVaJrsg,10239 +numpy/ma/timer_comparison.py,sha256=pIGSZG-qYYYlRWSTgzPlyCAINbGKhXrZrDZBBjiM080,15658 +numpy/matlib.py,sha256=0tYjeI3dLL0-zpuavuiXkdnewfnhQ_3Pxsz-CI1hl98,10365 +numpy/matrixlib/__init__.py,sha256=L4GDL_3Z8Tf-s8v5hgFbnCzCMNSzvnZydENoSZBkWI4,218 +numpy/matrixlib/__init__.pyi,sha256=-t3ZuvbzRuRwWfZOeN4xlNWdm7gQEprhUsWzu8MRvUE,252 +numpy/matrixlib/__pycache__/__init__.cpython-38.pyc,, +numpy/matrixlib/__pycache__/defmatrix.cpython-38.pyc,, +numpy/matrixlib/__pycache__/setup.cpython-38.pyc,, +numpy/matrixlib/defmatrix.py,sha256=K9ecSTjVAETfgpCLPEALKn5CvT-QynDDFQvMn_3gmv0,30667 +numpy/matrixlib/defmatrix.pyi,sha256=lmBMRahKcMOl2PHDo79J67VRAZOkI54BzfDaTLpE0LI,451 +numpy/matrixlib/setup.py,sha256=1r7JRkSM4HyVorgtjoKJGWLcOcPO3wmvivpeEsVtAEg,426 +numpy/matrixlib/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +numpy/matrixlib/tests/__pycache__/__init__.cpython-38.pyc,, +numpy/matrixlib/tests/__pycache__/test_defmatrix.cpython-38.pyc,, +numpy/matrixlib/tests/__pycache__/test_interaction.cpython-38.pyc,, +numpy/matrixlib/tests/__pycache__/test_masked_matrix.cpython-38.pyc,, +numpy/matrixlib/tests/__pycache__/test_matrix_linalg.cpython-38.pyc,, +numpy/matrixlib/tests/__pycache__/test_multiarray.cpython-38.pyc,, +numpy/matrixlib/tests/__pycache__/test_numeric.cpython-38.pyc,, +numpy/matrixlib/tests/__pycache__/test_regression.cpython-38.pyc,, +numpy/matrixlib/tests/test_defmatrix.py,sha256=8E_-y7VD2vsq1y8CcI8km37pp5qcAtkciO16xqf2UIs,14982 +numpy/matrixlib/tests/test_interaction.py,sha256=PpjmgjEKighDXvt38labKE6L7f2jP74UEmp3JRb_iOY,11875 +numpy/matrixlib/tests/test_masked_matrix.py,sha256=RyL5DfLJoNUe-ZgQndMvpP8Jp_XKlreyhWjR1sfU-9A,8925 +numpy/matrixlib/tests/test_matrix_linalg.py,sha256=ObbSUXU4R2pWajH__xAdizADrU2kBKDDCxkDV-oVBXc,2059 +numpy/matrixlib/tests/test_multiarray.py,sha256=jB3XCBmAtcqf-Wb9PwBW6uIykPpMPthuXLJ0giTKzZE,554 +numpy/matrixlib/tests/test_numeric.py,sha256=MP70qUwgshTtThKZaZDp7_6U-Z66NIV1geVhasGXejQ,441 +numpy/matrixlib/tests/test_regression.py,sha256=8sHDtO8Zi8p3a1eQKEWxtCmKrXmHoD3qxlIokg2AIAU,927 +numpy/polynomial/__init__.py,sha256=8jrPKniYrbrE59nmLBbH2WLxNLeMkZ-vQuLa3Hu9Apg,6788 +numpy/polynomial/__init__.pyi,sha256=W8szYtVUy0RUi83jmFLK58BN8CKVSoHA2CW7IcdUl1c,701 +numpy/polynomial/__pycache__/__init__.cpython-38.pyc,, +numpy/polynomial/__pycache__/_polybase.cpython-38.pyc,, +numpy/polynomial/__pycache__/chebyshev.cpython-38.pyc,, +numpy/polynomial/__pycache__/hermite.cpython-38.pyc,, +numpy/polynomial/__pycache__/hermite_e.cpython-38.pyc,, +numpy/polynomial/__pycache__/laguerre.cpython-38.pyc,, +numpy/polynomial/__pycache__/legendre.cpython-38.pyc,, +numpy/polynomial/__pycache__/polynomial.cpython-38.pyc,, +numpy/polynomial/__pycache__/polyutils.cpython-38.pyc,, +numpy/polynomial/__pycache__/setup.cpython-38.pyc,, +numpy/polynomial/_polybase.py,sha256=n_5hGWdm0M-848FOc4Nm5ZXITrxgRLEoccfJxqbZT1U,36485 +numpy/polynomial/_polybase.pyi,sha256=R_hpsVb_tnzrSwtnp3v6ZXnJoU5rmTp-DEPPNM8J350,2247 +numpy/polynomial/chebyshev.py,sha256=_qbtl09xdBK0ZTNUaOUnZY-f5j5PImJEc8h8eKDN-jk,62490 +numpy/polynomial/chebyshev.pyi,sha256=035CNdOas4dnb6lFLzRiBrYT_VnWh2T1-A3ibm_HYkI,1387 +numpy/polynomial/hermite.py,sha256=EWb1Fa-0Hl8qI18bkplFOXoyR7aU3_etQjsC6g1VikY,52238 +numpy/polynomial/hermite.pyi,sha256=hdsvTULow8bIjnATudf0i6brpLHV7vbOoHzaMvbjMy0,1217 +numpy/polynomial/hermite_e.py,sha256=9gSngNFbr3U39lUEU8lxwfLMxi5K5E7c64b2Sjz8rLY,52366 +numpy/polynomial/hermite_e.pyi,sha256=zV7msb9v9rV0iv_rnD3SjP-TGyc6pd3maCqiPCj3PbA,1238 +numpy/polynomial/laguerre.py,sha256=ACxiDr-SlY-F-iUpnTQCN7JaBVt8FDBBrWPIxuNm8O4,50568 +numpy/polynomial/laguerre.pyi,sha256=Gxc9SLISNKMWrKdsVJ9fKFFFwfxxZzfF-Yc-2r__z5M,1178 +numpy/polynomial/legendre.py,sha256=Pyp8xafrILE0qZxSHnQLo5C6xB4zNHWRikHEcLsyU00,51274 +numpy/polynomial/legendre.pyi,sha256=9dmANwkxf7EbOHV3XQBPoaDtc56cCkf75Wo7FG9Zfj4,1178 +numpy/polynomial/polynomial.py,sha256=l8CnljcDTqW6JEOtzvzfXhBvMK0le7gI3SRtnDOS-Os,48690 +numpy/polynomial/polynomial.pyi,sha256=bOPRnub4xXxsUwNGeiQLTT4PCfN1ysSrf6LBZIcAN2Y,1132 +numpy/polynomial/polyutils.py,sha256=xyHL_X5yxum8z1wCN3HA5J48WMgpxm0zmQ5bqg_iq80,22105 +numpy/polynomial/polyutils.pyi,sha256=FQPYayL0opxcsQfOOcxCtb7Tg6TKr3ytYXnxmQT3ffM,227 +numpy/polynomial/setup.py,sha256=dXQfzVUMP9OcB6iKv5yo1GLEwFB3gJ48phIgo4N-eM0,373 +numpy/polynomial/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +numpy/polynomial/tests/__pycache__/__init__.cpython-38.pyc,, +numpy/polynomial/tests/__pycache__/test_chebyshev.cpython-38.pyc,, +numpy/polynomial/tests/__pycache__/test_classes.cpython-38.pyc,, +numpy/polynomial/tests/__pycache__/test_hermite.cpython-38.pyc,, +numpy/polynomial/tests/__pycache__/test_hermite_e.cpython-38.pyc,, +numpy/polynomial/tests/__pycache__/test_laguerre.cpython-38.pyc,, +numpy/polynomial/tests/__pycache__/test_legendre.cpython-38.pyc,, +numpy/polynomial/tests/__pycache__/test_polynomial.cpython-38.pyc,, +numpy/polynomial/tests/__pycache__/test_polyutils.cpython-38.pyc,, +numpy/polynomial/tests/__pycache__/test_printing.cpython-38.pyc,, +numpy/polynomial/tests/test_chebyshev.py,sha256=6tMsFP1h7K8Zf72mNOta6Tv52_fVTlXknseuffj080c,20522 +numpy/polynomial/tests/test_classes.py,sha256=DFyY2IQBj3r2GZkvbRIeZO2EEY466xbuwc4PShAl4Sw,18331 +numpy/polynomial/tests/test_hermite.py,sha256=N9b2dx2UWPyja5v02dSoWYPnKvb6H-Ozgtrx-xjWz2k,18577 +numpy/polynomial/tests/test_hermite_e.py,sha256=_A3ohAWS4HXrQG06S8L47dImdZGTwYosCXnoyw7L45o,18911 +numpy/polynomial/tests/test_laguerre.py,sha256=BZOgs49VBXOFBepHopxuEDkIROHEvFBfWe4X73UZhn8,17511 +numpy/polynomial/tests/test_legendre.py,sha256=b_bblHs0F_BWw9ESuSq52ZsLKcQKFR5eqPf_SppWFqo,18673 +numpy/polynomial/tests/test_polynomial.py,sha256=OjoRocjhPfEd1tOW6J5LwUan3SdWTLwzHOzLU9umcI8,20238 +numpy/polynomial/tests/test_polyutils.py,sha256=IxkbVfpcBqe5lOZluHFUPbLATLu1rwVg7ghLASpfYrY,3579 +numpy/polynomial/tests/test_printing.py,sha256=Txe4Ac_P5w07avL_2Wr7niF7U8yPBqSLJkgMpGa3Va0,15786 +numpy/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +numpy/random/__init__.pxd,sha256=9JbnX540aJNSothGs-7e23ozhilG6U8tINOUEp08M_k,431 +numpy/random/__init__.py,sha256=81Thnexg5umN5WZwD5TRyzNc2Yp-d14B6UC7NBgVKh8,7506 +numpy/random/__init__.pyi,sha256=3Giv8W2ELfu8n-B7aiMYdXegLIVrS9uu-HpzpLqyM2s,2055 +numpy/random/__pycache__/__init__.cpython-38.pyc,, +numpy/random/__pycache__/_pickle.cpython-38.pyc,, +numpy/random/__pycache__/setup.cpython-38.pyc,, +numpy/random/_bounded_integers.cpython-38-x86_64-linux-gnu.so,sha256=OjVMwSo7kpfSUNzvkxFlJWq4Pn6GG1NFZmSwWRM05gs,441920 +numpy/random/_bounded_integers.pxd,sha256=hcoucPH5hkFEM2nm12zYO-5O_Rt8RujEXT5YWuAzl1Q,1669 +numpy/random/_common.cpython-38-x86_64-linux-gnu.so,sha256=v_bPO-qs93fSH216S_OHLIcCi3EchurwjRabPrk5kGk,311056 +numpy/random/_common.pxd,sha256=yb9RtI6u1nyYGnIu1KwX4h_A0pEwA3HExVKdWJ6eMU0,4745 +numpy/random/_examples/cffi/__pycache__/extending.cpython-38.pyc,, +numpy/random/_examples/cffi/__pycache__/parse.cpython-38.pyc,, +numpy/random/_examples/cffi/extending.py,sha256=xSla3zWqxi6Hj48EvnYfD3WHfE189VvC4XsKu4_T_Iw,880 +numpy/random/_examples/cffi/parse.py,sha256=o41aw7pB_nA8RfLDUlaP0DNDO_bDo__B0XM5pGLxtY0,1829 +numpy/random/_examples/cython/__pycache__/setup.cpython-38.pyc,, +numpy/random/_examples/cython/extending.pyx,sha256=4IE692pq1V53UhPZqQiQGcIHXDoNyqTx62x5a36puVg,2290 +numpy/random/_examples/cython/extending_distributions.pyx,sha256=oazFVWeemfE0eDzax7r7MMHNL1_Yofws2m-c_KT2Hbo,3870 +numpy/random/_examples/cython/setup.py,sha256=mLckw_C9kipWCVT4Eq5nkpZEUB0E3Hfom8rbjl7q1dE,1448 +numpy/random/_examples/numba/__pycache__/extending.cpython-38.pyc,, +numpy/random/_examples/numba/__pycache__/extending_distributions.cpython-38.pyc,, +numpy/random/_examples/numba/extending.py,sha256=Ipyzel_h5iU_DMJ_vnXUgQC38uMDMn7adUpWSeEQLFE,1957 +numpy/random/_examples/numba/extending_distributions.py,sha256=Jnr9aWkHyIWygNbdae32GVURK-5T9BTGhuExRpvve98,2034 +numpy/random/_generator.cpython-38-x86_64-linux-gnu.so,sha256=LW2PZ9DM_vqU9Tw98FNBtXcNeWkVE1sY8zPA0iMudv8,1035072 +numpy/random/_generator.pyi,sha256=WWrF4oNiUPalnzPeiDO1rkWsm6iAqicTvQC-59pJNlg,21682 +numpy/random/_mt19937.cpython-38-x86_64-linux-gnu.so,sha256=uIFQRubQJWvQhJ_GU8NDWfSxrIXdkB9lrjyg2iKdo8Q,124472 +numpy/random/_mt19937.pyi,sha256=_iZKaAmuKBQ4itSggfQvYYj_KjktcN4rt-YpE6bqFAM,724 +numpy/random/_pcg64.cpython-38-x86_64-linux-gnu.so,sha256=crHvffytMWJBcoaw7XM9X2uhb1SLyflGC73EBQE_2Sc,126880 +numpy/random/_pcg64.pyi,sha256=uxr5CbEJetN6lv9vBG21jlRhuzOK8SQnXrwqAQBxj_c,1091 +numpy/random/_philox.cpython-38-x86_64-linux-gnu.so,sha256=uJVptddYrJD9MXSSoOmnJkVIDh9GcDh6yAHlwjt93mQ,106008 +numpy/random/_philox.pyi,sha256=OKlaiIU-hj72Bp04zjNifwusOD_3-mYxIfvyuys8c_o,978 +numpy/random/_pickle.py,sha256=bNQeLjnzvu3-AqKied42orG4Fh75Oi1DuH23sQz5mFE,2305 +numpy/random/_sfc64.cpython-38-x86_64-linux-gnu.so,sha256=XCwVgqEq7Ec0S3h3xPhOnMFDPFHYf7R2pjSK9lVxvBw,76128 +numpy/random/_sfc64.pyi,sha256=09afHTedVW-519493ZXtGcl-H-_zluj-B_yfEJG8MMs,709 +numpy/random/bit_generator.cpython-38-x86_64-linux-gnu.so,sha256=SvMzdph6xLEbVlFmADciIb90o_uAFPn2vtpWqt7WnQU,227216 +numpy/random/bit_generator.pxd,sha256=lArpIXSgTwVnJMYc4XX0NGxegXq3h_QsUDK6qeZKbNc,1007 +numpy/random/bit_generator.pyi,sha256=cGZU1H0hAszMBzP4BhvmfWCGXHlXOp5Kx_Koar6r0Dw,3387 +numpy/random/c_distributions.pxd,sha256=FrGMrxWXGD8tc4HUWnzLpzUU8codNR-alXk1hjIAjmI,6033 +numpy/random/lib/libnpyrandom.a,sha256=TEqoEnbHLOOCdcE157dZ_q1OOdQBHPc0rcb-WaUqriQ,274034 +numpy/random/mtrand.cpython-38-x86_64-linux-gnu.so,sha256=YCarJ53LsSj1uZj44_-vadIAVVchRLnA0buOg6OEUqQ,825520 +numpy/random/mtrand.pyi,sha256=UxxighuldyE8L23LoJs7F1b4fUjyxG5oj7h0z-5LDIU,19616 +numpy/random/setup.py,sha256=Cck92cScNxegafuWrM-3hV0ZRSYCxhi-jrbx3tR_wNQ,6998 +numpy/random/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +numpy/random/tests/__pycache__/__init__.cpython-38.pyc,, +numpy/random/tests/__pycache__/test_direct.cpython-38.pyc,, +numpy/random/tests/__pycache__/test_extending.cpython-38.pyc,, +numpy/random/tests/__pycache__/test_generator_mt19937.cpython-38.pyc,, +numpy/random/tests/__pycache__/test_generator_mt19937_regressions.cpython-38.pyc,, +numpy/random/tests/__pycache__/test_random.cpython-38.pyc,, +numpy/random/tests/__pycache__/test_randomstate.cpython-38.pyc,, +numpy/random/tests/__pycache__/test_randomstate_regression.cpython-38.pyc,, +numpy/random/tests/__pycache__/test_regression.cpython-38.pyc,, +numpy/random/tests/__pycache__/test_seed_sequence.cpython-38.pyc,, +numpy/random/tests/__pycache__/test_smoke.cpython-38.pyc,, +numpy/random/tests/data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +numpy/random/tests/data/__pycache__/__init__.cpython-38.pyc,, +numpy/random/tests/data/mt19937-testset-1.csv,sha256=Xkef402AVB-eZgYQkVtoxERHkxffCA9Jyt_oMbtJGwY,15844 +numpy/random/tests/data/mt19937-testset-2.csv,sha256=nsBEQNnff-aFjHYK4thjvUK4xSXDSfv5aTbcE59pOkE,15825 +numpy/random/tests/data/pcg64-testset-1.csv,sha256=xB00DpknGUTTCxDr9L6aNo9Hs-sfzEMbUSS4t11TTfE,23839 +numpy/random/tests/data/pcg64-testset-2.csv,sha256=NTdzTKvG2U7_WyU_IoQUtMzU3kEvDH39CgnR6VzhTkw,23845 +numpy/random/tests/data/pcg64dxsm-testset-1.csv,sha256=vNSUT-gXS_oEw_awR3O30ziVO4seNPUv1UIZ01SfVnI,23833 +numpy/random/tests/data/pcg64dxsm-testset-2.csv,sha256=uylS8PU2AIKZ185OC04RBr_OePweGRtvn-dE4YN0yYA,23839 +numpy/random/tests/data/philox-testset-1.csv,sha256=SedRaIy5zFadmk71nKrGxCFZ6BwKz8g1A9-OZp3IkkY,23852 +numpy/random/tests/data/philox-testset-2.csv,sha256=dWECt-sbfvaSiK8-Ygp5AqyjoN5i26VEOrXqg01rk3g,23838 +numpy/random/tests/data/sfc64-testset-1.csv,sha256=iHs6iX6KR8bxGwKk-3tedAdMPz6ZW8slDSUECkAqC8Q,23840 +numpy/random/tests/data/sfc64-testset-2.csv,sha256=FIDIDFCaPZfWUSxsJMAe58hPNmMrU27kCd9FhCEYt_k,23833 +numpy/random/tests/test_direct.py,sha256=ROlEv_OqQQ2-vtypmqNtg-wzLXNuNe8YIQaMgBQfhLs,16429 +numpy/random/tests/test_extending.py,sha256=d50c5E5wueAfkYM5qZQ9YAJk735M735XPnZUL2SLfto,3488 +numpy/random/tests/test_generator_mt19937.py,sha256=bom4r8eSr4O53gtwBPb5X07pwNxYGq2at-LmsZCp8kU,113329 +numpy/random/tests/test_generator_mt19937_regressions.py,sha256=SAdHm3KlGjdh0IKyOF8TQd1YS-P59nSkIwKOe9SuT0U,5639 +numpy/random/tests/test_random.py,sha256=sTm24yZocm2BpEEa24SueCuhdHg5Dg6Ftb0XCVrQDZY,69953 +numpy/random/tests/test_randomstate.py,sha256=vHRYMUDrR192QhQyVN8g0g5Wbv5igzP56d9TZ3WkNhM,81516 +numpy/random/tests/test_randomstate_regression.py,sha256=VucYWIjA7sAquWsalvZMnfkmYLM1O6ysyWnLl931-lA,7917 +numpy/random/tests/test_regression.py,sha256=trntK51UvajOVELiluEO85l64CKSw5nvBSc5SqYyr9w,5439 +numpy/random/tests/test_seed_sequence.py,sha256=GNRJ4jyzrtfolOND3gUWamnbvK6-b_p1bBK_RIG0sfU,3311 +numpy/random/tests/test_smoke.py,sha256=jjNz0aEGD1_oQl9a9UWt6Mz_298alG7KryLT1pgHljw,28183 +numpy/setup.py,sha256=u3vdMH69z-UM6XNxec8o2cIp9AEfNqZ7fsVGp48ChLk,1101 +numpy/testing/__init__.py,sha256=G8Qlx2bRgbnTCVFGoo8kR_OlsebpcTaJHeYUnHY4sZ8,650 +numpy/testing/__init__.pyi,sha256=FB_4wiugmKbDTWXr-FVxp-mGNvJQjGUBYz5C5xblgnI,1803 +numpy/testing/__pycache__/__init__.cpython-38.pyc,, +numpy/testing/__pycache__/print_coercion_tables.cpython-38.pyc,, +numpy/testing/__pycache__/setup.cpython-38.pyc,, +numpy/testing/__pycache__/utils.cpython-38.pyc,, +numpy/testing/_private/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +numpy/testing/_private/__pycache__/__init__.cpython-38.pyc,, +numpy/testing/_private/__pycache__/decorators.cpython-38.pyc,, +numpy/testing/_private/__pycache__/extbuild.cpython-38.pyc,, +numpy/testing/_private/__pycache__/noseclasses.cpython-38.pyc,, +numpy/testing/_private/__pycache__/nosetester.cpython-38.pyc,, +numpy/testing/_private/__pycache__/parameterized.cpython-38.pyc,, +numpy/testing/_private/__pycache__/utils.cpython-38.pyc,, +numpy/testing/_private/decorators.py,sha256=amFUfIH86_F8qvD-jqky59GYVtqMLs7uSxZ6euHblh8,11401 +numpy/testing/_private/extbuild.py,sha256=yFqsntQv4LHSLbVOCcT0nenb87EdFc8fwyLc-LxDYEo,7816 +numpy/testing/_private/noseclasses.py,sha256=0wuRHsQVkz1c5bX1F0v2C4QEJWdhCuAdVOwo8uOefP8,14516 +numpy/testing/_private/nosetester.py,sha256=wKjN3dagwDInzGdeN6wO9JnLe6IoTxGqF_idSL0qpCQ,19435 +numpy/testing/_private/parameterized.py,sha256=mSWTmj1C2R9jjgqwMbqFlRXRcIBUaalAO8pYMg5nCpo,16156 +numpy/testing/_private/utils.py,sha256=_EEDDTlTM3oQpD5-ykBdHMIxnYjP2GSKprzFFGAa6eo,85421 +numpy/testing/_private/utils.pyi,sha256=rY_ld2hVfTK-JGTOVuhCB7xPyOdRN2KDaKjm_XdI_mo,9988 +numpy/testing/print_coercion_tables.py,sha256=ndxOsS4XfrZ4UY_9nqRTCnxhkzgdqcuUHL8nezd7Op4,6180 +numpy/testing/setup.py,sha256=GPKAtTTBRsNW4kmR7NjP6mmBR_GTdpaTvkTm10_VcLg,709 +numpy/testing/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +numpy/testing/tests/__pycache__/__init__.cpython-38.pyc,, +numpy/testing/tests/__pycache__/test_doctesting.cpython-38.pyc,, +numpy/testing/tests/__pycache__/test_utils.cpython-38.pyc,, +numpy/testing/tests/test_doctesting.py,sha256=84GCZsWBQ3gqKrRI5NzmH_PmFHMShaVpZ4m0b_T1qNA,1347 +numpy/testing/tests/test_utils.py,sha256=rPggQz9_D6X98UZPHCLO_FMnsebLqdqtVB19eTuNVUU,55025 +numpy/testing/utils.py,sha256=B77PkK2qIw8R8tKk09OpWGVQV2O_P77fu4wt5QGOXSM,1255 +numpy/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +numpy/tests/__pycache__/__init__.cpython-38.pyc,, +numpy/tests/__pycache__/test__all__.cpython-38.pyc,, +numpy/tests/__pycache__/test_ctypeslib.cpython-38.pyc,, +numpy/tests/__pycache__/test_matlib.cpython-38.pyc,, +numpy/tests/__pycache__/test_numpy_version.cpython-38.pyc,, +numpy/tests/__pycache__/test_public_api.cpython-38.pyc,, +numpy/tests/__pycache__/test_reloading.cpython-38.pyc,, +numpy/tests/__pycache__/test_scripts.cpython-38.pyc,, +numpy/tests/__pycache__/test_warnings.cpython-38.pyc,, +numpy/tests/test__all__.py,sha256=L3mCnYPTpzAgNfedVuq9g7xPWbc0c1Pot94k9jZ9NpI,221 +numpy/tests/test_ctypeslib.py,sha256=uAckGtgfFsaRGhD6ySPD5YR77US98TIUwR8DVS1bQvU,12290 +numpy/tests/test_matlib.py,sha256=gwhIXrJJo9DiecaGLCHLJBjhx2nVGl6yHq80AOUQSRM,1852 +numpy/tests/test_numpy_version.py,sha256=87imE8sJR6w16YYiTAfHxBSq7IFLnmgNpL6DUgqjKTs,1575 +numpy/tests/test_public_api.py,sha256=Jby34FmGujPqjyoyO80wifL9z-Pj31NzmO6LkMQbXt4,15916 +numpy/tests/test_reloading.py,sha256=bjyPiRx3AMPWcu-ExgbrlgmX4DxRAswwU_ci_Rl3hBk,2244 +numpy/tests/test_scripts.py,sha256=3jYt6iysOTgQjU5W_xPUo6MCRPmaFbRRP0UhVJOVLRc,1573 +numpy/tests/test_warnings.py,sha256=b7x4zdms9sNJkO9FJ-LTzYI4BWhbeLGy2oFMC6Z85ig,2280 +numpy/typing/__init__.py,sha256=EAAiyHa5jGJpF9ECFel-qnCo18VUnT5Y8YCuKd0zN-I,5231 +numpy/typing/__pycache__/__init__.cpython-38.pyc,, +numpy/typing/__pycache__/mypy_plugin.cpython-38.pyc,, +numpy/typing/__pycache__/setup.cpython-38.pyc,, +numpy/typing/mypy_plugin.py,sha256=-Lzl_iaVlYSvDZwDSk0Ee-IaWQsI1OUFbtd_aNchegU,6479 +numpy/typing/setup.py,sha256=Cnz9q53w-vJNyE6vYxqYvQXx0pJbrG9quHyz9sqxfek,374 +numpy/typing/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +numpy/typing/tests/__pycache__/__init__.cpython-38.pyc,, +numpy/typing/tests/__pycache__/test_generic_alias.cpython-38.pyc,, +numpy/typing/tests/__pycache__/test_isfile.cpython-38.pyc,, +numpy/typing/tests/__pycache__/test_runtime.cpython-38.pyc,, +numpy/typing/tests/__pycache__/test_typing.cpython-38.pyc,, +numpy/typing/tests/data/fail/arithmetic.pyi,sha256=4rY_ASCERAl8WCus1RakOe0Aw-8vvjilL29mgdD4lv0,3850 +numpy/typing/tests/data/fail/array_constructors.pyi,sha256=X9y_jUYS17WfYmXW5NwkVudyiR6ouUaAwEh0JRte42o,1089 +numpy/typing/tests/data/fail/array_like.pyi,sha256=OVAlEJZ5k8ZRKt0aGpZQwIjlUGpy0PzOOYqfI-IMqBQ,455 +numpy/typing/tests/data/fail/array_pad.pyi,sha256=57oK0Yp53rtKjjIrRFYLcxa-IfIGhtI-bEem7ggJKwI,132 +numpy/typing/tests/data/fail/arrayprint.pyi,sha256=-Fs9VnQfxyfak008Hq8kJWfB0snA6jGDXZz8ljQnwGE,549 +numpy/typing/tests/data/fail/arrayterator.pyi,sha256=FoU4ahHkJZ67dwWXer5FXLjjjesKKg-w2Jq1X1bHymA,480 +numpy/typing/tests/data/fail/bitwise_ops.pyi,sha256=GN9dVqk4_HFXn7zbRrHzJq_UGRFBccoYVUG1UuE7bXs,515 +numpy/typing/tests/data/fail/char.pyi,sha256=-vgN6EmfQ8VaA4SOZ5Ol9u4-Z7Q5I7G78LmaxZOuZ90,2615 +numpy/typing/tests/data/fail/chararray.pyi,sha256=jrNryZFpr8nxG2IHb9e0x3ranpvJpBy_RDex-WpT5rU,2296 +numpy/typing/tests/data/fail/comparisons.pyi,sha256=U4neWzwwtxG6QXsKlNGJuKXHBtwzYBQOa47_7SKF5Wg,888 +numpy/typing/tests/data/fail/constants.pyi,sha256=YSqNbXdhbdMmYbs7ntH0FCKbnm8IFeqsDlZBqcU43iw,286 +numpy/typing/tests/data/fail/datasource.pyi,sha256=PRT2hixR-mVxr2UILvHa99Dr54EF2h3snJXE-v3rWcc,395 +numpy/typing/tests/data/fail/dtype.pyi,sha256=OAGABqdXNB8gClJFEGMckoycuZcIasMaAlS2RkiKROI,334 +numpy/typing/tests/data/fail/einsumfunc.pyi,sha256=O6lo1B3IpdBQ_r6nvJudEYRekl_2g8j3PAH_eahvvyY,737 +numpy/typing/tests/data/fail/false_positives.pyi,sha256=Q61qMsSsNCtmO0EMRxHj5Z7RYTyrELVpkzfJY5eK8Z0,366 +numpy/typing/tests/data/fail/flatiter.pyi,sha256=qLM4qm7gvJtEZ0rTHcyasUzoP5JbX4FREtqV3g1w6Lo,843 +numpy/typing/tests/data/fail/fromnumeric.pyi,sha256=FH2mjkgtCbA9soqlJRhYN7IIfRRrUL1i9mwqcbYKZSc,5591 +numpy/typing/tests/data/fail/histograms.pyi,sha256=8Hx8zJ113UtHPc_yi-BM3xUqtmeUS3r3IFYvci9quQA,424 +numpy/typing/tests/data/fail/index_tricks.pyi,sha256=moINir9iQoi6Q1ZuVg5BuSB9hSBtbg_uzv-Qm_lLYZk,509 +numpy/typing/tests/data/fail/lib_function_base.pyi,sha256=6y9T773CBLX-jUry1sCQGVuKVKM2wMuQ56Ni5V5j4Dw,2081 +numpy/typing/tests/data/fail/lib_polynomial.pyi,sha256=siSXSVM0FqwwdHnYrYksOrnMrgdK_zdZ9xGVQ67iMNw,913 +numpy/typing/tests/data/fail/lib_utils.pyi,sha256=VFpE6_DisvlDByyp1PiNPJEe5IcZp8cH0FlAJyoZipo,276 +numpy/typing/tests/data/fail/lib_version.pyi,sha256=7-ZJDZwDcB-wzpMN8TeYtZAgaqc7xnQ8Dnx2ISiX2Ts,158 +numpy/typing/tests/data/fail/linalg.pyi,sha256=yDd05aK1dI37RPt3pD2eJYo4dZFaT2yB1PEu3K0y9Tg,1322 +numpy/typing/tests/data/fail/memmap.pyi,sha256=HSTCQYNuW1Y6X1Woj361pN4rusSPs4oDCXywqk20yUo,159 +numpy/typing/tests/data/fail/modules.pyi,sha256=biKdya7jl9ptCNorql1AFHoOtXU9bdTFodlIUQtbwUY,652 +numpy/typing/tests/data/fail/multiarray.pyi,sha256=XCdBxufNhR8ZtG8UMzk8nt9_NC5gJTKP9-xTqKO_K9I,1693 +numpy/typing/tests/data/fail/ndarray.pyi,sha256=YnjXy16RHs_esKelMjB07865CQ7gLyQnXhnitq5Kv5c,405 +numpy/typing/tests/data/fail/ndarray_misc.pyi,sha256=w-10xTDDWoff9Lq0dBO-jBeiBR-XjCz2qmes0dLx238,1372 +numpy/typing/tests/data/fail/nditer.pyi,sha256=w7emjnOxnf3NcvLktNLlke6Cuivn2gU3sVmGCfbG6rw,325 +numpy/typing/tests/data/fail/nested_sequence.pyi,sha256=em4GZwLDFE0QSxxg081wVwhh-Dmtkn8f7wThI0DiXVs,427 +numpy/typing/tests/data/fail/npyio.pyi,sha256=nUAt8mHO_ZzKsdo_G9mjJfaBCdrba_Q3KiyJwzMiHys,780 +numpy/typing/tests/data/fail/numerictypes.pyi,sha256=S_AIFg4DsJ1sX3EcCAh7ZlsAkpCsycZ_tU92Sj1DWyY,341 +numpy/typing/tests/data/fail/random.pyi,sha256=p5WsUGyOL-MGIeALh9Y0dVhYSRQLaUwMdjXc3G6C_7Q,2830 +numpy/typing/tests/data/fail/rec.pyi,sha256=Ws3TyesnoQjt7Q0wwtpShRDJmZCs2jjP17buFMomVGA,704 +numpy/typing/tests/data/fail/scalars.pyi,sha256=StglCm8lfzTZbp0Va_abLFXE48Pa63e58PLwWT6rX04,2955 +numpy/typing/tests/data/fail/shape_base.pyi,sha256=Y_f4buHtX2Q2ZA4kaDTyR8LErlPXTzCB_-jBoScGh_Q,152 +numpy/typing/tests/data/fail/stride_tricks.pyi,sha256=IjA0Xrnx0lG3m07d1Hjbhtyo1Te5cXgjgr5fLUo4LYQ,315 +numpy/typing/tests/data/fail/testing.pyi,sha256=e7b5GKTWCtKGoB8z2a8edsW0Xjl1rMheALsvzEJjlCw,1370 +numpy/typing/tests/data/fail/twodim_base.pyi,sha256=ZqbRJfy5S_pW3fFLuomy4L5SBNqj6Nklexg9KDTo65c,899 +numpy/typing/tests/data/fail/type_check.pyi,sha256=CIyI0j0Buxv0QgCvNG2urjaKpoIZ-ZNawC2m6NzGlbo,379 +numpy/typing/tests/data/fail/ufunc_config.pyi,sha256=ukA0xwfJHLoGfoOIpWIN-91wj-DG8oaIjYbO72ymjg4,733 +numpy/typing/tests/data/fail/ufunclike.pyi,sha256=lbxjJyfARmt_QK1HxhxFxvwQTqCEZwJ9I53Wp8X3KIY,679 +numpy/typing/tests/data/fail/ufuncs.pyi,sha256=YaDTL7QLmGSUxE6JVMzpOlZTjHWrgbOo0UIlkX-6ZQk,1347 +numpy/typing/tests/data/fail/warnings_and_errors.pyi,sha256=PrbYDFI7IGN3Gf0OPBkVfefzQs4AXHwDQ495pvrX3RY,174 +numpy/typing/tests/data/misc/extended_precision.pyi,sha256=XJE_Qjaou-yzhww8K_3ypc4WTPudW0b3g0-T82aB8QE,347 +numpy/typing/tests/data/mypy.ini,sha256=a4--l5EymPReC-WKEsCfl2Nve_1T4XTFcoexa5q2MpY,166 +numpy/typing/tests/data/pass/__pycache__/arithmetic.cpython-38.pyc,, +numpy/typing/tests/data/pass/__pycache__/array_constructors.cpython-38.pyc,, +numpy/typing/tests/data/pass/__pycache__/array_like.cpython-38.pyc,, +numpy/typing/tests/data/pass/__pycache__/arrayprint.cpython-38.pyc,, +numpy/typing/tests/data/pass/__pycache__/arrayterator.cpython-38.pyc,, +numpy/typing/tests/data/pass/__pycache__/bitwise_ops.cpython-38.pyc,, +numpy/typing/tests/data/pass/__pycache__/comparisons.cpython-38.pyc,, +numpy/typing/tests/data/pass/__pycache__/dtype.cpython-38.pyc,, +numpy/typing/tests/data/pass/__pycache__/einsumfunc.cpython-38.pyc,, +numpy/typing/tests/data/pass/__pycache__/flatiter.cpython-38.pyc,, +numpy/typing/tests/data/pass/__pycache__/fromnumeric.cpython-38.pyc,, +numpy/typing/tests/data/pass/__pycache__/index_tricks.cpython-38.pyc,, +numpy/typing/tests/data/pass/__pycache__/lib_utils.cpython-38.pyc,, +numpy/typing/tests/data/pass/__pycache__/lib_version.cpython-38.pyc,, +numpy/typing/tests/data/pass/__pycache__/literal.cpython-38.pyc,, +numpy/typing/tests/data/pass/__pycache__/mod.cpython-38.pyc,, +numpy/typing/tests/data/pass/__pycache__/modules.cpython-38.pyc,, +numpy/typing/tests/data/pass/__pycache__/multiarray.cpython-38.pyc,, +numpy/typing/tests/data/pass/__pycache__/ndarray_conversion.cpython-38.pyc,, +numpy/typing/tests/data/pass/__pycache__/ndarray_misc.cpython-38.pyc,, +numpy/typing/tests/data/pass/__pycache__/ndarray_shape_manipulation.cpython-38.pyc,, +numpy/typing/tests/data/pass/__pycache__/numeric.cpython-38.pyc,, +numpy/typing/tests/data/pass/__pycache__/numerictypes.cpython-38.pyc,, +numpy/typing/tests/data/pass/__pycache__/random.cpython-38.pyc,, +numpy/typing/tests/data/pass/__pycache__/scalars.cpython-38.pyc,, +numpy/typing/tests/data/pass/__pycache__/simple.cpython-38.pyc,, +numpy/typing/tests/data/pass/__pycache__/simple_py3.cpython-38.pyc,, +numpy/typing/tests/data/pass/__pycache__/ufunc_config.cpython-38.pyc,, +numpy/typing/tests/data/pass/__pycache__/ufunclike.cpython-38.pyc,, +numpy/typing/tests/data/pass/__pycache__/ufuncs.cpython-38.pyc,, +numpy/typing/tests/data/pass/__pycache__/warnings_and_errors.cpython-38.pyc,, +numpy/typing/tests/data/pass/arithmetic.py,sha256=jNeZRSmFv8R01gN421L_qRXRBUxKwZ7VU_sJp9TQSIo,7398 +numpy/typing/tests/data/pass/array_constructors.py,sha256=3GrhfBcmWX53pJHD0NvhXjwr2-uNKREbR1I9WCcZ7rI,2419 +numpy/typing/tests/data/pass/array_like.py,sha256=ce_IVubBd7J6FkSpJmD7qMlRLuwmiidhOqhYfZb16Wo,916 +numpy/typing/tests/data/pass/arrayprint.py,sha256=y_KkuLz1uM7pv53qfq7GQOuud4LoXE3apK1wtARdVyM,766 +numpy/typing/tests/data/pass/arrayterator.py,sha256=FqcpKdUQBQ0FazHFxr9MsLEZG-jnJVGKWZX2owRr4DQ,393 +numpy/typing/tests/data/pass/bitwise_ops.py,sha256=UnmxVr9HwI8ifdrutGm_u3EZU4iOOPQhrOku7hTaH0c,970 +numpy/typing/tests/data/pass/comparisons.py,sha256=nTE-fvraLK6xTZcP4uPV02wOShzYKWDaoapx35AeDOY,2992 +numpy/typing/tests/data/pass/dtype.py,sha256=lI_5QlB7_20TyC1Urxr0No9MbrhpBHQxs-F_v7UyPmo,1073 +numpy/typing/tests/data/pass/einsumfunc.py,sha256=eXj5L5MWPtQHgrHPsJ36qqrmBHqct9UoujjJCvHnF1k,1370 +numpy/typing/tests/data/pass/flatiter.py,sha256=0BnbuLMBC7MQlprNZ0QhNSscfYwPhEhXOhWoyiRACWU,174 +numpy/typing/tests/data/pass/fromnumeric.py,sha256=Xd_nJVVDoONdztUX8ddgo7EXJ2FD8AX51MO_Yujnmog,3742 +numpy/typing/tests/data/pass/index_tricks.py,sha256=oaFD9vY01_RI5OkrXt-xTk1n_dd-SpuPp-eZ58XR3c8,1492 +numpy/typing/tests/data/pass/lib_utils.py,sha256=SEJRuh7J7JHHlOVctf-zQ9zRwVpCvZ_HvAXHvDrjxw0,420 +numpy/typing/tests/data/pass/lib_version.py,sha256=HnuGOx7tQA_bcxFIJ3dRoMAR0fockxg4lGqQ4g7LGIw,299 +numpy/typing/tests/data/pass/literal.py,sha256=DLzdWHD6ttW4S0NEvGQbsH_UEJjhZyhvO4OXJjoyvZQ,1331 +numpy/typing/tests/data/pass/mod.py,sha256=HB9aK4_wGJbc44tomaoroNy0foIL5cI9KIjknvMTbkk,1578 +numpy/typing/tests/data/pass/modules.py,sha256=f-6R2TbqrLX7F8A3Z9VgSyPAlOwvOy1zZyvUgivD250,595 +numpy/typing/tests/data/pass/multiarray.py,sha256=MxHax6l94yqlTVZleAqG77ILEbW6wU5osPcHzxJ85ns,1331 +numpy/typing/tests/data/pass/ndarray_conversion.py,sha256=yPgzXG6paY1uF_z-QyHYrcmrZvhX7qtvTUh7ANLseCA,1626 +numpy/typing/tests/data/pass/ndarray_misc.py,sha256=Rtb4uJ3oDGo8ke3H0qbKLLIPZ2_3xsNgxLsfHYWVo3k,2716 +numpy/typing/tests/data/pass/ndarray_shape_manipulation.py,sha256=37eYwMNqMLwanIW9-63hrokacnSz2K_qtPUlkdpsTjo,640 +numpy/typing/tests/data/pass/numeric.py,sha256=SdnsD5zv0wm8T2hnIylyS14ig2McSz6rG9YslckbNQ4,1490 +numpy/typing/tests/data/pass/numerictypes.py,sha256=JnP5m-QpK7YEfeeYzaDyIUUQ_q95hjSQMIgUIPTdSwU,973 +numpy/typing/tests/data/pass/random.py,sha256=6qLgsOcyeKls-M6hulhHtCLKnvfjdGeYkBq8xNMPLMg,61810 +numpy/typing/tests/data/pass/scalars.py,sha256=l2S3iqsY7zTx65u2eGyoygteobjpd0ysTNIlot5XyZY,3464 +numpy/typing/tests/data/pass/simple.py,sha256=Vf3nKTGD6kSqoaH2MWSDRny2-knWX-fQHoEJONC7q9s,2684 +numpy/typing/tests/data/pass/simple_py3.py,sha256=HuLrc5aphThQkLjU2_19KgGFaXwKOfSzXe0p2xMm8ZI,96 +numpy/typing/tests/data/pass/ufunc_config.py,sha256=b0nWLyq0V2H4mKZXrNM0kT-GM-x8ig9tv3al50_YAWM,1120 +numpy/typing/tests/data/pass/ufunclike.py,sha256=Gve6cJ2AT3TAwOjUOQQDIUnqsRCGYq70_tv_sgODiiA,1039 +numpy/typing/tests/data/pass/ufuncs.py,sha256=xGuKuqPetUTS4io5YDHaki5nbYRu-wC29SGU32tzVIg,462 +numpy/typing/tests/data/pass/warnings_and_errors.py,sha256=Pcg-QWfY4PAhTKyehae8q6LhtbUABxa2Ye63-3h1f4w,150 +numpy/typing/tests/data/reveal/arithmetic.pyi,sha256=kTKcuu9SHUdR_1LCp4lA7DdbY_Olhx8s17zyrGc3sNM,20805 +numpy/typing/tests/data/reveal/array_constructors.pyi,sha256=WloltIK2MdIGFwr3JC6g4KLi4nraOsR3AJ4XhCq8eOc,11574 +numpy/typing/tests/data/reveal/arraypad.pyi,sha256=9S-6k9KTi4TrKO-s-cW1jvoWry7mc-8G4VVIU7cqICY,694 +numpy/typing/tests/data/reveal/arrayprint.pyi,sha256=2C2mIauAAGfor2_YsCTXPGu5gZhln7acekNp5T4Ekxs,686 +numpy/typing/tests/data/reveal/arraysetops.pyi,sha256=cKxJCQKVLOAXRDi0XGc-pFvHqzYfJW3w3O5JwD3bfW0,4671 +numpy/typing/tests/data/reveal/arrayterator.pyi,sha256=OEt5c-fFsve0Qc4e2Jb9_HN1BKUrCJU-YSAf_GTvKe8,1128 +numpy/typing/tests/data/reveal/bitwise_ops.pyi,sha256=t7nz7G8SNpGw_8Hdmpwl68pBH1fGHS6JVQAa5e8dd2s,3607 +numpy/typing/tests/data/reveal/char.pyi,sha256=VjyPAgov14MyqEuGJO-4NovgqcU5nfuZ0opefDZmfzE,8047 +numpy/typing/tests/data/reveal/chararray.pyi,sha256=_7dslcz7tDdoicD8XAa6ql7Ye71LRWeH1bnNQ4bxxN4,6312 +numpy/typing/tests/data/reveal/comparisons.pyi,sha256=MJ4UdmIzzgW-vBs2Vj0RCyqurgIEtdjAqcoal3VuX-w,7746 +numpy/typing/tests/data/reveal/constants.pyi,sha256=RFPG2UQfP6aRLtDLmL72iz2tqfkLC0GX0uIPUQPLfi8,1940 +numpy/typing/tests/data/reveal/ctypeslib.pyi,sha256=tgvlw5te1vcaf5WeBXBC_ja7i1nH54FD_ViOyrhHMEs,5106 +numpy/typing/tests/data/reveal/datasource.pyi,sha256=melhwwltIDET_oudcv-skR8jKrGeVF5UOZVqfSKjXBw,557 +numpy/typing/tests/data/reveal/dtype.pyi,sha256=8YejndV1C4jgAzBvh-4JUn0gsjTwoeqVyaW9BniSuvw,2703 +numpy/typing/tests/data/reveal/einsumfunc.pyi,sha256=W_DsO6jL5uOIvuct7Juwv06efnPLrksIddqM1YC17_8,1887 +numpy/typing/tests/data/reveal/emath.pyi,sha256=iieDKvLNdM0DSJ-CiG9DNrnBc-p7LhV6DDDZxGFGDfQ,2538 +numpy/typing/tests/data/reveal/false_positives.pyi,sha256=oQx8mhWsl0V7Zg7d49ZmFGiUV9azVdGPbrXgk1Faj70,349 +numpy/typing/tests/data/reveal/fft.pyi,sha256=T5w3JYzXQhZdfYk7oGXr9fZf1T9kOqaHS2e0DSAOB4I,1852 +numpy/typing/tests/data/reveal/flatiter.pyi,sha256=jJ2TKMlZbh85AP3ey1Za1eyVEO2plh4dSUa5XjLccRw,851 +numpy/typing/tests/data/reveal/fromnumeric.pyi,sha256=qHv6SiH3llJjvrL8A3P3eg6b-wNnNribI60Gv9uPFSw,13631 +numpy/typing/tests/data/reveal/getlimits.pyi,sha256=XCjHClh1U8G-KawZAif3B4vD60e83YTEie1cR9oFRKw,1547 +numpy/typing/tests/data/reveal/histograms.pyi,sha256=9xBXQvL5n670oencXNwqNveDPH8dXHKK9djEvnQ0d7Q,1391 +numpy/typing/tests/data/reveal/index_tricks.pyi,sha256=oMkRrY65nIZTQ4WWRPdN7GFv9A0FA47MF_8ALYQbS14,3481 +numpy/typing/tests/data/reveal/lib_function_base.pyi,sha256=eYc65sc8sCQ7a-UOitDppSIqzThzMhR-tgTMM02DueY,9208 +numpy/typing/tests/data/reveal/lib_polynomial.pyi,sha256=r3WFzw-MOAyl2DeNIKrAPOTjBBjrTJHJYtE7chiAbyw,6353 +numpy/typing/tests/data/reveal/lib_utils.pyi,sha256=3FASdA5Z7XlefhOBamomqbx917hDl4LoBqFD10BC3x0,917 +numpy/typing/tests/data/reveal/lib_version.pyi,sha256=SEo2pRemac1XnmhNDOKEEM0oHf8E0BTJR4rqJekI3fI,605 +numpy/typing/tests/data/reveal/linalg.pyi,sha256=QPfMGXSOSoIT-kGPV0PysdJxVr7Qfklr9zM7R8hy_N8,6389 +numpy/typing/tests/data/reveal/matrix.pyi,sha256=QiJFt5JxiM_KTmzSs3k9jUcjNssdMGBjD1RrbP4nEdM,3033 +numpy/typing/tests/data/reveal/memmap.pyi,sha256=rNVyEHg5RU_g77H7UgDBpPHHmgRsWogqf09wXc0n7oI,755 +numpy/typing/tests/data/reveal/mod.pyi,sha256=a-d4dlG69pP_2YmQ-H63S7gfgAr_EzqzZlVLXrCAam8,5989 +numpy/typing/tests/data/reveal/modules.pyi,sha256=xarouCu6De5qF9dFqrGZafxZ85p7npV958o-uYIxG0E,1910 +numpy/typing/tests/data/reveal/multiarray.pyi,sha256=uSLZoWQSHHImm7nOmBtHy9Psmxy6qO3Xjt8ETvLNozs,5670 +numpy/typing/tests/data/reveal/nbit_base_example.pyi,sha256=dlpC5thGC-6iPNwjEckkequk2jeNjbfAFK0xyDNqmOQ,500 +numpy/typing/tests/data/reveal/ndarray_conversion.pyi,sha256=wzVZpYgNbyeHmMWZd_k0wwbiXRrOMy-_0YL-uVeiJCw,1913 +numpy/typing/tests/data/reveal/ndarray_misc.pyi,sha256=lcz1B-VfYy95vXUCNBYIuIk-eD4yAejVFdvUn2lhBbw,7753 +numpy/typing/tests/data/reveal/ndarray_shape_manipulation.pyi,sha256=Ywz-fsGOQBfzs62Z2hwLlStZJk1-XqU12EhF1XV-80M,904 +numpy/typing/tests/data/reveal/nditer.pyi,sha256=7bxrQBoMou8014t7biD44Gx53-w0yK7dipZuX-GHPVI,2067 +numpy/typing/tests/data/reveal/nested_sequence.pyi,sha256=k8Aac9HP6cunRWwkU7BKR25UrTHpEpPOX5zsyldRdiQ,648 +numpy/typing/tests/data/reveal/npyio.pyi,sha256=UJ1znmJlAW7_hH6ph0PyWKw6tzK6XQNqppPrO54r9uU,4464 +numpy/typing/tests/data/reveal/numeric.pyi,sha256=YJBFghgxK3BBueERO5V3o7VqrmklKUtrmGsXXQPH3RY,6802 +numpy/typing/tests/data/reveal/numerictypes.pyi,sha256=Hjj6lrqqtDWvBtYECcfm4_xoeJvY5MiTCaqprt8Gxx0,1786 +numpy/typing/tests/data/reveal/random.pyi,sha256=KBHaA8TAvOUUW68G2RdfMWa8W1MRRtHWbpDig7GvPnM,129388 +numpy/typing/tests/data/reveal/rec.pyi,sha256=SObXQ2Td2wWPmI_Ilu_4MU9OfZpv-F_FeQIS-kVCjVs,3380 +numpy/typing/tests/data/reveal/scalars.pyi,sha256=4uXG4aWbbE7J8_caSkdzlyz9WBEAzJAqNgFnmaZ0QwE,5694 +numpy/typing/tests/data/reveal/shape_base.pyi,sha256=4p8Pazg55LxX41edkDu8wwAUg6wwUfrPVjCvfL4tVo8,2632 +numpy/typing/tests/data/reveal/stride_tricks.pyi,sha256=hhWXM8W88kieGN-07k5vgJnc5T9jBtx0e9S6f3AkXus,1563 +numpy/typing/tests/data/reveal/testing.pyi,sha256=suu0v3cHRAoz9bZ9zcMJdIavomX1IDDI8OpQRlDQFsI,9020 +numpy/typing/tests/data/reveal/twodim_base.pyi,sha256=Nst-USEDdDOddfyBy1RrmxQWmDHRKPd32SVHIhPd9fk,3327 +numpy/typing/tests/data/reveal/type_check.pyi,sha256=bkUwGo1PRIOwlsQ5Lzb4CI-4vc_QaD-75wwW9dxfrGs,3031 +numpy/typing/tests/data/reveal/ufunc_config.pyi,sha256=178x2bi3cwqRvGtfMWVdgy1zngKWtYPKq3iRfNicbHo,1304 +numpy/typing/tests/data/reveal/ufunclike.pyi,sha256=49gm2MdQWkwURr3iiykm5xzLWSe1op1z8yIm0SC3Gik,1319 +numpy/typing/tests/data/reveal/ufuncs.pyi,sha256=iau_uG1ombTNB2nhpUgdGnY3Pxx6mUj667tRXfLOvEI,2919 +numpy/typing/tests/data/reveal/version.pyi,sha256=T2ECJgJDcQDd5f71eJmnm_QqmXWYtBnlT5xomJqxAmI,313 +numpy/typing/tests/data/reveal/warnings_and_errors.pyi,sha256=QJb7pCEw-B3pz9OcD6RyK135lYT4CQiyt70yxp708qQ,420 +numpy/typing/tests/test_generic_alias.py,sha256=99mEq24A5qL_82npa-OItH0t92I42iISdXexsNm4ZA4,6946 +numpy/typing/tests/test_isfile.py,sha256=xF6aWRj0ciBAPowsGx3fMUwRAryz8lxGDFiJPp-IGxc,812 +numpy/typing/tests/test_runtime.py,sha256=mTXwGVlgO5pflOgDdqfZYeCl6HIRtpWIzTyrdTHYgwM,2451 +numpy/typing/tests/test_typing.py,sha256=VqgCr14b1pN2EvC_LjyNnMNvwc3suIV0j6wAcFeZrPE,15312 +numpy/version.py,sha256=7WfmOFcKsQVxivXN6g0qZS_-D2PO9GisAfROkq5VlA8,475 diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/numpy-1.23.0.dist-info/REQUESTED b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/numpy-1.23.0.dist-info/REQUESTED new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/numpy-1.23.0.dist-info/WHEEL b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/numpy-1.23.0.dist-info/WHEEL new file mode 100644 index 0000000000000000000000000000000000000000..32bdea041ad9b5a3de7262ab9520dde8022f3b37 --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/numpy-1.23.0.dist-info/WHEEL @@ -0,0 +1,6 @@ +Wheel-Version: 1.0 +Generator: bdist_wheel (0.37.0) +Root-Is-Purelib: false +Tag: cp38-cp38-manylinux_2_17_x86_64 +Tag: cp38-cp38-manylinux2014_x86_64 + diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/numpy-1.23.0.dist-info/entry_points.txt b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/numpy-1.23.0.dist-info/entry_points.txt new file mode 100644 index 0000000000000000000000000000000000000000..7968c97f34f0a5eaa1d5bf6c647b193919ee3a49 --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/numpy-1.23.0.dist-info/entry_points.txt @@ -0,0 +1,11 @@ +[array_api] +numpy = numpy.array_api + +[console_scripts] +f2py = numpy.f2py.f2py2e:main +f2py3 = numpy.f2py.f2py2e:main +f2py3.8 = numpy.f2py.f2py2e:main + +[pyinstaller40] +hook-dirs = numpy:_pyinstaller_hooks_dir + diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/numpy-1.23.0.dist-info/top_level.txt b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/numpy-1.23.0.dist-info/top_level.txt new file mode 100644 index 0000000000000000000000000000000000000000..24ce15ab7ead32f98c7ac3edcd34bb2010ff4326 --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/numpy-1.23.0.dist-info/top_level.txt @@ -0,0 +1 @@ +numpy diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/skvideo/__init__.py b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/skvideo/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..db13a885fe81822456fda5a18e18f08480c66bf4 --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/skvideo/__init__.py @@ -0,0 +1,382 @@ +__version__ = "1.1.11" + +from .utils import check_output, where +import os +import warnings +import numpy as np + +# Run a program-based check to see if all install +# requirements have been met. +# Sets environment variables based on programs +# found. + +def which(command): + candidates = where(command) + if len(candidates) > 0: + return os.path.split(candidates[0])[0] + else: + return "" + + +# only ffprobe exists with ffmpeg +_FFMPEG_PATH = which("ffprobe") + +# only avprobe exists with libav +_AVCONV_PATH = which("avprobe") + +_MEDIAINFO_PATH = which("mediainfo") + +_HAS_FFMPEG = 0 +_HAS_AVCONV = 0 +_HAS_MEDIAINFO = 0 + +_LIBAV_MAJOR_VERSION = "0" +_LIBAV_MINOR_VERSION = "0" +_FFMPEG_MAJOR_VERSION = "0" +_FFMPEG_MINOR_VERSION = "0" +_FFMPEG_PATCH_VERSION = "0" + +_FFMPEG_SUPPORTED_DECODERS = [] +_FFMPEG_SUPPORTED_ENCODERS = [] +_LIBAV_SUPPORTED_EXT = [] + +_FFPROBE_APPLICATION = "ffprobe" +_FFMPEG_APPLICATION = "ffmpeg" +_AVPROBE_APPLICATION = "avprobe" +_AVCONV_APPLICATION = "avconv" +_MEDIAINFO_APPLICATION = "mediainfo" + +# Windows compat +if os.name == "nt": + _FFPROBE_APPLICATION += ".exe" + _FFMPEG_APPLICATION += ".exe" + _AVPROBE_APPLICATION += ".exe" + _AVCONV_APPLICATION += ".exe" + _MEDIAINFO_APPLICATION += ".exe" + +def scan_ffmpeg(): + global _FFMPEG_MAJOR_VERSION + global _FFMPEG_MINOR_VERSION + global _FFMPEG_PATCH_VERSION + global _FFMPEG_SUPPORTED_DECODERS + global _FFMPEG_SUPPORTED_ENCODERS + _FFMPEG_MAJOR_VERSION = "0" + _FFMPEG_MINOR_VERSION = "0" + _FFMPEG_PATCH_VERSION = "0" + _FFMPEG_SUPPORTED_DECODERS = [] + _FFMPEG_SUPPORTED_ENCODERS = [] + try: + # grab program version string + version = check_output([os.path.join(_FFMPEG_PATH, _FFMPEG_APPLICATION), "-version"]) + # only parse the first line returned + firstline = version.split(b'\n')[0] + + # the 3rd element in this line is the version number + version = firstline.split(b' ')[2].strip() + versionparts = version.split(b'.') + if version[0] == b'N': + # this is the 'git' version of FFmpeg + _FFMPEG_MAJOR_VERSION = version + else: + _FFMPEG_MAJOR_VERSION = versionparts[0] + _FFMPEG_MINOR_VERSION = versionparts[1] + if len(versionparts) > 2: + _FFMPEG_PATCH_VERSION = versionparts[2] + except: + pass + + # decoders = [] + # encoders = [] + + # try: + # extension_lst = check_output([_FFMPEG_PATH + "/ffmpeg", "-formats"]) + # extension_lst = extension_lst.split(b'\n') + # # skip first line + # for item in extension_lst[4:]: + # parts = [x.strip() for x in item.split(b' ') if x] + # if len(parts) < 2: + # continue + # rule = parts[0] + # extension = parts[1] + # if b'D' in rule: + # for item in extension.split(b","): + # decoders.append(item) + # if b'E' in rule: + # for item in extension.split(b","): + # encoders.append(item) + # except: + # pass + + # try: + # for enc in encoders: + # extension_lst = check_output([_FFMPEG_PATH + "/ffmpeg", "-v", "1", "-h", "muxer="+str(enc)]) + # csvstring = "" + # for line in extension_lst.split('\n'): + # if "Common extensions:" in line: + # csvstring = line.replace("Common extensions:", "").replace(".", "").strip() + # break + # if csvstring == "": + # continue + # csvlist = csvstring.split(',') + # for listitem in csvlist: + # _FFMPEG_SUPPORTED_ENCODERS.append(b"." + listitem) + # for enc in encoders: + # extension_lst = check_output([_FFMPEG_PATH + "/ffmpeg", "-v", "1", "-h", "demuxer="+str(enc)]) + # csvstring = "" + # for line in extension_lst.split('\n'): + # if "Common extensions:" in line: + # csvstring = line.replace("Common extensions:", "").replace(".", "").strip() + # break + # if csvstring == "": + # continue + # csvlist = csvstring.split(',') + # for listitem in csvlist: + # _FFMPEG_SUPPORTED_ENCODERS.append(b"." + listitem) + + # _FFMPEG_SUPPORTED_ENCODERS = np.unique(_FFMPEG_SUPPORTED_ENCODERS) + # except: + # pass + + # try: + # for dec in decoders: + # extension_lst = check_output([_FFMPEG_PATH + "/ffmpeg", "-v", "1", "-h", "muxer="+str(dec)]) + # csvstring = "" + # for line in extension_lst.split('\n'): + # if "Common extensions:" in line: + # csvstring = line.replace("Common extensions:", "").replace(".", "").strip() + # break + # if csvstring == "": + # continue + # csvlist = csvstring.split(',') + # for listitem in csvlist: + # _FFMPEG_SUPPORTED_DECODERS.append(b"." + listitem) + # for dec in decoders: + # extension_lst = check_output([_FFMPEG_PATH + "/ffmpeg", "-v", "1", "-h", "demuxer="+str(dec)]) + # csvstring = "" + # for line in extension_lst.split('\n'): + # if "Common extensions:" in line: + # csvstring = line.replace("Common extensions:", "").replace(".", "").strip() + # break + # if csvstring == "": + # continue + # csvlist = csvstring.split(',') + # for listitem in csvlist: + # _FFMPEG_SUPPORTED_DECODERS.append(b"." + listitem) + + # _FFMPEG_SUPPORTED_DECODERS = np.unique(_FFMPEG_SUPPORTED_DECODERS) + # except: + # pass + + # by running the above code block, the bottom arrays are populated + # output staticly provided for speed concerns + _FFMPEG_SUPPORTED_DECODERS = [ + b'.264', b'.265', b'.302', b'.3g2', b'.3gp', b'.722', b'.aa', b'.aa3', b'.aac', b'.ac3', + b'.acm', b'.adf', b'.adp', b'.ads', b'.adx', b'.aea', b'.afc', b'.aif', b'.aifc', b'.aiff', + b'.al', b'.amr', b'.ans', b'.ape', b'.apl', b'.apng', b'.aqt', b'.art', b'.asc', b'.asf', + b'.ass', b'.ast', b'.au', b'.avc', b'.avi', b'.avr', b'.bcstm', b'.bfstm', b'.bin', b'.bit', + b'.bmp', b'.bmv', b'.brstm', b'.caf', b'.cavs', b'.cdata', b'.cdg', b'.cdxl', b'.cgi', + b'.cif', b'.daud', b'.dif', b'.diz', b'.dnxhd', b'.dpx', b'.drc', b'.dss', b'.dtk', b'.dts', + b'.dtshd', b'.dv', b'.eac3', b'.fap', b'.ffm', b'.ffmeta', b'.flac', b'.flm', b'.flv', + b'.fsb', b'.g722', b'.g723_1', b'.g729', b'.genh', b'.gif', b'.gsm', b'.gxf', b'.h261', + b'.h263', b'.h264', b'.h265', b'.h26l', b'.hevc', b'.ice', b'.ico', b'.idf', b'.idx', b'.im1', + b'.im24', b'.im8', b'.ircam', b'.ivf', b'.ivr', b'.j2c', b'.j2k', b'.jls', b'.jp2', b'.jpeg', + b'.jpg', b'.js', b'.jss', b'.lbc', b'.ljpg', b'.lrc', b'.lvf', b'.m2a', b'.m2t', b'.m2ts', + b'.m3u8', b'.m4a', b'.m4v', b'.mac', b'.mj2', b'.mjpeg', b'.mjpg', b'.mk3d', b'.mka', b'.mks', + b'.mkv', b'.mlp', b'.mmf', b'.mov', b'.mp2', b'.mp3', b'.mp4', b'.mpa', b'.mpc', b'.mpeg', + b'.mpg', b'.mpl2', b'.mpo', b'.msf', b'.mts', b'.mvi', b'.mxf', b'.mxg', b'.nfo', b'.nist', + b'.nut', b'.ogg', b'.ogv', b'.oma', b'.omg', b'.paf', b'.pam', b'.pbm', b'.pcx', b'.pgm', + b'.pgmyuv', b'.pix', b'.pjs', b'.png', b'.ppm', b'.pvf', b'.qcif', b'.ra', b'.ras', b'.rco', + b'.rcv', b'.rgb', b'.rm', b'.roq', b'.rs', b'.rsd', b'.rso', b'.rt', b'.sami', b'.sb', b'.sbg', + b'.sdr2', b'.sf', b'.sgi', b'.shn', b'.sln', b'.smi', b'.son', b'.sox', b'.spdif', b'.sph', + b'.srt', b'.ss2', b'.ssa', b'.stl', b'.str', b'.sub', b'.sun', b'.sunras', b'.sup', b'.svag', + b'.sw', b'.swf', b'.tak', b'.tco', b'.tga', b'.thd', b'.tif', b'.tiff', b'.ts', b'.tta', + b'.txt', b'.ub', b'.ul', b'.uw', b'.v', b'.v210', b'.vag', b'.vb', b'.vc1', b'.viv', b'.voc', + b'.vpk', b'.vqe', b'.vqf', b'.vql', b'.vt', b'.vtt', b'.w64', b'.wav', b'.webm', b'.wma', + b'.wmv', b'.wtv', b'.wv', b'.xbm', b'.xface', b'.xl', b'.xml', b'.xvag', b'.xwd', b'.y', + b'.y4m', b'.yop', b'.yuv', b'.yuv10', + + # extra extensions that are known container formats + b'.raw', + b'.iso' + ] + + _FFMPEG_SUPPORTED_ENCODERS = [ + b'., A64', b'.264', b'.265', b'.302', b'.3g2', b'.3gp', b'.722', b'.a64', b'.aa3', b'.aac', + b'.ac3', b'.adts', b'.adx', b'.afc', b'.aif', b'.aifc', b'.aiff', b'.al', b'.amr', b'.apng', + b'.asf', b'.ass', b'.ast', b'.au', b'.avc', b'.avi', b'.bit', b'.bmp', b'.caf', b'.cavs', + b'.chk', b'.cif', b'.daud', b'.dif', b'.dnxhd', b'.dpx', b'.drc', b'.dts', b'.dv', b'.dvd', + b'.eac3', b'.f4v', b'.ffm', b'.ffmeta', b'.flac', b'.flm', b'.flv', b'.g722', b'.g723_1', + b'.gif', b'.gxf', b'.h261', b'.h263', b'.h264', b'.h265', b'.h26l', b'.hevc', b'.ico', + b'.im1', b'.im24', b'.im8', b'.ircam', b'.isma', b'.ismv', b'.ivf', b'.j2c', b'.j2k', b'.jls', + b'.jp2', b'.jpeg', b'.jpg', b'.js', b'.jss', b'.latm', b'.lbc', b'.ljpg', b'.loas', b'.lrc', + b'.m1v', b'.m2a', b'.m2t', b'.m2ts', b'.m2v', b'.m3u8', b'.m4a', b'.m4v', b'.mj2', b'.mjpeg', + b'.mjpg', b'.mk3d', b'.mka', b'.mks', b'.mkv', b'.mlp', b'.mmf', b'.mov', b'.mp2', b'.mp3', + b'.mp4', b'.mpa', b'.mpeg', b'.mpg', b'.mpo', b'.mts', b'.mxf', b'.nut', b'.oga', b'.ogg', + b'.ogv', b'.oma', b'.omg', b'.opus', b'.pam', b'.pbm', b'.pcx', b'.pgm', b'.pgmyuv', b'.pix', + b'.png', b'.ppm', b'.psp', b'.qcif', b'.ra', b'.ras', b'.rco', b'.rcv', b'.rgb', b'.rm', + b'.roq', b'.rs', b'.rso', b'.sb', b'.sf', b'.sgi', b'.sox', b'.spdif', b'.spx', b'.srt', + b'.ssa', b'.sub', b'.sun', b'.sunras', b'.sw', b'.swf', b'.tco', b'.tga', b'.thd', b'.tif', + b'.tiff', b'.ts', b'.ub', b'.ul', b'.uw', b'.vc1', b'.vob', b'.voc', b'.vtt', b'.w64', b'.wav', + b'.webm', b'.webp', b'.wma', b'.wmv', b'.wtv', b'.wv', b'.xbm', b'.xface', b'.xml', b'.xwd', + b'.y', b'.y4m', b'.yuv', + + # extra extensions that are known container formats + b'.raw' + ] + + +def scan_libav(): + global _LIBAV_MAJOR_VERSION + global _LIBAV_MINOR_VERSION + _LIBAV_MAJOR_VERSION = "0" + _LIBAV_MINOR_VERSION = "0" + try: + # grab program version string + version = check_output([os.path.join(_AVCONV_PATH, _AVCONV_APPLICATION), "-version"]) + # only parse the first line returned + firstline = version.split(b'\n')[0] + + firstlineparts = firstline.split(b' ') + + # in older versions, the second word is "version", + # else the version number starts with "v" + version = "" + if firstlineparts[1].strip() == b"version": + version = firstlineparts[2].split('.')[0] + else: + version = firstlineparts[1].split(b'-')[0] + + # check for underscore + version = version.split(b'_')[0] + versionparts = version.split(b'.') + if versionparts[0].decode()[0] == 'v': + _LIBAV_MAJOR_VERSION = versionparts[0].decode()[1:] + else: + _LIBAV_MAJOR_VERSION = str(versionparts[0].decode()) + _LIBAV_MINOR_VERSION = str(versionparts[1].decode()) + except: + pass + + + +if _MEDIAINFO_PATH is not None: + _HAS_MEDIAINFO = 1 + + +# allow library configuration checking +def getFFmpegPath(): + """ Returns the path to the directory containing both ffmpeg and ffprobe + """ + return _FFMPEG_PATH + + +def getFFmpegVersion(): + """ Returns the version of FFmpeg that is currently being used + """ + if _FFMPEG_MAJOR_VERSION[0] == 'N': + return "%s" % (_FFMPEG_MAJOR_VERSION, ) + else: + return "%s.%s.%s" % (_FFMPEG_MAJOR_VERSION, _FFMPEG_MINOR_VERSION, _FFMPEG_PATCH_VERSION) + + +def setFFmpegPath(path): + """ Sets up the path to the directory containing both ffmpeg and ffprobe + + Use this function for to specify specific system installs of FFmpeg. All + calls to ffmpeg and ffprobe will use this path as a prefix. + + Parameters + ---------- + path : string + Path to directory containing ffmpeg and ffprobe + + Returns + ------- + none + + """ + global _FFMPEG_PATH + global _HAS_FFMPEG + _FFMPEG_PATH = path + + # check to see if the executables actually exist on these paths + if os.path.isfile(os.path.join(_FFMPEG_PATH, _FFMPEG_APPLICATION)) and os.path.isfile(os.path.join(_FFMPEG_PATH, _FFPROBE_APPLICATION)): + _HAS_FFMPEG = 1 + else: + warnings.warn("ffmpeg/ffprobe not found in path: " + str(path), UserWarning) + _HAS_FFMPEG = 0 + global _FFMPEG_MAJOR_VERSION + global _FFMPEG_MINOR_VERSION + global _FFMPEG_PATCH_VERSION + _FFMPEG_MAJOR_VERSION = "0" + _FFMPEG_MINOR_VERSION = "0" + _FFMPEG_PATCH_VERSION = "0" + return + + # reload version from new path + scan_ffmpeg() + + +def getLibAVPath(): + """ Returns the path to the directory containing both avconv and avprobe + """ + return _AVCONV_PATH + + +def getLibAVVersion(): + """ Returns the version of LibAV that is currently being used + """ + return "%s.%s" % (_LIBAV_MAJOR_VERSION, _LIBAV_MINOR_VERSION) + + +def setLibAVPath(path): + """ Sets up the path to the directory containing both avconv and avprobe + + Use this function for to specify specific system installs of LibAV. All + calls to avconv and avprobe will use this path as a prefix. + + Parameters + ---------- + path : string + Path to directory containing avconv and avprobe + + Returns + ------- + none + + """ + global _AVCONV_PATH + global _HAS_AVCONV + _AVCONV_PATH = path + + # check to see if the executables actually exist on these paths + if os.path.isfile(os.path.join(_AVCONV_PATH, _AVCONV_APPLICATION)) and os.path.isfile(os.path.join(_AVCONV_PATH, _AVPROBE_APPLICATION)): + _HAS_AVCONV = 1 + else: + warnings.warn("avconv/avprobe not found in path: " + str(path), UserWarning) + _HAS_AVCONV = 0 + global _LIBAV_MAJOR_VERSION + global _LIBAV_MINOR_VERSION + _LIBAV_MAJOR_VERSION = "0" + _LIBAV_MINOR_VERSION = "0" + return + + # reload version from new path + scan_libav() + +if (len(_FFMPEG_PATH) > 0): + setFFmpegPath(_FFMPEG_PATH) + + +if (len(_AVCONV_PATH) > 0): + setLibAVPath(_AVCONV_PATH) + + +__all__ = [ + getFFmpegPath, + getFFmpegVersion, + setFFmpegPath, + getLibAVPath, + getLibAVVersion, + setLibAVPath, +] diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/skvideo/setup.py b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/skvideo/setup.py new file mode 100644 index 0000000000000000000000000000000000000000..263918d864034ac7cd15ad6af5b185d2fec4ddcc --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/skvideo/setup.py @@ -0,0 +1,12 @@ +def configuration(parent_package='',top_path=None): + from numpy.distutils.misc_util import Configuration + config = Configuration('skvideo', parent_package, top_path) + + config.add_subpackage('io') + config.add_subpackage('datasets') + config.add_subpackage('tests') + config.add_subpackage('motion') + config.add_subpackage('utils') + config.add_subpackage('measure') + + return config diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/smmap/__init__.py b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/smmap/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..696401c8c6158c9fcf9041ba0115c62a06c82d20 --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/smmap/__init__.py @@ -0,0 +1,11 @@ +"""Intialize the smmap package""" + +__author__ = "Sebastian Thiel" +__contact__ = "byronimo@gmail.com" +__homepage__ = "https://github.com/gitpython-developers/smmap" +version_info = (5, 0, 0) +__version__ = '.'.join(str(i) for i in version_info) + +# make everything available in root package for convenience +from .mman import * +from .buf import * diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/smmap/buf.py b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/smmap/buf.py new file mode 100644 index 0000000000000000000000000000000000000000..795e0fd872cde8502c6fb07031424fe3d717b90e --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/smmap/buf.py @@ -0,0 +1,143 @@ +"""Module with a simple buffer implementation using the memory manager""" +import sys + +__all__ = ["SlidingWindowMapBuffer"] + + +class SlidingWindowMapBuffer: + + """A buffer like object which allows direct byte-wise object and slicing into + memory of a mapped file. The mapping is controlled by the provided cursor. + + The buffer is relative, that is if you map an offset, index 0 will map to the + first byte at the offset you used during initialization or begin_access + + **Note:** Although this type effectively hides the fact that there are mapped windows + underneath, it can unfortunately not be used in any non-pure python method which + needs a buffer or string""" + __slots__ = ( + '_c', # our cursor + '_size', # our supposed size + ) + + def __init__(self, cursor=None, offset=0, size=sys.maxsize, flags=0): + """Initalize the instance to operate on the given cursor. + :param cursor: if not None, the associated cursor to the file you want to access + If None, you have call begin_access before using the buffer and provide a cursor + :param offset: absolute offset in bytes + :param size: the total size of the mapping. Defaults to the maximum possible size + From that point on, the __len__ of the buffer will be the given size or the file size. + If the size is larger than the mappable area, you can only access the actually available + area, although the length of the buffer is reported to be your given size. + Hence it is in your own interest to provide a proper size ! + :param flags: Additional flags to be passed to os.open + :raise ValueError: if the buffer could not achieve a valid state""" + self._c = cursor + if cursor and not self.begin_access(cursor, offset, size, flags): + raise ValueError("Failed to allocate the buffer - probably the given offset is out of bounds") + # END handle offset + + def __del__(self): + self.end_access() + + def __enter__(self): + return self + + def __exit__(self, exc_type, exc_value, traceback): + self.end_access() + + def __len__(self): + return self._size + + def __getitem__(self, i): + if isinstance(i, slice): + return self.__getslice__(i.start or 0, i.stop or self._size) + c = self._c + assert c.is_valid() + if i < 0: + i = self._size + i + if not c.includes_ofs(i): + c.use_region(i, 1) + # END handle region usage + return c.buffer()[i - c.ofs_begin()] + + def __getslice__(self, i, j): + c = self._c + # fast path, slice fully included - safes a concatenate operation and + # should be the default + assert c.is_valid() + if i < 0: + i = self._size + i + if j == sys.maxsize: + j = self._size + if j < 0: + j = self._size + j + if (c.ofs_begin() <= i) and (j < c.ofs_end()): + b = c.ofs_begin() + return c.buffer()[i - b:j - b] + else: + l = j - i # total length + ofs = i + # It's fastest to keep tokens and join later, especially in py3, which was 7 times slower + # in the previous iteration of this code + md = list() + while l: + c.use_region(ofs, l) + assert c.is_valid() + d = c.buffer()[:l] + ofs += len(d) + l -= len(d) + # Make sure we don't keep references, as c.use_region() might attempt to free resources, but + # can't unless we use pure bytes + if hasattr(d, 'tobytes'): + d = d.tobytes() + md.append(d) + # END while there are bytes to read + return bytes().join(md) + # END fast or slow path + #{ Interface + + def begin_access(self, cursor=None, offset=0, size=sys.maxsize, flags=0): + """Call this before the first use of this instance. The method was already + called by the constructor in case sufficient information was provided. + + For more information no the parameters, see the __init__ method + :param path: if cursor is None the existing one will be used. + :return: True if the buffer can be used""" + if cursor: + self._c = cursor + # END update our cursor + + # reuse existing cursors if possible + if self._c is not None and self._c.is_associated(): + res = self._c.use_region(offset, size, flags).is_valid() + if res: + # if given size is too large or default, we computer a proper size + # If its smaller, we assume the combination between offset and size + # as chosen by the user is correct and use it ! + # If not, the user is in trouble. + if size > self._c.file_size(): + size = self._c.file_size() - offset + # END handle size + self._size = size + # END set size + return res + # END use our cursor + return False + + def end_access(self): + """Call this method once you are done using the instance. It is automatically + called on destruction, and should be called just in time to allow system + resources to be freed. + + Once you called end_access, you must call begin access before reusing this instance!""" + self._size = 0 + if self._c is not None: + self._c.unuse_region() + # END unuse region + + def cursor(self): + """:return: the currently set cursor which provides access to the data""" + return self._c + + #}END interface diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/smmap/mman.py b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/smmap/mman.py new file mode 100644 index 0000000000000000000000000000000000000000..1de7d9e97de182bf08b787ac5b6ed70f7588461a --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/smmap/mman.py @@ -0,0 +1,588 @@ +"""Module containing a memory memory manager which provides a sliding window on a number of memory mapped files""" +from .util import ( + MapWindow, + MapRegion, + MapRegionList, + is_64_bit, +) + +import sys +from functools import reduce + +__all__ = ["StaticWindowMapManager", "SlidingWindowMapManager", "WindowCursor"] +#{ Utilities + +#}END utilities + + +class WindowCursor: + + """ + Pointer into the mapped region of the memory manager, keeping the map + alive until it is destroyed and no other client uses it. + + Cursors should not be created manually, but are instead returned by the SlidingWindowMapManager + + **Note:**: The current implementation is suited for static and sliding window managers, but it also means + that it must be suited for the somewhat quite different sliding manager. It could be improved, but + I see no real need to do so.""" + __slots__ = ( + '_manager', # the manger keeping all file regions + '_rlist', # a regions list with regions for our file + '_region', # our current class:`MapRegion` or None + '_ofs', # relative offset from the actually mapped area to our start area + '_size' # maximum size we should provide + ) + + def __init__(self, manager=None, regions=None): + self._manager = manager + self._rlist = regions + self._region = None + self._ofs = 0 + self._size = 0 + + def __del__(self): + self._destroy() + + def __enter__(self): + return self + + def __exit__(self, exc_type, exc_value, traceback): + self._destroy() + + def _destroy(self): + """Destruction code to decrement counters""" + self.unuse_region() + + if self._rlist is not None: + # Actual client count, which doesn't include the reference kept by the manager, nor ours + # as we are about to be deleted + try: + if len(self._rlist) == 0: + # Free all resources associated with the mapped file + self._manager._fdict.pop(self._rlist.path_or_fd()) + # END remove regions list from manager + except (TypeError, KeyError): + # sometimes, during shutdown, getrefcount is None. Its possible + # to re-import it, however, its probably better to just ignore + # this python problem (for now). + # The next step is to get rid of the error prone getrefcount alltogether. + pass + # END exception handling + # END handle regions + + def _copy_from(self, rhs): + """Copy all data from rhs into this instance, handles usage count""" + self._manager = rhs._manager + self._rlist = type(rhs._rlist)(rhs._rlist) + self._region = rhs._region + self._ofs = rhs._ofs + self._size = rhs._size + + for region in self._rlist: + region.increment_client_count() + + if self._region is not None: + self._region.increment_client_count() + # END handle regions + + def __copy__(self): + """copy module interface""" + cpy = type(self)() + cpy._copy_from(self) + return cpy + + #{ Interface + def assign(self, rhs): + """Assign rhs to this instance. This is required in order to get a real copy. + Alternativly, you can copy an existing instance using the copy module""" + self._destroy() + self._copy_from(rhs) + + def use_region(self, offset=0, size=0, flags=0): + """Assure we point to a window which allows access to the given offset into the file + + :param offset: absolute offset in bytes into the file + :param size: amount of bytes to map. If 0, all available bytes will be mapped + :param flags: additional flags to be given to os.open in case a file handle is initially opened + for mapping. Has no effect if a region can actually be reused. + :return: this instance - it should be queried for whether it points to a valid memory region. + This is not the case if the mapping failed because we reached the end of the file + + **Note:**: The size actually mapped may be smaller than the given size. If that is the case, + either the file has reached its end, or the map was created between two existing regions""" + need_region = True + man = self._manager + fsize = self._rlist.file_size() + size = min(size or fsize, man.window_size() or fsize) # clamp size to window size + + if self._region is not None: + if self._region.includes_ofs(offset): + need_region = False + else: + self.unuse_region() + # END handle existing region + # END check existing region + + # offset too large ? + if offset >= fsize: + return self + # END handle offset + + if need_region: + self._region = man._obtain_region(self._rlist, offset, size, flags, False) + self._region.increment_client_count() + # END need region handling + + self._ofs = offset - self._region._b + self._size = min(size, self._region.ofs_end() - offset) + + return self + + def unuse_region(self): + """Unuse the current region. Does nothing if we have no current region + + **Note:** the cursor unuses the region automatically upon destruction. It is recommended + to un-use the region once you are done reading from it in persistent cursors as it + helps to free up resource more quickly""" + if self._region is not None: + self._region.increment_client_count(-1) + self._region = None + # note: should reset ofs and size, but we spare that for performance. Its not + # allowed to query information if we are not valid ! + + def buffer(self): + """Return a buffer object which allows access to our memory region from our offset + to the window size. Please note that it might be smaller than you requested when calling use_region() + + **Note:** You can only obtain a buffer if this instance is_valid() ! + + **Note:** buffers should not be cached passed the duration of your access as it will + prevent resources from being freed even though they might not be accounted for anymore !""" + return memoryview(self._region.buffer())[self._ofs:self._ofs+self._size] + + def map(self): + """ + :return: the underlying raw memory map. Please not that the offset and size is likely to be different + to what you set as offset and size. Use it only if you are sure about the region it maps, which is the whole + file in case of StaticWindowMapManager""" + return self._region.map() + + def is_valid(self): + """:return: True if we have a valid and usable region""" + return self._region is not None + + def is_associated(self): + """:return: True if we are associated with a specific file already""" + return self._rlist is not None + + def ofs_begin(self): + """:return: offset to the first byte pointed to by our cursor + + **Note:** only if is_valid() is True""" + return self._region._b + self._ofs + + def ofs_end(self): + """:return: offset to one past the last available byte""" + # unroll method calls for performance ! + return self._region._b + self._ofs + self._size + + def size(self): + """:return: amount of bytes we point to""" + return self._size + + def region(self): + """:return: our mapped region, or None if nothing is mapped yet + :raise AssertionError: if we have no current region. This is only useful for debugging""" + return self._region + + def includes_ofs(self, ofs): + """:return: True if the given absolute offset is contained in the cursors + current region + + **Note:** cursor must be valid for this to work""" + # unroll methods + return (self._region._b + self._ofs) <= ofs < (self._region._b + self._ofs + self._size) + + def file_size(self): + """:return: size of the underlying file""" + return self._rlist.file_size() + + def path_or_fd(self): + """:return: path or file descriptor of the underlying mapped file""" + return self._rlist.path_or_fd() + + def path(self): + """:return: path of the underlying mapped file + :raise ValueError: if attached path is not a path""" + if isinstance(self._rlist.path_or_fd(), int): + raise ValueError("Path queried although mapping was applied to a file descriptor") + # END handle type + return self._rlist.path_or_fd() + + def fd(self): + """:return: file descriptor used to create the underlying mapping. + + **Note:** it is not required to be valid anymore + :raise ValueError: if the mapping was not created by a file descriptor""" + if isinstance(self._rlist.path_or_fd(), str): + raise ValueError("File descriptor queried although mapping was generated from path") + # END handle type + return self._rlist.path_or_fd() + + #} END interface + + +class StaticWindowMapManager: + + """Provides a manager which will produce single size cursors that are allowed + to always map the whole file. + + Clients must be written to specifically know that they are accessing their data + through a StaticWindowMapManager, as they otherwise have to deal with their window size. + + These clients would have to use a SlidingWindowMapBuffer to hide this fact. + + This type will always use a maximum window size, and optimize certain methods to + accommodate this fact""" + + __slots__ = [ + '_fdict', # mapping of path -> StorageHelper (of some kind + '_window_size', # maximum size of a window + '_max_memory_size', # maximum amount of memory we may allocate + '_max_handle_count', # maximum amount of handles to keep open + '_memory_size', # currently allocated memory size + '_handle_count', # amount of currently allocated file handles + ] + + #{ Configuration + MapRegionListCls = MapRegionList + MapWindowCls = MapWindow + MapRegionCls = MapRegion + WindowCursorCls = WindowCursor + #} END configuration + + _MB_in_bytes = 1024 * 1024 + + def __init__(self, window_size=0, max_memory_size=0, max_open_handles=sys.maxsize): + """initialize the manager with the given parameters. + :param window_size: if -1, a default window size will be chosen depending on + the operating system's architecture. It will internally be quantified to a multiple of the page size + If 0, the window may have any size, which basically results in mapping the whole file at one + :param max_memory_size: maximum amount of memory we may map at once before releasing mapped regions. + If 0, a viable default will be set depending on the system's architecture. + It is a soft limit that is tried to be kept, but nothing bad happens if we have to over-allocate + :param max_open_handles: if not maxint, limit the amount of open file handles to the given number. + Otherwise the amount is only limited by the system itself. If a system or soft limit is hit, + the manager will free as many handles as possible""" + self._fdict = dict() + self._window_size = window_size + self._max_memory_size = max_memory_size + self._max_handle_count = max_open_handles + self._memory_size = 0 + self._handle_count = 0 + + if window_size < 0: + coeff = 64 + if is_64_bit(): + coeff = 1024 + # END handle arch + self._window_size = coeff * self._MB_in_bytes + # END handle max window size + + if max_memory_size == 0: + coeff = 1024 + if is_64_bit(): + coeff = 8192 + # END handle arch + self._max_memory_size = coeff * self._MB_in_bytes + # END handle max memory size + + #{ Internal Methods + + def _collect_lru_region(self, size): + """Unmap the region which was least-recently used and has no client + :param size: size of the region we want to map next (assuming its not already mapped partially or full + if 0, we try to free any available region + :return: Amount of freed regions + + .. Note:: + We don't raise exceptions anymore, in order to keep the system working, allowing temporary overallocation. + If the system runs out of memory, it will tell. + + .. TODO:: + implement a case where all unusued regions are discarded efficiently. + Currently its only brute force + """ + num_found = 0 + while (size == 0) or (self._memory_size + size > self._max_memory_size): + lru_region = None + lru_list = None + for regions in self._fdict.values(): + for region in regions: + # check client count - if it's 1, it's just us + if (region.client_count() == 1 and + (lru_region is None or region._uc < lru_region._uc)): + lru_region = region + lru_list = regions + # END update lru_region + # END for each region + # END for each regions list + + if lru_region is None: + break + # END handle region not found + + num_found += 1 + del(lru_list[lru_list.index(lru_region)]) + lru_region.increment_client_count(-1) + self._memory_size -= lru_region.size() + self._handle_count -= 1 + # END while there is more memory to free + return num_found + + def _obtain_region(self, a, offset, size, flags, is_recursive): + """Utilty to create a new region - for more information on the parameters, + see MapCursor.use_region. + :param a: A regions (a)rray + :return: The newly created region""" + if self._memory_size + size > self._max_memory_size: + self._collect_lru_region(size) + # END handle collection + + r = None + if a: + assert len(a) == 1 + r = a[0] + else: + try: + r = self.MapRegionCls(a.path_or_fd(), 0, sys.maxsize, flags) + except Exception: + # apparently we are out of system resources or hit a limit + # As many more operations are likely to fail in that condition ( + # like reading a file from disk, etc) we free up as much as possible + # As this invalidates our insert position, we have to recurse here + if is_recursive: + # we already tried this, and still have no success in obtaining + # a mapping. This is an exception, so we propagate it + raise + # END handle existing recursion + self._collect_lru_region(0) + return self._obtain_region(a, offset, size, flags, True) + # END handle exceptions + + self._handle_count += 1 + self._memory_size += r.size() + a.append(r) + # END handle array + + assert r.includes_ofs(offset) + return r + + #}END internal methods + + #{ Interface + def make_cursor(self, path_or_fd): + """ + :return: a cursor pointing to the given path or file descriptor. + It can be used to map new regions of the file into memory + + **Note:** if a file descriptor is given, it is assumed to be open and valid, + but may be closed afterwards. To refer to the same file, you may reuse + your existing file descriptor, but keep in mind that new windows can only + be mapped as long as it stays valid. This is why the using actual file paths + are preferred unless you plan to keep the file descriptor open. + + **Note:** file descriptors are problematic as they are not necessarily unique, as two + different files opened and closed in succession might have the same file descriptor id. + + **Note:** Using file descriptors directly is faster once new windows are mapped as it + prevents the file to be opened again just for the purpose of mapping it.""" + regions = self._fdict.get(path_or_fd) + if regions is None: + regions = self.MapRegionListCls(path_or_fd) + self._fdict[path_or_fd] = regions + # END obtain region for path + return self.WindowCursorCls(self, regions) + + def collect(self): + """Collect all available free-to-collect mapped regions + :return: Amount of freed handles""" + return self._collect_lru_region(0) + + def num_file_handles(self): + """:return: amount of file handles in use. Each mapped region uses one file handle""" + return self._handle_count + + def num_open_files(self): + """Amount of opened files in the system""" + return reduce(lambda x, y: x + y, (1 for rlist in self._fdict.values() if len(rlist) > 0), 0) + + def window_size(self): + """:return: size of each window when allocating new regions""" + return self._window_size + + def mapped_memory_size(self): + """:return: amount of bytes currently mapped in total""" + return self._memory_size + + def max_file_handles(self): + """:return: maximium amount of handles we may have opened""" + return self._max_handle_count + + def max_mapped_memory_size(self): + """:return: maximum amount of memory we may allocate""" + return self._max_memory_size + + #} END interface + + #{ Special Purpose Interface + + def force_map_handle_removal_win(self, base_path): + """ONLY AVAILABLE ON WINDOWS + On windows removing files is not allowed if anybody still has it opened. + If this process is ourselves, and if the whole process uses this memory + manager (as far as the parent framework is concerned) we can enforce + closing all memory maps whose path matches the given base path to + allow the respective operation after all. + The respective system must NOT access the closed memory regions anymore ! + This really may only be used if you know that the items which keep + the cursors alive will not be using it anymore. They need to be recreated ! + :return: Amount of closed handles + + **Note:** does nothing on non-windows platforms""" + if sys.platform != 'win32': + return + # END early bailout + + num_closed = 0 + for path, rlist in self._fdict.items(): + if path.startswith(base_path): + for region in rlist: + region.release() + num_closed += 1 + # END path matches + # END for each path + return num_closed + #} END special purpose interface + + +class SlidingWindowMapManager(StaticWindowMapManager): + + """Maintains a list of ranges of mapped memory regions in one or more files and allows to easily + obtain additional regions assuring there is no overlap. + Once a certain memory limit is reached globally, or if there cannot be more open file handles + which result from each mmap call, the least recently used, and currently unused mapped regions + are unloaded automatically. + + **Note:** currently not thread-safe ! + + **Note:** in the current implementation, we will automatically unload windows if we either cannot + create more memory maps (as the open file handles limit is hit) or if we have allocated more than + a safe amount of memory already, which would possibly cause memory allocations to fail as our address + space is full.""" + + __slots__ = tuple() + + def __init__(self, window_size=-1, max_memory_size=0, max_open_handles=sys.maxsize): + """Adjusts the default window size to -1""" + super().__init__(window_size, max_memory_size, max_open_handles) + + def _obtain_region(self, a, offset, size, flags, is_recursive): + # bisect to find an existing region. The c++ implementation cannot + # do that as it uses a linked list for regions. + r = None + lo = 0 + hi = len(a) + while lo < hi: + mid = (lo + hi) // 2 + ofs = a[mid]._b + if ofs <= offset: + if a[mid].includes_ofs(offset): + r = a[mid] + break + # END have region + lo = mid + 1 + else: + hi = mid + # END handle position + # END while bisecting + + if r is None: + window_size = self._window_size + left = self.MapWindowCls(0, 0) + mid = self.MapWindowCls(offset, size) + right = self.MapWindowCls(a.file_size(), 0) + + # we want to honor the max memory size, and assure we have anough + # memory available + # Save calls ! + if self._memory_size + window_size > self._max_memory_size: + self._collect_lru_region(window_size) + # END handle collection + + # we assume the list remains sorted by offset + insert_pos = 0 + len_regions = len(a) + if len_regions == 1: + if a[0]._b <= offset: + insert_pos = 1 + # END maintain sort + else: + # find insert position + insert_pos = len_regions + for i, region in enumerate(a): + if region._b > offset: + insert_pos = i + break + # END if insert position is correct + # END for each region + # END obtain insert pos + + # adjust the actual offset and size values to create the largest + # possible mapping + if insert_pos == 0: + if len_regions: + right = self.MapWindowCls.from_region(a[insert_pos]) + # END adjust right side + else: + if insert_pos != len_regions: + right = self.MapWindowCls.from_region(a[insert_pos]) + # END adjust right window + left = self.MapWindowCls.from_region(a[insert_pos - 1]) + # END adjust surrounding windows + + mid.extend_left_to(left, window_size) + mid.extend_right_to(right, window_size) + mid.align() + + # it can happen that we align beyond the end of the file + if mid.ofs_end() > right.ofs: + mid.size = right.ofs - mid.ofs + # END readjust size + + # insert new region at the right offset to keep the order + try: + if self._handle_count >= self._max_handle_count: + raise Exception + # END assert own imposed max file handles + r = self.MapRegionCls(a.path_or_fd(), mid.ofs, mid.size, flags) + except Exception: + # apparently we are out of system resources or hit a limit + # As many more operations are likely to fail in that condition ( + # like reading a file from disk, etc) we free up as much as possible + # As this invalidates our insert position, we have to recurse here + if is_recursive: + # we already tried this, and still have no success in obtaining + # a mapping. This is an exception, so we propagate it + raise + # END handle existing recursion + self._collect_lru_region(0) + return self._obtain_region(a, offset, size, flags, True) + # END handle exceptions + + self._handle_count += 1 + self._memory_size += r.size() + a.insert(insert_pos, r) + # END create new region + return r diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/smmap/util.py b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/smmap/util.py new file mode 100644 index 0000000000000000000000000000000000000000..cf027afdc0c5c6ccc0c48245bd2da80bf1094174 --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/smmap/util.py @@ -0,0 +1,222 @@ +"""Module containing a memory memory manager which provides a sliding window on a number of memory mapped files""" +import os +import sys + +from mmap import mmap, ACCESS_READ +from mmap import ALLOCATIONGRANULARITY + +__all__ = ["align_to_mmap", "is_64_bit", + "MapWindow", "MapRegion", "MapRegionList", "ALLOCATIONGRANULARITY"] + +#{ Utilities + + +def align_to_mmap(num, round_up): + """ + Align the given integer number to the closest page offset, which usually is 4096 bytes. + + :param round_up: if True, the next higher multiple of page size is used, otherwise + the lower page_size will be used (i.e. if True, 1 becomes 4096, otherwise it becomes 0) + :return: num rounded to closest page""" + res = (num // ALLOCATIONGRANULARITY) * ALLOCATIONGRANULARITY + if round_up and (res != num): + res += ALLOCATIONGRANULARITY + # END handle size + return res + + +def is_64_bit(): + """:return: True if the system is 64 bit. Otherwise it can be assumed to be 32 bit""" + return sys.maxsize > (1 << 32) - 1 + +#}END utilities + + +#{ Utility Classes + +class MapWindow: + + """Utility type which is used to snap windows towards each other, and to adjust their size""" + __slots__ = ( + 'ofs', # offset into the file in bytes + 'size' # size of the window in bytes + ) + + def __init__(self, offset, size): + self.ofs = offset + self.size = size + + def __repr__(self): + return "MapWindow(%i, %i)" % (self.ofs, self.size) + + @classmethod + def from_region(cls, region): + """:return: new window from a region""" + return cls(region._b, region.size()) + + def ofs_end(self): + return self.ofs + self.size + + def align(self): + """Assures the previous window area is contained in the new one""" + nofs = align_to_mmap(self.ofs, 0) + self.size += self.ofs - nofs # keep size constant + self.ofs = nofs + self.size = align_to_mmap(self.size, 1) + + def extend_left_to(self, window, max_size): + """Adjust the offset to start where the given window on our left ends if possible, + but don't make yourself larger than max_size. + The resize will assure that the new window still contains the old window area""" + rofs = self.ofs - window.ofs_end() + nsize = rofs + self.size + rofs -= nsize - min(nsize, max_size) + self.ofs = self.ofs - rofs + self.size += rofs + + def extend_right_to(self, window, max_size): + """Adjust the size to make our window end where the right window begins, but don't + get larger than max_size""" + self.size = min(self.size + (window.ofs - self.ofs_end()), max_size) + + +class MapRegion: + + """Defines a mapped region of memory, aligned to pagesizes + + **Note:** deallocates used region automatically on destruction""" + __slots__ = [ + '_b', # beginning of mapping + '_mf', # mapped memory chunk (as returned by mmap) + '_uc', # total amount of usages + '_size', # cached size of our memory map + '__weakref__' + ] + + #{ Configuration + #} END configuration + + def __init__(self, path_or_fd, ofs, size, flags=0): + """Initialize a region, allocate the memory map + :param path_or_fd: path to the file to map, or the opened file descriptor + :param ofs: **aligned** offset into the file to be mapped + :param size: if size is larger then the file on disk, the whole file will be + allocated the the size automatically adjusted + :param flags: additional flags to be given when opening the file. + :raise Exception: if no memory can be allocated""" + self._b = ofs + self._size = 0 + self._uc = 0 + + if isinstance(path_or_fd, int): + fd = path_or_fd + else: + fd = os.open(path_or_fd, os.O_RDONLY | getattr(os, 'O_BINARY', 0) | flags) + # END handle fd + + try: + kwargs = dict(access=ACCESS_READ, offset=ofs) + corrected_size = size + sizeofs = ofs + + # have to correct size, otherwise (instead of the c version) it will + # bark that the size is too large ... many extra file accesses because + # if this ... argh ! + actual_size = min(os.fstat(fd).st_size - sizeofs, corrected_size) + self._mf = mmap(fd, actual_size, **kwargs) + # END handle memory mode + + self._size = len(self._mf) + finally: + if isinstance(path_or_fd, str): + os.close(fd) + # END only close it if we opened it + # END close file handle + # We assume the first one to use us keeps us around + self.increment_client_count() + + def __repr__(self): + return "MapRegion<%i, %i>" % (self._b, self.size()) + + #{ Interface + + def buffer(self): + """:return: a buffer containing the memory""" + return self._mf + + def map(self): + """:return: a memory map containing the memory""" + return self._mf + + def ofs_begin(self): + """:return: absolute byte offset to the first byte of the mapping""" + return self._b + + def size(self): + """:return: total size of the mapped region in bytes""" + return self._size + + def ofs_end(self): + """:return: Absolute offset to one byte beyond the mapping into the file""" + return self._b + self._size + + def includes_ofs(self, ofs): + """:return: True if the given offset can be read in our mapped region""" + return self._b <= ofs < self._b + self._size + + def client_count(self): + """:return: number of clients currently using this region""" + return self._uc + + def increment_client_count(self, ofs = 1): + """Adjust the usage count by the given positive or negative offset. + If usage count equals 0, we will auto-release our resources + :return: True if we released resources, False otherwise. In the latter case, we can still be used""" + self._uc += ofs + assert self._uc > -1, "Increments must match decrements, usage counter negative: %i" % self._uc + + if self.client_count() == 0: + self.release() + return True + else: + return False + # end handle release + + def release(self): + """Release all resources this instance might hold. Must only be called if there usage_count() is zero""" + self._mf.close() + + #} END interface + + +class MapRegionList(list): + + """List of MapRegion instances associating a path with a list of regions.""" + __slots__ = ( + '_path_or_fd', # path or file descriptor which is mapped by all our regions + '_file_size' # total size of the file we map + ) + + def __new__(cls, path): + return super().__new__(cls) + + def __init__(self, path_or_fd): + self._path_or_fd = path_or_fd + self._file_size = None + + def path_or_fd(self): + """:return: path or file descriptor we are attached to""" + return self._path_or_fd + + def file_size(self): + """:return: size of file we manager""" + if self._file_size is None: + if isinstance(self._path_or_fd, str): + self._file_size = os.stat(self._path_or_fd).st_size + else: + self._file_size = os.fstat(self._path_or_fd).st_size + # END handle path type + # END update file size + return self._file_size + +#} END utility classes diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/torchaudio/_torchaudio_decoder.so b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/torchaudio/_torchaudio_decoder.so new file mode 100644 index 0000000000000000000000000000000000000000..d3444682efba51d64a9a373e7e785655a0d927fe --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/torchaudio/_torchaudio_decoder.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:cfb8c622f599d2a2a002d798c16f3752d83beace05ce3997fe492a0fd5d21693 +size 570584 diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/tqdm/__main__.py b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/tqdm/__main__.py new file mode 100644 index 0000000000000000000000000000000000000000..4e28416e104515e90fca4b69cc60d0c61fd15d61 --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/tqdm/__main__.py @@ -0,0 +1,3 @@ +from .cli import main + +main() diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/tqdm/_tqdm.py b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/tqdm/_tqdm.py new file mode 100644 index 0000000000000000000000000000000000000000..7fc4962774a4651db7a739a3f143633b6215a9bd --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/tqdm/_tqdm.py @@ -0,0 +1,9 @@ +from warnings import warn + +from .std import * # NOQA +from .std import __all__ # NOQA +from .std import TqdmDeprecationWarning + +warn("This function will be removed in tqdm==5.0.0\n" + "Please use `tqdm.std.*` instead of `tqdm._tqdm.*`", + TqdmDeprecationWarning, stacklevel=2) diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/tqdm/_tqdm_notebook.py b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/tqdm/_tqdm_notebook.py new file mode 100644 index 0000000000000000000000000000000000000000..f225fbf5b52d04987ccf68f4d5ee4b735e3158b0 --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/tqdm/_tqdm_notebook.py @@ -0,0 +1,9 @@ +from warnings import warn + +from .notebook import * # NOQA +from .notebook import __all__ # NOQA +from .std import TqdmDeprecationWarning + +warn("This function will be removed in tqdm==5.0.0\n" + "Please use `tqdm.notebook.*` instead of `tqdm._tqdm_notebook.*`", + TqdmDeprecationWarning, stacklevel=2) diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/tqdm/asyncio.py b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/tqdm/asyncio.py new file mode 100644 index 0000000000000000000000000000000000000000..97c5f88fc22480a45e919de73c4077c4415bdc85 --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/tqdm/asyncio.py @@ -0,0 +1,93 @@ +""" +Asynchronous progressbar decorator for iterators. +Includes a default `range` iterator printing to `stderr`. + +Usage: +>>> from tqdm.asyncio import trange, tqdm +>>> async for i in trange(10): +... ... +""" +import asyncio +from sys import version_info + +from .std import tqdm as std_tqdm + +__author__ = {"github.com/": ["casperdcl"]} +__all__ = ['tqdm_asyncio', 'tarange', 'tqdm', 'trange'] + + +class tqdm_asyncio(std_tqdm): + """ + Asynchronous-friendly version of tqdm (Python 3.6+). + """ + def __init__(self, iterable=None, *args, **kwargs): + super(tqdm_asyncio, self).__init__(iterable, *args, **kwargs) + self.iterable_awaitable = False + if iterable is not None: + if hasattr(iterable, "__anext__"): + self.iterable_next = iterable.__anext__ + self.iterable_awaitable = True + elif hasattr(iterable, "__next__"): + self.iterable_next = iterable.__next__ + else: + self.iterable_iterator = iter(iterable) + self.iterable_next = self.iterable_iterator.__next__ + + def __aiter__(self): + return self + + async def __anext__(self): + try: + if self.iterable_awaitable: + res = await self.iterable_next() + else: + res = self.iterable_next() + self.update() + return res + except StopIteration: + self.close() + raise StopAsyncIteration + except BaseException: + self.close() + raise + + def send(self, *args, **kwargs): + return self.iterable.send(*args, **kwargs) + + @classmethod + def as_completed(cls, fs, *, loop=None, timeout=None, total=None, **tqdm_kwargs): + """ + Wrapper for `asyncio.as_completed`. + """ + if total is None: + total = len(fs) + kwargs = {} + if version_info[:2] < (3, 10): + kwargs['loop'] = loop + yield from cls(asyncio.as_completed(fs, timeout=timeout, **kwargs), + total=total, **tqdm_kwargs) + + @classmethod + async def gather(cls, *fs, loop=None, timeout=None, total=None, **tqdm_kwargs): + """ + Wrapper for `asyncio.gather`. + """ + async def wrap_awaitable(i, f): + return i, await f + + ifs = [wrap_awaitable(i, f) for i, f in enumerate(fs)] + res = [await f for f in cls.as_completed(ifs, loop=loop, timeout=timeout, + total=total, **tqdm_kwargs)] + return [i for _, i in sorted(res)] + + +def tarange(*args, **kwargs): + """ + A shortcut for `tqdm.asyncio.tqdm(range(*args), **kwargs)`. + """ + return tqdm_asyncio(range(*args), **kwargs) + + +# Aliases +tqdm = tqdm_asyncio +trange = tarange diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/tqdm/notebook.py b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/tqdm/notebook.py new file mode 100644 index 0000000000000000000000000000000000000000..5a264d36c1b962119fd0d1f828fd8ab08cc2cba4 --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/tqdm/notebook.py @@ -0,0 +1,328 @@ +""" +IPython/Jupyter Notebook progressbar decorator for iterators. +Includes a default `range` iterator printing to `stderr`. + +Usage: +>>> from tqdm.notebook import trange, tqdm +>>> for i in trange(10): +... ... +""" +# future division is important to divide integers and get as +# a result precise floating numbers (instead of truncated int) +from __future__ import absolute_import, division + +# import compatibility functions and utilities +import re +import sys +from weakref import proxy + +# to inherit from the tqdm class +from .std import tqdm as std_tqdm +from .utils import _range + +if True: # pragma: no cover + # import IPython/Jupyter base widget and display utilities + IPY = 0 + try: # IPython 4.x + import ipywidgets + IPY = 4 + except ImportError: # IPython 3.x / 2.x + IPY = 32 + import warnings + with warnings.catch_warnings(): + warnings.filterwarnings( + 'ignore', message=".*The `IPython.html` package has been deprecated.*") + try: + import IPython.html.widgets as ipywidgets # NOQA: F401 + except ImportError: + pass + + try: # IPython 4.x / 3.x + if IPY == 32: + from IPython.html.widgets import HTML + from IPython.html.widgets import FloatProgress as IProgress + from IPython.html.widgets import HBox + IPY = 3 + else: + from ipywidgets import HTML + from ipywidgets import FloatProgress as IProgress + from ipywidgets import HBox + except ImportError: + try: # IPython 2.x + from IPython.html.widgets import HTML + from IPython.html.widgets import ContainerWidget as HBox + from IPython.html.widgets import FloatProgressWidget as IProgress + IPY = 2 + except ImportError: + IPY = 0 + IProgress = None + HBox = object + + try: + from IPython.display import display # , clear_output + except ImportError: + pass + + # HTML encoding + try: # Py3 + from html import escape + except ImportError: # Py2 + from cgi import escape + +__author__ = {"github.com/": ["lrq3000", "casperdcl", "alexanderkuk"]} +__all__ = ['tqdm_notebook', 'tnrange', 'tqdm', 'trange'] +WARN_NOIPYW = ("IProgress not found. Please update jupyter and ipywidgets." + " See https://ipywidgets.readthedocs.io/en/stable" + "/user_install.html") + + +class TqdmHBox(HBox): + """`ipywidgets.HBox` with a pretty representation""" + def _repr_json_(self, pretty=None): + pbar = getattr(self, 'pbar', None) + if pbar is None: + return {} + d = pbar.format_dict + if pretty is not None: + d["ascii"] = not pretty + return d + + def __repr__(self, pretty=False): + pbar = getattr(self, 'pbar', None) + if pbar is None: + return super(TqdmHBox, self).__repr__() + return pbar.format_meter(**self._repr_json_(pretty)) + + def _repr_pretty_(self, pp, *_, **__): + pp.text(self.__repr__(True)) + + +class tqdm_notebook(std_tqdm): + """ + Experimental IPython/Jupyter Notebook widget using tqdm! + """ + @staticmethod + def status_printer(_, total=None, desc=None, ncols=None): + """ + Manage the printing of an IPython/Jupyter Notebook progress bar widget. + """ + # Fallback to text bar if there's no total + # DEPRECATED: replaced with an 'info' style bar + # if not total: + # return super(tqdm_notebook, tqdm_notebook).status_printer(file) + + # fp = file + + # Prepare IPython progress bar + if IProgress is None: # #187 #451 #558 #872 + raise ImportError(WARN_NOIPYW) + if total: + pbar = IProgress(min=0, max=total) + else: # No total? Show info style bar with no progress tqdm status + pbar = IProgress(min=0, max=1) + pbar.value = 1 + pbar.bar_style = 'info' + if ncols is None: + pbar.layout.width = "20px" + + ltext = HTML() + rtext = HTML() + if desc: + ltext.value = desc + container = TqdmHBox(children=[ltext, pbar, rtext]) + # Prepare layout + if ncols is not None: # use default style of ipywidgets + # ncols could be 100, "100px", "100%" + ncols = str(ncols) # ipywidgets only accepts string + try: + if int(ncols) > 0: # isnumeric and positive + ncols += 'px' + except ValueError: + pass + pbar.layout.flex = '2' + container.layout.width = ncols + container.layout.display = 'inline-flex' + container.layout.flex_flow = 'row wrap' + + return container + + def display(self, msg=None, pos=None, + # additional signals + close=False, bar_style=None, check_delay=True): + # Note: contrary to native tqdm, msg='' does NOT clear bar + # goal is to keep all infos if error happens so user knows + # at which iteration the loop failed. + + # Clear previous output (really necessary?) + # clear_output(wait=1) + + if not msg and not close: + d = self.format_dict + # remove {bar} + d['bar_format'] = (d['bar_format'] or "{l_bar}{r_bar}").replace( + "{bar}", "") + msg = self.format_meter(**d) + + ltext, pbar, rtext = self.container.children + pbar.value = self.n + + if msg: + # html escape special characters (like '&') + if '' in msg: + left, right = map(escape, re.split(r'\|?\|?', msg, 1)) + else: + left, right = '', escape(msg) + + # Update description + ltext.value = left + # never clear the bar (signal: msg='') + if right: + rtext.value = right + + # Change bar style + if bar_style: + # Hack-ish way to avoid the danger bar_style being overridden by + # success because the bar gets closed after the error... + if pbar.bar_style != 'danger' or bar_style != 'success': + pbar.bar_style = bar_style + + # Special signal to close the bar + if close and pbar.bar_style != 'danger': # hide only if no error + try: + self.container.close() + except AttributeError: + self.container.visible = False + + if check_delay and self.delay > 0 and not self.displayed: + display(self.container) + self.displayed = True + + @property + def colour(self): + if hasattr(self, 'container'): + return self.container.children[-2].style.bar_color + + @colour.setter + def colour(self, bar_color): + if hasattr(self, 'container'): + self.container.children[-2].style.bar_color = bar_color + + def __init__(self, *args, **kwargs): + """ + Supports the usual `tqdm.tqdm` parameters as well as those listed below. + + Parameters + ---------- + display : Whether to call `display(self.container)` immediately + [default: True]. + """ + kwargs = kwargs.copy() + # Setup default output + file_kwarg = kwargs.get('file', sys.stderr) + if file_kwarg is sys.stderr or file_kwarg is None: + kwargs['file'] = sys.stdout # avoid the red block in IPython + + # Initialize parent class + avoid printing by using gui=True + kwargs['gui'] = True + # convert disable = None to False + kwargs['disable'] = bool(kwargs.get('disable', False)) + colour = kwargs.pop('colour', None) + display_here = kwargs.pop('display', True) + super(tqdm_notebook, self).__init__(*args, **kwargs) + if self.disable or not kwargs['gui']: + self.disp = lambda *_, **__: None + return + + # Get bar width + self.ncols = '100%' if self.dynamic_ncols else kwargs.get("ncols", None) + + # Replace with IPython progress bar display (with correct total) + unit_scale = 1 if self.unit_scale is True else self.unit_scale or 1 + total = self.total * unit_scale if self.total else self.total + self.container = self.status_printer(self.fp, total, self.desc, self.ncols) + self.container.pbar = proxy(self) + self.displayed = False + if display_here and self.delay <= 0: + display(self.container) + self.displayed = True + self.disp = self.display + self.colour = colour + + # Print initial bar state + if not self.disable: + self.display(check_delay=False) + + def __iter__(self): + try: + it = super(tqdm_notebook, self).__iter__() + for obj in it: + # return super(tqdm...) will not catch exception + yield obj + # NB: except ... [ as ...] breaks IPython async KeyboardInterrupt + except: # NOQA + self.disp(bar_style='danger') + raise + # NB: don't `finally: close()` + # since this could be a shared bar which the user will `reset()` + + def update(self, n=1): + try: + return super(tqdm_notebook, self).update(n=n) + # NB: except ... [ as ...] breaks IPython async KeyboardInterrupt + except: # NOQA + # cannot catch KeyboardInterrupt when using manual tqdm + # as the interrupt will most likely happen on another statement + self.disp(bar_style='danger') + raise + # NB: don't `finally: close()` + # since this could be a shared bar which the user will `reset()` + + def close(self): + if self.disable: + return + super(tqdm_notebook, self).close() + # Try to detect if there was an error or KeyboardInterrupt + # in manual mode: if n < total, things probably got wrong + if self.total and self.n < self.total: + self.disp(bar_style='danger', check_delay=False) + else: + if self.leave: + self.disp(bar_style='success', check_delay=False) + else: + self.disp(close=True, check_delay=False) + + def clear(self, *_, **__): + pass + + def reset(self, total=None): + """ + Resets to 0 iterations for repeated use. + + Consider combining with `leave=True`. + + Parameters + ---------- + total : int or float, optional. Total to use for the new bar. + """ + if self.disable: + return super(tqdm_notebook, self).reset(total=total) + _, pbar, _ = self.container.children + pbar.bar_style = '' + if total is not None: + pbar.max = total + if not self.total and self.ncols is None: # no longer unknown total + pbar.layout.width = None # reset width + return super(tqdm_notebook, self).reset(total=total) + + +def tnrange(*args, **kwargs): + """ + A shortcut for `tqdm.notebook.tqdm(xrange(*args), **kwargs)`. + On Python3+, `range` is used instead of `xrange`. + """ + return tqdm_notebook(_range(*args), **kwargs) + + +# Aliases +tqdm = tqdm_notebook +trange = tnrange diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/tqdm/rich.py b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/tqdm/rich.py new file mode 100644 index 0000000000000000000000000000000000000000..69893ffdd5247dc40ab44a9de09697e5c8e0bb3b --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/tqdm/rich.py @@ -0,0 +1,156 @@ +""" +`rich.progress` decorator for iterators. + +Usage: +>>> from tqdm.rich import trange, tqdm +>>> for i in trange(10): +... ... +""" +from __future__ import absolute_import + +from warnings import warn + +from rich.progress import ( + BarColumn, Progress, ProgressColumn, Text, TimeElapsedColumn, TimeRemainingColumn, filesize) + +from .std import TqdmExperimentalWarning +from .std import tqdm as std_tqdm +from .utils import _range + +__author__ = {"github.com/": ["casperdcl"]} +__all__ = ['tqdm_rich', 'trrange', 'tqdm', 'trange'] + + +class FractionColumn(ProgressColumn): + """Renders completed/total, e.g. '0.5/2.3 G'.""" + def __init__(self, unit_scale=False, unit_divisor=1000): + self.unit_scale = unit_scale + self.unit_divisor = unit_divisor + super().__init__() + + def render(self, task): + """Calculate common unit for completed and total.""" + completed = int(task.completed) + total = int(task.total) + if self.unit_scale: + unit, suffix = filesize.pick_unit_and_suffix( + total, + ["", "K", "M", "G", "T", "P", "E", "Z", "Y"], + self.unit_divisor, + ) + else: + unit, suffix = filesize.pick_unit_and_suffix(total, [""], 1) + precision = 0 if unit == 1 else 1 + return Text( + f"{completed/unit:,.{precision}f}/{total/unit:,.{precision}f} {suffix}", + style="progress.download") + + +class RateColumn(ProgressColumn): + """Renders human readable transfer speed.""" + def __init__(self, unit="", unit_scale=False, unit_divisor=1000): + self.unit = unit + self.unit_scale = unit_scale + self.unit_divisor = unit_divisor + super().__init__() + + def render(self, task): + """Show data transfer speed.""" + speed = task.speed + if speed is None: + return Text(f"? {self.unit}/s", style="progress.data.speed") + if self.unit_scale: + unit, suffix = filesize.pick_unit_and_suffix( + speed, + ["", "K", "M", "G", "T", "P", "E", "Z", "Y"], + self.unit_divisor, + ) + else: + unit, suffix = filesize.pick_unit_and_suffix(speed, [""], 1) + precision = 0 if unit == 1 else 1 + return Text(f"{speed/unit:,.{precision}f} {suffix}{self.unit}/s", + style="progress.data.speed") + + +class tqdm_rich(std_tqdm): # pragma: no cover + """Experimental rich.progress GUI version of tqdm!""" + # TODO: @classmethod: write()? + def __init__(self, *args, **kwargs): + """ + This class accepts the following parameters *in addition* to + the parameters accepted by `tqdm`. + + Parameters + ---------- + progress : tuple, optional + arguments for `rich.progress.Progress()`. + options : dict, optional + keyword arguments for `rich.progress.Progress()`. + """ + kwargs = kwargs.copy() + kwargs['gui'] = True + # convert disable = None to False + kwargs['disable'] = bool(kwargs.get('disable', False)) + progress = kwargs.pop('progress', None) + options = kwargs.pop('options', {}).copy() + super(tqdm_rich, self).__init__(*args, **kwargs) + + if self.disable: + return + + warn("rich is experimental/alpha", TqdmExperimentalWarning, stacklevel=2) + d = self.format_dict + if progress is None: + progress = ( + "[progress.description]{task.description}" + "[progress.percentage]{task.percentage:>4.0f}%", + BarColumn(bar_width=None), + FractionColumn( + unit_scale=d['unit_scale'], unit_divisor=d['unit_divisor']), + "[", TimeElapsedColumn(), "<", TimeRemainingColumn(), + ",", RateColumn(unit=d['unit'], unit_scale=d['unit_scale'], + unit_divisor=d['unit_divisor']), "]" + ) + options.setdefault('transient', not self.leave) + self._prog = Progress(*progress, **options) + self._prog.__enter__() + self._task_id = self._prog.add_task(self.desc or "", **d) + + def close(self): + if self.disable: + return + super(tqdm_rich, self).close() + self._prog.__exit__(None, None, None) + + def clear(self, *_, **__): + pass + + def display(self, *_, **__): + if not hasattr(self, '_prog'): + return + self._prog.update(self._task_id, completed=self.n, description=self.desc) + + def reset(self, total=None): + """ + Resets to 0 iterations for repeated use. + + Parameters + ---------- + total : int or float, optional. Total to use for the new bar. + """ + if hasattr(self, '_prog'): + self._prog.reset(total=total) + super(tqdm_rich, self).reset(total=total) + + +def trrange(*args, **kwargs): + """ + A shortcut for `tqdm.rich.tqdm(xrange(*args), **kwargs)`. + On Python3+, `range` is used instead of `xrange`. + """ + return tqdm_rich(_range(*args), **kwargs) + + +# Aliases +tqdm = tqdm_rich +trange = trrange diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/tqdm/std.py b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/tqdm/std.py new file mode 100644 index 0000000000000000000000000000000000000000..5f9dccafeaaf1a37713497291f004eb89ab9ad41 --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/tqdm/std.py @@ -0,0 +1,1541 @@ +""" +Customisable progressbar decorator for iterators. +Includes a default `range` iterator printing to `stderr`. + +Usage: +>>> from tqdm import trange, tqdm +>>> for i in trange(10): +... ... +""" +from __future__ import absolute_import, division + +import sys +from collections import OrderedDict, defaultdict +from contextlib import contextmanager +from datetime import datetime, timedelta +from numbers import Number +from time import time +from warnings import warn +from weakref import WeakSet + +from ._monitor import TMonitor +from .utils import ( + CallbackIOWrapper, Comparable, DisableOnWriteError, FormatReplace, SimpleTextIOWrapper, + _basestring, _is_ascii, _range, _screen_shape_wrapper, _supports_unicode, _term_move_up, + _unich, _unicode, disp_len, disp_trim) + +__author__ = "https://github.com/tqdm/tqdm#contributions" +__all__ = ['tqdm', 'trange', + 'TqdmTypeError', 'TqdmKeyError', 'TqdmWarning', + 'TqdmExperimentalWarning', 'TqdmDeprecationWarning', + 'TqdmMonitorWarning'] + + +class TqdmTypeError(TypeError): + pass + + +class TqdmKeyError(KeyError): + pass + + +class TqdmWarning(Warning): + """base class for all tqdm warnings. + + Used for non-external-code-breaking errors, such as garbled printing. + """ + def __init__(self, msg, fp_write=None, *a, **k): + if fp_write is not None: + fp_write("\n" + self.__class__.__name__ + ": " + str(msg).rstrip() + '\n') + else: + super(TqdmWarning, self).__init__(msg, *a, **k) + + +class TqdmExperimentalWarning(TqdmWarning, FutureWarning): + """beta feature, unstable API and behaviour""" + pass + + +class TqdmDeprecationWarning(TqdmWarning, DeprecationWarning): + # not suppressed if raised + pass + + +class TqdmMonitorWarning(TqdmWarning, RuntimeWarning): + """tqdm monitor errors which do not affect external functionality""" + pass + + +def TRLock(*args, **kwargs): + """threading RLock""" + try: + from threading import RLock + return RLock(*args, **kwargs) + except (ImportError, OSError): # pragma: no cover + pass + + +class TqdmDefaultWriteLock(object): + """ + Provide a default write lock for thread and multiprocessing safety. + Works only on platforms supporting `fork` (so Windows is excluded). + You must initialise a `tqdm` or `TqdmDefaultWriteLock` instance + before forking in order for the write lock to work. + On Windows, you need to supply the lock from the parent to the children as + an argument to joblib or the parallelism lib you use. + """ + # global thread lock so no setup required for multithreading. + # NB: Do not create multiprocessing lock as it sets the multiprocessing + # context, disallowing `spawn()`/`forkserver()` + th_lock = TRLock() + + def __init__(self): + # Create global parallelism locks to avoid racing issues with parallel + # bars works only if fork available (Linux/MacOSX, but not Windows) + cls = type(self) + root_lock = cls.th_lock + if root_lock is not None: + root_lock.acquire() + cls.create_mp_lock() + self.locks = [lk for lk in [cls.mp_lock, cls.th_lock] if lk is not None] + if root_lock is not None: + root_lock.release() + + def acquire(self, *a, **k): + for lock in self.locks: + lock.acquire(*a, **k) + + def release(self): + for lock in self.locks[::-1]: # Release in inverse order of acquisition + lock.release() + + def __enter__(self): + self.acquire() + + def __exit__(self, *exc): + self.release() + + @classmethod + def create_mp_lock(cls): + if not hasattr(cls, 'mp_lock'): + try: + from multiprocessing import RLock + cls.mp_lock = RLock() + except (ImportError, OSError): # pragma: no cover + cls.mp_lock = None + + @classmethod + def create_th_lock(cls): + assert hasattr(cls, 'th_lock') + warn("create_th_lock not needed anymore", TqdmDeprecationWarning, stacklevel=2) + + +class Bar(object): + """ + `str.format`-able bar with format specifiers: `[width][type]` + + - `width` + + unspecified (default): use `self.default_len` + + `int >= 0`: overrides `self.default_len` + + `int < 0`: subtract from `self.default_len` + - `type` + + `a`: ascii (`charset=self.ASCII` override) + + `u`: unicode (`charset=self.UTF` override) + + `b`: blank (`charset=" "` override) + """ + ASCII = " 123456789#" + UTF = u" " + u''.join(map(_unich, range(0x258F, 0x2587, -1))) + BLANK = " " + COLOUR_RESET = '\x1b[0m' + COLOUR_RGB = '\x1b[38;2;%d;%d;%dm' + COLOURS = {'BLACK': '\x1b[30m', 'RED': '\x1b[31m', 'GREEN': '\x1b[32m', + 'YELLOW': '\x1b[33m', 'BLUE': '\x1b[34m', 'MAGENTA': '\x1b[35m', + 'CYAN': '\x1b[36m', 'WHITE': '\x1b[37m'} + + def __init__(self, frac, default_len=10, charset=UTF, colour=None): + if not 0 <= frac <= 1: + warn("clamping frac to range [0, 1]", TqdmWarning, stacklevel=2) + frac = max(0, min(1, frac)) + assert default_len > 0 + self.frac = frac + self.default_len = default_len + self.charset = charset + self.colour = colour + + @property + def colour(self): + return self._colour + + @colour.setter + def colour(self, value): + if not value: + self._colour = None + return + try: + if value.upper() in self.COLOURS: + self._colour = self.COLOURS[value.upper()] + elif value[0] == '#' and len(value) == 7: + self._colour = self.COLOUR_RGB % tuple( + int(i, 16) for i in (value[1:3], value[3:5], value[5:7])) + else: + raise KeyError + except (KeyError, AttributeError): + warn("Unknown colour (%s); valid choices: [hex (#00ff00), %s]" % ( + value, ", ".join(self.COLOURS)), + TqdmWarning, stacklevel=2) + self._colour = None + + def __format__(self, format_spec): + if format_spec: + _type = format_spec[-1].lower() + try: + charset = {'a': self.ASCII, 'u': self.UTF, 'b': self.BLANK}[_type] + except KeyError: + charset = self.charset + else: + format_spec = format_spec[:-1] + if format_spec: + N_BARS = int(format_spec) + if N_BARS < 0: + N_BARS += self.default_len + else: + N_BARS = self.default_len + else: + charset = self.charset + N_BARS = self.default_len + + nsyms = len(charset) - 1 + bar_length, frac_bar_length = divmod(int(self.frac * N_BARS * nsyms), nsyms) + + res = charset[-1] * bar_length + if bar_length < N_BARS: # whitespace padding + res = res + charset[frac_bar_length] + charset[0] * (N_BARS - bar_length - 1) + return self.colour + res + self.COLOUR_RESET if self.colour else res + + +class EMA(object): + """ + Exponential moving average: smoothing to give progressively lower + weights to older values. + + Parameters + ---------- + smoothing : float, optional + Smoothing factor in range [0, 1], [default: 0.3]. + Increase to give more weight to recent values. + Ranges from 0 (yields old value) to 1 (yields new value). + """ + def __init__(self, smoothing=0.3): + self.alpha = smoothing + self.last = 0 + self.calls = 0 + + def __call__(self, x=None): + """ + Parameters + ---------- + x : float + New value to include in EMA. + """ + beta = 1 - self.alpha + if x is not None: + self.last = self.alpha * x + beta * self.last + self.calls += 1 + return self.last / (1 - beta ** self.calls) if self.calls else self.last + + +class tqdm(Comparable): + """ + Decorate an iterable object, returning an iterator which acts exactly + like the original iterable, but prints a dynamically updating + progressbar every time a value is requested. + """ + + monitor_interval = 10 # set to 0 to disable the thread + monitor = None + _instances = WeakSet() + + @staticmethod + def format_sizeof(num, suffix='', divisor=1000): + """ + Formats a number (greater than unity) with SI Order of Magnitude + prefixes. + + Parameters + ---------- + num : float + Number ( >= 1) to format. + suffix : str, optional + Post-postfix [default: '']. + divisor : float, optional + Divisor between prefixes [default: 1000]. + + Returns + ------- + out : str + Number with Order of Magnitude SI unit postfix. + """ + for unit in ['', 'k', 'M', 'G', 'T', 'P', 'E', 'Z']: + if abs(num) < 999.5: + if abs(num) < 99.95: + if abs(num) < 9.995: + return '{0:1.2f}'.format(num) + unit + suffix + return '{0:2.1f}'.format(num) + unit + suffix + return '{0:3.0f}'.format(num) + unit + suffix + num /= divisor + return '{0:3.1f}Y'.format(num) + suffix + + @staticmethod + def format_interval(t): + """ + Formats a number of seconds as a clock time, [H:]MM:SS + + Parameters + ---------- + t : int + Number of seconds. + + Returns + ------- + out : str + [H:]MM:SS + """ + mins, s = divmod(int(t), 60) + h, m = divmod(mins, 60) + if h: + return '{0:d}:{1:02d}:{2:02d}'.format(h, m, s) + else: + return '{0:02d}:{1:02d}'.format(m, s) + + @staticmethod + def format_num(n): + """ + Intelligent scientific notation (.3g). + + Parameters + ---------- + n : int or float or Numeric + A Number. + + Returns + ------- + out : str + Formatted number. + """ + f = '{0:.3g}'.format(n).replace('+0', '+').replace('-0', '-') + n = str(n) + return f if len(f) < len(n) else n + + @staticmethod + def status_printer(file): + """ + Manage the printing and in-place updating of a line of characters. + Note that if the string is longer than a line, then in-place + updating may not work (it will print a new line at each refresh). + """ + fp = file + fp_flush = getattr(fp, 'flush', lambda: None) # pragma: no cover + if fp in (sys.stderr, sys.stdout): + getattr(sys.stderr, 'flush', lambda: None)() + getattr(sys.stdout, 'flush', lambda: None)() + + def fp_write(s): + fp.write(_unicode(s)) + fp_flush() + + last_len = [0] + + def print_status(s): + len_s = disp_len(s) + fp_write('\r' + s + (' ' * max(last_len[0] - len_s, 0))) + last_len[0] = len_s + + return print_status + + @staticmethod + def format_meter(n, total, elapsed, ncols=None, prefix='', ascii=False, unit='it', + unit_scale=False, rate=None, bar_format=None, postfix=None, + unit_divisor=1000, initial=0, colour=None, **extra_kwargs): + """ + Return a string-based progress bar given some parameters + + Parameters + ---------- + n : int or float + Number of finished iterations. + total : int or float + The expected total number of iterations. If meaningless (None), + only basic progress statistics are displayed (no ETA). + elapsed : float + Number of seconds passed since start. + ncols : int, optional + The width of the entire output message. If specified, + dynamically resizes `{bar}` to stay within this bound + [default: None]. If `0`, will not print any bar (only stats). + The fallback is `{bar:10}`. + prefix : str, optional + Prefix message (included in total width) [default: '']. + Use as {desc} in bar_format string. + ascii : bool, optional or str, optional + If not set, use unicode (smooth blocks) to fill the meter + [default: False]. The fallback is to use ASCII characters + " 123456789#". + unit : str, optional + The iteration unit [default: 'it']. + unit_scale : bool or int or float, optional + If 1 or True, the number of iterations will be printed with an + appropriate SI metric prefix (k = 10^3, M = 10^6, etc.) + [default: False]. If any other non-zero number, will scale + `total` and `n`. + rate : float, optional + Manual override for iteration rate. + If [default: None], uses n/elapsed. + bar_format : str, optional + Specify a custom bar string formatting. May impact performance. + [default: '{l_bar}{bar}{r_bar}'], where + l_bar='{desc}: {percentage:3.0f}%|' and + r_bar='| {n_fmt}/{total_fmt} [{elapsed}<{remaining}, ' + '{rate_fmt}{postfix}]' + Possible vars: l_bar, bar, r_bar, n, n_fmt, total, total_fmt, + percentage, elapsed, elapsed_s, ncols, nrows, desc, unit, + rate, rate_fmt, rate_noinv, rate_noinv_fmt, + rate_inv, rate_inv_fmt, postfix, unit_divisor, + remaining, remaining_s, eta. + Note that a trailing ": " is automatically removed after {desc} + if the latter is empty. + postfix : *, optional + Similar to `prefix`, but placed at the end + (e.g. for additional stats). + Note: postfix is usually a string (not a dict) for this method, + and will if possible be set to postfix = ', ' + postfix. + However other types are supported (#382). + unit_divisor : float, optional + [default: 1000], ignored unless `unit_scale` is True. + initial : int or float, optional + The initial counter value [default: 0]. + colour : str, optional + Bar colour (e.g. 'green', '#00ff00'). + + Returns + ------- + out : Formatted meter and stats, ready to display. + """ + + # sanity check: total + if total and n >= (total + 0.5): # allow float imprecision (#849) + total = None + + # apply custom scale if necessary + if unit_scale and unit_scale not in (True, 1): + if total: + total *= unit_scale + n *= unit_scale + if rate: + rate *= unit_scale # by default rate = self.avg_dn / self.avg_dt + unit_scale = False + + elapsed_str = tqdm.format_interval(elapsed) + + # if unspecified, attempt to use rate = average speed + # (we allow manual override since predicting time is an arcane art) + if rate is None and elapsed: + rate = (n - initial) / elapsed + inv_rate = 1 / rate if rate else None + format_sizeof = tqdm.format_sizeof + rate_noinv_fmt = ((format_sizeof(rate) if unit_scale else + '{0:5.2f}'.format(rate)) if rate else '?') + unit + '/s' + rate_inv_fmt = ( + (format_sizeof(inv_rate) if unit_scale else '{0:5.2f}'.format(inv_rate)) + if inv_rate else '?') + 's/' + unit + rate_fmt = rate_inv_fmt if inv_rate and inv_rate > 1 else rate_noinv_fmt + + if unit_scale: + n_fmt = format_sizeof(n, divisor=unit_divisor) + total_fmt = format_sizeof(total, divisor=unit_divisor) if total is not None else '?' + else: + n_fmt = str(n) + total_fmt = str(total) if total is not None else '?' + + try: + postfix = ', ' + postfix if postfix else '' + except TypeError: + pass + + remaining = (total - n) / rate if rate and total else 0 + remaining_str = tqdm.format_interval(remaining) if rate else '?' + try: + eta_dt = (datetime.now() + timedelta(seconds=remaining) + if rate and total else datetime.utcfromtimestamp(0)) + except OverflowError: + eta_dt = datetime.max + + # format the stats displayed to the left and right sides of the bar + if prefix: + # old prefix setup work around + bool_prefix_colon_already = (prefix[-2:] == ": ") + l_bar = prefix if bool_prefix_colon_already else prefix + ": " + else: + l_bar = '' + + r_bar = '| {0}/{1} [{2}<{3}, {4}{5}]'.format( + n_fmt, total_fmt, elapsed_str, remaining_str, rate_fmt, postfix) + + # Custom bar formatting + # Populate a dict with all available progress indicators + format_dict = dict( + # slight extension of self.format_dict + n=n, n_fmt=n_fmt, total=total, total_fmt=total_fmt, + elapsed=elapsed_str, elapsed_s=elapsed, + ncols=ncols, desc=prefix or '', unit=unit, + rate=inv_rate if inv_rate and inv_rate > 1 else rate, + rate_fmt=rate_fmt, rate_noinv=rate, + rate_noinv_fmt=rate_noinv_fmt, rate_inv=inv_rate, + rate_inv_fmt=rate_inv_fmt, + postfix=postfix, unit_divisor=unit_divisor, + colour=colour, + # plus more useful definitions + remaining=remaining_str, remaining_s=remaining, + l_bar=l_bar, r_bar=r_bar, eta=eta_dt, + **extra_kwargs) + + # total is known: we can predict some stats + if total: + # fractional and percentage progress + frac = n / total + percentage = frac * 100 + + l_bar += '{0:3.0f}%|'.format(percentage) + + if ncols == 0: + return l_bar[:-1] + r_bar[1:] + + format_dict.update(l_bar=l_bar) + if bar_format: + format_dict.update(percentage=percentage) + + # auto-remove colon for empty `desc` + if not prefix: + bar_format = bar_format.replace("{desc}: ", '') + else: + bar_format = "{l_bar}{bar}{r_bar}" + + full_bar = FormatReplace() + try: + nobar = bar_format.format(bar=full_bar, **format_dict) + except UnicodeEncodeError: + bar_format = _unicode(bar_format) + nobar = bar_format.format(bar=full_bar, **format_dict) + if not full_bar.format_called: + # no {bar}, we can just format and return + return nobar + + # Formatting progress bar space available for bar's display + full_bar = Bar(frac, + max(1, ncols - disp_len(nobar)) if ncols else 10, + charset=Bar.ASCII if ascii is True else ascii or Bar.UTF, + colour=colour) + if not _is_ascii(full_bar.charset) and _is_ascii(bar_format): + bar_format = _unicode(bar_format) + res = bar_format.format(bar=full_bar, **format_dict) + return disp_trim(res, ncols) if ncols else res + + elif bar_format: + # user-specified bar_format but no total + l_bar += '|' + format_dict.update(l_bar=l_bar, percentage=0) + full_bar = FormatReplace() + nobar = bar_format.format(bar=full_bar, **format_dict) + if not full_bar.format_called: + return nobar + full_bar = Bar(0, + max(1, ncols - disp_len(nobar)) if ncols else 10, + charset=Bar.BLANK, colour=colour) + res = bar_format.format(bar=full_bar, **format_dict) + return disp_trim(res, ncols) if ncols else res + else: + # no total: no progressbar, ETA, just progress stats + return '{0}{1}{2} [{3}, {4}{5}]'.format( + (prefix + ": ") if prefix else '', n_fmt, unit, elapsed_str, rate_fmt, postfix) + + def __new__(cls, *_, **__): + instance = object.__new__(cls) + with cls.get_lock(): # also constructs lock if non-existent + cls._instances.add(instance) + # create monitoring thread + if cls.monitor_interval and (cls.monitor is None + or not cls.monitor.report()): + try: + cls.monitor = TMonitor(cls, cls.monitor_interval) + except Exception as e: # pragma: nocover + warn("tqdm:disabling monitor support" + " (monitor_interval = 0) due to:\n" + str(e), + TqdmMonitorWarning, stacklevel=2) + cls.monitor_interval = 0 + return instance + + @classmethod + def _get_free_pos(cls, instance=None): + """Skips specified instance.""" + positions = {abs(inst.pos) for inst in cls._instances + if inst is not instance and hasattr(inst, "pos")} + return min(set(range(len(positions) + 1)).difference(positions)) + + @classmethod + def _decr_instances(cls, instance): + """ + Remove from list and reposition another unfixed bar + to fill the new gap. + + This means that by default (where all nested bars are unfixed), + order is not maintained but screen flicker/blank space is minimised. + (tqdm<=4.44.1 moved ALL subsequent unfixed bars up.) + """ + with cls._lock: + try: + cls._instances.remove(instance) + except KeyError: + # if not instance.gui: # pragma: no cover + # raise + pass # py2: maybe magically removed already + # else: + if not instance.gui: + last = (instance.nrows or 20) - 1 + # find unfixed (`pos >= 0`) overflow (`pos >= nrows - 1`) + instances = list(filter( + lambda i: hasattr(i, "pos") and last <= i.pos, + cls._instances)) + # set first found to current `pos` + if instances: + inst = min(instances, key=lambda i: i.pos) + inst.clear(nolock=True) + inst.pos = abs(instance.pos) + + @classmethod + def write(cls, s, file=None, end="\n", nolock=False): + """Print a message via tqdm (without overlap with bars).""" + fp = file if file is not None else sys.stdout + with cls.external_write_mode(file=file, nolock=nolock): + # Write the message + fp.write(s) + fp.write(end) + + @classmethod + @contextmanager + def external_write_mode(cls, file=None, nolock=False): + """ + Disable tqdm within context and refresh tqdm when exits. + Useful when writing to standard output stream + """ + fp = file if file is not None else sys.stdout + + try: + if not nolock: + cls.get_lock().acquire() + # Clear all bars + inst_cleared = [] + for inst in getattr(cls, '_instances', []): + # Clear instance if in the target output file + # or if write output + tqdm output are both either + # sys.stdout or sys.stderr (because both are mixed in terminal) + if hasattr(inst, "start_t") and (inst.fp == fp or all( + f in (sys.stdout, sys.stderr) for f in (fp, inst.fp))): + inst.clear(nolock=True) + inst_cleared.append(inst) + yield + # Force refresh display of bars we cleared + for inst in inst_cleared: + inst.refresh(nolock=True) + finally: + if not nolock: + cls._lock.release() + + @classmethod + def set_lock(cls, lock): + """Set the global lock.""" + cls._lock = lock + + @classmethod + def get_lock(cls): + """Get the global lock. Construct it if it does not exist.""" + if not hasattr(cls, '_lock'): + cls._lock = TqdmDefaultWriteLock() + return cls._lock + + @classmethod + def pandas(cls, **tqdm_kwargs): + """ + Registers the current `tqdm` class with + pandas.core. + ( frame.DataFrame + | series.Series + | groupby.(generic.)DataFrameGroupBy + | groupby.(generic.)SeriesGroupBy + ).progress_apply + + A new instance will be created every time `progress_apply` is called, + and each instance will automatically `close()` upon completion. + + Parameters + ---------- + tqdm_kwargs : arguments for the tqdm instance + + Examples + -------- + >>> import pandas as pd + >>> import numpy as np + >>> from tqdm import tqdm + >>> from tqdm.gui import tqdm as tqdm_gui + >>> + >>> df = pd.DataFrame(np.random.randint(0, 100, (100000, 6))) + >>> tqdm.pandas(ncols=50) # can use tqdm_gui, optional kwargs, etc + >>> # Now you can use `progress_apply` instead of `apply` + >>> df.groupby(0).progress_apply(lambda x: x**2) + + References + ---------- + + """ + from warnings import catch_warnings, simplefilter + + from pandas.core.frame import DataFrame + from pandas.core.series import Series + try: + with catch_warnings(): + simplefilter("ignore", category=FutureWarning) + from pandas import Panel + except ImportError: # pandas>=1.2.0 + Panel = None + Rolling, Expanding = None, None + try: # pandas>=1.0.0 + from pandas.core.window.rolling import _Rolling_and_Expanding + except ImportError: + try: # pandas>=0.18.0 + from pandas.core.window import _Rolling_and_Expanding + except ImportError: # pandas>=1.2.0 + try: # pandas>=1.2.0 + from pandas.core.window.expanding import Expanding + from pandas.core.window.rolling import Rolling + _Rolling_and_Expanding = Rolling, Expanding + except ImportError: # pragma: no cover + _Rolling_and_Expanding = None + try: # pandas>=0.25.0 + from pandas.core.groupby.generic import SeriesGroupBy # , NDFrameGroupBy + from pandas.core.groupby.generic import DataFrameGroupBy + except ImportError: # pragma: no cover + try: # pandas>=0.23.0 + from pandas.core.groupby.groupby import DataFrameGroupBy, SeriesGroupBy + except ImportError: + from pandas.core.groupby import DataFrameGroupBy, SeriesGroupBy + try: # pandas>=0.23.0 + from pandas.core.groupby.groupby import GroupBy + except ImportError: # pragma: no cover + from pandas.core.groupby import GroupBy + + try: # pandas>=0.23.0 + from pandas.core.groupby.groupby import PanelGroupBy + except ImportError: + try: + from pandas.core.groupby import PanelGroupBy + except ImportError: # pandas>=0.25.0 + PanelGroupBy = None + + tqdm_kwargs = tqdm_kwargs.copy() + deprecated_t = [tqdm_kwargs.pop('deprecated_t', None)] + + def inner_generator(df_function='apply'): + def inner(df, func, *args, **kwargs): + """ + Parameters + ---------- + df : (DataFrame|Series)[GroupBy] + Data (may be grouped). + func : function + To be applied on the (grouped) data. + **kwargs : optional + Transmitted to `df.apply()`. + """ + + # Precompute total iterations + total = tqdm_kwargs.pop("total", getattr(df, 'ngroups', None)) + if total is None: # not grouped + if df_function == 'applymap': + total = df.size + elif isinstance(df, Series): + total = len(df) + elif (_Rolling_and_Expanding is None or + not isinstance(df, _Rolling_and_Expanding)): + # DataFrame or Panel + axis = kwargs.get('axis', 0) + if axis == 'index': + axis = 0 + elif axis == 'columns': + axis = 1 + # when axis=0, total is shape[axis1] + total = df.size // df.shape[axis] + + # Init bar + if deprecated_t[0] is not None: + t = deprecated_t[0] + deprecated_t[0] = None + else: + t = cls(total=total, **tqdm_kwargs) + + if len(args) > 0: + # *args intentionally not supported (see #244, #299) + TqdmDeprecationWarning( + "Except func, normal arguments are intentionally" + + " not supported by" + + " `(DataFrame|Series|GroupBy).progress_apply`." + + " Use keyword arguments instead.", + fp_write=getattr(t.fp, 'write', sys.stderr.write)) + + try: # pandas>=1.3.0 + from pandas.core.common import is_builtin_func + except ImportError: + is_builtin_func = df._is_builtin_func + try: + func = is_builtin_func(func) + except TypeError: + pass + + # Define bar updating wrapper + def wrapper(*args, **kwargs): + # update tbar correctly + # it seems `pandas apply` calls `func` twice + # on the first column/row to decide whether it can + # take a fast or slow code path; so stop when t.total==t.n + t.update(n=1 if not t.total or t.n < t.total else 0) + return func(*args, **kwargs) + + # Apply the provided function (in **kwargs) + # on the df using our wrapper (which provides bar updating) + try: + return getattr(df, df_function)(wrapper, **kwargs) + finally: + t.close() + + return inner + + # Monkeypatch pandas to provide easy methods + # Enable custom tqdm progress in pandas! + Series.progress_apply = inner_generator() + SeriesGroupBy.progress_apply = inner_generator() + Series.progress_map = inner_generator('map') + SeriesGroupBy.progress_map = inner_generator('map') + + DataFrame.progress_apply = inner_generator() + DataFrameGroupBy.progress_apply = inner_generator() + DataFrame.progress_applymap = inner_generator('applymap') + + if Panel is not None: + Panel.progress_apply = inner_generator() + if PanelGroupBy is not None: + PanelGroupBy.progress_apply = inner_generator() + + GroupBy.progress_apply = inner_generator() + GroupBy.progress_aggregate = inner_generator('aggregate') + GroupBy.progress_transform = inner_generator('transform') + + if Rolling is not None and Expanding is not None: + Rolling.progress_apply = inner_generator() + Expanding.progress_apply = inner_generator() + elif _Rolling_and_Expanding is not None: + _Rolling_and_Expanding.progress_apply = inner_generator() + + def __init__(self, iterable=None, desc=None, total=None, leave=True, file=None, + ncols=None, mininterval=0.1, maxinterval=10.0, miniters=None, + ascii=None, disable=False, unit='it', unit_scale=False, + dynamic_ncols=False, smoothing=0.3, bar_format=None, initial=0, + position=None, postfix=None, unit_divisor=1000, write_bytes=None, + lock_args=None, nrows=None, colour=None, delay=0, gui=False, + **kwargs): + """ + Parameters + ---------- + iterable : iterable, optional + Iterable to decorate with a progressbar. + Leave blank to manually manage the updates. + desc : str, optional + Prefix for the progressbar. + total : int or float, optional + The number of expected iterations. If unspecified, + len(iterable) is used if possible. If float("inf") or as a last + resort, only basic progress statistics are displayed + (no ETA, no progressbar). + If `gui` is True and this parameter needs subsequent updating, + specify an initial arbitrary large positive number, + e.g. 9e9. + leave : bool, optional + If [default: True], keeps all traces of the progressbar + upon termination of iteration. + If `None`, will leave only if `position` is `0`. + file : `io.TextIOWrapper` or `io.StringIO`, optional + Specifies where to output the progress messages + (default: sys.stderr). Uses `file.write(str)` and `file.flush()` + methods. For encoding, see `write_bytes`. + ncols : int, optional + The width of the entire output message. If specified, + dynamically resizes the progressbar to stay within this bound. + If unspecified, attempts to use environment width. The + fallback is a meter width of 10 and no limit for the counter and + statistics. If 0, will not print any meter (only stats). + mininterval : float, optional + Minimum progress display update interval [default: 0.1] seconds. + maxinterval : float, optional + Maximum progress display update interval [default: 10] seconds. + Automatically adjusts `miniters` to correspond to `mininterval` + after long display update lag. Only works if `dynamic_miniters` + or monitor thread is enabled. + miniters : int or float, optional + Minimum progress display update interval, in iterations. + If 0 and `dynamic_miniters`, will automatically adjust to equal + `mininterval` (more CPU efficient, good for tight loops). + If > 0, will skip display of specified number of iterations. + Tweak this and `mininterval` to get very efficient loops. + If your progress is erratic with both fast and slow iterations + (network, skipping items, etc) you should set miniters=1. + ascii : bool or str, optional + If unspecified or False, use unicode (smooth blocks) to fill + the meter. The fallback is to use ASCII characters " 123456789#". + disable : bool, optional + Whether to disable the entire progressbar wrapper + [default: False]. If set to None, disable on non-TTY. + unit : str, optional + String that will be used to define the unit of each iteration + [default: it]. + unit_scale : bool or int or float, optional + If 1 or True, the number of iterations will be reduced/scaled + automatically and a metric prefix following the + International System of Units standard will be added + (kilo, mega, etc.) [default: False]. If any other non-zero + number, will scale `total` and `n`. + dynamic_ncols : bool, optional + If set, constantly alters `ncols` and `nrows` to the + environment (allowing for window resizes) [default: False]. + smoothing : float, optional + Exponential moving average smoothing factor for speed estimates + (ignored in GUI mode). Ranges from 0 (average speed) to 1 + (current/instantaneous speed) [default: 0.3]. + bar_format : str, optional + Specify a custom bar string formatting. May impact performance. + [default: '{l_bar}{bar}{r_bar}'], where + l_bar='{desc}: {percentage:3.0f}%|' and + r_bar='| {n_fmt}/{total_fmt} [{elapsed}<{remaining}, ' + '{rate_fmt}{postfix}]' + Possible vars: l_bar, bar, r_bar, n, n_fmt, total, total_fmt, + percentage, elapsed, elapsed_s, ncols, nrows, desc, unit, + rate, rate_fmt, rate_noinv, rate_noinv_fmt, + rate_inv, rate_inv_fmt, postfix, unit_divisor, + remaining, remaining_s, eta. + Note that a trailing ": " is automatically removed after {desc} + if the latter is empty. + initial : int or float, optional + The initial counter value. Useful when restarting a progress + bar [default: 0]. If using float, consider specifying `{n:.3f}` + or similar in `bar_format`, or specifying `unit_scale`. + position : int, optional + Specify the line offset to print this bar (starting from 0) + Automatic if unspecified. + Useful to manage multiple bars at once (eg, from threads). + postfix : dict or *, optional + Specify additional stats to display at the end of the bar. + Calls `set_postfix(**postfix)` if possible (dict). + unit_divisor : float, optional + [default: 1000], ignored unless `unit_scale` is True. + write_bytes : bool, optional + If (default: None) and `file` is unspecified, + bytes will be written in Python 2. If `True` will also write + bytes. In all other cases will default to unicode. + lock_args : tuple, optional + Passed to `refresh` for intermediate output + (initialisation, iterating, and updating). + nrows : int, optional + The screen height. If specified, hides nested bars outside this + bound. If unspecified, attempts to use environment height. + The fallback is 20. + colour : str, optional + Bar colour (e.g. 'green', '#00ff00'). + delay : float, optional + Don't display until [default: 0] seconds have elapsed. + gui : bool, optional + WARNING: internal parameter - do not use. + Use tqdm.gui.tqdm(...) instead. If set, will attempt to use + matplotlib animations for a graphical output [default: False]. + + Returns + ------- + out : decorated iterator. + """ + if write_bytes is None: + write_bytes = file is None and sys.version_info < (3,) + + if file is None: + file = sys.stderr + + if write_bytes: + # Despite coercing unicode into bytes, py2 sys.std* streams + # should have bytes written to them. + file = SimpleTextIOWrapper( + file, encoding=getattr(file, 'encoding', None) or 'utf-8') + + file = DisableOnWriteError(file, tqdm_instance=self) + + if disable is None and hasattr(file, "isatty") and not file.isatty(): + disable = True + + if total is None and iterable is not None: + try: + total = len(iterable) + except (TypeError, AttributeError): + total = None + if total == float("inf"): + # Infinite iterations, behave same as unknown + total = None + + if disable: + self.iterable = iterable + self.disable = disable + with self._lock: + self.pos = self._get_free_pos(self) + self._instances.remove(self) + self.n = initial + self.total = total + self.leave = leave + return + + if kwargs: + self.disable = True + with self._lock: + self.pos = self._get_free_pos(self) + self._instances.remove(self) + raise ( + TqdmDeprecationWarning( + "`nested` is deprecated and automated.\n" + "Use `position` instead for manual control.\n", + fp_write=getattr(file, 'write', sys.stderr.write)) + if "nested" in kwargs else + TqdmKeyError("Unknown argument(s): " + str(kwargs))) + + # Preprocess the arguments + if ( + (ncols is None or nrows is None) and (file in (sys.stderr, sys.stdout)) + ) or dynamic_ncols: # pragma: no cover + if dynamic_ncols: + dynamic_ncols = _screen_shape_wrapper() + if dynamic_ncols: + ncols, nrows = dynamic_ncols(file) + else: + _dynamic_ncols = _screen_shape_wrapper() + if _dynamic_ncols: + _ncols, _nrows = _dynamic_ncols(file) + if ncols is None: + ncols = _ncols + if nrows is None: + nrows = _nrows + + if miniters is None: + miniters = 0 + dynamic_miniters = True + else: + dynamic_miniters = False + + if mininterval is None: + mininterval = 0 + + if maxinterval is None: + maxinterval = 0 + + if ascii is None: + ascii = not _supports_unicode(file) + + if bar_format and ascii is not True and not _is_ascii(ascii): + # Convert bar format into unicode since terminal uses unicode + bar_format = _unicode(bar_format) + + if smoothing is None: + smoothing = 0 + + # Store the arguments + self.iterable = iterable + self.desc = desc or '' + self.total = total + self.leave = leave + self.fp = file + self.ncols = ncols + self.nrows = nrows + self.mininterval = mininterval + self.maxinterval = maxinterval + self.miniters = miniters + self.dynamic_miniters = dynamic_miniters + self.ascii = ascii + self.disable = disable + self.unit = unit + self.unit_scale = unit_scale + self.unit_divisor = unit_divisor + self.initial = initial + self.lock_args = lock_args + self.delay = delay + self.gui = gui + self.dynamic_ncols = dynamic_ncols + self.smoothing = smoothing + self._ema_dn = EMA(smoothing) + self._ema_dt = EMA(smoothing) + self._ema_miniters = EMA(smoothing) + self.bar_format = bar_format + self.postfix = None + self.colour = colour + self._time = time + if postfix: + try: + self.set_postfix(refresh=False, **postfix) + except TypeError: + self.postfix = postfix + + # Init the iterations counters + self.last_print_n = initial + self.n = initial + + # if nested, at initial sp() call we replace '\r' by '\n' to + # not overwrite the outer progress bar + with self._lock: + # mark fixed positions as negative + self.pos = self._get_free_pos(self) if position is None else -position + + if not gui: + # Initialize the screen printer + self.sp = self.status_printer(self.fp) + if delay <= 0: + self.refresh(lock_args=self.lock_args) + + # Init the time counter + self.last_print_t = self._time() + # NB: Avoid race conditions by setting start_t at the very end of init + self.start_t = self.last_print_t + + def __bool__(self): + if self.total is not None: + return self.total > 0 + if self.iterable is None: + raise TypeError('bool() undefined when iterable == total == None') + return bool(self.iterable) + + def __nonzero__(self): + return self.__bool__() + + def __len__(self): + return ( + self.total if self.iterable is None + else self.iterable.shape[0] if hasattr(self.iterable, "shape") + else len(self.iterable) if hasattr(self.iterable, "__len__") + else self.iterable.__length_hint__() if hasattr(self.iterable, "__length_hint__") + else getattr(self, "total", None)) + + def __reversed__(self): + try: + orig = self.iterable + except AttributeError: + raise TypeError("'tqdm' object is not reversible") + else: + self.iterable = reversed(self.iterable) + return self.__iter__() + finally: + self.iterable = orig + + def __contains__(self, item): + contains = getattr(self.iterable, '__contains__', None) + return contains(item) if contains is not None else item in self.__iter__() + + def __enter__(self): + return self + + def __exit__(self, exc_type, exc_value, traceback): + try: + self.close() + except AttributeError: + # maybe eager thread cleanup upon external error + if (exc_type, exc_value, traceback) == (None, None, None): + raise + warn("AttributeError ignored", TqdmWarning, stacklevel=2) + + def __del__(self): + self.close() + + def __str__(self): + return self.format_meter(**self.format_dict) + + @property + def _comparable(self): + return abs(getattr(self, "pos", 1 << 31)) + + def __hash__(self): + return id(self) + + def __iter__(self): + """Backward-compatibility to use: for x in tqdm(iterable)""" + + # Inlining instance variables as locals (speed optimisation) + iterable = self.iterable + + # If the bar is disabled, then just walk the iterable + # (note: keep this check outside the loop for performance) + if self.disable: + for obj in iterable: + yield obj + return + + mininterval = self.mininterval + last_print_t = self.last_print_t + last_print_n = self.last_print_n + min_start_t = self.start_t + self.delay + n = self.n + time = self._time + + try: + for obj in iterable: + yield obj + # Update and possibly print the progressbar. + # Note: does not call self.update(1) for speed optimisation. + n += 1 + + if n - last_print_n >= self.miniters: + cur_t = time() + dt = cur_t - last_print_t + if dt >= mininterval and cur_t >= min_start_t: + self.update(n - last_print_n) + last_print_n = self.last_print_n + last_print_t = self.last_print_t + finally: + self.n = n + self.close() + + def update(self, n=1): + """ + Manually update the progress bar, useful for streams + such as reading files. + E.g.: + >>> t = tqdm(total=filesize) # Initialise + >>> for current_buffer in stream: + ... ... + ... t.update(len(current_buffer)) + >>> t.close() + The last line is highly recommended, but possibly not necessary if + `t.update()` will be called in such a way that `filesize` will be + exactly reached and printed. + + Parameters + ---------- + n : int or float, optional + Increment to add to the internal counter of iterations + [default: 1]. If using float, consider specifying `{n:.3f}` + or similar in `bar_format`, or specifying `unit_scale`. + + Returns + ------- + out : bool or None + True if a `display()` was triggered. + """ + if self.disable: + return + + if n < 0: + self.last_print_n += n # for auto-refresh logic to work + self.n += n + + # check counter first to reduce calls to time() + if self.n - self.last_print_n >= self.miniters: + cur_t = self._time() + dt = cur_t - self.last_print_t + if dt >= self.mininterval and cur_t >= self.start_t + self.delay: + cur_t = self._time() + dn = self.n - self.last_print_n # >= n + if self.smoothing and dt and dn: + # EMA (not just overall average) + self._ema_dn(dn) + self._ema_dt(dt) + self.refresh(lock_args=self.lock_args) + if self.dynamic_miniters: + # If no `miniters` was specified, adjust automatically to the + # maximum iteration rate seen so far between two prints. + # e.g.: After running `tqdm.update(5)`, subsequent + # calls to `tqdm.update()` will only cause an update after + # at least 5 more iterations. + if self.maxinterval and dt >= self.maxinterval: + self.miniters = dn * (self.mininterval or self.maxinterval) / dt + elif self.smoothing: + # EMA miniters update + self.miniters = self._ema_miniters( + dn * (self.mininterval / dt if self.mininterval and dt + else 1)) + else: + # max iters between two prints + self.miniters = max(self.miniters, dn) + + # Store old values for next call + self.last_print_n = self.n + self.last_print_t = cur_t + return True + + def close(self): + """Cleanup and (if leave=False) close the progressbar.""" + if self.disable: + return + + # Prevent multiple closures + self.disable = True + + # decrement instance pos and remove from internal set + pos = abs(self.pos) + self._decr_instances(self) + + if self.last_print_t < self.start_t + self.delay: + # haven't ever displayed; nothing to clear + return + + # GUI mode + if getattr(self, 'sp', None) is None: + return + + # annoyingly, _supports_unicode isn't good enough + def fp_write(s): + self.fp.write(_unicode(s)) + + try: + fp_write('') + except ValueError as e: + if 'closed' in str(e): + return + raise # pragma: no cover + + leave = pos == 0 if self.leave is None else self.leave + + with self._lock: + if leave: + # stats for overall rate (no weighted average) + self._ema_dt = lambda: None + self.display(pos=0) + fp_write('\n') + else: + # clear previous display + if self.display(msg='', pos=pos) and not pos: + fp_write('\r') + + def clear(self, nolock=False): + """Clear current bar display.""" + if self.disable: + return + + if not nolock: + self._lock.acquire() + pos = abs(self.pos) + if pos < (self.nrows or 20): + self.moveto(pos) + self.sp('') + self.fp.write('\r') # place cursor back at the beginning of line + self.moveto(-pos) + if not nolock: + self._lock.release() + + def refresh(self, nolock=False, lock_args=None): + """ + Force refresh the display of this bar. + + Parameters + ---------- + nolock : bool, optional + If `True`, does not lock. + If [default: `False`]: calls `acquire()` on internal lock. + lock_args : tuple, optional + Passed to internal lock's `acquire()`. + If specified, will only `display()` if `acquire()` returns `True`. + """ + if self.disable: + return + + if not nolock: + if lock_args: + if not self._lock.acquire(*lock_args): + return False + else: + self._lock.acquire() + self.display() + if not nolock: + self._lock.release() + return True + + def unpause(self): + """Restart tqdm timer from last print time.""" + if self.disable: + return + cur_t = self._time() + self.start_t += cur_t - self.last_print_t + self.last_print_t = cur_t + + def reset(self, total=None): + """ + Resets to 0 iterations for repeated use. + + Consider combining with `leave=True`. + + Parameters + ---------- + total : int or float, optional. Total to use for the new bar. + """ + self.n = 0 + if total is not None: + self.total = total + if self.disable: + return + self.last_print_n = 0 + self.last_print_t = self.start_t = self._time() + self._ema_dn = EMA(self.smoothing) + self._ema_dt = EMA(self.smoothing) + self._ema_miniters = EMA(self.smoothing) + self.refresh() + + def set_description(self, desc=None, refresh=True): + """ + Set/modify description of the progress bar. + + Parameters + ---------- + desc : str, optional + refresh : bool, optional + Forces refresh [default: True]. + """ + self.desc = desc + ': ' if desc else '' + if refresh: + self.refresh() + + def set_description_str(self, desc=None, refresh=True): + """Set/modify description without ': ' appended.""" + self.desc = desc or '' + if refresh: + self.refresh() + + def set_postfix(self, ordered_dict=None, refresh=True, **kwargs): + """ + Set/modify postfix (additional stats) + with automatic formatting based on datatype. + + Parameters + ---------- + ordered_dict : dict or OrderedDict, optional + refresh : bool, optional + Forces refresh [default: True]. + kwargs : dict, optional + """ + # Sort in alphabetical order to be more deterministic + postfix = OrderedDict([] if ordered_dict is None else ordered_dict) + for key in sorted(kwargs.keys()): + postfix[key] = kwargs[key] + # Preprocess stats according to datatype + for key in postfix.keys(): + # Number: limit the length of the string + if isinstance(postfix[key], Number): + postfix[key] = self.format_num(postfix[key]) + # Else for any other type, try to get the string conversion + elif not isinstance(postfix[key], _basestring): + postfix[key] = str(postfix[key]) + # Else if it's a string, don't need to preprocess anything + # Stitch together to get the final postfix + self.postfix = ', '.join(key + '=' + postfix[key].strip() + for key in postfix.keys()) + if refresh: + self.refresh() + + def set_postfix_str(self, s='', refresh=True): + """ + Postfix without dictionary expansion, similar to prefix handling. + """ + self.postfix = str(s) + if refresh: + self.refresh() + + def moveto(self, n): + # TODO: private method + self.fp.write(_unicode('\n' * n + _term_move_up() * -n)) + getattr(self.fp, 'flush', lambda: None)() + + @property + def format_dict(self): + """Public API for read-only member access.""" + if self.disable and not hasattr(self, 'unit'): + return defaultdict(lambda: None, { + 'n': self.n, 'total': self.total, 'elapsed': 0, 'unit': 'it'}) + if self.dynamic_ncols: + self.ncols, self.nrows = self.dynamic_ncols(self.fp) + return { + 'n': self.n, 'total': self.total, + 'elapsed': self._time() - self.start_t if hasattr(self, 'start_t') else 0, + 'ncols': self.ncols, 'nrows': self.nrows, 'prefix': self.desc, + 'ascii': self.ascii, 'unit': self.unit, 'unit_scale': self.unit_scale, + 'rate': self._ema_dn() / self._ema_dt() if self._ema_dt() else None, + 'bar_format': self.bar_format, 'postfix': self.postfix, + 'unit_divisor': self.unit_divisor, 'initial': self.initial, + 'colour': self.colour} + + def display(self, msg=None, pos=None): + """ + Use `self.sp` to display `msg` in the specified `pos`. + + Consider overloading this function when inheriting to use e.g.: + `self.some_frontend(**self.format_dict)` instead of `self.sp`. + + Parameters + ---------- + msg : str, optional. What to display (default: `repr(self)`). + pos : int, optional. Position to `moveto` + (default: `abs(self.pos)`). + """ + if pos is None: + pos = abs(self.pos) + + nrows = self.nrows or 20 + if pos >= nrows - 1: + if pos >= nrows: + return False + if msg or msg is None: # override at `nrows - 1` + msg = " ... (more hidden) ..." + + if not hasattr(self, "sp"): + raise TqdmDeprecationWarning( + "Please use `tqdm.gui.tqdm(...)`" + " instead of `tqdm(..., gui=True)`\n", + fp_write=getattr(self.fp, 'write', sys.stderr.write)) + + if pos: + self.moveto(pos) + self.sp(self.__str__() if msg is None else msg) + if pos: + self.moveto(-pos) + return True + + @classmethod + @contextmanager + def wrapattr(cls, stream, method, total=None, bytes=True, **tqdm_kwargs): + """ + stream : file-like object. + method : str, "read" or "write". The result of `read()` and + the first argument of `write()` should have a `len()`. + + >>> with tqdm.wrapattr(file_obj, "read", total=file_obj.size) as fobj: + ... while True: + ... chunk = fobj.read(chunk_size) + ... if not chunk: + ... break + """ + with cls(total=total, **tqdm_kwargs) as t: + if bytes: + t.unit = "B" + t.unit_scale = True + t.unit_divisor = 1024 + yield CallbackIOWrapper(t.update, stream, method) + + +def trange(*args, **kwargs): + """ + A shortcut for tqdm(xrange(*args), **kwargs). + On Python3+ range is used instead of xrange. + """ + return tqdm(_range(*args), **kwargs) diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/xontrib/conda.xsh b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/xontrib/conda.xsh new file mode 100644 index 0000000000000000000000000000000000000000..a74bb056930e377b8694e43fc5ca5453114eb5e4 --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/xontrib/conda.xsh @@ -0,0 +1,205 @@ +$CONDA_EXE = "/workspace/anaconda3/bin/conda" +# Copyright (C) 2012 Anaconda, Inc +# SPDX-License-Identifier: BSD-3-Clause +# Much of this forked from https://github.com/gforsyth/xonda +# Copyright (c) 2016, Gil Forsyth, All rights reserved. +# Original code licensed under BSD-3-Clause. +from xonsh.lazyasd import lazyobject + +if 'CONDA_EXE' not in ${...}: + ![python -m conda init --dev out> conda-dev-init.sh] + source-bash conda-dev-init.sh + import os + os.remove("conda-dev-init.sh") + +_REACTIVATE_COMMANDS = ('install', 'update', 'upgrade', 'remove', 'uninstall') + + +@lazyobject +def Env(): + from collections import namedtuple + return namedtuple('Env', ['name', 'path', 'bin_dir', 'envs_dir']) + + +def _parse_args(args=None): + from argparse import ArgumentParser + p = ArgumentParser(add_help=False) + p.add_argument('command') + ns, _ = p.parse_known_args(args) + if ns.command == 'activate': + p.add_argument('env_name_or_prefix', default='base') + elif ns.command in _REACTIVATE_COMMANDS: + p.add_argument('-n', '--name') + p.add_argument('-p', '--prefix') + parsed_args, _ = p.parse_known_args(args) + return parsed_args + + +def _raise_pipeline_error(pipeline): + stdout = pipeline.out + stderr = pipeline.err + if pipeline.returncode != 0: + message = ("exited with %s\nstdout: %s\nstderr: %s\n" + "" % (pipeline.returncode, stdout, stderr)) + raise RuntimeError(message) + return stdout.strip() + + +def _conda_activate_handler(env_name_or_prefix): + import os + + __xonsh__.execer.exec($($CONDA_EXE shell.xonsh activate @(env_name_or_prefix)), + glbs=__xonsh__.ctx, + filename="$(conda shell.xonsh activate " + env_name_or_prefix + ")") + if $CONDA_DEFAULT_ENV != os.path.split(env_name_or_prefix)[1]: + import sys as _sys + + print("WARNING: conda environment not activated properly. " + "This is likely because you have a conda init inside of your " + "~/.bashrc (unix) or *.bat activation file (windows). This is " + "causing conda to activate twice in xonsh. Please remove the conda " + "init block from your other shell.", file=_sys.stderr) + + +def _conda_deactivate_handler(): + __xonsh__.execer.exec($($CONDA_EXE shell.xonsh deactivate), + glbs=__xonsh__.ctx, + filename="$(conda shell.xonsh deactivate)") + + +def _conda_passthrough_handler(args): + pipeline = ![$CONDA_EXE @(args)] + _raise_pipeline_error(pipeline) + + +def _conda_reactivate_handler(args, name_or_prefix_given): + pipeline = ![$CONDA_EXE @(args)] + _raise_pipeline_error(pipeline) + if not name_or_prefix_given: + __xonsh__.execer.exec($($CONDA_EXE shell.xonsh reactivate), + glbs=__xonsh__.ctx, + filename="$(conda shell.xonsh reactivate)") + + +def _conda_main(args=None): + parsed_args = _parse_args(args) + if parsed_args.command == 'activate': + _conda_activate_handler(parsed_args.env_name_or_prefix) + elif parsed_args.command == 'deactivate': + _conda_deactivate_handler() + elif parsed_args.command in _REACTIVATE_COMMANDS: + name_or_prefix_given = bool(parsed_args.name or parsed_args.prefix) + _conda_reactivate_handler(args, name_or_prefix_given) + else: + _conda_passthrough_handler(args) + + +if 'CONDA_SHLVL' not in ${...}: + $CONDA_SHLVL = '0' + import os as _os + import sys as _sys + _sys.path.insert(0, _os.path.join(_os.path.dirname(_os.path.dirname($CONDA_EXE)), "condabin")) + del _os, _sys + +aliases['conda'] = _conda_main + + +def _list_dirs(path): + """ + Generator that lists the directories in a given path. + """ + import os + for entry in os.scandir(path): + if not entry.name.startswith('.') and entry.is_dir(): + yield entry.name + + +def _get_envs_unfiltered(): + """ + Grab a list of all conda env dirs from conda, allowing all warnings. + """ + import os + import importlib + + try: + # breaking changes introduced in Anaconda 4.4.7 + # try to import newer library structure first + context = importlib.import_module('conda.base.context') + config = context.context + except ModuleNotFoundError: + config = importlib.import_module('conda.config') + + # create the list of environments + env_list = [] + for envs_dir in config.envs_dirs: + # skip non-existing environments directories + if not os.path.exists(envs_dir): + continue + # for each environment in the environments directory + for env_name in _list_dirs(envs_dir): + # check for duplicates names + if env_name in [env.name for env in env_list]: + raise ValueError('Multiple environments with the same name ' + "in the system is not supported by conda's xonsh tools.") + # add the environment to the list + env_list.append(Env(name=env_name, + path=os.path.join(envs_dir, env_name), + bin_dir=os.path.join(envs_dir, env_name, 'bin'), + envs_dir=envs_dir, + )) + return env_list + + +def _get_envs(): + """ + Grab a list of all conda env dirs from conda, ignoring all warnings + """ + import warnings + with warnings.catch_warnings(): + warnings.simplefilter("ignore") + return _get_envs_unfiltered() + + +def _conda_completer(prefix, line, start, end, ctx): + """ + Completion for conda + """ + args = line.split(' ') + possible = set() + if len(args) == 0 or args[0] not in ['xonda', 'conda']: + return None + curix = args.index(prefix) + if curix == 1: + possible = {'activate', 'deactivate', 'install', 'remove', 'info', + 'help', 'list', 'search', 'update', 'upgrade', 'uninstall', + 'config', 'init', 'clean', 'package', 'bundle', 'env', + 'select', 'create', '-h', '--help', '-V', '--version'} + + elif curix == 2: + if args[1] in ['activate', 'select']: + possible = set([env.name for env in _get_envs()]) + elif args[1] == 'create': + possible = {'-p', '-n'} + elif args[1] == 'env': + possible = {'attach', 'create', 'export', 'list', 'remove', + 'upload', 'update'} + + elif curix == 3: + if args[2] == 'export': + possible = {'-n', '--name'} + elif args[2] == 'create': + possible = {'-h', '--help', '-f', '--file', '-n', '--name', '-p', + '--prefix', '-q', '--quiet', '--force', '--json', + '--debug', '-v', '--verbose'} + + elif curix == 4: + if args[2] == 'export' and args[3] in ['-n','--name']: + possible = set([env.name for env in _get_envs()]) + + return {i for i in possible if i.startswith(prefix)} + + +# add _xonda_completer to list of completers +__xonsh__.completers['conda'] = _conda_completer +# bump to top of list +__xonsh__.completers.move_to_end('conda', last=False) diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/zstandard/_cffi.cpython-38-x86_64-linux-gnu.so b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/zstandard/_cffi.cpython-38-x86_64-linux-gnu.so new file mode 100644 index 0000000000000000000000000000000000000000..2fc0eaf60eb2331eba7f8c360bb80931777f40ca --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/zstandard/_cffi.cpython-38-x86_64-linux-gnu.so @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5d19192136dd9d5a0d43b5a0ea0b78fa42c6661f7249d0789700644e5c210d68 +size 893416