Add files using upload-large-folder tool

.gitattributes

@@ -176,3 +176,6 @@ my_container_sandbox/workspace/anaconda3/pkgs/sqlite-3.36.0-hc218d9a_0.conda fil
 my_container_sandbox/workspace/anaconda3/pkgs/certifi-2021.5.30-py39h06a4308_0.conda filter=lfs diff=lfs merge=lfs -text
 my_container_sandbox/workspace/anaconda3/pkgs/ncurses-6.2-he6710b0_1.conda filter=lfs diff=lfs merge=lfs -text
 my_container_sandbox/workspace/anaconda3/pkgs/pip-21.1.3-py39h06a4308_0.conda filter=lfs diff=lfs merge=lfs -text
+my_container_sandbox/workspace/anaconda3/pkgs/certifi-2024.2.2-pyhd8ed1ab_0.conda filter=lfs diff=lfs merge=lfs -text
+my_container_sandbox/workspace/anaconda3/pkgs/sqlite-3.41.2-h5eee18b_0.conda filter=lfs diff=lfs merge=lfs -text
+my_container_sandbox/workspace/anaconda3/pkgs/brotlipy-0.7.0-py39h27cfd23_1003.conda filter=lfs diff=lfs merge=lfs -text

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/_distutils_hack/__init__.py

@@ -0,0 +1,220 @@
+# don't import any costly modules
+import sys
+import os
+
+
+def warn_distutils_present():
+    if 'distutils' not in sys.modules:
+        return
+    import warnings
+
+    warnings.warn(
+        "Distutils was imported before Setuptools, but importing Setuptools "
+        "also replaces the `distutils` module in `sys.modules`. This may lead "
+        "to undesirable behaviors or errors. To avoid these issues, avoid "
+        "using distutils directly, ensure that setuptools is installed in the "
+        "traditional way (e.g. not an editable install), and/or make sure "
+        "that setuptools is always imported before distutils."
+    )
+
+
+def clear_distutils():
+    if 'distutils' not in sys.modules:
+        return
+    import warnings
+
+    warnings.warn("Setuptools is replacing distutils.")
+    mods = [
+        name
+        for name in sys.modules
+        if name == "distutils" or name.startswith("distutils.")
+    ]
+    for name in mods:
+        del sys.modules[name]
+
+
+def enabled():
+    """
+    Allow selection of distutils by environment variable.
+    """
+    which = os.environ.get('SETUPTOOLS_USE_DISTUTILS', 'local')
+    return which == 'local'
+
+
+def ensure_local_distutils():
+    import importlib
+
+    clear_distutils()
+
+    # With the DistutilsMetaFinder in place,
+    # perform an import to cause distutils to be
+    # loaded from setuptools._distutils. Ref #2906.
+    with shim():
+        importlib.import_module('distutils')
+
+    # check that submodules load as expected
+    core = importlib.import_module('distutils.core')
+    assert '_distutils' in core.__file__, core.__file__
+    assert 'setuptools._distutils.log' not in sys.modules
+
+
+def do_override():
+    """
+    Ensure that the local copy of distutils is preferred over stdlib.
+
+    See https://github.com/pypa/setuptools/issues/417#issuecomment-392298401
+    for more motivation.
+    """
+    if enabled():
+        warn_distutils_present()
+        ensure_local_distutils()
+
+
+class _TrivialRe:
+    def __init__(self, *patterns):
+        self._patterns = patterns
+
+    def match(self, string):
+        return all(pat in string for pat in self._patterns)
+
+
+class DistutilsMetaFinder:
+    def find_spec(self, fullname, path, target=None):
+        # optimization: only consider top level modules and those
+        # found in the CPython test suite.
+        if path is not None and not fullname.startswith('test.'):
+            return None
+
+        method_name = 'spec_for_{fullname}'.format(**locals())
+        method = getattr(self, method_name, lambda: None)
+        return method()
+
+    def spec_for_distutils(self):
+        if self.is_cpython():
+            return None
+
+        import importlib
+        import importlib.abc
+        import importlib.util
+
+        try:
+            mod = importlib.import_module('setuptools._distutils')
+        except Exception:
+            # There are a couple of cases where setuptools._distutils
+            # may not be present:
+            # - An older Setuptools without a local distutils is
+            #   taking precedence. Ref #2957.
+            # - Path manipulation during sitecustomize removes
+            #   setuptools from the path but only after the hook
+            #   has been loaded. Ref #2980.
+            # In either case, fall back to stdlib behavior.
+            return None
+
+        class DistutilsLoader(importlib.abc.Loader):
+            def create_module(self, spec):
+                mod.__name__ = 'distutils'
+                return mod
+
+            def exec_module(self, module):
+                pass
+
+        return importlib.util.spec_from_loader(
+            'distutils', DistutilsLoader(), origin=mod.__file__
+        )
+
+    @staticmethod
+    def is_cpython():
+        """
+        Suppress supplying distutils for CPython (build and tests).
+        Ref #2965 and #3007.
+        """
+        return os.path.isfile('pybuilddir.txt')
+
+    def spec_for_pip(self):
+        """
+        Ensure stdlib distutils when running under pip.
+        See pypa/pip#8761 for rationale.
+        """
+        if sys.version_info >= (3, 12) or self.pip_imported_during_build():
+            return
+        clear_distutils()
+        self.spec_for_distutils = lambda: None
+
+    @classmethod
+    def pip_imported_during_build(cls):
+        """
+        Detect if pip is being imported in a build script. Ref #2355.
+        """
+        import traceback
+
+        return any(
+            cls.frame_file_is_setup(frame) for frame, line in traceback.walk_stack(None)
+        )
+
+    @staticmethod
+    def frame_file_is_setup(frame):
+        """
+        Return True if the indicated frame suggests a setup.py file.
+        """
+        # some frames may not have __file__ (#2940)
+        return frame.f_globals.get('__file__', '').endswith('setup.py')
+
+    def spec_for_sensitive_tests(self):
+        """
+        Ensure stdlib distutils when running select tests under CPython.
+
+        python/cpython#91169
+        """
+        clear_distutils()
+        self.spec_for_distutils = lambda: None
+
+    sensitive_tests = (
+        [
+            'test.test_distutils',
+            'test.test_peg_generator',
+            'test.test_importlib',
+        ]
+        if sys.version_info < (3, 10)
+        else [
+            'test.test_distutils',
+        ]
+    )
+
+
+for name in DistutilsMetaFinder.sensitive_tests:
+    setattr(
+        DistutilsMetaFinder,
+        f'spec_for_{name}',
+        DistutilsMetaFinder.spec_for_sensitive_tests,
+    )
+
+
+DISTUTILS_FINDER = DistutilsMetaFinder()
+
+
+def add_shim():
+    DISTUTILS_FINDER in sys.meta_path or insert_shim()
+
+
+class shim:
+    def __enter__(self):
+        insert_shim()
+
+    def __exit__(self, exc, value, tb):
+        _remove_shim()
+
+
+def insert_shim():
+    sys.meta_path.insert(0, DISTUTILS_FINDER)
+
+
+def _remove_shim():
+    try:
+        sys.meta_path.remove(DISTUTILS_FINDER)
+    except ValueError:
+        pass
+
+
+if sys.version_info < (3, 12):
+    # DistutilsMetaFinder can only be disabled in Python < 3.12 (PEP 632)
+    remove_shim = _remove_shim

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/_distutils_hack/override.py

@@ -0,0 +1 @@
+__import__('_distutils_hack').do_override()

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/charset_normalizer/__init__.py

@@ -0,0 +1,56 @@
+# -*- coding: utf_8 -*-
+"""
+Charset-Normalizer
+~~~~~~~~~~~~~~
+The Real First Universal Charset Detector.
+A library that helps you read text from an unknown charset encoding.
+Motivated by chardet, This package is trying to resolve the issue by taking a new approach.
+All IANA character set names for which the Python core library provides codecs are supported.
+
+Basic usage:
+   >>> from charset_normalizer import from_bytes
+   >>> results = from_bytes('Bсеки човек има право на образование. Oбразованието!'.encode('utf_8'))
+   >>> best_guess = results.best()
+   >>> str(best_guess)
+   'Bсеки човек има право на образование. Oбразованието!'
+
+Others methods and usages are available - see the full documentation
+at <https://github.com/Ousret/charset_normalizer>.
+:copyright: (c) 2021 by Ahmed TAHRI
+:license: MIT, see LICENSE for more details.
+"""
+import logging
+
+from .api import from_bytes, from_fp, from_path, normalize
+from .legacy import (
+    CharsetDetector,
+    CharsetDoctor,
+    CharsetNormalizerMatch,
+    CharsetNormalizerMatches,
+    detect,
+)
+from .models import CharsetMatch, CharsetMatches
+from .utils import set_logging_handler
+from .version import VERSION, __version__
+
+__all__ = (
+    "from_fp",
+    "from_path",
+    "from_bytes",
+    "normalize",
+    "detect",
+    "CharsetMatch",
+    "CharsetMatches",
+    "CharsetNormalizerMatch",
+    "CharsetNormalizerMatches",
+    "CharsetDetector",
+    "CharsetDoctor",
+    "__version__",
+    "VERSION",
+    "set_logging_handler",
+)
+
+# Attach a NullHandler to the top level logger by default
+# https://docs.python.org/3.3/howto/logging.html#configuring-logging-for-a-library
+
+logging.getLogger("charset_normalizer").addHandler(logging.NullHandler())

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/charset_normalizer/api.py

