diff --git a/.gitattributes b/.gitattributes index 1710a0377ae1535ca8672565d0af8921989a5f2d..dac57419ee19863fabbe5ff74c6fc474d8ac3838 100644 --- a/.gitattributes +++ b/.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 diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/_distutils_hack/__init__.py b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/_distutils_hack/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..4d3f09b0ae97c9d614522eb9a44533b32543cb9b --- /dev/null +++ b/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 diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/_distutils_hack/override.py b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/_distutils_hack/override.py new file mode 100644 index 0000000000000000000000000000000000000000..2cc433a4a55e3b41fa31089918fb62096092f89f --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/_distutils_hack/override.py @@ -0,0 +1 @@ +__import__('_distutils_hack').do_override() diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/charset_normalizer/__init__.py b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/charset_normalizer/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..1aea851aa509f1403940e46e6207bb9cd3f57aec --- /dev/null +++ b/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 . +: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()) diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/charset_normalizer/api.py b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/charset_normalizer/api.py new file mode 100644 index 0000000000000000000000000000000000000000..bdc8ed9893d3cbb96d931b351ae1bcd06c9b24f1 --- /dev/null +++ b/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 diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/charset_normalizer/cd.py b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/charset_normalizer/cd.py new file mode 100644 index 0000000000000000000000000000000000000000..8429a0eb206db493f6bab629b45fe69f5d90fe5e --- /dev/null +++ b/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) diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/charset_normalizer/legacy.py b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/charset_normalizer/legacy.py new file mode 100644 index 0000000000000000000000000000000000000000..cdebe2b81cf1b706994ae3dd9c48adc42bf9b357 --- /dev/null +++ b/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 diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/charset_normalizer/models.py b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/charset_normalizer/models.py new file mode 100644 index 0000000000000000000000000000000000000000..c38da31fa565ec7ec0ae2d4fb538e9bec9ec9af8 --- /dev/null +++ b/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 "".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) diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/charset_normalizer/utils.py b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/charset_normalizer/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..dcb14dfee1f41a553bb77f285579f7aa76cc5143 --- /dev/null +++ b/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) diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/charset_normalizer/version.py b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/charset_normalizer/version.py new file mode 100644 index 0000000000000000000000000000000000000000..77cfff25d64c48a340d1f38952761c64e21bea06 --- /dev/null +++ b/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(".") diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/deprecate/__init__.py b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/deprecate/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..db4f54cc68d34ddd9efd6f829aa30c81cfcee5fb --- /dev/null +++ b/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 diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/deprecate/deprecation.py b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/deprecate/deprecation.py new file mode 100644 index 0000000000000000000000000000000000000000..22e72df8b47241eccc375b5d6e0e28e4923c5900 --- /dev/null +++ b/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, )] + + """ + 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 diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/deprecate/utils.py b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/deprecate/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..c34d57ee034d9852ef54f9869b9ece06ea121fd5 --- /dev/null +++ b/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 diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/docs/conf.py b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/docs/conf.py new file mode 100644 index 0000000000000000000000000000000000000000..f9630e64020a09ecf3fcbc24204adfc805d3beaf --- /dev/null +++ b/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'] \ No newline at end of file diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/ema_pytorch-0.0.8.dist-info/INSTALLER b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/ema_pytorch-0.0.8.dist-info/INSTALLER new file mode 100644 index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68 --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/ema_pytorch-0.0.8.dist-info/INSTALLER @@ -0,0 +1 @@ +pip diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/ema_pytorch-0.0.8.dist-info/LICENSE b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/ema_pytorch-0.0.8.dist-info/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..272afdf8f32f26f6bc221715fcefb4f8d7e31bc9 --- /dev/null +++ b/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. diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/ema_pytorch-0.0.8.dist-info/REQUESTED b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/ema_pytorch-0.0.8.dist-info/REQUESTED new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/filelock-3.13.1.dist-info/INSTALLER b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/filelock-3.13.1.dist-info/INSTALLER new file mode 100644 index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68 --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/filelock-3.13.1.dist-info/INSTALLER @@ -0,0 +1 @@ +pip diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/filelock-3.13.1.dist-info/METADATA b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/filelock-3.13.1.dist-info/METADATA new file mode 100644 index 0000000000000000000000000000000000000000..f8bcc58eb2894b4de4655c4bd498bc043fb052c1 --- /dev/null +++ b/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 +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). diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/filelock-3.13.1.dist-info/RECORD b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/filelock-3.13.1.dist-info/RECORD new file mode 100644 index 0000000000000000000000000000000000000000..91985f78558cd34c88a1e86732eb96896b2c4a4b --- /dev/null +++ b/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 diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/filelock-3.13.1.dist-info/WHEEL b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/filelock-3.13.1.dist-info/WHEEL new file mode 100644 index 0000000000000000000000000000000000000000..ba1a8af28bcccdacebb8c22dfda1537447a1a58a --- /dev/null +++ b/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 diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/glob2-0.7.dist-info/INSTALLER b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/glob2-0.7.dist-info/INSTALLER new file mode 100644 index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68 --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/glob2-0.7.dist-info/INSTALLER @@ -0,0 +1 @@ +pip diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/glob2-0.7.dist-info/LICENSE b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/glob2-0.7.dist-info/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..953b038c1e06721ba5f7116b99152ba85800c3aa --- /dev/null +++ b/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 +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. \ No newline at end of file diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/glob2-0.7.dist-info/METADATA b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/glob2-0.7.dist-info/METADATA new file mode 100644 index 0000000000000000000000000000000000000000..2cfe5bd34a9bb0bd41e510dab9bfdae7d3601d47 --- /dev/null +++ b/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 + diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/glob2-0.7.dist-info/RECORD b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/glob2-0.7.dist-info/RECORD new file mode 100644 index 0000000000000000000000000000000000000000..adca9610e5d4260c7236ea98ffbfe2ec173e7f9e --- /dev/null +++ b/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 diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/glob2-0.7.dist-info/REQUESTED b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/glob2-0.7.dist-info/REQUESTED new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/glob2-0.7.dist-info/WHEEL b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/glob2-0.7.dist-info/WHEEL new file mode 100644 index 0000000000000000000000000000000000000000..01b8fc7d4a10cb8b4f1d21f11d3398d07d6b3478 --- /dev/null +++ b/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 + diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/glob2-0.7.dist-info/top_level.txt b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/glob2-0.7.dist-info/top_level.txt new file mode 100644 index 0000000000000000000000000000000000000000..769cb00fa3b8e23e0fa31258f6b545a10bc3a6e3 --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/glob2-0.7.dist-info/top_level.txt @@ -0,0 +1 @@ +glob2 diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/imageio-2.19.3.dist-info/INSTALLER b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/imageio-2.19.3.dist-info/INSTALLER new file mode 100644 index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68 --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/imageio-2.19.3.dist-info/INSTALLER @@ -0,0 +1 @@ +pip diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/imageio-2.19.3.dist-info/LICENSE b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/imageio-2.19.3.dist-info/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..33b1352017fa3939ee32c08e027f57deefb9470f --- /dev/null +++ b/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. + diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/imageio-2.19.3.dist-info/RECORD b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/imageio-2.19.3.dist-info/RECORD new file mode 100644 index 0000000000000000000000000000000000000000..6ef51b816b261244c9209e83e8e05acfb2d2fc8c --- /dev/null +++ b/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 diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/imageio-2.19.3.dist-info/REQUESTED b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/imageio-2.19.3.dist-info/REQUESTED new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/imageio-2.19.3.dist-info/WHEEL b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/imageio-2.19.3.dist-info/WHEEL new file mode 100644 index 0000000000000000000000000000000000000000..becc9a66ea739ba941d48a749e248761cc6e658a --- /dev/null +++ b/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 + diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/imageio-2.19.3.dist-info/entry_points.txt b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/imageio-2.19.3.dist-info/entry_points.txt new file mode 100644 index 0000000000000000000000000000000000000000..d17059abd84fc0302df9d9e9aefc5b603a1b48ab --- /dev/null +++ b/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 + diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/monai/__init__.py b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/monai/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e56a2f34440b11f91d3a471006826a21d6fb2111 --- /dev/null +++ b/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", +] diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/monai/_version.py b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/monai/_version.py new file mode 100644 index 0000000000000000000000000000000000000000..1fb5f5b1f3b727e36ce40274d6f495bc39722195 --- /dev/null +++ b/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) diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/monai/py.typed b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/monai/py.typed new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/multidict-6.0.2.dist-info/LICENSE b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/multidict-6.0.2.dist-info/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..305eef60038b4758348300a70a14ab2012b1dce1 --- /dev/null +++ b/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. diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/multidict-6.0.2.dist-info/METADATA b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/multidict-6.0.2.dist-info/METADATA new file mode 100644 index 0000000000000000000000000000000000000000..31a09fd8ec2022cbb94d59ea1e65b9ae39c739c9 --- /dev/null +++ b/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 `_. + diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/multidict-6.0.2.dist-info/RECORD b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/multidict-6.0.2.dist-info/RECORD new file mode 100644 index 0000000000000000000000000000000000000000..4fab18d2b17ff5a60017a1dcc78d7cf00e17b2a9 --- /dev/null +++ b/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 diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/multidict-6.0.2.dist-info/REQUESTED b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/multidict-6.0.2.dist-info/REQUESTED new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/multidict-6.0.2.dist-info/WHEEL b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/multidict-6.0.2.dist-info/WHEEL new file mode 100644 index 0000000000000000000000000000000000000000..3a48d3480384503bea53d4a7c55a666ace0eb5fc --- /dev/null +++ b/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 + diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/multidict-6.0.2.dist-info/top_level.txt b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/multidict-6.0.2.dist-info/top_level.txt new file mode 100644 index 0000000000000000000000000000000000000000..afcecdff08229f3faf1ecef41cf814c26c207f5c --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/multidict-6.0.2.dist-info/top_level.txt @@ -0,0 +1 @@ +multidict diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/pip/__main__.py b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/pip/__main__.py new file mode 100644 index 0000000000000000000000000000000000000000..5991326115fe5026470165b387ba2bc78bceb006 --- /dev/null +++ b/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 +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()) diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/pip/py.typed b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/pip/py.typed new file mode 100644 index 0000000000000000000000000000000000000000..493b53e4e7a3984ddd49780313bf3bd9901dc1e0 --- /dev/null +++ b/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. diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/protobuf-3.20.1.dist-info/INSTALLER b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/protobuf-3.20.1.dist-info/INSTALLER new file mode 100644 index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68 --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/protobuf-3.20.1.dist-info/INSTALLER @@ -0,0 +1 @@ +pip diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/protobuf-3.20.1.dist-info/METADATA b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/protobuf-3.20.1.dist-info/METADATA new file mode 100644 index 0000000000000000000000000000000000000000..4678190a516754d5d028edeedf5047e265050298 --- /dev/null +++ b/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 + diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/protobuf-3.20.1.dist-info/RECORD b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/protobuf-3.20.1.dist-info/RECORD new file mode 100644 index 0000000000000000000000000000000000000000..575a49b7e911ca68b345a196b14977e402533e0a --- /dev/null +++ b/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 diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/protobuf-3.20.1.dist-info/REQUESTED b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/protobuf-3.20.1.dist-info/REQUESTED new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/protobuf-3.20.1.dist-info/WHEEL b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/protobuf-3.20.1.dist-info/WHEEL new file mode 100644 index 0000000000000000000000000000000000000000..5ddfb131dc41b5e88183b7e2513f131e5565134a --- /dev/null +++ b/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 + diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/protobuf-3.20.1.dist-info/namespace_packages.txt b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/protobuf-3.20.1.dist-info/namespace_packages.txt new file mode 100644 index 0000000000000000000000000000000000000000..cb429113e0f9a73019fd799e8052093fea7f0c8b --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/protobuf-3.20.1.dist-info/namespace_packages.txt @@ -0,0 +1 @@ +google diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/protobuf-3.20.1.dist-info/top_level.txt b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/protobuf-3.20.1.dist-info/top_level.txt new file mode 100644 index 0000000000000000000000000000000000000000..cb429113e0f9a73019fd799e8052093fea7f0c8b --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/protobuf-3.20.1.dist-info/top_level.txt @@ -0,0 +1 @@ +google diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/pycosat-0.6.6.dist-info/AUTHORS.md b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/pycosat-0.6.6.dist-info/AUTHORS.md new file mode 100644 index 0000000000000000000000000000000000000000..4977f2ea34ee6a00f2f41ddc2ce24cdb7fc3fb4f --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/pycosat-0.6.6.dist-info/AUTHORS.md @@ -0,0 +1,15 @@ +All of the people who have made at least one contribution to pycosat. +Authors are sorted alphabetically. + +* Aaron Meurer +* Bradley M. Froehle +* Conda Bot +* Daniel Holth +* Ilan Schnell +* Jannis Leidel +* Ken Odegard +* Mike Sarahan +* Ondřej Čertík +* Ray Donnelly +* Travis E. Oliphant +* William Schwartz diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/pycosat-0.6.6.dist-info/METADATA b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/pycosat-0.6.6.dist-info/METADATA new file mode 100644 index 0000000000000000000000000000000000000000..119db9903d87ea7ea71bbe881c379bba47f8eeb1 --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/pycosat-0.6.6.dist-info/METADATA @@ -0,0 +1,140 @@ +Metadata-Version: 2.1 +Name: pycosat +Version: 0.6.6 +Summary: bindings to picosat (a SAT solver) +Home-page: https://github.com/ContinuumIO/pycosat +Author: Ilan Schnell +Author-email: ilan@continuum.io +License: MIT +Classifier: Development Status :: 6 - Mature +Classifier: Intended Audience :: Developers +Classifier: Operating System :: OS Independent +Classifier: Programming Language :: C +Classifier: Programming Language :: Python :: 2 +Classifier: Programming Language :: Python :: 2.7 +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: Programming Language :: Python :: 3.11 +Classifier: Topic :: Utilities +License-File: LICENSE +License-File: AUTHORS.md + +=========================================== +pycosat: bindings to picosat (a SAT solver) +=========================================== + +`PicoSAT `_ is a popular +`SAT `_ solver +written by Armin Biere in pure C. +This package provides efficient Python bindings to picosat on the C level, +i.e. when importing pycosat, the picosat solver becomes part of the +Python process itself. For ease of deployment, the picosat source (namely +picosat.c and picosat.h) is included in this project. These files have +been extracted from the picosat source (picosat-965.tar.gz). + +Usage +----- + +The ``pycosat`` module has two functions ``solve`` and ``itersolve``, +both of which take an iterable of clauses as an argument. Each clause +is itself represented as an iterable of (non-zero) integers. + +The function ``solve`` returns one of the following: + * one solution (a list of integers) + * the string "UNSAT" (when the clauses are unsatisfiable) + * the string "UNKNOWN" (when a solution could not be determined within the + propagation limit) + +The function ``itersolve`` returns an iterator over solutions. When the +propagation limit is specified, exhausting the iterator may not yield all +possible solutions. + +Both functions take the following keyword arguments: + * ``prop_limit``: the propagation limit (integer) + * ``vars``: number of variables (integer) + * ``verbose``: the verbosity level (integer) + + +Example +------- + +Let us consider the following clauses, represented using +the DIMACS `cnf `_ +format:: + + p cnf 5 3 + 1 -5 4 0 + -1 5 3 4 0 + -3 -4 0 + +Here, we have 5 variables and 3 clauses, the first clause being +(x\ :sub:`1` or not x\ :sub:`5` or x\ :sub:`4`). +Note that the variable x\ :sub:`2` is not used in any of the clauses, +which means that for each solution with x\ :sub:`2` = True, we must +also have a solution with x\ :sub:`2` = False. In Python, each clause is +most conveniently represented as a list of integers. Naturally, it makes +sense to represent each solution also as a list of integers, where the sign +corresponds to the Boolean value (+ for True and - for False) and the +absolute value corresponds to i\ :sup:`th` variable:: + + >>> import pycosat + >>> cnf = [[1, -5, 4], [-1, 5, 3, 4], [-3, -4]] + >>> pycosat.solve(cnf) + [1, -2, -3, -4, 5] + +This solution translates to: x\ :sub:`1` = x\ :sub:`5` = True, +x\ :sub:`2` = x\ :sub:`3` = x\ :sub:`4` = False + +To find all solutions, use ``itersolve``:: + + >>> for sol in pycosat.itersolve(cnf): + ... print sol + ... + [1, -2, -3, -4, 5] + [1, -2, -3, 4, -5] + [1, -2, -3, 4, 5] + ... + >>> len(list(pycosat.itersolve(cnf))) + 18 + +In this example, there are a total of 18 possible solutions, which had to +be an even number because x\ :sub:`2` was left unspecified in the clauses. + +The fact that ``itersolve`` returns an iterator, makes it very elegant +and efficient for many types of operations. For example, using +the ``itertools`` module from the standard library, here is how one +would construct a list of (up to) 3 solutions:: + + >>> import itertools + >>> list(itertools.islice(pycosat.itersolve(cnf), 3)) + [[1, -2, -3, -4, 5], [1, -2, -3, 4, -5], [1, -2, -3, 4, 5]] + + +Implementation of itersolve +--------------------------- + +How does one go from having found one solution to another solution? +The answer is surprisingly simple. One adds the *inverse* of the already +found solution as a new clause. This new clause ensures that another +solution is searched for, as it *excludes* the already found solution. +Here is basically a pure Python implementation of ``itersolve`` in terms +of ``solve``:: + + def py_itersolve(clauses): # don't use this function! + while True: # (it is only here to explain things) + sol = pycosat.solve(clauses) + if isinstance(sol, list): + yield sol + clauses.append([-x for x in sol]) + else: # no more solutions -- stop iteration + return + +This implementation has several problems. Firstly, it is quite slow as +``pycosat.solve`` has to convert the list of clauses over and over and over +again. Secondly, after calling ``py_itersolve`` the list of clauses will +be modified. In pycosat, ``itersolve`` is implemented on the C level, +making use of the picosat C interface (which makes it much, much faster +than the naive Python implementation above). diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/pycosat-0.6.6.dist-info/RECORD b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/pycosat-0.6.6.dist-info/RECORD new file mode 100644 index 0000000000000000000000000000000000000000..a11d5eabd849911c9a020541637d91d3258c41c7 --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/pycosat-0.6.6.dist-info/RECORD @@ -0,0 +1,12 @@ +__pycache__/test_pycosat.cpython-38.pyc,, +pycosat-0.6.6.dist-info/AUTHORS.md,sha256=3P0IzZhVbjKQ3pYkPwB4MUdDKHBuWPsu3AEY69so1V4,303 +pycosat-0.6.6.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +pycosat-0.6.6.dist-info/LICENSE,sha256=Iz2aOx2eDYr7Eg7na5jmXFXt4EFi_jfC6AOj04loAh4,1084 +pycosat-0.6.6.dist-info/METADATA,sha256=w99oSIpweubW4OxchuumR4sQkQt062ooow_Vovr5zH0,5361 +pycosat-0.6.6.dist-info/RECORD,, +pycosat-0.6.6.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +pycosat-0.6.6.dist-info/WHEEL,sha256=bsTed55pnupMBzCO4birsRUZqi-B74u0toVjVzLw3F8,103 +pycosat-0.6.6.dist-info/direct_url.json,sha256=cSlcqmyaKFpdmhFuZ2zjxIyylcjic7qi6jVMYn0rHF4,67 +pycosat-0.6.6.dist-info/top_level.txt,sha256=R99AzohPlZWIOjm1RWK9iv6o4d_YKzkWUJnHcczYONE,21 +pycosat.cpython-38-x86_64-linux-gnu.so,sha256=hrsoAcTubpzIqGJr__wf89YE0lVDpP7aiFRx0ogxSJ0,97176 +test_pycosat.py,sha256=97zvF46rrLnEd7oguI6GRq3ijIbCPtkyfuzIFEd32LI,8806 diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/pycosat-0.6.6.dist-info/direct_url.json b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/pycosat-0.6.6.dist-info/direct_url.json new file mode 100644 index 0000000000000000000000000000000000000000..7ed83c92ed1d020dad95a19aba850de63c246648 --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/pycosat-0.6.6.dist-info/direct_url.json @@ -0,0 +1 @@ +{"dir_info": {}, "url": "file:///croot/pycosat_1696536503704/work"} \ No newline at end of file diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/pycosat-0.6.6.dist-info/top_level.txt b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/pycosat-0.6.6.dist-info/top_level.txt new file mode 100644 index 0000000000000000000000000000000000000000..978e56121aa6fd2ae5d4ce24979650a638694f8c --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/pycosat-0.6.6.dist-info/top_level.txt @@ -0,0 +1,2 @@ +pycosat +test_pycosat diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/scikit_video-1.1.11.dist-info/DESCRIPTION.rst b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/scikit_video-1.1.11.dist-info/DESCRIPTION.rst new file mode 100644 index 0000000000000000000000000000000000000000..bfa917d5ce96748461e08b7787c227eabf823236 --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/scikit_video-1.1.11.dist-info/DESCRIPTION.rst @@ -0,0 +1,6 @@ +This library provides easy access to common as well as +state-of-the-art video processing routines. Check out the +website for more details. + + + diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/scikit_video-1.1.11.dist-info/INSTALLER b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/scikit_video-1.1.11.dist-info/INSTALLER new file mode 100644 index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68 --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/scikit_video-1.1.11.dist-info/INSTALLER @@ -0,0 +1 @@ +pip diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/scikit_video-1.1.11.dist-info/METADATA b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/scikit_video-1.1.11.dist-info/METADATA new file mode 100644 index 0000000000000000000000000000000000000000..298b38c098434ff74f3c60e6bed0f3973711bb98 --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/scikit_video-1.1.11.dist-info/METADATA @@ -0,0 +1,33 @@ +Metadata-Version: 2.0 +Name: scikit-video +Version: 1.1.11 +Summary: Video Processing in Python +Home-page: http://scikit-video.org/ +Author: ('Todd Goodall',) +Author-email: info@scikit-video.org +License: BSD +Download-URL: https://github.com/scikit-video/scikit-video +Description-Content-Type: UNKNOWN +Platform: UNKNOWN +Classifier: Development Status :: 3 - Alpha +Classifier: Intended Audience :: Developers +Classifier: Intended Audience :: Science/Research +Classifier: License :: OSI Approved :: BSD License +Classifier: Operating System :: POSIX :: Linux +Classifier: Operating System :: MacOS +Classifier: Operating System :: Microsoft :: Windows +Classifier: Programming Language :: Python :: 2.6 +Classifier: Programming Language :: Python :: 2.7 +Classifier: Programming Language :: Python :: 3.6 +Classifier: Topic :: Multimedia :: Video +Classifier: Topic :: Scientific/Engineering +Requires-Dist: numpy +Requires-Dist: pillow +Requires-Dist: scipy + +This library provides easy access to common as well as +state-of-the-art video processing routines. Check out the +website for more details. + + + diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/scikit_video-1.1.11.dist-info/RECORD b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/scikit_video-1.1.11.dist-info/RECORD new file mode 100644 index 0000000000000000000000000000000000000000..ff5b56daff2461f676e7f9706777a92b2c2f1581 --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/scikit_video-1.1.11.dist-info/RECORD @@ -0,0 +1,116 @@ +scikit_video-1.1.11.dist-info/DESCRIPTION.rst,sha256=iOZTVGWLIqe2Mq3SzBfrUR1n1_rHLl2VWrA1RZ71hMk,142 +scikit_video-1.1.11.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +scikit_video-1.1.11.dist-info/METADATA,sha256=EvN8JAojYGtTP3fyEDDg7Vz7TcS57ccuK8AQI6ba_f4,1084 +scikit_video-1.1.11.dist-info/RECORD,, +scikit_video-1.1.11.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +scikit_video-1.1.11.dist-info/WHEEL,sha256=o2k-Qa-RMNIJmUdIc7KU6VWR_ErNRbWNlxDIpl7lm34,110 +scikit_video-1.1.11.dist-info/metadata.json,sha256=jgcoMXj5DM3ss7He5KuoEEG1Fp0DWf2jS4Zyq120-pQ,1059 +scikit_video-1.1.11.dist-info/top_level.txt,sha256=sFcPKt1c2OIATzJhWvClOk9dP_GL0NMm7j7O-ixwh4I,8 +skvideo/__init__.py,sha256=BwOyCFbVaTHkj_XhDX2tTLnAgAWHzTqFvxgIkdkWyaE,14599 +skvideo/__pycache__/__init__.cpython-38.pyc,, +skvideo/__pycache__/setup.cpython-38.pyc,, +skvideo/datasets/__init__.py,sha256=I2J9CNvY4FoqHlgSAfA9rwf_OwjeElZvKNGd9rLuN4U,1264 +skvideo/datasets/__pycache__/__init__.cpython-38.pyc,, +skvideo/datasets/__pycache__/setup.cpython-38.pyc,, +skvideo/datasets/data/bigbuckbunny.mp4,sha256=8lsx8VWXDEYwCTS9pKds0vWBrKtFxJdigy_9_dvPn90,1055736 +skvideo/datasets/data/bikes.mp4,sha256=kQKPnWxyzIE32L0FZ4vfz1q3yP2de3fecM56Ot4le7U,509868 +skvideo/datasets/data/carphone_distorted.mp4,sha256=RgUaO5BgWZ11MG9oKvkZJ_M-I7aNFMFcCXjh8FcuwF4,7019 +skvideo/datasets/data/carphone_pristine.mp4,sha256=HErdeDiwe01lrZ1m6UkXWMfbtscXSQ20t57Pn_grqyg,588804 +skvideo/datasets/setup.py,sha256=ZW73PzfaVcNEzV33ksKPMK_ctvazy2pe-NUubkmkvc4,227 +skvideo/io/__init__.py,sha256=9zhCNeb1NZ_3RtlpYaIL3QXGsQT7FtJEay-NgVoSPRI,360 +skvideo/io/__pycache__/__init__.cpython-38.pyc,, +skvideo/io/__pycache__/abstract.cpython-38.pyc,, +skvideo/io/__pycache__/avconv.cpython-38.pyc,, +skvideo/io/__pycache__/avprobe.cpython-38.pyc,, +skvideo/io/__pycache__/ffmpeg.cpython-38.pyc,, +skvideo/io/__pycache__/ffprobe.cpython-38.pyc,, +skvideo/io/__pycache__/io.cpython-38.pyc,, +skvideo/io/__pycache__/mprobe.cpython-38.pyc,, +skvideo/io/abstract.py,sha256=24uohGUZ43_PcQ5rVG-aSqyF1vZZSSnwyY9E4ebfAIc,19351 +skvideo/io/avconv.py,sha256=zS2xN6ZDezhIFAkWHWn7w-60s6ZKo1ydgZmzvS_r7HE,4581 +skvideo/io/avprobe.py,sha256=BQHTPLfE-u_mFRKHbO1elFoOYWwHBcIxGLKe_TySq4E,1444 +skvideo/io/ffmpeg.py,sha256=lqwmbu32KqQ6f9ymldn8hDqTNFLKqdzwuhb4mENhxKA,3958 +skvideo/io/ffprobe.py,sha256=DgFIIiU3Jiz-goXMcPD48GuzIfuopo7mxuAp_xrNgzs,1417 +skvideo/io/io.py,sha256=FAwSKELtjDHut6ZrUzlQGFBlrX531hpLi219I-PXi2k,8598 +skvideo/io/mprobe.py,sha256=DcUGwJezjoaleUZhlJ23QwgM3CXiCkcTShYUrXJBEeA,1763 +skvideo/measure/Li3DDCT.py,sha256=f0-l3N357_JmLWuEMfgq62EIU2NurWHvl1L4FwV9o80,4090 +skvideo/measure/__init__.py,sha256=N3suX-_cS4jvrEX1_B6rW1Zq5R5MtZ2XhU2Aro-e254,547 +skvideo/measure/__pycache__/Li3DDCT.cpython-38.pyc,, +skvideo/measure/__pycache__/__init__.cpython-38.pyc,, +skvideo/measure/__pycache__/brisque.cpython-38.pyc,, +skvideo/measure/__pycache__/mad.cpython-38.pyc,, +skvideo/measure/__pycache__/mae.cpython-38.pyc,, +skvideo/measure/__pycache__/mse.cpython-38.pyc,, +skvideo/measure/__pycache__/msssim.cpython-38.pyc,, +skvideo/measure/__pycache__/niqe.cpython-38.pyc,, +skvideo/measure/__pycache__/psnr.cpython-38.pyc,, +skvideo/measure/__pycache__/scene.cpython-38.pyc,, +skvideo/measure/__pycache__/setup.cpython-38.pyc,, +skvideo/measure/__pycache__/ssim.cpython-38.pyc,, +skvideo/measure/__pycache__/strred.cpython-38.pyc,, +skvideo/measure/__pycache__/videobliinds.cpython-38.pyc,, +skvideo/measure/__pycache__/viideo.cpython-38.pyc,, +skvideo/measure/brisque.py,sha256=ldiF59V8qumoAmmK5DrcDqCN644dPK_PRGkqZqpzlyM,2570 +skvideo/measure/data/frames_modelparameters.mat,sha256=YefZ4xjlDO-U3wQasLDv59sSrm-lGE_0ujNZDwg0Bro,8351 +skvideo/measure/data/niqe_cov_96.pkl,sha256=2aTXPCO9plz7OVubw12slIaHN1y1CD0YpbbUoxINPx0,5507 +skvideo/measure/data/niqe_image_params.mat,sha256=JpzS1f5M-q5EGIKxBuqEm7sKJ8FxdqPqOu2bvi89-18,10912 +skvideo/measure/data/niqe_mu_96.pkl,sha256=afgs7D45UJ5ByADqGdH5q2lEfXk9HDAU3I_7Rt0Gn_A,440 +skvideo/measure/mad.py,sha256=NqJXz1zPbcNpn1XSQu7QJhA2228BB97gvaUFYqbpLoM,1531 +skvideo/measure/mae.py,sha256=eWhcBpG_d4XNzj2B2pVputac7yk11iod-UZ75FAeSvA,1527 +skvideo/measure/mse.py,sha256=XfEEoRkhZtYCqNnePS6t0WqQJZnx6elHm8ANkREhCu4,1523 +skvideo/measure/msssim.py,sha256=wxiqrHA8ir-sp021scUhJiBAmhikfAvAzFb_bxaMkSg,3840 +skvideo/measure/niqe.py,sha256=snCHzctgIZWPGpkJWB6Hufg_kk_fWKqm5dleWDmMmTk,4897 +skvideo/measure/niqe_original.py,sha256=HorQN1p86bDH2bOLigtEOhDYbORR8_pI2Ai4Wr_S8zk,5686 +skvideo/measure/psnr.py,sha256=TwP64lzUCje1-kVdVU0Ika2PFZvQxKpSZ5g3WXG5i3Y,1757 +skvideo/measure/runb.py,sha256=1_wsR5M_pVsxcQv23M9Nm17w7VLj51Uyj02diwLW9Ik,542 +skvideo/measure/scene.py,sha256=f2ehHR8lRcKQnGN6mcfRhTkilVJFdwQuv9RcdgNOJYE,5248 +skvideo/measure/setup.py,sha256=rxFHBtCQKISUck8jf-ad1I5Q8bpTtYm-ybjwvoCkCcM,226 +skvideo/measure/ssim.py,sha256=XJZeE_0cSD2cL2ogN1uy7602zQj7gwRn8i8KCxj1Uow,8260 +skvideo/measure/strred.py,sha256=0T5GkdD2r5dcrD43XHAT94NxNV1IHWziAWpmMfxv1RQ,5590 +skvideo/measure/videobliinds.py,sha256=sIHkAoUASSohF1RUONrTebR4qJCooBRx_UcaNiQW6WU,12703 +skvideo/measure/viideo.py,sha256=-PGKdf77f85F-HmtR7xRm6Je6w0fazlHIv6E1OWUrc8,6845 +skvideo/motion/__init__.py,sha256=tkhJRLs-hiC_0pe9LS8yYOvzklxd9ZR5n3w1VA-S3hE,158 +skvideo/motion/__pycache__/__init__.cpython-38.pyc,, +skvideo/motion/__pycache__/block.cpython-38.pyc,, +skvideo/motion/__pycache__/gme.cpython-38.pyc,, +skvideo/motion/block.py,sha256=g3z9mL_UGgscYiUu1Bpdfsf_woVHFqCxl40a1N2WUrs,39474 +skvideo/motion/gme.py,sha256=xs-LKxYUMZYGkgaWEFkvmq7L6y5-BWkEO4aZCL7WHeU,3203 +skvideo/setup.py,sha256=py7SZ5MoMfcnZopxCjQEUkIwK6cw3r0hZG0wJkDATCs,405 +skvideo/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +skvideo/tests/__pycache__/__init__.cpython-38.pyc,, +skvideo/tests/__pycache__/test_IOfail.cpython-38.pyc,, +skvideo/tests/__pycache__/test_ffmpeg.cpython-38.pyc,, +skvideo/tests/__pycache__/test_libav.cpython-38.pyc,, +skvideo/tests/__pycache__/test_measure.cpython-38.pyc,, +skvideo/tests/__pycache__/test_measure2.cpython-38.pyc,, +skvideo/tests/__pycache__/test_motion.cpython-38.pyc,, +skvideo/tests/__pycache__/test_path.cpython-38.pyc,, +skvideo/tests/__pycache__/test_pattern.cpython-38.pyc,, +skvideo/tests/__pycache__/test_scenedet.cpython-38.pyc,, +skvideo/tests/__pycache__/test_vread.cpython-38.pyc,, +skvideo/tests/__pycache__/test_vreader.cpython-38.pyc,, +skvideo/tests/__pycache__/test_vwrite.cpython-38.pyc,, +skvideo/tests/test_IOfail.py,sha256=lUDnWaTXjmFm-IUNjp85kYYqgHAl6kx1leuGCHeLJpA,944 +skvideo/tests/test_ffmpeg.py,sha256=Cp100W0XBGMs16GHLIvrhBjN9rIyKwj1CdQK4ww_72E,3908 +skvideo/tests/test_libav.py,sha256=zZGTfrFd8vM4N254ABTGwDjr8KRNRkJ2r_Kj3wMwjpU,5650 +skvideo/tests/test_measure.py,sha256=G5j-jIaqU4mLcIndejzQXtay4JmntC96sfhAXdAJhQw,6485 +skvideo/tests/test_measure2.py,sha256=ovVUnAr32tBzC4QlRdXMU-r3-Hf6iO2nY52kmssvPQo,674 +skvideo/tests/test_motion.py,sha256=gIpnhmCIMaRV_8EvwglH-6OTxd26g3unLYO7BJx-26o,3166 +skvideo/tests/test_path.py,sha256=PqTGJp2qRYpAZYHEBH_e4XG-4nFY8hUhRWKzrtWGQuM,1929 +skvideo/tests/test_pattern.py,sha256=kHXDCRA8-e3TNRmLo4C4y4jWbKQc1mfAEgfoAf2IOYY,3444 +skvideo/tests/test_scenedet.py,sha256=1kt7JbtxyZwA4SmT8gM1UI-dqqanOd03Bgyj_m4hTDE,886 +skvideo/tests/test_vread.py,sha256=WHZRHrpIokvo1mFUqAicqGQjfeRWKPQ7qIWXbesjyUs,5660 +skvideo/tests/test_vreader.py,sha256=JdXZGv3czufQubLkRX2OEyvYlmfDjztq5KSRE1nsLQ8,1092 +skvideo/tests/test_vwrite.py,sha256=iYiQdj6Q0Aztp7BDiKYFPutaolQElax81YYdfd-ypAo,1261 +skvideo/utils/__init__.py,sha256=VJVEiCUd_NubH2wl0ZTeaOpV47nrJSSf9gLF3Jye8Mw,10232 +skvideo/utils/__pycache__/__init__.cpython-38.pyc,, +skvideo/utils/__pycache__/edge.cpython-38.pyc,, +skvideo/utils/__pycache__/mscn.cpython-38.pyc,, +skvideo/utils/__pycache__/stats.cpython-38.pyc,, +skvideo/utils/__pycache__/stpyr.cpython-38.pyc,, +skvideo/utils/__pycache__/xmltodict.cpython-38.pyc,, +skvideo/utils/edge.py,sha256=2AU1JkW5ZQa_-E147zrdOsGAjLpNSVvm8UwNvZGVFlY,5405 +skvideo/utils/mscn.py,sha256=0cymVLbWVk2s3SR8_CAoC6dQATSJLQLCCsWxZ1GfO1Y,1284 +skvideo/utils/stats.py,sha256=aJCfSNxRMaJQ4bp1Z9PONtBlzUlOIp11aCOE26c4plU,2206 +skvideo/utils/stpyr.py,sha256=Jh3i-oKEmdjCo7p-AavT5apjNtHPj65p6_Rc7t2d7Pc,19304 +skvideo/utils/xmltodict.py,sha256=cg_dY9XbmYD86z8ju0tYsoZiPcylZgToEJ4FB_WG-xQ,15157 diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/scikit_video-1.1.11.dist-info/REQUESTED b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/scikit_video-1.1.11.dist-info/REQUESTED new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/scikit_video-1.1.11.dist-info/WHEEL b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/scikit_video-1.1.11.dist-info/WHEEL new file mode 100644 index 0000000000000000000000000000000000000000..8b6dd1b5a884bfc07b5f771ab5dc56ed02323531 --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/scikit_video-1.1.11.dist-info/WHEEL @@ -0,0 +1,6 @@ +Wheel-Version: 1.0 +Generator: bdist_wheel (0.29.0) +Root-Is-Purelib: true +Tag: py2-none-any +Tag: py3-none-any + diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/scikit_video-1.1.11.dist-info/metadata.json b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/scikit_video-1.1.11.dist-info/metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..80070a16111409d479e7525ce9ddb3f503c5fa81 --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/scikit_video-1.1.11.dist-info/metadata.json @@ -0,0 +1 @@ +{"classifiers": ["Development Status :: 3 - Alpha", "Intended Audience :: Developers", "Intended Audience :: Science/Research", "License :: OSI Approved :: BSD License", "Operating System :: POSIX :: Linux", "Operating System :: MacOS", "Operating System :: Microsoft :: Windows", "Programming Language :: Python :: 2.6", "Programming Language :: Python :: 2.7", "Programming Language :: Python :: 3.6", "Topic :: Multimedia :: Video", "Topic :: Scientific/Engineering"], "description_content_type": "UNKNOWN", "download_url": "https://github.com/scikit-video/scikit-video", "extensions": {"python.details": {"contacts": [{"email": "info@scikit-video.org", "name": "('Todd Goodall',)", "role": "author"}], "document_names": {"description": "DESCRIPTION.rst"}, "project_urls": {"Home": "http://scikit-video.org/"}}}, "extras": [], "generator": "bdist_wheel (0.29.0)", "license": "BSD", "metadata_version": "2.0", "name": "scikit-video", "run_requires": [{"requires": ["numpy", "pillow", "scipy"]}], "summary": "Video Processing in Python", "version": "1.1.11"} \ No newline at end of file diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/scikit_video-1.1.11.dist-info/top_level.txt b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/scikit_video-1.1.11.dist-info/top_level.txt new file mode 100644 index 0000000000000000000000000000000000000000..ee4392a62487bda2beceab6b76cd62b830b340c5 --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/scikit_video-1.1.11.dist-info/top_level.txt @@ -0,0 +1 @@ +skvideo diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/timm/__init__.py b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/timm/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..3d38cdb978f4130e6d02bc9503d1eaa2c1d74e92 --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/timm/__init__.py @@ -0,0 +1,4 @@ +from .version import __version__ +from .layers import is_scriptable, is_exportable, set_scriptable, set_exportable +from .models import create_model, list_models, list_pretrained, is_model, list_modules, model_entrypoint, \ + is_model_pretrained, get_pretrained_cfg, get_pretrained_cfg_value diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/timm/version.py b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/timm/version.py new file mode 100644 index 0000000000000000000000000000000000000000..2affa6a8e46d7a9b4e7a2922f590442e8ec9bd09 --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/timm/version.py @@ -0,0 +1 @@ +__version__ = '0.9.16' diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/torchvision.libs/libz.1328edc3.so.1 b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/torchvision.libs/libz.1328edc3.so.1 new file mode 100644 index 0000000000000000000000000000000000000000..e64e40188b54dc5bbf7ba2bc6dd5e25f51cdc27f Binary files /dev/null and b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/torchvision.libs/libz.1328edc3.so.1 differ diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/wandb-0.12.21.dist-info/INSTALLER b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/wandb-0.12.21.dist-info/INSTALLER new file mode 100644 index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68 --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/wandb-0.12.21.dist-info/INSTALLER @@ -0,0 +1 @@ +pip diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/wandb-0.12.21.dist-info/LICENSE b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/wandb-0.12.21.dist-info/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..1f4e645404cd4ae9f131e45091c1cf9db97af225 --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/wandb-0.12.21.dist-info/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2021 Weights and Biases, Inc. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/wandb-0.12.21.dist-info/METADATA b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/wandb-0.12.21.dist-info/METADATA new file mode 100644 index 0000000000000000000000000000000000000000..a1beb3b7ef71db3991cf161aab2defb05236562d --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/wandb-0.12.21.dist-info/METADATA @@ -0,0 +1,168 @@ +Metadata-Version: 2.1 +Name: wandb +Version: 0.12.21 +Summary: A CLI and library for interacting with the Weights and Biases API. +Home-page: https://github.com/wandb/client +Author: Weights & Biases +Author-email: support@wandb.com +License: MIT license +Classifier: Development Status :: 5 - Production/Stable +Classifier: Intended Audience :: Developers +Classifier: Intended Audience :: Science/Research +Classifier: License :: OSI Approved :: MIT License +Classifier: Natural Language :: English +Classifier: Programming Language :: Python :: 3 :: Only +Classifier: Programming Language :: Python :: 3.6 +Classifier: Programming Language :: Python :: 3.7 +Classifier: Programming Language :: Python :: 3.8 +Classifier: Programming Language :: Python :: 3.9 +Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence +Classifier: Topic :: Software Development :: Libraries :: Python Modules +Classifier: Topic :: System :: Logging +Classifier: Topic :: System :: Monitoring +Requires-Python: >=3.6 +Description-Content-Type: text/markdown +License-File: LICENSE +Requires-Dist: Click (!=8.0.0,>=7.0) +Requires-Dist: GitPython (>=1.0.0) +Requires-Dist: requests (<3,>=2.0.0) +Requires-Dist: promise (<3,>=2.0) +Requires-Dist: shortuuid (>=0.5.0) +Requires-Dist: psutil (>=5.0.0) +Requires-Dist: sentry-sdk (>=1.0.0) +Requires-Dist: six (>=1.13.0) +Requires-Dist: docker-pycreds (>=0.4.0) +Requires-Dist: protobuf (<4.0dev,>=3.12.0) +Requires-Dist: PyYAML +Requires-Dist: pathtools +Requires-Dist: setproctitle +Requires-Dist: setuptools +Provides-Extra: aws +Requires-Dist: boto3 ; extra == 'aws' +Provides-Extra: azure +Requires-Dist: azure-storage-blob ; extra == 'azure' +Provides-Extra: gcp +Requires-Dist: google-cloud-storage ; extra == 'gcp' +Provides-Extra: grpc +Requires-Dist: grpcio (>=1.27.2) ; extra == 'grpc' +Provides-Extra: kubeflow +Requires-Dist: kubernetes ; extra == 'kubeflow' +Requires-Dist: minio ; extra == 'kubeflow' +Requires-Dist: google-cloud-storage ; extra == 'kubeflow' +Requires-Dist: sh ; extra == 'kubeflow' +Provides-Extra: launch +Requires-Dist: nbconvert ; extra == 'launch' +Requires-Dist: nbformat ; extra == 'launch' +Requires-Dist: chardet ; extra == 'launch' +Requires-Dist: iso8601 ; extra == 'launch' +Requires-Dist: typing-extensions ; extra == 'launch' +Requires-Dist: boto3 ; extra == 'launch' +Requires-Dist: google-cloud-storage ; extra == 'launch' +Requires-Dist: kubernetes ; extra == 'launch' +Provides-Extra: media +Requires-Dist: numpy ; extra == 'media' +Requires-Dist: moviepy ; extra == 'media' +Requires-Dist: pillow ; extra == 'media' +Requires-Dist: bokeh ; extra == 'media' +Requires-Dist: soundfile ; extra == 'media' +Requires-Dist: plotly ; extra == 'media' +Requires-Dist: rdkit-pypi ; extra == 'media' +Provides-Extra: models +Requires-Dist: cloudpickle ; extra == 'models' +Provides-Extra: service +Provides-Extra: sweeps +Requires-Dist: sweeps (>=0.1.0) ; extra == 'sweeps' + +
+

+
+ +# Weights and Biases [![ci](https://circleci.com/gh/wandb/client.svg?style=svg)](https://circleci.com/gh/wandb/client) [![pypi](https://img.shields.io/pypi/v/wandb.svg)](https://pypi.python.org/pypi/wandb) [![codecov](https://codecov.io/gh/wandb/client/branch/master/graph/badge.svg?token=41Iw2WzViQ)](https://codecov.io/gh/wandb/client) + +Use W&B to build better models faster. Track and visualize all the pieces of your machine learning pipeline, from datasets to production models. + +- Quickly identify model regressions. Use W&B to visualize results in real time, all in a central dashboard. +- Focus on the interesting ML. Spend less time manually tracking results in spreadsheets and text files. +- Capture dataset versions with W&B Artifacts to identify how changing data affects your resulting models. +- Reproduce any model, with saved code, hyperparameters, launch commands, input data, and resulting model weights. + +[Sign up for a free account →](https://wandb.ai/login?signup=true) + +## Features + +- Store hyper-parameters used in a training run +- Search, compare, and visualize training runs +- Analyze system usage metrics alongside runs +- Collaborate with team members +- Replicate historic results +- Run parameter sweeps +- Keep records of experiments available forever + +[Documentation →](https://docs.wandb.com) + +## Quickstart + +```shell +pip install wandb +``` + +In your training script: + +```python +import wandb +# Your custom arguments defined here +args = ... + +wandb.init(config=args, project="my-project") +wandb.config["more"] = "custom" + +def training_loop(): + while True: + # Do some machine learning + epoch, loss, val_loss = ... + # Framework agnostic / custom metrics + wandb.log({"epoch": epoch, "loss": loss, "val_loss": val_loss}) +``` + +If you're already using Tensorboard or [TensorboardX](https://github.com/lanpa/tensorboardX), you can integrate with one line: + +```python +wandb.init(sync_tensorboard=True) +``` + +## Running your script + +Run `wandb login` from your terminal to signup or authenticate your machine (we store your api key in ~/.netrc). You can also set the `WANDB_API_KEY` environment variable with a key from your [settings](https://app.wandb.ai/settings). + +Run your script with `python my_script.py` and all metadata will be synced to the cloud. You will see a url in your terminal logs when your script starts and finishes. Data is staged locally in a directory named _wandb_ relative to your script. If you want to test your script without syncing to the cloud you can set the environment variable `WANDB_MODE=dryrun`. + +If you are using [docker](https://docker.com) to run your code, we provide a wrapper command `wandb docker` that mounts your current directory, sets environment variables, and ensures the wandb library is installed. Training your models in docker gives you the ability to restore the exact code and environment with the `wandb restore` command. + +## Web Interface + +[Sign up for a free account →](https://wandb.com) +[![Watch the video](https://i.imgur.com/PW0Ejlc.png)](https://youtu.be/EeqhOSvNX-A) +[Introduction video →](https://youtu.be/EeqhOSvNX-A) + +## Detailed Usage + +Framework specific and detailed usage can be found in our [documentation](http://docs.wandb.com/). + +## Testing + +To run basic test use `make test`. More detailed information can be found at CONTRIBUTING.md. + +We use [circleci](https://circleci.com) for CI. + +# Academic Researchers +If you'd like a free academic account for your research group, [reach out to us →](https://www.wandb.com/academic) + +We make it easy to cite W&B in your published paper. [Learn more →](https://www.wandb.com/academic) +[![](https://i.imgur.com/loKLiez.png)](https://www.wandb.com/academic) + +## Community +Got questions, feedback or want to join a community of ML engineers working on exciting projects? + +slack Join our [slack](https://bit.ly/wb-slack) community. + +[![Twitter](https://img.shields.io/twitter/follow/weights_biases?style=social)](https://twitter.com/weights_biases) Follow us on [Twitter](https://twitter.com/weights_biases). diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/wandb-0.12.21.dist-info/RECORD b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/wandb-0.12.21.dist-info/RECORD new file mode 100644 index 0000000000000000000000000000000000000000..65164503f88cc10a97a1dc20d84695cb46038133 --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/wandb-0.12.21.dist-info/RECORD @@ -0,0 +1,1281 @@ +../../../bin/wandb,sha256=AzimxAP8F3ifb_2lHd4KiGb_XwEHIy0nsfrEh1Ne940,228 +../../../bin/wb,sha256=AzimxAP8F3ifb_2lHd4KiGb_XwEHIy0nsfrEh1Ne940,228 +wandb-0.12.21.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4 +wandb-0.12.21.dist-info/LICENSE,sha256=izOKRJpGOx1PrJiGOKR0HsNdlB5JdH2d0Z4P7a7ssTc,1081 +wandb-0.12.21.dist-info/METADATA,sha256=3BUK_WEb05J7ViR02W3ZkeU5bp84BFNttRq74KBLFQA,7172 +wandb-0.12.21.dist-info/RECORD,, +wandb-0.12.21.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +wandb-0.12.21.dist-info/WHEEL,sha256=z9j0xAa_JmUKMpmz72K0ZGALSM_n-wQVmGbleXx2VHg,110 +wandb-0.12.21.dist-info/entry_points.txt,sha256=v4FCOZ9gW7Pc6KLsmgQqpCiKTrA1wh2XHmNf-NUP1-I,67 +wandb-0.12.21.dist-info/top_level.txt,sha256=gPLPSekU6Labh_9yJz7WLb6Q9DK72I02_ARvDEG9Xsw,6 +wandb/__init__.py,sha256=OIAN8KR9cdJ--NZRw5nByAXKEbmLO86yblXp50MWhPk,6059 +wandb/__main__.py,sha256=gripuDgB7J8wMMeJt4CIBRjn1BMSFr5zvsrt585Pnj4,64 +wandb/__pycache__/__init__.cpython-38.pyc,, +wandb/__pycache__/__main__.cpython-38.pyc,, +wandb/__pycache__/_globals.cpython-38.pyc,, +wandb/__pycache__/data_types.cpython-38.pyc,, +wandb/__pycache__/env.cpython-38.pyc,, +wandb/__pycache__/jupyter.cpython-38.pyc,, +wandb/__pycache__/magic.cpython-38.pyc,, +wandb/__pycache__/trigger.cpython-38.pyc,, +wandb/__pycache__/util.cpython-38.pyc,, +wandb/__pycache__/viz.cpython-38.pyc,, +wandb/__pycache__/wandb_agent.cpython-38.pyc,, +wandb/__pycache__/wandb_controller.cpython-38.pyc,, +wandb/__pycache__/wandb_run.cpython-38.pyc,, +wandb/__pycache__/wandb_torch.cpython-38.pyc,, +wandb/_globals.py,sha256=CccwOAls5bxJArYHg12b08ZeKR8Qu9u57GtYWjBH0o0,702 +wandb/agents/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +wandb/agents/__pycache__/__init__.cpython-38.pyc,, +wandb/agents/__pycache__/pyagent.cpython-38.pyc,, +wandb/agents/pyagent.py,sha256=7cjVvN_gNwi5WINTWJWMLu1dXe-po10p7UNq-uNbeSE,12939 +wandb/apis/__init__.py,sha256=yw2DQaJB4DyQJADLVljtqNVFManXDGZw2dvWxJObeYI,1148 +wandb/apis/__pycache__/__init__.cpython-38.pyc,, +wandb/apis/__pycache__/internal.cpython-38.pyc,, +wandb/apis/__pycache__/normalize.cpython-38.pyc,, +wandb/apis/__pycache__/public.cpython-38.pyc,, +wandb/apis/internal.py,sha256=A4PHI-tw1w-P_LozbCjBRj5JhO9V7QiAikCRVYwxEAY,5380 +wandb/apis/normalize.py,sha256=tTWCllQmGgDI_qmx7pCflqo-C_yKoeHAm2ZiXMK_XRA,1963 +wandb/apis/public.py,sha256=L9drXtdMURNvrZ1lSpD3dyTi7ksB6byoVlOfqq9D7IA,153120 +wandb/apis/reports/__init__.py,sha256=eoMEosndrhIaNdZV1QWNubrfCnK7mybVvDBzLfpDn7w,122 +wandb/apis/reports/__pycache__/__init__.cpython-38.pyc,, +wandb/apis/reports/__pycache__/block_gallery.cpython-38.pyc,, +wandb/apis/reports/__pycache__/blocks.cpython-38.pyc,, +wandb/apis/reports/__pycache__/mutations.cpython-38.pyc,, +wandb/apis/reports/__pycache__/panels.cpython-38.pyc,, +wandb/apis/reports/__pycache__/reports.cpython-38.pyc,, +wandb/apis/reports/__pycache__/util.cpython-38.pyc,, +wandb/apis/reports/__pycache__/validators.cpython-38.pyc,, +wandb/apis/reports/block_gallery.py,sha256=VJ668DzP0UbbkZ-qrWCQ29g1Bkq7NHv_HRS8zLnMi14,99 +wandb/apis/reports/blocks.py,sha256=T8j2Iu-rQ3n9CcSPzClEtCLg8WiW1VT_KxpZmhskqi8,391 +wandb/apis/reports/mutations.py,sha256=SW68qQWBuy_V3BpGiT3Yw6Dh9pHhhDcfH2j1obB0Qg8,1754 +wandb/apis/reports/panels.py,sha256=NQLU7Qs7RVU7to1qDqgkqr51uu6DOcvDib4fAiBPX6Q,350 +wandb/apis/reports/reports.py,sha256=PHFQ_t9X7fddr9dTKjx02_8Wmc6cTO2jZSKJ5JXlIPs,57328 +wandb/apis/reports/util.py,sha256=vuaEgKRsHYFbTHMvrbZg-m_ooIHRzdTuLOaqGugzvwQ,9831 +wandb/apis/reports/validators.py,sha256=C3GJeJYEmoP6y612Zw7hypQsuAzP_sgrualZ42N5WDA,4125 +wandb/beta/__pycache__/workflows.cpython-38.pyc,, +wandb/beta/workflows.py,sha256=WWNiROe0tkpVIPBQ4jMk1HVK_tKEP0Du0lfW_ZRskTY,9745 +wandb/bin/apple_gpu_stats,sha256=-CVDIPhgV1f_jjM1dkXJgmo6AQY4wjy1xCGg1e8zn0w,337072 +wandb/catboost/__init__.py,sha256=gAAH_JMIDviLuGqo2MK2W3KdQEV69KQPTjssL_QGdIM,227 +wandb/catboost/__pycache__/__init__.cpython-38.pyc,, +wandb/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +wandb/cli/__pycache__/__init__.cpython-38.pyc,, +wandb/cli/__pycache__/cli.cpython-38.pyc,, +wandb/cli/cli.py,sha256=AVC7JPVXiy03ICaRW9b0pE0-ovZPzLlnqe35doZu77U,74268 +wandb/data_types.py,sha256=X4hPSwv9eeBKClmXpdSiJREpf1WH77vEPb4-c_g4GkM,75212 +wandb/docker/__init__.py,sha256=seLIgTIC9FcvHq34_N_LkPj2c1lKsJNqIGMua0lsisM,7423 +wandb/docker/__pycache__/__init__.cpython-38.pyc,, +wandb/docker/__pycache__/auth.cpython-38.pyc,, +wandb/docker/__pycache__/www_authenticate.cpython-38.pyc,, +wandb/docker/auth.py,sha256=Ui0Wq41qfZg6E7_TRr3HiCi-T1D8K5eo4U1tuzC4yGQ,13751 +wandb/docker/wandb-entrypoint.sh,sha256=P4eTMG7wYsgTfJIws_HT7QFlYBI70ZLnNlDGTZdmYVE,989 +wandb/docker/www_authenticate.py,sha256=AxP3XZT3tQtIdIRrkJhHwQd1Ubsx6atpPmE6IxXfwYQ,2582 +wandb/env.py,sha256=QF7aFoaH_EgazoK_iY0eFIdjt-BpXb3LYE7-VbTLUn8,8193 +wandb/errors/__init__.py,sha256=1uYnwVgbkqHCvytRbGO1u5dJPPVOKIWUr2fU3iwnSvY,2479 +wandb/errors/__pycache__/__init__.cpython-38.pyc,, +wandb/errors/__pycache__/term.cpython-38.pyc,, +wandb/errors/term.py,sha256=tSafM3NPK31A_P3DUQrT1wwtZXWursGsH46h9l2jR1M,2518 +wandb/fastai/__init__.py,sha256=Er2O8i577OxhG_bCTGn8K1mEgMd5SKwGJmiv3JMSOhk,193 +wandb/fastai/__pycache__/__init__.cpython-38.pyc,, +wandb/filesync/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +wandb/filesync/__pycache__/__init__.cpython-38.pyc,, +wandb/filesync/__pycache__/dir_watcher.cpython-38.pyc,, +wandb/filesync/__pycache__/stats.cpython-38.pyc,, +wandb/filesync/__pycache__/step_checksum.cpython-38.pyc,, +wandb/filesync/__pycache__/step_prepare.cpython-38.pyc,, +wandb/filesync/__pycache__/step_upload.cpython-38.pyc,, +wandb/filesync/__pycache__/upload_job.cpython-38.pyc,, +wandb/filesync/dir_watcher.py,sha256=lq-wWsLigPKg6AfYgjWyPR1SIxr7GZNsF9W9_L4Tfeo,15716 +wandb/filesync/stats.py,sha256=UuL2nPr7BIswblRa6vJCoU84F5SkQo4rM1swyRSgUZE,2840 +wandb/filesync/step_checksum.py,sha256=le7Faap5B_hbSxeaDYp4YHacqZdSMfu9ItG4v_wA2SU,5698 +wandb/filesync/step_prepare.py,sha256=n30BA18lTVRmlu0ANldJHkuvWCqGNKNvU_ZgMVyQOlU,5765 +wandb/filesync/step_upload.py,sha256=2j_3lhvzF7xcc2QLnNRHwdqXq2SY3STwY5j10TSIgz4,7715 +wandb/filesync/upload_job.py,sha256=4pUvE1U1Vc3Iiqo3a1j9njttR5eluFS93NyDAtuJtBc,6016 +wandb/integration/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +wandb/integration/__pycache__/__init__.cpython-38.pyc,, +wandb/integration/__pycache__/magic.cpython-38.pyc,, +wandb/integration/catboost/__init__.py,sha256=BlkX4BLtY0-bOMM2PLpKo-wmDIbQiaUBNWFpbcDx4Y4,128 +wandb/integration/catboost/__pycache__/__init__.cpython-38.pyc,, +wandb/integration/catboost/__pycache__/catboost.cpython-38.pyc,, +wandb/integration/catboost/catboost.py,sha256=7FUj4djlfVuHEUr9GCz0boSQzOaE2vscCGpBYMl99pA,5969 +wandb/integration/fastai/__init__.py,sha256=yBBG--5dIt_OVrf92gZXmGJz8myjK_U1Nk6C3EMhbwE,9583 +wandb/integration/fastai/__pycache__/__init__.cpython-38.pyc,, +wandb/integration/gym/__init__.py,sha256=WcMgvMQXTokSq89-qjyOrHVsw94TzN5U3k7UBkIBBl8,688 +wandb/integration/gym/__pycache__/__init__.cpython-38.pyc,, +wandb/integration/keras/__init__.py,sha256=p6yhUqmC52uPZlER9CFdgWITRwEKn-zHuWe1mx2e1hc,275 +wandb/integration/keras/__pycache__/__init__.cpython-38.pyc,, +wandb/integration/keras/__pycache__/keras.cpython-38.pyc,, +wandb/integration/keras/keras.py,sha256=kycmJVdov96k6UqKfXB9MFkSrqG2DwDMCJr2WFJ4QeI,43142 +wandb/integration/kfp/__init__.py,sha256=WhBhg3mQopGNDbWzGJ8Xyld8w3FAAvmP1G1Wtv_QaC0,136 +wandb/integration/kfp/__pycache__/__init__.cpython-38.pyc,, +wandb/integration/kfp/__pycache__/helpers.cpython-38.pyc,, +wandb/integration/kfp/__pycache__/kfp_patch.cpython-38.pyc,, +wandb/integration/kfp/__pycache__/wandb_logging.cpython-38.pyc,, +wandb/integration/kfp/helpers.py,sha256=yEVO9rrz27hc4nk3WwNL3v1aRAUlS-OlXMC8Rj0G1tI,1016 +wandb/integration/kfp/kfp_patch.py,sha256=pumSfap-_BPqW352Tfw92XRM6CRIDewUvIJ8CuIH218,13014 +wandb/integration/kfp/wandb_logging.py,sha256=cPhPMxV9RNzLjWeV4k6z-6pMUxIMDQ84kEhPYbM738I,6159 +wandb/integration/lightgbm/__init__.py,sha256=MZcfJZV_VnSH1mLqWshR2O_esudoNnvkWC5ExYMNK34,7178 +wandb/integration/lightgbm/__pycache__/__init__.cpython-38.pyc,, +wandb/integration/magic.py,sha256=SFeGwHC8xfQHHdk-AOKMnJNXc5yJo3clMMNdOEtrHVA,17242 +wandb/integration/metaflow/__init__.py,sha256=nYn3ubiX9Ay6PFxr7r7F8Ia_2dLImb63rpYDmuDlkkQ,109 +wandb/integration/metaflow/__pycache__/__init__.cpython-38.pyc,, +wandb/integration/metaflow/__pycache__/metaflow.cpython-38.pyc,, +wandb/integration/metaflow/metaflow.py,sha256=Qa8T-MBvpONkF7wahMPZTmeatmJzw9RvM96ZZ61P9RI,11670 +wandb/integration/prodigy/__init__.py,sha256=1-Hg98Y4T1kSNAbrlR9TUrr7dwL1Gxxa-Exu0fsfxl0,66 +wandb/integration/prodigy/__pycache__/__init__.cpython-38.pyc,, +wandb/integration/prodigy/__pycache__/prodigy.cpython-38.pyc,, +wandb/integration/prodigy/prodigy.py,sha256=NpZem6KBdTKZ9lY6zZrNpfs9quMVccajqOYxA96KFNo,11600 +wandb/integration/sacred/__init__.py,sha256=4lg69Tk3C9X0mdIsMfOyPYpJVa0Y3l5Qs5El4OOUHJo,5759 +wandb/integration/sacred/__pycache__/__init__.cpython-38.pyc,, +wandb/integration/sagemaker/__init__.py,sha256=uKEx_Qst9uk0GrOqg_JYi3pSmjNrXb0RuOPSHtDidw8,284 +wandb/integration/sagemaker/__pycache__/__init__.cpython-38.pyc,, +wandb/integration/sagemaker/__pycache__/auth.cpython-38.pyc,, +wandb/integration/sagemaker/__pycache__/config.cpython-38.pyc,, +wandb/integration/sagemaker/__pycache__/files.cpython-38.pyc,, +wandb/integration/sagemaker/__pycache__/resources.cpython-38.pyc,, +wandb/integration/sagemaker/auth.py,sha256=LnAJEv3_1bLq6HkKYvZp9Ydktsgh08VCa6PJ3_u6U2g,975 +wandb/integration/sagemaker/config.py,sha256=1_qIHBi7CymYOVNnDun1SyrV-_wRJ-7-xOwc-cjEqoE,801 +wandb/integration/sagemaker/files.py,sha256=DcAP4h3DiEniB_NkP_g8nxvoWHkV3tn93Mk1GzABYyI,153 +wandb/integration/sagemaker/resources.py,sha256=TvIG77sKbaur12QpUQbJCyd3teArogp8B2sWBgcDHAA,900 +wandb/integration/sb3/__init__.py,sha256=w_VX7C6qAE1vK7xb24JchQtORxzfpXvl6YmZHUIskJM,60 +wandb/integration/sb3/__pycache__/__init__.cpython-38.pyc,, +wandb/integration/sb3/__pycache__/sb3.cpython-38.pyc,, +wandb/integration/sb3/sb3.py,sha256=DDcKCWQuHUG_OTDXtj7NqvOQvvPyKDI5fYTl3y_tpUU,4841 +wandb/integration/tensorboard/__init__.py,sha256=FhKb5cjAWK9NqHP7ZlYRAtzi9nz0-bjZQyA2csnZF_E,215 +wandb/integration/tensorboard/__pycache__/__init__.cpython-38.pyc,, +wandb/integration/tensorboard/__pycache__/log.cpython-38.pyc,, +wandb/integration/tensorboard/__pycache__/monkeypatch.cpython-38.pyc,, +wandb/integration/tensorboard/log.py,sha256=b4RvMRcpOwg8JK1CqLJueJBr2vE5DV7tC4qH01z-ZGY,14345 +wandb/integration/tensorboard/monkeypatch.py,sha256=p6fuiMeTkhe-gghyl2jao24xvYv1JLl1wEkF4XcKdJk,6746 +wandb/integration/tensorflow/__init__.py,sha256=7uulpVfg5Na2o7Y2bxq0RMI2TmIGJakrDeNFqmYAo_k,127 +wandb/integration/tensorflow/__pycache__/__init__.cpython-38.pyc,, +wandb/integration/tensorflow/__pycache__/estimator_hook.cpython-38.pyc,, +wandb/integration/tensorflow/estimator_hook.py,sha256=JwE4WmHfkddFPDm63pHFq4egaMjCGxj4wubSSjzvcfo,1756 +wandb/integration/torch/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +wandb/integration/torch/__pycache__/__init__.cpython-38.pyc,, +wandb/integration/xgboost/__init__.py,sha256=7mzsanhwAtQK429y0tKgv6S4uBFQhfPgHvTcEhBaTtk,374 +wandb/integration/xgboost/__pycache__/__init__.cpython-38.pyc,, +wandb/integration/xgboost/__pycache__/xgboost.cpython-38.pyc,, +wandb/integration/xgboost/xgboost.py,sha256=dDhbKt_EGe8TBbTGo7i1Aw3MMfbIu3hyjnwdhsE-DnU,6497 +wandb/jupyter.py,sha256=OCXRe8oQDIiYroHkOaf2YN4X2-AZRcDBgjFUPc7Y938,16763 +wandb/keras/__init__.py,sha256=3GnD0VbhFPtshPcBfeJty416CkwwF_gHZp3eHcZgBdk,206 +wandb/keras/__pycache__/__init__.cpython-38.pyc,, +wandb/lightgbm/__init__.py,sha256=RD_LJvn6ndc0Y_aL13VB53i4Ttk0-RPXnUynESEO-N8,230 +wandb/lightgbm/__pycache__/__init__.cpython-38.pyc,, +wandb/magic.py,sha256=7jS_Zrqk0vBi4sYIQvz0BJuoJtz7jWvoUJpLkyaVrz8,60 +wandb/mpmain/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +wandb/mpmain/__main__.py,sha256=bLhspPeHQvNMyRNR7xi9v-02XfW1mhJY2yBWI3bYtbg,57 +wandb/mpmain/__pycache__/__init__.cpython-38.pyc,, +wandb/mpmain/__pycache__/__main__.cpython-38.pyc,, +wandb/old/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +wandb/old/__pycache__/__init__.cpython-38.pyc,, +wandb/old/__pycache__/core.cpython-38.pyc,, +wandb/old/__pycache__/settings.cpython-38.pyc,, +wandb/old/__pycache__/summary.cpython-38.pyc,, +wandb/old/core.py,sha256=tiUjgEdlNrAUInEz0JHIJbKs32WQJ1eK_h6T4Kl0OD0,3716 +wandb/old/settings.py,sha256=_VESaNgzKasF9Vy4PtZlK1H7C2CIybxwfWw7zBZ27-0,4301 +wandb/old/summary.py,sha256=ysVPcUNW973FsU_W0sILzhl0kz-3wHR1rWQQUtj6y0g,13451 +wandb/plot/__init__.py,sha256=85EyvJWul9j_fEXAYxSeH9N1mDVw0fkRtf98AEiBrfw,481 +wandb/plot/__pycache__/__init__.cpython-38.pyc,, +wandb/plot/__pycache__/bar.cpython-38.pyc,, +wandb/plot/__pycache__/confusion_matrix.cpython-38.pyc,, +wandb/plot/__pycache__/histogram.cpython-38.pyc,, +wandb/plot/__pycache__/line.cpython-38.pyc,, +wandb/plot/__pycache__/line_series.cpython-38.pyc,, +wandb/plot/__pycache__/pr_curve.cpython-38.pyc,, +wandb/plot/__pycache__/roc_curve.cpython-38.pyc,, +wandb/plot/__pycache__/scatter.cpython-38.pyc,, +wandb/plot/bar.py,sha256=tT1GLwHrA67ZaSeTCFPtlU62SjWNBqOQ-ELKK2PqNuc,922 +wandb/plot/confusion_matrix.py,sha256=s723ggzBllkW3rBd1W5cfQlAuOV2Osvg6MH64scTz34,3213 +wandb/plot/histogram.py,sha256=pVawrazOSU6Q_np8TpRWWNKjZV88EQguVMm0zevdWTQ,765 +wandb/plot/line.py,sha256=HIcdITbYoCd13EHpSZhvCBIXlLgVg0ApcwK8vKPH2tg,947 +wandb/plot/line_series.py,sha256=L71yGDtXDa4QmCc3Qtl0e8SJbrgzzMvhwgCg8LE15Lc,2751 +wandb/plot/pr_curve.py,sha256=IoLx06v5OOXMwvuiNxwSMj3LTjTJVxK3dyQEdwizcdY,4839 +wandb/plot/roc_curve.py,sha256=9qe2fS3fXxNc43kWqy9iauyUivpH73CwgSQMrknMSoo,3687 +wandb/plot/scatter.py,sha256=_IJVT6Ks0mKAqcnTUp13cn4FSdRUU1Y2-Nr9tqv1UCM,749 +wandb/plots/__init__.py,sha256=57wa19yyEkPQi6GGPPW7Cx1ddGz-xUa21CqL3zawvn0,331 +wandb/plots/__pycache__/__init__.cpython-38.pyc,, +wandb/plots/__pycache__/explain_text.cpython-38.pyc,, +wandb/plots/__pycache__/heatmap.cpython-38.pyc,, +wandb/plots/__pycache__/named_entity.cpython-38.pyc,, +wandb/plots/__pycache__/part_of_speech.cpython-38.pyc,, +wandb/plots/__pycache__/plot_definitions.cpython-38.pyc,, +wandb/plots/__pycache__/precision_recall.cpython-38.pyc,, +wandb/plots/__pycache__/roc.cpython-38.pyc,, +wandb/plots/__pycache__/utils.cpython-38.pyc,, +wandb/plots/explain_text.py,sha256=ySOqdtLrEgwIAAXHHVer42FxjYXI18MnTRCKPO_WR3A,1254 +wandb/plots/heatmap.py,sha256=Vc-s_8UxEeLWjTkdpCS0CVU3tqULLK9F73z9F8W2Tu8,2755 +wandb/plots/named_entity.py,sha256=dPCie9THwNA0Qq9CONUUhygU8P560gFJs__34GppqYo,1189 +wandb/plots/part_of_speech.py,sha256=f7w1dLwzneUyWT-vW8SU5Wb52g2TGxh2Z243Cb2fQls,1416 +wandb/plots/plot_definitions.py,sha256=G2Q6I7yKhCxRSzJd_nZnDTuuJgKyfRWN3MXNlwAepXw,19402 +wandb/plots/precision_recall.py,sha256=EnKSBxBIfmF7zP6vJuNkPdJN31OsPM-dEZJfTZ70YgQ,4666 +wandb/plots/roc.py,sha256=WLP_xiJcSrHQ-7PEFxge1lZPFcx8NxGVNTCVk0Y2ulQ,3433 +wandb/plots/utils.py,sha256=SMPrJrjgES6SGKavN-T2Wv0KoZHKAtNcXTWM-HA2qfA,7185 +wandb/proto/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +wandb/proto/__pycache__/__init__.cpython-38.pyc,, +wandb/proto/__pycache__/wandb_base_pb2.cpython-38.pyc,, +wandb/proto/__pycache__/wandb_deprecated.cpython-38.pyc,, +wandb/proto/__pycache__/wandb_internal_codegen.cpython-38.pyc,, +wandb/proto/__pycache__/wandb_internal_pb2.cpython-38.pyc,, +wandb/proto/__pycache__/wandb_server_pb2.cpython-38.pyc,, +wandb/proto/__pycache__/wandb_server_pb2_grpc.cpython-38.pyc,, +wandb/proto/__pycache__/wandb_telemetry_pb2.cpython-38.pyc,, +wandb/proto/wandb_base_pb2.py,sha256=nQyi4Buviy5vRHhJfItJyiOgvV7mdQQ5YWljYHOXxI0,5178 +wandb/proto/wandb_deprecated.py,sha256=z2jNz0BR2qjYcPzxrSaQS9BUO0e6IstQMJdX0BYd2a8,1060 +wandb/proto/wandb_internal_codegen.py,sha256=pgLvp6fhnPaXD5DwSngzz4QnQUdegHRd2jxEpkf-j_g,3310 +wandb/proto/wandb_internal_pb2.py,sha256=J0N7Iz3cT8SQrYoi3dxRsULnu6IkDSuzxKWOmF4XQ6E,259932 +wandb/proto/wandb_server_pb2.py,sha256=u0NUMxIJEKUI1ZPJqDHMeYWPuD3kulxSAtCNyFwtHdE,71515 +wandb/proto/wandb_server_pb2_grpc.py,sha256=Ugl0PXHsU6UZ3WJ86MxyjO8iHtGC8IeHEo7Cf0Y_EIo,60824 +wandb/proto/wandb_telemetry_pb2.py,sha256=_N_ygQx5arw1WdxgIUMKJFSay9sNl-cH9Y7iR8jrxHU,74249 +wandb/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +wandb/sacred/__init__.py,sha256=2sCLXqvkwjEqOvPFdtAtmo80PY4hky7rj4owO5PoJWQ,80 +wandb/sacred/__pycache__/__init__.cpython-38.pyc,, +wandb/sdk/__init__.py,sha256=wZ4cQd9dqkpM0y08PF1PyEoAkw9Xtmbm8Gv__JcsTVA,720 +wandb/sdk/__pycache__/__init__.cpython-38.pyc,, +wandb/sdk/__pycache__/wandb_alerts.cpython-38.pyc,, +wandb/sdk/__pycache__/wandb_artifacts.cpython-38.pyc,, +wandb/sdk/__pycache__/wandb_config.cpython-38.pyc,, +wandb/sdk/__pycache__/wandb_helper.cpython-38.pyc,, +wandb/sdk/__pycache__/wandb_init.cpython-38.pyc,, +wandb/sdk/__pycache__/wandb_login.cpython-38.pyc,, +wandb/sdk/__pycache__/wandb_manager.cpython-38.pyc,, +wandb/sdk/__pycache__/wandb_metric.cpython-38.pyc,, +wandb/sdk/__pycache__/wandb_require.cpython-38.pyc,, +wandb/sdk/__pycache__/wandb_require_helpers.cpython-38.pyc,, +wandb/sdk/__pycache__/wandb_run.cpython-38.pyc,, +wandb/sdk/__pycache__/wandb_save.cpython-38.pyc,, +wandb/sdk/__pycache__/wandb_settings.cpython-38.pyc,, +wandb/sdk/__pycache__/wandb_setup.cpython-38.pyc,, +wandb/sdk/__pycache__/wandb_summary.cpython-38.pyc,, +wandb/sdk/__pycache__/wandb_sweep.cpython-38.pyc,, +wandb/sdk/__pycache__/wandb_watch.cpython-38.pyc,, +wandb/sdk/backend/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +wandb/sdk/backend/__pycache__/__init__.cpython-38.pyc,, +wandb/sdk/backend/__pycache__/backend.cpython-38.pyc,, +wandb/sdk/backend/backend.py,sha256=Da_7FOsVJT1oGZ8rYQsLvQkGRtdDMpJG3CnMtYliiyc,8655 +wandb/sdk/data_types/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +wandb/sdk/data_types/__pycache__/__init__.cpython-38.pyc,, +wandb/sdk/data_types/__pycache__/_dtypes.cpython-38.pyc,, +wandb/sdk/data_types/__pycache__/_private.cpython-38.pyc,, +wandb/sdk/data_types/__pycache__/histogram.cpython-38.pyc,, +wandb/sdk/data_types/__pycache__/html.cpython-38.pyc,, +wandb/sdk/data_types/__pycache__/image.cpython-38.pyc,, +wandb/sdk/data_types/__pycache__/molecule.cpython-38.pyc,, +wandb/sdk/data_types/__pycache__/object_3d.cpython-38.pyc,, +wandb/sdk/data_types/__pycache__/plotly.cpython-38.pyc,, +wandb/sdk/data_types/__pycache__/saved_model.cpython-38.pyc,, +wandb/sdk/data_types/__pycache__/utils.cpython-38.pyc,, +wandb/sdk/data_types/__pycache__/video.cpython-38.pyc,, +wandb/sdk/data_types/_dtypes.py,sha256=kqWw3x0eEd8nh1R9-wA1Qqilu8NUwrP_15E2jfGX89c,30236 +wandb/sdk/data_types/_private.py,sha256=IEDH2Qu3YIVow2XbMs-7BhPo1qi42KkClSiRr6O6IVY,72 +wandb/sdk/data_types/base_types/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +wandb/sdk/data_types/base_types/__pycache__/__init__.cpython-38.pyc,, +wandb/sdk/data_types/base_types/__pycache__/json_metadata.cpython-38.pyc,, +wandb/sdk/data_types/base_types/__pycache__/media.cpython-38.pyc,, +wandb/sdk/data_types/base_types/__pycache__/wb_value.cpython-38.pyc,, +wandb/sdk/data_types/base_types/json_metadata.py,sha256=T1V_AK644kJ_6SEW_CCJHvUSnjVhH36-Ey8JwgF6ZxE,1541 +wandb/sdk/data_types/base_types/media.py,sha256=FTVQsZVNvPEF2uTJNuwpfHOcpE8wk-NDIovv9-ykCLA,11804 +wandb/sdk/data_types/base_types/wb_value.py,sha256=rj152lBTdBMVaPaaL0dzn0z8Q0Zs1vDeVwzMoj9_6Xs,11072 +wandb/sdk/data_types/helper_types/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +wandb/sdk/data_types/helper_types/__pycache__/__init__.cpython-38.pyc,, +wandb/sdk/data_types/helper_types/__pycache__/bounding_boxes_2d.cpython-38.pyc,, +wandb/sdk/data_types/helper_types/__pycache__/classes.cpython-38.pyc,, +wandb/sdk/data_types/helper_types/__pycache__/image_mask.cpython-38.pyc,, +wandb/sdk/data_types/helper_types/bounding_boxes_2d.py,sha256=0gC_b_qIpR5JdaNE_w46fYL1O4qkFHWcuifqM-RWFDU,14298 +wandb/sdk/data_types/helper_types/classes.py,sha256=WeCBxhxniSuZ7YhGG6c9dFoR-wRCkpM4JNDM_uP0GlA,5544 +wandb/sdk/data_types/helper_types/image_mask.py,sha256=KrFEhfGj-28d326kHULywyCjO4yBI9fsZLOs-6Aglk0,8805 +wandb/sdk/data_types/histogram.py,sha256=01_MxumM8gYm1n0x3KiFFTpZ2m8AIvG-Gnn_XbEExNM,3224 +wandb/sdk/data_types/html.py,sha256=lwdVsmAgeKjlTNWOHeyFVRMN8TAtHvl62ms_p2Lt4FM,3526 +wandb/sdk/data_types/image.py,sha256=kAWPSQ3ivTa_RgaZUDttzH_woej-3LtS66N2C8LTB2c,23030 +wandb/sdk/data_types/molecule.py,sha256=_ML2ZAeX0k-2UO7E1bqKREQIY2MO7kQrw3bDkJ4TXaw,8614 +wandb/sdk/data_types/object_3d.py,sha256=ikLPKX_joG8AovRq-wxTJmE1ceG_SZ2rAluHk2bEfpU,7644 +wandb/sdk/data_types/plotly.py,sha256=m4XRPH_XtnTf6J8ZIUohizy_cX1OpzfvjOZRIfpp3eU,2916 +wandb/sdk/data_types/saved_model.py,sha256=Ji7BWqARwXaZP3zq7IhYn4QdIzqXC1pfM0ZYwUZy0Zw,16554 +wandb/sdk/data_types/utils.py,sha256=2c9fLtn6crRiQJZVjNhsCpddHf02H30okvpcdVq52d0,6249 +wandb/sdk/data_types/video.py,sha256=L3cf5KkRIdIniQlj_UVEUxMbrNRGQPS-kq6So6gvc8Q,8794 +wandb/sdk/integration_utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +wandb/sdk/integration_utils/__pycache__/__init__.cpython-38.pyc,, +wandb/sdk/integration_utils/__pycache__/data_logging.cpython-38.pyc,, +wandb/sdk/integration_utils/data_logging.py,sha256=8xjvqa9ekD-wrsRZdPsIsWqiWQOPX676rexUlLyOJpk,19469 +wandb/sdk/interface/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +wandb/sdk/interface/__pycache__/__init__.cpython-38.pyc,, +wandb/sdk/interface/__pycache__/artifacts.cpython-38.pyc,, +wandb/sdk/interface/__pycache__/constants.cpython-38.pyc,, +wandb/sdk/interface/__pycache__/interface.cpython-38.pyc,, +wandb/sdk/interface/__pycache__/interface_grpc.cpython-38.pyc,, +wandb/sdk/interface/__pycache__/interface_queue.cpython-38.pyc,, +wandb/sdk/interface/__pycache__/interface_relay.cpython-38.pyc,, +wandb/sdk/interface/__pycache__/interface_shared.cpython-38.pyc,, +wandb/sdk/interface/__pycache__/interface_sock.cpython-38.pyc,, +wandb/sdk/interface/__pycache__/message_future.cpython-38.pyc,, +wandb/sdk/interface/__pycache__/message_future_poll.cpython-38.pyc,, +wandb/sdk/interface/__pycache__/router.cpython-38.pyc,, +wandb/sdk/interface/__pycache__/router_queue.cpython-38.pyc,, +wandb/sdk/interface/__pycache__/router_relay.cpython-38.pyc,, +wandb/sdk/interface/__pycache__/router_sock.cpython-38.pyc,, +wandb/sdk/interface/__pycache__/summary_record.cpython-38.pyc,, +wandb/sdk/interface/artifacts.py,sha256=LH0OClQdVHaUDEaEKZcckOk7KQvXCDW8YWuqAHrMDm4,31535 +wandb/sdk/interface/constants.py,sha256=NJNBFr7LkshLI837D3LU3JuEURLzBwza9H-kxcy4ihw,60 +wandb/sdk/interface/interface.py,sha256=stqNkaECcQv92-pVEewCtXEnBES17YSB0-hAe-Rw-Ow,22986 +wandb/sdk/interface/interface_grpc.py,sha256=qO2TF_UJvlvrqOHmNqYiQrhKH_CMpVHLsnb2nQyla-0,9002 +wandb/sdk/interface/interface_queue.py,sha256=dk2gSAK5NkhhLz9EMcMy4LEuvoJaHIuRyoheSQCyMks,1764 +wandb/sdk/interface/interface_relay.py,sha256=Antop6pUAgD-xi3U79OL5ud97PCPSwuOvbPhztvGP4U,1267 +wandb/sdk/interface/interface_shared.py,sha256=OLd0xxeJWTmDhta6PAtuUvf8F8vuvwdYqDYRy2sslLs,16933 +wandb/sdk/interface/interface_sock.py,sha256=C1ey7NOxtquMqmwWa_mqYvTta4mB8vO3FoEQlFv7thk,2953 +wandb/sdk/interface/message_future.py,sha256=kjbREob9UAS4dbrG6dzvjETIsgcguUpn8c63-UIWIBY,674 +wandb/sdk/interface/message_future_poll.py,sha256=6DSWgEoh6zZHXlCTtIT8_KosE9xssRB27mgxvD8I3jo,1389 +wandb/sdk/interface/router.py,sha256=kwn-07Fb7oERLP4OBMBAOr2L_ofcjyrr7Gh4hM87KPo,3202 +wandb/sdk/interface/router_queue.py,sha256=NER-PJqvtjbvWvz4D8znRN4F3k5pXqyLIy8ks6RURu0,1103 +wandb/sdk/interface/router_relay.py,sha256=E6mkr83P3YwXCVf-qMQfGPJvvPoK1vZrUBct-R_-tjI,942 +wandb/sdk/interface/router_sock.py,sha256=TGeOW81fB7vzo90rW_hoAPeokf7qFOniVjLJ5AV6WO8,988 +wandb/sdk/interface/summary_record.py,sha256=l-ZQQ4hFfmtw6JovmzE7pubjEmc2VpRGBWeWf-ga2G4,1676 +wandb/sdk/internal/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +wandb/sdk/internal/__pycache__/__init__.cpython-38.pyc,, +wandb/sdk/internal/__pycache__/artifacts.cpython-38.pyc,, +wandb/sdk/internal/__pycache__/datastore.cpython-38.pyc,, +wandb/sdk/internal/__pycache__/file_pusher.cpython-38.pyc,, +wandb/sdk/internal/__pycache__/file_stream.cpython-38.pyc,, +wandb/sdk/internal/__pycache__/handler.cpython-38.pyc,, +wandb/sdk/internal/__pycache__/internal.cpython-38.pyc,, +wandb/sdk/internal/__pycache__/internal_api.cpython-38.pyc,, +wandb/sdk/internal/__pycache__/internal_util.cpython-38.pyc,, +wandb/sdk/internal/__pycache__/meta.cpython-38.pyc,, +wandb/sdk/internal/__pycache__/profiler.cpython-38.pyc,, +wandb/sdk/internal/__pycache__/progress.cpython-38.pyc,, +wandb/sdk/internal/__pycache__/run.cpython-38.pyc,, +wandb/sdk/internal/__pycache__/sample.cpython-38.pyc,, +wandb/sdk/internal/__pycache__/sender.cpython-38.pyc,, +wandb/sdk/internal/__pycache__/settings_static.cpython-38.pyc,, +wandb/sdk/internal/__pycache__/stats.cpython-38.pyc,, +wandb/sdk/internal/__pycache__/tb_watcher.cpython-38.pyc,, +wandb/sdk/internal/__pycache__/tpu.cpython-38.pyc,, +wandb/sdk/internal/__pycache__/update.cpython-38.pyc,, +wandb/sdk/internal/__pycache__/writer.cpython-38.pyc,, +wandb/sdk/internal/artifacts.py,sha256=E2SJ7QNZX6Xf4XVbt66t1wtoQEkH4DdV204_ZWC7PIY,9946 +wandb/sdk/internal/datastore.py,sha256=NRasOPPUqfsETgGRYW5atHZaY0yTDupDRtLuDMldzcA,9275 +wandb/sdk/internal/file_pusher.py,sha256=OaDYA6IT4TxCRKzvxnfzTeMvHPaTlKArR4F6yzOtt3A,5854 +wandb/sdk/internal/file_stream.py,sha256=8iD_u_35NgF6Lk1a6atsma5c7VX4BeLywnYsuk3x810,23122 +wandb/sdk/internal/handler.py,sha256=8R9DTu2UxV6p23ZlcuIPvJrG5Q34EXUZsRj3WJxkKgU,29997 +wandb/sdk/internal/internal.py,sha256=S601uqUNsD_ejJvRz_HZLBUONK4Z21cQBZY_7QzCOuI,11846 +wandb/sdk/internal/internal_api.py,sha256=QBSE74ScjMe0Z_tUUkDaczqC5-aB5ydBt5WJ85Kax_I,95399 +wandb/sdk/internal/internal_util.py,sha256=2AWb1F-NTKxKHEf5siA95aFFJXiGwg3sWnpYAVdtKi8,2678 +wandb/sdk/internal/meta.py,sha256=hZBpNvZYW1jg4a1lToMn9LNEIZMMQt-vNUIx6ZFHbPA,9754 +wandb/sdk/internal/profiler.py,sha256=hyOZu0igND4mx3Lyplkfmf3tEBdnFe82Yrd_OX5kbfY,2348 +wandb/sdk/internal/progress.py,sha256=ga3RECDJsUWVNyPJSnGa92TPmNvw5VWv4OBs55cVId0,2438 +wandb/sdk/internal/run.py,sha256=zZVFW3o78iQO6Yl74pJnEI_X4Qi1b1Y5NXD3VDDxwkU,681 +wandb/sdk/internal/sample.py,sha256=ggpdVq_pw57AF6iXSH0cN7vqrmP7pN_vwZjbwtPjXiQ,2444 +wandb/sdk/internal/sender.py,sha256=QdELae9F4wiBR_KhGCkHFmBGvD0y-aaCEcKKzgMv6AQ,45680 +wandb/sdk/internal/settings_static.py,sha256=9xy1YqNXi1uZ1w29rMdggQR8lv4KbpWd8cIZiY6t55I,1604 +wandb/sdk/internal/stats.py,sha256=89OYtt30SxTQT8lEK5qIOcKZAtgckm8qHzzpL2XUaUQ,10368 +wandb/sdk/internal/tb_watcher.py,sha256=4d05z5aZb1UiitHKGTs4HdfjzJjF1De0FgpS1pgTzmU,18328 +wandb/sdk/internal/tpu.py,sha256=EwTEAatbROX1RTByLQ0J5zYVSuW6iDYOe9OrohKBAlA,3859 +wandb/sdk/internal/update.py,sha256=-qKqixBJ-NViqNhu0_kZgO56RGcuhTkc7pYaeZiiQC4,3911 +wandb/sdk/internal/writer.py,sha256=6hMy8qBCBNNn5WVPGr0MBBJz1aMVmaa7qJ6-XKWWbag,775 +wandb/sdk/launch/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +wandb/sdk/launch/__pycache__/__init__.cpython-38.pyc,, +wandb/sdk/launch/__pycache__/_project_spec.cpython-38.pyc,, +wandb/sdk/launch/__pycache__/launch.cpython-38.pyc,, +wandb/sdk/launch/__pycache__/launch_add.cpython-38.pyc,, +wandb/sdk/launch/__pycache__/utils.cpython-38.pyc,, +wandb/sdk/launch/_project_spec.py,sha256=cP_oODM8oBCewoKH4GKYzb7riPZZ3krRAfnz3G2TtOM,17280 +wandb/sdk/launch/agent/__init__.py,sha256=nwGHzJptq87cXCSAJi7Wv2ShL-HZwDgMo2aFC2Rh20w,85 +wandb/sdk/launch/agent/__pycache__/__init__.cpython-38.pyc,, +wandb/sdk/launch/agent/__pycache__/agent.cpython-38.pyc,, +wandb/sdk/launch/agent/agent.py,sha256=2maJ4M31MKv7BgYTBAfRVmPy1ZUEN3RXG8etKbVqap8,9177 +wandb/sdk/launch/builder/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +wandb/sdk/launch/builder/__pycache__/__init__.cpython-38.pyc,, +wandb/sdk/launch/builder/__pycache__/abstract.cpython-38.pyc,, +wandb/sdk/launch/builder/__pycache__/build.cpython-38.pyc,, +wandb/sdk/launch/builder/__pycache__/docker.cpython-38.pyc,, +wandb/sdk/launch/builder/__pycache__/kaniko.cpython-38.pyc,, +wandb/sdk/launch/builder/__pycache__/loader.cpython-38.pyc,, +wandb/sdk/launch/builder/abstract.py,sha256=IgeOG_L6sXalgbrTIDg8t5so8tK3JVbxI4F_VLFQNo8,845 +wandb/sdk/launch/builder/build.py,sha256=Lm3ur4hPb8MHOOMWr5KXFHRvKvZTu_rkhEYUiaBRDt4,17891 +wandb/sdk/launch/builder/docker.py,sha256=e7cTpxOyq4v7oIX2cZjxQLMMU-nk5FDhSs7fqb_AbSs,2747 +wandb/sdk/launch/builder/kaniko.py,sha256=OhWyFUANgYTBdIBgqyOFOIK2BYf3EfqPSIPWwFoyZyo,13735 +wandb/sdk/launch/builder/loader.py,sha256=EyEUgCvxX0BWxqK514vhLmsuKuMRj8ejQZYbKaz648Q,754 +wandb/sdk/launch/builder/templates/__pycache__/_wandb_bootstrap.cpython-38.pyc,, +wandb/sdk/launch/builder/templates/_wandb_bootstrap.py,sha256=LGsxGdH_fgaxL6y-Mk15Uo3zcKp2FyZi9c8-mB7p1Zw,3242 +wandb/sdk/launch/launch.py,sha256=xgLXPC3To3msSYhPlg-AjtgYjZ0KMHSf1wMxjkd6ThY,9743 +wandb/sdk/launch/launch_add.py,sha256=1AWPd80ntyzMrWuE5R4vNPKbX7yYFQVYolqualjGTFM,2802 +wandb/sdk/launch/runner/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +wandb/sdk/launch/runner/__pycache__/__init__.cpython-38.pyc,, +wandb/sdk/launch/runner/__pycache__/abstract.cpython-38.pyc,, +wandb/sdk/launch/runner/__pycache__/aws.cpython-38.pyc,, +wandb/sdk/launch/runner/__pycache__/gcp_vertex.cpython-38.pyc,, +wandb/sdk/launch/runner/__pycache__/kubernetes.cpython-38.pyc,, +wandb/sdk/launch/runner/__pycache__/loader.cpython-38.pyc,, +wandb/sdk/launch/runner/__pycache__/local_container.cpython-38.pyc,, +wandb/sdk/launch/runner/__pycache__/local_process.cpython-38.pyc,, +wandb/sdk/launch/runner/abstract.py,sha256=S035cL1Mw4lCSGj5GTthH2nMzjmt5AS5tjyHOtavuD4,5776 +wandb/sdk/launch/runner/aws.py,sha256=Z0twygZXIV17_9WtNQsBTLJ7jKWdgip475Ula3zMF-8,15549 +wandb/sdk/launch/runner/gcp_vertex.py,sha256=aubIWCJwUiRiS9ECjhfVeJCW6iVxeM8pcGczL1M4yA8,8602 +wandb/sdk/launch/runner/kubernetes.py,sha256=wIkIZdqUEXKV4pl1Vn8nUAeZ532dzZJxMtaOC7X5vS4,18457 +wandb/sdk/launch/runner/loader.py,sha256=vlYZlsxbo0FpT79V6p5-84XK_Ju78OAuMzQ-On2qTqk,1442 +wandb/sdk/launch/runner/local_container.py,sha256=oFf4yIzFQLEczEVCf40_tcWQXzOAd1XP6noQ3nho1Ec,7461 +wandb/sdk/launch/runner/local_process.py,sha256=M4aMsK-OJuhijvGhg9EgTLZVafD9GDYgugVsMPUBAgA,2896 +wandb/sdk/launch/sweeps/__init__.py,sha256=Rbp2qKqpaeEsVWWi2JaV5B5ZL1DECcuY6Kcmy4_Ped4,795 +wandb/sdk/launch/sweeps/__pycache__/__init__.cpython-38.pyc,, +wandb/sdk/launch/sweeps/__pycache__/scheduler.cpython-38.pyc,, +wandb/sdk/launch/sweeps/__pycache__/scheduler_sweep.cpython-38.pyc,, +wandb/sdk/launch/sweeps/scheduler.py,sha256=g-xJf4WKpNRXlHKM7X4dXI3Fa0hRTgrTEOqJDVZCaWY,5995 +wandb/sdk/launch/sweeps/scheduler_sweep.py,sha256=oGlgS4jzg7IGLD_HctBOq0VxP0CUuUUhLgkd8xTan3A,5552 +wandb/sdk/launch/templates/__pycache__/_wandb_bootstrap.cpython-38.pyc,, +wandb/sdk/launch/templates/_wandb_bootstrap.py,sha256=_pvLG6qkw7d1pF1q1i9fntvxqN74hq72kq39bVCJbCY,3249 +wandb/sdk/launch/utils.py,sha256=iL3WchRoK_CDF8zzDaYQpaIzh8We_IH1Z1GWZdE5Oq4,19638 +wandb/sdk/lib/__init__.py,sha256=PeqhRWcgiOzo6LliKn8UgNOXMzbr2k0dx5egTAKa7g4,149 +wandb/sdk/lib/__pycache__/__init__.cpython-38.pyc,, +wandb/sdk/lib/__pycache__/_wburls_generate.cpython-38.pyc,, +wandb/sdk/lib/__pycache__/_wburls_generated.cpython-38.pyc,, +wandb/sdk/lib/__pycache__/apikey.cpython-38.pyc,, +wandb/sdk/lib/__pycache__/config_util.cpython-38.pyc,, +wandb/sdk/lib/__pycache__/console.cpython-38.pyc,, +wandb/sdk/lib/__pycache__/deprecate.cpython-38.pyc,, +wandb/sdk/lib/__pycache__/disabled.cpython-38.pyc,, +wandb/sdk/lib/__pycache__/exit_hooks.cpython-38.pyc,, +wandb/sdk/lib/__pycache__/file_stream_utils.cpython-38.pyc,, +wandb/sdk/lib/__pycache__/filenames.cpython-38.pyc,, +wandb/sdk/lib/__pycache__/filesystem.cpython-38.pyc,, +wandb/sdk/lib/__pycache__/git.cpython-38.pyc,, +wandb/sdk/lib/__pycache__/handler_util.cpython-38.pyc,, +wandb/sdk/lib/__pycache__/ipython.cpython-38.pyc,, +wandb/sdk/lib/__pycache__/lazyloader.cpython-38.pyc,, +wandb/sdk/lib/__pycache__/module.cpython-38.pyc,, +wandb/sdk/lib/__pycache__/preinit.cpython-38.pyc,, +wandb/sdk/lib/__pycache__/printer.cpython-38.pyc,, +wandb/sdk/lib/__pycache__/proto_util.cpython-38.pyc,, +wandb/sdk/lib/__pycache__/redirect.cpython-38.pyc,, +wandb/sdk/lib/__pycache__/reporting.cpython-38.pyc,, +wandb/sdk/lib/__pycache__/retry.cpython-38.pyc,, +wandb/sdk/lib/__pycache__/runid.cpython-38.pyc,, +wandb/sdk/lib/__pycache__/server.cpython-38.pyc,, +wandb/sdk/lib/__pycache__/sock_client.cpython-38.pyc,, +wandb/sdk/lib/__pycache__/sparkline.cpython-38.pyc,, +wandb/sdk/lib/__pycache__/telemetry.cpython-38.pyc,, +wandb/sdk/lib/__pycache__/timed_input.cpython-38.pyc,, +wandb/sdk/lib/__pycache__/tracelog.cpython-38.pyc,, +wandb/sdk/lib/__pycache__/wburls.cpython-38.pyc,, +wandb/sdk/lib/_wburls_generate.py,sha256=mZsSEcfK8Soy_Wf-WFVKsysULERPaDKsPirpj9uxUaw,440 +wandb/sdk/lib/_wburls_generated.py,sha256=zvF_0GgDa3cytceCdsv3eckyI_rO67NrWtJo7ru5UPk,355 +wandb/sdk/lib/apikey.py,sha256=zW1txFCID2ERnWZCEyQfYoo9amArPl2OZxK1H_juE4E,7889 +wandb/sdk/lib/config_util.py,sha256=GNEld8uPL6YHXon1aY64hRppS_bItg9iOQC8Dd66jwg,3790 +wandb/sdk/lib/console.py,sha256=7zhEgjS3riknrt9DkWrC-H1eHIxpJhpNEKwH632uWPs,1033 +wandb/sdk/lib/deprecate.py,sha256=CtaFDG4TN_ZUGjnnUHkgP55o_nz_p8I00vUBbeJjp7I,1464 +wandb/sdk/lib/disabled.py,sha256=-REmuFxa43C5k4pzhR8k7EshPUUHRdqsgL8qi0Jt2gA,3577 +wandb/sdk/lib/exit_hooks.py,sha256=_dHedgNuUELrxBDdUc__kcHCT1suU5tp30gviVFD-s8,1527 +wandb/sdk/lib/file_stream_utils.py,sha256=TA9AAow_nrAsIyWgI8eXSJ9wG-K11meA6UD8PsKGTHY,4004 +wandb/sdk/lib/filenames.py,sha256=LGxQ1oaJCEWL5387EIrn8XrvCGwaXKb_wIphDjJM0Nk,1283 +wandb/sdk/lib/filesystem.py,sha256=uivW41ODIPLlXHxsATYL44ib9etASN3abUXk2Ykxry4,1817 +wandb/sdk/lib/git.py,sha256=kmzIAy9o1cwGi92EepsIRerkcnzCRsXeJuZkG9wpIzU,6126 +wandb/sdk/lib/handler_util.py,sha256=mT9CKsmboq4lPWElsi4uo9ORHhx6OYTr7KY2QtgbM6M,589 +wandb/sdk/lib/ipython.py,sha256=cjK99DOninOZDlFs4AOhaOnUYFycNCOnHDaWhQ6HVXo,3683 +wandb/sdk/lib/lazyloader.py,sha256=Dhd6QYPM6OJ447ERzJUU5BNeyPaRsaj7egzNSRXHJvw,1879 +wandb/sdk/lib/module.py,sha256=nhXo7OJGGqbJTd2iraxQsGoCB7Qh8nQZjxfjtn5wnKo,1604 +wandb/sdk/lib/preinit.py,sha256=DHXTrSc7z5UHdy0uADageV6TWPcKw71j6iElAlNYVn4,1452 +wandb/sdk/lib/printer.py,sha256=VA07mQivvTW7sp5tLlRvZpzeTSUpz5nLaybToIB3G-Y,6410 +wandb/sdk/lib/proto_util.py,sha256=lBUsf-AW_ezh3ZBA7Je9-JhmrVSvp9ld6BdD2mZ5NvU,3104 +wandb/sdk/lib/redirect.py,sha256=_5v0siV6buc0ZmIOmrsgFd10ptakFtSeaditAACCFwI,25162 +wandb/sdk/lib/reporting.py,sha256=5sphfWWfmTNbDnTBU9wJBpikEr4siie3xH5adasvXw0,2412 +wandb/sdk/lib/retry.py,sha256=ZLk0B0A61OZAHYv80GyN8L_BrM_1Y4K9kAnxlk20N6w,6083 +wandb/sdk/lib/runid.py,sha256=kVAveCxGlvJ2BvH2EN_V-lq45jE33X8UA30HUl5rDyM,264 +wandb/sdk/lib/server.py,sha256=CuBQmjTWY-lxmbjoSV4CkciD82Cl5Cd_VNI5XYcKRCI,1376 +wandb/sdk/lib/sock_client.py,sha256=8YImal0XzXo37SJYN4ojC18oaaapK87BAxJwONxM5g0,6595 +wandb/sdk/lib/sparkline.py,sha256=0yyh0pFLjwU-DZ1ajxxlwrNUaj-iUZCoySPxJeo-A0k,1374 +wandb/sdk/lib/telemetry.py,sha256=NI4jk_JvYr2RCxs3Ord3DEWdZ5NQj37_Xrv4gLjr1O8,2277 +wandb/sdk/lib/timed_input.py,sha256=D7vx3N3m4LlxwkQpzS7lDi7IOnccqZ3WfLlDYRs8Oes,3229 +wandb/sdk/lib/tracelog.py,sha256=VR_a_Zn-Q1xtgQ9Doi1bDJkUKUcI64TIFpFMPW4Nkfc,7405 +wandb/sdk/lib/wburls.py,sha256=MaWLIEzGBHRIsZhWhvdB8JSRUXZNfmJCbVBK57tCvFo,1207 +wandb/sdk/service/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +wandb/sdk/service/__pycache__/__init__.cpython-38.pyc,, +wandb/sdk/service/__pycache__/port_file.cpython-38.pyc,, +wandb/sdk/service/__pycache__/server.cpython-38.pyc,, +wandb/sdk/service/__pycache__/server_grpc.cpython-38.pyc,, +wandb/sdk/service/__pycache__/server_sock.cpython-38.pyc,, +wandb/sdk/service/__pycache__/service.cpython-38.pyc,, +wandb/sdk/service/__pycache__/service_base.cpython-38.pyc,, +wandb/sdk/service/__pycache__/service_grpc.cpython-38.pyc,, +wandb/sdk/service/__pycache__/service_sock.cpython-38.pyc,, +wandb/sdk/service/__pycache__/streams.cpython-38.pyc,, +wandb/sdk/service/port_file.py,sha256=KbgL509cAbubyXq4VUoOs5dZgAXv5nIXZ43BD9br0YI,1969 +wandb/sdk/service/server.py,sha256=-2FX4NB9TqkjAVhvJADnrxkBluKLGqIwr1Vtls8xL2Q,4542 +wandb/sdk/service/server_grpc.py,sha256=7MWb1g60e4cv5azejIuu7dsVss1TdlSMbNyD7k5wstI,13907 +wandb/sdk/service/server_sock.py,sha256=Noe9b7wPCUywet5AxLHhy6KyvBDRUODNSKG2BAUF4M0,9544 +wandb/sdk/service/service.py,sha256=pYPIDXO_ZBRk3mysLg-sR8BDZKy9TqQ0imGY1ef6Lbw,3924 +wandb/sdk/service/service_base.py,sha256=ZpdS_sPVSIDQrRkqHNdDbik9Pniy1s0ZksuzEz8EMVU,2372 +wandb/sdk/service/service_grpc.py,sha256=i4uuj5lislzVMCl4e6VY8xaofoOgpV4Wp3WpEWcf3go,2474 +wandb/sdk/service/service_sock.py,sha256=IjtpkAhVNxNNWAgWuW1zPYK3D0u7LlEW4ulLT0X-76o,2369 +wandb/sdk/service/streams.py,sha256=66DtSHYIXGlqD_sFwlBY3w08wdmewl_se4fYiE4Ih5I,11527 +wandb/sdk/verify/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +wandb/sdk/verify/__pycache__/__init__.cpython-38.pyc,, +wandb/sdk/verify/__pycache__/verify.cpython-38.pyc,, +wandb/sdk/verify/verify.py,sha256=buiCt5qw2ZyTJvhaqpbSfVW6nkYZ8r11vBE1ZkPzDh0,16037 +wandb/sdk/wandb_alerts.py,sha256=SwBPBiXRxknMTMGbsVoMMWqWK65UWMcKAdTWZtdwAeo,193 +wandb/sdk/wandb_artifacts.py,sha256=rOvkHG1nZ8GoEF8Ew_4Ha_ejGArpXS3eyNgM2B0pOC8,70426 +wandb/sdk/wandb_config.py,sha256=x3LCshBDOKfjcYJNVP4NR8eyJG3pO9juvaOKyL_W8_w,9597 +wandb/sdk/wandb_helper.py,sha256=ohzUbYu1rv_acQP9PAzYThZe48av8eq6evir47u6ors,1838 +wandb/sdk/wandb_init.py,sha256=54absydG_CGyfR1K85JwkhSKln5tDzwm0MNAUrun6fA,44056 +wandb/sdk/wandb_login.py,sha256=H0OVKjTwqVP8lVAwYa8n_j8zpi8aepJeIYpXqZUfmJg,10040 +wandb/sdk/wandb_manager.py,sha256=VrLNMWU9mZef5vjnqsAEK0BWJ0QNviBnJahUbHdq_uc,5370 +wandb/sdk/wandb_metric.py,sha256=6fnPdfCgbhn05kGCqhU-U8npVMmBJ1IMYLiTlE3UWr4,3220 +wandb/sdk/wandb_require.py,sha256=AW9tcRZtQHozYhjP2gR8knyRDIri8QzeVofvi4Azuxk,3126 +wandb/sdk/wandb_require_helpers.py,sha256=ZfrfRmKdYCq0Dvyt8srUz2h6d8iqk-JKZDnsmJ7r5_w,1490 +wandb/sdk/wandb_run.py,sha256=bpQJfC9RseQy5UznO-629G83HBcVVShNMjYkNd7Txz4,129793 +wandb/sdk/wandb_save.py,sha256=8PAsl4AbfEDhuZYuBw7FGAJQ0NNGlIXkrYmiJodF-zI,183 +wandb/sdk/wandb_settings.py,sha256=egbRWW9L49TIwIcVzoHq30IfbZ8lYbXzlY2n_uaDkkw,58717 +wandb/sdk/wandb_setup.py,sha256=GA86WB-uNLHNIAmHmls7RLLiwKstt_qYXZ69WRAPFyg,10302 +wandb/sdk/wandb_summary.py,sha256=ejcg0n85jaQFL-9C5p0WF0FQh9rl93qnTeiZzt0b-e8,4504 +wandb/sdk/wandb_sweep.py,sha256=ldMQ0uu6PddtzjUkPZ0SALMMAxLSm6SYCimPS_1nkyQ,4504 +wandb/sdk/wandb_watch.py,sha256=7A3h1jOawIHg5sXwLvp8WVbazTsqpbyXnP5tYW_mcyE,3783 +wandb/sklearn/__init__.py,sha256=toKvfdpIIIXQHMz8_XGieUZH91lslgEOj8Xqjtil55o,927 +wandb/sklearn/__pycache__/__init__.cpython-38.pyc,, +wandb/sklearn/__pycache__/utils.cpython-38.pyc,, +wandb/sklearn/calculate/__init__.py,sha256=T19bKtuyTbRNzcIg3QbnRD8vm085QJXQFZfQ_STjrCk,1055 +wandb/sklearn/calculate/__pycache__/__init__.cpython-38.pyc,, +wandb/sklearn/calculate/__pycache__/calibration_curves.cpython-38.pyc,, +wandb/sklearn/calculate/__pycache__/class_proportions.cpython-38.pyc,, +wandb/sklearn/calculate/__pycache__/confusion_matrix.cpython-38.pyc,, +wandb/sklearn/calculate/__pycache__/decision_boundaries.cpython-38.pyc,, +wandb/sklearn/calculate/__pycache__/elbow_curve.cpython-38.pyc,, +wandb/sklearn/calculate/__pycache__/feature_importances.cpython-38.pyc,, +wandb/sklearn/calculate/__pycache__/learning_curve.cpython-38.pyc,, +wandb/sklearn/calculate/__pycache__/outlier_candidates.cpython-38.pyc,, +wandb/sklearn/calculate/__pycache__/residuals.cpython-38.pyc,, +wandb/sklearn/calculate/__pycache__/silhouette.cpython-38.pyc,, +wandb/sklearn/calculate/__pycache__/summary_metrics.cpython-38.pyc,, +wandb/sklearn/calculate/calibration_curves.py,sha256=H0YmdlQdKKZDD8xtaApfJmRXsgQ_33C5_6tuHUbb3HU,3805 +wandb/sklearn/calculate/class_proportions.py,sha256=1UtzZH3IuDX8-JWOZHyLiRr_HMM3ghYd-JptBFT3NWQ,2107 +wandb/sklearn/calculate/confusion_matrix.py,sha256=T9sCKsItd2nT_Y7y28MQ8Xg_a3svGbyw3taLtKvNRTo,2545 +wandb/sklearn/calculate/decision_boundaries.py,sha256=jHpx3WN6_Dbv3C4mUrRegZYmi5NnT-8SJGKkXpNG4Qo,1087 +wandb/sklearn/calculate/elbow_curve.py,sha256=XrEFtbZn_rQNmLOofoM9qooC9oWunnKxvGJv-xq25iM,1450 +wandb/sklearn/calculate/feature_importances.py,sha256=MyhIsOac3P43wDyExblzfFK54ZI2-FfAZpF9jK7is5o,2261 +wandb/sklearn/calculate/learning_curve.py,sha256=ZdzHhWQvd_NtT0pUjdTkBbfDjazmWpTIJC5xBAQQVrI,1703 +wandb/sklearn/calculate/outlier_candidates.py,sha256=nrfrSrg3gHFpyL8Mn0LUp7dfJAgIYFejCv7qC0DXBM4,1920 +wandb/sklearn/calculate/residuals.py,sha256=zoEQ9Q_YjG0b5Nm-1SbdD5x_B_oGu37GhvW4VdztskU,2345 +wandb/sklearn/calculate/silhouette.py,sha256=vMru4HhCiYiYBSa4YBQLAT5h5oQbJGxWqtaI0zORv1w,3296 +wandb/sklearn/calculate/summary_metrics.py,sha256=Nl2ZbhA2z_IpsFkzZgEX4A0qtdJQh7ue2UXlSuz65dM,1987 +wandb/sklearn/plot/__init__.py,sha256=HgabpHNwyASmZR2AZs03wOtROjhBbTVX52qUdl-4K-M,1292 +wandb/sklearn/plot/__pycache__/__init__.cpython-38.pyc,, +wandb/sklearn/plot/__pycache__/classifier.cpython-38.pyc,, +wandb/sklearn/plot/__pycache__/clusterer.cpython-38.pyc,, +wandb/sklearn/plot/__pycache__/regressor.cpython-38.pyc,, +wandb/sklearn/plot/__pycache__/shared.cpython-38.pyc,, +wandb/sklearn/plot/classifier.py,sha256=_x4GlNgDTrDQf-rWUtw8HNfR0x7up8tR1QhM6E7abf4,13876 +wandb/sklearn/plot/clusterer.py,sha256=uhhvgKcJqhJ_Ri0yEI4pWpI_woICR_7zHgSviXFiXLc,4888 +wandb/sklearn/plot/regressor.py,sha256=jIw5Z24tTTDDHzFybsHVHOgCgLNwc2q-U6YY1aweG1k,3944 +wandb/sklearn/plot/shared.py,sha256=nkDgjAAPKPrxiyJhIxkAEk_OB0OGjvAM3TXgPSq4eVE,2763 +wandb/sklearn/utils.py,sha256=Tso2fVZaGGj5mfa0U2osLW9w8DmhICj1RT2CTlYh_rc,5902 +wandb/sync/__init__.py,sha256=0tCdQMljofnO3k0woU2xL8XY9G481Fhz2JbxJlh24u4,102 +wandb/sync/__pycache__/__init__.cpython-38.pyc,, +wandb/sync/__pycache__/sync.cpython-38.pyc,, +wandb/sync/sync.py,sha256=HQFGugXRXeN5bLiOBNhOSlJRasPuKebE66dSa59H3hQ,13950 +wandb/trigger.py,sha256=uoxjd5fg7STXAZF_I7_cgCoFLMj4OkHG6Qfh3uM6AcI,613 +wandb/util.py,sha256=qoxCH2bVNi95BGfTF210Kf9KbOi2uZ0aVJ0OtrLpTcg,53355 +wandb/vendor/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +wandb/vendor/__pycache__/__init__.cpython-38.pyc,, +wandb/vendor/gql-0.2.0/__pycache__/setup.cpython-38.pyc,, +wandb/vendor/gql-0.2.0/setup.py,sha256=_osNap_aCOVvTlDwP9f-aI10TJbpIflxcG6fEQoAxNs,1314 +wandb/vendor/gql-0.2.0/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +wandb/vendor/gql-0.2.0/tests/__pycache__/__init__.cpython-38.pyc,, +wandb/vendor/gql-0.2.0/tests/__pycache__/test_client.cpython-38.pyc,, +wandb/vendor/gql-0.2.0/tests/__pycache__/test_transport.cpython-38.pyc,, +wandb/vendor/gql-0.2.0/tests/starwars/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +wandb/vendor/gql-0.2.0/tests/starwars/__pycache__/__init__.cpython-38.pyc,, +wandb/vendor/gql-0.2.0/tests/starwars/__pycache__/fixtures.cpython-38.pyc,, +wandb/vendor/gql-0.2.0/tests/starwars/__pycache__/schema.cpython-38.pyc,, +wandb/vendor/gql-0.2.0/tests/starwars/__pycache__/test_dsl.cpython-38.pyc,, +wandb/vendor/gql-0.2.0/tests/starwars/__pycache__/test_query.cpython-38.pyc,, +wandb/vendor/gql-0.2.0/tests/starwars/__pycache__/test_validation.cpython-38.pyc,, +wandb/vendor/gql-0.2.0/tests/starwars/fixtures.py,sha256=VSe1BHn6ltu2O_tPOUAFqDg7extW41OiEFO7AjRb8ic,1681 +wandb/vendor/gql-0.2.0/tests/starwars/schema.py,sha256=uCQATEOQIPd3IP4LSEtVjLHmKJ_ArLvEUArVFDf-D0U,4755 +wandb/vendor/gql-0.2.0/tests/starwars/test_dsl.py,sha256=DjJ5ot7wAt84ICcFPpKcxlL-zZTHUBn0QF6I2eSZk9o,5986 +wandb/vendor/gql-0.2.0/tests/starwars/test_query.py,sha256=QcjH1DwLqqb1N-qCx5shN4yo9Qw3-j-NlxoBUw3huqI,7964 +wandb/vendor/gql-0.2.0/tests/starwars/test_validation.py,sha256=DvaFqQ_hy0W92Gsw2av8IjQR51QN2tfZ-NHTM_KCbWs,3350 +wandb/vendor/gql-0.2.0/tests/test_client.py,sha256=ITo-5YBgRTq7vrBOJ97ztXKcyQn5niWOnAkE6sqJgM0,697 +wandb/vendor/gql-0.2.0/tests/test_transport.py,sha256=BZwYV6DQBlRFkLVHp_dH2CzSbOQsLNR9peEPCsZCqmU,2240 +wandb/vendor/gql-0.2.0/wandb_gql/__init__.py,sha256=sokx5ACyDmgDtL-io3gBEVKcBAi1CV4nSiXEjeGMjVI,77 +wandb/vendor/gql-0.2.0/wandb_gql/__pycache__/__init__.cpython-38.pyc,, +wandb/vendor/gql-0.2.0/wandb_gql/__pycache__/client.cpython-38.pyc,, +wandb/vendor/gql-0.2.0/wandb_gql/__pycache__/dsl.cpython-38.pyc,, +wandb/vendor/gql-0.2.0/wandb_gql/__pycache__/gql.cpython-38.pyc,, +wandb/vendor/gql-0.2.0/wandb_gql/__pycache__/utils.cpython-38.pyc,, +wandb/vendor/gql-0.2.0/wandb_gql/client.py,sha256=AR45930Eaf1DYmcA-Fm9NouXU0kKTCl1aEyZtECKAY0,2964 +wandb/vendor/gql-0.2.0/wandb_gql/dsl.py,sha256=bedgbKX8Bt63KwgdJbXZXmF12qvqxnd4B7uGW5QkkCk,4409 +wandb/vendor/gql-0.2.0/wandb_gql/gql.py,sha256=gcVWc8pHszmPZv9MAn6Ae0rq2rfxRVQP0TC6XsfS5UI,372 +wandb/vendor/gql-0.2.0/wandb_gql/transport/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +wandb/vendor/gql-0.2.0/wandb_gql/transport/__pycache__/__init__.cpython-38.pyc,, +wandb/vendor/gql-0.2.0/wandb_gql/transport/__pycache__/http.cpython-38.pyc,, +wandb/vendor/gql-0.2.0/wandb_gql/transport/__pycache__/local_schema.cpython-38.pyc,, +wandb/vendor/gql-0.2.0/wandb_gql/transport/__pycache__/requests.cpython-38.pyc,, +wandb/vendor/gql-0.2.0/wandb_gql/transport/http.py,sha256=W_21pHSLCNme_ukkin1muiF7vUtK21LEzUcqPNK-6_k,172 +wandb/vendor/gql-0.2.0/wandb_gql/transport/local_schema.py,sha256=rWiVTPpRJGCZIkLkp-QiV26pc0YkgVpt2PtoNivihGg,316 +wandb/vendor/gql-0.2.0/wandb_gql/transport/requests.py,sha256=eaSF9HIGaBwRvXbUzifemmQ5uNbDj4e9lzGfD4zH-gY,1637 +wandb/vendor/gql-0.2.0/wandb_gql/utils.py,sha256=rV2mkAU9-6DBPTyyHTSq0lBuXC5o6HHOLN2Kmy0ifds,676 +wandb/vendor/graphql-core-1.1/__pycache__/setup.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/setup.py,sha256=FV94NFqGy3w5eILAhH_rldtMwyQ7KNEomxwUR-ceJ3M,2743 +wandb/vendor/graphql-core-1.1/wandb_graphql/__init__.py,sha256=x2MzOC7YipdFCsvCmZV1ogaacUxvdHaTTkbdb4dZuNI,7300 +wandb/vendor/graphql-core-1.1/wandb_graphql/__pycache__/__init__.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/__pycache__/graphql.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/error/__init__.py,sha256=9yXJJMFCWiPT_ljIvpkYvDJ0-nx9BAx3bEGOwtPQkqA,251 +wandb/vendor/graphql-core-1.1/wandb_graphql/error/__pycache__/__init__.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/error/__pycache__/base.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/error/__pycache__/format_error.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/error/__pycache__/located_error.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/error/__pycache__/syntax_error.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/error/base.py,sha256=CayEVQJFcT5AjEyDOSIKAdniIKUQoM6E7VM1VU2vy2s,1285 +wandb/vendor/graphql-core-1.1/wandb_graphql/error/format_error.py,sha256=McCg1u3AEgfAGug7QnhXWUHHYpzbsJpaW8YGbS5f4XQ,296 +wandb/vendor/graphql-core-1.1/wandb_graphql/error/located_error.py,sha256=HLg4fJmLDtRcUVZ331dhd2rIA9Lg3DI09kpq7cSS6BA,757 +wandb/vendor/graphql-core-1.1/wandb_graphql/error/syntax_error.py,sha256=d5oGQt5wjORtqR7o8hKYsITl1COSt_gZlT3gScSds4I,1132 +wandb/vendor/graphql-core-1.1/wandb_graphql/execution/__init__.py,sha256=OQcZ6FkavSXLlrqOYTC1Q-H7CQ4S1onzJnsSOkta6IA,723 +wandb/vendor/graphql-core-1.1/wandb_graphql/execution/__pycache__/__init__.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/execution/__pycache__/base.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/execution/__pycache__/executor.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/execution/__pycache__/middleware.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/execution/__pycache__/values.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/execution/base.py,sha256=WYuAfruLgMl9__UMg24yA9VBckcOaWgw0csrFDQ_oxw,11264 +wandb/vendor/graphql-core-1.1/wandb_graphql/execution/executor.py,sha256=WuoXfSNn1heYjwWeAFEn4hyEPWmDFJF9n_gbk4Mf0WM,14350 +wandb/vendor/graphql-core-1.1/wandb_graphql/execution/executors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +wandb/vendor/graphql-core-1.1/wandb_graphql/execution/executors/__pycache__/__init__.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/execution/executors/__pycache__/asyncio.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/execution/executors/__pycache__/gevent.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/execution/executors/__pycache__/process.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/execution/executors/__pycache__/sync.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/execution/executors/__pycache__/thread.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/execution/executors/__pycache__/utils.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/execution/executors/asyncio.py,sha256=9ttDPmZHYxJ2DuGa1biWWLlAKUQdjP75eP62GbzTbmQ,1788 +wandb/vendor/graphql-core-1.1/wandb_graphql/execution/executors/gevent.py,sha256=_YsY3UO2yT4s3VdRqgu5WTqd02TOWyHCsZy8SePqw5g,489 +wandb/vendor/graphql-core-1.1/wandb_graphql/execution/executors/process.py,sha256=r3bIsUzW6J9A59whW3Uc8wf_ZHiCKQf5KVd1o919qcs,751 +wandb/vendor/graphql-core-1.1/wandb_graphql/execution/executors/sync.py,sha256=57ylY5MVMo3P5EJbaNPQtsx8kLCK7ZaHDKuXKY30HQ8,157 +wandb/vendor/graphql-core-1.1/wandb_graphql/execution/executors/thread.py,sha256=GeL2C6dv1-Ybj_8TQqcOUTtvl2lqihj28DITp_oEzxM,947 +wandb/vendor/graphql-core-1.1/wandb_graphql/execution/executors/utils.py,sha256=3zHgHZKyrbDIWsDRuLHRtrRYFmi6mQ14q6n9hjKr30E,151 +wandb/vendor/graphql-core-1.1/wandb_graphql/execution/experimental/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +wandb/vendor/graphql-core-1.1/wandb_graphql/execution/experimental/__pycache__/__init__.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/execution/experimental/__pycache__/executor.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/execution/experimental/__pycache__/fragment.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/execution/experimental/__pycache__/resolver.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/execution/experimental/__pycache__/utils.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/execution/experimental/executor.py,sha256=vBGki5kDBdzlUvMWhcQIEvqCp1F4-3TjgeI2t6UjDyk,2245 +wandb/vendor/graphql-core-1.1/wandb_graphql/execution/experimental/fragment.py,sha256=V_nrcq1EfHlKOjkOiMyQYTA6NJlQZ5kEdNnYrHUPPeg,8323 +wandb/vendor/graphql-core-1.1/wandb_graphql/execution/experimental/resolver.py,sha256=HPkLoQMuHUCXWPVcKVQr0ZU0XiO9Aa4ssYT6zX4wz94,6348 +wandb/vendor/graphql-core-1.1/wandb_graphql/execution/experimental/utils.py,sha256=akGcXkBUaN7Qig7Y1itPkcarjVZYwjfJG-97sNsylT4,149 +wandb/vendor/graphql-core-1.1/wandb_graphql/execution/middleware.py,sha256=c9Zj0qTz-AQtHA5da2qlmqpKSj2bokjLjYclB5zrPeA,1719 +wandb/vendor/graphql-core-1.1/wandb_graphql/execution/values.py,sha256=BRYJIf5PhDJxLyjlKzqhEnW4Hod_T5udP31fWyXpdKs,4783 +wandb/vendor/graphql-core-1.1/wandb_graphql/graphql.py,sha256=9Fu2CLxgimKzSpZAkqeWUSA8lDK8LRRkUnn40-rTjF0,2224 +wandb/vendor/graphql-core-1.1/wandb_graphql/language/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +wandb/vendor/graphql-core-1.1/wandb_graphql/language/__pycache__/__init__.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/language/__pycache__/ast.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/language/__pycache__/base.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/language/__pycache__/lexer.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/language/__pycache__/location.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/language/__pycache__/parser.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/language/__pycache__/printer.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/language/__pycache__/source.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/language/__pycache__/visitor.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/language/__pycache__/visitor_meta.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/language/ast.py,sha256=VnBTudpMQoxmGHgiHyKN_74uGf3baiU-c13zzcR_QtQ,35008 +wandb/vendor/graphql-core-1.1/wandb_graphql/language/base.py,sha256=Q07CFeZbOfxiR_Dc5HOIBRbJK6Zk5mfl8KE2e7WVrq4,408 +wandb/vendor/graphql-core-1.1/wandb_graphql/language/lexer.py,sha256=D6ooEKpLWoKOz630y43OGQoerMv6QuMss57noL7Dd84,11585 +wandb/vendor/graphql-core-1.1/wandb_graphql/language/location.py,sha256=QcVvx0NKUUt8L2LSGQzSWKjnCoaOnoxqokp-mlnQ9TI,746 +wandb/vendor/graphql-core-1.1/wandb_graphql/language/parser.py,sha256=Wlb4DI0jujl6FGucb9dZpoa-c9dHIY5Z0VSfiGbTPJg,20953 +wandb/vendor/graphql-core-1.1/wandb_graphql/language/printer.py,sha256=gH-I-gieWXw9FcCIISaXoxK_v_mzmhzAOqwiRiVbTQ8,5888 +wandb/vendor/graphql-core-1.1/wandb_graphql/language/source.py,sha256=UI0kq69Mujj986BiQoqeNDrxEBWPzf3IH4C1NZ1PXW8,405 +wandb/vendor/graphql-core-1.1/wandb_graphql/language/visitor.py,sha256=SzD15WdVAmtBEkvIGytjnebI7CTxCwfiH9ACNXOY4rY,6276 +wandb/vendor/graphql-core-1.1/wandb_graphql/language/visitor_meta.py,sha256=Qat5ccqiNGOHE9W7z38YGdtW2c8koBw0OUWEMxpdBhk,2980 +wandb/vendor/graphql-core-1.1/wandb_graphql/pyutils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +wandb/vendor/graphql-core-1.1/wandb_graphql/pyutils/__pycache__/__init__.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/pyutils/__pycache__/cached_property.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/pyutils/__pycache__/contain_subset.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/pyutils/__pycache__/default_ordered_dict.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/pyutils/__pycache__/ordereddict.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/pyutils/__pycache__/pair_set.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/pyutils/__pycache__/version.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/pyutils/cached_property.py,sha256=eaxADzdmkEbkQmiu47k5p72Inyce9pxaVto1gvkkmMY,588 +wandb/vendor/graphql-core-1.1/wandb_graphql/pyutils/contain_subset.py,sha256=_-KYbYuSC3fiVSxcCwKHpwtS_Ig85HgRP6Hx5xbDF0E,1006 +wandb/vendor/graphql-core-1.1/wandb_graphql/pyutils/default_ordered_dict.py,sha256=xcFbt16AzcQsYehMOn-w04q1gOUiMzzySsKhpvpSQ6o,1288 +wandb/vendor/graphql-core-1.1/wandb_graphql/pyutils/ordereddict.py,sha256=YNLfN47G2nhMvl9Tm4DYPSJMzeLXKwTwAIPDarMtgjk,256 +wandb/vendor/graphql-core-1.1/wandb_graphql/pyutils/pair_set.py,sha256=gbdnd55q1UkTBdNSsAYVquiSSOAhI1q4mMWe6xfNkoI,1168 +wandb/vendor/graphql-core-1.1/wandb_graphql/pyutils/version.py,sha256=sd6hPQbuZ3kwijdPr5h6iZm2YFsmvqc9-6KtjRw7JU8,2454 +wandb/vendor/graphql-core-1.1/wandb_graphql/type/__init__.py,sha256=B_uo71CK3pr19VJjJf0G2dSEvS5p6zA5KbS53OxGsbY,1366 +wandb/vendor/graphql-core-1.1/wandb_graphql/type/__pycache__/__init__.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/type/__pycache__/definition.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/type/__pycache__/directives.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/type/__pycache__/introspection.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/type/__pycache__/scalars.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/type/__pycache__/schema.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/type/__pycache__/typemap.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/type/definition.py,sha256=IWLl1gp-mA5q1OTBkDXbn2v-vwU8F2ixdv24fkxLtL0,19260 +wandb/vendor/graphql-core-1.1/wandb_graphql/type/directives.py,sha256=HzUosIU0YzEzOvBPT0Ha8fXJoWYwPIXIYt2cVYvaopA,4108 +wandb/vendor/graphql-core-1.1/wandb_graphql/type/introspection.py,sha256=ZyyA_zIbe8HaSThL7O9Kl44NKDBAkKKp0QOlbUI4tLU,17580 +wandb/vendor/graphql-core-1.1/wandb_graphql/type/scalars.py,sha256=uk6XdTkW2iu5V8Do6LRP4AFvauHtoekVSh9YzxWrQmQ,3920 +wandb/vendor/graphql-core-1.1/wandb_graphql/type/schema.py,sha256=o6iMh91TedMeQXFxAn848hvyBZJXZ8OhZIz_XF8lK98,3484 +wandb/vendor/graphql-core-1.1/wandb_graphql/type/typemap.py,sha256=V-eprKfmudzHJm9bjArtJs0AogBnUhgQoqtsge44vNU,6854 +wandb/vendor/graphql-core-1.1/wandb_graphql/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +wandb/vendor/graphql-core-1.1/wandb_graphql/utils/__pycache__/__init__.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/utils/__pycache__/assert_valid_name.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/utils/__pycache__/ast_from_value.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/utils/__pycache__/ast_to_code.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/utils/__pycache__/ast_to_dict.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/utils/__pycache__/base.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/utils/__pycache__/build_ast_schema.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/utils/__pycache__/build_client_schema.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/utils/__pycache__/concat_ast.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/utils/__pycache__/extend_schema.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/utils/__pycache__/get_field_def.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/utils/__pycache__/get_operation_ast.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/utils/__pycache__/introspection_query.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/utils/__pycache__/is_valid_literal_value.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/utils/__pycache__/is_valid_value.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/utils/__pycache__/quoted_or_list.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/utils/__pycache__/schema_printer.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/utils/__pycache__/suggestion_list.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/utils/__pycache__/type_comparators.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/utils/__pycache__/type_from_ast.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/utils/__pycache__/type_info.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/utils/__pycache__/value_from_ast.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/utils/assert_valid_name.py,sha256=xqNTzOxF5UjdxIev_hUy3ewgBA9OOCiBQbIpdQlI3xs,308 +wandb/vendor/graphql-core-1.1/wandb_graphql/utils/ast_from_value.py,sha256=V0le6IGmSz1qaCqruCYVtzO2TDNffZo-Y4hYAZAOMyg,2037 +wandb/vendor/graphql-core-1.1/wandb_graphql/utils/ast_to_code.py,sha256=b5Qf8SeaqULW16bGIWTCZV5Mi0n-oUB_d5A-ez-d47k,1200 +wandb/vendor/graphql-core-1.1/wandb_graphql/utils/ast_to_dict.py,sha256=VtXQ63TuKC1EpKt3A96v4Bd4xIciRqVhk-rIHv8JiSs,638 +wandb/vendor/graphql-core-1.1/wandb_graphql/utils/base.py,sha256=qDhQwKRHDUN63UY4UbocIj6J8BnCEZD4meP_15ujzeo,2120 +wandb/vendor/graphql-core-1.1/wandb_graphql/utils/build_ast_schema.py,sha256=ljtWw-UiZZWaBsY3lfuHvsyXpoJ39KaxBwFVpbQjJ2o,10596 +wandb/vendor/graphql-core-1.1/wandb_graphql/utils/build_client_schema.py,sha256=a3x9-BKBa0xAQRNAuFtY6xbn9PChLrqpdG4Nu2sYPcY,10027 +wandb/vendor/graphql-core-1.1/wandb_graphql/utils/concat_ast.py,sha256=M7tFprLml4VjGXpxB5C_HLrRPbXcgr0dYyS_Ph4XCI8,204 +wandb/vendor/graphql-core-1.1/wandb_graphql/utils/extend_schema.py,sha256=A3uGbTgctv3AK4Bjd1tJM0x-AP6nP1Tv9MUYfoGhlaw,14143 +wandb/vendor/graphql-core-1.1/wandb_graphql/utils/get_field_def.py,sha256=PQU-C728tQHUOHBwK0oIc6iCnI8RdAEWZ3D3xtAJUkc,1108 +wandb/vendor/graphql-core-1.1/wandb_graphql/utils/get_operation_ast.py,sha256=h5_Ftqy1f2UExbOIw0EWENj-CY91KP_eStXRBvuL9Xc,834 +wandb/vendor/graphql-core-1.1/wandb_graphql/utils/introspection_query.py,sha256=UUt5Uiw9JHpkClfXyd6CIuC9LABoW2qxg95EH6OK_OE,1472 +wandb/vendor/graphql-core-1.1/wandb_graphql/utils/is_valid_literal_value.py,sha256=bIU5jV8pLARq_3qIc6jAWf1N2OCC5w4-qYCMzljupss,2366 +wandb/vendor/graphql-core-1.1/wandb_graphql/utils/is_valid_value.py,sha256=jE5_hyTb7Dj_Qr68Wg0dUCVy1DsS4Iq_TEm6wH-L664,2192 +wandb/vendor/graphql-core-1.1/wandb_graphql/utils/quoted_or_list.py,sha256=5nxFfvx2zMjravOr4uQadWxZ5KilIfOFSFyiGuTv9SY,704 +wandb/vendor/graphql-core-1.1/wandb_graphql/utils/schema_printer.py,sha256=dPXqQI-HjebWPcjKJj_Sgj4jiRauGPQMTaV808PLpCw,4792 +wandb/vendor/graphql-core-1.1/wandb_graphql/utils/suggestion_list.py,sha256=eW9FUe3-ByBL86Rr3EZ5wSMqX_rEHWkzSFCYt_67jeI,1845 +wandb/vendor/graphql-core-1.1/wandb_graphql/utils/type_comparators.py,sha256=bwHJP9lVRgTiwhxgGyrwpcn9VAE1q7J2coJRJZs-ETg,2433 +wandb/vendor/graphql-core-1.1/wandb_graphql/utils/type_from_ast.py,sha256=TylOn7PMSmbggdoKibSA2-O2A_JvGn3NDWySeJ6k9g8,703 +wandb/vendor/graphql-core-1.1/wandb_graphql/utils/type_info.py,sha256=D3IKU0hjGOheSh5vfV1BB6MSKtrQbFeGo-mmJUQ8NDM,4915 +wandb/vendor/graphql-core-1.1/wandb_graphql/utils/value_from_ast.py,sha256=XVlFlYTPeXf5HaO0M3lZjFj_3jvlAMJRjbQTFcQhURc,2437 +wandb/vendor/graphql-core-1.1/wandb_graphql/validation/__init__.py,sha256=dZtKP6R2FTSCc2gAkTOTayqmyrRl_gQlzBQCIDb3k10,111 +wandb/vendor/graphql-core-1.1/wandb_graphql/validation/__pycache__/__init__.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/validation/__pycache__/validation.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/validation/rules/__init__.py,sha256=WZsygnTsLd51GgWvmSWUAhGptrV0GzCB2pIcmDExFYA,2736 +wandb/vendor/graphql-core-1.1/wandb_graphql/validation/rules/__pycache__/__init__.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/validation/rules/__pycache__/arguments_of_correct_type.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/validation/rules/__pycache__/base.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/validation/rules/__pycache__/default_values_of_correct_type.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/validation/rules/__pycache__/fields_on_correct_type.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/validation/rules/__pycache__/fragments_on_composite_types.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/validation/rules/__pycache__/known_argument_names.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/validation/rules/__pycache__/known_directives.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/validation/rules/__pycache__/known_fragment_names.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/validation/rules/__pycache__/known_type_names.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/validation/rules/__pycache__/lone_anonymous_operation.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/validation/rules/__pycache__/no_fragment_cycles.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/validation/rules/__pycache__/no_undefined_variables.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/validation/rules/__pycache__/no_unused_fragments.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/validation/rules/__pycache__/no_unused_variables.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/validation/rules/__pycache__/overlapping_fields_can_be_merged.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/validation/rules/__pycache__/possible_fragment_spreads.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/validation/rules/__pycache__/provided_non_null_arguments.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/validation/rules/__pycache__/scalar_leafs.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/validation/rules/__pycache__/unique_argument_names.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/validation/rules/__pycache__/unique_fragment_names.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/validation/rules/__pycache__/unique_input_field_names.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/validation/rules/__pycache__/unique_operation_names.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/validation/rules/__pycache__/unique_variable_names.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/validation/rules/__pycache__/variables_are_input_types.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/validation/rules/__pycache__/variables_in_allowed_position.cpython-38.pyc,, +wandb/vendor/graphql-core-1.1/wandb_graphql/validation/rules/arguments_of_correct_type.py,sha256=0aFzTM-khI1psJZWnAMG91bCg1aZZphdSYRGslaymwc,982 +wandb/vendor/graphql-core-1.1/wandb_graphql/validation/rules/base.py,sha256=7hsprORsfDPcxJ4Ojvpn0qe1ZuGrnbrDT9BgK3Bd3EQ,165 +wandb/vendor/graphql-core-1.1/wandb_graphql/validation/rules/default_values_of_correct_type.py,sha256=l6khdFWN7K_we_uftEOjpaIx6bFYNdqTNqHr9RZHG9Q,1851 +wandb/vendor/graphql-core-1.1/wandb_graphql/validation/rules/fields_on_correct_type.py,sha256=hySfm5eYpG8ZIhDMVqpd2Ryo2JksBQBAlJZUoMekdF4,4401 +wandb/vendor/graphql-core-1.1/wandb_graphql/validation/rules/fragments_on_composite_types.py,sha256=5C4MABVySMpqlnE54e54D1gUn1EtBgQxTliu_aG_IV4,1333 +wandb/vendor/graphql-core-1.1/wandb_graphql/validation/rules/known_argument_names.py,sha256=4uDSSjMWlCVmYspTU0TR-SKBmjGqcuhBdbtejx4pctY,2484 +wandb/vendor/graphql-core-1.1/wandb_graphql/validation/rules/known_directives.py,sha256=0_V12oJpcblXXdPD7yZDeL_vp2lg90xfKT0-Q1N-nU0,3434 +wandb/vendor/graphql-core-1.1/wandb_graphql/validation/rules/known_fragment_names.py,sha256=W7k15YYDlsQqET6Frdn7_5NRhXGz0YKzlH8sBj30m90,597 +wandb/vendor/graphql-core-1.1/wandb_graphql/validation/rules/known_type_names.py,sha256=bLW1UkYYCu_KFEGZJEHydMjqrSprkHjHlzAnmLZjQnw,1258 +wandb/vendor/graphql-core-1.1/wandb_graphql/validation/rules/lone_anonymous_operation.py,sha256=egiNdBr2s1QHpP9Z2i9fL6PtlT17GXPfEiMh2F_v1Os,897 +wandb/vendor/graphql-core-1.1/wandb_graphql/validation/rules/no_fragment_cycles.py,sha256=myRMv0nLzmW0KGfyYUxvv6DiMZG50y7FTfNKkFg42MU,2275 +wandb/vendor/graphql-core-1.1/wandb_graphql/validation/rules/no_undefined_variables.py,sha256=1LqfZ3rH9E5KH3zQA5wd_BXUQdihrkFSTqVKG4j7gVo,1391 +wandb/vendor/graphql-core-1.1/wandb_graphql/validation/rules/no_unused_fragments.py,sha256=RG4DVQL7nA2MCijZtCVqKLVJN4dqQxVM_I1IQUUluNA,1489 +wandb/vendor/graphql-core-1.1/wandb_graphql/validation/rules/no_unused_variables.py,sha256=L4N3BzkvJ1GZI6gi2zsMinhej5bWQZqUcJWQ1qu5YJw,1508 +wandb/vendor/graphql-core-1.1/wandb_graphql/validation/rules/overlapping_fields_can_be_merged.py,sha256=CbtRQfEnQP6FTsqC_Jk9XSw4eGVb8shkA5P6yWxAxpk,24145 +wandb/vendor/graphql-core-1.1/wandb_graphql/validation/rules/possible_fragment_spreads.py,sha256=Oky-9Ta0aYgP0Fe1oOtwiOjrWvTpLVWGGwY6B-18l0g,2193 +wandb/vendor/graphql-core-1.1/wandb_graphql/validation/rules/provided_non_null_arguments.py,sha256=fdTVBXQXVgi3MKhGL0FYHYGq-HKCh3HLKAyc9POqD5c,1869 +wandb/vendor/graphql-core-1.1/wandb_graphql/validation/rules/scalar_leafs.py,sha256=Dei3Ss_ycaYfan-F8UBL6IyBjCWdGRoQ85nAq8Y2sFg,1115 +wandb/vendor/graphql-core-1.1/wandb_graphql/validation/rules/unique_argument_names.py,sha256=sCdSGBraWwNUpHhwPu3dk0t3aCPqVWgo1Y4v6LOMnzU,1024 +wandb/vendor/graphql-core-1.1/wandb_graphql/validation/rules/unique_fragment_names.py,sha256=xb_0UhQF7YDlK-vA1u-li6PL3V2FF3Z_kTLGTEKksoI,1002 +wandb/vendor/graphql-core-1.1/wandb_graphql/validation/rules/unique_input_field_names.py,sha256=_YAne-NO_OIenreW4v1XnJES4AK3Y9O_HhUk6M6ilPo,1187 +wandb/vendor/graphql-core-1.1/wandb_graphql/validation/rules/unique_operation_names.py,sha256=kzWjZtAiBou5WhZaOMzrB9UE_fZ8iN2M-VuOlN93lqA,1114 +wandb/vendor/graphql-core-1.1/wandb_graphql/validation/rules/unique_variable_names.py,sha256=5L90Rgnz8UM7N16mxZ4f263Wa4GCGIfLIHKh-UW3mlU,1034 +wandb/vendor/graphql-core-1.1/wandb_graphql/validation/rules/variables_are_input_types.py,sha256=9SbvdDA6ZshPM9-LqHI1byqO-3PwtfvyIgeXr5PHHvA,826 +wandb/vendor/graphql-core-1.1/wandb_graphql/validation/rules/variables_in_allowed_position.py,sha256=hqX7f5LJw3we9OoPWXgQpF333nrYDG_AZr4sSITTyXc,2367 +wandb/vendor/graphql-core-1.1/wandb_graphql/validation/validation.py,sha256=hRqVfs3jp0GFm44DDfKQipb0BEs-dgEeg8X5BcXf8lA,5580 +wandb/vendor/pygments/__init__.py,sha256=IkWLwTf8uusJPx4c3f3gpHwVJVi0UqeD6mo5wWHHdWs,3145 +wandb/vendor/pygments/__pycache__/__init__.cpython-38.pyc,, +wandb/vendor/pygments/__pycache__/cmdline.cpython-38.pyc,, +wandb/vendor/pygments/__pycache__/console.cpython-38.pyc,, +wandb/vendor/pygments/__pycache__/filter.cpython-38.pyc,, +wandb/vendor/pygments/__pycache__/formatter.cpython-38.pyc,, +wandb/vendor/pygments/__pycache__/lexer.cpython-38.pyc,, +wandb/vendor/pygments/__pycache__/modeline.cpython-38.pyc,, +wandb/vendor/pygments/__pycache__/plugin.cpython-38.pyc,, +wandb/vendor/pygments/__pycache__/regexopt.cpython-38.pyc,, +wandb/vendor/pygments/__pycache__/scanner.cpython-38.pyc,, +wandb/vendor/pygments/__pycache__/sphinxext.cpython-38.pyc,, +wandb/vendor/pygments/__pycache__/style.cpython-38.pyc,, +wandb/vendor/pygments/__pycache__/token.cpython-38.pyc,, +wandb/vendor/pygments/__pycache__/unistring.cpython-38.pyc,, +wandb/vendor/pygments/__pycache__/util.cpython-38.pyc,, +wandb/vendor/pygments/cmdline.py,sha256=_UA78VWUx--QdlHM0OuTu0W3zjDPhoVz8ipmjomf2Ac,19326 +wandb/vendor/pygments/console.py,sha256=AgkV5lDp2ghozb_J8V_UPZ0uudTWTz3isSK9oUvo750,1809 +wandb/vendor/pygments/filter.py,sha256=leZuvZlYC79jmrF_7ovSAZL5xohIhj7gx59FQx_F6gw,2038 +wandb/vendor/pygments/filters/__init__.py,sha256=IlSO7Mm0meA1rfssNwR9u7626sscMnASJlZ94yEy9lA,11573 +wandb/vendor/pygments/filters/__pycache__/__init__.cpython-38.pyc,, +wandb/vendor/pygments/formatter.py,sha256=RaPGA3oLywAbvSkzrj61U5Y8xzYai32bbajg8L3xreE,2948 +wandb/vendor/pygments/formatters/__init__.py,sha256=g5hpFvO_jy4-OV-pJr0jRP-vktKi6pXJKZ1z_XDnLIE,5099 +wandb/vendor/pygments/formatters/__pycache__/__init__.cpython-38.pyc,, +wandb/vendor/pygments/formatters/__pycache__/_mapping.cpython-38.pyc,, +wandb/vendor/pygments/formatters/__pycache__/bbcode.cpython-38.pyc,, +wandb/vendor/pygments/formatters/__pycache__/html.cpython-38.pyc,, +wandb/vendor/pygments/formatters/__pycache__/img.cpython-38.pyc,, +wandb/vendor/pygments/formatters/__pycache__/irc.cpython-38.pyc,, +wandb/vendor/pygments/formatters/__pycache__/latex.cpython-38.pyc,, +wandb/vendor/pygments/formatters/__pycache__/other.cpython-38.pyc,, +wandb/vendor/pygments/formatters/__pycache__/rtf.cpython-38.pyc,, +wandb/vendor/pygments/formatters/__pycache__/svg.cpython-38.pyc,, +wandb/vendor/pygments/formatters/__pycache__/terminal.cpython-38.pyc,, +wandb/vendor/pygments/formatters/__pycache__/terminal256.cpython-38.pyc,, +wandb/vendor/pygments/formatters/_mapping.py,sha256=E2DsoS8TZDCv_jJ1mn48rb3Qs4RIr8SJwILEVhYpGk4,6214 +wandb/vendor/pygments/formatters/bbcode.py,sha256=LYa2w-Ep7475be0GSH4MbuYiwH3gWIqpG4dQFCZLbGk,3314 +wandb/vendor/pygments/formatters/html.py,sha256=gvCUGAsxerTWRKnXa3a5ezmJg70KLt7wDb57JGjZhug,31759 +wandb/vendor/pygments/formatters/img.py,sha256=yWhrS8vgisj9XGOWjUrwtd8VZNuAffnBF8IAWl6p44g,19780 +wandb/vendor/pygments/formatters/irc.py,sha256=ApSLVBfjK78gkzXnMC8UrgnBLQulOvb-fza2e-D_RCI,5775 +wandb/vendor/pygments/formatters/latex.py,sha256=izNn5NjCTgu0gq8cyvvwNlRwc52CyAwvprN6DwlbUvU,17758 +wandb/vendor/pygments/formatters/other.py,sha256=p14Jboe9qeJ4xy9Xcb4f90szuQvQ0RI0q9DctZZmXDY,5162 +wandb/vendor/pygments/formatters/rtf.py,sha256=8HK5CpvqLchEWlbYptQKQ2RxQmayNLYyPOovCYBw4l4,5049 +wandb/vendor/pygments/formatters/svg.py,sha256=FT-DWvkC7bJ34-szEmh14PoqyqQkUE2jDPPVwOelqYQ,5840 +wandb/vendor/pygments/formatters/terminal.py,sha256=KkBzLxYMDvfbJXOecTgM1rAIVkYWYkE1a9pNIqtT0AA,4919 +wandb/vendor/pygments/formatters/terminal256.py,sha256=UKFNPANdnt2eGvYw_fRkyW2gKKXVpL9A5jVgEpGxd3g,10776 +wandb/vendor/pygments/lexer.py,sha256=CrUoLYlQbxO5W0YLH_a1lI8Dkw2l4nRZ5ciy9-R-n0I,31054 +wandb/vendor/pygments/lexers/__init__.py,sha256=77oWKOFsKWByzG5aMNDsWBJl0lQYSNgIC8XUUV2pCW4,10906 +wandb/vendor/pygments/lexers/__pycache__/__init__.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/_asy_builtins.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/_cl_builtins.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/_cocoa_builtins.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/_csound_builtins.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/_lasso_builtins.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/_lua_builtins.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/_mapping.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/_mql_builtins.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/_openedge_builtins.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/_php_builtins.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/_postgres_builtins.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/_scilab_builtins.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/_sourcemod_builtins.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/_stan_builtins.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/_stata_builtins.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/_tsql_builtins.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/_vim_builtins.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/actionscript.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/agile.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/algebra.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/ambient.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/ampl.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/apl.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/archetype.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/asm.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/automation.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/basic.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/bibtex.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/business.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/c_cpp.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/c_like.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/capnproto.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/chapel.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/clean.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/compiled.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/configs.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/console.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/crystal.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/csound.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/css.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/d.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/dalvik.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/data.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/diff.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/dotnet.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/dsls.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/dylan.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/ecl.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/eiffel.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/elm.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/erlang.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/esoteric.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/ezhil.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/factor.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/fantom.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/felix.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/forth.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/fortran.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/foxpro.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/functional.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/go.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/grammar_notation.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/graph.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/graphics.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/haskell.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/haxe.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/hdl.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/hexdump.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/html.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/idl.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/igor.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/inferno.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/installers.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/int_fiction.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/iolang.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/j.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/javascript.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/julia.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/jvm.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/lisp.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/make.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/markup.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/math.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/matlab.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/ml.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/modeling.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/modula2.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/monte.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/ncl.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/nimrod.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/nit.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/nix.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/oberon.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/objective.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/ooc.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/other.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/parasail.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/parsers.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/pascal.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/pawn.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/perl.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/php.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/praat.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/prolog.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/python.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/qvt.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/r.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/rdf.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/rebol.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/resource.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/rnc.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/roboconf.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/robotframework.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/ruby.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/rust.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/sas.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/scripting.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/shell.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/smalltalk.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/smv.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/snobol.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/special.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/sql.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/stata.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/supercollider.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/tcl.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/templates.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/testing.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/text.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/textedit.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/textfmts.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/theorem.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/trafficscript.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/typoscript.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/urbi.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/varnish.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/verification.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/web.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/webmisc.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/whiley.cpython-38.pyc,, +wandb/vendor/pygments/lexers/__pycache__/x10.cpython-38.pyc,, +wandb/vendor/pygments/lexers/_asy_builtins.py,sha256=zph3J1PBBtWjrvc_hUrmY-vk2WkN4zwT3OICH6nnyN0,27321 +wandb/vendor/pygments/lexers/_cl_builtins.py,sha256=1KrMgXg50ZsI02_WlDFuHugJzA-1LygeeUmHGBHBIgw,14053 +wandb/vendor/pygments/lexers/_cocoa_builtins.py,sha256=8b6As01z9rEa14hp7DXSXKHQXnRVI13eWEZ5rcmn5Bk,39982 +wandb/vendor/pygments/lexers/_csound_builtins.py,sha256=JkAZhrG-lXndYAsxWU2VqPce7MfwDknl7u8cYi3tAjs,21643 +wandb/vendor/pygments/lexers/_lasso_builtins.py,sha256=5PNX3gtW3f0X8gzoZUR6JW3mYzck3RcO1J6XtkUhY6Q,134534 +wandb/vendor/pygments/lexers/_lua_builtins.py,sha256=q1bCBDWwe7g-FwonM_xrGibEGdEYJvcdWRVGpYgBPpo,8340 +wandb/vendor/pygments/lexers/_mapping.py,sha256=_P3TsdkuN1NptMfEQkplLCf5TklMRNDi6Rtl_oc4XR4,54715 +wandb/vendor/pygments/lexers/_mql_builtins.py,sha256=qa9s_tUqXl16pAKzRDtWsJKzDPoU-bGaGdgrmHx7XOk,24736 +wandb/vendor/pygments/lexers/_openedge_builtins.py,sha256=0ADwH8PqzC6rJ_SZ8b3j0TgNut1kvLZL8RxpbC3J_nk,48362 +wandb/vendor/pygments/lexers/_php_builtins.py,sha256=cpkFCfHjPG1zExNaMI1JQY1at54pf5RMu-yCBmtwl78,154368 +wandb/vendor/pygments/lexers/_postgres_builtins.py,sha256=me5pfqtfUMpXYSvuTYXscyLCYUY9TcmBX8pGwimHG1U,11210 +wandb/vendor/pygments/lexers/_scilab_builtins.py,sha256=yXpa-XsMiNRgsPpDENWvZFZZJndUGFgv8uioKcfnejI,52405 +wandb/vendor/pygments/lexers/_sourcemod_builtins.py,sha256=DPFvfIi76GawQ603QG_EAFzl_6mmK5xZxfGWl4qlKFM,27113 +wandb/vendor/pygments/lexers/_stan_builtins.py,sha256=y6S6OymabXXmgrF3tMVkTxMHzkdyOi-Q_s0M2qdh-Xk,10121 +wandb/vendor/pygments/lexers/_stata_builtins.py,sha256=Hods-_4P3Ixov_hf9z6oeq-J_W_a8XOo8p--bECWJKo,25139 +wandb/vendor/pygments/lexers/_tsql_builtins.py,sha256=opXLcAQOoAgcizztFXepEHBABOrGjSvDWU3TxVvJS3M,15484 +wandb/vendor/pygments/lexers/_vim_builtins.py,sha256=mIYAlwzf687UR8oPcY6y48H-BjTyPNDx1oHiRc5wByw,57090 +wandb/vendor/pygments/lexers/actionscript.py,sha256=HWGTyjPGho_kZVVTxemN0_5iyhK5wFgFQQ0MYVS0as8,11179 +wandb/vendor/pygments/lexers/agile.py,sha256=zB0BGCISgQB2b-3ch3QNRgV2O7jq7QPD5nvBbXA_K5U,900 +wandb/vendor/pygments/lexers/algebra.py,sha256=fhvIdLDS3oW0iMsDSBAzg8l9DuBXxfLRFC53xRIzvHU,7201 +wandb/vendor/pygments/lexers/ambient.py,sha256=M77HDk4dzs3Amlgwi_ogj1PV1Ch77PyEW6SU5AFtL4w,2557 +wandb/vendor/pygments/lexers/ampl.py,sha256=6AQASY--hmYXtgkzsthZymRM4bzQ_RQZZC5Wu4RJG-A,4120 +wandb/vendor/pygments/lexers/apl.py,sha256=Lpv2nI1bSC_VpmckdbpMiuxWx-WVb6FgFWoJ31q002w,3167 +wandb/vendor/pygments/lexers/archetype.py,sha256=IwyDTh-U673WHQQThuf2dBz0Fc-XlcAP-xAhtnR2DH4,11136 +wandb/vendor/pygments/lexers/asm.py,sha256=YysaSPQr0Ir79aM5C0eOB7g8-vJ6m2gWdbghsEElGBM,25261 +wandb/vendor/pygments/lexers/automation.py,sha256=g_laLS9LstvXvrvVQI01fAf0fyZ4-ZHFewdVLtXPXf0,19648 +wandb/vendor/pygments/lexers/basic.py,sha256=XfeI7Tk78lN7YMqS6bYdRB6CRPa2vxcm5PzA2EbILnc,20306 +wandb/vendor/pygments/lexers/bibtex.py,sha256=CcIdWMtCUtpHoqXU9JtGYKOmQJscO7AwofABCnEx_lk,4724 +wandb/vendor/pygments/lexers/business.py,sha256=iJbZjsF_CwJvkWmuDEAUgRhIPN3Vus_sp2m4V9AsKuo,27665 +wandb/vendor/pygments/lexers/c_cpp.py,sha256=Ty6LTWNG_ZR8eLNmcdBmJfUIJlkAyd033JqIH3Mfric,10523 +wandb/vendor/pygments/lexers/c_like.py,sha256=AoPSFV_TFPudAnvkV0wLlM00A3_JrddoTd5GRMyeHcY,24124 +wandb/vendor/pygments/lexers/capnproto.py,sha256=8pl0G3q7k5AJeoe6Yfr2eMs81V8KW1IlduzkRPaNb7A,2188 +wandb/vendor/pygments/lexers/chapel.py,sha256=dMPHVlkPsEhqOHQmuX8QlxJ48c1Pml8Q7RpOhc9lYUk,3511 +wandb/vendor/pygments/lexers/clean.py,sha256=IukUXRAQigyPLlD4K1tfZhQ8qH2l6gVn4hGFuHsz_vc,10403 +wandb/vendor/pygments/lexers/compiled.py,sha256=9d_XDV75Fi_EnrsVPAexfs8LRAysfixpZDNqVEhjGUU,1385 +wandb/vendor/pygments/lexers/configs.py,sha256=W1OdBJEwZWp7imQE1bC6a4sGIGoKw5LIbmYwau6u6Ds,28266 +wandb/vendor/pygments/lexers/console.py,sha256=7rwV7Jsci0nC74JDVzNlD5-PlRsfzZspHfYFSC8OKtM,4120 +wandb/vendor/pygments/lexers/crystal.py,sha256=h6M1BX-vWjCUtPQNXH1KqgqoxuB6geR3kCKp74sIb48,16845 +wandb/vendor/pygments/lexers/csound.py,sha256=t4bVgLEkNXEFZdfdfB43yWGXjJhT3aiKN9uLHNrTtZA,12544 +wandb/vendor/pygments/lexers/css.py,sha256=QZadHT6mYr14tMhZKDVRP3uu_AWSmGNIkn7KUr5H_0k,31513 +wandb/vendor/pygments/lexers/d.py,sha256=G-RV1UPAI8Q6mstQCMa4vNhwop0pG2NO1APHkOLdayA,9530 +wandb/vendor/pygments/lexers/dalvik.py,sha256=RDuGFuTqCG1PxhBn-I80iJxegrJpUDi_knxCKwN1cKQ,4420 +wandb/vendor/pygments/lexers/data.py,sha256=HOBr6Xw4QOYI6sD3vvtuSoYRdMaQYBnT0IcgpWUwTx0,18771 +wandb/vendor/pygments/lexers/diff.py,sha256=n7dxgD0_z0W2LH_zf55E1erBs5iBHFZPZ0bItXSeiLI,4873 +wandb/vendor/pygments/lexers/dotnet.py,sha256=IxNL30wmyw-Z_QRSUf9G9kbhz017BP5Pjqn2LEcfE9A,27668 +wandb/vendor/pygments/lexers/dsls.py,sha256=6v76UwDB7PngLM0Ye79mz_cXpg075RBgTzS9VXIsMQw,33336 +wandb/vendor/pygments/lexers/dylan.py,sha256=YJyoYcXD622vwYxqCNtyoHqi-L67CABzNfcg9ERt1Ic,10421 +wandb/vendor/pygments/lexers/ecl.py,sha256=bRD_m3B8npOLIyHjxhcWUCXeD9YCw7I6u5WsCUb7Kpc,5875 +wandb/vendor/pygments/lexers/eiffel.py,sha256=1-7weE5oflU_dzDVhaQFx5ildMbBuCZ3OFXJpJ-U78c,2482 +wandb/vendor/pygments/lexers/elm.py,sha256=3qhDIU0GFJ4YzuVDyvbHZ39dOyY60QFVpRvDdpDeYUw,2996 +wandb/vendor/pygments/lexers/erlang.py,sha256=Ja1SxnF-f48ort3oRb4R9aaHXbLJZIp0ItsgI8ITDJM,18936 +wandb/vendor/pygments/lexers/esoteric.py,sha256=wdtih2rpCV-N79Rf2laxzlqSBMYwzQgeCtBcutTbt1E,9490 +wandb/vendor/pygments/lexers/ezhil.py,sha256=o3qj60N-fyLGjcho1lrVW4x-CZ0Fu-rDe7tuqInD5oQ,3020 +wandb/vendor/pygments/lexers/factor.py,sha256=Trq7bM5thNo6BFZ2Tnit82FnWuUK70TL-atOKkLdHng,17864 +wandb/vendor/pygments/lexers/fantom.py,sha256=AGk3ewVsJ8gA9dU6N7iWGIlJLt5p61vRiJmVhyCj7Zg,9982 +wandb/vendor/pygments/lexers/felix.py,sha256=94Ffv8uhADGlom_cjKKvlE1QYpDnxRo0EdPGYhlxNTA,9408 +wandb/vendor/pygments/lexers/forth.py,sha256=uN-Sr5fi4SHnTluGzwmUsPgMFt470gSM212e7M5bH9Q,7144 +wandb/vendor/pygments/lexers/fortran.py,sha256=QRpUhXg0xnUu8EqsbEG6S33Sn8AWU326RiC8J-r2ZVw,9768 +wandb/vendor/pygments/lexers/foxpro.py,sha256=AWnHAryB1dUQkU4I48zoJFI8M_DsoIlEmvemDs1O4nM,26236 +wandb/vendor/pygments/lexers/functional.py,sha256=PPhynqxQZ602rCV-TxNldHRwhjMPfyHkGIOPx0BoVZo,698 +wandb/vendor/pygments/lexers/go.py,sha256=6IS3PKkqGG18OIlYqDGUp46S1jcfAfjhixNJe8Dd3gQ,3701 +wandb/vendor/pygments/lexers/grammar_notation.py,sha256=xyJi8t0X8SFElc3HTsmzF4_2mZs-qHW-ur9kZKt48D0,6328 +wandb/vendor/pygments/lexers/graph.py,sha256=-71ZtKUTq4LX4uUyRWFruA57Z_8lyOas1z1bWdq8eMs,2370 +wandb/vendor/pygments/lexers/graphics.py,sha256=6AoxbU5ybgg0_Mm48dZlspishe7PuK0pa_8bsPsDVfM,25836 +wandb/vendor/pygments/lexers/haskell.py,sha256=uOzfXPsn9mBs26GzEm-3qNNNJy6Oxc66lt0NVDVRR-M,31218 +wandb/vendor/pygments/lexers/haxe.py,sha256=QWR5lBwbdCMrJbFcUAs4SnP66zVV8O-DiT4c4x6XtBA,30953 +wandb/vendor/pygments/lexers/hdl.py,sha256=h3CYE2ShUOejE7w0d1eSHkGgCS4EXJodOVgjfACWYz8,18699 +wandb/vendor/pygments/lexers/hexdump.py,sha256=-_u6qAw7yH7b8_25tHNLiybD3r5-OaYYwtf9RsSxfeE,3507 +wandb/vendor/pygments/lexers/html.py,sha256=1f0HI3wZoGZL9PY6dLdmG8AytfT3oEosKHQp3DuDZmY,19269 +wandb/vendor/pygments/lexers/idl.py,sha256=gNT6hIlEMD-ZjLZ3ru6RH7Z-X5u7TKQ7lRP_9Sz1SSg,14984 +wandb/vendor/pygments/lexers/igor.py,sha256=PsDRDxMkwslMjd4GdZmAOXLrblsc2FANBMlNfv-XbVg,19994 +wandb/vendor/pygments/lexers/inferno.py,sha256=G4uU8YQD9EGvDNCc6Av6LWvyRB8unp5qv47PfLUek_8,3116 +wandb/vendor/pygments/lexers/installers.py,sha256=QEPP1YcZ38DvErs7xwpChvKQFh1I6fIp0V6MXxIwzeY,12866 +wandb/vendor/pygments/lexers/int_fiction.py,sha256=m8rYr5egxBSxZ9FKunV_Yl_EtpoRBz1j55J_dtKG9oo,55778 +wandb/vendor/pygments/lexers/iolang.py,sha256=1kvzEPcJZ2eyF7mu58NT9yyqZobOvx1MlbUxA98bLJs,1904 +wandb/vendor/pygments/lexers/j.py,sha256=e6oqJQslgSl6q3hfEuTl0mtFnqCj4G29SwcMnTeBDBc,4525 +wandb/vendor/pygments/lexers/javascript.py,sha256=79c9e2wn7HiJ9S4WvRQ0qymMqj-YV7CS308_pMRNirk,60134 +wandb/vendor/pygments/lexers/julia.py,sha256=vXU5r_p6ko-I_fKITqiFmMn0rpw0NWujKVGGrndkfOI,14093 +wandb/vendor/pygments/lexers/jvm.py,sha256=9fjCUGFGApGNMDsrCWzaEiDA_CcoZPDaYAvBHFAh524,66792 +wandb/vendor/pygments/lexers/lisp.py,sha256=xeF_wQGdm-vkJ2j1JQd9mipAAtjwY3giOEH2cW2j0jk,140673 +wandb/vendor/pygments/lexers/make.py,sha256=jGkYUD5PD4vG7gC6qExOAp8ZE4KoB0jLMcTF5NzZGQs,7332 +wandb/vendor/pygments/lexers/markup.py,sha256=KQsXc5K_rn7G7bATKt81yURJjHHi5kCLokJXXom997I,20452 +wandb/vendor/pygments/lexers/math.py,sha256=TaE1dzOfu6ukxMFAInZI_Ua105LDnxx86Ufk4YdnvfA,700 +wandb/vendor/pygments/lexers/matlab.py,sha256=GUys_wezfz7n_F9U5l2HZauxlsSxrRh0bkgIjfhZ7ro,29146 +wandb/vendor/pygments/lexers/ml.py,sha256=GDreW4Pmgqt8BlfbeRG43e3wS3wSm_A7cHPKGeGY9hQ,27891 +wandb/vendor/pygments/lexers/modeling.py,sha256=4O9hB4wAhjD2HFYa74HsLf9QK4E8kq7k8c5M7WuM1f4,12833 +wandb/vendor/pygments/lexers/modula2.py,sha256=mNbhlG9lNZRXP9kzx9diJj7l6hiPQVqmOzrfJ53GarU,52561 +wandb/vendor/pygments/lexers/monte.py,sha256=MNswWqletPzSIg6TcECb-Dcq1bv-eSPhYLsbc-vnJzM,6307 +wandb/vendor/pygments/lexers/ncl.py,sha256=cvnCcYpC0jpHBrwtNXZhY5HheY3UMThsYbgscHGvZLM,63986 +wandb/vendor/pygments/lexers/nimrod.py,sha256=OizSj9kHvtFEu0OPXuBrXZCf_ZBMnR4hm3nMbjw50hQ,5174 +wandb/vendor/pygments/lexers/nit.py,sha256=1SJ45GOd9zQKuWhPuVy-KhLkXQn6V-7ESvjJJ7U9Vpo,2743 +wandb/vendor/pygments/lexers/nix.py,sha256=dWzLp5QxzLmskDflyMUGidGNau9Vtk8ViK5c6B2O4kI,4031 +wandb/vendor/pygments/lexers/oberon.py,sha256=CbqkEOdqxvWXfez5FiGeCE-f-Vlt6tu9kqPFEVVXAQc,3733 +wandb/vendor/pygments/lexers/objective.py,sha256=qCPLLfU3hl-CIOJWAZdQYjeIl1Ox1igZaPRGKowKYbs,22764 +wandb/vendor/pygments/lexers/ooc.py,sha256=_lnOynAR0vHli7OKWJ4yZs9-hyPZE5DGKwkdkP6SCuM,2999 +wandb/vendor/pygments/lexers/other.py,sha256=Utlo5esm3DetK9PSOueHu5mEjR25dIN3T_g2-u9cmeA,1768 +wandb/vendor/pygments/lexers/parasail.py,sha256=Egm3PcuCBjDgwUvvI0-t3oXMz4PPRY0dER3orrrlnfc,2737 +wandb/vendor/pygments/lexers/parsers.py,sha256=S93llPIzcqL0VU2C_SzFa-pykNcFE37Kvy9_7fNmdg4,27582 +wandb/vendor/pygments/lexers/pascal.py,sha256=tA4Na6dzTz8nd9-Q_tcBFVDo161qfG9bR4xIIIB8FY0,32646 +wandb/vendor/pygments/lexers/pawn.py,sha256=eJJfXLHPYEPflh3fKgyq4PD5b52pcqjBnAGDicqHK9w,8094 +wandb/vendor/pygments/lexers/perl.py,sha256=-k_lftMhedsEIQwmvEZyy8Xbtlgj28_fic6HhN_ZYGI,32012 +wandb/vendor/pygments/lexers/php.py,sha256=7tgZQvYAnprFRQfAUxOlXgNkeUyOYsvIkM5oW0NSzOU,10730 +wandb/vendor/pygments/lexers/praat.py,sha256=GpHWS1IyqpvFCbZ7JWXSyxgBl8KAQED8IonkJM-Ml28,12556 +wandb/vendor/pygments/lexers/prolog.py,sha256=GWAUHvP3eyROfr3ry8g_7OJSNpD3vwfAFTJsrqIL7cQ,12066 +wandb/vendor/pygments/lexers/python.py,sha256=pn_V-1XyAqoYD4x8Pclk4eP8nkYvacpObY06xwDYSq8,42384 +wandb/vendor/pygments/lexers/qvt.py,sha256=LnLMM2jTrc5k4kInraQmmui1mgf76Wx5Ln2CfBFqj4I,6111 +wandb/vendor/pygments/lexers/r.py,sha256=6aUQ8T4qn6qIWuR-D9P_r05CEcP5SJ8wMadzUVrgJ4k,23755 +wandb/vendor/pygments/lexers/rdf.py,sha256=qbH7suOIdGY435x721iWhJ9QXT3MYPo874Jss8f2WCY,9398 +wandb/vendor/pygments/lexers/rebol.py,sha256=91kF9ueomN_2-Za8u1nIsuYN6uTQ3T1UbZk3IfRoiD8,18617 +wandb/vendor/pygments/lexers/resource.py,sha256=uS23PmW5COZfyyCte9s6xLhqZS2uhfH5P3G41QGp5U0,2933 +wandb/vendor/pygments/lexers/rnc.py,sha256=QvwLWh7IG9LYp9hmD7dI2MM4ikNaeqSQf26LmCBPVLA,1990 +wandb/vendor/pygments/lexers/roboconf.py,sha256=2__rRqffgFjrqyFFHHjibSg1qHCm2_lIT7lOGu63DNI,2070 +wandb/vendor/pygments/lexers/robotframework.py,sha256=qKKxIoTAMDnr_iDEnFsF9sjH63uhr1hDQUMStJydMYo,18744 +wandb/vendor/pygments/lexers/ruby.py,sha256=pukJJddNWR7jC4Uxc_qnOrcFXI5am3d0A8ApiZfeAnQ,22141 +wandb/vendor/pygments/lexers/rust.py,sha256=q18g2pHP_srVa8ANoyiIoMmXB4XkYI6Xp57rC-V9xmU,7695 +wandb/vendor/pygments/lexers/sas.py,sha256=oKP_7bIyKUnFS8kDGKsWxHqKhkRBV4emle28pX3MUzE,9449 +wandb/vendor/pygments/lexers/scripting.py,sha256=1_gD_-cQHrDF-uDEmBlelrUSWV5cQoz79EZ_3RpAh48,67761 +wandb/vendor/pygments/lexers/shell.py,sha256=H1byqbwQefCUaSDra6EabmI2o15zfpeusc73p1mBDQw,31426 +wandb/vendor/pygments/lexers/smalltalk.py,sha256=QJHVLNsCWr8zWHoF9C9Lev7LwefFYgI7L4mtY-LWJRU,7215 +wandb/vendor/pygments/lexers/smv.py,sha256=HnLzDk-zFDXhaHXxFI-ZINv6pW6stkk0IfxVHgStOLY,2802 +wandb/vendor/pygments/lexers/snobol.py,sha256=glC_g_14iKbHWaYCdkMibhGBNdPbzOgl7MVlJbpZMUI,2756 +wandb/vendor/pygments/lexers/special.py,sha256=Q1qXU0E8ecPXL_rMnzksLNbcisjOexxjXmo9j5ODBmM,3151 +wandb/vendor/pygments/lexers/sql.py,sha256=eMnkUuSpfII72c_lCcxOSWkuAuZH7qN6GkwM1xllMpA,29445 +wandb/vendor/pygments/lexers/stata.py,sha256=XI46JTQw-9YH5TkDB35FfFy8lJVaxr7qbdnOWbFhG3s,3627 +wandb/vendor/pygments/lexers/supercollider.py,sha256=t5LHZNcKwtgxnnCJnHCSYGjHBGXZzNR_TLF_pPOMrh4,3516 +wandb/vendor/pygments/lexers/tcl.py,sha256=ulsFqa6OwCKUoJHDvqBLdVHZL31EA5BDI8bf3iB703E,5398 +wandb/vendor/pygments/lexers/templates.py,sha256=V4ColLZh2NTkxI_zr4J7JnpRAafVNEezy3GWjq8knXs,73457 +wandb/vendor/pygments/lexers/testing.py,sha256=lup3FuiDthufXo3ujm6HSV4QKBscYoTpNe9K5iHCZ2g,10751 +wandb/vendor/pygments/lexers/text.py,sha256=7nKWCivruly7wyquaug3-IF8v2fUdXUVSYXHMVUlkdY,977 +wandb/vendor/pygments/lexers/textedit.py,sha256=1kH4uCnq4j80c0KGSMRJgzRgglm_5ckoiQVZX21qXvc,6057 +wandb/vendor/pygments/lexers/textfmts.py,sha256=sOQ4vDo5P1SpY_obS7N5oObolY501Tk2va69iDQyWWM,10852 +wandb/vendor/pygments/lexers/theorem.py,sha256=HmW981GDEA0TM8H7siEv2lszH-U9S7hcExRyom2eX2w,19034 +wandb/vendor/pygments/lexers/trafficscript.py,sha256=Xyfa407k2_rzvlKuExUcB5h6bC89WN6eQx6K3o3uV3o,1546 +wandb/vendor/pygments/lexers/typoscript.py,sha256=c6gOzNkvqgixbRKeQO7vXSrEPf6K4pnrFLFQ9SzusA8,8392 +wandb/vendor/pygments/lexers/urbi.py,sha256=p4gxSltIKKMFL8wJuLQ_cC40zSAC8bqc7aXZT0s5M7Y,5750 +wandb/vendor/pygments/lexers/varnish.py,sha256=5aSrhCfYFRbZsvKtQuKzJjHGCosabDGua3_LCG-JLlA,7265 +wandb/vendor/pygments/lexers/verification.py,sha256=Pb3upMUI03UFFsYAmqEzB2VK3N-ppMs1KYExE_tS1yE,3705 +wandb/vendor/pygments/lexers/web.py,sha256=5RB4JP962BUzuMIHon_H3tRgO458FAROJ91S8uk-gno,918 +wandb/vendor/pygments/lexers/webmisc.py,sha256=-6FzwUll5VU4oN6rSutfQmqPqD_OvWZ7kZWO1H3WMXo,39891 +wandb/vendor/pygments/lexers/whiley.py,sha256=YNCb-hXy8rPPVH9ea4q8QAXqncXNPHtgqAqAKPLfHfM,4012 +wandb/vendor/pygments/lexers/x10.py,sha256=FyCneMc5r_PRL7a0iaAsvgfyrxk2dYSzE9WJa1O4ZBw,1965 +wandb/vendor/pygments/modeline.py,sha256=83v6_3Zo9RHEc0K8aepm1Sc8Iou7mRcwogl9MLUciiI,1010 +wandb/vendor/pygments/plugin.py,sha256=NFKzfoPXMA8x6yXqMVbM0k1YKHHeQIwnDEvVlxd-MEQ,1721 +wandb/vendor/pygments/regexopt.py,sha256=t8y9hRPYQKJysZQhWd_t15aqRAGJSk0ABynKyjmogIQ,3094 +wandb/vendor/pygments/scanner.py,sha256=Mf-ya9riFJ85N3AiGKvBUsAsjSEfTd0Bqw8KMxhj2ew,3123 +wandb/vendor/pygments/sphinxext.py,sha256=1nig8VbRlfIDZd1fhOKQmX2KcxyQoexwsOdX3DSGE1I,4655 +wandb/vendor/pygments/style.py,sha256=R-iSqMPqnMtciPTgPMvqNjUkWtg7CCQTpyyCBSAOv_g,4807 +wandb/vendor/pygments/styles/__init__.py,sha256=bMJA5A-As-KqVlgOVa1ryoivG-fI20nE5mlEvneFqT0,2553 +wandb/vendor/pygments/styles/__pycache__/__init__.cpython-38.pyc,, +wandb/vendor/pygments/styles/__pycache__/abap.cpython-38.pyc,, +wandb/vendor/pygments/styles/__pycache__/algol.cpython-38.pyc,, +wandb/vendor/pygments/styles/__pycache__/algol_nu.cpython-38.pyc,, +wandb/vendor/pygments/styles/__pycache__/arduino.cpython-38.pyc,, +wandb/vendor/pygments/styles/__pycache__/autumn.cpython-38.pyc,, +wandb/vendor/pygments/styles/__pycache__/borland.cpython-38.pyc,, +wandb/vendor/pygments/styles/__pycache__/bw.cpython-38.pyc,, +wandb/vendor/pygments/styles/__pycache__/colorful.cpython-38.pyc,, +wandb/vendor/pygments/styles/__pycache__/default.cpython-38.pyc,, +wandb/vendor/pygments/styles/__pycache__/emacs.cpython-38.pyc,, +wandb/vendor/pygments/styles/__pycache__/friendly.cpython-38.pyc,, +wandb/vendor/pygments/styles/__pycache__/fruity.cpython-38.pyc,, +wandb/vendor/pygments/styles/__pycache__/igor.cpython-38.pyc,, +wandb/vendor/pygments/styles/__pycache__/lovelace.cpython-38.pyc,, +wandb/vendor/pygments/styles/__pycache__/manni.cpython-38.pyc,, +wandb/vendor/pygments/styles/__pycache__/monokai.cpython-38.pyc,, +wandb/vendor/pygments/styles/__pycache__/murphy.cpython-38.pyc,, +wandb/vendor/pygments/styles/__pycache__/native.cpython-38.pyc,, +wandb/vendor/pygments/styles/__pycache__/paraiso_dark.cpython-38.pyc,, +wandb/vendor/pygments/styles/__pycache__/paraiso_light.cpython-38.pyc,, +wandb/vendor/pygments/styles/__pycache__/pastie.cpython-38.pyc,, +wandb/vendor/pygments/styles/__pycache__/perldoc.cpython-38.pyc,, +wandb/vendor/pygments/styles/__pycache__/rainbow_dash.cpython-38.pyc,, +wandb/vendor/pygments/styles/__pycache__/rrt.cpython-38.pyc,, +wandb/vendor/pygments/styles/__pycache__/sas.cpython-38.pyc,, +wandb/vendor/pygments/styles/__pycache__/stata.cpython-38.pyc,, +wandb/vendor/pygments/styles/__pycache__/tango.cpython-38.pyc,, +wandb/vendor/pygments/styles/__pycache__/trac.cpython-38.pyc,, +wandb/vendor/pygments/styles/__pycache__/vim.cpython-38.pyc,, +wandb/vendor/pygments/styles/__pycache__/vs.cpython-38.pyc,, +wandb/vendor/pygments/styles/__pycache__/xcode.cpython-38.pyc,, +wandb/vendor/pygments/styles/abap.py,sha256=GYW80_C20vlhROQCE9RIn8oOy0uFO5VeJJMm7FXCEz8,751 +wandb/vendor/pygments/styles/algol.py,sha256=mE09x_hUp-ferskH8OLAWO115u9GQQYMR70Y-2zS6Y0,2263 +wandb/vendor/pygments/styles/algol_nu.py,sha256=psY0F47Bl5LThIeih15ghZvkalijyq6jrUnx84n_TFg,2278 +wandb/vendor/pygments/styles/arduino.py,sha256=UTcdXehOhcXWda9NlYeW3piKZUbEpQQkx0ARZCC7Ih4,4492 +wandb/vendor/pygments/styles/autumn.py,sha256=FpFEPsPBnGugtBp4M-3FqKPbKlGomYAbq9HSNiYh3DU,2144 +wandb/vendor/pygments/styles/borland.py,sha256=QhOMFrDL3PAwEJZkuEt9qzPN8T8cVooRG5vtLROgkRc,1562 +wandb/vendor/pygments/styles/bw.py,sha256=vBQMjQhou4csJMHTIE5AJCeLESFaE5UqgSPN2ZAli6o,1355 +wandb/vendor/pygments/styles/colorful.py,sha256=SWzWtEmeEoZ7DNIh6XQeZxDz6bIOlgBuwGFePB2PUmc,2778 +wandb/vendor/pygments/styles/default.py,sha256=UUN6VGAOB12b_R2ky-6cHfdaXE34xJaNtaHwsBzl1I8,2532 +wandb/vendor/pygments/styles/emacs.py,sha256=CndsC1mEd6GGVCFA1uKmb5rMqjMiMCqJ1uBE2fgKCQA,2486 +wandb/vendor/pygments/styles/friendly.py,sha256=0c5ibD9ldewtsKzgjHSV2-FN_iRdDa_bUkVWi8ZnfdE,2515 +wandb/vendor/pygments/styles/fruity.py,sha256=cSYED092upFc4kekb2m-f34Wh4BWxXyEb8N6rYLZOas,1298 +wandb/vendor/pygments/styles/igor.py,sha256=MZNAVwgWh5FU2bRbKaXo5uV9_h2IH3gh4Cm3MspnFIc,739 +wandb/vendor/pygments/styles/lovelace.py,sha256=u0fQW4OUZ37w9Z1A0pzsMYfJX68kxMrp0CbjWJg46pE,3173 +wandb/vendor/pygments/styles/manni.py,sha256=2CC4G2o6hUYfCceP4O9bpNBgNONW7HCJ--L3khD7jhc,2374 +wandb/vendor/pygments/styles/monokai.py,sha256=QgSUuhv6DDz7LhyfL9lW5VMIRJIj0ID_GqTJupunWgs,5080 +wandb/vendor/pygments/styles/murphy.py,sha256=m2bWPIFW8gnR2miA6FF2kYDwXT2sltSJ9MMcA1AEnqg,2751 +wandb/vendor/pygments/styles/native.py,sha256=V_mDvPG5eUm8V2XSCYsKsqkp0XfxK8gn80wryiUmmIU,1938 +wandb/vendor/pygments/styles/paraiso_dark.py,sha256=YxdADs3KBND4ZXfYqkQBXGxIs2y4VxjaiKw8f3AdoFo,5641 +wandb/vendor/pygments/styles/paraiso_light.py,sha256=-HHuYHnJBX7Yehza875DjU4ly95ATC1sh6o_RuqbeuI,5645 +wandb/vendor/pygments/styles/pastie.py,sha256=6ku_vX2aFP7N9iAsT8a-1lzf9L1DR_j0SE37HVbFoSw,2473 +wandb/vendor/pygments/styles/perldoc.py,sha256=CJq6FzNG22C3aru3QO2_l6ebksqnAQhSBLeiYYoJjhw,2175 +wandb/vendor/pygments/styles/rainbow_dash.py,sha256=mPI5Yfl-sRW9Aig_xvs63i3sjWqO5fpihBbiaLozyYM,2480 +wandb/vendor/pygments/styles/rrt.py,sha256=-UUYhzna_sPcmwUXEtnDoAaUD8cnomk8grWfKOsmJ-M,852 +wandb/vendor/pygments/styles/sas.py,sha256=yKgZ8AiADLXtVZLZ0JtxlB6BGJAVkcX0DyG8g-R8nSE,1441 +wandb/vendor/pygments/styles/stata.py,sha256=PH8ckY6Q68QQXjv8wDK_Z-DVbyiWfy5vRLd4HUYd02k,1249 +wandb/vendor/pygments/styles/tango.py,sha256=Bsn6unVhwiOJ8dc1-csQYHanRjIZ7JOxQndq6Dc-BxE,7096 +wandb/vendor/pygments/styles/trac.py,sha256=XlcVcvSqIfVeqSsQo34V5B0VLi_FQwlpfaE0Zv7LE0M,1933 +wandb/vendor/pygments/styles/vim.py,sha256=hgv2HvW3kriTmj0HE7TdzeJhJhxvblqEG-S3ELiZEX4,1976 +wandb/vendor/pygments/styles/vs.py,sha256=X7jUKNoKNnNE6ewe9vsGgTeSxK4a7x8oBbaA6LNzpGQ,1073 +wandb/vendor/pygments/styles/xcode.py,sha256=gWl7xboxgvDzARO8-VmBfUX0GOnWWbGU9Su_TAIyEFQ,1501 +wandb/vendor/pygments/token.py,sha256=qowb6oBuyzaRfTyUe7F-LeMcNwRNLEiwjZl9o3ggsxc,6167 +wandb/vendor/pygments/unistring.py,sha256=rkFlgo6QzdUFWQ-uiOaz6MFfQg1f0-hH_B5F3PFXwXA,51150 +wandb/vendor/pygments/util.py,sha256=xO8RGLd_-7DoXCL799lWYgyub4whP2pSmnIsx1-wMyA,11900 +wandb/vendor/pynvml/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0 +wandb/vendor/pynvml/__pycache__/__init__.cpython-38.pyc,, +wandb/vendor/pynvml/__pycache__/pynvml.cpython-38.pyc,, +wandb/vendor/pynvml/pynvml.py,sha256=dKPakQ9psXpTy0N-j6yBetcWGPlQQW7MceKih0YjAeU,57388 +wandb/vendor/watchdog/__init__.py,sha256=-eu2NcfsKwZHudYM1DwZob-gagx9DhVVvJOvmIGWo8o,684 +wandb/vendor/watchdog/__pycache__/__init__.cpython-38.pyc,, +wandb/vendor/watchdog/__pycache__/events.cpython-38.pyc,, +wandb/vendor/watchdog/__pycache__/version.cpython-38.pyc,, +wandb/vendor/watchdog/__pycache__/watchmedo.cpython-38.pyc,, +wandb/vendor/watchdog/events.py,sha256=MihpHPaBE-l8UsCsl8xDZt5QECqhamA84mifmc7Ncco,18620 +wandb/vendor/watchdog/observers/__init__.py,sha256=Bsw_DuebZoPOR8dL-YyawCOTb0ULtsSBvzEXCo1QE-o,3852 +wandb/vendor/watchdog/observers/__pycache__/__init__.cpython-38.pyc,, +wandb/vendor/watchdog/observers/__pycache__/api.cpython-38.pyc,, +wandb/vendor/watchdog/observers/__pycache__/fsevents.cpython-38.pyc,, +wandb/vendor/watchdog/observers/__pycache__/fsevents2.cpython-38.pyc,, +wandb/vendor/watchdog/observers/__pycache__/inotify.cpython-38.pyc,, +wandb/vendor/watchdog/observers/__pycache__/inotify_buffer.cpython-38.pyc,, +wandb/vendor/watchdog/observers/__pycache__/inotify_c.cpython-38.pyc,, +wandb/vendor/watchdog/observers/__pycache__/kqueue.cpython-38.pyc,, +wandb/vendor/watchdog/observers/__pycache__/polling.cpython-38.pyc,, +wandb/vendor/watchdog/observers/__pycache__/read_directory_changes.cpython-38.pyc,, +wandb/vendor/watchdog/observers/__pycache__/winapi.cpython-38.pyc,, +wandb/vendor/watchdog/observers/api.py,sha256=AG43oQDN6-3rTYsjJv6vgxREXb2xG3Svjx2ZOy4V-Jk,11720 +wandb/vendor/watchdog/observers/fsevents.py,sha256=vt_eyA3G2R5D6R4A52D2ijOPxLYvfZxtbiKGf7Rv24k,6528 +wandb/vendor/watchdog/observers/fsevents2.py,sha256=UNuX_939yrmSKNQvJ-kKkQzKkMVOhaT9OHLmMLkd6s8,9025 +wandb/vendor/watchdog/observers/inotify.py,sha256=MjaaT7X-wxx6FFlqhfvoFu4uUeo8DgF7pFpPd8CkKoI,8528 +wandb/vendor/watchdog/observers/inotify_buffer.py,sha256=yW9FkfyL6GIvVF8loWRIoH6oQwKp0bFpu_k92xGLpEQ,3037 +wandb/vendor/watchdog/observers/inotify_c.py,sha256=9dtRNMjxUXxEOMONfXsFyUMy_4ORlxSa6C6soAUADb8,18899 +wandb/vendor/watchdog/observers/kqueue.py,sha256=Cts9-_dEyb9ZnHe6nu24RW3tmqZ7PphjIQWCzmtqig0,25300 +wandb/vendor/watchdog/observers/polling.py,sha256=o5RvBLOsAwaAIwRIm1otfT9PL385zNmz0dsFaxvh8Cs,4851 +wandb/vendor/watchdog/observers/read_directory_changes.py,sha256=veZehw9of0AdxMqiMlyicSfspGeAhqW9Klfapb9wINs,5244 +wandb/vendor/watchdog/observers/winapi.py,sha256=tLVNqoS-wkMsdUNkYrqsv6YWvqdPBpUAYBoOwTAxUzM,11693 +wandb/vendor/watchdog/tricks/__init__.py,sha256=m75MLiC4MgnSXlfk0vD91jr5U2bEj7eWo-0TMif1zps,5186 +wandb/vendor/watchdog/tricks/__pycache__/__init__.cpython-38.pyc,, +wandb/vendor/watchdog/utils/__init__.py,sha256=aYtJ9ImvKmwdqvNjbtGQUR7Qc_SsvabfJnLLngIEHlM,4460 +wandb/vendor/watchdog/utils/__pycache__/__init__.cpython-38.pyc,, +wandb/vendor/watchdog/utils/__pycache__/bricks.cpython-38.pyc,, +wandb/vendor/watchdog/utils/__pycache__/compat.cpython-38.pyc,, +wandb/vendor/watchdog/utils/__pycache__/decorators.cpython-38.pyc,, +wandb/vendor/watchdog/utils/__pycache__/delayed_queue.cpython-38.pyc,, +wandb/vendor/watchdog/utils/__pycache__/dirsnapshot.cpython-38.pyc,, +wandb/vendor/watchdog/utils/__pycache__/echo.cpython-38.pyc,, +wandb/vendor/watchdog/utils/__pycache__/event_backport.cpython-38.pyc,, +wandb/vendor/watchdog/utils/__pycache__/importlib2.cpython-38.pyc,, +wandb/vendor/watchdog/utils/__pycache__/platform.cpython-38.pyc,, +wandb/vendor/watchdog/utils/__pycache__/unicode_paths.cpython-38.pyc,, +wandb/vendor/watchdog/utils/__pycache__/win32stat.cpython-38.pyc,, +wandb/vendor/watchdog/utils/bricks.py,sha256=o3gFLBXeoQJSoJJqVz5NGhLyuZaRIqqcs7jY23YnEsg,7558 +wandb/vendor/watchdog/utils/compat.py,sha256=ezeJrD0LTvg2arGGWhQ0oq4CB31Hqi2FvJoJbDgX7No,860 +wandb/vendor/watchdog/utils/decorators.py,sha256=MkJQIlK9L3FD62_mzr-zlgJMQG6bey8C06xUxWkKucQ,4451 +wandb/vendor/watchdog/utils/delayed_queue.py,sha256=Q0Eylpvc-9wuKmvVcgk1dvm8GKJvif7zdLdk58P17aI,2926 +wandb/vendor/watchdog/utils/dirsnapshot.py,sha256=zQiINd21cl1b8Z5u-8W5466UNJ8jo1JgfmHdOPmRITc,9313 +wandb/vendor/watchdog/utils/echo.py,sha256=frPR2B1ZOvNue66V1WfzDjjX-fnv5_xYw36hQT6tuU4,5305 +wandb/vendor/watchdog/utils/event_backport.py,sha256=vnOWu6nNdSJJo69VSxeCfnfsXOo4CwTQDlMr6jAa6eI,902 +wandb/vendor/watchdog/utils/importlib2.py,sha256=cJIaJ2EQsoA8eWZ3d8hvgXq3OUxoRDdD5jo9XbUMRMI,1840 +wandb/vendor/watchdog/utils/platform.py,sha256=UORYTNVcUSE2NpFcq9UVLIS-tsS0TS_Qw8akhKxn2eY,1506 +wandb/vendor/watchdog/utils/unicode_paths.py,sha256=COKxLPWugflfTYrBGP1UzKp5mmSARLQ0U-ruwwZVmt4,2184 +wandb/vendor/watchdog/utils/win32stat.py,sha256=v2leeFe7bFo90DxhXljj4JU3MiAZ1Fa4O0pqVnAliqk,3832 +wandb/vendor/watchdog/version.py,sha256=GAUJcx7KVSbKa25fjKipygYc9zPtEPDDDcwlUpKfgmI,974 +wandb/vendor/watchdog/watchmedo.py,sha256=5TddCcneRN8X6drXiLEpmSjNyscFI_8WtAN28BFvBP8,17446 +wandb/viz.py,sha256=mG6rBSbK87FfxCgOKOoUGhla99Q1Vg8HwjbmvRkngTE,3202 +wandb/wandb_agent.py,sha256=OcZWxkfFtTsIDM_RcmpYDdYtYTRt5KNGAGlE_AVtcmQ,21723 +wandb/wandb_controller.py,sha256=g-xnbbPUXBb2EJ064IeCrtmOqkXa-SatoRBMiUbCX6E,24728 +wandb/wandb_run.py,sha256=RgMJZI9ZZ9uyf7ILsWbpuTIM8BIgnOIJA4bpbsF2SC4,156 +wandb/wandb_torch.py,sha256=ThX4XNUJrRel1aGA_Ejp4etMat-00_qsZVbj-Nd3rxY,21178 +wandb/xgboost/__init__.py,sha256=WDe1SW6iZwKMd-PXQZDUO_nhTUrnP7u5uw_JPJV3HZY,231 +wandb/xgboost/__pycache__/__init__.cpython-38.pyc,, diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/wandb-0.12.21.dist-info/REQUESTED b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/wandb-0.12.21.dist-info/REQUESTED new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/wandb-0.12.21.dist-info/WHEEL b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/wandb-0.12.21.dist-info/WHEEL new file mode 100644 index 0000000000000000000000000000000000000000..0b18a281107a0448a9980396d9d324ea2aa7a7f8 --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/wandb-0.12.21.dist-info/WHEEL @@ -0,0 +1,6 @@ +Wheel-Version: 1.0 +Generator: bdist_wheel (0.37.1) +Root-Is-Purelib: true +Tag: py2-none-any +Tag: py3-none-any + diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/wandb-0.12.21.dist-info/entry_points.txt b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/wandb-0.12.21.dist-info/entry_points.txt new file mode 100644 index 0000000000000000000000000000000000000000..bd9806f6b8b58b8ad6081627328a817c45942064 --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/wandb-0.12.21.dist-info/entry_points.txt @@ -0,0 +1,3 @@ +[console_scripts] +wandb = wandb.cli.cli:cli +wb = wandb.cli.cli:cli diff --git a/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/wandb-0.12.21.dist-info/top_level.txt b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/wandb-0.12.21.dist-info/top_level.txt new file mode 100644 index 0000000000000000000000000000000000000000..fff96000043b28d1317880a291a5463e49b9b720 --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/wandb-0.12.21.dist-info/top_level.txt @@ -0,0 +1 @@ +wandb diff --git a/my_container_sandbox/workspace/anaconda3/pkgs/brotlipy-0.7.0-py39h27cfd23_1003.conda b/my_container_sandbox/workspace/anaconda3/pkgs/brotlipy-0.7.0-py39h27cfd23_1003.conda new file mode 100644 index 0000000000000000000000000000000000000000..32a81919709ab0d2ca94ab3a86056e65dfd11f7f --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/pkgs/brotlipy-0.7.0-py39h27cfd23_1003.conda @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:17420d4eea48a3e89aa260c9233ba96815ea40d07702d7554b27f30f3ecdc2fb +size 331770 diff --git a/my_container_sandbox/workspace/anaconda3/pkgs/certifi-2024.2.2-pyhd8ed1ab_0.conda b/my_container_sandbox/workspace/anaconda3/pkgs/certifi-2024.2.2-pyhd8ed1ab_0.conda new file mode 100644 index 0000000000000000000000000000000000000000..f0dfe7e53af22b117a28119141b03480352e5f89 --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/pkgs/certifi-2024.2.2-pyhd8ed1ab_0.conda @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f1faca020f988696e6b6ee47c82524c7806380b37cfdd1def32f92c326caca54 +size 160559 diff --git a/my_container_sandbox/workspace/anaconda3/pkgs/sqlite-3.41.2-h5eee18b_0.conda b/my_container_sandbox/workspace/anaconda3/pkgs/sqlite-3.41.2-h5eee18b_0.conda new file mode 100644 index 0000000000000000000000000000000000000000..ffeb17c94d02d7c74e216bbda6a92a848840f209 --- /dev/null +++ b/my_container_sandbox/workspace/anaconda3/pkgs/sqlite-3.41.2-h5eee18b_0.conda @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b74eff1c483cb5e308ac499e5f1a29cfe70aa6e4a502470c650708106da5453a +size 1229749 diff --git a/tmp_inputs_32_25/case00003.nii.gz b/tmp_inputs_32_25/case00003.nii.gz new file mode 100644 index 0000000000000000000000000000000000000000..15d237a2210ce42b4c7c17ca26807d6f75bee22f --- /dev/null +++ b/tmp_inputs_32_25/case00003.nii.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:0d695394075a89a9c40c6808e54d0b454b0896565f9b5b65ea810a03024c5807 +size 31725489 diff --git a/tmp_inputs_32_8/case00006.nii.gz b/tmp_inputs_32_8/case00006.nii.gz new file mode 100644 index 0000000000000000000000000000000000000000..b5707123f4cf68e32ed68a478a5413c7370fb3dc --- /dev/null +++ b/tmp_inputs_32_8/case00006.nii.gz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:92145fecfe0010d5f85aea24ca83d29f7e353431b7e30a09d979e797261cf4af +size 37987631