@@ -0,0 +1,608 @@
+import logging
+from os.path import basename, splitext
+from typing import BinaryIO, List, Optional, Set
+
+try:
+    from os import PathLike
+except ImportError:  # pragma: no cover
+    PathLike = str  # type: ignore
+
+from .cd import (
+    coherence_ratio,
+    encoding_languages,
+    mb_encoding_languages,
+    merge_coherence_ratios,
+)
+from .constant import IANA_SUPPORTED, TOO_BIG_SEQUENCE, TOO_SMALL_SEQUENCE, TRACE
+from .md import mess_ratio
+from .models import CharsetMatch, CharsetMatches
+from .utils import (
+    any_specified_encoding,
+    iana_name,
+    identify_sig_or_bom,
+    is_cp_similar,
+    is_multi_byte_encoding,
+    should_strip_sig_or_bom,
+)
+
+# Will most likely be controversial
+# logging.addLevelName(TRACE, "TRACE")
+logger = logging.getLogger("charset_normalizer")
+explain_handler = logging.StreamHandler()
+explain_handler.setFormatter(
+    logging.Formatter("%(asctime)s | %(levelname)s | %(message)s")
+)
+
+
+def from_bytes(
+    sequences: bytes,
+    steps: int = 5,
+    chunk_size: int = 512,
+    threshold: float = 0.2,
+    cp_isolation: List[str] = None,
+    cp_exclusion: List[str] = None,
+    preemptive_behaviour: bool = True,
+    explain: bool = False,
+) -> CharsetMatches:
+    """
+    Given a raw bytes sequence, return the best possibles charset usable to render str objects.
+    If there is no results, it is a strong indicator that the source is binary/not text.
+    By default, the process will extract 5 blocs of 512o each to assess the mess and coherence of a given sequence.
+    And will give up a particular code page after 20% of measured mess. Those criteria are customizable at will.
+
+    The preemptive behavior DOES NOT replace the traditional detection workflow, it prioritize a particular code page
+    but never take it for granted. Can improve the performance.
+
+    You may want to focus your attention to some code page or/and not others, use cp_isolation and cp_exclusion for that
+    purpose.
+
+    This function will strip the SIG in the payload/sequence every time except on UTF-16, UTF-32.
+    By default the library does not setup any handler other than the NullHandler, if you choose to set the 'explain'
+    toggle to True it will alter the logger configuration to add a StreamHandler that is suitable for debugging.
+    Custom logging format and handler can be set manually.
+    """
+
+    if not isinstance(sequences, (bytearray, bytes)):
+        raise TypeError(
+            "Expected object of type bytes or bytearray, got: {0}".format(
+                type(sequences)
+            )
+        )
+
+    if explain:
+        previous_logger_level = logger.level  # type: int
+        logger.addHandler(explain_handler)
+        logger.setLevel(TRACE)
+
+    length = len(sequences)  # type: int
+
+    if length == 0:
+        logger.debug("Encoding detection on empty bytes, assuming utf_8 intention.")
+        if explain:
+            logger.removeHandler(explain_handler)
+            logger.setLevel(previous_logger_level or logging.WARNING)
+        return CharsetMatches([CharsetMatch(sequences, "utf_8", 0.0, False, [], "")])
+
+    if cp_isolation is not None:
+        logger.log(
+            TRACE,
+            "cp_isolation is set. use this flag for debugging purpose. "
+            "limited list of encoding allowed : %s.",
+            ", ".join(cp_isolation),
+        )
+        cp_isolation = [iana_name(cp, False) for cp in cp_isolation]
+    else:
+        cp_isolation = []
+
+    if cp_exclusion is not None:
+        logger.log(
+            TRACE,
+            "cp_exclusion is set. use this flag for debugging purpose. "
+            "limited list of encoding excluded : %s.",
+            ", ".join(cp_exclusion),
+        )
+        cp_exclusion = [iana_name(cp, False) for cp in cp_exclusion]
+    else:
+        cp_exclusion = []
+
+    if length <= (chunk_size * steps):
+        logger.log(
+            TRACE,
+            "override steps (%i) and chunk_size (%i) as content does not fit (%i byte(s) given) parameters.",
+            steps,
+            chunk_size,
+            length,
+        )
+        steps = 1
+        chunk_size = length
+
+    if steps > 1 and length / steps < chunk_size:
+        chunk_size = int(length / steps)
+
+    is_too_small_sequence = len(sequences) < TOO_SMALL_SEQUENCE  # type: bool
+    is_too_large_sequence = len(sequences) >= TOO_BIG_SEQUENCE  # type: bool
+
+    if is_too_small_sequence:
+        logger.log(
+            TRACE,
+            "Trying to detect encoding from a tiny portion of ({}) byte(s).".format(
+                length
+            ),
+        )
+    elif is_too_large_sequence:
+        logger.log(
+            TRACE,
+            "Using lazy str decoding because the payload is quite large, ({}) byte(s).".format(
+                length
+            ),
+        )
+
+    prioritized_encodings = []  # type: List[str]
+
+    specified_encoding = (
+        any_specified_encoding(sequences) if preemptive_behaviour else None
+    )  # type: Optional[str]
+
+    if specified_encoding is not None:
+        prioritized_encodings.append(specified_encoding)
+        logger.log(
+            TRACE,
+            "Detected declarative mark in sequence. Priority +1 given for %s.",
+            specified_encoding,
+        )
+
+    tested = set()  # type: Set[str]
+    tested_but_hard_failure = []  # type: List[str]
+    tested_but_soft_failure = []  # type: List[str]
+
+    fallback_ascii = None  # type: Optional[CharsetMatch]
+    fallback_u8 = None  # type: Optional[CharsetMatch]
+    fallback_specified = None  # type: Optional[CharsetMatch]
+
+    results = CharsetMatches()  # type: CharsetMatches
+
+    sig_encoding, sig_payload = identify_sig_or_bom(sequences)
+
+    if sig_encoding is not None:
+        prioritized_encodings.append(sig_encoding)
+        logger.log(
+            TRACE,
+            "Detected a SIG or BOM mark on first %i byte(s). Priority +1 given for %s.",
+            len(sig_payload),
+            sig_encoding,
+        )
+
+    prioritized_encodings.append("ascii")
+
+    if "utf_8" not in prioritized_encodings:
+        prioritized_encodings.append("utf_8")
+
+    for encoding_iana in prioritized_encodings + IANA_SUPPORTED:
+
+        if cp_isolation and encoding_iana not in cp_isolation:
+            continue
+
+        if cp_exclusion and encoding_iana in cp_exclusion:
+            continue
+
+        if encoding_iana in tested:
+            continue
+
+        tested.add(encoding_iana)
+
+        decoded_payload = None  # type: Optional[str]
+        bom_or_sig_available = sig_encoding == encoding_iana  # type: bool
+        strip_sig_or_bom = bom_or_sig_available and should_strip_sig_or_bom(
+            encoding_iana
+        )  # type: bool
+
+        if encoding_iana in {"utf_16", "utf_32"} and not bom_or_sig_available:
+            logger.log(
+                TRACE,
+                "Encoding %s wont be tested as-is because it require a BOM. Will try some sub-encoder LE/BE.",
+                encoding_iana,
+            )
+            continue
+
+        try:
+            is_multi_byte_decoder = is_multi_byte_encoding(encoding_iana)  # type: bool
+        except (ModuleNotFoundError, ImportError):
+            logger.log(
+                TRACE,
+                "Encoding %s does not provide an IncrementalDecoder",
+                encoding_iana,
+            )
+            continue
+
+        try:
+            if is_too_large_sequence and is_multi_byte_decoder is False:
+                str(
+                    sequences[: int(50e4)]
+                    if strip_sig_or_bom is False
+                    else sequences[len(sig_payload) : int(50e4)],
+                    encoding=encoding_iana,
+                )
+            else:
+                decoded_payload = str(
+                    sequences
+                    if strip_sig_or_bom is False
+                    else sequences[len(sig_payload) :],
+                    encoding=encoding_iana,
+                )
+        except (UnicodeDecodeError, LookupError) as e:
+            if not isinstance(e, LookupError):
+                logger.log(
+                    TRACE,
+                    "Code page %s does not fit given bytes sequence at ALL. %s",
+                    encoding_iana,
+                    str(e),
+                )
+            tested_but_hard_failure.append(encoding_iana)
+            continue
+
+        similar_soft_failure_test = False  # type: bool
+
+        for encoding_soft_failed in tested_but_soft_failure:
+            if is_cp_similar(encoding_iana, encoding_soft_failed):
+                similar_soft_failure_test = True
+                break
+
+        if similar_soft_failure_test:
+            logger.log(
+                TRACE,
+                "%s is deemed too similar to code page %s and was consider unsuited already. Continuing!",
+                encoding_iana,
+                encoding_soft_failed,
+            )
+            continue
+
+        r_ = range(
+            0 if not bom_or_sig_available else len(sig_payload),
+            length,
+            int(length / steps),
+        )
+
+        multi_byte_bonus = (
+            is_multi_byte_decoder
+            and decoded_payload is not None
+            and len(decoded_payload) < length
+        )  # type: bool
+
+        if multi_byte_bonus:
+            logger.log(
+                TRACE,
+                "Code page %s is a multi byte encoding table and it appear that at least one character "
+                "was encoded using n-bytes.",
+                encoding_iana,
+            )
+
+        max_chunk_gave_up = int(len(r_) / 4)  # type: int
+
+        max_chunk_gave_up = max(max_chunk_gave_up, 2)
+        early_stop_count = 0  # type: int
+        lazy_str_hard_failure = False
+
+        md_chunks = []  # type: List[str]
+        md_ratios = []
+
+        for i in r_:
+            if i + chunk_size > length + 8:
+                continue
+
+            cut_sequence = sequences[i : i + chunk_size]
+
+            if bom_or_sig_available and strip_sig_or_bom is False:
+                cut_sequence = sig_payload + cut_sequence
+
+            try:
+                chunk = cut_sequence.decode(
+                    encoding_iana,
+                    errors="ignore" if is_multi_byte_decoder else "strict",
+                )  # type: str
+            except UnicodeDecodeError as e:  # Lazy str loading may have missed something there
+                logger.log(
+                    TRACE,
+                    "LazyStr Loading: After MD chunk decode, code page %s does not fit given bytes sequence at ALL. %s",
+                    encoding_iana,
+                    str(e),
+                )
+                early_stop_count = max_chunk_gave_up
+                lazy_str_hard_failure = True
+                break
+
+            # multi-byte bad cutting detector and adjustment
+            # not the cleanest way to perform that fix but clever enough for now.
+            if is_multi_byte_decoder and i > 0 and sequences[i] >= 0x80:
+
+                chunk_partial_size_chk = min(chunk_size, 16)  # type: int
+
+                if (
+                    decoded_payload
+                    and chunk[:chunk_partial_size_chk] not in decoded_payload
+                ):
+                    for j in range(i, i - 4, -1):
+                        cut_sequence = sequences[j : i + chunk_size]
+
+                        if bom_or_sig_available and strip_sig_or_bom is False:
+                            cut_sequence = sig_payload + cut_sequence
+
+                        chunk = cut_sequence.decode(encoding_iana, errors="ignore")
+
+                        if chunk[:chunk_partial_size_chk] in decoded_payload:
+                            break
+
+            md_chunks.append(chunk)
+
+            md_ratios.append(mess_ratio(chunk, threshold))
+
+            if md_ratios[-1] >= threshold:
+                early_stop_count += 1
+
+            if (early_stop_count >= max_chunk_gave_up) or (
+                bom_or_sig_available and strip_sig_or_bom is False
+            ):
+                break
+
+        # We might want to check the sequence again with the whole content
+        # Only if initial MD tests passes
+        if (
+            not lazy_str_hard_failure
+            and is_too_large_sequence
+            and not is_multi_byte_decoder
+        ):
+            try:
+                sequences[int(50e3) :].decode(encoding_iana, errors="strict")
+            except UnicodeDecodeError as e:
+                logger.log(
+                    TRACE,
+                    "LazyStr Loading: After final lookup, code page %s does not fit given bytes sequence at ALL. %s",
+                    encoding_iana,
+                    str(e),
+                )
+                tested_but_hard_failure.append(encoding_iana)
+                continue
+
+        mean_mess_ratio = (
+            sum(md_ratios) / len(md_ratios) if md_ratios else 0.0
+        )  # type: float
+        if mean_mess_ratio >= threshold or early_stop_count >= max_chunk_gave_up:
+            tested_but_soft_failure.append(encoding_iana)
+            logger.log(
+                TRACE,
+                "%s was excluded because of initial chaos probing. Gave up %i time(s). "
+                "Computed mean chaos is %f %%.",
+                encoding_iana,
+                early_stop_count,
+                round(mean_mess_ratio * 100, ndigits=3),
+            )
+            # Preparing those fallbacks in case we got nothing.
+            if (
+                encoding_iana in ["ascii", "utf_8", specified_encoding]
+                and not lazy_str_hard_failure
+            ):
+                fallback_entry = CharsetMatch(
+                    sequences, encoding_iana, threshold, False, [], decoded_payload
+                )
+                if encoding_iana == specified_encoding:
+                    fallback_specified = fallback_entry
+                elif encoding_iana == "ascii":
+                    fallback_ascii = fallback_entry
+                else:
+                    fallback_u8 = fallback_entry
+            continue
+
+        logger.log(
+            TRACE,
+            "%s passed initial chaos probing. Mean measured chaos is %f %%",
+            encoding_iana,
+            round(mean_mess_ratio * 100, ndigits=3),
+        )
+
+        if not is_multi_byte_decoder:
+            target_languages = encoding_languages(encoding_iana)  # type: List[str]
+        else:
+            target_languages = mb_encoding_languages(encoding_iana)
+
+        if target_languages:
+            logger.log(
+                TRACE,
+                "{} should target any language(s) of {}".format(
+                    encoding_iana, str(target_languages)
+                ),
+            )
+
+        cd_ratios = []
+
+        # We shall skip the CD when its about ASCII
+        # Most of the time its not relevant to run "language-detection" on it.
+        if encoding_iana != "ascii":
+            for chunk in md_chunks:
+                chunk_languages = coherence_ratio(
+                    chunk, 0.1, ",".join(target_languages) if target_languages else None
+                )
+
+                cd_ratios.append(chunk_languages)
+
+        cd_ratios_merged = merge_coherence_ratios(cd_ratios)
+
+        if cd_ratios_merged:
+            logger.log(
+                TRACE,
+                "We detected language {} using {}".format(
+                    cd_ratios_merged, encoding_iana
+                ),
+            )
+
+        results.append(
+            CharsetMatch(
+                sequences,
+                encoding_iana,
+                mean_mess_ratio,
+                bom_or_sig_available,
+                cd_ratios_merged,
+                decoded_payload,
+            )
+        )
+
+        if (
+            encoding_iana in [specified_encoding, "ascii", "utf_8"]
+            and mean_mess_ratio < 0.1
+        ):
+            logger.debug(
+                "Encoding detection: %s is most likely the one.", encoding_iana
+            )
+            if explain:
+                logger.removeHandler(explain_handler)
+                logger.setLevel(previous_logger_level)
+            return CharsetMatches([results[encoding_iana]])
+
+        if encoding_iana == sig_encoding:
+            logger.debug(
+                "Encoding detection: %s is most likely the one as we detected a BOM or SIG within "
+                "the beginning of the sequence.",
+                encoding_iana,
+            )
+            if explain:
+                logger.removeHandler(explain_handler)
+                logger.setLevel(previous_logger_level)
+            return CharsetMatches([results[encoding_iana]])
+
+    if len(results) == 0:
+        if fallback_u8 or fallback_ascii or fallback_specified:
+            logger.log(
+                TRACE,
+                "Nothing got out of the detection process. Using ASCII/UTF-8/Specified fallback.",
+            )
+
+        if fallback_specified:
+            logger.debug(
+                "Encoding detection: %s will be used as a fallback match",
+                fallback_specified.encoding,
+            )
+            results.append(fallback_specified)
+        elif (
+            (fallback_u8 and fallback_ascii is None)
+            or (
+                fallback_u8
+                and fallback_ascii
+                and fallback_u8.fingerprint != fallback_ascii.fingerprint
+            )
+            or (fallback_u8 is not None)
+        ):
+            logger.debug("Encoding detection: utf_8 will be used as a fallback match")
+            results.append(fallback_u8)
+        elif fallback_ascii:
+            logger.debug("Encoding detection: ascii will be used as a fallback match")
+            results.append(fallback_ascii)
+
+    if results:
+        logger.debug(
+            "Encoding detection: Found %s as plausible (best-candidate) for content. With %i alternatives.",
+            results.best().encoding,  # type: ignore
+            len(results) - 1,
+        )
+    else:
+        logger.debug("Encoding detection: Unable to determine any suitable charset.")
+
+    if explain:
+        logger.removeHandler(explain_handler)
+        logger.setLevel(previous_logger_level)
+
+    return results
+
+
+def from_fp(
+    fp: BinaryIO,
+    steps: int = 5,
+    chunk_size: int = 512,
+    threshold: float = 0.20,
+    cp_isolation: List[str] = None,
+    cp_exclusion: List[str] = None,
+    preemptive_behaviour: bool = True,
+    explain: bool = False,
+) -> CharsetMatches:
+    """
+    Same thing than the function from_bytes but using a file pointer that is already ready.
+    Will not close the file pointer.
+    """
+    return from_bytes(
+        fp.read(),
+        steps,
+        chunk_size,
+        threshold,
+        cp_isolation,
+        cp_exclusion,
+        preemptive_behaviour,
+        explain,
+    )
+
+
+def from_path(
+    path: PathLike,
+    steps: int = 5,
+    chunk_size: int = 512,
+    threshold: float = 0.20,
+    cp_isolation: List[str] = None,
+    cp_exclusion: List[str] = None,
+    preemptive_behaviour: bool = True,
+    explain: bool = False,
+) -> CharsetMatches:
+    """
+    Same thing than the function from_bytes but with one extra step. Opening and reading given file path in binary mode.
+    Can raise IOError.
+    """
+    with open(path, "rb") as fp:
+        return from_fp(
+            fp,
+            steps,
+            chunk_size,
+            threshold,
+            cp_isolation,
+            cp_exclusion,
+            preemptive_behaviour,
+            explain,
+        )
+
+
+def normalize(
+    path: PathLike,
+    steps: int = 5,
+    chunk_size: int = 512,
+    threshold: float = 0.20,
+    cp_isolation: List[str] = None,
+    cp_exclusion: List[str] = None,
+    preemptive_behaviour: bool = True,
+) -> CharsetMatch:
+    """
+    Take a (text-based) file path and try to create another file next to it, this time using UTF-8.
+    """
+    results = from_path(
+        path,
+        steps,
+        chunk_size,
+        threshold,
+        cp_isolation,
+        cp_exclusion,
+        preemptive_behaviour,
+    )
+
+    filename = basename(path)
+    target_extensions = list(splitext(filename))
+
+    if len(results) == 0:
+        raise IOError(
+            'Unable to normalize "{}", no encoding charset seems to fit.'.format(
+                filename
+            )
+        )
+
+    result = results.best()
+
+    target_extensions[0] += "-" + result.encoding  # type: ignore
+
+    with open(
+        "{}".format(str(path).replace(filename, "".join(target_extensions))), "wb"
+    ) as fp:
+        fp.write(result.output())  # type: ignore
+
+    return result  # type: ignore

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/charset_normalizer/cd.py

@@ -0,0 +1,340 @@
+import importlib
+from codecs import IncrementalDecoder
+from collections import Counter, OrderedDict
+from functools import lru_cache
+from typing import Dict, List, Optional, Tuple
+
+from .assets import FREQUENCIES
+from .constant import KO_NAMES, LANGUAGE_SUPPORTED_COUNT, TOO_SMALL_SEQUENCE, ZH_NAMES
+from .md import is_suspiciously_successive_range
+from .models import CoherenceMatches
+from .utils import (
+    is_accentuated,
+    is_latin,
+    is_multi_byte_encoding,
+    is_unicode_range_secondary,
+    unicode_range,
+)
+
+
+def encoding_unicode_range(iana_name: str) -> List[str]:
+    """
+    Return associated unicode ranges in a single byte code page.
+    """
+    if is_multi_byte_encoding(iana_name):
+        raise IOError("Function not supported on multi-byte code page")
+
+    decoder = importlib.import_module("encodings.{}".format(iana_name)).IncrementalDecoder  # type: ignore
+
+    p = decoder(errors="ignore")  # type: IncrementalDecoder
+    seen_ranges = {}  # type: Dict[str, int]
+    character_count = 0  # type: int
+
+    for i in range(0x40, 0xFF):
+        chunk = p.decode(bytes([i]))  # type: str
+
+        if chunk:
+            character_range = unicode_range(chunk)  # type: Optional[str]
+
+            if character_range is None:
+                continue
+
+            if is_unicode_range_secondary(character_range) is False:
+                if character_range not in seen_ranges:
+                    seen_ranges[character_range] = 0
+                seen_ranges[character_range] += 1
+                character_count += 1
+
+    return sorted(
+        [
+            character_range
+            for character_range in seen_ranges
+            if seen_ranges[character_range] / character_count >= 0.15
+        ]
+    )
+
+
+def unicode_range_languages(primary_range: str) -> List[str]:
+    """
+    Return inferred languages used with a unicode range.
+    """
+    languages = []  # type: List[str]
+
+    for language, characters in FREQUENCIES.items():
+        for character in characters:
+            if unicode_range(character) == primary_range:
+                languages.append(language)
+                break
+
+    return languages
+
+
+@lru_cache()
+def encoding_languages(iana_name: str) -> List[str]:
+    """
+    Single-byte encoding language association. Some code page are heavily linked to particular language(s).
+    This function does the correspondence.
+    """
+    unicode_ranges = encoding_unicode_range(iana_name)  # type: List[str]
+    primary_range = None  # type: Optional[str]
+
+    for specified_range in unicode_ranges:
+        if "Latin" not in specified_range:
+            primary_range = specified_range
+            break
+
+    if primary_range is None:
+        return ["Latin Based"]
+
+    return unicode_range_languages(primary_range)
+
+
+@lru_cache()
+def mb_encoding_languages(iana_name: str) -> List[str]:
+    """
+    Multi-byte encoding language association. Some code page are heavily linked to particular language(s).
+    This function does the correspondence.
+    """
+    if (
+        iana_name.startswith("shift_")
+        or iana_name.startswith("iso2022_jp")
+        or iana_name.startswith("euc_j")
+        or iana_name == "cp932"
+    ):
+        return ["Japanese"]
+    if iana_name.startswith("gb") or iana_name in ZH_NAMES:
+        return ["Chinese", "Classical Chinese"]
+    if iana_name.startswith("iso2022_kr") or iana_name in KO_NAMES:
+        return ["Korean"]
+
+    return []
+
+
+@lru_cache(maxsize=LANGUAGE_SUPPORTED_COUNT)
+def get_target_features(language: str) -> Tuple[bool, bool]:
+    """
+    Determine main aspects from a supported language if it contains accents and if is pure Latin.
+    """
+    target_have_accents = False  # type: bool
+    target_pure_latin = True  # type: bool
+
+    for character in FREQUENCIES[language]:
+        if not target_have_accents and is_accentuated(character):
+            target_have_accents = True
+        if target_pure_latin and is_latin(character) is False:
+            target_pure_latin = False
+
+    return target_have_accents, target_pure_latin
+
+
+def alphabet_languages(
+    characters: List[str], ignore_non_latin: bool = False
+) -> List[str]:
+    """
+    Return associated languages associated to given characters.
+    """
+    languages = []  # type: List[Tuple[str, float]]
+
+    source_have_accents = any(is_accentuated(character) for character in characters)
+
+    for language, language_characters in FREQUENCIES.items():
+
+        target_have_accents, target_pure_latin = get_target_features(language)
+
+        if ignore_non_latin and target_pure_latin is False:
+            continue
+
+        if target_have_accents is False and source_have_accents:
+            continue
+
+        character_count = len(language_characters)  # type: int
+
+        character_match_count = len(
+            [c for c in language_characters if c in characters]
+        )  # type: int
+
+        ratio = character_match_count / character_count  # type: float
+
+        if ratio >= 0.2:
+            languages.append((language, ratio))
+
+    languages = sorted(languages, key=lambda x: x[1], reverse=True)
+
+    return [compatible_language[0] for compatible_language in languages]
+
+
+def characters_popularity_compare(
+    language: str, ordered_characters: List[str]
+) -> float:
+    """
+    Determine if a ordered characters list (by occurrence from most appearance to rarest) match a particular language.
+    The result is a ratio between 0. (absolutely no correspondence) and 1. (near perfect fit).
+    Beware that is function is not strict on the match in order to ease the detection. (Meaning close match is 1.)
+    """
+    if language not in FREQUENCIES:
+        raise ValueError("{} not available".format(language))
+
+    character_approved_count = 0  # type: int
+
+    for character in ordered_characters:
+        if character not in FREQUENCIES[language]:
+            continue
+
+        characters_before_source = FREQUENCIES[language][
+            0 : FREQUENCIES[language].index(character)
+        ]  # type: List[str]
+        characters_after_source = FREQUENCIES[language][
+            FREQUENCIES[language].index(character) :
+        ]  # type: List[str]
+
+        characters_before = ordered_characters[
+            0 : ordered_characters.index(character)
+        ]  # type: List[str]
+        characters_after = ordered_characters[
+            ordered_characters.index(character) :
+        ]  # type: List[str]
+
+        before_match_count = [
+            e in characters_before for e in characters_before_source
+        ].count(
+            True
+        )  # type: int
+        after_match_count = [
+            e in characters_after for e in characters_after_source
+        ].count(
+            True
+        )  # type: int
+
+        if len(characters_before_source) == 0 and before_match_count <= 4:
+            character_approved_count += 1
+            continue
+
+        if len(characters_after_source) == 0 and after_match_count <= 4:
+            character_approved_count += 1
+            continue
+
+        if (
+            before_match_count / len(characters_before_source) >= 0.4
+            or after_match_count / len(characters_after_source) >= 0.4
+        ):
+            character_approved_count += 1
+            continue
+
+    return character_approved_count / len(ordered_characters)
+
+
+def alpha_unicode_split(decoded_sequence: str) -> List[str]:
+    """
+    Given a decoded text sequence, return a list of str. Unicode range / alphabet separation.
+    Ex. a text containing English/Latin with a bit a Hebrew will return two items in the resulting list;
+    One containing the latin letters and the other hebrew.
+    """
+    layers = OrderedDict()  # type: Dict[str, str]
+
+    for character in decoded_sequence:
+        if character.isalpha() is False:
+            continue
+
+        character_range = unicode_range(character)  # type: Optional[str]
+
+        if character_range is None:
+            continue
+
+        layer_target_range = None  # type: Optional[str]
+
+        for discovered_range in layers:
+            if (
+                is_suspiciously_successive_range(discovered_range, character_range)
+                is False
+            ):
+                layer_target_range = discovered_range
+                break
+
+        if layer_target_range is None:
+            layer_target_range = character_range
+
+        if layer_target_range not in layers:
+            layers[layer_target_range] = character.lower()
+            continue
+
+        layers[layer_target_range] += character.lower()
+
+    return list(layers.values())
+
+
+def merge_coherence_ratios(results: List[CoherenceMatches]) -> CoherenceMatches:
+    """
+    This function merge results previously given by the function coherence_ratio.
+    The return type is the same as coherence_ratio.
+    """
+    per_language_ratios = OrderedDict()  # type: Dict[str, List[float]]
+    for result in results:
+        for sub_result in result:
+            language, ratio = sub_result
+            if language not in per_language_ratios:
+                per_language_ratios[language] = [ratio]
+                continue
+            per_language_ratios[language].append(ratio)
+
+    merge = [
+        (
+            language,
+            round(
+                sum(per_language_ratios[language]) / len(per_language_ratios[language]),
+                4,
+            ),
+        )
+        for language in per_language_ratios
+    ]
+
+    return sorted(merge, key=lambda x: x[1], reverse=True)
+
+
+@lru_cache(maxsize=2048)
+def coherence_ratio(
+    decoded_sequence: str, threshold: float = 0.1, lg_inclusion: Optional[str] = None
+) -> CoherenceMatches:
+    """
+    Detect ANY language that can be identified in given sequence. The sequence will be analysed by layers.
+    A layer = Character extraction by alphabets/ranges.
+    """
+
+    results = []  # type: List[Tuple[str, float]]
+    ignore_non_latin = False  # type: bool
+
+    sufficient_match_count = 0  # type: int
+
+    lg_inclusion_list = lg_inclusion.split(",") if lg_inclusion is not None else []
+    if "Latin Based" in lg_inclusion_list:
+        ignore_non_latin = True
+        lg_inclusion_list.remove("Latin Based")
+
+    for layer in alpha_unicode_split(decoded_sequence):
+        sequence_frequencies = Counter(layer)  # type: Counter
+        most_common = sequence_frequencies.most_common()
+
+        character_count = sum(o for c, o in most_common)  # type: int
+
+        if character_count <= TOO_SMALL_SEQUENCE:
+            continue
+
+        popular_character_ordered = [c for c, o in most_common]  # type: List[str]
+
+        for language in lg_inclusion_list or alphabet_languages(
+            popular_character_ordered, ignore_non_latin
+        ):
+            ratio = characters_popularity_compare(
+                language, popular_character_ordered
+            )  # type: float
+
+            if ratio < threshold:
+                continue
+            elif ratio >= 0.8:
+                sufficient_match_count += 1
+
+            results.append((language, round(ratio, 4)))
+
+            if sufficient_match_count >= 3:
+                break
+
+    return sorted(results, key=lambda x: x[1], reverse=True)

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/charset_normalizer/legacy.py

@@ -0,0 +1,95 @@
+import warnings
+from typing import Dict, Optional, Union
+
+from .api import from_bytes, from_fp, from_path, normalize
+from .constant import CHARDET_CORRESPONDENCE
+from .models import CharsetMatch, CharsetMatches
+
+
+def detect(byte_str: bytes) -> Dict[str, Optional[Union[str, float]]]:
+    """
+    chardet legacy method
+    Detect the encoding of the given byte string. It should be mostly backward-compatible.
+    Encoding name will match Chardet own writing whenever possible. (Not on encoding name unsupported by it)
+    This function is deprecated and should be used to migrate your project easily, consult the documentation for
+    further information. Not planned for removal.
+
+    :param byte_str:     The byte sequence to examine.
+    """
+    if not isinstance(byte_str, (bytearray, bytes)):
+        raise TypeError(  # pragma: nocover
+            "Expected object of type bytes or bytearray, got: "
+            "{0}".format(type(byte_str))
+        )
+
+    if isinstance(byte_str, bytearray):
+        byte_str = bytes(byte_str)
+
+    r = from_bytes(byte_str).best()
+
+    encoding = r.encoding if r is not None else None
+    language = r.language if r is not None and r.language != "Unknown" else ""
+    confidence = 1.0 - r.chaos if r is not None else None
+
+    # Note: CharsetNormalizer does not return 'UTF-8-SIG' as the sig get stripped in the detection/normalization process
+    # but chardet does return 'utf-8-sig' and it is a valid codec name.
+    if r is not None and encoding == "utf_8" and r.bom:
+        encoding += "_sig"
+
+    return {
+        "encoding": encoding
+        if encoding not in CHARDET_CORRESPONDENCE
+        else CHARDET_CORRESPONDENCE[encoding],
+        "language": language,
+        "confidence": confidence,
+    }
+
+
+class CharsetNormalizerMatch(CharsetMatch):
+    pass
+
+
+class CharsetNormalizerMatches(CharsetMatches):
+    @staticmethod
+    def from_fp(*args, **kwargs):  # type: ignore
+        warnings.warn(  # pragma: nocover
+            "staticmethod from_fp, from_bytes, from_path and normalize are deprecated "
+            "and scheduled to be removed in 3.0",
+            DeprecationWarning,
+        )
+        return from_fp(*args, **kwargs)  # pragma: nocover
+
+    @staticmethod
+    def from_bytes(*args, **kwargs):  # type: ignore
+        warnings.warn(  # pragma: nocover
+            "staticmethod from_fp, from_bytes, from_path and normalize are deprecated "
+            "and scheduled to be removed in 3.0",
+            DeprecationWarning,
+        )
+        return from_bytes(*args, **kwargs)  # pragma: nocover
+
+    @staticmethod
+    def from_path(*args, **kwargs):  # type: ignore
+        warnings.warn(  # pragma: nocover
+            "staticmethod from_fp, from_bytes, from_path and normalize are deprecated "
+            "and scheduled to be removed in 3.0",
+            DeprecationWarning,
+        )
+        return from_path(*args, **kwargs)  # pragma: nocover
+
+    @staticmethod
+    def normalize(*args, **kwargs):  # type: ignore
+        warnings.warn(  # pragma: nocover
+            "staticmethod from_fp, from_bytes, from_path and normalize are deprecated "
+            "and scheduled to be removed in 3.0",
+            DeprecationWarning,
+        )
+        return normalize(*args, **kwargs)  # pragma: nocover
+
+
+class CharsetDetector(CharsetNormalizerMatches):
+    pass
+
+
+class CharsetDoctor(CharsetNormalizerMatches):
+    pass

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/charset_normalizer/models.py

@@ -0,0 +1,392 @@
+import warnings
+from collections import Counter
+from encodings.aliases import aliases
+from hashlib import sha256
+from json import dumps
+from re import sub
+from typing import Any, Dict, Iterator, List, Optional, Tuple, Union
+
+from .constant import NOT_PRINTABLE_PATTERN, TOO_BIG_SEQUENCE
+from .md import mess_ratio
+from .utils import iana_name, is_multi_byte_encoding, unicode_range
+
+
+class CharsetMatch:
+    def __init__(
+        self,
+        payload: bytes,
+        guessed_encoding: str,
+        mean_mess_ratio: float,
+        has_sig_or_bom: bool,
+        languages: "CoherenceMatches",
+        decoded_payload: Optional[str] = None,
+    ):
+        self._payload = payload  # type: bytes
+
+        self._encoding = guessed_encoding  # type: str
+        self._mean_mess_ratio = mean_mess_ratio  # type: float
+        self._languages = languages  # type: CoherenceMatches
+        self._has_sig_or_bom = has_sig_or_bom  # type: bool
+        self._unicode_ranges = None  # type: Optional[List[str]]
+
+        self._leaves = []  # type: List[CharsetMatch]
+        self._mean_coherence_ratio = 0.0  # type: float
+
+        self._output_payload = None  # type: Optional[bytes]
+        self._output_encoding = None  # type: Optional[str]
+
+        self._string = decoded_payload  # type: Optional[str]
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, CharsetMatch):
+            raise TypeError(
+                "__eq__ cannot be invoked on {} and {}.".format(
+                    str(other.__class__), str(self.__class__)
+                )
+            )
+        return self.encoding == other.encoding and self.fingerprint == other.fingerprint
+
+    def __lt__(self, other: object) -> bool:
+        """
+        Implemented to make sorted available upon CharsetMatches items.
+        """
+        if not isinstance(other, CharsetMatch):
+            raise ValueError
+
+        chaos_difference = abs(self.chaos - other.chaos)  # type: float
+        coherence_difference = abs(self.coherence - other.coherence)  # type: float
+
+        # Bellow 1% difference --> Use Coherence
+        if chaos_difference < 0.01 and coherence_difference > 0.02:
+            # When having a tough decision, use the result that decoded as many multi-byte as possible.
+            if chaos_difference == 0.0 and self.coherence == other.coherence:
+                return self.multi_byte_usage > other.multi_byte_usage
+            return self.coherence > other.coherence
+
+        return self.chaos < other.chaos
+
+    @property
+    def multi_byte_usage(self) -> float:
+        return 1.0 - len(str(self)) / len(self.raw)
+
+    @property
+    def chaos_secondary_pass(self) -> float:
+        """
+        Check once again chaos in decoded text, except this time, with full content.
+        Use with caution, this can be very slow.
+        Notice: Will be removed in 3.0
+        """
+        warnings.warn(
+            "chaos_secondary_pass is deprecated and will be removed in 3.0",
+            DeprecationWarning,
+        )
+        return mess_ratio(str(self), 1.0)
+
+    @property
+    def coherence_non_latin(self) -> float:
+        """
+        Coherence ratio on the first non-latin language detected if ANY.
+        Notice: Will be removed in 3.0
+        """
+        warnings.warn(
+            "coherence_non_latin is deprecated and will be removed in 3.0",
+            DeprecationWarning,
+        )
+        return 0.0
+
+    @property
+    def w_counter(self) -> Counter:
+        """
+        Word counter instance on decoded text.
+        Notice: Will be removed in 3.0
+        """
+        warnings.warn(
+            "w_counter is deprecated and will be removed in 3.0", DeprecationWarning
+        )
+
+        string_printable_only = sub(NOT_PRINTABLE_PATTERN, " ", str(self).lower())
+
+        return Counter(string_printable_only.split())
+
+    def __str__(self) -> str:
+        # Lazy Str Loading
+        if self._string is None:
+            self._string = str(self._payload, self._encoding, "strict")
+        return self._string
+
+    def __repr__(self) -> str:
+        return "<CharsetMatch '{}' bytes({})>".format(self.encoding, self.fingerprint)
+
+    def add_submatch(self, other: "CharsetMatch") -> None:
+        if not isinstance(other, CharsetMatch) or other == self:
+            raise ValueError(
+                "Unable to add instance <{}> as a submatch of a CharsetMatch".format(
+                    other.__class__
+                )
+            )
+
+        other._string = None  # Unload RAM usage; dirty trick.
+        self._leaves.append(other)
+
+    @property
+    def encoding(self) -> str:
+        return self._encoding
+
+    @property
+    def encoding_aliases(self) -> List[str]:
+        """
+        Encoding name are known by many name, using this could help when searching for IBM855 when it's listed as CP855.
+        """
+        also_known_as = []  # type: List[str]
+        for u, p in aliases.items():
+            if self.encoding == u:
+                also_known_as.append(p)
+            elif self.encoding == p:
+                also_known_as.append(u)
+        return also_known_as
+
+    @property
+    def bom(self) -> bool:
+        return self._has_sig_or_bom
+
+    @property
+    def byte_order_mark(self) -> bool:
+        return self._has_sig_or_bom
+
+    @property
+    def languages(self) -> List[str]:
+        """
+        Return the complete list of possible languages found in decoded sequence.
+        Usually not really useful. Returned list may be empty even if 'language' property return something != 'Unknown'.
+        """
+        return [e[0] for e in self._languages]
+
+    @property
+    def language(self) -> str:
+        """
+        Most probable language found in decoded sequence. If none were detected or inferred, the property will return
+        "Unknown".
+        """
+        if not self._languages:
+            # Trying to infer the language based on the given encoding
+            # Its either English or we should not pronounce ourselves in certain cases.
+            if "ascii" in self.could_be_from_charset:
+                return "English"
+
+            # doing it there to avoid circular import
+            from charset_normalizer.cd import encoding_languages, mb_encoding_languages
+
+            languages = (
+                mb_encoding_languages(self.encoding)
+                if is_multi_byte_encoding(self.encoding)
+                else encoding_languages(self.encoding)
+            )
+
+            if len(languages) == 0 or "Latin Based" in languages:
+                return "Unknown"
+
+            return languages[0]
+
+        return self._languages[0][0]
+
+    @property
+    def chaos(self) -> float:
+        return self._mean_mess_ratio
+
+    @property
+    def coherence(self) -> float:
+        if not self._languages:
+            return 0.0
+        return self._languages[0][1]
+
+    @property
+    def percent_chaos(self) -> float:
+        return round(self.chaos * 100, ndigits=3)
+
+    @property
+    def percent_coherence(self) -> float:
+        return round(self.coherence * 100, ndigits=3)
+
+    @property
+    def raw(self) -> bytes:
+        """
+        Original untouched bytes.
+        """
+        return self._payload
+
+    @property
+    def submatch(self) -> List["CharsetMatch"]:
+        return self._leaves
+
+    @property
+    def has_submatch(self) -> bool:
+        return len(self._leaves) > 0
+
+    @property
+    def alphabets(self) -> List[str]:
+        if self._unicode_ranges is not None:
+            return self._unicode_ranges
+        # list detected ranges
+        detected_ranges = [
+            unicode_range(char) for char in str(self)
+        ]  # type: List[Optional[str]]
+        # filter and sort
+        self._unicode_ranges = sorted(list({r for r in detected_ranges if r}))
+        return self._unicode_ranges
+
+    @property
+    def could_be_from_charset(self) -> List[str]:
+        """
+        The complete list of encoding that output the exact SAME str result and therefore could be the originating
+        encoding.
+        This list does include the encoding available in property 'encoding'.
+        """
+        return [self._encoding] + [m.encoding for m in self._leaves]
+
+    def first(self) -> "CharsetMatch":
+        """
+        Kept for BC reasons. Will be removed in 3.0.
+        """
+        return self
+
+    def best(self) -> "CharsetMatch":
+        """
+        Kept for BC reasons. Will be removed in 3.0.
+        """
+        return self
+
+    def output(self, encoding: str = "utf_8") -> bytes:
+        """
+        Method to get re-encoded bytes payload using given target encoding. Default to UTF-8.
+        Any errors will be simply ignored by the encoder NOT replaced.
+        """
+        if self._output_encoding is None or self._output_encoding != encoding:
+            self._output_encoding = encoding
+            self._output_payload = str(self).encode(encoding, "replace")
+
+        return self._output_payload  # type: ignore
+
+    @property
+    def fingerprint(self) -> str:
+        """
+        Retrieve the unique SHA256 computed using the transformed (re-encoded) payload. Not the original one.
+        """
+        return sha256(self.output()).hexdigest()
+
+
+class CharsetMatches:
+    """
+    Container with every CharsetMatch items ordered by default from most probable to the less one.
+    Act like a list(iterable) but does not implements all related methods.
+    """
+
+    def __init__(self, results: List[CharsetMatch] = None):
+        self._results = sorted(results) if results else []  # type: List[CharsetMatch]
+
+    def __iter__(self) -> Iterator[CharsetMatch]:
+        yield from self._results
+
+    def __getitem__(self, item: Union[int, str]) -> CharsetMatch:
+        """
+        Retrieve a single item either by its position or encoding name (alias may be used here).
+        Raise KeyError upon invalid index or encoding not present in results.
+        """
+        if isinstance(item, int):
+            return self._results[item]
+        if isinstance(item, str):
+            item = iana_name(item, False)
+            for result in self._results:
+                if item in result.could_be_from_charset:
+                    return result
+        raise KeyError
+
+    def __len__(self) -> int:
+        return len(self._results)
+
+    def __bool__(self) -> bool:
+        return len(self._results) > 0
+
+    def append(self, item: CharsetMatch) -> None:
+        """
+        Insert a single match. Will be inserted accordingly to preserve sort.
+        Can be inserted as a submatch.
+        """
+        if not isinstance(item, CharsetMatch):
+            raise ValueError(
+                "Cannot append instance '{}' to CharsetMatches".format(
+                    str(item.__class__)
+                )
+            )
+        # We should disable the submatch factoring when the input file is too heavy (conserve RAM usage)
+        if len(item.raw) <= TOO_BIG_SEQUENCE:
+            for match in self._results:
+                if match.fingerprint == item.fingerprint and match.chaos == item.chaos:
+                    match.add_submatch(item)
+                    return
+        self._results.append(item)
+        self._results = sorted(self._results)
+
+    def best(self) -> Optional["CharsetMatch"]:
+        """
+        Simply return the first match. Strict equivalent to matches[0].
+        """
+        if not self._results:
+            return None
+        return self._results[0]
+
+    def first(self) -> Optional["CharsetMatch"]:
+        """
+        Redundant method, call the method best(). Kept for BC reasons.
+        """
+        return self.best()
+
+
+CoherenceMatch = Tuple[str, float]
+CoherenceMatches = List[CoherenceMatch]
+
+
+class CliDetectionResult:
+    def __init__(
+        self,
+        path: str,
+        encoding: Optional[str],
+        encoding_aliases: List[str],
+        alternative_encodings: List[str],
+        language: str,
+        alphabets: List[str],
+        has_sig_or_bom: bool,
+        chaos: float,
+        coherence: float,
+        unicode_path: Optional[str],
+        is_preferred: bool,
+    ):
+        self.path = path  # type: str
+        self.unicode_path = unicode_path  # type: Optional[str]
+        self.encoding = encoding  # type: Optional[str]
+        self.encoding_aliases = encoding_aliases  # type: List[str]
+        self.alternative_encodings = alternative_encodings  # type: List[str]
+        self.language = language  # type: str
+        self.alphabets = alphabets  # type: List[str]
+        self.has_sig_or_bom = has_sig_or_bom  # type: bool
+        self.chaos = chaos  # type: float
+        self.coherence = coherence  # type: float
+        self.is_preferred = is_preferred  # type: bool
+
+    @property
+    def __dict__(self) -> Dict[str, Any]:  # type: ignore
+        return {
+            "path": self.path,
+            "encoding": self.encoding,
+            "encoding_aliases": self.encoding_aliases,
+            "alternative_encodings": self.alternative_encodings,
+            "language": self.language,
+            "alphabets": self.alphabets,
+            "has_sig_or_bom": self.has_sig_or_bom,
+            "chaos": self.chaos,
+            "coherence": self.coherence,
+            "unicode_path": self.unicode_path,
+            "is_preferred": self.is_preferred,
+        }
+
+    def to_json(self) -> str:
+        return dumps(self.__dict__, ensure_ascii=True, indent=4)

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/charset_normalizer/utils.py

@@ -0,0 +1,342 @@
+try:
+    import unicodedata2 as unicodedata
+except ImportError:
+    import unicodedata  # type: ignore[no-redef]
+
+import importlib
+import logging
+from codecs import IncrementalDecoder
+from encodings.aliases import aliases
+from functools import lru_cache
+from re import findall
+from typing import List, Optional, Set, Tuple, Union
+
+from _multibytecodec import MultibyteIncrementalDecoder  # type: ignore
+
+from .constant import (
+    ENCODING_MARKS,
+    IANA_SUPPORTED_SIMILAR,
+    RE_POSSIBLE_ENCODING_INDICATION,
+    UNICODE_RANGES_COMBINED,
+    UNICODE_SECONDARY_RANGE_KEYWORD,
+    UTF8_MAXIMAL_ALLOCATION,
+)
+
+
+@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
+def is_accentuated(character: str) -> bool:
+    try:
+        description = unicodedata.name(character)  # type: str
+    except ValueError:
+        return False
+    return (
+        "WITH GRAVE" in description
+        or "WITH ACUTE" in description
+        or "WITH CEDILLA" in description
+        or "WITH DIAERESIS" in description
+        or "WITH CIRCUMFLEX" in description
+        or "WITH TILDE" in description
+    )
+
+
+@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
+def remove_accent(character: str) -> str:
+    decomposed = unicodedata.decomposition(character)  # type: str
+    if not decomposed:
+        return character
+
+    codes = decomposed.split(" ")  # type: List[str]
+
+    return chr(int(codes[0], 16))
+
+
+@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
+def unicode_range(character: str) -> Optional[str]:
+    """
+    Retrieve the Unicode range official name from a single character.
+    """
+    character_ord = ord(character)  # type: int
+
+    for range_name, ord_range in UNICODE_RANGES_COMBINED.items():
+        if character_ord in ord_range:
+            return range_name
+
+    return None
+
+
+@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
+def is_latin(character: str) -> bool:
+    try:
+        description = unicodedata.name(character)  # type: str
+    except ValueError:
+        return False
+    return "LATIN" in description
+
+
+def is_ascii(character: str) -> bool:
+    try:
+        character.encode("ascii")
+    except UnicodeEncodeError:
+        return False
+    return True
+
+
+@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
+def is_punctuation(character: str) -> bool:
+    character_category = unicodedata.category(character)  # type: str
+
+    if "P" in character_category:
+        return True
+
+    character_range = unicode_range(character)  # type: Optional[str]
+
+    if character_range is None:
+        return False
+
+    return "Punctuation" in character_range
+
+
+@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
+def is_symbol(character: str) -> bool:
+    character_category = unicodedata.category(character)  # type: str
+
+    if "S" in character_category or "N" in character_category:
+        return True
+
+    character_range = unicode_range(character)  # type: Optional[str]
+
+    if character_range is None:
+        return False
+
+    return "Forms" in character_range
+
+
+@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
+def is_emoticon(character: str) -> bool:
+    character_range = unicode_range(character)  # type: Optional[str]
+
+    if character_range is None:
+        return False
+
+    return "Emoticons" in character_range
+
+
+@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
+def is_separator(character: str) -> bool:
+    if character.isspace() or character in {"｜", "+", ",", ";", "<", ">"}:
+        return True
+
+    character_category = unicodedata.category(character)  # type: str
+
+    return "Z" in character_category
+
+
+@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
+def is_case_variable(character: str) -> bool:
+    return character.islower() != character.isupper()
+
+
+def is_private_use_only(character: str) -> bool:
+    character_category = unicodedata.category(character)  # type: str
+
+    return character_category == "Co"
+
+
+@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
+def is_cjk(character: str) -> bool:
+    try:
+        character_name = unicodedata.name(character)
+    except ValueError:
+        return False
+
+    return "CJK" in character_name
+
+
+@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
+def is_hiragana(character: str) -> bool:
+    try:
+        character_name = unicodedata.name(character)
+    except ValueError:
+        return False
+
+    return "HIRAGANA" in character_name
+
+
+@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
+def is_katakana(character: str) -> bool:
+    try:
+        character_name = unicodedata.name(character)
+    except ValueError:
+        return False
+
+    return "KATAKANA" in character_name
+
+
+@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
+def is_hangul(character: str) -> bool:
+    try:
+        character_name = unicodedata.name(character)
+    except ValueError:
+        return False
+
+    return "HANGUL" in character_name
+
+
+@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
+def is_thai(character: str) -> bool:
+    try:
+        character_name = unicodedata.name(character)
+    except ValueError:
+        return False
+
+    return "THAI" in character_name
+
+
+@lru_cache(maxsize=len(UNICODE_RANGES_COMBINED))
+def is_unicode_range_secondary(range_name: str) -> bool:
+    return any(keyword in range_name for keyword in UNICODE_SECONDARY_RANGE_KEYWORD)
+
+
+def any_specified_encoding(sequence: bytes, search_zone: int = 4096) -> Optional[str]:
+    """
+    Extract using ASCII-only decoder any specified encoding in the first n-bytes.
+    """
+    if not isinstance(sequence, bytes):
+        raise TypeError
+
+    seq_len = len(sequence)  # type: int
+
+    results = findall(
+        RE_POSSIBLE_ENCODING_INDICATION,
+        sequence[: min(seq_len, search_zone)].decode("ascii", errors="ignore"),
+    )  # type: List[str]
+
+    if len(results) == 0:
+        return None
+
+    for specified_encoding in results:
+        specified_encoding = specified_encoding.lower().replace("-", "_")
+
+        for encoding_alias, encoding_iana in aliases.items():
+            if encoding_alias == specified_encoding:
+                return encoding_iana
+            if encoding_iana == specified_encoding:
+                return encoding_iana
+
+    return None
+
+
+@lru_cache(maxsize=128)
+def is_multi_byte_encoding(name: str) -> bool:
+    """
+    Verify is a specific encoding is a multi byte one based on it IANA name
+    """
+    return name in {
+        "utf_8",
+        "utf_8_sig",
+        "utf_16",
+        "utf_16_be",
+        "utf_16_le",
+        "utf_32",
+        "utf_32_le",
+        "utf_32_be",
+        "utf_7",
+    } or issubclass(
+        importlib.import_module("encodings.{}".format(name)).IncrementalDecoder,  # type: ignore
+        MultibyteIncrementalDecoder,
+    )
+
+
+def identify_sig_or_bom(sequence: bytes) -> Tuple[Optional[str], bytes]:
+    """
+    Identify and extract SIG/BOM in given sequence.
+    """
+
+    for iana_encoding in ENCODING_MARKS:
+        marks = ENCODING_MARKS[iana_encoding]  # type: Union[bytes, List[bytes]]
+
+        if isinstance(marks, bytes):
+            marks = [marks]
+
+        for mark in marks:
+            if sequence.startswith(mark):
+                return iana_encoding, mark
+
+    return None, b""
+
+
+def should_strip_sig_or_bom(iana_encoding: str) -> bool:
+    return iana_encoding not in {"utf_16", "utf_32"}
+
+
+def iana_name(cp_name: str, strict: bool = True) -> str:
+    cp_name = cp_name.lower().replace("-", "_")
+
+    for encoding_alias, encoding_iana in aliases.items():
+        if cp_name in [encoding_alias, encoding_iana]:
+            return encoding_iana
+
+    if strict:
+        raise ValueError("Unable to retrieve IANA for '{}'".format(cp_name))
+
+    return cp_name
+
+
+def range_scan(decoded_sequence: str) -> List[str]:
+    ranges = set()  # type: Set[str]
+
+    for character in decoded_sequence:
+        character_range = unicode_range(character)  # type: Optional[str]
+
+        if character_range is None:
+            continue
+
+        ranges.add(character_range)
+
+    return list(ranges)
+
+
+def cp_similarity(iana_name_a: str, iana_name_b: str) -> float:
+
+    if is_multi_byte_encoding(iana_name_a) or is_multi_byte_encoding(iana_name_b):
+        return 0.0
+
+    decoder_a = importlib.import_module("encodings.{}".format(iana_name_a)).IncrementalDecoder  # type: ignore
+    decoder_b = importlib.import_module("encodings.{}".format(iana_name_b)).IncrementalDecoder  # type: ignore
+
+    id_a = decoder_a(errors="ignore")  # type: IncrementalDecoder
+    id_b = decoder_b(errors="ignore")  # type: IncrementalDecoder
+
+    character_match_count = 0  # type: int
+
+    for i in range(255):
+        to_be_decoded = bytes([i])  # type: bytes
+        if id_a.decode(to_be_decoded) == id_b.decode(to_be_decoded):
+            character_match_count += 1
+
+    return character_match_count / 254
+
+
+def is_cp_similar(iana_name_a: str, iana_name_b: str) -> bool:
+    """
+    Determine if two code page are at least 80% similar. IANA_SUPPORTED_SIMILAR dict was generated using
+    the function cp_similarity.
+    """
+    return (
+        iana_name_a in IANA_SUPPORTED_SIMILAR
+        and iana_name_b in IANA_SUPPORTED_SIMILAR[iana_name_a]
+    )
+
+
+def set_logging_handler(
+    name: str = "charset_normalizer",
+    level: int = logging.INFO,
+    format_string: str = "%(asctime)s | %(levelname)s | %(message)s",
+) -> None:
+
+    logger = logging.getLogger(name)
+    logger.setLevel(level)
+
+    handler = logging.StreamHandler()
+    handler.setFormatter(logging.Formatter(format_string))
+    logger.addHandler(handler)

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/charset_normalizer/version.py

@@ -0,0 +1,6 @@
+"""
+Expose version
+"""
+
+__version__ = "2.0.12"
+VERSION = __version__.split(".")

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/deprecate/__init__.py

@@ -0,0 +1,18 @@
+"""
+Copyright (C) 2020-2021 Jiri Borovec <...>
+"""
+import os
+
+__version__ = "0.3.1"
+__docs__ = "Deprecation tooling"
+__author__ = "Jiri Borovec"
+__author_email__ = "jiri.borovec@fel.cvut.cz"
+__homepage__ = "https://borda.github.io/pyDeprecate"
+__source_code__ = "https://github.com/Borda/pyDeprecate"
+__license__ = 'MIT'
+
+_PATH_PACKAGE = os.path.realpath(os.path.dirname(__file__))
+_PATH_PROJECT = os.path.dirname(_PATH_PACKAGE)
+
+from deprecate.deprecation import deprecated  # noqa: F401 E402
+from deprecate.utils import void  # noqa: F401 E402

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/deprecate/deprecation.py

@@ -0,0 +1,306 @@
+"""
+Copyright (C) 2020-2021 Jiri Borovec <...>
+"""
+import inspect
+from functools import partial, wraps
+from typing import Any, Callable, Dict, List, Optional, Tuple, Union
+from warnings import warn
+
+#: Default template warning message fot redirecting callable
+TEMPLATE_WARNING_CALLABLE = (
+    "The `%(source_name)s` was deprecated since v%(deprecated_in)s in favor of `%(target_path)s`."
+    " It will be removed in v%(remove_in)s."
+)
+#: Default template warning message for chnaging argument mapping
+TEMPLATE_WARNING_ARGUMENTS = (
+    "The `%(source_name)s` uses deprecated arguments: %(argument_map)s."
+    " They were deprecated since v%(deprecated_in)s and will be removed in v%(remove_in)s."
+)
+#: Tempalte for mapping from old to new examples
+TEMPLATE_ARGUMENT_MAPPING = "`%(old_arg)s` -> `%(new_arg)s`"
+#: Default template warning message for no target func/method
+TEMPLATE_WARNING_NO_TARGET = (
+    "The `%(source_name)s` was deprecated since v%(deprecated_in)s."
+    " It will be removed in v%(remove_in)s."
+)
+
+deprecation_warning = partial(warn, category=DeprecationWarning)
+
+
+def get_func_arguments_types_defaults(func: Callable) -> List[Tuple[str, Tuple, Any]]:
+    """
+    Parse function arguments, types and default values
+
+    Args:
+        func: a function to be xeamined
+
+    Returns:
+        sequence of details for each position/keyward argument
+
+    Example:
+        >>> get_func_arguments_types_defaults(get_func_arguments_types_defaults)
+        [('func', typing.Callable, <class 'inspect._empty'>)]
+
+    """
+    func_default_params = inspect.signature(func).parameters
+    func_arg_type_val = []
+    for arg in func_default_params:
+        arg_type = func_default_params[arg].annotation
+        arg_default = func_default_params[arg].default
+        func_arg_type_val.append((arg, arg_type, arg_default))
+    return func_arg_type_val
+
+
+def _update_kwargs_with_args(func: Callable, fn_args: tuple, fn_kwargs: dict) -> dict:
+    """ Update in case any args passed move them to kwargs and add defaults
+
+    Args:
+        func: particular function
+        fn_args: function position arguments
+        fn_kwargs: function keyword arguments
+
+    Returns:
+        extended dictionary with all args as keyword arguments
+
+    """
+    if not fn_args:
+        return fn_kwargs
+    func_arg_type_val = get_func_arguments_types_defaults(func)
+    # parse only the argument names
+    arg_names = [arg[0] for arg in func_arg_type_val]
+    # convert args to kwargs
+    fn_kwargs.update(dict(zip(arg_names, fn_args)))
+    return fn_kwargs
+
+
+def _update_kwargs_with_defaults(func: Callable, fn_kwargs: dict) -> dict:
+    """ Update in case any args passed move them to kwargs and add defaults
+
+    Args:
+        func: particular function
+        fn_kwargs: function keyword arguments
+
+    Returns:
+        extended dictionary with all args as keyword arguments
+
+    """
+    func_arg_type_val = get_func_arguments_types_defaults(func)
+    # fill by source defaults
+    fn_defaults = {arg[0]: arg[2] for arg in func_arg_type_val if arg[2] != inspect._empty}  # type: ignore
+    fn_kwargs = dict(list(fn_defaults.items()) + list(fn_kwargs.items()))
+    return fn_kwargs
+
+
+def _raise_warn(
+    stream: Callable,
+    source: Callable,
+    template_mgs: str,
+    **extras: str,
+) -> None:
+    """Raise deprecation warning with in given stream ...
+
+    Args:
+        stream: a function which takes message as the only position argument
+        source: function/methods which is wrapped
+        template_mgs: python formatted string message which has build-ins arguments
+        extras: string arguments used in the template message
+    """
+    source_name = source.__qualname__.split('.')[-2] if source.__name__ == "__init__" else source.__name__
+    source_path = f'{source.__module__}.{source_name}'
+    msg_args = dict(
+        source_name=source_name,
+        source_path=source_path,
+        **extras,
+    )
+    stream(template_mgs % msg_args)
+
+
+def _raise_warn_callable(
+    stream: Callable,
+    source: Callable,
+    target: Union[None, bool, Callable],
+    deprecated_in: str,
+    remove_in: str,
+    template_mgs: Optional[str] = None,
+) -> None:
+    """
+    Raise deprecation warning with in given stream, redirecting callables
+
+    Args:
+        stream: a function which takes message as the only position argument
+        source: function/methods which is wrapped
+        target: function/methods which is mapping target
+        deprecated_in: set version when source is deprecated
+        remove_in: set version when source will be removed
+        template_mgs: python formatted string message which has build-ins arguments:
+
+            - ``source_name`` just the functions name such as "my_source_func"
+            - ``source_path`` pythonic path to the function such as "my_package.with_module.my_source_func"
+            - ``target_name`` just the functions name such as "my_target_func"
+            - ``target_path`` pythonic path to the function such as "any_package.with_module.my_target_func"
+            - ``deprecated_in`` version passed to wrapper
+            - ``remove_in`` version passed to wrapper
+
+    """
+    if callable(target):
+        target_name = target.__name__
+        target_path = f'{target.__module__}.{target_name}'
+        template_mgs = template_mgs or TEMPLATE_WARNING_CALLABLE
+    else:
+        target_name, target_path = "", ""
+        template_mgs = template_mgs or TEMPLATE_WARNING_NO_TARGET
+    _raise_warn(
+        stream,
+        source,
+        template_mgs,
+        deprecated_in=deprecated_in,
+        remove_in=remove_in,
+        target_name=target_name,
+        target_path=target_path
+    )
+
+
+def _raise_warn_arguments(
+    stream: Callable,
+    source: Callable,
+    arguments: Dict[str, str],
+    deprecated_in: str,
+    remove_in: str,
+    template_mgs: Optional[str] = None,
+) -> None:
+    """
+    Raise deprecation warning with in given stream, note about arguments
+
+    Args:
+        stream: a function which takes message as the only position argument
+        source: function/methods which is wrapped
+        arguments: mapping from deprecated to new arguments
+        deprecated_in: set version when source is deprecated
+        remove_in: set version when source will be removed
+        template_mgs: python formatted string message which has build-ins arguments:
+
+            - ``source_name`` just the functions name such as "my_source_func"
+            - ``source_path`` pythonic path to the function such as "my_package.with_module.my_source_func"
+            - ``argument_map`` mapping from deprecated to new argument "old_arg -> new_arg"
+            - ``deprecated_in`` version passed to wrapper
+            - ``remove_in`` version passed to wrapper
+
+    """
+    args_map = ', '.join([TEMPLATE_ARGUMENT_MAPPING % dict(old_arg=a, new_arg=b) for a, b in arguments.items()])
+    template_mgs = template_mgs or TEMPLATE_WARNING_ARGUMENTS
+    _raise_warn(stream, source, template_mgs, deprecated_in=deprecated_in, remove_in=remove_in, argument_map=args_map)
+
+
+def deprecated(
+    target: Union[bool, None, Callable],
+    deprecated_in: str = "",
+    remove_in: str = "",
+    stream: Optional[Callable] = deprecation_warning,
+    num_warns: int = 1,
+    template_mgs: Optional[str] = None,
+    args_mapping: Optional[Dict[str, str]] = None,
+    args_extra: Optional[Dict[str, Any]] = None,
+    skip_if: Union[bool, Callable] = False,
+) -> Callable:
+    """
+    Decorate a function or class ``__init__`` with warning message
+     and pass all arguments directly to the target class/method.
+
+    Args:
+        target: Function or method to forward the call. If set ``None``, no forwarding is applied and only warn.
+        deprecated_in: Define version when the wrapped function is deprecated.
+        remove_in: Define version when the wrapped function will be removed.
+        stream: Set stream for printing warning messages, by default is deprecation warning.
+            Setting ``None``, no warning is shown to user.
+        num_warns: Custom define number or warning raised. Negative value (-1) means no limit.
+        template_mgs: python formatted string message which has build-ins arguments:
+            ``source_name``, ``source_path``, ``target_name``, ``target_path``, ``deprecated_in``, ``remove_in``
+            Example of a custom message is::
+
+                "v%(deprecated_in)s: `%(source_name)s` was deprecated in favor of `%(target_path)s`."
+
+        args_mapping: Custom argument mapping argument between source and target and options to suppress some,
+            for example ``{'my_arg': 'their_arg`}`` passes "my_arg" from source as "their_arg" in target
+            or ``{'my_arg': None}`` ignores the "my_arg" from source function.
+        args_extra: Custom filling extra argument in target function, mostly if they are required
+            or your needed default is different from target one, for example ``{'their_arg': 42}``
+        skip_if: Conditional skip for this wrapper, e.g. in case of versions
+
+    Returns:
+        wrapped function pointing to the target implementation with source arguments
+
+    Raises:
+        TypeError: if there are some argument in source function which are missing in target function
+
+    """
+
+    def packing(source: Callable) -> Callable:
+
+        @wraps(source)
+        def wrapped_fn(*args: Any, **kwargs: Any) -> Any:
+            # check if user requested a skip
+            shall_skip = skip_if() if callable(skip_if) else bool(skip_if)
+            assert isinstance(shall_skip, bool), "function shall return bool"
+            if shall_skip:
+                return source(*args, **kwargs)
+
+            nb_called = getattr(wrapped_fn, '_called', 0)
+            setattr(wrapped_fn, "_called", nb_called + 1)
+            # convert args to kwargs
+            kwargs = _update_kwargs_with_args(source, args, kwargs)
+
+            reason_callable = target is None or callable(target)
+            reason_argument = {}
+            if args_mapping and target:
+                reason_argument = {a: b for a, b in args_mapping.items() if a in kwargs}
+            # short cycle with no reason for redirect
+            if not (reason_callable or reason_argument):
+                # todo: eventually warn that there is no reason to use wrapper, e.g. mapping args does not exist
+                return source(**kwargs)
+
+            # warning per argument
+            if reason_argument:
+                arg_warns = [getattr(wrapped_fn, f'_warned_{arg}', 0) for arg in reason_argument]
+                nb_warned = min(arg_warns)
+            else:
+                nb_warned = getattr(wrapped_fn, '_warned', 0)
+
+            # warn user only N times in lifetime or infinitely...
+            if stream and (num_warns < 0 or nb_warned < num_warns):
+                if reason_callable:
+                    _raise_warn_callable(stream, source, target, deprecated_in, remove_in, template_mgs)
+                    setattr(wrapped_fn, "_warned", nb_warned + 1)
+                elif reason_argument:
+                    _raise_warn_arguments(stream, source, reason_argument, deprecated_in, remove_in, template_mgs)
+                    attrib_names = [f'_warned_{arg}' for arg in reason_argument]
+                    for n in attrib_names:
+                        setattr(wrapped_fn, n, getattr(wrapped_fn, n, 0) + 1)
+
+            if reason_callable:
+                kwargs = _update_kwargs_with_defaults(source, kwargs)
+            if args_mapping and target:  # covers target as True and callable
+                # filter args which shall be skipped
+                args_skip = [arg for arg in args_mapping if not args_mapping[arg]]
+                # Look-Up-table mapping
+                kwargs = {args_mapping.get(arg, arg): val for arg, val in kwargs.items() if arg not in args_skip}
+
+            if args_extra and target:  # covers target as True and callable
+                # update target argument by extra arguments
+                kwargs.update(args_extra)
+
+            if not callable(target):
+                return source(**kwargs)
+
+            target_is_class = inspect.isclass(target)
+            target_func = target.__init__ if target_is_class else target  # type: ignore
+            target_args = [arg[0] for arg in get_func_arguments_types_defaults(target_func)]
+
+            missed = [arg for arg in kwargs if arg not in target_args]
+            if missed:
+                raise TypeError("Failed mapping, arguments missing in target source: %s" % missed)
+            # all args were already moved to kwargs
+            return target_func(**kwargs)
+
+        return wrapped_fn
+
+    return packing

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/deprecate/utils.py

@@ -0,0 +1,53 @@
+"""
+Copyright (C) 2020-2021 Jiri Borovec <...>
+"""
+import warnings
+from contextlib import contextmanager
+from typing import Any, Generator, List, Optional, Type, Union
+
+
+def _warns_repr(warns: List[warnings.WarningMessage]) -> List[Union[Warning, str]]:
+    return [w.message for w in warns]
+
+
+@contextmanager
+def no_warning_call(warning_type: Optional[Type[Warning]] = None, match: Optional[str] = None) -> Generator:
+    """
+
+    Args:
+        warning_type: specify catching warning, if None catching all
+        match: match message, containing following string, if None catches all
+
+    Raises:
+        AssertionError: if specified warning was called
+    """
+    with warnings.catch_warnings(record=True) as called:
+        # Cause all warnings to always be triggered.
+        warnings.simplefilter("always")
+        # Trigger a warning.
+        yield
+        # no warning raised
+        if not called:
+            return
+        if not warning_type:
+            raise AssertionError(f'While catching all warnings, these were found: {_warns_repr(called)}')
+        # filter warnings by type
+        warns = [w for w in called if issubclass(w.category, warning_type)]
+        # Verify some things
+        if not warns:
+            return
+        if not match:
+            raise AssertionError(
+                f'While catching `{warning_type.__name__}` warnings, these were found: {_warns_repr(warns)}'
+            )
+        found = [w for w in warns if match in w.message.__str__()]
+        if found:
+            raise AssertionError(
+                f'While catching `{warning_type.__name__}` warnings with "{match}",'
+                f' these were found: {_warns_repr(found)}'
+            )
+
+
+def void(*args: Any, **kwrgs: Any) -> Any:
+    """Empty function which does nothing, just let your IDE stop complaining about unused arguments."""
+    _, _ = args, kwrgs

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/docs/conf.py

@@ -0,0 +1,83 @@
+# Copyright 2021 The ML Collections Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Configuration file for the Sphinx documentation builder.
+#
+# This file only contains a selection of the most common options. For a full
+# list see the documentation:
+# https://www.sphinx-doc.org/en/master/usage/configuration.html
+
+# -- Path setup --------------------------------------------------------------
+
+# If extensions (or modules to document with autodoc) are in another directory,
+# add these directories to sys.path here. If the directory is relative to the
+# documentation root, use os.path.abspath to make it absolute, like shown here.
+#
+# import os
+# import sys
+# sys.path.insert(0, os.path.abspath('.'))
+
+import os
+import sys
+sys.path.insert(0, os.path.abspath('..'))
+
+# -- Project information -----------------------------------------------------
+
+project = 'ml_collections'
+copyright = '2020, The ML Collection Authors'
+author = 'The ML Collection Authors'
+
+# The full version, including alpha/beta/rc tags
+release = '0.1.0'
+
+
+# -- General configuration ---------------------------------------------------
+
+# Add any Sphinx extension module names here, as strings. They can be
+# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
+# ones.
+extensions = [
+    'sphinx.ext.autodoc',
+    'sphinx.ext.autosummary',
+    'sphinx.ext.intersphinx',
+    'sphinx.ext.mathjax',
+    'sphinx.ext.napoleon',
+    'sphinx.ext.viewcode',
+    'nbsphinx',
+    'recommonmark',
+]
+
+# Add any paths that contain templates here, relative to this directory.
+templates_path = ['_templates']
+
+# List of patterns, relative to source directory, that match files and
+# directories to ignore when looking for source files.
+# This pattern also affects html_static_path and html_extra_path.
+exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store']
+
+autosummary_generate = True
+
+master_doc = 'index'
+
+# -- Options for HTML output -------------------------------------------------
+
+# The theme to use for HTML and HTML Help pages.  See the documentation for
+# a list of builtin themes.
+#
+html_theme = 'sphinx_rtd_theme'
+
+# Add any paths that contain custom static files (such as style sheets) here,
+# relative to this directory. They are copied after the builtin static files,
+# so a file named "default.css" will overwrite the builtin "default.css".
+html_static_path = ['_static']

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/ema_pytorch-0.0.8.dist-info/INSTALLER

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

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/ema_pytorch-0.0.8.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Phil Wang
+
+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.

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/filelock-3.13.1.dist-info/INSTALLER

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

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/filelock-3.13.1.dist-info/METADATA

@@ -0,0 +1,56 @@
+Metadata-Version: 2.1
+Name: filelock
+Version: 3.13.1
+Summary: A platform independent file lock.
+Project-URL: Documentation, https://py-filelock.readthedocs.io
+Project-URL: Homepage, https://github.com/tox-dev/py-filelock
+Project-URL: Source, https://github.com/tox-dev/py-filelock
+Project-URL: Tracker, https://github.com/tox-dev/py-filelock/issues
+Maintainer-email: Bernát Gábor <gaborjbernat@gmail.com>
+License-Expression: Unlicense
+License-File: LICENSE
+Keywords: application,cache,directory,log,user
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: The Unlicense (Unlicense)
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3 :: Only
+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: Topic :: Internet
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: System
+Requires-Python: >=3.8
+Provides-Extra: docs
+Requires-Dist: furo>=2023.9.10; extra == 'docs'
+Requires-Dist: sphinx-autodoc-typehints!=1.23.4,>=1.24; extra == 'docs'
+Requires-Dist: sphinx>=7.2.6; extra == 'docs'
+Provides-Extra: testing
+Requires-Dist: covdefaults>=2.3; extra == 'testing'
+Requires-Dist: coverage>=7.3.2; extra == 'testing'
+Requires-Dist: diff-cover>=8; extra == 'testing'
+Requires-Dist: pytest-cov>=4.1; extra == 'testing'
+Requires-Dist: pytest-mock>=3.12; extra == 'testing'
+Requires-Dist: pytest-timeout>=2.2; extra == 'testing'
+Requires-Dist: pytest>=7.4.3; extra == 'testing'
+Provides-Extra: typing
+Requires-Dist: typing-extensions>=4.8; python_version < '3.11' and extra == 'typing'
+Description-Content-Type: text/markdown
+
+# filelock
+
+[![PyPI](https://img.shields.io/pypi/v/filelock)](https://pypi.org/project/filelock/)
+[![Supported Python
+versions](https://img.shields.io/pypi/pyversions/filelock.svg)](https://pypi.org/project/filelock/)
+[![Documentation
+status](https://readthedocs.org/projects/py-filelock/badge/?version=latest)](https://py-filelock.readthedocs.io/en/latest/?badge=latest)
+[![Code style:
+black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
+[![Downloads](https://static.pepy.tech/badge/filelock/month)](https://pepy.tech/project/filelock)
+[![check](https://github.com/tox-dev/py-filelock/actions/workflows/check.yml/badge.svg)](https://github.com/tox-dev/py-filelock/actions/workflows/check.yml)
+
+For more information checkout the [official documentation](https://py-filelock.readthedocs.io/en/latest/index.html).

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/filelock-3.13.1.dist-info/RECORD

@@ -0,0 +1,22 @@
+filelock-3.13.1.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+filelock-3.13.1.dist-info/METADATA,sha256=gi7LyG-dEuOBZC32wie-OOG0OkPZHABsn9rXvxuQlcA,2784
+filelock-3.13.1.dist-info/RECORD,,
+filelock-3.13.1.dist-info/WHEEL,sha256=9QBuHhg6FNW7lppboF2vKVbCGTVzsFykgRQjjlajrhA,87
+filelock-3.13.1.dist-info/licenses/LICENSE,sha256=iNm062BXnBkew5HKBMFhMFctfu3EqG2qWL8oxuFMm80,1210
+filelock/__init__.py,sha256=wAVZ_9_-3Y14xzzupRk5BTTRewFJekR2vf9oIx4M750,1213
+filelock/__pycache__/__init__.cpython-38.pyc,,
+filelock/__pycache__/_api.cpython-38.pyc,,
+filelock/__pycache__/_error.cpython-38.pyc,,
+filelock/__pycache__/_soft.cpython-38.pyc,,
+filelock/__pycache__/_unix.cpython-38.pyc,,
+filelock/__pycache__/_util.cpython-38.pyc,,
+filelock/__pycache__/_windows.cpython-38.pyc,,
+filelock/__pycache__/version.cpython-38.pyc,,
+filelock/_api.py,sha256=UsVWPEOOgFH1pR_6WMk2b5hWZ7nWhUPT5GZX9WuYaC8,11860
+filelock/_error.py,sha256=-5jMcjTu60YAvAO1UbqDD1GIEjVkwr8xCFwDBtMeYDg,787
+filelock/_soft.py,sha256=haqtc_TB_KJbYv2a8iuEAclKuM4fMG1vTcp28sK919c,1711
+filelock/_unix.py,sha256=ViG38PgJsIhT3xaArugvw0TPP6VWoP2VJj7FEIWypkg,2157
+filelock/_util.py,sha256=dBDlIj1dHL_juXX0Qqq6bZtyE53YZTN8GFhtyTV043o,1708
+filelock/_windows.py,sha256=eMKL8dZKrgekf5VYVGR14an29JGEInRtUO8ui9ABywg,2177
+filelock/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+filelock/version.py,sha256=fmajg3X8ZdOn-UpUewARwK5cfYf4wP4Xa0DcHjigFYo,413

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/filelock-3.13.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.18.0
+Root-Is-Purelib: true
+Tag: py3-none-any

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/glob2-0.7.dist-info/INSTALLER

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

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/glob2-0.7.dist-info/LICENSE

@@ -0,0 +1,27 @@
+Copyright (c) 2008, Michael Elsdörfer <http://elsdoerfer.name>
+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.
+
+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.

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/glob2-0.7.dist-info/METADATA

@@ -0,0 +1,17 @@
+Metadata-Version: 2.1
+Name: glob2
+Version: 0.7
+Summary: Version of the glob module that can capture patterns and supports recursive wildcards
+Home-page: http://github.com/miracle2k/python-glob2/
+Author: Michael Elsdoerfer
+Author-email: michael@elsdoerfer.com
+License: BSD
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Libraries
+License-File: LICENSE
+

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/glob2-0.7.dist-info/RECORD

@@ -0,0 +1,15 @@
+glob2-0.7.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+glob2-0.7.dist-info/LICENSE,sha256=mfyVVvpQ7TUZmWlxvy7Bq_n0tj8PP07RXN7oTjBhNLc,1359
+glob2-0.7.dist-info/METADATA,sha256=x0sgtwGrFtBnmOZD6uGMbiiNmWkWDQzaqR1OIoQlv2g,627
+glob2-0.7.dist-info/RECORD,,
+glob2-0.7.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+glob2-0.7.dist-info/WHEEL,sha256=Z-nyYpwrcSqxfdux5Mbn_DQ525iP7J2DG3JgGvOYyTQ,110
+glob2-0.7.dist-info/top_level.txt,sha256=LmVNT8jZb84cpRTpWn9CBoPunhq4nawIWlwXjJi2s68,6
+glob2/__init__.py,sha256=SWkdfrrElFQVNPEPy3YCNaK0Nb95Wcyb-4XADiQskqA,82
+glob2/__pycache__/__init__.cpython-38.pyc,,
+glob2/__pycache__/compat.cpython-38.pyc,,
+glob2/__pycache__/fnmatch.cpython-38.pyc,,
+glob2/__pycache__/impl.cpython-38.pyc,,
+glob2/compat.py,sha256=jRLW2AMBM4OATSUdfE3D6tpvf8Oexwiw2c0r4_npU6c,6859
+glob2/fnmatch.py,sha256=6wv-SO-Sm9MG9w95IM5wr3Zt-U_vFFHBNtjhIzO1RH0,4463
+glob2/impl.py,sha256=4paYLj3fVdJ4wR--iRUW0fUzDXYlkTSTXRV3uJEYc9Q,8304

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/glob2-0.7.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.36.2)
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any
+

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/glob2-0.7.dist-info/top_level.txt

@@ -0,0 +1 @@
+glob2

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/imageio-2.19.3.dist-info/INSTALLER

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

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/imageio-2.19.3.dist-info/LICENSE

@@ -0,0 +1,24 @@
+Copyright (c) 2014-2022, imageio 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.
+
+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.
+

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/imageio-2.19.3.dist-info/RECORD

@@ -0,0 +1,113 @@
+../../../bin/imageio_download_bin,sha256=UUAW50PLPWt4jQrKugwzR1q7LYxViUNpQHNZctfXnss,259
+../../../bin/imageio_remove_bin,sha256=wyw25HOufznctDRLJjogj37UhB9JWZYyuKUNOI9jlgk,255
+imageio-2.19.3.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+imageio-2.19.3.dist-info/LICENSE,sha256=rlmepQpJTvtyXkIKqzXR91kgDP5BhrbGSjC6Sds_0GQ,1307
+imageio-2.19.3.dist-info/METADATA,sha256=yRnqA9nRW7j1uNZjdZuAkyxS-7avpekBmLfaVybb20k,4930
+imageio-2.19.3.dist-info/RECORD,,
+imageio-2.19.3.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+imageio-2.19.3.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
+imageio-2.19.3.dist-info/entry_points.txt,sha256=wIv0WLZA9V-h0NF4ozbsQHo8Ym9-tj4lfOG6J9Pv13c,131
+imageio-2.19.3.dist-info/top_level.txt,sha256=iSUjc-wEw-xbMTvMOSKg85n0-E7Ms--Mo4FLMC-J2YM,8
+imageio/__init__.py,sha256=8IKfa2UXtNJmE8u7BY0huDJ91_8wqKwLMrwxXqP8uWA,3272
+imageio/__main__.py,sha256=s5nidb9wRZ6AbimHTPHULt3sTXPx4mqNil67KJHZvd4,5393
+imageio/__pycache__/__init__.cpython-38.pyc,,
+imageio/__pycache__/__main__.cpython-38.pyc,,
+imageio/__pycache__/freeze.cpython-38.pyc,,
+imageio/__pycache__/testing.cpython-38.pyc,,
+imageio/__pycache__/typing.cpython-38.pyc,,
+imageio/__pycache__/v2.cpython-38.pyc,,
+imageio/__pycache__/v3.cpython-38.pyc,,
+imageio/config/__init__.py,sha256=8NOpL5ePrkiioJb9hRBw3rydc4iNZkMwp7VdQlP4jDc,307
+imageio/config/__pycache__/__init__.cpython-38.pyc,,
+imageio/config/__pycache__/extensions.cpython-38.pyc,,
+imageio/config/__pycache__/plugins.cpython-38.pyc,,
+imageio/config/extensions.py,sha256=GdmyD2XXj--NXurv07wb9K93tJt5YxNU9YQfMJRW9sE,44975
+imageio/config/plugins.py,sha256=QRD4jIKRyGVn1QDBKAtECbqFwf6YfAGO_4xID78O2lk,20181
+imageio/core/__init__.py,sha256=PSkGH8K76ntSWhwM4j7W49UmCSZf_OGaSl9fNbQP7uQ,639
+imageio/core/__pycache__/__init__.cpython-38.pyc,,
+imageio/core/__pycache__/fetching.cpython-38.pyc,,
+imageio/core/__pycache__/findlib.cpython-38.pyc,,
+imageio/core/__pycache__/format.cpython-38.pyc,,
+imageio/core/__pycache__/imopen.cpython-38.pyc,,
+imageio/core/__pycache__/legacy_plugin_wrapper.cpython-38.pyc,,
+imageio/core/__pycache__/request.cpython-38.pyc,,
+imageio/core/__pycache__/util.cpython-38.pyc,,
+imageio/core/__pycache__/v3_plugin_api.cpython-38.pyc,,
+imageio/core/fetching.py,sha256=r81yBsJMqkwAXeVAuQuAzbk9etWxQUEUe4__UUjpQpc,9176
+imageio/core/findlib.py,sha256=Zrhs0rEyp8p8iSIuCoBco0dCaB5dxJVZ4lRgv82Sqm0,5552
+imageio/core/format.py,sha256=P8juRQqIRO1sPInRV9F7LpBNzKv6kGbLVFBi-XLsBCI,29975
+imageio/core/imopen.py,sha256=vWyQyEn65JuvlUxy0898O_r37TqjB3H_PRyTEvJkhEk,10717
+imageio/core/legacy_plugin_wrapper.py,sha256=FogsZ5wUltLxBDGyILY4WIEe3OgfAaboTHdlDUgZjwQ,10798
+imageio/core/request.py,sha256=t1BTuwhqDBu2xGfmEuhQtpkLy9TvW506-1P8KCE5Eko,26762
+imageio/core/util.py,sha256=3-TvMyWV6c67j6FnOztPaTVfoFjHn5z_mKb4IXjFUQM,18655
+imageio/core/v3_plugin_api.py,sha256=lycFyzUj2DUVuGJZD34kDu1RNyeWYoxdf1irupv09eo,15427
+imageio/freeze.py,sha256=hi9MNZz-ridgQBWcAqnd92sULek2lgmBSTmuott5lus,170
+imageio/plugins/__init__.py,sha256=e1-9CjZ5HRnirnY_iBT26xXxDo4hfDmavOdiwUgDzUA,4289
+imageio/plugins/__pycache__/__init__.cpython-38.pyc,,
+imageio/plugins/__pycache__/_bsdf.cpython-38.pyc,,
+imageio/plugins/__pycache__/_dicom.cpython-38.pyc,,
+imageio/plugins/__pycache__/_freeimage.cpython-38.pyc,,
+imageio/plugins/__pycache__/_swf.cpython-38.pyc,,
+imageio/plugins/__pycache__/_tifffile.cpython-38.pyc,,
+imageio/plugins/__pycache__/bsdf.cpython-38.pyc,,
+imageio/plugins/__pycache__/dicom.cpython-38.pyc,,
+imageio/plugins/__pycache__/example.cpython-38.pyc,,
+imageio/plugins/__pycache__/feisem.cpython-38.pyc,,
+imageio/plugins/__pycache__/ffmpeg.cpython-38.pyc,,
+imageio/plugins/__pycache__/fits.cpython-38.pyc,,
+imageio/plugins/__pycache__/freeimage.cpython-38.pyc,,
+imageio/plugins/__pycache__/freeimagemulti.cpython-38.pyc,,
+imageio/plugins/__pycache__/gdal.cpython-38.pyc,,
+imageio/plugins/__pycache__/grab.cpython-38.pyc,,
+imageio/plugins/__pycache__/lytro.cpython-38.pyc,,
+imageio/plugins/__pycache__/npz.cpython-38.pyc,,
+imageio/plugins/__pycache__/opencv.cpython-38.pyc,,
+imageio/plugins/__pycache__/pillow.cpython-38.pyc,,
+imageio/plugins/__pycache__/pillow_info.cpython-38.pyc,,
+imageio/plugins/__pycache__/pillow_legacy.cpython-38.pyc,,
+imageio/plugins/__pycache__/pillowmulti.cpython-38.pyc,,
+imageio/plugins/__pycache__/pyav.cpython-38.pyc,,
+imageio/plugins/__pycache__/simpleitk.cpython-38.pyc,,
+imageio/plugins/__pycache__/spe.cpython-38.pyc,,
+imageio/plugins/__pycache__/swf.cpython-38.pyc,,
+imageio/plugins/__pycache__/tifffile.cpython-38.pyc,,
+imageio/plugins/_bsdf.py,sha256=F2of0kjrhnGVWbrrgI7lkNJbAvfCrxF3jSu0GWZb_lQ,32757
+imageio/plugins/_dicom.py,sha256=-IrYSnUNgeRvvm_lXtZbwteFiVWJ6UXKorzX94JEX9o,33859
+imageio/plugins/_freeimage.py,sha256=7BmrZZoC_CbLjnULnfmUnSIXJQz2yKDF9tmWMQG5QQo,51755
+imageio/plugins/_swf.py,sha256=q-QR-_8itteClrh94aVyjk5f5bvveElwUGrS9BRzLKM,25763
+imageio/plugins/_tifffile.py,sha256=mQkxDuW_ir0Mg2rknFskoN5AcYLSfAJhcFotU0u9fs4,371589
+imageio/plugins/bsdf.py,sha256=yZNfHwGlVnFWiQsSMy8QZocUsasUYHQUhIDRZEvnKCM,12854
+imageio/plugins/dicom.py,sha256=iSb1QgDIZjbaQRJLtVD51Zry5GamZ02YRscerzBihng,11873
+imageio/plugins/example.py,sha256=5nNT3f7O0M9GkBzEx6Jy0Vf2pYEP4V7j6vYCzKgBhos,5695
+imageio/plugins/feisem.py,sha256=AKwZv7Zac0_grnr-wnzU7R0Zf2KSUe91k06evPa1NI8,3360
+imageio/plugins/ffmpeg.py,sha256=0psArn9N58SZ-keIwyE4mb23qrvealGsu6M9UIo_-CI,29120
+imageio/plugins/fits.py,sha256=XnlmeC79sIiIPd_7IDx05-p3-b2unO4CVR0nWAA4ph0,4531
+imageio/plugins/freeimage.py,sha256=g7EDxJJrm_gM3ESIV0eBQWIuCHJA4ZdT5vFUn2K8_Yk,14646
+imageio/plugins/freeimagemulti.py,sha256=hQjH18oGR5VaBw6vyrVz0MIH2nu9LbiithFYxPynfhA,11422
+imageio/plugins/gdal.py,sha256=r2Ux7MQeHCUsmdk0aGENzGX8M5hCBU7NJomcf6G8FCU,1653
+imageio/plugins/grab.py,sha256=wnDY-ly32gjY2ypQzlN_djBh4BC6cUFH5t9jA4LA65Q,2906
+imageio/plugins/lytro.py,sha256=UQfVTsuTOpa0zx2v7KcyxaVBLTFdfiT9PqmAvNOYJeQ,25542
+imageio/plugins/npz.py,sha256=7ZQr-4lQEKbfjaF6rOmpq9pQgDTUHvkZa_NHZkJWBQo,2670
+imageio/plugins/opencv.py,sha256=VubaalArEUbO2Lt_zeNvh8DfeygBbI63CwZ8OHc_UU4,11109
+imageio/plugins/pillow.py,sha256=l994prHdtMinPaduMhJSfibaysSLFq5hU7ErmeiMdmg,16100
+imageio/plugins/pillow_info.py,sha256=Bt5iJtQnAh6mGViPIxhxRQPNidqay9-6BleAJZkhN1w,36624
+imageio/plugins/pillow_legacy.py,sha256=zHQaXh2n-QYI8omk_Se7zKDK49hmDZQ62B8UU_RDfM8,31863
+imageio/plugins/pillowmulti.py,sha256=IveZ5_QRAHMPdP4weiRa7zlkg7LpOyv7o3IgcYgwgO8,11296
+imageio/plugins/pyav.py,sha256=bANtErft2UhHYpCwgOiMOMit5H8lEiXMfLqNVjf-w5c,36394
+imageio/plugins/simpleitk.py,sha256=ldQWjkiCSZPoUnN87MtUqRIMMcIKmk8ZUeyDCQhnpG0,4107
+imageio/plugins/spe.py,sha256=sg9dkZLUOS7tuVS-g5QopiLbBB_5bE_HwzrfvYb6uQc,24792
+imageio/plugins/swf.py,sha256=QreAl1pdTVRsC8iD8x4pPS1C6LzklSXQ4RexafQupP8,11876
+imageio/plugins/tifffile.py,sha256=jYj0JCjkNr0z8Ijelv1nCPN7zRkf9Jr37uR1GB3xO2U,19771
+imageio/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+imageio/resources/images/astronaut.png,sha256=iEMc2WU8zVOXQbVV-wpGthVYswHUEQQStbwotePqbLU,791555
+imageio/resources/images/chelsea.png,sha256=l0A8nBcdGu3SAmx1FeICCO-GXqq1bUYsPC7vrem313k,221294
+imageio/resources/images/chelsea.zip,sha256=ieIbNItsviHa0hRghW_MBOgCXdnr1Sp7MvC_vXEDGJo,221318
+imageio/resources/images/cockatoo.mp4,sha256=X9419aKIyobiFtLcKBiKtktFYNMCHyc_rv3w3oDziqU,728751
+imageio/resources/images/newtonscradle.gif,sha256=pmPE4Ha1xI4KrFjHd30rsxk8swU8CY0I2ieKYtAv8xQ,583374
+imageio/resources/images/realshort.mp4,sha256=qLNcLCEwRTueoRcq1K9orAJ7wkg-8FRXaWhHIhJ7_hg,96822
+imageio/resources/images/stent.npz,sha256=YKg9Ipa1HualMVPpupa6kCA5GwyJUoldnWCgpimsa7Y,824612
+imageio/resources/shipped_resources_go_here,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+imageio/testing.py,sha256=tkRPxZZpG68q_MAIux8WE8QeKbhbq6rDPVfCDsof1Ms,1597
+imageio/typing.py,sha256=GiWD3Muonws8wZv3SDsuP_5s6eZtYHouEAshCo-5bW0,342
+imageio/v2.py,sha256=OIvZXgso8d0GSynaF0Mra_j2BbOdqtzCErMoW9u13Qc,17232
+imageio/v3.py,sha256=iG2UEJkePrkqp3jr_6EGktj7WFGuddcHuld__M-5iyE,10217

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/imageio-2.19.3.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.37.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/imageio-2.19.3.dist-info/entry_points.txt

@@ -0,0 +1,4 @@
+[console_scripts]
+imageio_download_bin = imageio.__main__:download_bin_main
+imageio_remove_bin = imageio.__main__:remove_bin_main
+

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/monai/__init__.py

@@ -0,0 +1,65 @@
+# Copyright (c) MONAI Consortium
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#     http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import os
+import sys
+
+from ._version import get_versions
+
+PY_REQUIRED_MAJOR = 3
+PY_REQUIRED_MINOR = 7
+
+version_dict = get_versions()
+__version__: str = version_dict.get("version", "0+unknown")
+__revision_id__: str = version_dict.get("full-revisionid")
+del get_versions, version_dict
+
+__copyright__ = "(c) MONAI Consortium"
+
+__basedir__ = os.path.dirname(__file__)
+
+if sys.version_info.major != PY_REQUIRED_MAJOR or sys.version_info.minor < PY_REQUIRED_MINOR:
+    import warnings
+
+    warnings.warn(
+        f"MONAI requires Python {PY_REQUIRED_MAJOR}.{PY_REQUIRED_MINOR} or higher. "
+        f"But the current Python is: {sys.version}",
+        category=RuntimeWarning,
+    )
+
+from .utils.module import load_submodules  # noqa: E402
+
+# handlers_* have some external decorators the users may not have installed
+# *.so files and folder "_C" may not exist when the cpp extensions are not compiled
+excludes = "(^(monai.handlers))|(^(monai.bundle))|((\\.so)$)|(^(monai._C))"
+
+# load directory modules only, skip loading individual files
+load_submodules(sys.modules[__name__], False, exclude_pattern=excludes)
+
+# load all modules, this will trigger all export decorations
+load_submodules(sys.modules[__name__], True, exclude_pattern=excludes)
+
+__all__ = [
+    "apps",
+    "bundle",
+    "config",
+    "data",
+    "engines",
+    "handlers",
+    "inferers",
+    "losses",
+    "metrics",
+    "networks",
+    "optimizers",
+    "transforms",
+    "utils",
+    "visualize",
+]

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/monai/_version.py

@@ -0,0 +1,21 @@
+
+# This file was generated by 'versioneer.py' (0.19) from
+# revision-control system data, or from the parent directory name of an
+# unpacked source archive. Distribution tarballs contain a pre-generated copy
+# of this file.
+
+import json
+
+version_json = '''
+{
+ "date": "2022-06-13T15:14:10+0000",
+ "dirty": false,
+ "error": null,
+ "full-revisionid": "af0e0e9f757558d144b655c63afcea3a4e0a06f5",
+ "version": "0.9.0"
+}
+'''  # END VERSION_JSON
+
+
+def get_versions():
+    return json.loads(version_json)

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/multidict-6.0.2.dist-info/LICENSE

@@ -0,0 +1,13 @@
+   Copyright 2016-2021 Andrew Svetlov and aio-libs team
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/multidict-6.0.2.dist-info/METADATA

@@ -0,0 +1,131 @@
+Metadata-Version: 2.1
+Name: multidict
+Version: 6.0.2
+Summary: multidict implementation
+Home-page: https://github.com/aio-libs/multidict
+Author: Andrew Svetlov
+Author-email: andrew.svetlov@gmail.com
+License: Apache 2
+Project-URL: Chat: Gitter, https://gitter.im/aio-libs/Lobby
+Project-URL: CI: GitHub, https://github.com/aio-libs/multidict/actions
+Project-URL: Coverage: codecov, https://codecov.io/github/aio-libs/multidict
+Project-URL: Docs: RTD, https://multidict.readthedocs.io
+Project-URL: GitHub: issues, https://github.com/aio-libs/multidict/issues
+Project-URL: GitHub: repo, https://github.com/aio-libs/multidict
+Platform: UNKNOWN
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Development Status :: 5 - Production/Stable
+Requires-Python: >=3.7
+License-File: LICENSE
+
+=========
+multidict
+=========
+
+.. image:: https://github.com/aio-libs/multidict/workflows/CI/badge.svg
+   :target: https://github.com/aio-libs/multidict/actions?query=workflow%3ACI
+   :alt: GitHub status for master branch
+
+.. image:: https://codecov.io/gh/aio-libs/multidict/branch/master/graph/badge.svg
+   :target: https://codecov.io/gh/aio-libs/multidict
+   :alt: Coverage metrics
+
+.. image:: https://img.shields.io/pypi/v/multidict.svg
+   :target: https://pypi.org/project/multidict
+   :alt: PyPI
+
+.. image:: https://readthedocs.org/projects/multidict/badge/?version=latest
+   :target: http://multidict.readthedocs.org/en/latest/?badge=latest
+   :alt: Documentationb
+
+.. image:: https://img.shields.io/pypi/pyversions/multidict.svg
+   :target: https://pypi.org/project/multidict
+   :alt: Python versions
+
+.. image:: https://badges.gitter.im/Join%20Chat.svg
+   :target: https://gitter.im/aio-libs/Lobby
+   :alt: Chat on Gitter
+
+Multidict is dict-like collection of *key-value pairs* where key
+might be occurred more than once in the container.
+
+Introduction
+------------
+
+*HTTP Headers* and *URL query string* require specific data structure:
+*multidict*. It behaves mostly like a regular ``dict`` but it may have
+several *values* for the same *key* and *preserves insertion ordering*.
+
+The *key* is ``str`` (or ``istr`` for case-insensitive dictionaries).
+
+``multidict`` has four multidict classes:
+``MultiDict``, ``MultiDictProxy``, ``CIMultiDict``
+and ``CIMultiDictProxy``.
+
+Immutable proxies (``MultiDictProxy`` and
+``CIMultiDictProxy``) provide a dynamic view for the
+proxied multidict, the view reflects underlying collection changes. They
+implement the ``collections.abc.Mapping`` interface.
+
+Regular mutable (``MultiDict`` and ``CIMultiDict``) classes
+implement ``collections.abc.MutableMapping`` and allows to change
+their own content.
+
+
+*Case insensitive* (``CIMultiDict`` and
+``CIMultiDictProxy``) ones assume the *keys* are case
+insensitive, e.g.::
+
+   >>> dct = CIMultiDict(key='val')
+   >>> 'Key' in dct
+   True
+   >>> dct['Key']
+   'val'
+
+*Keys* should be ``str`` or ``istr`` instances.
+
+The library has optional C Extensions for sake of speed.
+
+
+License
+-------
+
+Apache 2
+
+Library Installation
+--------------------
+
+.. code-block:: bash
+
+   $ pip install multidict
+
+The library is Python 3 only!
+
+PyPI contains binary wheels for Linux, Windows and MacOS.  If you want to install
+``multidict`` on another operation system (or *Alpine Linux* inside a Docker) the
+Tarball will be used to compile the library from sources.  It requires C compiler and
+Python headers installed.
+
+To skip the compilation please use `MULTIDICT_NO_EXTENSIONS` environment variable,
+e.g.:
+
+.. code-block:: bash
+
+   $ MULTIDICT_NO_EXTENSIONS=1 pip install multidict
+
+Please note, Pure Python (uncompiled) version is about 20-50 times slower depending on
+the usage scenario!!!
+
+
+
+Changelog
+---------
+See `RTD page <http://multidict.readthedocs.org/en/latest/changes.html>`_.
+

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/multidict-6.0.2.dist-info/RECORD

@@ -0,0 +1,20 @@
+multidict-6.0.2.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+multidict-6.0.2.dist-info/LICENSE,sha256=BqJA6hC6ho_aLeWN-FmIaWHfhzqnS7qx4PE-r5n5K3s,608
+multidict-6.0.2.dist-info/METADATA,sha256=iNMvE8dk8rtpvHO0DbdsVPatveZlkoIlBI3YZvw-Q0Y,4106
+multidict-6.0.2.dist-info/RECORD,,
+multidict-6.0.2.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+multidict-6.0.2.dist-info/WHEEL,sha256=-ijGDuALlPxm3HbhKntps0QzHsi-DPlXqgerYTTJkFE,148
+multidict-6.0.2.dist-info/top_level.txt,sha256=-euDElkk5_qkmfIJ7WiqCab02ZlSFZWynejKg59qZQQ,10
+multidict/__init__.py,sha256=IoPxk53SsLhHykEQC4N5gxZWPZf72KueDKUOqBc7cH0,928
+multidict/__init__.pyi,sha256=jLQkZwqRJYl_MOMGSavmzwzwefTEH_Tjk3oTKV7c6HY,5035
+multidict/__pycache__/__init__.cpython-38.pyc,,
+multidict/__pycache__/_abc.cpython-38.pyc,,
+multidict/__pycache__/_compat.cpython-38.pyc,,
+multidict/__pycache__/_multidict_base.cpython-38.pyc,,
+multidict/__pycache__/_multidict_py.cpython-38.pyc,,
+multidict/_abc.py,sha256=Zvnrn4SBkrv4QTD7-ZzqNcoxw0f8KStLMPzGvBuGT2w,1190
+multidict/_compat.py,sha256=tjUGdP9ooiH6c2KJrvUbPRwcvjWerKlKU6InIviwh7w,316
+multidict/_multidict.cpython-38-x86_64-linux-gnu.so,sha256=ZkT3hCEbGN2vvbWCgI9B8ydrTPoHP4dw1peUHtgqe6A,384936
+multidict/_multidict_base.py,sha256=XugkE78fXBmtzDdg2Yi9TrEhDexmL-6qJbFIG0viLMg,3791
+multidict/_multidict_py.py,sha256=kG9sxY0_E2e3B1qzDmFzgZvZtu8qmEhR5nhnvH4xatc,14864
+multidict/py.typed,sha256=e9bmbH3UFxsabQrnNFPG9qxIXztwbcM6IKDYnvZwprY,15

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/multidict-6.0.2.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.37.1)
+Root-Is-Purelib: false
+Tag: cp38-cp38-manylinux_2_17_x86_64
+Tag: cp38-cp38-manylinux2014_x86_64
+

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/multidict-6.0.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+multidict

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/pip/__main__.py

@@ -0,0 +1,24 @@
+import os
+import sys
+
+# Remove '' and current working directory from the first entry
+# of sys.path, if present to avoid using current directory
+# in pip commands check, freeze, install, list and show,
+# when invoked as python -m pip <command>
+if sys.path[0] in ("", os.getcwd()):
+    sys.path.pop(0)
+
+# If we are running from a wheel, add the wheel to sys.path
+# This allows the usage python pip-*.whl/pip install pip-*.whl
+if __package__ == "":
+    # __file__ is pip-*.whl/pip/__main__.py
+    # first dirname call strips of '/__main__.py', second strips off '/pip'
+    # Resulting path is the name of the wheel itself
+    # Add that to sys.path so we can import pip
+    path = os.path.dirname(os.path.dirname(__file__))
+    sys.path.insert(0, path)
+
+if __name__ == "__main__":
+    from pip._internal.cli.main import main as _main
+
+    sys.exit(_main())

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/pip/py.typed

@@ -0,0 +1,4 @@
+pip is a command line program. While it is implemented in Python, and so is
+available for import, you must not use pip's internal APIs in this way. Typing
+information is provided as a convenience only and is not a guarantee. Expect
+unannounced changes to the API and types in releases.

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/protobuf-3.20.1.dist-info/INSTALLER

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

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/protobuf-3.20.1.dist-info/METADATA

@@ -0,0 +1,20 @@
+Metadata-Version: 2.1
+Name: protobuf
+Version: 3.20.1
+Summary: Protocol Buffers
+Home-page: https://developers.google.com/protocol-buffers/
+Download-URL: https://github.com/protocolbuffers/protobuf/releases
+Maintainer: protobuf@googlegroups.com
+Maintainer-email: protobuf@googlegroups.com
+License: BSD-3-Clause
+Platform: UNKNOWN
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Requires-Python: >=3.7
+
+Protocol Buffers are Google's data interchange format
+

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/protobuf-3.20.1.dist-info/RECORD

@@ -0,0 +1,100 @@
+google/protobuf/__init__.py,sha256=QmlumOi-Q0lfJS91GeA8GTtpEnUb2YRcta57NBc9-fc,1705
+google/protobuf/__pycache__/__init__.cpython-38.pyc,,
+google/protobuf/__pycache__/any_pb2.cpython-38.pyc,,
+google/protobuf/__pycache__/api_pb2.cpython-38.pyc,,
+google/protobuf/__pycache__/descriptor.cpython-38.pyc,,
+google/protobuf/__pycache__/descriptor_database.cpython-38.pyc,,
+google/protobuf/__pycache__/descriptor_pb2.cpython-38.pyc,,
+google/protobuf/__pycache__/descriptor_pool.cpython-38.pyc,,
+google/protobuf/__pycache__/duration_pb2.cpython-38.pyc,,
+google/protobuf/__pycache__/empty_pb2.cpython-38.pyc,,
+google/protobuf/__pycache__/field_mask_pb2.cpython-38.pyc,,
+google/protobuf/__pycache__/json_format.cpython-38.pyc,,
+google/protobuf/__pycache__/message.cpython-38.pyc,,
+google/protobuf/__pycache__/message_factory.cpython-38.pyc,,
+google/protobuf/__pycache__/proto_builder.cpython-38.pyc,,
+google/protobuf/__pycache__/reflection.cpython-38.pyc,,
+google/protobuf/__pycache__/service.cpython-38.pyc,,
+google/protobuf/__pycache__/service_reflection.cpython-38.pyc,,
+google/protobuf/__pycache__/source_context_pb2.cpython-38.pyc,,
+google/protobuf/__pycache__/struct_pb2.cpython-38.pyc,,
+google/protobuf/__pycache__/symbol_database.cpython-38.pyc,,
+google/protobuf/__pycache__/text_encoding.cpython-38.pyc,,
+google/protobuf/__pycache__/text_format.cpython-38.pyc,,
+google/protobuf/__pycache__/timestamp_pb2.cpython-38.pyc,,
+google/protobuf/__pycache__/type_pb2.cpython-38.pyc,,
+google/protobuf/__pycache__/wrappers_pb2.cpython-38.pyc,,
+google/protobuf/any_pb2.py,sha256=TdTaU8MPj7tqjilhMbIK8m3AIP7Yvd08R2LoXojwYaE,1355
+google/protobuf/api_pb2.py,sha256=PMh7xH6vsLCW-y1f_A_0Qnx3PtSx-g2UsS4AIswXrcM,2539
+google/protobuf/compiler/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+google/protobuf/compiler/__pycache__/__init__.cpython-38.pyc,,
+google/protobuf/compiler/__pycache__/plugin_pb2.cpython-38.pyc,,
+google/protobuf/compiler/plugin_pb2.py,sha256=Bv73ahQkWnOx9XH8YF5TrrzSPjksbqelnDTl63q17v0,2740
+google/protobuf/descriptor.py,sha256=DiDxSej4W4dt3Y_bvv0uCa9YwdCaMCe-WYFigii3VaA,46474
+google/protobuf/descriptor_database.py,sha256=2hBUBbzWjTdyq0nLZ9HYKbqhMpouzZVk9srurERnLVo,6819
+google/protobuf/descriptor_pb2.py,sha256=o5c8FFMBHDxryibe_JCEYO5xi4AAm_Te4xZeWlJ8hlI,109072
+google/protobuf/descriptor_pool.py,sha256=yHiZzzFTuh_LGp-WNHzGe4MVDpThNI3mtjV1bpkSAoY,47281
+google/protobuf/duration_pb2.py,sha256=KmfAu5bQ4GhoeqH06nJ7tjRbtov3b0ktUHohhNIl2p0,1430
+google/protobuf/empty_pb2.py,sha256=d6CTe50gpFNlRuXXyL6R1PU8WuLg8qqLsye7tElunFU,1319
+google/protobuf/field_mask_pb2.py,sha256=nNXqeAZhmPOsez6D7V5eA9VQICbB5mXNe1um1jmH-tA,1401
+google/protobuf/internal/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+google/protobuf/internal/__pycache__/__init__.cpython-38.pyc,,
+google/protobuf/internal/__pycache__/api_implementation.cpython-38.pyc,,
+google/protobuf/internal/__pycache__/builder.cpython-38.pyc,,
+google/protobuf/internal/__pycache__/containers.cpython-38.pyc,,
+google/protobuf/internal/__pycache__/decoder.cpython-38.pyc,,
+google/protobuf/internal/__pycache__/encoder.cpython-38.pyc,,
+google/protobuf/internal/__pycache__/enum_type_wrapper.cpython-38.pyc,,
+google/protobuf/internal/__pycache__/extension_dict.cpython-38.pyc,,
+google/protobuf/internal/__pycache__/message_listener.cpython-38.pyc,,
+google/protobuf/internal/__pycache__/python_message.cpython-38.pyc,,
+google/protobuf/internal/__pycache__/type_checkers.cpython-38.pyc,,
+google/protobuf/internal/__pycache__/well_known_types.cpython-38.pyc,,
+google/protobuf/internal/__pycache__/wire_format.cpython-38.pyc,,
+google/protobuf/internal/_api_implementation.cpython-38-x86_64-linux-gnu.so,sha256=ZVZ-zAKr-zEzoo9ICWeshNyERCjUH9o5eeQSgncSmtk,5504
+google/protobuf/internal/api_implementation.py,sha256=rma5XlGOY6x35S55AS5bSOv0vq_211gjnL4Q9X74lpY,4562
+google/protobuf/internal/builder.py,sha256=wtugRgYbIMeo4txvGUlfFLD8nKZEDCxH3lkRtyVndbY,5188
+google/protobuf/internal/containers.py,sha256=RH6NkwSCLzQ5qTgsvM04jkRjgCDNHFRWZyfSCvvv_rk,23328
+google/protobuf/internal/decoder.py,sha256=XDqpaEzqavV4Ka7jx2jonxCEyuKClxzbWPS2M4OTe0I,37567
+google/protobuf/internal/encoder.py,sha256=6hXWsTHCB-cumgbAMi5Z3JIxab8E5LD9p_iPS2HohiA,28656
+google/protobuf/internal/enum_type_wrapper.py,sha256=PKWYYZRexjkl4KrMnGa6Csq2xbKFXoqsWbwYHvJ0yiM,4821
+google/protobuf/internal/extension_dict.py,sha256=3DbWhlrpGybuur1bjfGKhx2d8IVo7tVQUEcF8tPLTyo,8443
+google/protobuf/internal/message_listener.py,sha256=Qwc5gkifAvWzhm3b0v-nXJkozNTgL-L92XAslngFaow,3367
+google/protobuf/internal/python_message.py,sha256=MEDGdNsrBo8OKk92s87J9qjJCQN_lkZCJHJXaA1th8U,58146
+google/protobuf/internal/type_checkers.py,sha256=a3o2y-S9XSFEiPUau5faEz2fu2OIxYhTM9ZGiLPCXlM,16912
+google/protobuf/internal/well_known_types.py,sha256=yLtyfrZ3svShTNgMW-U0TLt77pHsewi6xILDgabd-BY,30014
+google/protobuf/internal/wire_format.py,sha256=7Wz8gV7QOvoTzLMWrwlWSg7hIJ_T8Pm1w8_WLhpieVw,8444
+google/protobuf/json_format.py,sha256=egKnvgSRn62HI6UMWw-COTPfheBFERSqMNixp2iJZF0,35664
+google/protobuf/message.py,sha256=Gyj0Yb6eWiI47QO4DnA2W2J0WlDiRVm83FlKfO_Isf8,14523
+google/protobuf/message_factory.py,sha256=LD18eAKZ_tZnDzIUc_gDmrkxuwiYkUh-f-BkfVW7Wko,7482
+google/protobuf/proto_builder.py,sha256=WcEmUDU26k_JSiUzXJ7bgthgR7jlTiOecV1np0zGyA8,5506
+google/protobuf/pyext/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+google/protobuf/pyext/__pycache__/__init__.cpython-38.pyc,,
+google/protobuf/pyext/__pycache__/cpp_message.cpython-38.pyc,,
+google/protobuf/pyext/_message.cpython-38-x86_64-linux-gnu.so,sha256=41tJIVp4nvcNndk4MDiDldwaRpAGBCEPNAiToQLjXg4,2478152
+google/protobuf/pyext/cpp_message.py,sha256=D0-bxtjf1Ri8b0GubL5xgkkEB_z_mIf847yrRvVqDBU,2851
+google/protobuf/reflection.py,sha256=f61wP6k-HMShRwLsfRomScGzG0ZpWULpyhYwvjuZMKQ,3779
+google/protobuf/service.py,sha256=MGWgoxTrSlmqWsgXvp1XaP5Sg-_pq8Sw2XJuY1m6MVM,9146
+google/protobuf/service_reflection.py,sha256=5hBr8Q4gTgg3MT4NZoTxRSjTaxzLtNSG-8cXa5nHXaQ,11417
+google/protobuf/source_context_pb2.py,sha256=9sFLqhUhkTHkdKMZCQPQQ3GClbDMtOSlAy4P9LjPEvg,1416
+google/protobuf/struct_pb2.py,sha256=J16zp6HU5P2TyHpmAOzTvPDN_nih9uLg-z18-3bnFp0,2477
+google/protobuf/symbol_database.py,sha256=aCPGE4N2slb6HFB4cHFJDA8zehgMy16XY8BMH_ebfhc,6944
+google/protobuf/text_encoding.py,sha256=IrfncP112lKMLnWhhjXoczxEv2RZ9kzlinzAzHstrlY,4728
+google/protobuf/text_format.py,sha256=6aYyfB-htl2za_waO6LV9JVTPbx5Qj2vf0uE-cZdC6M,60006
+google/protobuf/timestamp_pb2.py,sha256=PTClFsyHjuwKHv4h6Ho1-GcMOfU3Rhd3edANjTQEbJI,1439
+google/protobuf/type_pb2.py,sha256=Iifx3dIukGbRBdYaJPQJADJ-ZcBdjztB1JvplT7EiJo,4425
+google/protobuf/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+google/protobuf/util/__pycache__/__init__.cpython-38.pyc,,
+google/protobuf/util/__pycache__/json_format_pb2.cpython-38.pyc,,
+google/protobuf/util/__pycache__/json_format_proto3_pb2.cpython-38.pyc,,
+google/protobuf/util/json_format_pb2.py,sha256=NR9GMe0hgwdbDEW5PyquvwAYcsHkPsobrnGV4sIyiis,6124
+google/protobuf/util/json_format_proto3_pb2.py,sha256=Gy7gqXLUPfSQkhmP6epX0-xODDGdE6pY57Mn93f4EmA,14095
+google/protobuf/wrappers_pb2.py,sha256=7g8cp-WcEg0HWzx53KagbAr9a4cjXJHGMraSM2i4Kc4,2410
+protobuf-3.20.1-py3.8-nspkg.pth,sha256=xH5gTxc4UipYP3qrbP-4CCHNGBV97eBR4QqhheCvBl4,539
+protobuf-3.20.1.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+protobuf-3.20.1.dist-info/METADATA,sha256=Nm_OXnXJP9NViOodFARMR9MGLGHJ81WH-fnWlnOlcuY,698
+protobuf-3.20.1.dist-info/RECORD,,
+protobuf-3.20.1.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+protobuf-3.20.1.dist-info/WHEEL,sha256=U9CYjdvnyMM6M9rFbVg1rC7FvR0cX-CcV6tdgX3Vy0E,144
+protobuf-3.20.1.dist-info/namespace_packages.txt,sha256=_1QvSJIhFAGfxb79D6DhB7SUw2X6T4rwnz_LLrbcD3c,7
+protobuf-3.20.1.dist-info/top_level.txt,sha256=_1QvSJIhFAGfxb79D6DhB7SUw2X6T4rwnz_LLrbcD3c,7

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/protobuf-3.20.1.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.37.1)
+Root-Is-Purelib: false
+Tag: cp38-cp38-manylinux_2_5_x86_64
+Tag: cp38-cp38-manylinux1_x86_64
+