Add files using upload-large-folder tool

.gitattributes

@@ -202,3 +202,7 @@ my_container_sandbox/workspace/anaconda3/pkgs/pip-24.0-pyhd8ed1ab_0.conda filter
 my_container_sandbox/workspace/anaconda3/pkgs/conda-package-handling-1.7.3-py39h27cfd23_1.conda filter=lfs diff=lfs merge=lfs -text
 my_container_sandbox/workspace/anaconda3/lib/python3.8/__pycache__/_pydecimal.cpython-38.pyc filter=lfs diff=lfs merge=lfs -text
 my_container_sandbox/workspace/anaconda3/lib/itcl4.2.2/libitcl4.2.2.so filter=lfs diff=lfs merge=lfs -text
+my_container_sandbox/workspace/anaconda3/lib/tk8.6/demos/images/teapot.ppm filter=lfs diff=lfs merge=lfs -text
+my_container_sandbox/workspace/anaconda3/lib/python3.8/__pycache__/turtle.cpython-38.pyc filter=lfs diff=lfs merge=lfs -text
+my_container_sandbox/workspace/anaconda3/lib/python3.8/lib-dynload/_codecs_tw.cpython-38-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+my_container_sandbox/workspace/anaconda3/lib/python3.8/lib-dynload/_hashlib.cpython-38-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text

my_container_sandbox/workspace/anaconda3/lib/python3.8/__pycache__/turtle.cpython-38.pyc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a30f9c746e7da6afd15f2be270fd357970e5b7656190f73e6010912b7edd1f52
+size 130017

my_container_sandbox/workspace/anaconda3/lib/python3.8/lib-dynload/_codecs_tw.cpython-38-x86_64-linux-gnu.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1027d0872cc277ee517b0c33d7ec1b558efbed103bc6353e02aa2ff1ab2e31ba
+size 139888

my_container_sandbox/workspace/anaconda3/lib/python3.8/lib-dynload/_hashlib.cpython-38-x86_64-linux-gnu.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e7da966d0029e722191836daf8ffb8166d406e0b038ca01a746658c21a015afb
+size 138464

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

@@ -0,0 +1 @@
+4.14.0

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

@@ -0,0 +1,149 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2012 Anaconda, Inc
+# SPDX-License-Identifier: BSD-3-Clause
+"""OS-agnostic, system-level binary package manager."""
+from __future__ import absolute_import, division, print_function, unicode_literals
+
+import os
+from os.path import abspath, dirname
+import sys
+import warnings
+
+from json import JSONEncoder
+
+
+
+__all__ = (
+    "__name__", "__version__", "__author__", "__email__", "__license__", "__summary__", "__url__",
+    "CONDA_PACKAGE_ROOT", "CondaError", "CondaMultiError", "CondaExitZero", "conda_signal_handler",
+    "__copyright__",
+)
+
+__name__ = "conda"
+__version__ = "4.14.0"
+__author__ = "Anaconda, Inc."
+__email__ = "conda@continuum.io"
+__license__ = "BSD-3-Clause"
+__copyright__ = "Copyright (c) 2012, Anaconda, Inc."
+__summary__ = __doc__
+__url__ = "https://github.com/conda/conda"
+
+if os.getenv('CONDA_ROOT') is None:
+    os.environ[str('CONDA_ROOT')] = sys.prefix
+
+#: The conda package directory.
+CONDA_PACKAGE_ROOT = abspath(dirname(__file__))
+#: The path within which to find the conda package.
+#:
+#: If `conda` is statically installed this is the site-packages. If `conda` is an editable install
+#: or otherwise uninstalled this is the git repo.
+CONDA_SOURCE_ROOT = dirname(CONDA_PACKAGE_ROOT)
+
+def another_to_unicode(val):
+    warnings.warn(
+        "`conda.another_to_unicode` is pending deprecation and will be removed in a "
+        "future release.",
+        PendingDeprecationWarning,
+    )
+    # ignore flake8 on this because it finds this as an error on py3 even though it is guarded
+    if isinstance(val, basestring) and not isinstance(val, unicode):  # NOQA
+        return unicode(val, encoding='utf-8')  # NOQA
+    return val
+
+class CondaError(Exception):
+    return_code = 1
+    reportable = False  # Exception may be reported to core maintainers
+
+    def __init__(self, message, caused_by=None, **kwargs):
+        self.message = message
+        self._kwargs = kwargs
+        self._caused_by = caused_by
+        super(CondaError, self).__init__(message)
+
+    def __repr__(self):
+        return '%s: %s' % (self.__class__.__name__, str(self))
+
+    def __str__(self):
+        try:
+            return str(self.message % self._kwargs)
+        except Exception:
+            debug_message = "\n".join((
+                "class: " + self.__class__.__name__,
+                "message:",
+                self.message,
+                "kwargs:",
+                str(self._kwargs),
+                "",
+            ))
+            print(debug_message, file=sys.stderr)
+            raise
+
+    def dump_map(self):
+        result = dict((k, v) for k, v in vars(self).items() if not k.startswith('_'))
+        result.update(exception_type=str(type(self)),
+                      exception_name=self.__class__.__name__,
+                      message=str(self),
+                      error=repr(self),
+                      caused_by=repr(self._caused_by),
+                      **self._kwargs)
+        return result
+
+
+class CondaMultiError(CondaError):
+
+    def __init__(self, errors):
+        self.errors = errors
+        super(CondaMultiError, self).__init__(None)
+
+    def __repr__(self):
+        errs = []
+        for e in self.errors:
+            if isinstance(e, EnvironmentError) and not isinstance(e, CondaError):
+                errs.append(str(e))
+            else:
+                # We avoid Python casting this back to a str()
+                # by using e.__repr__() instead of repr(e)
+                # https://github.com/scrapy/cssselect/issues/34
+                errs.append(e.__repr__())
+        res = '\n'.join(errs)
+        return res
+
+    def __str__(self):
+        return str('\n').join(str(e) for e in self.errors) + str('\n')
+
+    def dump_map(self):
+        return dict(exception_type=str(type(self)),
+                    exception_name=self.__class__.__name__,
+                    errors=tuple(error.dump_map() for error in self.errors),
+                    error="Multiple Errors Encountered.",
+                    )
+
+    def contains(self, exception_class):
+        return any(isinstance(e, exception_class) for e in self.errors)
+
+
+class CondaExitZero(CondaError):
+    return_code = 0
+
+
+ACTIVE_SUBPROCESSES = set()
+
+
+def conda_signal_handler(signum, frame):
+    # This function is in the base __init__.py so that it can be monkey-patched by other code
+    #   if downstream conda users so choose.  The biggest danger of monkey-patching is that
+    #   unlink/link transactions don't get rolled back if interrupted mid-transaction.
+    for p in ACTIVE_SUBPROCESSES:
+        if p.poll() is None:
+            p.send_signal(signum)
+
+    from .exceptions import CondaSignalInterrupt
+    raise CondaSignalInterrupt(signum)
+
+
+def _default(self, obj):
+    return getattr(obj.__class__, "to_json", _default.default)(obj)
+
+
+_default.default = JSONEncoder().default
+JSONEncoder.default = _default

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

@@ -0,0 +1,8 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2012 Anaconda, Inc
+# SPDX-License-Identifier: BSD-3-Clause
+import sys
+
+from .cli import main
+
+sys.exit(main())

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

@@ -0,0 +1,461 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2012 Anaconda, Inc
+# SPDX-License-Identifier: BSD-3-Clause
+from __future__ import absolute_import, division, print_function, unicode_literals
+
+from .base.constants import DepsModifier as _DepsModifier, UpdateModifier as _UpdateModifier
+from .common.constants import NULL
+from .core.package_cache_data import PackageCacheData as _PackageCacheData
+from .core.prefix_data import PrefixData as _PrefixData
+from .core.solve import _get_solver_class
+from .core.subdir_data import SubdirData as _SubdirData
+from .models.channel import Channel
+
+DepsModifier = _DepsModifier
+"""Flags to enable alternate handling of dependencies."""
+
+UpdateModifier = _UpdateModifier
+"""Flags to enable alternate handling for updates of existing packages in the environment."""
+
+
+class Solver(object):
+    """
+    **Beta** While in beta, expect both major and minor changes across minor releases.
+
+    A high-level API to conda's solving logic. Three public methods are provided to access a
+    solution in various forms.
+
+      * :meth:`solve_final_state`
+      * :meth:`solve_for_diff`
+      * :meth:`solve_for_transaction`
+
+    """
+
+    def __init__(self, prefix, channels, subdirs=(), specs_to_add=(), specs_to_remove=()):
+        """
+        **Beta**
+
+        Args:
+            prefix (str):
+                The conda prefix / environment location for which the :class:`Solver`
+                is being instantiated.
+            channels (Sequence[:class:`Channel`]):
+                A prioritized list of channels to use for the solution.
+            subdirs (Sequence[str]):
+                A prioritized list of subdirs to use for the solution.
+            specs_to_add (Set[:class:`MatchSpec`]):
+                The set of package specs to add to the prefix.
+            specs_to_remove (Set[:class:`MatchSpec`]):
+                The set of package specs to remove from the prefix.
+
+        """
+        SolverType = _get_solver_class()
+        self._internal = SolverType(prefix, channels, subdirs, specs_to_add, specs_to_remove)
+
+    def solve_final_state(self, update_modifier=NULL, deps_modifier=NULL, prune=NULL,
+                          ignore_pinned=NULL, force_remove=NULL):
+        """
+        **Beta** While in beta, expect both major and minor changes across minor releases.
+
+        Gives the final, solved state of the environment.
+
+        Args:
+            deps_modifier (DepsModifier):
+                An optional flag indicating special solver handling for dependencies. The
+                default solver behavior is to be as conservative as possible with dependency
+                updates (in the case the dependency already exists in the environment), while
+                still ensuring all dependencies are satisfied.  Options include
+                * NO_DEPS
+                * ONLY_DEPS
+                * UPDATE_DEPS
+                * UPDATE_DEPS_ONLY_DEPS
+                * FREEZE_INSTALLED
+            prune (bool):
+                If ``True``, the solution will not contain packages that were
+                previously brought into the environment as dependencies but are no longer
+                required as dependencies and are not user-requested.
+            ignore_pinned (bool):
+                If ``True``, the solution will ignore pinned package configuration
+                for the prefix.
+            force_remove (bool):
+                Forces removal of a package without removing packages that depend on it.
+
+        Returns:
+            Tuple[PackageRef]:
+                In sorted dependency order from roots to leaves, the package references for
+                the solved state of the environment.
+
+        """
+        return self._internal.solve_final_state(update_modifier, deps_modifier, prune,
+                                                ignore_pinned, force_remove)
+
+    def solve_for_diff(self, update_modifier=NULL, deps_modifier=NULL, prune=NULL,
+                       ignore_pinned=NULL, force_remove=NULL, force_reinstall=False):
+        """
+        **Beta** While in beta, expect both major and minor changes across minor releases.
+
+        Gives the package references to remove from an environment, followed by
+        the package references to add to an environment.
+
+        Args:
+            deps_modifier (DepsModifier):
+                See :meth:`solve_final_state`.
+            prune (bool):
+                See :meth:`solve_final_state`.
+            ignore_pinned (bool):
+                See :meth:`solve_final_state`.
+            force_remove (bool):
+                See :meth:`solve_final_state`.
+            force_reinstall (bool):
+                For requested specs_to_add that are already satisfied in the environment,
+                instructs the solver to remove the package and spec from the environment,
+                and then add it back--possibly with the exact package instance modified,
+                depending on the spec exactness.
+
+        Returns:
+            Tuple[PackageRef], Tuple[PackageRef]:
+                A two-tuple of PackageRef sequences.  The first is the group of packages to
+                remove from the environment, in sorted dependency order from leaves to roots.
+                The second is the group of packages to add to the environment, in sorted
+                dependency order from roots to leaves.
+
+        """
+        return self._internal.solve_for_diff(update_modifier, deps_modifier, prune, ignore_pinned,
+                                             force_remove, force_reinstall)
+
+    def solve_for_transaction(self, update_modifier=NULL, deps_modifier=NULL, prune=NULL,
+                              ignore_pinned=NULL, force_remove=NULL, force_reinstall=False):
+        """
+        **Beta** While in beta, expect both major and minor changes across minor releases.
+
+        Gives an UnlinkLinkTransaction instance that can be used to execute the solution
+        on an environment.
+
+        Args:
+            deps_modifier (DepsModifier):
+                See :meth:`solve_final_state`.
+            prune (bool):
+                See :meth:`solve_final_state`.
+            ignore_pinned (bool):
+                See :meth:`solve_final_state`.
+            force_remove (bool):
+                See :meth:`solve_final_state`.
+            force_reinstall (bool):
+                See :meth:`solve_for_diff`.
+
+        Returns:
+            UnlinkLinkTransaction:
+
+        """
+        return self._internal.solve_for_transaction(update_modifier, deps_modifier, prune,
+                                                    ignore_pinned, force_remove, force_reinstall)
+
+
+class SubdirData(object):
+    """
+    **Beta** While in beta, expect both major and minor changes across minor releases.
+
+    High-level management and usage of repodata.json for subdirs.
+    """
+
+    def __init__(self, channel):
+        """
+        **Beta** While in beta, expect both major and minor changes across minor releases.
+
+        Args:
+            channel (str or Channel):
+                The target subdir for the instance. Must either be a url that includes a subdir
+                or a :obj:`Channel` that includes a subdir. e.g.:
+                    * 'https://repo.anaconda.com/pkgs/main/linux-64'
+                    * Channel('https://repo.anaconda.com/pkgs/main/linux-64')
+                    * Channel('conda-forge/osx-64')
+        """
+        channel = Channel(channel)
+        assert channel.subdir
+        self._internal = _SubdirData(channel)
+
+    def query(self, package_ref_or_match_spec):
+        """
+        **Beta** While in beta, expect both major and minor changes across minor releases.
+
+        Run a query against this specific instance of repodata.
+
+        Args:
+            package_ref_or_match_spec (PackageRef or MatchSpec or str):
+                Either an exact :obj:`PackageRef` to match against, or a :obj:`MatchSpec`
+                query object.  A :obj:`str` will be turned into a :obj:`MatchSpec` automatically.
+
+        Returns:
+            Tuple[PackageRecord]
+
+        """
+        return tuple(self._internal.query(package_ref_or_match_spec))
+
+    @staticmethod
+    def query_all(package_ref_or_match_spec, channels=None, subdirs=None):
+        """
+        **Beta** While in beta, expect both major and minor changes across minor releases.
+
+        Run a query against all repodata instances in channel/subdir matrix.
+
+        Args:
+            package_ref_or_match_spec (PackageRef or MatchSpec or str):
+                Either an exact :obj:`PackageRef` to match against, or a :obj:`MatchSpec`
+                query object.  A :obj:`str` will be turned into a :obj:`MatchSpec` automatically.
+            channels (Iterable[Channel or str] or None):
+                An iterable of urls for channels or :obj:`Channel` objects. If None, will fall
+                back to context.channels.
+            subdirs (Iterable[str] or None):
+                If None, will fall back to context.subdirs.
+
+        Returns:
+            Tuple[PackageRecord]
+
+        """
+        return tuple(_SubdirData.query_all(package_ref_or_match_spec, channels, subdirs))
+
+    def iter_records(self):
+        """
+        **Beta** While in beta, expect both major and minor changes across minor releases.
+
+        Returns:
+            Iterable[PackageRecord]: A generator over all records contained in the repodata.json
+                instance.  Warning: this is a generator that is exhausted on first use.
+
+        """
+        return self._internal.iter_records()
+
+    def reload(self):
+        """
+        **Beta** While in beta, expect both major and minor changes across minor releases.
+
+        Update the instance with new information. Backing information (i.e. repodata.json)
+        is lazily downloaded/loaded on first use by the other methods of this class. You
+        should only use this method if you are *sure* you have outdated data.
+
+        Returns:
+            SubdirData
+
+        """
+        self._internal = self._internal.reload()
+        return self
+
+
+class PackageCacheData(object):
+    """
+    **Beta** While in beta, expect both major and minor changes across minor releases.
+
+    High-level management and usage of package caches.
+    """
+
+    def __init__(self, pkgs_dir):
+        """
+        **Beta** While in beta, expect both major and minor changes across minor releases.
+
+        Args:
+            pkgs_dir (str):
+        """
+        self._internal = _PackageCacheData(pkgs_dir)
+
+    def get(self, package_ref, default=NULL):
+        """
+        **Beta** While in beta, expect both major and minor changes across minor releases.
+
+        Args:
+            package_ref (PackageRef):
+                A :obj:`PackageRef` instance representing the key for the
+                :obj:`PackageCacheRecord` being sought.
+            default: The default value to return if the record does not exist. If not
+                specified and no record exists, :exc:`KeyError` is raised.
+
+        Returns:
+            PackageCacheRecord
+
+        """
+        return self._internal.get(package_ref, default)
+
+    def query(self, package_ref_or_match_spec):
+        """
+        **Beta** While in beta, expect both major and minor changes across minor releases.
+
+        Run a query against this specific package cache instance.
+
+        Args:
+            package_ref_or_match_spec (PackageRef or MatchSpec or str):
+                Either an exact :obj:`PackageRef` to match against, or a :obj:`MatchSpec`
+                query object.  A :obj:`str` will be turned into a :obj:`MatchSpec` automatically.
+
+        Returns:
+            Tuple[PackageCacheRecord]
+
+        """
+        return tuple(self._internal.query(package_ref_or_match_spec))
+
+    @staticmethod
+    def query_all(package_ref_or_match_spec, pkgs_dirs=None):
+        """
+        **Beta** While in beta, expect both major and minor changes across minor releases.
+
+        Run a query against all package caches.
+
+        Args:
+            package_ref_or_match_spec (PackageRef or MatchSpec or str):
+                Either an exact :obj:`PackageRef` to match against, or a :obj:`MatchSpec`
+                query object.  A :obj:`str` will be turned into a :obj:`MatchSpec` automatically.
+            pkgs_dirs (Iterable[str] or None):
+                If None, will fall back to context.pkgs_dirs.
+
+        Returns:
+            Tuple[PackageCacheRecord]
+
+        """
+        return tuple(_PackageCacheData.query_all(package_ref_or_match_spec, pkgs_dirs))
+
+    def iter_records(self):
+        """
+        **Beta** While in beta, expect both major and minor changes across minor releases.
+
+        Returns:
+            Iterable[PackageCacheRecord]: A generator over all records contained in the package
+                cache instance.  Warning: this is a generator that is exhausted on first use.
+
+        """
+        return self._internal.iter_records()
+
+    @property
+    def is_writable(self):
+        """
+        **Beta** While in beta, expect both major and minor changes across minor releases.
+
+        Indicates if the package cache location is writable or read-only.
+
+        Returns:
+            bool
+
+        """
+        return self._internal.is_writable
+
+    @staticmethod
+    def first_writable(pkgs_dirs=None):
+        """
+        **Beta** While in beta, expect both major and minor changes across minor releases.
+
+        Get an instance object for the first writable package cache.
+
+        Args:
+            pkgs_dirs (Iterable[str]):
+                If None, will fall back to context.pkgs_dirs.
+
+        Returns:
+            PackageCacheData:
+                An instance for the first writable package cache.
+
+        """
+        return PackageCacheData(_PackageCacheData.first_writable(pkgs_dirs).pkgs_dir)
+
+    def reload(self):
+        """
+        **Beta** While in beta, expect both major and minor changes across minor releases.
+
+        Update the instance with new information. Backing information (i.e. contents of
+        the pkgs_dir) is lazily loaded on first use by the other methods of this class. You
+        should only use this method if you are *sure* you have outdated data.
+
+        Returns:
+            PackageCacheData
+
+        """
+        self._internal = self._internal.reload()
+        return self
+
+
+class PrefixData(object):
+    """
+    **Beta** While in beta, expect both major and minor changes across minor releases.
+
+    High-level management and usage of conda environment prefixes.
+    """
+
+    def __init__(self, prefix_path):
+        """
+        **Beta** While in beta, expect both major and minor changes across minor releases.
+
+        Args:
+            prefix_path (str):
+        """
+        self._internal = _PrefixData(prefix_path)
+
+    def get(self, package_ref, default=NULL):
+        """
+        **Beta** While in beta, expect both major and minor changes across minor releases.
+
+        Args:
+            package_ref (PackageRef):
+                A :obj:`PackageRef` instance representing the key for the
+                :obj:`PrefixRecord` being sought.
+            default: The default value to return if the record does not exist. If not
+                specified and no record exists, :exc:`KeyError` is raised.
+
+        Returns:
+            PrefixRecord
+
+        """
+        return self._internal.get(package_ref.name, default)
+
+    def query(self, package_ref_or_match_spec):
+        """
+        **Beta** While in beta, expect both major and minor changes across minor releases.
+
+        Run a query against this specific prefix instance.
+
+        Args:
+            package_ref_or_match_spec (PackageRef or MatchSpec or str):
+                Either an exact :obj:`PackageRef` to match against, or a :obj:`MatchSpec`
+                query object.  A :obj:`str` will be turned into a :obj:`MatchSpec` automatically.
+
+        Returns:
+            Tuple[PrefixRecord]
+
+        """
+        return tuple(self._internal.query(package_ref_or_match_spec))
+
+    def iter_records(self):
+        """
+        **Beta** While in beta, expect both major and minor changes across minor releases.
+
+        Returns:
+            Iterable[PrefixRecord]: A generator over all records contained in the prefix.
+                Warning: this is a generator that is exhausted on first use.
+
+        """
+        return self._internal.iter_records()
+
+    @property
+    def is_writable(self):
+        """
+        **Beta** While in beta, expect both major and minor changes across minor releases.
+
+        Indicates if the prefix is writable or read-only.
+
+        Returns:
+            bool or None:
+                True if the prefix is writable.  False if read-only.  None if the prefix
+                does not exist as a conda environment.
+
+        """
+        return self._internal.is_writable
+
+    def reload(self):
+        """
+        **Beta** While in beta, expect both major and minor changes across minor releases.
+
+        Update the instance with new information. Backing information (i.e. contents of
+        the conda-meta directory) is lazily loaded on first use by the other methods of this
+        class. You should only use this method if you are *sure* you have outdated data.
+
+        Returns:
+            PrefixData
+
+        """
+        self._internal = self._internal.reload()
+        return self

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/conda/exports.py

@@ -0,0 +1,378 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2012 Anaconda, Inc
+# SPDX-License-Identifier: BSD-3-Clause
+from __future__ import absolute_import, division, print_function, unicode_literals
+
+from collections.abc import Hashable as _Hashable
+import errno
+import functools
+import os
+import sys
+import threading
+import warnings
+
+# necessary for conda-build
+from ._vendor.six import PY3, iteritems, string_types, text_type  # noqa: F401
+from io import StringIO  # noqa: F401
+from builtins import input  # noqa: F401
+
+from . import CondaError  # noqa: F401
+from .base.context import reset_context
+
+reset_context()  # initialize context when conda.exports is imported
+
+from . import plan  # noqa: F401
+from .core.solve import Solver  # noqa: F401
+from .cli.common import specs_from_args, spec_from_line, specs_from_url  # noqa: F401
+from .cli.conda_argparse import add_parser_prefix, add_parser_channels  # noqa: F401
+from .cli.conda_argparse import ArgumentParser  # noqa: F401
+from .common import compat  # noqa: F401
+from .common.compat import on_win  # noqa: F401
+from .gateways.connection.session import CondaSession  # noqa: F401
+from .gateways.disk.create import TemporaryDirectory  # noqa: F401
+from .common.toposort import _toposort  # noqa: F401
+from .gateways.disk.link import lchmod  # noqa: F401
+from .gateways.connection.download import TmpDownload, download as _download  # noqa: F401
+
+handle_proxy_407 = lambda x, y: warnings.warn(
+    "The `conda.exports.handle_proxy_407` is pending deprecation and will be removed in a "
+    "future release. Now handled by CondaSession.",
+    PendingDeprecationWarning,
+)
+
+from .core.package_cache_data import rm_fetched  # noqa: F401
+from .gateways.disk.delete import delete_trash, move_to_trash  # noqa: F401
+from .misc import untracked, walk_prefix  # noqa: F401
+from .resolve import MatchSpec, ResolvePackageNotFound, Resolve, Unsatisfiable  # noqa: F401
+
+NoPackagesFound = NoPackagesFoundError = ResolvePackageNotFound
+
+from .utils import hashsum_file, human_bytes, unix_path_to_win, url_path  # noqa: F401
+from .common.path import win_path_to_unix  # noqa: F401
+from .gateways.disk.read import compute_md5sum
+
+md5_file = compute_md5sum
+
+from .models.version import VersionOrder, normalized_version  # noqa: F401
+from .models.channel import Channel  # noqa: F401
+import conda.base.context
+from .base.context import get_prefix, non_x86_machines, reset_context, sys_rc_path  # noqa: F401
+
+non_x86_linux_machines = non_x86_machines
+
+from .auxlib.entity import EntityEncoder  # noqa: F401
+from .base.constants import (  # noqa: F401
+    DEFAULT_CHANNELS,
+    DEFAULT_CHANNELS_WIN,
+    DEFAULT_CHANNELS_UNIX,
+)
+
+get_default_urls = lambda: DEFAULT_CHANNELS
+
+from .base.constants import PREFIX_PLACEHOLDER
+
+_PREFIX_PLACEHOLDER = prefix_placeholder = PREFIX_PLACEHOLDER
+
+arch_name = conda.base.context.context.arch_name
+binstar_upload = conda.base.context.context.anaconda_upload
+bits = conda.base.context.context.bits
+default_prefix = conda.base.context.context.default_prefix
+default_python = conda.base.context.context.default_python
+envs_dirs = conda.base.context.context.envs_dirs
+pkgs_dirs = conda.base.context.context.pkgs_dirs
+platform = conda.base.context.context.platform
+root_dir = conda.base.context.context.root_prefix
+root_writable = conda.base.context.context.root_writable
+subdir = conda.base.context.context.subdir
+conda_private = conda.base.context.context.conda_private
+conda_build = conda.base.context.context.conda_build
+
+from .models.channel import get_conda_build_local_url  # NOQA
+
+get_rc_urls = lambda: list(conda.base.context.context.channels)
+get_local_urls = lambda: list(get_conda_build_local_url()) or []
+load_condarc = lambda fn: conda.base.context.reset_context([fn])
+
+from .exceptions import PaddingError, LinkError, CondaOSError, PathNotFoundError  # NOQA
+
+PaddingError = PaddingError
+LinkError = LinkError
+CondaOSError = CondaOSError
+# PathNotFoundError is the conda 4.4.x name for it - let's plan ahead.
+PathNotFoundError = CondaFileNotFoundError = PathNotFoundError
+
+from .models.enums import FileMode  # noqa: F401
+from .models.enums import PathType  # noqa: F401
+from .models.records import PackageRecord
+
+IndexRecord = PackageRecord
+
+from .models.dist import Dist
+from .gateways.subprocess import ACTIVE_SUBPROCESSES, subprocess_call  # noqa: F401
+from .core.subdir_data import cache_fn_url  # noqa: F401
+from .core.package_cache_data import ProgressiveFetchExtract  # noqa: F401
+from .exceptions import CondaHTTPError, LockError, UnsatisfiableError  # noqa: F401
+
+
+class Completer(object):  # pragma: no cover
+    def get_items(self):
+        return self._get_items()
+
+    def __contains__(self, item):
+        return True
+
+    def __iter__(self):
+        return iter(self.get_items())
+
+
+class InstalledPackages(object):
+    pass
+
+
+class memoized(object):  # pragma: no cover
+    """Decorator. Caches a function's return value each time it is called.
+    If called later with the same arguments, the cached value is returned
+    (not reevaluated).
+    """
+    def __init__(self, func):
+        warnings.warn(
+            "The `conda.exports.memoized` decorator is pending deprecation and will be removed in "
+            "a future release. Please use `functools.lru_cache` instead.",
+            PendingDeprecationWarning,
+            stacklevel=2,
+        )
+
+        self.func = func
+        self.cache = {}
+        self.lock = threading.Lock()
+
+    def __call__(self, *args, **kw):
+        newargs = []
+        for arg in args:
+            if isinstance(arg, list):
+                newargs.append(tuple(arg))
+            elif not isinstance(arg, _Hashable):
+                # uncacheable. a list, for instance.
+                # better to not cache than blow up.
+                return self.func(*args, **kw)
+            else:
+                newargs.append(arg)
+        newargs = tuple(newargs)
+        key = (newargs, frozenset(sorted(kw.items())))
+        with self.lock:
+            if key in self.cache:
+                return self.cache[key]
+            else:
+                value = self.func(*args, **kw)
+                self.cache[key] = value
+                return value
+
+
+from .gateways.disk.delete import rm_rf as _rm_rf
+from .core.prefix_data import delete_prefix_from_linked_data
+
+
+def rm_rf(path, max_retries=5, trash=True):
+    _rm_rf(path, max_retries, trash)
+    delete_prefix_from_linked_data(path)
+
+
+# ######################
+# signature.py
+# ######################
+KEYS = None
+KEYS_DIR = None
+
+
+def hash_file(_):
+    return None  # pragma: no cover
+
+
+def verify(_):
+    return False  # pragma: no cover
+
+
+from .plan import (  # noqa: F401
+    execute_actions,
+    execute_instructions,
+    execute_plan,
+    install_actions,
+)
+from .plan import display_actions as _display_actions
+
+
+def display_actions(actions, index, show_channel_urls=None, specs_to_remove=(), specs_to_add=()):
+    if 'FETCH' in actions:
+        actions['FETCH'] = [index[d] for d in actions['FETCH']]
+    if 'LINK' in actions:
+        actions['LINK'] = [index[d] for d in actions['LINK']]
+    if 'UNLINK' in actions:
+        actions['UNLINK'] = [index[d] for d in actions['UNLINK']]
+    index = {prec: prec for prec in index.values()}
+    return _display_actions(actions, index, show_channel_urls, specs_to_remove, specs_to_add)
+
+
+from .core.index import (  # noqa: F401
+    dist_str_in_index,
+    fetch_index as _fetch_index,
+    get_index as _get_index,
+)
+
+
+def get_index(channel_urls=(), prepend=True, platform=None,
+              use_local=False, use_cache=False, unknown=None, prefix=None):
+    index = _get_index(channel_urls, prepend, platform, use_local, use_cache, unknown, prefix)
+    return {Dist(prec): prec for prec in index.values()}
+
+
+def fetch_index(channel_urls, use_cache=False, index=None):
+    index = _fetch_index(channel_urls, use_cache, index)
+    return {Dist(prec): prec for prec in index.values()}
+
+
+def package_cache():
+    from .core.package_cache_data import PackageCacheData
+
+    class package_cache(object):
+
+        def __contains__(self, dist):
+            return bool(PackageCacheData.first_writable().get(Dist(dist).to_package_ref(), None))
+
+        def keys(self):
+            return (Dist(v) for v in PackageCacheData.first_writable().values())
+
+        def __delitem__(self, dist):
+            PackageCacheData.first_writable().remove(Dist(dist).to_package_ref())
+
+    return package_cache()
+
+
+def symlink_conda(prefix, root_dir, shell=None):  # pragma: no cover
+    print("WARNING: symlink_conda() is deprecated.", file=sys.stderr)
+    # do not symlink root env - this clobbers activate incorrectly.
+    # prefix should always be longer than, or outside the root dir.
+    if os.path.normcase(os.path.normpath(prefix)) in os.path.normcase(os.path.normpath(root_dir)):
+        return
+    if on_win:
+        where = 'condabin'
+        symlink_fn = functools.partial(win_conda_bat_redirect, shell=shell)
+    else:
+        where = 'bin'
+        symlink_fn = os.symlink
+    if not os.path.isdir(os.path.join(prefix, where)):
+        os.makedirs(os.path.join(prefix, where))
+    _symlink_conda_hlp(prefix, root_dir, where, symlink_fn)
+
+
+def _symlink_conda_hlp(prefix, root_dir, where, symlink_fn):  # pragma: no cover
+    scripts = ["conda", "activate", "deactivate"]
+    prefix_where = os.path.join(prefix, where)
+    if not os.path.isdir(prefix_where):
+        os.makedirs(prefix_where)
+    for f in scripts:
+        root_file = os.path.join(root_dir, where, f)
+        prefix_file = os.path.join(prefix_where, f)
+        try:
+            # try to kill stale links if they exist
+            if os.path.lexists(prefix_file):
+                rm_rf(prefix_file)
+            # if they're in use, they won't be killed.  Skip making new symlink.
+            if not os.path.lexists(prefix_file):
+                symlink_fn(root_file, prefix_file)
+        except (IOError, OSError) as e:
+            if (os.path.lexists(prefix_file) and (e.errno in (
+                    errno.EPERM, errno.EACCES, errno.EROFS, errno.EEXIST
+            ))):
+                # Cannot symlink root_file to prefix_file. Ignoring since link already exists
+                pass
+            else:
+                raise
+
+
+if on_win:  # pragma: no cover
+    def win_conda_bat_redirect(src, dst, shell):
+        """Special function for Windows XP where the `CreateSymbolicLink`
+        function is not available.
+
+        Simply creates a `.bat` file at `dst` which calls `src` together with
+        all command line arguments.
+
+        Works of course only with callable files, e.g. `.bat` or `.exe` files.
+        """
+        from .utils import shells
+        try:
+            os.makedirs(os.path.dirname(dst))
+        except OSError as exc:  # Python >2.5
+            if exc.errno == errno.EEXIST and os.path.isdir(os.path.dirname(dst)):
+                pass
+            else:
+                raise
+
+        # bat file redirect
+        if not os.path.isfile(dst + '.bat'):
+            with open(dst + '.bat', 'w') as f:
+                f.write('@echo off\ncall "%s" %%*\n' % src)
+
+        # TODO: probably need one here for powershell at some point
+
+        # This one is for bash/cygwin/msys
+        # set default shell to bash.exe when not provided, as that's most common
+        if not shell:
+            shell = "bash.exe"
+
+        # technically these are "links" - but islink doesn't work on win
+        if not os.path.isfile(dst):
+            with open(dst, "w") as f:
+                f.write("#!/usr/bin/env bash \n")
+                if src.endswith("conda"):
+                    f.write('%s "$@"' % shells[shell]['path_to'](src+".exe"))
+                else:
+                    f.write('source %s "$@"' % shells[shell]['path_to'](src))
+            # Make the new file executable
+            # http://stackoverflow.com/a/30463972/1170370
+            mode = os.stat(dst).st_mode
+            mode |= (mode & 292) >> 2    # copy R bits to X
+            os.chmod(dst, mode)
+
+
+def linked_data(prefix, ignore_channels=False):
+    """
+    Return a dictionary of the linked packages in prefix.
+    """
+    from .core.prefix_data import PrefixData
+    from .models.dist import Dist
+    pd = PrefixData(prefix)
+    return {Dist(prefix_record): prefix_record for prefix_record in pd._prefix_records.values()}
+
+
+def linked(prefix, ignore_channels=False):
+    """
+    Return the Dists of linked packages in prefix.
+    """
+    from .models.enums import PackageType
+    conda_package_types = PackageType.conda_package_types()
+    ld = linked_data(prefix, ignore_channels=ignore_channels).items()
+    return set(dist for dist, prefix_rec in ld if prefix_rec.package_type in conda_package_types)
+
+
+# exports
+def is_linked(prefix, dist):
+    """
+    Return the install metadata for a linked package in a prefix, or None
+    if the package is not linked in the prefix.
+    """
+    # FIXME Functions that begin with `is_` should return True/False
+    from .core.prefix_data import PrefixData
+    pd = PrefixData(prefix)
+    prefix_record = pd.get(dist.name, None)
+    if prefix_record is None:
+        return None
+    elif MatchSpec(dist).match(prefix_record):
+        return prefix_record
+    else:
+        return None
+
+
+def download(url, dst_path, session=None, md5sum=None, urlstxt=False, retries=3,
+             sha256=None, size=None):
+    return _download(url, dst_path, md5=md5sum, sha256=sha256, size=size)

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/conda/history.py

@@ -0,0 +1,410 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2012 Anaconda, Inc
+# SPDX-License-Identifier: BSD-3-Clause
+from __future__ import absolute_import, division, print_function, unicode_literals
+
+from ast import literal_eval
+import codecs
+from errno import EACCES, EPERM, EROFS
+import logging
+from operator import itemgetter
+import os
+from os.path import isdir, isfile, join
+import re
+import sys
+from textwrap import dedent
+import time
+import warnings
+
+from . import __version__ as CONDA_VERSION
+from .auxlib.ish import dals
+from ._vendor.toolz import groupby, take
+from .base.constants import DEFAULTS_CHANNEL_NAME
+from .base.context import context
+from .common.compat import ensure_text_type, open
+from .common.path import paths_equal
+from .core.prefix_data import PrefixData
+from .exceptions import CondaHistoryError, NotWritableError
+from .gateways.disk.update import touch
+from .models.dist import dist_str_to_quad
+from .models.version import VersionOrder, version_relation_re
+from .models.match_spec import MatchSpec
+
+log = logging.getLogger(__name__)
+
+
+class CondaHistoryWarning(Warning):
+    pass
+
+
+def write_head(fo):
+    fo.write("==> %s <==\n" % time.strftime('%Y-%m-%d %H:%M:%S'))
+    fo.write("# cmd: %s\n" % (' '.join(ensure_text_type(s) for s in sys.argv)))
+    fo.write("# conda version: %s\n" % '.'.join(take(3, CONDA_VERSION.split('.'))))
+
+
+def is_diff(content):
+    return any(s.startswith(('-', '+')) for s in content)
+
+
+def pretty_diff(diff):
+    added = {}
+    removed = {}
+    for s in diff:
+        fn = s[1:]
+        name, version, _, channel = dist_str_to_quad(fn)
+        if channel != DEFAULTS_CHANNEL_NAME:
+            version += ' (%s)' % channel
+        if s.startswith('-'):
+            removed[name.lower()] = version
+        elif s.startswith('+'):
+            added[name.lower()] = version
+    changed = set(added) & set(removed)
+    for name in sorted(changed):
+        yield ' %s  {%s -> %s}' % (name, removed[name], added[name])
+    for name in sorted(set(removed) - changed):
+        yield '-%s-%s' % (name, removed[name])
+    for name in sorted(set(added) - changed):
+        yield '+%s-%s' % (name, added[name])
+
+
+def pretty_content(content):
+    if is_diff(content):
+        return pretty_diff(content)
+    else:
+        return iter(sorted(content))
+
+
+class History(object):
+
+    com_pat = re.compile(r'#\s*cmd:\s*(.+)')
+    spec_pat = re.compile(r'#\s*(\w+)\s*specs:\s*(.+)?')
+    conda_v_pat = re.compile(r'#\s*conda version:\s*(.+)')
+
+    def __init__(self, prefix):
+        self.prefix = prefix
+        self.meta_dir = join(prefix, 'conda-meta')
+        self.path = join(self.meta_dir, 'history')
+
+    def __enter__(self):
+        self.init_log_file()
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self.update()
+
+    def init_log_file(self):
+        touch(self.path, True)
+
+    def file_is_empty(self):
+        return os.stat(self.path).st_size == 0
+
+    def update(self):
+        """
+        update the history file (creating a new one if necessary)
+        """
+        try:
+            try:
+                last = set(self.get_state())
+            except CondaHistoryError as e:
+                warnings.warn("Error in %s: %s" % (self.path, e),
+                              CondaHistoryWarning)
+                return
+            pd = PrefixData(self.prefix)
+            curr = set(prefix_rec.dist_str() for prefix_rec in pd.iter_records())
+            self.write_changes(last, curr)
+        except EnvironmentError as e:
+            if e.errno in (EACCES, EPERM, EROFS):
+                raise NotWritableError(self.path, e.errno)
+            else:
+                raise
+
+    def parse(self):
+        """
+        parse the history file and return a list of
+        tuples(datetime strings, set of distributions/diffs, comments)
+        """
+        res = []
+        if not isfile(self.path):
+            return res
+        sep_pat = re.compile(r'==>\s*(.+?)\s*<==')
+        with open(self.path) as f:
+            lines = f.read().splitlines()
+        for line in lines:
+            line = line.strip()
+            if not line:
+                continue
+            m = sep_pat.match(line)
+            if m:
+                res.append((m.group(1), set(), []))
+            elif line.startswith('#'):
+                res[-1][2].append(line)
+            elif len(res) > 0:
+                res[-1][1].add(line)
+        return res
+
+    @staticmethod
+    def _parse_old_format_specs_string(specs_string):
+        """
+        Parse specifications string that use conda<4.5 syntax.
+
+        Examples
+        --------
+          - "param >=1.5.1,<2.0'"
+          - "python>=3.5.1,jupyter >=1.0.0,<2.0,matplotlib >=1.5.1,<2.0"
+        """
+        specs = []
+        for spec in specs_string.split(','):
+            # If the spec starts with a version qualifier, then it actually belongs to the
+            # previous spec. But don't try to join if there was no previous spec.
+            if version_relation_re.match(spec) and specs:
+                specs[-1] = ','.join([specs[-1], spec])
+            else:
+                specs.append(spec)
+        return specs
+
+    @classmethod
+    def _parse_comment_line(cls, line):
+        """
+        Parse comment lines in the history file.
+
+        These lines can be of command type or action type.
+
+        Examples
+        --------
+          - "# cmd: /scratch/mc3/bin/conda install -c conda-forge param>=1.5.1,<2.0"
+          - "# install specs: python>=3.5.1,jupyter >=1.0.0,<2.0,matplotlib >=1.5.1,<2.0"
+        """
+        item = {}
+        m = cls.com_pat.match(line)
+        if m:
+            argv = m.group(1).split()
+            if argv[0].endswith('conda'):
+                argv[0] = 'conda'
+            item['cmd'] = argv
+
+        m = cls.conda_v_pat.match(line)
+        if m:
+            item['conda_version'] = m.group(1)
+
+        m = cls.spec_pat.match(line)
+        if m:
+            action, specs_string = m.groups()
+            specs_string = specs_string or ""
+            item['action'] = action
+
+            if specs_string.startswith('['):
+                specs = literal_eval(specs_string)
+            elif '[' not in specs_string:
+                specs = History._parse_old_format_specs_string(specs_string)
+
+            specs = [spec for spec in specs if spec and not spec.endswith('@')]
+
+            if specs and action in ('update', 'install', 'create'):
+                item['update_specs'] = item['specs'] = specs
+            elif specs and action in ('remove', 'uninstall'):
+                item['remove_specs'] = item['specs'] = specs
+            elif specs and action in ('neutered', ):
+                item['neutered_specs'] = item['specs'] = specs
+
+        return item
+
+    def get_user_requests(self):
+        """
+        return a list of user requested items.  Each item is a dict with the
+        following keys:
+        'date': the date and time running the command
+        'cmd': a list of argv of the actual command which was run
+        'action': install/remove/update
+        'specs': the specs being used
+        """
+        res = []
+        for dt, unused_cont, comments in self.parse():
+            item = {'date': dt}
+            for line in comments:
+                comment_items = self._parse_comment_line(line)
+                item.update(comment_items)
+
+            if 'cmd' in item:
+                res.append(item)
+
+            dists = groupby(itemgetter(0), unused_cont)
+            item['unlink_dists'] = dists.get('-', ())
+            item['link_dists'] = dists.get('+', ())
+
+        conda_versions_from_history = tuple(x['conda_version'] for x in res
+                                            if 'conda_version' in x)
+        if conda_versions_from_history and not context.allow_conda_downgrades:
+            minimum_conda_version = sorted(conda_versions_from_history, key=VersionOrder)[-1]
+            minimum_major_minor = '.'.join(take(2, minimum_conda_version.split('.')))
+            current_major_minor = '.'.join(take(2, CONDA_VERSION.split('.')))
+            if VersionOrder(current_major_minor) < VersionOrder(minimum_major_minor):
+                message = dals("""
+                This environment has previously been operated on by a conda version that's newer
+                than the conda currently being used. A newer version of conda is required.
+                  target environment location: %(target_prefix)s
+                  current conda version: %(conda_version)s
+                  minimum conda version: %(minimum_version)s
+                """) % {
+                    "target_prefix": self.prefix,
+                    "conda_version": CONDA_VERSION,
+                    "minimum_version": minimum_major_minor,
+                }
+                if not paths_equal(self.prefix, context.root_prefix):
+                    message += dedent("""
+                    Update conda and try again.
+                        $ conda install -p "%(base_prefix)s" "conda>=%(minimum_version)s"
+                    """) % {
+                        "base_prefix": context.root_prefix,
+                        "minimum_version": minimum_major_minor,
+                    }
+                message += dedent("""
+                To work around this restriction, one can also set the config parameter
+                'allow_conda_downgrades' to False at their own risk.
+                """)
+
+                # TODO: we need to rethink this.  It's fine as a warning to try to get users
+                #    to avoid breaking their system.  However, right now it is preventing
+                #    normal conda operation after downgrading conda.
+                # raise CondaUpgradeError(message)
+
+        return res
+
+    def get_requested_specs_map(self):
+        # keys are package names and values are specs
+        spec_map = {}
+        for request in self.get_user_requests():
+            remove_specs = (MatchSpec(spec) for spec in request.get('remove_specs', ()))
+            for spec in remove_specs:
+                spec_map.pop(spec.name, None)
+            update_specs = (MatchSpec(spec) for spec in request.get('update_specs', ()))
+            spec_map.update(((s.name, s) for s in update_specs))
+            # here is where the neutering takes effect, overriding past values
+            neutered_specs = (MatchSpec(spec) for spec in request.get('neutered_specs', ()))
+            spec_map.update(((s.name, s) for s in neutered_specs))
+
+        # Conda hasn't always been good about recording when specs have been removed from
+        # environments.  If the package isn't installed in the current environment, then we
+        # shouldn't try to force it here.
+        prefix_recs = set(_.name for _ in PrefixData(self.prefix).iter_records())
+        return dict((name, spec) for name, spec in spec_map.items() if name in prefix_recs)
+
+    def construct_states(self):
+        """
+        return a list of tuples(datetime strings, set of distributions)
+        """
+        res = []
+        cur = set([])
+        for dt, cont, unused_com in self.parse():
+            if not is_diff(cont):
+                cur = cont
+            else:
+                for s in cont:
+                    if s.startswith('-'):
+                        cur.discard(s[1:])
+                    elif s.startswith('+'):
+                        cur.add(s[1:])
+                    else:
+                        raise CondaHistoryError('Did not expect: %s' % s)
+            res.append((dt, cur.copy()))
+        return res
+
+    def get_state(self, rev=-1):
+        """
+        return the state, i.e. the set of distributions, for a given revision,
+        defaults to latest (which is the same as the current state when
+        the log file is up-to-date)
+
+        Returns a list of dist_strs
+        """
+        states = self.construct_states()
+        if not states:
+            return set([])
+        times, pkgs = zip(*states)
+        return pkgs[rev]
+
+    def print_log(self):
+        for i, (date, content, unused_com) in enumerate(self.parse()):
+            print('%s  (rev %d)' % (date, i))
+            for line in pretty_content(content):
+                print('    %s' % line)
+            print('')
+
+    def object_log(self):
+        result = []
+        for i, (date, content, unused_com) in enumerate(self.parse()):
+            # Based on Mateusz's code; provides more details about the
+            # history event
+            event = {
+                'date': date,
+                'rev': i,
+                'install': [],
+                'remove': [],
+                'upgrade': [],
+                'downgrade': []
+            }
+            added = {}
+            removed = {}
+            if is_diff(content):
+                for pkg in content:
+                    name, version, build, channel = dist_str_to_quad(pkg[1:])
+                    if pkg.startswith('+'):
+                        added[name.lower()] = (version, build, channel)
+                    elif pkg.startswith('-'):
+                        removed[name.lower()] = (version, build, channel)
+
+                changed = set(added) & set(removed)
+                for name in sorted(changed):
+                    old = removed[name]
+                    new = added[name]
+                    details = {
+                        'old': '-'.join((name,) + old),
+                        'new': '-'.join((name,) + new)
+                    }
+
+                    if new > old:
+                        event['upgrade'].append(details)
+                    else:
+                        event['downgrade'].append(details)
+
+                for name in sorted(set(removed) - changed):
+                    event['remove'].append('-'.join((name,) + removed[name]))
+
+                for name in sorted(set(added) - changed):
+                    event['install'].append('-'.join((name,) + added[name]))
+            else:
+                for pkg in sorted(content):
+                    event['install'].append(pkg)
+            result.append(event)
+        return result
+
+    def write_changes(self, last_state, current_state):
+        if not isdir(self.meta_dir):
+            os.makedirs(self.meta_dir)
+        with codecs.open(self.path, mode='ab', encoding='utf-8') as fo:
+            write_head(fo)
+            for fn in sorted(last_state - current_state):
+                fo.write('-%s\n' % fn)
+            for fn in sorted(current_state - last_state):
+                fo.write('+%s\n' % fn)
+
+    def write_specs(self, remove_specs=(), update_specs=(), neutered_specs=()):
+        remove_specs = [str(MatchSpec(s)) for s in remove_specs]
+        update_specs = [str(MatchSpec(s)) for s in update_specs]
+        neutered_specs = [str(MatchSpec(s)) for s in neutered_specs]
+        if any((update_specs, remove_specs, neutered_specs)):
+            with codecs.open(self.path, mode='ab', encoding='utf-8') as fh:
+                if remove_specs:
+                    fh.write("# remove specs: %s\n" % remove_specs)
+                if update_specs:
+                    fh.write("# update specs: %s\n" % update_specs)
+                if neutered_specs:
+                    fh.write("# neutered specs: %s\n" % neutered_specs)
+
+
+if __name__ == '__main__':
+    from pprint import pprint
+    # Don't use in context manager mode---it augments the history every time
+    h = History(sys.prefix)
+    pprint(h.get_user_requests())
+    print(h.get_requested_specs_map())

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/conda/lock.py

@@ -0,0 +1,134 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2012 Anaconda, Inc
+# SPDX-License-Identifier: BSD-3-Clause
+"""
+Tools for working with locks
+
+A lock is just an empty directory. We use directories because this lets us use
+the race condition-proof os.makedirs.
+
+For now, there is one global lock for all of conda, because some things happen
+globally (such as downloading packages).
+
+We don't raise an error if the lock is named with the current PID
+"""
+from __future__ import absolute_import, division, print_function, unicode_literals
+
+from glob import glob
+import logging
+import os
+from os.path import abspath, basename, dirname, isdir, join
+import time
+import warnings
+
+from .exceptions import LockError
+
+warnings.warn(
+    "The `conda.lock` module is pending deprecation and will be removed in a future release. "
+    "Please use `filelock` instead.",
+    PendingDeprecationWarning,
+)
+
+LOCK_EXTENSION = 'conda_lock'
+
+# Keep the string "LOCKERROR" in this string so that external
+# programs can look for it.
+LOCKSTR = """
+LOCKERROR: It looks like conda is already doing something.
+The lock {0} was found. Wait for it to finish before continuing.
+If you are sure that conda is not running, remove it and try again.
+You can also use: $ conda clean --lock
+"""
+
+log = logging.getLogger(__name__)
+stdoutlog = logging.getLogger('conda.stdoutlog')
+
+def touch(file_name, times=None):
+    """ Touch function like touch in Unix shell
+    :param file_name: the name of file
+    :param times: the access and modified time
+    Examples:
+        touch("hello_world.py")
+    """
+    try:
+        with open(file_name, 'a'):
+            os.utime(file_name, times)
+    except (OSError, IOError) as e:
+        log.warn("Failed to create lock, do not run conda in parallel processes [errno %d]",
+                 e.errno)
+
+
+class FileLock(object):
+    """Lock a path (file or directory) with the lock file sitting *beside* path.
+
+    :param path_to_lock: the path to be locked
+    :param retries: max number of retries
+    """
+    def __init__(self, path_to_lock, retries=10):
+        """
+        """
+        self.path_to_lock = abspath(path_to_lock)
+        self.retries = retries
+        self.lock_file_path = "%s.pid{0}.%s" % (self.path_to_lock, LOCK_EXTENSION)
+        # e.g. if locking path `/conda`, lock file will be `/conda.pidXXXX.conda_lock`
+        self.lock_file_glob_str = "%s.pid*.%s" % (self.path_to_lock, LOCK_EXTENSION)
+        assert isdir(dirname(self.path_to_lock)), "{0} doesn't exist".format(self.path_to_lock)
+        assert "::" not in self.path_to_lock, self.path_to_lock
+
+    def __enter__(self):
+        sleep_time = 1
+        self.lock_file_path = self.lock_file_path.format(os.getpid())
+        last_glob_match = None
+
+        for _ in range(self.retries + 1):
+
+            # search, whether there is process already locked on this file
+            glob_result = glob(self.lock_file_glob_str)
+            if glob_result:
+                log.debug(LOCKSTR.format(glob_result))
+                log.debug("Sleeping for %s seconds", sleep_time)
+
+                time.sleep(sleep_time / 10)
+                sleep_time *= 2
+                last_glob_match = glob_result
+            else:
+                touch(self.lock_file_path)
+                return self
+
+        stdoutlog.error("Exceeded max retries, giving up")
+        raise LockError(LOCKSTR.format(last_glob_match))
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        from .gateways.disk.delete import rm_rf
+        rm_rf(self.lock_file_path)
+
+
+# lgtm alert ignore because this lock functionality is unused and will soon be replaced
+class DirectoryLock(FileLock):  # lgtm [py/missing-call-to-init]
+    """Lock a directory with the lock file sitting *within* the directory being locked.
+
+    Useful when, for example, locking the root prefix at ``/conda``, and ``/`` is not writable.
+
+    :param directory_path: the path to be locked
+    :param retries: max number of retries
+    """
+
+    def __init__(self, directory_path, retries=10):
+        self.directory_path = abspath(directory_path)
+        directory_name = basename(self.directory_path)
+        self.retries = retries
+        lock_path_pre = join(self.directory_path, directory_name)
+        self.lock_file_path = "%s.pid{0}.%s" % (lock_path_pre, LOCK_EXTENSION)
+        # e.g. if locking directory `/conda`, lock file will be `/conda/conda.pidXXXX.conda_lock`
+        self.lock_file_glob_str = "%s.pid*.%s" % (lock_path_pre, LOCK_EXTENSION)
+        # make sure '/' exists
+        assert isdir(dirname(self.directory_path)), "{0} doesn't exist".format(self.directory_path)
+        if not isdir(self.directory_path):
+            try:
+                os.makedirs(self.directory_path)
+                log.debug("forced to create %s", self.directory_path)
+            except (OSError, IOError) as e:
+                log.warn("Failed to create directory %s [errno %d]", self.directory_path, e.errno)
+
+
+Locked = DirectoryLock

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/conda/plan.py

@@ -0,0 +1,563 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2012 Anaconda, Inc
+# SPDX-License-Identifier: BSD-3-Clause
+"""
+Handle the planning of installs and their execution.
+
+NOTE:
+    conda.install uses canonical package names in its interface functions,
+    whereas conda.resolve uses package filenames, as those are used as index
+    keys.  We try to keep fixes to this "impedance mismatch" local to this
+    module.
+"""
+from __future__ import absolute_import, division, print_function, unicode_literals
+
+from collections import defaultdict
+from logging import getLogger
+import sys
+
+from ._vendor.boltons.setutils import IndexedSet
+from ._vendor.toolz import concatv
+from .base.constants import DEFAULTS_CHANNEL_NAME, UNKNOWN_CHANNEL
+from .base.context import context, stack_context_default
+from .common.io import dashlist, env_vars, time_recorder
+from .core.index import LAST_CHANNEL_URLS, _supplement_index_with_prefix
+from .core.link import PrefixSetup, UnlinkLinkTransaction
+from .core.solve import diff_for_unlink_link_precs
+from .exceptions import CondaIndexError, PackagesNotFoundError
+from .history import History
+from .instructions import (FETCH, LINK, SYMLINK_CONDA, UNLINK)
+from .models.channel import Channel, prioritize_channels
+from .models.dist import Dist
+from .models.enums import LinkType
+from .models.match_spec import ChannelMatch
+from .models.prefix_graph import PrefixGraph
+from .models.records import PackageRecord
+from .models.version import normalized_version
+from .resolve import MatchSpec
+from .utils import human_bytes
+
+log = getLogger(__name__)
+
+# TODO: Remove conda/plan.py.  This module should be almost completely deprecated now.
+
+def print_dists(dists_extras):
+    fmt = "    %-27s|%17s"
+    print(fmt % ('package', 'build'))
+    print(fmt % ('-' * 27, '-' * 17))
+    for prec, extra in dists_extras:
+        line = fmt % (prec.name + '-' + prec.version, prec.build)
+        if extra:
+            line += extra
+        print(line)
+
+
+def display_actions(actions, index, show_channel_urls=None, specs_to_remove=(), specs_to_add=()):
+    prefix = actions.get("PREFIX")
+    builder = ['', '## Package Plan ##\n']
+    if prefix:
+        builder.append('  environment location: %s' % prefix)
+        builder.append('')
+    if specs_to_remove:
+        builder.append('  removed specs: %s'
+                       % dashlist(sorted(str(s) for s in specs_to_remove), indent=4))
+        builder.append('')
+    if specs_to_add:
+        builder.append('  added / updated specs: %s'
+                       % dashlist(sorted(str(s) for s in specs_to_add), indent=4))
+        builder.append('')
+    print('\n'.join(builder))
+
+    if show_channel_urls is None:
+        show_channel_urls = context.show_channel_urls
+
+    def channel_str(rec):
+        if rec.get('schannel'):
+            return rec['schannel']
+        if rec.get('url'):
+            return Channel(rec['url']).canonical_name
+        if rec.get('channel'):
+            return Channel(rec['channel']).canonical_name
+        return UNKNOWN_CHANNEL
+
+    def channel_filt(s):
+        if show_channel_urls is False:
+            return ''
+        if show_channel_urls is None and s == DEFAULTS_CHANNEL_NAME:
+            return ''
+        return s
+
+    if actions.get(FETCH):
+        print("\nThe following packages will be downloaded:\n")
+
+        disp_lst = []
+        for prec in actions[FETCH]:
+            assert isinstance(prec, PackageRecord)
+            extra = '%15s' % human_bytes(prec['size'])
+            schannel = channel_filt(prec.channel.canonical_name)
+            if schannel:
+                extra += '  ' + schannel
+            disp_lst.append((prec, extra))
+        print_dists(disp_lst)
+
+        if index and len(actions[FETCH]) > 1:
+            num_bytes = sum(prec['size'] for prec in actions[FETCH])
+            print(' ' * 4 + '-' * 60)
+            print(" " * 43 + "Total: %14s" % human_bytes(num_bytes))
+
+    # package -> [oldver-oldbuild, newver-newbuild]
+    packages = defaultdict(lambda: list(('', '')))
+    features = defaultdict(lambda: list(('', '')))
+    channels = defaultdict(lambda: list(('', '')))
+    records = defaultdict(lambda: list((None, None)))
+    linktypes = {}
+
+    for prec in actions.get(LINK, []):
+        assert isinstance(prec, PackageRecord)
+        pkg = prec['name']
+        channels[pkg][1] = channel_str(prec)
+        packages[pkg][1] = prec['version'] + '-' + prec['build']
+        records[pkg][1] = prec
+        linktypes[pkg] = LinkType.hardlink  # TODO: this is a lie; may have to give this report after UnlinkLinkTransaction.verify()  # NOQA
+        features[pkg][1] = ','.join(prec.get('features') or ())
+    for prec in actions.get(UNLINK, []):
+        assert isinstance(prec, PackageRecord)
+        pkg = prec['name']
+        channels[pkg][0] = channel_str(prec)
+        packages[pkg][0] = prec['version'] + '-' + prec['build']
+        records[pkg][0] = prec
+        features[pkg][0] = ','.join(prec.get('features') or ())
+
+    new = {p for p in packages if not packages[p][0]}
+    removed = {p for p in packages if not packages[p][1]}
+    # New packages are actually listed in the left-hand column,
+    # so let's move them over there
+    for pkg in new:
+        for var in (packages, features, channels, records):
+            var[pkg] = var[pkg][::-1]
+
+    updated = set()
+    downgraded = set()
+    channeled = set()
+    oldfmt = {}
+    newfmt = {}
+    empty = True
+    if packages:
+        empty = False
+        maxpkg = max(len(p) for p in packages) + 1
+        maxoldver = max(len(p[0]) for p in packages.values())
+        maxnewver = max(len(p[1]) for p in packages.values())
+        maxoldfeatures = max(len(p[0]) for p in features.values())
+        maxnewfeatures = max(len(p[1]) for p in features.values())
+        maxoldchannels = max(len(channel_filt(p[0])) for p in channels.values())
+        maxnewchannels = max(len(channel_filt(p[1])) for p in channels.values())
+        for pkg in packages:
+            # That's right. I'm using old-style string formatting to generate a
+            # string with new-style string formatting.
+            oldfmt[pkg] = '{pkg:<%s} {vers[0]:<%s}' % (maxpkg, maxoldver)
+            if maxoldchannels:
+                oldfmt[pkg] += ' {channels[0]:<%s}' % maxoldchannels
+            if features[pkg][0]:
+                oldfmt[pkg] += ' [{features[0]:<%s}]' % maxoldfeatures
+
+            lt = LinkType(linktypes.get(pkg, LinkType.hardlink))
+            lt = '' if lt == LinkType.hardlink else (' (%s)' % lt)
+            if pkg in removed or pkg in new:
+                oldfmt[pkg] += lt
+                continue
+
+            newfmt[pkg] = '{vers[1]:<%s}' % maxnewver
+            if maxnewchannels:
+                newfmt[pkg] += ' {channels[1]:<%s}' % maxnewchannels
+            if features[pkg][1]:
+                newfmt[pkg] += ' [{features[1]:<%s}]' % maxnewfeatures
+            newfmt[pkg] += lt
+
+            P0 = records[pkg][0]
+            P1 = records[pkg][1]
+            pri0 = P0.get('priority')
+            pri1 = P1.get('priority')
+            if pri0 is None or pri1 is None:
+                pri0 = pri1 = 1
+            try:
+                if str(P1.version) == 'custom':
+                    newver = str(P0.version) != 'custom'
+                    oldver = not newver
+                else:
+                    # <= here means that unchanged packages will be put in updated
+                    N0 = normalized_version(P0.version)
+                    N1 = normalized_version(P1.version)
+                    newver = N0 < N1
+                    oldver = N0 > N1
+            except TypeError:
+                newver = P0.version < P1.version
+                oldver = P0.version > P1.version
+            oldbld = P0.build_number > P1.build_number
+            newbld = P0.build_number < P1.build_number
+            if context.channel_priority and pri1 < pri0 and (oldver or not newver and not newbld):
+                channeled.add(pkg)
+            elif newver:
+                updated.add(pkg)
+            elif pri1 < pri0 and (oldver or not newver and oldbld):
+                channeled.add(pkg)
+            elif oldver:
+                downgraded.add(pkg)
+            elif not oldbld:
+                updated.add(pkg)
+            else:
+                downgraded.add(pkg)
+
+    arrow = ' --> '
+    lead = ' ' * 4
+
+    def format(s, pkg):
+        chans = [channel_filt(c) for c in channels[pkg]]
+        return lead + s.format(pkg=pkg + ':', vers=packages[pkg],
+                               channels=chans, features=features[pkg])
+
+    if new:
+        print("\nThe following NEW packages will be INSTALLED:\n")
+        for pkg in sorted(new):
+            # New packages have been moved to the "old" column for display
+            print(format(oldfmt[pkg], pkg))
+
+    if removed:
+        print("\nThe following packages will be REMOVED:\n")
+        for pkg in sorted(removed):
+            print(format(oldfmt[pkg], pkg))
+
+    if updated:
+        print("\nThe following packages will be UPDATED:\n")
+        for pkg in sorted(updated):
+            print(format(oldfmt[pkg] + arrow + newfmt[pkg], pkg))
+
+    if channeled:
+        print("\nThe following packages will be SUPERSEDED by a higher-priority channel:\n")
+        for pkg in sorted(channeled):
+            print(format(oldfmt[pkg] + arrow + newfmt[pkg], pkg))
+
+    if downgraded:
+        print("\nThe following packages will be DOWNGRADED:\n")
+        for pkg in sorted(downgraded):
+            print(format(oldfmt[pkg] + arrow + newfmt[pkg], pkg))
+
+    if empty and actions.get(SYMLINK_CONDA):
+        print("\nThe following empty environments will be CREATED:\n")
+        print(actions['PREFIX'])
+
+    print('')
+
+
+def add_unlink(actions, dist):
+    assert isinstance(dist, Dist)
+    if UNLINK not in actions:
+        actions[UNLINK] = []
+    actions[UNLINK].append(dist)
+
+
+# -------------------------------------------------------------------
+
+
+def add_defaults_to_specs(r, linked, specs, update=False, prefix=None):
+    return
+
+
+def _get_best_prec_match(precs):
+    assert precs
+    for chn in context.channels:
+        channel_matcher = ChannelMatch(chn)
+        prec_matches = tuple(prec for prec in precs if channel_matcher.match(prec.channel.name))
+        if prec_matches:
+            break
+    else:
+        prec_matches = precs
+    log.warn("Multiple packages found:%s", dashlist(prec_matches))
+    return prec_matches[0]
+
+
+def revert_actions(prefix, revision=-1, index=None):
+    # TODO: If revision raise a revision error, should always go back to a safe revision
+    h = History(prefix)
+    # TODO: need a History method to get user-requested specs for revision number
+    #       Doing a revert right now messes up user-requested spec history.
+    #       Either need to wipe out history after ``revision``, or add the correct
+    #       history information to the new entry about to be created.
+    # TODO: This is wrong!!!!!!!!!!
+    user_requested_specs = h.get_requested_specs_map().values()
+    try:
+        target_state = {MatchSpec.from_dist_str(dist_str) for dist_str in h.get_state(revision)}
+    except IndexError:
+        raise CondaIndexError("no such revision: %d" % revision)
+
+    _supplement_index_with_prefix(index, prefix)
+
+    not_found_in_index_specs = set()
+    link_precs = set()
+    for spec in target_state:
+        precs = tuple(prec for prec in index.values() if spec.match(prec))
+        if not precs:
+            not_found_in_index_specs.add(spec)
+        elif len(precs) > 1:
+            link_precs.add(_get_best_prec_match(precs))
+        else:
+            link_precs.add(precs[0])
+
+    if not_found_in_index_specs:
+        raise PackagesNotFoundError(not_found_in_index_specs)
+
+    final_precs = IndexedSet(PrefixGraph(link_precs).graph)  # toposort
+    unlink_precs, link_precs = diff_for_unlink_link_precs(prefix, final_precs)
+    stp = PrefixSetup(prefix, unlink_precs, link_precs, (), user_requested_specs, ())
+    txn = UnlinkLinkTransaction(stp)
+    return txn
+
+
+# ---------------------------- Backwards compat for conda-build --------------------------
+
+@time_recorder("execute_actions")
+def execute_actions(actions, index, verbose=False):  # pragma: no cover
+    plan = _plan_from_actions(actions, index)
+    execute_instructions(plan, index, verbose)
+
+
+def _plan_from_actions(actions, index):  # pragma: no cover
+    from .instructions import ACTION_CODES, PREFIX, PRINT, PROGRESS, PROGRESS_COMMANDS
+
+    if 'op_order' in actions and actions['op_order']:
+        op_order = actions['op_order']
+    else:
+        op_order = ACTION_CODES
+
+    assert PREFIX in actions and actions[PREFIX]
+    prefix = actions[PREFIX]
+    plan = [('PREFIX', '%s' % prefix)]
+
+    unlink_link_transaction = actions.get('UNLINKLINKTRANSACTION')
+    if unlink_link_transaction:
+        raise RuntimeError()
+        # progressive_fetch_extract = actions.get('PROGRESSIVEFETCHEXTRACT')
+        # if progressive_fetch_extract:
+        #     plan.append((PROGRESSIVEFETCHEXTRACT, progressive_fetch_extract))
+        # plan.append((UNLINKLINKTRANSACTION, unlink_link_transaction))
+        # return plan
+
+    axn = actions.get('ACTION') or None
+    specs = actions.get('SPECS', [])
+
+    log.debug("Adding plans for operations: {0}".format(op_order))
+    for op in op_order:
+        if op not in actions:
+            log.trace("action {0} not in actions".format(op))
+            continue
+        if not actions[op]:
+            log.trace("action {0} has None value".format(op))
+            continue
+        if '_' not in op:
+            plan.append((PRINT, '%sing packages ...' % op.capitalize()))
+        elif op.startswith('RM_'):
+            plan.append((PRINT, 'Pruning %s packages from the cache ...' % op[3:].lower()))
+        if op in PROGRESS_COMMANDS:
+            plan.append((PROGRESS, '%d' % len(actions[op])))
+        for arg in actions[op]:
+            log.debug("appending value {0} for action {1}".format(arg, op))
+            plan.append((op, arg))
+
+    plan = _inject_UNLINKLINKTRANSACTION(plan, index, prefix, axn, specs)
+
+    return plan
+
+
+def _inject_UNLINKLINKTRANSACTION(plan, index, prefix, axn, specs):  # pragma: no cover
+    from os.path import isdir
+    from .models.dist import Dist
+    from ._vendor.toolz.itertoolz import groupby
+    from .instructions import LINK, PROGRESSIVEFETCHEXTRACT, UNLINK, UNLINKLINKTRANSACTION
+    from .core.package_cache_data import ProgressiveFetchExtract
+    from .core.link import PrefixSetup, UnlinkLinkTransaction
+    # this is only used for conda-build at this point
+    first_unlink_link_idx = next((q for q, p in enumerate(plan) if p[0] in (UNLINK, LINK)), -1)
+    if first_unlink_link_idx >= 0:
+        grouped_instructions = groupby(lambda x: x[0], plan)
+        unlink_dists = tuple(Dist(d[1]) for d in grouped_instructions.get(UNLINK, ()))
+        link_dists = tuple(Dist(d[1]) for d in grouped_instructions.get(LINK, ()))
+        unlink_dists, link_dists = _handle_menuinst(unlink_dists, link_dists)
+
+        if isdir(prefix):
+            unlink_precs = tuple(index[d] for d in unlink_dists)
+        else:
+            # there's nothing to unlink in an environment that doesn't exist
+            # this is a hack for what appears to be a logic error in conda-build
+            # caught in tests/test_subpackages.py::test_subpackage_recipes[python_test_dep]
+            unlink_precs = ()
+        link_precs = tuple(index[d] for d in link_dists)
+
+        pfe = ProgressiveFetchExtract(link_precs)
+        pfe.prepare()
+
+        stp = PrefixSetup(prefix, unlink_precs, link_precs, (), specs, ())
+        plan.insert(first_unlink_link_idx, (UNLINKLINKTRANSACTION, UnlinkLinkTransaction(stp)))
+        plan.insert(first_unlink_link_idx, (PROGRESSIVEFETCHEXTRACT, pfe))
+    elif axn in ('INSTALL', 'CREATE'):
+        plan.insert(0, (UNLINKLINKTRANSACTION, (prefix, (), (), (), specs)))
+
+    return plan
+
+
+def _handle_menuinst(unlink_dists, link_dists):  # pragma: no cover
+    from .common.compat import on_win
+    if not on_win:
+        return unlink_dists, link_dists
+
+    # Always link/unlink menuinst first/last on windows in case a subsequent
+    # package tries to import it to create/remove a shortcut
+
+    # unlink
+    menuinst_idx = next((q for q, d in enumerate(unlink_dists) if d.name == 'menuinst'), None)
+    if menuinst_idx is not None:
+        unlink_dists = tuple(concatv(
+            unlink_dists[:menuinst_idx],
+            unlink_dists[menuinst_idx+1:],
+            unlink_dists[menuinst_idx:menuinst_idx+1],
+        ))
+
+    # link
+    menuinst_idx = next((q for q, d in enumerate(link_dists) if d.name == 'menuinst'), None)
+    if menuinst_idx is not None:
+        link_dists = tuple(concatv(
+            link_dists[menuinst_idx:menuinst_idx+1],
+            link_dists[:menuinst_idx],
+            link_dists[menuinst_idx+1:],
+        ))
+
+    return unlink_dists, link_dists
+
+
+@time_recorder("install_actions")
+def install_actions(prefix, index, specs, force=False, only_names=None, always_copy=False,
+                    pinned=True, update_deps=True, prune=False,
+                    channel_priority_map=None, is_update=False,
+                    minimal_hint=False):  # pragma: no cover
+    # this is for conda-build
+    with env_vars({
+        'CONDA_ALLOW_NON_CHANNEL_URLS': 'true',
+        'CONDA_SOLVER_IGNORE_TIMESTAMPS': 'false',
+    }, stack_callback=stack_context_default):
+        from os.path import basename
+        from ._vendor.boltons.setutils import IndexedSet
+        from .core.solve import _get_solver_class
+        from .models.channel import Channel
+        from .models.dist import Dist
+        if channel_priority_map:
+            channel_names = IndexedSet(Channel(url).canonical_name for url in channel_priority_map)
+            channels = IndexedSet(Channel(cn) for cn in channel_names)
+            subdirs = IndexedSet(basename(url) for url in channel_priority_map)
+        else:
+            # a hack for when conda-build calls this function without giving channel_priority_map
+            if LAST_CHANNEL_URLS:
+                channel_priority_map = prioritize_channels(LAST_CHANNEL_URLS)
+                channels = IndexedSet(Channel(url) for url in channel_priority_map)
+                subdirs = IndexedSet(
+                    subdir for subdir in (c.subdir for c in channels) if subdir
+                ) or context.subdirs
+            else:
+                channels = subdirs = None
+
+        specs = tuple(MatchSpec(spec) for spec in specs)
+
+        from .core.prefix_data import PrefixData
+        PrefixData._cache_.clear()
+
+        solver = _get_solver_class()(prefix, channels, subdirs, specs_to_add=specs)
+        if index:
+            solver._index = {prec: prec for prec in index.values()}
+        txn = solver.solve_for_transaction(prune=prune, ignore_pinned=not pinned)
+        prefix_setup = txn.prefix_setups[prefix]
+        actions = get_blank_actions(prefix)
+        actions['UNLINK'].extend(Dist(prec) for prec in prefix_setup.unlink_precs)
+        actions['LINK'].extend(Dist(prec) for prec in prefix_setup.link_precs)
+        return actions
+
+
+def get_blank_actions(prefix):  # pragma: no cover
+    from collections import defaultdict
+    from .instructions import (CHECK_EXTRACT, CHECK_FETCH, EXTRACT, FETCH, LINK, PREFIX,
+                               RM_EXTRACTED, RM_FETCHED, SYMLINK_CONDA, UNLINK)
+    actions = defaultdict(list)
+    actions[PREFIX] = prefix
+    actions['op_order'] = (CHECK_FETCH, RM_FETCHED, FETCH, CHECK_EXTRACT,
+                           RM_EXTRACTED, EXTRACT,
+                           UNLINK, LINK, SYMLINK_CONDA)
+    return actions
+
+
+@time_recorder("execute_plan")
+def execute_plan(old_plan, index=None, verbose=False):  # pragma: no cover
+    """
+    Deprecated: This should `conda.instructions.execute_instructions` instead
+    """
+    plan = _update_old_plan(old_plan)
+    execute_instructions(plan, index, verbose)
+
+
+def execute_instructions(plan, index=None, verbose=False, _commands=None):  # pragma: no cover
+    """Execute the instructions in the plan
+
+    :param plan: A list of (instruction, arg) tuples
+    :param index: The meta-data index
+    :param verbose: verbose output
+    :param _commands: (For testing only) dict mapping an instruction to executable if None
+    then the default commands will be used
+    """
+    from .instructions import commands, PROGRESS_COMMANDS
+    from .base.context import context
+    from .models.dist import Dist
+    if _commands is None:
+        _commands = commands
+
+    log.debug("executing plan %s", plan)
+
+    state = {'i': None, 'prefix': context.root_prefix, 'index': index}
+
+    for instruction, arg in plan:
+
+        log.debug(' %s(%r)', instruction, arg)
+
+        if state['i'] is not None and instruction in PROGRESS_COMMANDS:
+            state['i'] += 1
+            getLogger('progress.update').info((Dist(arg).dist_name,
+                                               state['i'] - 1))
+        cmd = _commands[instruction]
+
+        if callable(cmd):
+            cmd(state, arg)
+
+        if (state['i'] is not None and instruction in PROGRESS_COMMANDS
+                and state['maxval'] == state['i']):
+
+            state['i'] = None
+            getLogger('progress.stop').info(None)
+
+
+def _update_old_plan(old_plan):  # pragma: no cover
+    """
+    Update an old plan object to work with
+    `conda.instructions.execute_instructions`
+    """
+    plan = []
+    for line in old_plan:
+        if line.startswith('#'):
+            continue
+        if ' ' not in line:
+            from .exceptions import ArgumentError
+            raise ArgumentError("The instruction '%s' takes at least"
+                                " one argument" % line)
+
+        instruction, arg = line.split(' ', 1)
+        plan.append((instruction, arg))
+    return plan
+
+
+if __name__ == '__main__':
+    # for testing new revert_actions() only
+    from pprint import pprint
+    pprint(dict(revert_actions(sys.prefix, int(sys.argv[1]))))

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/conda/resolve.py

@@ -0,0 +1,1463 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2012 Anaconda, Inc
+# SPDX-License-Identifier: BSD-3-Clause
+from __future__ import absolute_import, division, print_function, unicode_literals
+
+from collections import defaultdict, OrderedDict, deque
+import copy
+from functools import lru_cache
+from logging import DEBUG, getLogger
+
+from .auxlib.decorators import memoizemethod
+from ._vendor.frozendict import FrozenOrderedDict as frozendict
+from ._vendor.toolz import concat, groupby
+from ._vendor.tqdm import tqdm
+from .base.constants import ChannelPriority, MAX_CHANNEL_PRIORITY, SatSolverChoice
+from .base.context import context
+from .common.compat import on_win
+from .common.io import dashlist, time_recorder
+from .common.logic import (Clauses, PycoSatSolver, PyCryptoSatSolver, PySatSolver, TRUE,
+                           minimal_unsatisfiable_subset)
+from .common.toposort import toposort
+from .exceptions import (CondaDependencyError, InvalidSpec, ResolvePackageNotFound,
+                         UnsatisfiableError)
+from .models.channel import Channel, MultiChannel
+from .models.enums import NoarchType, PackageType
+from .models.match_spec import MatchSpec
+from .models.records import PackageRecord
+from .models.version import VersionOrder
+
+log = getLogger(__name__)
+stdoutlog = getLogger('conda.stdoutlog')
+
+# used in conda build
+Unsatisfiable = UnsatisfiableError
+ResolvePackageNotFound = ResolvePackageNotFound
+
+_sat_solvers = {
+    SatSolverChoice.PYCOSAT: PycoSatSolver,
+    SatSolverChoice.PYCRYPTOSAT: PyCryptoSatSolver,
+    SatSolverChoice.PYSAT: PySatSolver,
+}
+
+
+@lru_cache(maxsize=None)
+def _get_sat_solver_cls(sat_solver_choice=SatSolverChoice.PYCOSAT):
+    def try_out_solver(sat_solver):
+        c = Clauses(sat_solver=sat_solver)
+        required = {c.new_var(), c.new_var()}
+        c.Require(c.And, *required)
+        solution = set(c.sat())
+        if not required.issubset(solution):
+            raise RuntimeError("Wrong SAT solution: {}. Required: {}".format(solution, required))
+
+    sat_solver = _sat_solvers[sat_solver_choice]
+    try:
+        try_out_solver(sat_solver)
+    except Exception as e:
+        log.warning("Could not run SAT solver through interface '%s'.", sat_solver_choice)
+        log.debug("SAT interface error due to: %s", e, exc_info=True)
+    else:
+        log.debug("Using SAT solver interface '%s'.", sat_solver_choice)
+        return sat_solver
+    for solver_choice, sat_solver in _sat_solvers.items():
+        try:
+            try_out_solver(sat_solver)
+        except Exception as e:
+            log.debug("Attempted SAT interface '%s' but unavailable due to: %s",
+                      sat_solver_choice, e)
+        else:
+            log.debug("Falling back to SAT solver interface '%s'.", sat_solver_choice)
+            return sat_solver
+    raise CondaDependencyError("Cannot run solver. No functioning SAT implementations available.")
+
+
+def exactness_and_number_of_deps(resolve_obj, ms):
+    """Sorting key to emphasize packages that have more strict
+    requirements. More strict means the reduced index can be reduced
+    more, so we want to consider these more constrained deps earlier in
+    reducing the index."""
+    if ms.strictness == 3:
+        prec = resolve_obj.find_matches(ms)
+        value = 3
+        if prec:
+            for dep in prec[0].depends:
+                value += MatchSpec(dep).strictness
+    else:
+        value = ms.strictness
+    return value
+
+
+class Resolve(object):
+
+    def __init__(self, index, processed=False, channels=()):
+        self.index = index
+
+        self.channels = channels
+        self._channel_priorities_map = self._make_channel_priorities(channels) if channels else {}
+        self._channel_priority = context.channel_priority
+        self._solver_ignore_timestamps = context.solver_ignore_timestamps
+
+        groups = groupby("name", index.values())
+        trackers = defaultdict(list)
+
+        for name in groups:
+            unmanageable_precs = [prec for prec in groups[name] if prec.is_unmanageable]
+            if unmanageable_precs:
+                log.debug("restricting to unmanageable packages: %s", name)
+                groups[name] = unmanageable_precs
+            tf_precs = (prec for prec in groups[name] if prec.track_features)
+            for prec in tf_precs:
+                for feature_name in prec.track_features:
+                    trackers[feature_name].append(prec)
+
+        self.groups = groups  # Dict[package_name, List[PackageRecord]]
+        self.trackers = trackers  # Dict[track_feature, Set[PackageRecord]]
+        self._cached_find_matches = {}  # Dict[MatchSpec, Set[PackageRecord]]
+        self.ms_depends_ = {}  # Dict[PackageRecord, List[MatchSpec]]
+        self._reduced_index_cache = {}
+        self._pool_cache = {}
+        self._strict_channel_cache = {}
+
+        self._system_precs = {_ for _ in index if (
+            hasattr(_, 'package_type') and _.package_type == PackageType.VIRTUAL_SYSTEM)}
+
+        # sorting these in reverse order is effectively prioritizing
+        # constraint behavior from newer packages. It is applying broadening
+        # reduction based on the latest packages, which may reduce the space
+        # more, because more modern packages utilize constraints in more sane
+        # ways (for example, using run_exports in conda-build 3)
+        for name, group in self.groups.items():
+            self.groups[name] = sorted(group, key=self.version_key, reverse=True)
+
+    def __hash__(self):
+        return (super(Resolve, self).__hash__() ^
+                hash(frozenset(self.channels)) ^
+                hash(frozendict(self._channel_priorities_map)) ^
+                hash(self._channel_priority) ^
+                hash(self._solver_ignore_timestamps) ^
+                hash(frozendict((k, tuple(v)) for k, v in self.groups.items())) ^
+                hash(frozendict((k, tuple(v)) for k, v in self.trackers.items())) ^
+                hash(frozendict((k, tuple(v)) for k, v in self.ms_depends_.items()))
+                )
+
+    def default_filter(self, features=None, filter=None):
+        # TODO: fix this import; this is bad
+        from .core.subdir_data import make_feature_record
+
+        if filter is None:
+            filter = {}
+        else:
+            filter.clear()
+
+        filter.update({make_feature_record(fstr): False for fstr in self.trackers.keys()})
+        if features:
+            filter.update({make_feature_record(fstr): True for fstr in features})
+        return filter
+
+    def valid(self, spec_or_prec, filter, optional=True):
+        """Tests if a package, MatchSpec, or a list of both has satisfiable
+        dependencies, assuming cyclic dependencies are always valid.
+
+        Args:
+            spec_or_prec: a package record, a MatchSpec, or an iterable of these.
+            filter: a dictionary of (fkey,valid) pairs, used to consider a subset
+                of dependencies, and to eliminate repeated searches.
+            optional: if True (default), do not enforce optional specifications
+                when considering validity. If False, enforce them.
+
+        Returns:
+            True if the full set of dependencies can be satisfied; False otherwise.
+            If filter is supplied and update is True, it will be updated with the
+            search results.
+        """
+        def v_(spec):
+            return v_ms_(spec) if isinstance(spec, MatchSpec) else v_fkey_(spec)
+
+        def v_ms_(ms):
+            return (optional and ms.optional
+                    or any(v_fkey_(fkey) for fkey in self.find_matches(ms)))
+
+        def v_fkey_(prec):
+            val = filter.get(prec)
+            if val is None:
+                filter[prec] = True
+                try:
+                    depends = self.ms_depends(prec)
+                except InvalidSpec:
+                    val = filter[prec] = False
+                else:
+                    val = filter[prec] = all(v_ms_(ms) for ms in depends)
+            return val
+
+        result = v_(spec_or_prec)
+        return result
+
+    def valid2(self, spec_or_prec, filter_out, optional=True):
+        def is_valid(_spec_or_prec):
+            if isinstance(_spec_or_prec, MatchSpec):
+                return is_valid_spec(_spec_or_prec)
+            else:
+                return is_valid_prec(_spec_or_prec)
+
+        @memoizemethod
+        def is_valid_spec(_spec):
+            return optional and _spec.optional or any(
+                is_valid_prec(_prec) for _prec in self.find_matches(_spec)
+            )
+
+        def is_valid_prec(prec):
+            val = filter_out.get(prec)
+            if val is None:
+                filter_out[prec] = False
+                try:
+                    has_valid_deps = all(is_valid_spec(ms) for ms in self.ms_depends(prec))
+                except InvalidSpec:
+                    val = filter_out[prec] = "invalid dep specs"
+                else:
+                    val = filter_out[prec] = False if has_valid_deps else "invalid depends specs"
+            return not val
+
+        return is_valid(spec_or_prec)
+
+    def invalid_chains(self, spec, filter, optional=True):
+        """Constructs a set of 'dependency chains' for invalid specs.
+
+        A dependency chain is a tuple of MatchSpec objects, starting with
+        the requested spec, proceeding down the dependency tree, ending at
+        a specification that cannot be satisfied.
+
+        Args:
+            spec: a package key or MatchSpec
+            filter: a dictionary of (prec, valid) pairs to be used when
+                testing for package validity.
+
+        Returns:
+            A tuple of tuples, empty if the MatchSpec is valid.
+        """
+        def chains_(spec, names):
+            if spec.name in names:
+                return
+            names.add(spec.name)
+            if self.valid(spec, filter, optional):
+                return
+            precs = self.find_matches(spec)
+            found = False
+
+            conflict_deps = set()
+            for prec in precs:
+                for m2 in self.ms_depends(prec):
+                    for x in chains_(m2, names):
+                        found = True
+                        yield (spec,) + x
+                    else:
+                        conflict_deps.add(m2)
+            if not found:
+                conflict_groups = groupby(lambda x: x.name, conflict_deps)
+                for group in conflict_groups.values():
+                    yield (spec,) + MatchSpec.union(group)
+
+        return chains_(spec, set())
+
+    def verify_specs(self, specs):
+        """Perform a quick verification that specs and dependencies are reasonable.
+
+        Args:
+            specs: An iterable of strings or MatchSpec objects to be tested.
+
+        Returns:
+            Nothing, but if there is a conflict, an error is thrown.
+
+        Note that this does not attempt to resolve circular dependencies.
+        """
+        non_tf_specs = []
+        bad_deps = []
+        feature_names = set()
+        for ms in specs:
+            _feature_names = ms.get_exact_value('track_features')
+            if _feature_names:
+                feature_names.update(_feature_names)
+            else:
+                non_tf_specs.append(ms)
+        bad_deps.extend((spec, ) for spec in non_tf_specs if (not spec.optional and
+                                                              not self.find_matches(spec)))
+        if bad_deps:
+            raise ResolvePackageNotFound(bad_deps)
+        return tuple(non_tf_specs), feature_names
+
+    def _classify_bad_deps(self, bad_deps, specs_to_add, history_specs, strict_channel_priority):
+        classes = {'python': set(),
+                   'request_conflict_with_history': set(),
+                   'direct': set(),
+                   'virtual_package': set(),
+                   }
+        specs_to_add = set(MatchSpec(_) for _ in specs_to_add or [])
+        history_specs = set(MatchSpec(_) for _ in history_specs or [])
+        for chain in bad_deps:
+            # sometimes chains come in as strings
+            if len(chain) > 1 and chain[-1].name == 'python' and \
+                    not any(_.name == 'python' for _ in specs_to_add) and \
+                    any(_[0] for _ in bad_deps if _[0].name == 'python'):
+                python_first_specs = [_[0] for _ in bad_deps if _[0].name == 'python']
+                if python_first_specs:
+                    python_spec = python_first_specs[0]
+                    if not (set(self.find_matches(python_spec)) &
+                            set(self.find_matches(chain[-1]))):
+                        classes['python'].add((tuple([chain[0], chain[-1]]),
+                                               str(MatchSpec(python_spec, target=None))))
+            elif chain[-1].name.startswith('__'):
+                version = [_ for _ in self._system_precs if _.name == chain[-1].name]
+                virtual_package_version = version[0].version if version else "not available"
+                classes['virtual_package'].add((tuple(chain), virtual_package_version))
+            elif chain[0] in specs_to_add:
+                match = False
+                for spec in history_specs:
+                    if spec.name == chain[-1].name:
+                        classes['request_conflict_with_history'].add((
+                            tuple(chain), str(MatchSpec(spec, target=None))))
+                        match = True
+
+                if not match:
+                    classes['direct'].add((tuple(chain), str(MatchSpec(chain[0], target=None))))
+            else:
+                if len(chain) > 1 or any(len(c) >= 1 and c[0] == chain[0] for c in bad_deps):
+                    classes['direct'].add((tuple(chain),
+                                           str(MatchSpec(chain[0], target=None))))
+
+        if classes['python']:
+            # filter out plain single-entry python conflicts.  The python section explains these.
+            classes['direct'] = [_ for _ in classes['direct']
+                                 if _[1].startswith('python ') or len(_[0]) > 1]
+        return classes
+
+    def find_matches_with_strict(self, ms, strict_channel_priority):
+        matches = self.find_matches(ms)
+        if not strict_channel_priority:
+            return matches
+        sole_source_channel_name = self._get_strict_channel(ms.name)
+        return tuple(f for f in matches if f.channel.name == sole_source_channel_name)
+
+    def find_conflicts(self, specs, specs_to_add=None, history_specs=None):
+        if context.unsatisfiable_hints:
+            if not context.json:
+                print("\nFound conflicts! Looking for incompatible packages.\n"
+                      "This can take several minutes.  Press CTRL-C to abort.")
+            bad_deps = self.build_conflict_map(specs, specs_to_add, history_specs)
+        else:
+            bad_deps = {}
+        strict_channel_priority = context.channel_priority == ChannelPriority.STRICT
+        raise UnsatisfiableError(bad_deps, strict=strict_channel_priority)
+
+    def breadth_first_search_for_dep_graph(self, root_spec, target_name, dep_graph, num_targets=1):
+        """Return shorted path from root_spec to target_name"""
+        queue = []
+        queue.append([root_spec])
+        visited = []
+        target_paths = []
+        while queue:
+            path = queue.pop(0)
+            node = path[-1]
+            if node in visited:
+                continue
+            visited.append(node)
+            if node.name == target_name:
+                if len(target_paths) == 0:
+                    target_paths.append(path)
+                if len(target_paths[-1]) == len(path):
+                    last_spec = MatchSpec.union((path[-1], target_paths[-1][-1]))[0]
+                    target_paths[-1][-1] = last_spec
+                else:
+                    target_paths.append(path)
+
+                found_all_targets = len(target_paths) == num_targets and \
+                    any(len(_) != len(path) for _ in queue)
+                if len(queue) == 0 or found_all_targets:
+                    return target_paths
+            sub_graph = dep_graph
+            for p in path[0:-1]:
+                sub_graph = sub_graph[p]
+            children = [_ for _ in sub_graph.get(node, {})]
+            if children is None:
+                continue
+            for adj in children:
+                if len(target_paths) < num_targets:
+                    new_path = list(path)
+                    new_path.append(adj)
+                    queue.append(new_path)
+        return target_paths
+
+    def build_graph_of_deps(self, spec):
+        dep_graph = {spec: {}}
+        all_deps = set()
+        queue = [[spec]]
+        while queue:
+            path = queue.pop(0)
+            sub_graph = dep_graph
+            for p in path:
+                sub_graph = sub_graph[p]
+            parent_node = path[-1]
+            matches = self.find_matches(parent_node)
+            for mat in matches:
+                if len(mat.depends) > 0:
+                    for i in mat.depends:
+                        new_node = MatchSpec(i)
+                        sub_graph.update({new_node: {}})
+                        all_deps.add(new_node)
+                        new_path = list(path)
+                        new_path.append(new_node)
+                        if len(new_path) <= context.unsatisfiable_hints_check_depth:
+                            queue.append(new_path)
+        return dep_graph, all_deps
+
+    def build_conflict_map(self, specs, specs_to_add=None, history_specs=None):
+        """Perform a deeper analysis on conflicting specifications, by attempting
+        to find the common dependencies that might be the cause of conflicts.
+
+        Args:
+            specs: An iterable of strings or MatchSpec objects to be tested.
+            It is assumed that the specs conflict.
+
+        Returns:
+            bad_deps: A list of lists of bad deps
+
+        Strategy:
+            If we're here, we know that the specs conflict. This could be because:
+            - One spec conflicts with another; e.g.
+                  ['numpy 1.5*', 'numpy >=1.6']
+            - One spec conflicts with a dependency of another; e.g.
+                  ['numpy 1.5*', 'scipy 0.12.0b1']
+            - Each spec depends on *the same package* but in a different way; e.g.,
+                  ['A', 'B'] where A depends on numpy 1.5, and B on numpy 1.6.
+            Technically, all three of these cases can be boiled down to the last
+            one if we treat the spec itself as one of the "dependencies". There
+            might be more complex reasons for a conflict, but this code only
+            considers the ones above.
+
+            The purpose of this code, then, is to identify packages (like numpy
+            above) that all of the specs depend on *but in different ways*. We
+            then identify the dependency chains that lead to those packages.
+        """
+        # if only a single package matches the spec use the packages depends
+        # rather than the spec itself
+        strict_channel_priority = context.channel_priority == ChannelPriority.STRICT
+
+        specs = set(specs) | (specs_to_add or set())
+        # Remove virtual packages
+        specs = set([spec for spec in specs if not spec.name.startswith('__')])
+        if len(specs) == 1:
+            matches = self.find_matches(next(iter(specs)))
+            if len(matches) == 1:
+                specs = set(self.ms_depends(matches[0]))
+        specs.update({_.to_match_spec() for _ in self._system_precs})
+        for spec in specs:
+            self._get_package_pool((spec, ))
+
+        dep_graph = {}
+        dep_list = {}
+        with tqdm(total=len(specs), desc="Building graph of deps",
+                  leave=False, disable=context.json) as t:
+            for spec in specs:
+                t.set_description("Examining {}".format(spec))
+                t.update()
+                dep_graph_for_spec, all_deps_for_spec = self.build_graph_of_deps(spec)
+                dep_graph.update(dep_graph_for_spec)
+                if dep_list.get(spec.name):
+                    dep_list[spec.name].append(spec)
+                else:
+                    dep_list[spec.name] = [spec]
+                for dep in all_deps_for_spec:
+                    if dep_list.get(dep.name):
+                        dep_list[dep.name].append(spec)
+                    else:
+                        dep_list[dep.name] = [spec]
+
+        chains = []
+        conflicting_pkgs_pkgs = {}
+        for k, v in dep_list.items():
+            set_v = frozenset(v)
+            # Packages probably conflicts if many specs depend on it
+            if len(set_v) > 1:
+                if conflicting_pkgs_pkgs.get(set_v) is None:
+                    conflicting_pkgs_pkgs[set_v] = [k]
+                else:
+                    conflicting_pkgs_pkgs[set_v].append(k)
+            # Conflict if required virtual package is not present
+            elif k.startswith("__") and any(s for s in set_v if s.name != k):
+                conflicting_pkgs_pkgs[set_v] = [k]
+
+        with tqdm(total=len(specs), desc="Determining conflicts",
+                  leave=False, disable=context.json) as t:
+            for roots, nodes in conflicting_pkgs_pkgs.items():
+                t.set_description("Examining conflict for {}".format(
+                    " ".join(_.name for _ in roots)))
+                t.update()
+                lroots = [_ for _ in roots]
+                current_shortest_chain = []
+                shortest_node = None
+                requested_spec_unsat = frozenset(nodes).intersection(set(_.name for _ in roots))
+                if requested_spec_unsat:
+                    chains.append([_ for _ in roots if _.name in requested_spec_unsat])
+                    shortest_node = chains[-1][0]
+                    for root in roots:
+                        if root != chains[0][0]:
+                            search_node = shortest_node.name
+                            num_occurances = dep_list[search_node].count(root)
+                            c = self.breadth_first_search_for_dep_graph(
+                                root, search_node, dep_graph, num_occurances)
+                            chains.extend(c)
+                else:
+                    for node in nodes:
+                        num_occurances = dep_list[node].count(lroots[0])
+                        chain = self.breadth_first_search_for_dep_graph(
+                            lroots[0], node, dep_graph, num_occurances)
+                        chains.extend(chain)
+                        if len(current_shortest_chain) == 0 or \
+                                len(chain) < len(current_shortest_chain):
+                            current_shortest_chain = chain
+                            shortest_node = node
+                    for root in lroots[1:]:
+                        num_occurances = dep_list[shortest_node].count(root)
+                        c = self.breadth_first_search_for_dep_graph(
+                            root, shortest_node, dep_graph, num_occurances)
+                        chains.extend(c)
+
+        bad_deps = self._classify_bad_deps(chains, specs_to_add, history_specs,
+                                           strict_channel_priority)
+        return bad_deps
+
+    def _get_strict_channel(self, package_name):
+        channel_name = None
+        try:
+            channel_name = self._strict_channel_cache[package_name]
+        except KeyError:
+            if package_name in self.groups:
+                all_channel_names = set(prec.channel.name for prec in self.groups[package_name])
+                by_cp = {self._channel_priorities_map.get(cn, 1): cn for cn in all_channel_names}
+                highest_priority = sorted(by_cp)[0]  # highest priority is the lowest number
+                channel_name = self._strict_channel_cache[package_name] = by_cp[highest_priority]
+        return channel_name
+
+    @memoizemethod
+    def _broader(self, ms, specs_by_name):
+        """prevent introduction of matchspecs that broaden our selection of choices"""
+        if not specs_by_name:
+            return False
+        return ms.strictness < specs_by_name[0].strictness
+
+    def _get_package_pool(self, specs):
+        specs = frozenset(specs)
+        if specs in self._pool_cache:
+            pool = self._pool_cache[specs]
+        else:
+            pool = self.get_reduced_index(specs)
+            grouped_pool = groupby(lambda x: x.name, pool)
+            pool = {k: set(v) for k, v in grouped_pool.items()}
+            self._pool_cache[specs] = pool
+        return pool
+
+    @time_recorder(module_name=__name__)
+    def get_reduced_index(self, explicit_specs, sort_by_exactness=True, exit_on_conflict=False):
+        # TODO: fix this import; this is bad
+        from .core.subdir_data import make_feature_record
+
+        strict_channel_priority = context.channel_priority == ChannelPriority.STRICT
+
+        cache_key = strict_channel_priority, tuple(explicit_specs)
+        if cache_key in self._reduced_index_cache:
+            return self._reduced_index_cache[cache_key]
+
+        if log.isEnabledFor(DEBUG):
+            log.debug('Retrieving packages for: %s', dashlist(
+                sorted(str(s) for s in explicit_specs)))
+
+        explicit_specs, features = self.verify_specs(explicit_specs)
+        filter_out = {prec: False if val else "feature not enabled"
+                      for prec, val in self.default_filter(features).items()}
+        snames = set()
+        top_level_spec = None
+        cp_filter_applied = set()  # values are package names
+        if sort_by_exactness:
+            # prioritize specs that are more exact.  Exact specs will evaluate to 3,
+            #    constrained specs will evaluate to 2, and name only will be 1
+            explicit_specs = sorted(list(explicit_specs), key=lambda x: (
+                exactness_and_number_of_deps(self, x), x.dist_str()), reverse=True)
+        # tuple because it needs to be hashable
+        explicit_specs = tuple(explicit_specs)
+
+        explicit_spec_package_pool = {}
+        for s in explicit_specs:
+            explicit_spec_package_pool[s.name] = explicit_spec_package_pool.get(
+                s.name, set()) | set(self.find_matches(s))
+
+        def filter_group(_specs):
+            # all _specs should be for the same package name
+            name = next(iter(_specs)).name
+            group = self.groups.get(name, ())
+
+            # implement strict channel priority
+            if group and strict_channel_priority and name not in cp_filter_applied:
+                sole_source_channel_name = self._get_strict_channel(name)
+                for prec in group:
+                    if prec.channel.name != sole_source_channel_name:
+                        filter_out[prec] = "removed due to strict channel priority"
+                cp_filter_applied.add(name)
+
+            # Prune packages that don't match any of the patterns,
+            # have unsatisfiable dependencies, or conflict with the explicit specs
+            nold = nnew = 0
+            for prec in group:
+                if not filter_out.setdefault(prec, False):
+                    nold += 1
+                    if (not self.match_any(_specs, prec)) or (
+                            explicit_spec_package_pool.get(name) and
+                            prec not in explicit_spec_package_pool[name]):
+                        filter_out[prec] = "incompatible with required spec %s" % top_level_spec
+                        continue
+                    unsatisfiable_dep_specs = set()
+                    for ms in self.ms_depends(prec):
+                        if not ms.optional and not any(
+                                 rec for rec in self.find_matches(ms)
+                                if not filter_out.get(rec, False)):
+                            unsatisfiable_dep_specs.add(ms)
+                    if unsatisfiable_dep_specs:
+                        filter_out[prec] = "unsatisfiable dependencies %s" % " ".join(
+                            str(s) for s in unsatisfiable_dep_specs
+                        )
+                        continue
+                    filter_out[prec] = False
+                    nnew += 1
+
+            reduced = nnew < nold
+            if reduced:
+                log.debug('%s: pruned from %d -> %d' % (name, nold, nnew))
+            if any(ms.optional for ms in _specs):
+                return reduced
+            elif nnew == 0:
+                # Indicates that a conflict was found; we can exit early
+                return None
+
+            # Perform the same filtering steps on any dependencies shared across
+            # *all* packages in the group. Even if just one of the packages does
+            # not have a particular dependency, it must be ignored in this pass.
+            # Otherwise, we might do more filtering than we should---and it is
+            # better to have extra packages here than missing ones.
+            if reduced or name not in snames:
+                snames.add(name)
+
+                _dep_specs = groupby(lambda s: s.name, (
+                    dep_spec
+                    for prec in group if not filter_out.get(prec, False)
+                    for dep_spec in self.ms_depends(prec) if not dep_spec.optional
+                ))
+                _dep_specs.pop("*", None)  # discard track_features specs
+
+                for deps_name, deps in sorted(_dep_specs.items(),
+                                              key=lambda x: any(_.optional for _ in x[1])):
+                    if len(deps) >= nnew:
+                        res = filter_group(set(deps))
+                        if res:
+                            reduced = True
+                        elif res is None:
+                            # Indicates that a conflict was found; we can exit early
+                            return None
+
+            return reduced
+
+        # Iterate on pruning until no progress is made. We've implemented
+        # what amounts to "double-elimination" here; packages get one additional
+        # chance after their first "False" reduction. This catches more instances
+        # where one package's filter affects another. But we don't have to be
+        # perfect about this, so performance matters.
+        pruned_to_zero = set()
+        for _ in range(2):
+            snames.clear()
+            slist = deque(explicit_specs)
+            while slist:
+                s = slist.popleft()
+                if filter_group([s]):
+                    slist.append(s)
+                else:
+                    pruned_to_zero.add(s)
+
+        if pruned_to_zero and exit_on_conflict:
+            return {}
+
+        # Determine all valid packages in the dependency graph
+        reduced_index2 = {prec: prec for prec in (make_feature_record(fstr) for fstr in features)}
+        specs_by_name_seed = OrderedDict()
+        for s in explicit_specs:
+            specs_by_name_seed[s.name] = specs_by_name_seed.get(s.name, list()) + [s]
+        for explicit_spec in explicit_specs:
+            add_these_precs2 = tuple(
+                prec for prec in self.find_matches(explicit_spec)
+                if prec not in reduced_index2 and self.valid2(prec, filter_out))
+
+            if strict_channel_priority and add_these_precs2:
+                strict_channel_name = self._get_strict_channel(add_these_precs2[0].name)
+
+                add_these_precs2 = tuple(
+                    prec for prec in add_these_precs2 if prec.channel.name == strict_channel_name
+                )
+            reduced_index2.update((prec, prec) for prec in add_these_precs2)
+
+            for pkg in add_these_precs2:
+                # what we have seen is only relevant within the context of a single package
+                #    that is picked up because of an explicit spec.  We don't want the
+                #    broadening check to apply across packages at the explicit level; only
+                #    at the level of deps below that explicit package.
+                seen_specs = set()
+                specs_by_name = copy.deepcopy(specs_by_name_seed)
+
+                dep_specs = set(self.ms_depends(pkg))
+                for dep in dep_specs:
+                    specs = specs_by_name.get(dep.name, list())
+                    if dep not in specs and (not specs or dep.strictness >= specs[0].strictness):
+                        specs.insert(0, dep)
+                    specs_by_name[dep.name] = specs
+
+                while dep_specs:
+                    # used for debugging
+                    # size_index = len(reduced_index2)
+                    # specs_added = []
+                    ms = dep_specs.pop()
+                    seen_specs.add(ms)
+                    for dep_pkg in (_ for _ in self.find_matches(ms) if _ not in reduced_index2):
+                        if not self.valid2(dep_pkg, filter_out):
+                            continue
+
+                        # expand the reduced index if not using strict channel priority,
+                        #    or if using it and this package is in the appropriate channel
+                        if (not strict_channel_priority or
+                                (self._get_strict_channel(dep_pkg.name) ==
+                                 dep_pkg.channel.name)):
+                            reduced_index2[dep_pkg] = dep_pkg
+
+                            # recurse to deps of this dep
+                            new_specs = set(self.ms_depends(dep_pkg)) - seen_specs
+                            for new_ms in new_specs:
+                                # We do not pull packages into the reduced index due
+                                # to a track_features dependency. Remember, a feature
+                                # specifies a "soft" dependency: it must be in the
+                                # environment, but it is not _pulled_ in. The SAT
+                                # logic doesn't do a perfect job of capturing this
+                                # behavior, but keeping these packags out of the
+                                # reduced index helps. Of course, if _another_
+                                # package pulls it in by dependency, that's fine.
+                                if ('track_features' not in new_ms and not self._broader(
+                                        new_ms, tuple(specs_by_name.get(new_ms.name, tuple())))):
+                                    dep_specs.add(new_ms)
+                                    # if new_ms not in dep_specs:
+                                    #     specs_added.append(new_ms)
+                                else:
+                                    seen_specs.add(new_ms)
+                    # debugging info - see what specs are bringing in the largest blobs
+                    # if size_index != len(reduced_index2):
+                    #     print("MS {} added {} pkgs to index".format(ms,
+                    #           len(reduced_index2) - size_index))
+                    # if specs_added:
+                    #     print("MS {} added {} specs to further examination".format(ms,
+                    #                                                                specs_added))
+
+        reduced_index2 = frozendict(reduced_index2)
+        self._reduced_index_cache[cache_key] = reduced_index2
+        return reduced_index2
+
+    def match_any(self, mss, prec):
+        return any(ms.match(prec) for ms in mss)
+
+    def find_matches(self, spec):
+        # type: (MatchSpec) -> Set[PackageRecord]
+        res = self._cached_find_matches.get(spec, None)
+        if res is not None:
+            return res
+
+        spec_name = spec.get_exact_value('name')
+        if spec_name:
+            candidate_precs = self.groups.get(spec_name, ())
+        elif spec.get_exact_value('track_features'):
+            feature_names = spec.get_exact_value('track_features')
+            candidate_precs = concat(
+                self.trackers.get(feature_name, ()) for feature_name in feature_names
+            )
+        else:
+            candidate_precs = self.index.values()
+
+        res = tuple(p for p in candidate_precs if spec.match(p))
+        self._cached_find_matches[spec] = res
+        return res
+
+    def ms_depends(self, prec):
+        # type: (PackageRecord) -> List[MatchSpec]
+        deps = self.ms_depends_.get(prec)
+        if deps is None:
+            deps = [MatchSpec(d) for d in prec.combined_depends]
+            deps.extend(MatchSpec(track_features=feat) for feat in prec.features)
+            self.ms_depends_[prec] = deps
+        return deps
+
+    def version_key(self, prec, vtype=None):
+        channel = prec.channel
+        channel_priority = self._channel_priorities_map.get(channel.name, 1)  # TODO: ask @mcg1969 why the default value is 1 here  # NOQA
+        valid = 1 if channel_priority < MAX_CHANNEL_PRIORITY else 0
+        version_comparator = VersionOrder(prec.get('version', ''))
+        build_number = prec.get('build_number', 0)
+        build_string = prec.get('build')
+        noarch = - int(prec.subdir == 'noarch')
+        if self._channel_priority != ChannelPriority.DISABLED:
+            vkey = [valid, -channel_priority, version_comparator, build_number, noarch]
+        else:
+            vkey = [valid, version_comparator, -channel_priority, build_number, noarch]
+        if self._solver_ignore_timestamps:
+            vkey.append(build_string)
+        else:
+            vkey.extend((prec.get('timestamp', 0), build_string))
+        return vkey
+
+    @staticmethod
+    def _make_channel_priorities(channels):
+        priorities_map = {}
+        for priority_counter, chn in enumerate(concat(
+            (Channel(cc) for cc in c._channels) if isinstance(c, MultiChannel) else (c,)
+            for c in (Channel(c) for c in channels)
+        )):
+            channel_name = chn.name
+            if channel_name in priorities_map:
+                continue
+            priorities_map[channel_name] = min(priority_counter, MAX_CHANNEL_PRIORITY - 1)
+        return priorities_map
+
+    def get_pkgs(self, ms, emptyok=False):  # pragma: no cover
+        # legacy method for conda-build
+        ms = MatchSpec(ms)
+        precs = self.find_matches(ms)
+        if not precs and not emptyok:
+            raise ResolvePackageNotFound([(ms,)])
+        return sorted(precs, key=self.version_key)
+
+    @staticmethod
+    def to_sat_name(val):
+        # val can be a PackageRecord or MatchSpec
+        if isinstance(val, PackageRecord):
+            return val.dist_str()
+        elif isinstance(val, MatchSpec):
+            return '@s@' + str(val) + ('?' if val.optional else '')
+        else:
+            raise NotImplementedError()
+
+    @staticmethod
+    def to_feature_metric_id(prec_dist_str, feat):
+        return '@fm@%s@%s' % (prec_dist_str, feat)
+
+    def push_MatchSpec(self, C, spec):
+        spec = MatchSpec(spec)
+        sat_name = self.to_sat_name(spec)
+        m = C.from_name(sat_name)
+        if m is not None:
+            # the spec has already been pushed onto the clauses stack
+            return sat_name
+
+        simple = spec._is_single()
+        nm = spec.get_exact_value('name')
+        tf = frozenset(_tf for _tf in (
+            f.strip() for f in spec.get_exact_value('track_features') or ()
+        ) if _tf)
+
+        if nm:
+            tgroup = libs = self.groups.get(nm, [])
+        elif tf:
+            assert len(tf) == 1
+            k = next(iter(tf))
+            tgroup = libs = self.trackers.get(k, [])
+        else:
+            tgroup = libs = self.index.keys()
+            simple = False
+        if not simple:
+            libs = [fkey for fkey in tgroup if spec.match(fkey)]
+        if len(libs) == len(tgroup):
+            if spec.optional:
+                m = TRUE
+            elif not simple:
+                ms2 = MatchSpec(track_features=tf) if tf else MatchSpec(nm)
+                m = C.from_name(self.push_MatchSpec(C, ms2))
+        if m is None:
+            sat_names = [self.to_sat_name(prec) for prec in libs]
+            if spec.optional:
+                ms2 = MatchSpec(track_features=tf) if tf else MatchSpec(nm)
+                sat_names.append('!' + self.to_sat_name(ms2))
+            m = C.Any(sat_names)
+        C.name_var(m, sat_name)
+        return sat_name
+
+    @time_recorder(module_name=__name__)
+    def gen_clauses(self):
+        C = Clauses(sat_solver=_get_sat_solver_cls(context.sat_solver))
+        for name, group in self.groups.items():
+            group = [self.to_sat_name(prec) for prec in group]
+            # Create one variable for each package
+            for sat_name in group:
+                C.new_var(sat_name)
+            # Create one variable for the group
+            m = C.new_var(self.to_sat_name(MatchSpec(name)))
+
+            # Exactly one of the package variables, OR
+            # the negation of the group variable, is true
+            C.Require(C.ExactlyOne, group + [C.Not(m)])
+
+        # If a package is installed, its dependencies must be as well
+        for prec in self.index.values():
+            nkey = C.Not(self.to_sat_name(prec))
+            for ms in self.ms_depends(prec):
+                # Virtual packages can't be installed, we ignore them
+                if not ms.name.startswith('__'):
+                    C.Require(C.Or, nkey, self.push_MatchSpec(C, ms))
+
+        if log.isEnabledFor(DEBUG):
+            log.debug("gen_clauses returning with clause count: %d", C.get_clause_count())
+        return C
+
+    def generate_spec_constraints(self, C, specs):
+        result = [(self.push_MatchSpec(C, ms),) for ms in specs]
+        if log.isEnabledFor(DEBUG):
+            log.debug(
+                "generate_spec_constraints returning with clause count: %d",
+                C.get_clause_count())
+        return result
+
+    def generate_feature_count(self, C):
+        result = {self.push_MatchSpec(C, MatchSpec(track_features=name)): 1
+                  for name in self.trackers.keys()}
+        if log.isEnabledFor(DEBUG):
+            log.debug(
+                "generate_feature_count returning with clause count: %d", C.get_clause_count())
+        return result
+
+    def generate_update_count(self, C, specs):
+        return {'!'+ms.target: 1 for ms in specs if ms.target and C.from_name(ms.target)}
+
+    def generate_feature_metric(self, C):
+        eq = {}  # a C.minimize() objective: Dict[varname, coeff]
+        # Given a pair (prec, feature), assign a "1" score IF:
+        # - The prec is installed
+        # - The prec does NOT require the feature
+        # - At least one package in the group DOES require the feature
+        # - A package that tracks the feature is installed
+        for name, group in self.groups.items():
+            prec_feats = {self.to_sat_name(prec): set(prec.features) for prec in group}
+            active_feats = set.union(*prec_feats.values()).intersection(self.trackers)
+            for feat in active_feats:
+                clause_id_for_feature = self.push_MatchSpec(C, MatchSpec(track_features=feat))
+                for prec_sat_name, features in prec_feats.items():
+                    if feat not in features:
+                        feature_metric_id = self.to_feature_metric_id(prec_sat_name, feat)
+                        C.name_var(C.And(prec_sat_name, clause_id_for_feature), feature_metric_id)
+                        eq[feature_metric_id] = 1
+        return eq
+
+    def generate_removal_count(self, C, specs):
+        return {'!'+self.push_MatchSpec(C, ms.name): 1 for ms in specs}
+
+    def generate_install_count(self, C, specs):
+        return {self.push_MatchSpec(C, ms.name): 1 for ms in specs if ms.optional}
+
+    def generate_package_count(self, C, missing):
+        return {self.push_MatchSpec(C, nm): 1 for nm in missing}
+
+    def generate_version_metrics(self, C, specs, include0=False):
+        # each of these are weights saying how well packages match the specs
+        #    format for each: a C.minimize() objective: Dict[varname, coeff]
+        eqc = {}  # channel
+        eqv = {}  # version
+        eqb = {}  # build number
+        eqa = {}  # arch/noarch
+        eqt = {}  # timestamp
+
+        sdict = {}  # Dict[package_name, PackageRecord]
+
+        for s in specs:
+            s = MatchSpec(s)  # needed for testing
+            sdict.setdefault(s.name, [])
+            # # TODO: this block is important! can't leave it commented out
+            # rec = sdict.setdefault(s.name, [])
+            # if s.target:
+            #     dist = Dist(s.target)
+            #     if dist in self.index:
+            #         if self.index[dist].get('priority', 0) < MAX_CHANNEL_PRIORITY:
+            #             rec.append(dist)
+
+        for name, targets in sdict.items():
+            pkgs = [(self.version_key(p), p) for p in self.groups.get(name, [])]
+            pkey = None
+            # keep in mind that pkgs is already sorted according to version_key (a tuple,
+            #    so composite sort key).  Later entries in the list are, by definition,
+            #    greater in some way, so simply comparing with != suffices.
+            for version_key, prec in pkgs:
+                if targets and any(prec == t for t in targets):
+                    continue
+                if pkey is None:
+                    ic = iv = ib = it = ia = 0
+                # valid package, channel priority
+                elif pkey[0] != version_key[0] or pkey[1] != version_key[1]:
+                    ic += 1
+                    iv = ib = it = ia = 0
+                # version
+                elif pkey[2] != version_key[2]:
+                    iv += 1
+                    ib = it = ia = 0
+                # build number
+                elif pkey[3] != version_key[3]:
+                    ib += 1
+                    it = ia = 0
+                # arch/noarch
+                elif pkey[4] != version_key[4]:
+                    ia += 1
+                    it = 0
+                elif not self._solver_ignore_timestamps and pkey[5] != version_key[5]:
+                    it += 1
+
+                prec_sat_name = self.to_sat_name(prec)
+                if ic or include0:
+                    eqc[prec_sat_name] = ic
+                if iv or include0:
+                    eqv[prec_sat_name] = iv
+                if ib or include0:
+                    eqb[prec_sat_name] = ib
+                if ia or include0:
+                    eqa[prec_sat_name] = ia
+                if it or include0:
+                    eqt[prec_sat_name] = it
+                pkey = version_key
+
+        return eqc, eqv, eqb, eqa, eqt
+
+    def dependency_sort(self, must_have):
+        # type: (Dict[package_name, PackageRecord]) -> List[PackageRecord]
+        assert isinstance(must_have, dict)
+
+        digraph = {}  # Dict[package_name, Set[dependent_package_names]]
+        for package_name, prec in must_have.items():
+            if prec in self.index:
+                digraph[package_name] = set(ms.name for ms in self.ms_depends(prec))
+
+        # There are currently at least three special cases to be aware of.
+        # 1. The `toposort()` function, called below, contains special case code to remove
+        #    any circular dependency between python and pip.
+        # 2. conda/plan.py has special case code for menuinst
+        #       Always link/unlink menuinst first/last on windows in case a subsequent
+        #       package tries to import it to create/remove a shortcut
+        # 3. On windows, python noarch packages need an implicit dependency on conda added, if
+        #    conda is in the list of packages for the environment.  Python noarch packages
+        #    that have entry points use conda's own conda.exe python entry point binary. If conda
+        #    is going to be updated during an operation, the unlink / link order matters.
+        #    See issue #6057.
+
+        if on_win and 'conda' in digraph:
+            for package_name, dist in must_have.items():
+                record = self.index.get(prec)
+                if hasattr(record, 'noarch') and record.noarch == NoarchType.python:
+                    digraph[package_name].add('conda')
+
+        sorted_keys = toposort(digraph)
+        must_have = must_have.copy()
+        # Take all of the items in the sorted keys
+        # Don't fail if the key does not exist
+        result = [must_have.pop(key) for key in sorted_keys if key in must_have]
+        # Take any key that were not sorted
+        result.extend(must_have.values())
+        return result
+
+    def environment_is_consistent(self, installed):
+        log.debug('Checking if the current environment is consistent')
+        if not installed:
+            return None, []
+        sat_name_map = {}  # Dict[sat_name, PackageRecord]
+        specs = []
+        for prec in installed:
+            sat_name_map[self.to_sat_name(prec)] = prec
+            specs.append(MatchSpec('%s %s %s' % (prec.name, prec.version, prec.build)))
+        r2 = Resolve(OrderedDict((prec, prec) for prec in installed), True, channels=self.channels)
+        C = r2.gen_clauses()
+        constraints = r2.generate_spec_constraints(C, specs)
+        solution = C.sat(constraints)
+        return bool(solution)
+
+    def get_conflicting_specs(self, specs, explicit_specs):
+        if not specs:
+            return ()
+
+        all_specs = set(specs) | set(explicit_specs)
+        reduced_index = self.get_reduced_index(all_specs)
+
+        # Check if satisfiable
+        def mysat(specs, add_if=False):
+            constraints = r2.generate_spec_constraints(C, specs)
+            return C.sat(constraints, add_if)
+
+        if reduced_index:
+            r2 = Resolve(reduced_index, True, channels=self.channels)
+            C = r2.gen_clauses()
+            solution = mysat(all_specs, True)
+        else:
+            solution = None
+
+        if solution:
+            final_unsat_specs = ()
+        elif context.unsatisfiable_hints:
+            r2 = Resolve(self.index, True, channels=self.channels)
+            C = r2.gen_clauses()
+            # This first result is just a single unsatisfiable core. There may be several.
+            final_unsat_specs = tuple(minimal_unsatisfiable_subset(specs, sat=mysat,
+                                                                   explicit_specs=explicit_specs))
+        else:
+            final_unsat_specs = None
+        return final_unsat_specs
+
+    def bad_installed(self, installed, new_specs):
+        log.debug('Checking if the current environment is consistent')
+        if not installed:
+            return None, []
+        sat_name_map = {}  # Dict[sat_name, PackageRecord]
+        specs = []
+        for prec in installed:
+            sat_name_map[self.to_sat_name(prec)] = prec
+            specs.append(MatchSpec('%s %s %s' % (prec.name, prec.version, prec.build)))
+        new_index = {prec: prec for prec in sat_name_map.values()}
+        name_map = {p.name: p for p in new_index}
+        if 'python' in name_map and 'pip' not in name_map:
+            python_prec = new_index[name_map['python']]
+            if 'pip' in python_prec.depends:
+                # strip pip dependency from python if not installed in environment
+                new_deps = [d for d in python_prec.depends if d != 'pip']
+                python_prec.depends = new_deps
+        r2 = Resolve(new_index, True, channels=self.channels)
+        C = r2.gen_clauses()
+        constraints = r2.generate_spec_constraints(C, specs)
+        solution = C.sat(constraints)
+        limit = xtra = None
+        if not solution or xtra:
+            def get_(name, snames):
+                if name not in snames:
+                    snames.add(name)
+                    for fn in self.groups.get(name, []):
+                        for ms in self.ms_depends(fn):
+                            get_(ms.name, snames)
+            # New addition: find the largest set of installed packages that
+            # are consistent with each other, and include those in the
+            # list of packages to maintain consistency with
+            snames = set()
+            eq_optional_c = r2.generate_removal_count(C, specs)
+            solution, _ = C.minimize(eq_optional_c, C.sat())
+            snames.update(sat_name_map[sat_name]['name']
+                          for sat_name in (C.from_index(s) for s in solution)
+                          if sat_name and sat_name[0] != '!' and '@' not in sat_name)
+            # Existing behavior: keep all specs and their dependencies
+            for spec in new_specs:
+                get_(MatchSpec(spec).name, snames)
+            if len(snames) < len(sat_name_map):
+                limit = snames
+                xtra = [rec for sat_name, rec in sat_name_map.items()
+                        if rec['name'] not in snames]
+                log.debug('Limiting solver to the following packages: %s', ', '.join(limit))
+        if xtra:
+            log.debug('Packages to be preserved: %s', xtra)
+        return limit, xtra
+
+    def restore_bad(self, pkgs, preserve):
+        if preserve:
+            sdict = {prec.name: prec for prec in pkgs}
+            pkgs.extend(p for p in preserve if p.name not in sdict)
+
+    def install_specs(self, specs, installed, update_deps=True):
+        specs = list(map(MatchSpec, specs))
+        snames = {s.name for s in specs}
+        log.debug('Checking satisfiability of current install')
+        limit, preserve = self.bad_installed(installed, specs)
+        for prec in installed:
+            if prec not in self.index:
+                continue
+            name, version, build = prec.name, prec.version, prec.build
+            schannel = prec.channel.canonical_name
+            if name in snames or limit is not None and name not in limit:
+                continue
+            # If update_deps=True, set the target package in MatchSpec so that
+            # the solver can minimize the version change. If update_deps=False,
+            # fix the version and build so that no change is possible.
+            if update_deps:
+                # TODO: fix target here
+                spec = MatchSpec(name=name, target=prec.dist_str())
+            else:
+                spec = MatchSpec(name=name, version=version,
+                                 build=build, channel=schannel)
+            specs.insert(0, spec)
+        return tuple(specs), preserve
+
+    def install(self, specs, installed=None, update_deps=True, returnall=False):
+        specs, preserve = self.install_specs(specs, installed or [], update_deps)
+        pkgs = []
+        if specs:
+            pkgs = self.solve(specs, returnall=returnall, _remove=False)
+        self.restore_bad(pkgs, preserve)
+        return pkgs
+
+    def remove_specs(self, specs, installed):
+        nspecs = []
+        # There's an imperfect thing happening here. "specs" nominally contains
+        # a list of package names or track_feature values to be removed. But
+        # because of add_defaults_to_specs it may also contain version constraints
+        # like "python 2.7*", which are *not* asking for python to be removed.
+        # We need to separate these two kinds of specs here.
+        for s in map(MatchSpec, specs):
+            # Since '@' is an illegal version number, this ensures that all of
+            # these matches will never match an actual package. Combined with
+            # optional=True, this has the effect of forcing their removal.
+            if s._is_single():
+                nspecs.append(MatchSpec(s, version='@', optional=True))
+            else:
+                nspecs.append(MatchSpec(s, optional=True))
+        snames = set(s.name for s in nspecs if s.name)
+        limit, _ = self.bad_installed(installed, nspecs)
+        preserve = []
+        for prec in installed:
+            nm, ver = prec.name, prec.version
+            if nm in snames:
+                continue
+            elif limit is not None:
+                preserve.append(prec)
+            else:
+                # TODO: fix target here
+                nspecs.append(MatchSpec(name=nm,
+                                        version='>='+ver if ver else None,
+                                        optional=True,
+                                        target=prec.dist_str()))
+        return nspecs, preserve
+
+    def remove(self, specs, installed):
+        specs, preserve = self.remove_specs(specs, installed)
+        pkgs = self.solve(specs, _remove=True)
+        self.restore_bad(pkgs, preserve)
+        return pkgs
+
+    @time_recorder(module_name=__name__)
+    def solve(self, specs, returnall=False, _remove=False, specs_to_add=None, history_specs=None,
+              should_retry_solve=False):
+        # type: (List[str], bool) -> List[PackageRecord]
+
+        if specs and not isinstance(specs[0], MatchSpec):
+            specs = tuple(MatchSpec(_) for _ in specs)
+
+        specs = set(specs)
+        if log.isEnabledFor(DEBUG):
+            dlist = dashlist(str(
+                '%i: %s target=%s optional=%s' % (i, s, s.target, s.optional))
+                for i, s in enumerate(specs))
+            log.debug('Solving for: %s', dlist)
+
+        if not specs:
+            return tuple()
+
+        # Find the compliant packages
+        log.debug("Solve: Getting reduced index of compliant packages")
+        len0 = len(specs)
+
+        reduced_index = self.get_reduced_index(
+            specs, exit_on_conflict=not context.unsatisfiable_hints)
+        if not reduced_index:
+            # something is intrinsically unsatisfiable - either not found or
+            # not the right version
+            not_found_packages = set()
+            wrong_version_packages = set()
+            for s in specs:
+                if not self.find_matches(s):
+                    if s.name in self.groups:
+                        wrong_version_packages.add(s)
+                    else:
+                        not_found_packages.add(s)
+            if not_found_packages:
+                raise ResolvePackageNotFound(not_found_packages)
+            elif wrong_version_packages:
+                raise UnsatisfiableError([[d] for d in wrong_version_packages], chains=False)
+            if should_retry_solve:
+                # We don't want to call find_conflicts until our last try.
+                # This jumps back out to conda/cli/install.py, where the
+                # retries happen
+                raise UnsatisfiableError({})
+            else:
+                self.find_conflicts(specs, specs_to_add, history_specs)
+
+        # Check if satisfiable
+        log.debug("Solve: determining satisfiability")
+
+        def mysat(specs, add_if=False):
+            constraints = r2.generate_spec_constraints(C, specs)
+            return C.sat(constraints, add_if)
+
+        # Return a solution of packages
+        def clean(sol):
+            return [q for q in (C.from_index(s) for s in sol)
+                    if q and q[0] != '!' and '@' not in q]
+
+        def is_converged(solution):
+            """ Determine if the SAT problem has converged to a single solution.
+
+            This is determined by testing for a SAT solution with the current
+            clause set and a clause in which at least one of the packages in
+            the current solution is excluded. If a solution exists the problem
+            has not converged as multiple solutions still exist.
+            """
+            psolution = clean(solution)
+            nclause = tuple(C.Not(C.from_name(q)) for q in psolution)
+            if C.sat((nclause,), includeIf=False) is None:
+                return True
+            return False
+
+        r2 = Resolve(reduced_index, True, channels=self.channels)
+        C = r2.gen_clauses()
+        solution = mysat(specs, True)
+        if not solution:
+            if should_retry_solve:
+                # we don't want to call find_conflicts until our last try
+                raise UnsatisfiableError({})
+            else:
+                self.find_conflicts(specs, specs_to_add, history_specs)
+
+        speco = []  # optional packages
+        specr = []  # requested packages
+        speca = []  # all other packages
+        specm = set(r2.groups)  # missing from specs
+        for k, s in enumerate(specs):
+            if s.name in specm:
+                specm.remove(s.name)
+            if not s.optional:
+                (speca if s.target or k >= len0 else specr).append(s)
+            elif any(r2.find_matches(s)):
+                s = MatchSpec(s.name, optional=True, target=s.target)
+                speco.append(s)
+                speca.append(s)
+        speca.extend(MatchSpec(s) for s in specm)
+
+        if log.isEnabledFor(DEBUG):
+            log.debug('Requested specs: %s', dashlist(sorted(str(s) for s in specr)))
+            log.debug('Optional specs: %s', dashlist(sorted(str(s) for s in speco)))
+            log.debug('All other specs: %s', dashlist(sorted(str(s) for s in speca)))
+            log.debug('missing specs: %s', dashlist(sorted(str(s) for s in specm)))
+
+        # Removed packages: minimize count
+        log.debug("Solve: minimize removed packages")
+        if _remove:
+            eq_optional_c = r2.generate_removal_count(C, speco)
+            solution, obj7 = C.minimize(eq_optional_c, solution)
+            log.debug('Package removal metric: %d', obj7)
+
+        # Requested packages: maximize versions
+        log.debug("Solve: maximize versions of requested packages")
+        eq_req_c, eq_req_v, eq_req_b, eq_req_a, eq_req_t = r2.generate_version_metrics(C, specr)
+        solution, obj3a = C.minimize(eq_req_c, solution)
+        solution, obj3 = C.minimize(eq_req_v, solution)
+        log.debug('Initial package channel/version metric: %d/%d', obj3a, obj3)
+
+        # Track features: minimize feature count
+        log.debug("Solve: minimize track_feature count")
+        eq_feature_count = r2.generate_feature_count(C)
+        solution, obj1 = C.minimize(eq_feature_count, solution)
+        log.debug('Track feature count: %d', obj1)
+
+        # Featured packages: minimize number of featureless packages
+        # installed when a featured alternative is feasible.
+        # For example, package name foo exists with two built packages. One with
+        # 'track_features: 'feat1', and one with 'track_features': 'feat2'.
+        # The previous "Track features" minimization pass has chosen 'feat1' for the
+        # environment, but not 'feat2'. In this case, the 'feat2' version of foo is
+        # considered "featureless."
+        eq_feature_metric = r2.generate_feature_metric(C)
+        solution, obj2 = C.minimize(eq_feature_metric, solution)
+        log.debug('Package misfeature count: %d', obj2)
+
+        # Requested packages: maximize builds
+        log.debug("Solve: maximize build numbers of requested packages")
+        solution, obj4 = C.minimize(eq_req_b, solution)
+        log.debug('Initial package build metric: %d', obj4)
+
+        # prefer arch packages where available for requested specs
+        log.debug("Solve: prefer arch over noarch for requested packages")
+        solution, noarch_obj = C.minimize(eq_req_a, solution)
+        log.debug('Noarch metric: %d', noarch_obj)
+
+        # Optional installations: minimize count
+        if not _remove:
+            log.debug("Solve: minimize number of optional installations")
+            eq_optional_install = r2.generate_install_count(C, speco)
+            solution, obj49 = C.minimize(eq_optional_install, solution)
+            log.debug('Optional package install metric: %d', obj49)
+
+        # Dependencies: minimize the number of packages that need upgrading
+        log.debug("Solve: minimize number of necessary upgrades")
+        eq_u = r2.generate_update_count(C, speca)
+        solution, obj50 = C.minimize(eq_u, solution)
+        log.debug('Dependency update count: %d', obj50)
+
+        # Remaining packages: maximize versions, then builds
+        log.debug("Solve: maximize versions and builds of indirect dependencies.  "
+                  "Prefer arch over noarch where equivalent.")
+        eq_c, eq_v, eq_b, eq_a, eq_t = r2.generate_version_metrics(C, speca)
+        solution, obj5a = C.minimize(eq_c, solution)
+        solution, obj5 = C.minimize(eq_v, solution)
+        solution, obj6 = C.minimize(eq_b, solution)
+        solution, obj6a = C.minimize(eq_a, solution)
+        log.debug('Additional package channel/version/build/noarch metrics: %d/%d/%d/%d',
+                  obj5a, obj5, obj6, obj6a)
+
+        # Prune unnecessary packages
+        log.debug("Solve: prune unnecessary packages")
+        eq_c = r2.generate_package_count(C, specm)
+        solution, obj7 = C.minimize(eq_c, solution, trymax=True)
+        log.debug('Weak dependency count: %d', obj7)
+
+        if not is_converged(solution):
+            # Maximize timestamps
+            eq_t.update(eq_req_t)
+            solution, obj6t = C.minimize(eq_t, solution)
+            log.debug('Timestamp metric: %d', obj6t)
+
+        log.debug('Looking for alternate solutions')
+        nsol = 1
+        psolutions = []
+        psolution = clean(solution)
+        psolutions.append(psolution)
+        while True:
+            nclause = tuple(C.Not(C.from_name(q)) for q in psolution)
+            solution = C.sat((nclause,), True)
+            if solution is None:
+                break
+            nsol += 1
+            if nsol > 10:
+                log.debug('Too many solutions; terminating')
+                break
+            psolution = clean(solution)
+            psolutions.append(psolution)
+
+        if nsol > 1:
+            psols2 = list(map(set, psolutions))
+            common = set.intersection(*psols2)
+            diffs = [sorted(set(sol) - common) for sol in psols2]
+            if not context.json:
+                stdoutlog.info(
+                    '\nWarning: %s possible package resolutions '
+                    '(only showing differing packages):%s%s' %
+                    ('>10' if nsol > 10 else nsol,
+                     dashlist(', '.join(diff) for diff in diffs),
+                     '\n  ... and others' if nsol > 10 else ''))
+
+        # def stripfeat(sol):
+        #     return sol.split('[')[0]
+
+        new_index = {self.to_sat_name(prec): prec for prec in self.index.values()}
+
+        if returnall:
+            if len(psolutions) > 1:
+                raise RuntimeError()
+            # TODO: clean up this mess
+            # return [sorted(Dist(stripfeat(dname)) for dname in psol) for psol in psolutions]
+            # return [sorted((new_index[sat_name] for sat_name in psol), key=lambda x: x.name)
+            #         for psol in psolutions]
+
+            # return sorted(Dist(stripfeat(dname)) for dname in psolutions[0])
+        return sorted((new_index[sat_name] for sat_name in psolutions[0]), key=lambda x: x.name)

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

@@ -0,0 +1,531 @@
+# -*- coding: utf-8 -*-
+# Copyright (C) 2012 Anaconda, Inc
+# SPDX-License-Identifier: BSD-3-Clause
+from __future__ import absolute_import, division, print_function, unicode_literals
+
+from contextlib import contextmanager
+from functools import lru_cache, wraps
+import logging
+from os.path import abspath, join, isfile, basename, dirname
+from os import environ
+from pathlib import Path
+import re
+import sys
+
+from . import CondaError
+from .auxlib.compat import shlex_split_unicode, Utf8NamedTemporaryFile
+from .common.compat import on_win, isiterable
+from .common.path import win_path_to_unix, which
+from .common.url import path_to_url
+
+log = logging.getLogger(__name__)
+
+def path_identity(path):
+    """Used as a dummy path converter where no conversion necessary"""
+    return path
+
+
+def unix_path_to_win(path, root_prefix=""):
+    """Convert a path or :-separated string of paths into a Windows representation
+
+    Does not add cygdrive.  If you need that, set root_prefix to "/cygdrive"
+    """
+    if len(path) > 1 and (";" in path or (path[1] == ":" and path.count(":") == 1)):
+        # already a windows path
+        return path.replace("/", "\\")
+    path_re = root_prefix + r'(/[a-zA-Z]/(?:(?![:\s]/)[^:*?"<>])*)'
+
+    def _translation(found_path):
+        group = found_path.group(0)
+        return "{0}:{1}".format(group[len(root_prefix)+1],
+                                group[len(root_prefix)+2:].replace("/", "\\"))
+    translation = re.sub(path_re, _translation, path)
+    translation = re.sub(":([a-zA-Z]):\\\\",
+                         lambda match: ";" + match.group(0)[1] + ":\\",
+                         translation)
+    return translation
+
+
+# curry cygwin functions
+def win_path_to_cygwin(path):
+    return win_path_to_unix(path, "/cygdrive")
+
+
+def cygwin_path_to_win(path):
+    return unix_path_to_win(path, "/cygdrive")
+
+
+def translate_stream(stream, translator):
+    return "\n".join(translator(line) for line in stream.split("\n"))
+
+
+def human_bytes(n):
+    """
+    Return the number of bytes n in more human readable form.
+
+    Examples:
+        >>> human_bytes(42)
+        '42 B'
+        >>> human_bytes(1042)
+        '1 KB'
+        >>> human_bytes(10004242)
+        '9.5 MB'
+        >>> human_bytes(100000004242)
+        '93.13 GB'
+    """
+    if n < 1024:
+        return '%d B' % n
+    k = n/1024
+    if k < 1024:
+        return '%d KB' % round(k)
+    m = k/1024
+    if m < 1024:
+        return '%.1f MB' % m
+    g = m/1024
+    return '%.2f GB' % g
+
+
+# TODO: this should be done in a more extensible way
+#     (like files for each shell, with some registration mechanism.)
+
+# defaults for unix shells.  Note: missing "exe" entry, which should be set to
+#    either an executable on PATH, or a full path to an executable for a shell
+unix_shell_base = dict(
+                       binpath="/bin/",  # mind the trailing slash.
+                       echo="echo",
+                       env_script_suffix=".sh",
+                       nul='2>/dev/null',
+                       path_from=path_identity,
+                       path_to=path_identity,
+                       pathsep=":",
+                       printdefaultenv='echo $CONDA_DEFAULT_ENV',
+                       printpath="echo $PATH",
+                       printps1='echo $CONDA_PROMPT_MODIFIER',
+                       promptvar='PS1',
+                       sep="/",
+                       set_var='export ',
+                       shell_args=["-l", "-c"],
+                       shell_suffix="",
+                       slash_convert=("\\", "/"),
+                       source_setup="source",
+                       test_echo_extra="",
+                       var_format="${}",
+)
+
+msys2_shell_base = dict(
+                        unix_shell_base,
+                        path_from=unix_path_to_win,
+                        path_to=win_path_to_unix,
+                        binpath="/bin/",  # mind the trailing slash.
+                        printpath="python -c \"import os; print(';'.join(os.environ['PATH'].split(';')[1:]))\" | cygpath --path -f -",  # NOQA
+)
+
+if on_win:
+    shells = {
+        # "powershell.exe": dict(
+        #    echo="echo",
+        #    test_echo_extra=" .",
+        #    var_format="${var}",
+        #    binpath="/bin/",  # mind the trailing slash.
+        #    source_setup="source",
+        #    nul='2>/dev/null',
+        #    set_var='export ',
+        #    shell_suffix=".ps",
+        #    env_script_suffix=".ps",
+        #    printps1='echo $PS1',
+        #    printdefaultenv='echo $CONDA_DEFAULT_ENV',
+        #    printpath="echo %PATH%",
+        #    exe="powershell.exe",
+        #    path_from=path_identity,
+        #    path_to=path_identity,
+        #    slash_convert = ("/", "\\"),
+        # ),
+        "cmd.exe": dict(
+            echo="@echo",
+            var_format="%{}%",
+            binpath="\\Scripts\\",  # mind the trailing slash.
+            source_setup="call",
+            test_echo_extra="",
+            nul='1>NUL 2>&1',
+            set_var='set ',
+            shell_suffix=".bat",
+            env_script_suffix=".bat",
+            printps1="@echo %PROMPT%",
+            promptvar="PROMPT",
+            # parens mismatched intentionally.  See http://stackoverflow.com/questions/20691060/how-do-i-echo-a-blank-empty-line-to-the-console-from-a-windows-batch-file # NOQA
+            printdefaultenv='IF NOT "%CONDA_DEFAULT_ENV%" == "" (\n'
+                            'echo %CONDA_DEFAULT_ENV% ) ELSE (\n'
+                            'echo()',
+            printpath="@echo %PATH%",
+            exe="cmd.exe",
+            shell_args=["/d", "/c"],
+            path_from=path_identity,
+            path_to=path_identity,
+            slash_convert=("/", "\\"),
+            sep="\\",
+            pathsep=";",
+        ),
+        "cygwin": dict(
+            unix_shell_base,
+            exe="bash.exe",
+            binpath="/Scripts/",  # mind the trailing slash.
+            path_from=cygwin_path_to_win,
+            path_to=win_path_to_cygwin
+        ),
+        # bash is whichever bash is on PATH.  If using Cygwin, you should use the cygwin
+        #    entry instead.  The only major difference is that it handle's cygwin's /cygdrive
+        #    filesystem root.
+        "bash.exe": dict(
+            msys2_shell_base, exe="bash.exe",
+        ),
+        "bash": dict(
+            msys2_shell_base, exe="bash",
+        ),
+        "sh.exe": dict(
+            msys2_shell_base, exe="sh.exe",
+        ),
+        "zsh.exe": dict(
+            msys2_shell_base, exe="zsh.exe",
+        ),
+        "zsh": dict(
+            msys2_shell_base, exe="zsh",
+        ),
+    }
+
+else:
+    shells = {
+        "bash": dict(
+            unix_shell_base, exe="bash",
+        ),
+        "dash": dict(
+            unix_shell_base, exe="dash",
+            source_setup=".",
+        ),
+        "zsh": dict(
+            unix_shell_base, exe="zsh",
+        ),
+        "fish": dict(
+            unix_shell_base, exe="fish",
+            pathsep=" ",
+        ),
+    }
+
+
+# ##########################################
+# put back because of conda build
+# ##########################################
+
+urlpath = url_path = path_to_url
+
+
+def md5_file(path):  # pragma: no cover
+    from .gateways.disk.read import compute_md5sum
+    return compute_md5sum(path)
+
+
+def hashsum_file(path, mode='md5'):  # pragma: no cover
+    import hashlib
+    h = hashlib.new(mode)
+    with open(path, 'rb') as fi:
+        while True:
+            chunk = fi.read(262144)  # process chunks of 256KB
+            if not chunk:
+                break
+            h.update(chunk)
+    return h.hexdigest()
+
+
+@lru_cache(maxsize=None)
+def sys_prefix_unfollowed():
+    """Since conda is installed into non-root environments as a symlink only
+    and because sys.prefix follows symlinks, this function can be used to
+    get the 'unfollowed' sys.prefix.
+
+    This value is usually the same as the prefix of the environment into
+    which conda has been symlinked. An example of when this is necessary
+    is when conda looks for external sub-commands in find_commands.py
+    """
+    try:
+        frame = next(iter(sys._current_frames().values()))
+        while frame.f_back:
+            frame = frame.f_back
+        code = frame.f_code
+        filename = code.co_filename
+        unfollowed = dirname(dirname(filename))
+    except Exception:
+        return sys.prefix
+    return unfollowed
+
+
+def quote_for_shell(*arguments):
+    """Properly quote arguments for command line passing.
+
+    For POSIX uses `shlex.join`, for Windows uses a custom implementation to properly escape
+    metacharacters.
+
+    :param arguments: Arguments to quote.
+    :type arguments: list of str
+    :return: Quoted arguments.
+    :rtype: str
+    """
+    # [backport] Support passing in a list of strings or args of string.
+    if len(arguments) == 1 and isiterable(arguments[0]):
+        arguments = arguments[0]
+
+    return _args_join(arguments)
+
+
+if on_win:
+    # https://ss64.com/nt/syntax-esc.html
+    # https://docs.microsoft.com/en-us/archive/blogs/twistylittlepassagesallalike/everyone-quotes-command-line-arguments-the-wrong-way
+
+    _RE_UNSAFE = re.compile(r'["%\s^<>&|]')
+    _RE_DBL = re.compile(r'(["%])')
+
+    def _args_join(args):
+        """Return a shell-escaped string from *args*."""
+
+        def quote(s):
+            # derived from shlex.quote
+            if not s:
+                return '""'
+            # if any unsafe chars are present we must quote
+            if not _RE_UNSAFE.search(s):
+                return s
+            # double escape (" -> "")
+            s = _RE_DBL.sub(r"\1\1", s)
+            # quote entire string
+            return f'"{s}"'
+
+        return " ".join(quote(arg) for arg in args)
+else:
+    try:
+        from shlex import join as _args_join
+    except ImportError:
+        # [backport] Python <3.8
+        def _args_join(args):
+            """Return a shell-escaped string from *args*."""
+            from shlex import quote
+
+            return " ".join(quote(arg) for arg in args)
+
+
+# Ensures arguments are a tuple or a list. Strings are converted
+# by shlex_split_unicode() which is bad; we warn about it or else
+# we assert (and fix the code).
+def massage_arguments(arguments, errors='assert'):
+
+    # For reference and in-case anything breaks ..
+    # .. one of the places (run_command in conda_env/utils.py) this
+    # gets called from used to do this too:
+    #
+    #    def escape_for_winpath(p):
+    #        return p.replace('\\', '\\\\')
+    #
+    #    if not isinstance(arguments, list):
+    #        arguments = list(map(escape_for_winpath, arguments))
+
+    if isinstance(arguments, str):
+        if errors == 'assert':
+            # This should be something like 'conda programming bug', it is an assert
+            assert False, 'Please ensure arguments are not strings'
+        else:
+            arguments = shlex_split_unicode(arguments)
+            log.warning("Please ensure arguments is not a string; "
+                        "used `shlex_split_unicode()` on it")
+
+    if not isiterable(arguments):
+        arguments = (arguments,)
+
+    assert not any([isiterable(arg) for arg in arguments]), "Individual arguments must not be iterable"  # NOQA
+    arguments = list(arguments)
+
+    return arguments
+
+
+def wrap_subprocess_call(
+        root_prefix,
+        prefix,
+        dev_mode,
+        debug_wrapper_scripts,
+        arguments,
+        use_system_tmp_path=False):
+    arguments = massage_arguments(arguments)
+    if not use_system_tmp_path:
+        tmp_prefix = abspath(join(prefix, '.tmp'))
+    else:
+        tmp_prefix = None
+    script_caller = None
+    multiline = False
+    if len(arguments) == 1 and '\n' in arguments[0]:
+        multiline = True
+    if on_win:
+        comspec = get_comspec()  # fail early with KeyError if undefined
+        if dev_mode:
+            from conda import CONDA_PACKAGE_ROOT
+            conda_bat = join(CONDA_PACKAGE_ROOT, 'shell', 'condabin', 'conda.bat')
+        else:
+            conda_bat = environ.get("CONDA_BAT",
+                                    abspath(join(root_prefix, 'condabin', 'conda.bat')))
+        with Utf8NamedTemporaryFile(mode='w', prefix=tmp_prefix,
+                                    suffix='.bat', delete=False) as fh:
+            silencer = "" if debug_wrapper_scripts else "@"
+            fh.write("{}ECHO OFF\n".format(silencer))
+            fh.write("{}SET PYTHONIOENCODING=utf-8\n".format(silencer))
+            fh.write("{}SET PYTHONUTF8=1\n".format(silencer))
+            fh.write('{}FOR /F "tokens=2 delims=:." %%A in (\'chcp\') do for %%B in (%%A) do set "_CONDA_OLD_CHCP=%%B"\n'.format(silencer))  # NOQA
+            fh.write("{}chcp 65001 > NUL\n".format(silencer))
+            if dev_mode:
+                from . import CONDA_SOURCE_ROOT
+                fh.write("{}SET CONDA_DEV=1\n".format(silencer))
+                # In dev mode, conda is really:
+                # 'python -m conda'
+                # *with* PYTHONPATH set.
+                fh.write("{}SET PYTHONPATH={}\n".format(silencer, CONDA_SOURCE_ROOT))
+                fh.write("{}SET CONDA_EXE={}\n".format(silencer, sys.executable))
+                fh.write("{}SET _CE_M=-m\n".format(silencer))
+                fh.write("{}SET _CE_CONDA=conda\n".format(silencer))
+            if debug_wrapper_scripts:
+                fh.write('echo *** environment before *** 1>&2\n')
+                fh.write('SET 1>&2\n')
+            # Not sure there is any point in backing this up, nothing will get called with it reset
+            # after all!
+            # fh.write("@FOR /F \"tokens=100\" %%F IN ('chcp') DO @SET CONDA_OLD_CHCP=%%F\n")
+            # fh.write('@chcp 65001>NUL\n')
+            fh.write('{0}CALL \"{1}\" activate \"{2}\"\n'.format(silencer, conda_bat, prefix))
+            fh.write("{}IF %ERRORLEVEL% NEQ 0 EXIT /b %ERRORLEVEL%\n".format(silencer))
+            if debug_wrapper_scripts:
+                fh.write('echo *** environment after *** 1>&2\n')
+                fh.write('SET 1>&2\n')
+            if multiline:
+                # No point silencing the first line. If that's what's wanted then
+                # it needs doing for each line and the caller may as well do that.
+                fh.write("{0}\n".format(arguments[0]))
+            else:
+                assert not any("\n" in arg for arg in arguments), (
+                    "Support for scripts where arguments contain newlines not implemented.\n"
+                    ".. requires writing the script to an external file and knowing how to "
+                    "transform the command-line (e.g. `python -c args` => `python file`) "
+                    "in a tool dependent way, or attempting something like:\n"
+                    ".. https://stackoverflow.com/a/15032476 (adds unacceptable escaping"
+                    "requirements)"
+                )
+                fh.write("{0}{1}\n".format(silencer, quote_for_shell(*arguments)))
+            fh.write("{}IF %ERRORLEVEL% NEQ 0 EXIT /b %ERRORLEVEL%\n".format(silencer))
+            fh.write("{}chcp %_CONDA_OLD_CHCP%>NUL\n".format(silencer))
+            script_caller = fh.name
+        command_args = [comspec, '/d', '/c', script_caller]
+    else:
+        shell_path = which('bash') or which('sh')
+        if shell_path is None:
+            raise Exception("No compatible shell found!")
+
+        # During tests, we sometimes like to have a temp env with e.g. an old python in it
+        # and have it run tests against the very latest development sources. For that to
+        # work we need extra smarts here, we want it to be instead:
+        if dev_mode:
+            conda_exe = [abspath(join(root_prefix, 'bin', 'python')), '-m', 'conda']
+            dev_arg = '--dev'
+            dev_args = [dev_arg]
+        else:
+            conda_exe = [environ.get("CONDA_EXE", abspath(join(root_prefix, 'bin', 'conda')))]
+            dev_arg = ''
+            dev_args = []
+        with Utf8NamedTemporaryFile(mode='w', prefix=tmp_prefix, delete=False) as fh:
+            if dev_mode:
+                from . import CONDA_SOURCE_ROOT
+
+                fh.write(">&2 export PYTHONPATH=" + CONDA_SOURCE_ROOT + "\n")
+            hook_quoted = quote_for_shell(*conda_exe, "shell.posix", "hook", *dev_args)
+            if debug_wrapper_scripts:
+                fh.write(">&2 echo '*** environment before ***'\n" ">&2 env\n")
+                fh.write('>&2 echo "$({0})"\n'.format(hook_quoted))
+            fh.write('eval "$({0})"\n'.format(hook_quoted))
+            fh.write("conda activate {0} {1}\n".format(dev_arg, quote_for_shell(prefix)))
+            if debug_wrapper_scripts:
+                fh.write(">&2 echo '*** environment after ***'\n" ">&2 env\n")
+            if multiline:
+                # The ' '.join() is pointless since mutliline is only True when there's 1 arg
+                # still, if that were to change this would prevent breakage.
+                fh.write("{0}\n".format(" ".join(arguments)))
+            else:
+                fh.write("{0}\n".format(quote_for_shell(*arguments)))
+            script_caller = fh.name
+        if debug_wrapper_scripts:
+            command_args = [shell_path, "-x", script_caller]
+        else:
+            command_args = [shell_path, script_caller]
+
+    return script_caller, command_args
+
+
+def get_comspec():
+    """Returns COMSPEC from envvars.
+
+    Ensures COMSPEC envvar is set to cmd.exe, if not attempt to find it.
+
+    :raises KeyError: COMSPEC is undefined and cannot be found.
+    :returns: COMSPEC value.
+    :rtype: str
+    """
+    if basename(environ.get("COMSPEC", "")).lower() != "cmd.exe":
+        for comspec in (
+            # %SystemRoot%\System32\cmd.exe
+            environ.get("SystemRoot") and join(environ["SystemRoot"], "System32", "cmd.exe"),
+            # %windir%\System32\cmd.exe
+            environ.get("windir") and join(environ["windir"], "System32", "cmd.exe"),
+        ):
+            if comspec and isfile(comspec):
+                environ["COMSPEC"] = comspec
+                break
+        else:
+            log.warn("cmd.exe could not be found. Looked in SystemRoot and windir env vars.\n")
+
+    # fails with KeyError if still undefined
+    return environ["COMSPEC"]
+
+
+def ensure_dir_exists(func):
+    """
+    Ensures that the directory exists for functions returning
+    a Path object containing a directory
+    """
+
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        result = func(*args, **kwargs)
+
+        if isinstance(result, Path):
+            try:
+                result.mkdir(parents=True, exist_ok=True)
+            except OSError as exc:
+                raise CondaError(
+                    "Error encountered while attempting to create cache directory."
+                    f"\n  Directory: {result}"
+                    f"\n  Exception: {exc}"
+                )
+
+        return result
+
+    return wrapper
+
+
+@contextmanager
+def safe_open(*args, **kwargs):
+    """
+    Allows us to open files while catching any exceptions
+    and raise them as CondaErrors instead.
+
+    We do this to provide a more informative/actionable error output.
+    """
+    try:
+        fp = open(*args, **kwargs)
+        yield fp
+    except OSError as exc:
+        raise CondaError(
+            "Error encountered while reading or writing from cache."
+            f"\n  File: {args[0]}"
+            f"\n  Exception: {exc}"
+        )
+
+    fp.close()

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/pyasn1_modules/pem.py

@@ -0,0 +1,65 @@
+#
+# This file is part of pyasn1-modules software.
+#
+# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# License: http://snmplabs.com/pyasn1/license.html
+#
+import base64
+import sys
+
+stSpam, stHam, stDump = 0, 1, 2
+
+
+# The markers parameters is in form ('start1', 'stop1'), ('start2', 'stop2')...
+# Return is (marker-index, substrate)
+def readPemBlocksFromFile(fileObj, *markers):
+    startMarkers = dict(map(lambda x: (x[1], x[0]),
+                            enumerate(map(lambda y: y[0], markers))))
+    stopMarkers = dict(map(lambda x: (x[1], x[0]),
+                           enumerate(map(lambda y: y[1], markers))))
+    idx = -1
+    substrate = ''
+    certLines = []
+    state = stSpam
+    while True:
+        certLine = fileObj.readline()
+        if not certLine:
+            break
+        certLine = certLine.strip()
+        if state == stSpam:
+            if certLine in startMarkers:
+                certLines = []
+                idx = startMarkers[certLine]
+                state = stHam
+                continue
+        if state == stHam:
+            if certLine in stopMarkers and stopMarkers[certLine] == idx:
+                state = stDump
+            else:
+                certLines.append(certLine)
+        if state == stDump:
+            if sys.version_info[0] <= 2:
+                substrate = ''.join([base64.b64decode(x) for x in certLines])
+            else:
+                substrate = ''.encode().join([base64.b64decode(x.encode()) for x in certLines])
+            break
+    return idx, substrate
+
+
+# Backward compatibility routine
+def readPemFromFile(fileObj,
+                    startMarker='-----BEGIN CERTIFICATE-----',
+                    endMarker='-----END CERTIFICATE-----'):
+    idx, substrate = readPemBlocksFromFile(fileObj, (startMarker, endMarker))
+    return substrate
+
+
+def readBase64fromText(text):
+    if sys.version_info[0] <= 2:
+        return base64.b64decode(text)
+    else:
+        return base64.b64decode(text.encode())
+
+
+def readBase64FromFile(fileObj):
+    return readBase64fromText(fileObj.read())

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/pyasn1_modules/rfc2631.py

@@ -0,0 +1,37 @@
+#
+# This file is part of pyasn1-modules software.
+#
+# Created by Russ Housley with assistance from asn1ate v.0.6.0.
+#
+# Copyright (c) 2019, Vigil Security, LLC
+# License: http://snmplabs.com/pyasn1/license.html
+#
+# Diffie-Hellman Key Agreement
+#
+# ASN.1 source from:
+# https://www.rfc-editor.org/rfc/rfc2631.txt
+# https://www.rfc-editor.org/errata/eid5897
+#
+
+from pyasn1.type import constraint
+from pyasn1.type import namedtype
+from pyasn1.type import tag
+from pyasn1.type import univ
+
+
+class KeySpecificInfo(univ.Sequence):
+    componentType = namedtype.NamedTypes(
+        namedtype.NamedType('algorithm', univ.ObjectIdentifier()),
+        namedtype.NamedType('counter', univ.OctetString().subtype(
+            subtypeSpec=constraint.ValueSizeConstraint(4, 4)))
+    )
+
+
+class OtherInfo(univ.Sequence):
+    componentType = namedtype.NamedTypes(
+        namedtype.NamedType('keyInfo', KeySpecificInfo()),
+        namedtype.OptionalNamedType('partyAInfo', univ.OctetString().subtype(
+            explicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 0))),
+        namedtype.NamedType('suppPubInfo', univ.OctetString().subtype(
+            explicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 2)))
+    )

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/pyasn1_modules/rfc5280.py

@@ -0,0 +1,1658 @@
+# coding: utf-8
+#
+# This file is part of pyasn1-modules software.
+#
+# Created by Stanisław Pitucha with asn1ate tool.
+# Updated by Russ Housley for ORAddress Extension Attribute opentype support.
+# Updated by Russ Housley for AlgorithmIdentifier opentype support.
+#
+# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# License: http://snmplabs.com/pyasn1/license.html
+#
+# Internet X.509 Public Key Infrastructure Certificate and Certificate
+# Revocation List (CRL) Profile
+#
+# ASN.1 source from:
+# https://www.rfc-editor.org/rfc/rfc5280.txt
+#
+from pyasn1.type import char
+from pyasn1.type import constraint
+from pyasn1.type import namedtype
+from pyasn1.type import namedval
+from pyasn1.type import opentype
+from pyasn1.type import tag
+from pyasn1.type import univ
+from pyasn1.type import useful
+
+MAX = float('inf')
+
+
+def _buildOid(*components):
+    output = []
+    for x in tuple(components):
+        if isinstance(x, univ.ObjectIdentifier):
+            output.extend(list(x))
+        else:
+            output.append(int(x))
+
+    return univ.ObjectIdentifier(output)
+
+
+ub_e163_4_sub_address_length = univ.Integer(40)
+
+ub_e163_4_number_length = univ.Integer(15)
+
+unformatted_postal_address = univ.Integer(16)
+
+
+class TerminalType(univ.Integer):
+    pass
+
+
+TerminalType.namedValues = namedval.NamedValues(
+    ('telex', 3),
+    ('teletex', 4),
+    ('g3-facsimile', 5),
+    ('g4-facsimile', 6),
+    ('ia5-terminal', 7),
+    ('videotex', 8)
+)
+
+
+class Extension(univ.Sequence):
+    pass
+
+
+Extension.componentType = namedtype.NamedTypes(
+    namedtype.NamedType('extnID', univ.ObjectIdentifier()),
+    namedtype.DefaultedNamedType('critical', univ.Boolean().subtype(value=0)),
+    namedtype.NamedType('extnValue', univ.OctetString())
+)
+
+
+class Extensions(univ.SequenceOf):
+    pass
+
+
+Extensions.componentType = Extension()
+Extensions.sizeSpec = constraint.ValueSizeConstraint(1, MAX)
+
+physical_delivery_personal_name = univ.Integer(13)
+
+ub_unformatted_address_length = univ.Integer(180)
+
+ub_pds_parameter_length = univ.Integer(30)
+
+ub_pds_physical_address_lines = univ.Integer(6)
+
+
+class UnformattedPostalAddress(univ.Set):
+    pass
+
+
+UnformattedPostalAddress.componentType = namedtype.NamedTypes(
+    namedtype.OptionalNamedType('printable-address', univ.SequenceOf(componentType=char.PrintableString().subtype(
+        subtypeSpec=constraint.ValueSizeConstraint(1, ub_pds_parameter_length)))),
+    namedtype.OptionalNamedType('teletex-string', char.TeletexString().subtype(
+        subtypeSpec=constraint.ValueSizeConstraint(1, ub_unformatted_address_length)))
+)
+
+ub_organization_name = univ.Integer(64)
+
+
+class X520OrganizationName(univ.Choice):
+    pass
+
+
+X520OrganizationName.componentType = namedtype.NamedTypes(
+    namedtype.NamedType('teletexString', char.TeletexString().subtype(
+        subtypeSpec=constraint.ValueSizeConstraint(1, ub_organization_name))),
+    namedtype.NamedType('printableString', char.PrintableString().subtype(
+        subtypeSpec=constraint.ValueSizeConstraint(1, ub_organization_name))),
+    namedtype.NamedType('universalString', char.UniversalString().subtype(
+        subtypeSpec=constraint.ValueSizeConstraint(1, ub_organization_name))),
+    namedtype.NamedType('utf8String',
+                        char.UTF8String().subtype(subtypeSpec=constraint.ValueSizeConstraint(1, ub_organization_name))),
+    namedtype.NamedType('bmpString',
+                        char.BMPString().subtype(subtypeSpec=constraint.ValueSizeConstraint(1, ub_organization_name)))
+)
+
+ub_x121_address_length = univ.Integer(16)
+
+pds_name = univ.Integer(7)
+
+id_pkix = _buildOid(1, 3, 6, 1, 5, 5, 7)
+
+id_kp = _buildOid(id_pkix, 3)
+
+ub_postal_code_length = univ.Integer(16)
+
+
+class PostalCode(univ.Choice):
+    pass
+
+
+PostalCode.componentType = namedtype.NamedTypes(
+    namedtype.NamedType('numeric-code', char.NumericString().subtype(
+        subtypeSpec=constraint.ValueSizeConstraint(1, ub_postal_code_length))),
+    namedtype.NamedType('printable-code', char.PrintableString().subtype(
+        subtypeSpec=constraint.ValueSizeConstraint(1, ub_postal_code_length)))
+)
+
+ub_generation_qualifier_length = univ.Integer(3)
+
+unique_postal_name = univ.Integer(20)
+
+
+class DomainComponent(char.IA5String):
+    pass
+
+
+ub_domain_defined_attribute_value_length = univ.Integer(128)
+
+ub_match = univ.Integer(128)
+
+id_at = _buildOid(2, 5, 4)
+
+
+class AttributeType(univ.ObjectIdentifier):
+    pass
+
+
+id_at_organizationalUnitName = _buildOid(id_at, 11)
+
+terminal_type = univ.Integer(23)
+
+
+class PDSParameter(univ.Set):
+    pass
+
+
+PDSParameter.componentType = namedtype.NamedTypes(
+    namedtype.OptionalNamedType('printable-string', char.PrintableString().subtype(
+        subtypeSpec=constraint.ValueSizeConstraint(1, ub_pds_parameter_length))),
+    namedtype.OptionalNamedType('teletex-string', char.TeletexString().subtype(
+        subtypeSpec=constraint.ValueSizeConstraint(1, ub_pds_parameter_length)))
+)
+
+
+class PhysicalDeliveryPersonalName(PDSParameter):
+    pass
+
+
+ub_surname_length = univ.Integer(40)
+
+id_ad = _buildOid(id_pkix, 48)
+
+ub_domain_defined_attribute_type_length = univ.Integer(8)
+
+
+class TeletexDomainDefinedAttribute(univ.Sequence):
+    pass
+
+
+TeletexDomainDefinedAttribute.componentType = namedtype.NamedTypes(
+    namedtype.NamedType('type', char.TeletexString().subtype(
+        subtypeSpec=constraint.ValueSizeConstraint(1, ub_domain_defined_attribute_type_length))),
+    namedtype.NamedType('value', char.TeletexString().subtype(
+        subtypeSpec=constraint.ValueSizeConstraint(1, ub_domain_defined_attribute_value_length)))
+)
+
+ub_domain_defined_attributes = univ.Integer(4)
+
+
+class TeletexDomainDefinedAttributes(univ.SequenceOf):
+    pass
+
+
+TeletexDomainDefinedAttributes.componentType = TeletexDomainDefinedAttribute()
+TeletexDomainDefinedAttributes.sizeSpec = constraint.ValueSizeConstraint(1, ub_domain_defined_attributes)
+
+extended_network_address = univ.Integer(22)
+
+ub_locality_name = univ.Integer(128)
+
+
+class X520LocalityName(univ.Choice):
+    pass
+
+
+X520LocalityName.componentType = namedtype.NamedTypes(
+    namedtype.NamedType('teletexString',
+                        char.TeletexString().subtype(subtypeSpec=constraint.ValueSizeConstraint(1, ub_locality_name))),
+    namedtype.NamedType('printableString', char.PrintableString().subtype(
+        subtypeSpec=constraint.ValueSizeConstraint(1, ub_locality_name))),
+    namedtype.NamedType('universalString', char.UniversalString().subtype(
+        subtypeSpec=constraint.ValueSizeConstraint(1, ub_locality_name))),
+    namedtype.NamedType('utf8String',
+                        char.UTF8String().subtype(subtypeSpec=constraint.ValueSizeConstraint(1, ub_locality_name))),
+    namedtype.NamedType('bmpString',
+                        char.BMPString().subtype(subtypeSpec=constraint.ValueSizeConstraint(1, ub_locality_name)))
+)
+
+teletex_organization_name = univ.Integer(3)
+
+ub_given_name_length = univ.Integer(16)
+
+ub_initials_length = univ.Integer(5)
+
+
+class PersonalName(univ.Set):
+    pass
+
+
+PersonalName.componentType = namedtype.NamedTypes(
+    namedtype.NamedType('surname', char.PrintableString().subtype(
+        subtypeSpec=constraint.ValueSizeConstraint(1, ub_surname_length)).subtype(
+        implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 0))),
+    namedtype.OptionalNamedType('given-name', char.PrintableString().subtype(
+        subtypeSpec=constraint.ValueSizeConstraint(1, ub_given_name_length)).subtype(
+        implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 1))),
+    namedtype.OptionalNamedType('initials', char.PrintableString().subtype(
+        subtypeSpec=constraint.ValueSizeConstraint(1, ub_initials_length)).subtype(
+        implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 2))),
+    namedtype.OptionalNamedType('generation-qualifier', char.PrintableString().subtype(
+        subtypeSpec=constraint.ValueSizeConstraint(1, ub_generation_qualifier_length)).subtype(
+        implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 3)))
+)
+
+ub_organizational_unit_name_length = univ.Integer(32)
+
+
+class OrganizationalUnitName(char.PrintableString):
+    pass
+
+
+OrganizationalUnitName.subtypeSpec = constraint.ValueSizeConstraint(1, ub_organizational_unit_name_length)
+
+id_at_generationQualifier = _buildOid(id_at, 44)
+
+
+class Version(univ.Integer):
+    pass
+
+
+Version.namedValues = namedval.NamedValues(
+    ('v1', 0),
+    ('v2', 1),
+    ('v3', 2)
+)
+
+
+class CertificateSerialNumber(univ.Integer):
+    pass
+
+
+algorithmIdentifierMap = {}
+
+
+class AlgorithmIdentifier(univ.Sequence):
+    componentType = namedtype.NamedTypes(
+        namedtype.NamedType('algorithm', univ.ObjectIdentifier()),
+        namedtype.OptionalNamedType('parameters', univ.Any(),
+            openType=opentype.OpenType('algorithm', algorithmIdentifierMap)
+        )
+    )
+
+
+class Time(univ.Choice):
+    pass
+
+
+Time.componentType = namedtype.NamedTypes(
+    namedtype.NamedType('utcTime', useful.UTCTime()),
+    namedtype.NamedType('generalTime', useful.GeneralizedTime())
+)
+
+
+class AttributeValue(univ.Any):
+    pass
+
+
+certificateAttributesMap = {}
+
+
+class AttributeTypeAndValue(univ.Sequence):
+    componentType = namedtype.NamedTypes(
+        namedtype.NamedType('type', AttributeType()),
+        namedtype.NamedType(
+            'value', AttributeValue(),
+            openType=opentype.OpenType('type', certificateAttributesMap)
+        )
+    )
+
+
+class RelativeDistinguishedName(univ.SetOf):
+    pass
+
+
+RelativeDistinguishedName.componentType = AttributeTypeAndValue()
+RelativeDistinguishedName.sizeSpec = constraint.ValueSizeConstraint(1, MAX)
+
+
+class RDNSequence(univ.SequenceOf):
+    pass
+
+
+RDNSequence.componentType = RelativeDistinguishedName()
+
+
+class Name(univ.Choice):
+    pass
+
+
+Name.componentType = namedtype.NamedTypes(
+    namedtype.NamedType('rdnSequence', RDNSequence())
+)
+
+
+class TBSCertList(univ.Sequence):
+    pass
+
+
+TBSCertList.componentType = namedtype.NamedTypes(
+    namedtype.OptionalNamedType('version', Version()),
+    namedtype.NamedType('signature', AlgorithmIdentifier()),
+    namedtype.NamedType('issuer', Name()),
+    namedtype.NamedType('thisUpdate', Time()),
+    namedtype.OptionalNamedType('nextUpdate', Time()),
+    namedtype.OptionalNamedType(
+        'revokedCertificates', univ.SequenceOf(
+            componentType=univ.Sequence(
+                componentType=namedtype.NamedTypes(
+                    namedtype.NamedType('userCertificate', CertificateSerialNumber()),
+                    namedtype.NamedType('revocationDate', Time()),
+                    namedtype.OptionalNamedType('crlEntryExtensions', Extensions())
+                )
+            )
+        )
+    ),
+    namedtype.OptionalNamedType(
+        'crlExtensions', Extensions().subtype(explicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 0)))
+)
+
+
+class CertificateList(univ.Sequence):
+    pass
+
+
+CertificateList.componentType = namedtype.NamedTypes(
+    namedtype.NamedType('tbsCertList', TBSCertList()),
+    namedtype.NamedType('signatureAlgorithm', AlgorithmIdentifier()),
+    namedtype.NamedType('signature', univ.BitString())
+)
+
+
+class PhysicalDeliveryOfficeName(PDSParameter):
+    pass
+
+
+ub_extension_attributes = univ.Integer(256)
+
+certificateExtensionsMap = {
+}
+
+oraddressExtensionAttributeMap = {
+}
+
+
+class ExtensionAttribute(univ.Sequence):
+    componentType = namedtype.NamedTypes(
+        namedtype.NamedType(
+            'extension-attribute-type',
+            univ.Integer().subtype(subtypeSpec=constraint.ValueRangeConstraint(0, ub_extension_attributes)).subtype(implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 0))),
+        namedtype.NamedType(
+            'extension-attribute-value',
+            univ.Any().subtype(explicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 1)),
+            openType=opentype.OpenType('extension-attribute-type', oraddressExtensionAttributeMap))
+    )
+
+id_qt = _buildOid(id_pkix, 2)
+
+id_qt_cps = _buildOid(id_qt, 1)
+
+id_at_stateOrProvinceName = _buildOid(id_at, 8)
+
+id_at_title = _buildOid(id_at, 12)
+
+id_at_serialNumber = _buildOid(id_at, 5)
+
+
+class X520dnQualifier(char.PrintableString):
+    pass
+
+
+class PosteRestanteAddress(PDSParameter):
+    pass
+
+
+poste_restante_address = univ.Integer(19)
+
+
+class UniqueIdentifier(univ.BitString):
+    pass
+
+
+class Validity(univ.Sequence):
+    pass
+
+
+Validity.componentType = namedtype.NamedTypes(
+    namedtype.NamedType('notBefore', Time()),
+    namedtype.NamedType('notAfter', Time())
+)
+
+
+class SubjectPublicKeyInfo(univ.Sequence):
+    pass
+
+
+SubjectPublicKeyInfo.componentType = namedtype.NamedTypes(
+    namedtype.NamedType('algorithm', AlgorithmIdentifier()),
+    namedtype.NamedType('subjectPublicKey', univ.BitString())
+)
+
+
+class TBSCertificate(univ.Sequence):
+    pass
+
+
+TBSCertificate.componentType = namedtype.NamedTypes(
+    namedtype.DefaultedNamedType('version',
+                                 Version().subtype(explicitTag=tag.Tag(tag.tagClassContext,
+                                                                       tag.tagFormatSimple, 0)).subtype(value="v1")),
+    namedtype.NamedType('serialNumber', CertificateSerialNumber()),
+    namedtype.NamedType('signature', AlgorithmIdentifier()),
+    namedtype.NamedType('issuer', Name()),
+    namedtype.NamedType('validity', Validity()),
+    namedtype.NamedType('subject', Name()),
+    namedtype.NamedType('subjectPublicKeyInfo', SubjectPublicKeyInfo()),
+    namedtype.OptionalNamedType('issuerUniqueID', UniqueIdentifier().subtype(
+        implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 1))),
+    namedtype.OptionalNamedType('subjectUniqueID', UniqueIdentifier().subtype(
+        implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 2))),
+    namedtype.OptionalNamedType('extensions',
+                                Extensions().subtype(explicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 3)))
+)
+
+physical_delivery_office_name = univ.Integer(10)
+
+ub_name = univ.Integer(32768)
+
+
+class X520name(univ.Choice):
+    pass
+
+
+X520name.componentType = namedtype.NamedTypes(
+    namedtype.NamedType('teletexString',
+                        char.TeletexString().subtype(subtypeSpec=constraint.ValueSizeConstraint(1, ub_name))),
+    namedtype.NamedType('printableString',
+                        char.PrintableString().subtype(subtypeSpec=constraint.ValueSizeConstraint(1, ub_name))),
+    namedtype.NamedType('universalString',
+                        char.UniversalString().subtype(subtypeSpec=constraint.ValueSizeConstraint(1, ub_name))),
+    namedtype.NamedType('utf8String',
+                        char.UTF8String().subtype(subtypeSpec=constraint.ValueSizeConstraint(1, ub_name))),
+    namedtype.NamedType('bmpString', char.BMPString().subtype(subtypeSpec=constraint.ValueSizeConstraint(1, ub_name)))
+)
+
+id_at_dnQualifier = _buildOid(id_at, 46)
+
+ub_serial_number = univ.Integer(64)
+
+ub_pseudonym = univ.Integer(128)
+
+pkcs_9 = _buildOid(1, 2, 840, 113549, 1, 9)
+
+
+class X121Address(char.NumericString):
+    pass
+
+
+X121Address.subtypeSpec = constraint.ValueSizeConstraint(1, ub_x121_address_length)
+
+
+class NetworkAddress(X121Address):
+    pass
+
+
+ub_integer_options = univ.Integer(256)
+
+id_at_commonName = _buildOid(id_at, 3)
+
+ub_organization_name_length = univ.Integer(64)
+
+id_ad_ocsp = _buildOid(id_ad, 1)
+
+ub_country_name_numeric_length = univ.Integer(3)
+
+ub_country_name_alpha_length = univ.Integer(2)
+
+
+class PhysicalDeliveryCountryName(univ.Choice):
+    pass
+
+
+PhysicalDeliveryCountryName.componentType = namedtype.NamedTypes(
+    namedtype.NamedType('x121-dcc-code', char.NumericString().subtype(
+        subtypeSpec=constraint.ValueSizeConstraint(ub_country_name_numeric_length, ub_country_name_numeric_length))),
+    namedtype.NamedType('iso-3166-alpha2-code', char.PrintableString().subtype(
+        subtypeSpec=constraint.ValueSizeConstraint(ub_country_name_alpha_length, ub_country_name_alpha_length)))
+)
+
+id_emailAddress = _buildOid(pkcs_9, 1)
+
+common_name = univ.Integer(1)
+
+
+class X520Pseudonym(univ.Choice):
+    pass
+
+
+X520Pseudonym.componentType = namedtype.NamedTypes(
+    namedtype.NamedType('teletexString',
+                        char.TeletexString().subtype(subtypeSpec=constraint.ValueSizeConstraint(1, ub_pseudonym))),
+    namedtype.NamedType('printableString',
+                        char.PrintableString().subtype(subtypeSpec=constraint.ValueSizeConstraint(1, ub_pseudonym))),
+    namedtype.NamedType('universalString',
+                        char.UniversalString().subtype(subtypeSpec=constraint.ValueSizeConstraint(1, ub_pseudonym))),
+    namedtype.NamedType('utf8String',
+                        char.UTF8String().subtype(subtypeSpec=constraint.ValueSizeConstraint(1, ub_pseudonym))),
+    namedtype.NamedType('bmpString',
+                        char.BMPString().subtype(subtypeSpec=constraint.ValueSizeConstraint(1, ub_pseudonym)))
+)
+
+ub_domain_name_length = univ.Integer(16)
+
+
+class AdministrationDomainName(univ.Choice):
+    pass
+
+
+AdministrationDomainName.tagSet = univ.Choice.tagSet.tagExplicitly(
+    tag.Tag(tag.tagClassApplication, tag.tagFormatConstructed, 2))
+AdministrationDomainName.componentType = namedtype.NamedTypes(
+    namedtype.NamedType('numeric', char.NumericString().subtype(
+        subtypeSpec=constraint.ValueSizeConstraint(0, ub_domain_name_length))),
+    namedtype.NamedType('printable', char.PrintableString().subtype(
+        subtypeSpec=constraint.ValueSizeConstraint(0, ub_domain_name_length)))
+)
+
+
+class PresentationAddress(univ.Sequence):
+    pass
+
+
+PresentationAddress.componentType = namedtype.NamedTypes(
+    namedtype.OptionalNamedType('pSelector', univ.OctetString().subtype(
+        explicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 0))),
+    namedtype.OptionalNamedType('sSelector', univ.OctetString().subtype(
+        explicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 1))),
+    namedtype.OptionalNamedType('tSelector', univ.OctetString().subtype(
+        explicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 2))),
+    namedtype.NamedType('nAddresses', univ.SetOf(componentType=univ.OctetString()).subtype(
+        explicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 3)))
+)
+
+
+class ExtendedNetworkAddress(univ.Choice):
+    pass
+
+
+ExtendedNetworkAddress.componentType = namedtype.NamedTypes(
+    namedtype.NamedType(
+        'e163-4-address', univ.Sequence(
+            componentType=namedtype.NamedTypes(
+                namedtype.NamedType('number', char.NumericString().subtype(subtypeSpec=constraint.ValueSizeConstraint(1, ub_e163_4_number_length)).subtype(implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 0))),
+                namedtype.OptionalNamedType('sub-address', char.NumericString().subtype(subtypeSpec=constraint.ValueSizeConstraint(1, ub_e163_4_sub_address_length)).subtype(implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 1)))
+            )
+        )
+    ),
+    namedtype.NamedType('psap-address', PresentationAddress().subtype(
+        implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatConstructed, 0)))
+)
+
+
+class TeletexOrganizationName(char.TeletexString):
+    pass
+
+
+TeletexOrganizationName.subtypeSpec = constraint.ValueSizeConstraint(1, ub_organization_name_length)
+
+ub_terminal_id_length = univ.Integer(24)
+
+
+class TerminalIdentifier(char.PrintableString):
+    pass
+
+
+TerminalIdentifier.subtypeSpec = constraint.ValueSizeConstraint(1, ub_terminal_id_length)
+
+id_ad_caIssuers = _buildOid(id_ad, 2)
+
+id_at_countryName = _buildOid(id_at, 6)
+
+
+class StreetAddress(PDSParameter):
+    pass
+
+
+postal_code = univ.Integer(9)
+
+id_at_givenName = _buildOid(id_at, 42)
+
+ub_title = univ.Integer(64)
+
+
+class ExtensionAttributes(univ.SetOf):
+    pass
+
+
+ExtensionAttributes.componentType = ExtensionAttribute()
+ExtensionAttributes.sizeSpec = constraint.ValueSizeConstraint(1, ub_extension_attributes)
+
+ub_emailaddress_length = univ.Integer(255)
+
+id_ad_caRepository = _buildOid(id_ad, 5)
+
+
+class ExtensionORAddressComponents(PDSParameter):
+    pass
+
+
+ub_organizational_unit_name = univ.Integer(64)
+
+
+class X520OrganizationalUnitName(univ.Choice):
+    pass
+
+
+X520OrganizationalUnitName.componentType = namedtype.NamedTypes(
+    namedtype.NamedType('teletexString', char.TeletexString().subtype(
+        subtypeSpec=constraint.ValueSizeConstraint(1, ub_organizational_unit_name))),
+    namedtype.NamedType('printableString', char.PrintableString().subtype(
+        subtypeSpec=constraint.ValueSizeConstraint(1, ub_organizational_unit_name))),
+    namedtype.NamedType('universalString', char.UniversalString().subtype(
+        subtypeSpec=constraint.ValueSizeConstraint(1, ub_organizational_unit_name))),
+    namedtype.NamedType('utf8String', char.UTF8String().subtype(
+        subtypeSpec=constraint.ValueSizeConstraint(1, ub_organizational_unit_name))),
+    namedtype.NamedType('bmpString', char.BMPString().subtype(
+        subtypeSpec=constraint.ValueSizeConstraint(1, ub_organizational_unit_name)))
+)
+
+
+class LocalPostalAttributes(PDSParameter):
+    pass
+
+
+teletex_organizational_unit_names = univ.Integer(5)
+
+
+class X520Title(univ.Choice):
+    pass
+
+
+X520Title.componentType = namedtype.NamedTypes(
+    namedtype.NamedType('teletexString',
+                        char.TeletexString().subtype(subtypeSpec=constraint.ValueSizeConstraint(1, ub_title))),
+    namedtype.NamedType('printableString',
+                        char.PrintableString().subtype(subtypeSpec=constraint.ValueSizeConstraint(1, ub_title))),
+    namedtype.NamedType('universalString',
+                        char.UniversalString().subtype(subtypeSpec=constraint.ValueSizeConstraint(1, ub_title))),
+    namedtype.NamedType('utf8String',
+                        char.UTF8String().subtype(subtypeSpec=constraint.ValueSizeConstraint(1, ub_title))),
+    namedtype.NamedType('bmpString', char.BMPString().subtype(subtypeSpec=constraint.ValueSizeConstraint(1, ub_title)))
+)
+
+id_at_localityName = _buildOid(id_at, 7)
+
+id_at_initials = _buildOid(id_at, 43)
+
+ub_state_name = univ.Integer(128)
+
+
+class X520StateOrProvinceName(univ.Choice):
+    pass
+
+
+X520StateOrProvinceName.componentType = namedtype.NamedTypes(
+    namedtype.NamedType('teletexString',
+                        char.TeletexString().subtype(subtypeSpec=constraint.ValueSizeConstraint(1, ub_state_name))),
+    namedtype.NamedType('printableString',
+                        char.PrintableString().subtype(subtypeSpec=constraint.ValueSizeConstraint(1, ub_state_name))),
+    namedtype.NamedType('universalString',
+                        char.UniversalString().subtype(subtypeSpec=constraint.ValueSizeConstraint(1, ub_state_name))),
+    namedtype.NamedType('utf8String',
+                        char.UTF8String().subtype(subtypeSpec=constraint.ValueSizeConstraint(1, ub_state_name))),
+    namedtype.NamedType('bmpString',
+                        char.BMPString().subtype(subtypeSpec=constraint.ValueSizeConstraint(1, ub_state_name)))
+)
+
+physical_delivery_organization_name = univ.Integer(14)
+
+id_at_surname = _buildOid(id_at, 4)
+
+
+class X520countryName(char.PrintableString):
+    pass
+
+
+X520countryName.subtypeSpec = constraint.ValueSizeConstraint(2, 2)
+
+physical_delivery_office_number = univ.Integer(11)
+
+id_qt_unotice = _buildOid(id_qt, 2)
+
+
+class X520SerialNumber(char.PrintableString):
+    pass
+
+
+X520SerialNumber.subtypeSpec = constraint.ValueSizeConstraint(1, ub_serial_number)
+
+
+class Attribute(univ.Sequence):
+    componentType = namedtype.NamedTypes(
+        namedtype.NamedType('type', AttributeType()),
+        namedtype.NamedType('values',
+                            univ.SetOf(componentType=AttributeValue()),
+                            openType=opentype.OpenType('type', certificateAttributesMap))
+    )
+
+ub_common_name = univ.Integer(64)
+
+id_pe = _buildOid(id_pkix, 1)
+
+
+class ExtensionPhysicalDeliveryAddressComponents(PDSParameter):
+    pass
+
+
+class EmailAddress(char.IA5String):
+    pass
+
+
+EmailAddress.subtypeSpec = constraint.ValueSizeConstraint(1, ub_emailaddress_length)
+
+id_at_organizationName = _buildOid(id_at, 10)
+
+post_office_box_address = univ.Integer(18)
+
+
+class BuiltInDomainDefinedAttribute(univ.Sequence):
+    pass
+
+
+BuiltInDomainDefinedAttribute.componentType = namedtype.NamedTypes(
+    namedtype.NamedType('type', char.PrintableString().subtype(
+        subtypeSpec=constraint.ValueSizeConstraint(1, ub_domain_defined_attribute_type_length))),
+    namedtype.NamedType('value', char.PrintableString().subtype(
+        subtypeSpec=constraint.ValueSizeConstraint(1, ub_domain_defined_attribute_value_length)))
+)
+
+
+class BuiltInDomainDefinedAttributes(univ.SequenceOf):
+    pass
+
+
+BuiltInDomainDefinedAttributes.componentType = BuiltInDomainDefinedAttribute()
+BuiltInDomainDefinedAttributes.sizeSpec = constraint.ValueSizeConstraint(1, ub_domain_defined_attributes)
+
+id_at_pseudonym = _buildOid(id_at, 65)
+
+id_domainComponent = _buildOid(0, 9, 2342, 19200300, 100, 1, 25)
+
+
+class X520CommonName(univ.Choice):
+    pass
+
+
+X520CommonName.componentType = namedtype.NamedTypes(
+    namedtype.NamedType('teletexString',
+                        char.TeletexString().subtype(subtypeSpec=constraint.ValueSizeConstraint(1, ub_common_name))),
+    namedtype.NamedType('printableString',
+                        char.PrintableString().subtype(subtypeSpec=constraint.ValueSizeConstraint(1, ub_common_name))),
+    namedtype.NamedType('universalString',
+                        char.UniversalString().subtype(subtypeSpec=constraint.ValueSizeConstraint(1, ub_common_name))),
+    namedtype.NamedType('utf8String',
+                        char.UTF8String().subtype(subtypeSpec=constraint.ValueSizeConstraint(1, ub_common_name))),
+    namedtype.NamedType('bmpString',
+                        char.BMPString().subtype(subtypeSpec=constraint.ValueSizeConstraint(1, ub_common_name)))
+)
+
+extension_OR_address_components = univ.Integer(12)
+
+ub_organizational_units = univ.Integer(4)
+
+teletex_personal_name = univ.Integer(4)
+
+ub_numeric_user_id_length = univ.Integer(32)
+
+ub_common_name_length = univ.Integer(64)
+
+
+class TeletexCommonName(char.TeletexString):
+    pass
+
+
+TeletexCommonName.subtypeSpec = constraint.ValueSizeConstraint(1, ub_common_name_length)
+
+
+class PhysicalDeliveryOrganizationName(PDSParameter):
+    pass
+
+
+extension_physical_delivery_address_components = univ.Integer(15)
+
+
+class NumericUserIdentifier(char.NumericString):
+    pass
+
+
+NumericUserIdentifier.subtypeSpec = constraint.ValueSizeConstraint(1, ub_numeric_user_id_length)
+
+
+class CountryName(univ.Choice):
+    pass
+
+
+CountryName.tagSet = univ.Choice.tagSet.tagExplicitly(tag.Tag(tag.tagClassApplication, tag.tagFormatConstructed, 1))
+CountryName.componentType = namedtype.NamedTypes(
+    namedtype.NamedType('x121-dcc-code', char.NumericString().subtype(
+        subtypeSpec=constraint.ValueSizeConstraint(ub_country_name_numeric_length, ub_country_name_numeric_length))),
+    namedtype.NamedType('iso-3166-alpha2-code', char.PrintableString().subtype(
+        subtypeSpec=constraint.ValueSizeConstraint(ub_country_name_alpha_length, ub_country_name_alpha_length)))
+)
+
+
+class OrganizationName(char.PrintableString):
+    pass
+
+
+OrganizationName.subtypeSpec = constraint.ValueSizeConstraint(1, ub_organization_name_length)
+
+
+class OrganizationalUnitNames(univ.SequenceOf):
+    pass
+
+
+OrganizationalUnitNames.componentType = OrganizationalUnitName()
+OrganizationalUnitNames.sizeSpec = constraint.ValueSizeConstraint(1, ub_organizational_units)
+
+
+class PrivateDomainName(univ.Choice):
+    pass
+
+
+PrivateDomainName.componentType = namedtype.NamedTypes(
+    namedtype.NamedType('numeric', char.NumericString().subtype(
+        subtypeSpec=constraint.ValueSizeConstraint(1, ub_domain_name_length))),
+    namedtype.NamedType('printable', char.PrintableString().subtype(
+        subtypeSpec=constraint.ValueSizeConstraint(1, ub_domain_name_length)))
+)
+
+
+class BuiltInStandardAttributes(univ.Sequence):
+    pass
+
+
+BuiltInStandardAttributes.componentType = namedtype.NamedTypes(
+    namedtype.OptionalNamedType('country-name', CountryName()),
+    namedtype.OptionalNamedType('administration-domain-name', AdministrationDomainName()),
+    namedtype.OptionalNamedType('network-address', NetworkAddress().subtype(
+        implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 0))),
+    namedtype.OptionalNamedType('terminal-identifier', TerminalIdentifier().subtype(
+        implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 1))),
+    namedtype.OptionalNamedType('private-domain-name', PrivateDomainName().subtype(
+        explicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatConstructed, 2))),
+    namedtype.OptionalNamedType('organization-name', OrganizationName().subtype(
+        implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 3))),
+    namedtype.OptionalNamedType('numeric-user-identifier', NumericUserIdentifier().subtype(
+        implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 4))),
+    namedtype.OptionalNamedType('personal-name', PersonalName().subtype(
+        implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatConstructed, 5))),
+    namedtype.OptionalNamedType('organizational-unit-names', OrganizationalUnitNames().subtype(
+        implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 6)))
+)
+
+
+class ORAddress(univ.Sequence):
+    pass
+
+
+ORAddress.componentType = namedtype.NamedTypes(
+    namedtype.NamedType('built-in-standard-attributes', BuiltInStandardAttributes()),
+    namedtype.OptionalNamedType('built-in-domain-defined-attributes', BuiltInDomainDefinedAttributes()),
+    namedtype.OptionalNamedType('extension-attributes', ExtensionAttributes())
+)
+
+
+class DistinguishedName(RDNSequence):
+    pass
+
+
+id_ad_timeStamping = _buildOid(id_ad, 3)
+
+
+class PhysicalDeliveryOfficeNumber(PDSParameter):
+    pass
+
+
+teletex_domain_defined_attributes = univ.Integer(6)
+
+
+class UniquePostalName(PDSParameter):
+    pass
+
+
+physical_delivery_country_name = univ.Integer(8)
+
+ub_pds_name_length = univ.Integer(16)
+
+
+class PDSName(char.PrintableString):
+    pass
+
+
+PDSName.subtypeSpec = constraint.ValueSizeConstraint(1, ub_pds_name_length)
+
+
+class TeletexPersonalName(univ.Set):
+    pass
+
+
+TeletexPersonalName.componentType = namedtype.NamedTypes(
+    namedtype.NamedType('surname', char.TeletexString().subtype(
+        subtypeSpec=constraint.ValueSizeConstraint(1, ub_surname_length)).subtype(
+        implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 0))),
+    namedtype.OptionalNamedType('given-name', char.TeletexString().subtype(
+        subtypeSpec=constraint.ValueSizeConstraint(1, ub_given_name_length)).subtype(
+        implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 1))),
+    namedtype.OptionalNamedType('initials', char.TeletexString().subtype(
+        subtypeSpec=constraint.ValueSizeConstraint(1, ub_initials_length)).subtype(
+        implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 2))),
+    namedtype.OptionalNamedType('generation-qualifier', char.TeletexString().subtype(
+        subtypeSpec=constraint.ValueSizeConstraint(1, ub_generation_qualifier_length)).subtype(
+        implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 3)))
+)
+
+street_address = univ.Integer(17)
+
+
+class PostOfficeBoxAddress(PDSParameter):
+    pass
+
+
+local_postal_attributes = univ.Integer(21)
+
+
+class DirectoryString(univ.Choice):
+    pass
+
+
+DirectoryString.componentType = namedtype.NamedTypes(
+    namedtype.NamedType('teletexString',
+                        char.TeletexString().subtype(subtypeSpec=constraint.ValueSizeConstraint(1, MAX))),
+    namedtype.NamedType('printableString',
+                        char.PrintableString().subtype(subtypeSpec=constraint.ValueSizeConstraint(1, MAX))),
+    namedtype.NamedType('universalString',
+                        char.UniversalString().subtype(subtypeSpec=constraint.ValueSizeConstraint(1, MAX))),
+    namedtype.NamedType('utf8String', char.UTF8String().subtype(subtypeSpec=constraint.ValueSizeConstraint(1, MAX))),
+    namedtype.NamedType('bmpString', char.BMPString().subtype(subtypeSpec=constraint.ValueSizeConstraint(1, MAX)))
+)
+
+teletex_common_name = univ.Integer(2)
+
+
+class CommonName(char.PrintableString):
+    pass
+
+
+CommonName.subtypeSpec = constraint.ValueSizeConstraint(1, ub_common_name_length)
+
+
+class Certificate(univ.Sequence):
+    pass
+
+
+Certificate.componentType = namedtype.NamedTypes(
+    namedtype.NamedType('tbsCertificate', TBSCertificate()),
+    namedtype.NamedType('signatureAlgorithm', AlgorithmIdentifier()),
+    namedtype.NamedType('signature', univ.BitString())
+)
+
+
+class TeletexOrganizationalUnitName(char.TeletexString):
+    pass
+
+
+TeletexOrganizationalUnitName.subtypeSpec = constraint.ValueSizeConstraint(1, ub_organizational_unit_name_length)
+
+id_at_name = _buildOid(id_at, 41)
+
+
+class TeletexOrganizationalUnitNames(univ.SequenceOf):
+    pass
+
+
+TeletexOrganizationalUnitNames.componentType = TeletexOrganizationalUnitName()
+TeletexOrganizationalUnitNames.sizeSpec = constraint.ValueSizeConstraint(1, ub_organizational_units)
+
+id_ce = _buildOid(2, 5, 29)
+
+id_ce_issuerAltName = _buildOid(id_ce, 18)
+
+
+class SkipCerts(univ.Integer):
+    pass
+
+
+SkipCerts.subtypeSpec = constraint.ValueRangeConstraint(0, MAX)
+
+
+class CRLReason(univ.Enumerated):
+    pass
+
+
+CRLReason.namedValues = namedval.NamedValues(
+    ('unspecified', 0),
+    ('keyCompromise', 1),
+    ('cACompromise', 2),
+    ('affiliationChanged', 3),
+    ('superseded', 4),
+    ('cessationOfOperation', 5),
+    ('certificateHold', 6),
+    ('removeFromCRL', 8),
+    ('privilegeWithdrawn', 9),
+    ('aACompromise', 10)
+)
+
+
+class PrivateKeyUsagePeriod(univ.Sequence):
+    pass
+
+
+PrivateKeyUsagePeriod.componentType = namedtype.NamedTypes(
+    namedtype.OptionalNamedType('notBefore', useful.GeneralizedTime().subtype(
+        implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 0))),
+    namedtype.OptionalNamedType('notAfter', useful.GeneralizedTime().subtype(
+        implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 1)))
+)
+
+
+anotherNameMap = {
+
+}
+
+
+class AnotherName(univ.Sequence):
+    componentType = namedtype.NamedTypes(
+        namedtype.NamedType('type-id', univ.ObjectIdentifier()),
+        namedtype.NamedType(
+            'value',
+            univ.Any().subtype(explicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 0)),
+            openType=opentype.OpenType('type-id', anotherNameMap)
+        )
+    )
+
+
+class EDIPartyName(univ.Sequence):
+    pass
+
+
+EDIPartyName.componentType = namedtype.NamedTypes(
+    namedtype.OptionalNamedType('nameAssigner', DirectoryString().subtype(
+        implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatConstructed, 0))),
+    namedtype.NamedType('partyName', DirectoryString().subtype(
+        implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatConstructed, 1)))
+)
+
+
+class GeneralName(univ.Choice):
+    pass
+
+
+GeneralName.componentType = namedtype.NamedTypes(
+    namedtype.NamedType('otherName',
+                        AnotherName().subtype(implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatConstructed, 0))),
+    namedtype.NamedType('rfc822Name',
+                        char.IA5String().subtype(implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 1))),
+    namedtype.NamedType('dNSName',
+                        char.IA5String().subtype(implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 2))),
+    namedtype.NamedType('x400Address',
+                        ORAddress().subtype(implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 3))),
+    namedtype.NamedType('directoryName',
+                        Name().subtype(implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatConstructed, 4))),
+    namedtype.NamedType('ediPartyName',
+                        EDIPartyName().subtype(implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatConstructed, 5))),
+    namedtype.NamedType('uniformResourceIdentifier',
+                        char.IA5String().subtype(implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 6))),
+    namedtype.NamedType('iPAddress',
+                        univ.OctetString().subtype(implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 7))),
+    namedtype.NamedType('registeredID', univ.ObjectIdentifier().subtype(
+        implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 8)))
+)
+
+
+class BaseDistance(univ.Integer):
+    pass
+
+
+BaseDistance.subtypeSpec = constraint.ValueRangeConstraint(0, MAX)
+
+
+class GeneralSubtree(univ.Sequence):
+    pass
+
+
+GeneralSubtree.componentType = namedtype.NamedTypes(
+    namedtype.NamedType('base', GeneralName()),
+    namedtype.DefaultedNamedType('minimum', BaseDistance().subtype(
+        implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 0)).subtype(value=0)),
+    namedtype.OptionalNamedType('maximum', BaseDistance().subtype(
+        implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 1)))
+)
+
+
+class GeneralNames(univ.SequenceOf):
+    pass
+
+
+GeneralNames.componentType = GeneralName()
+GeneralNames.sizeSpec = constraint.ValueSizeConstraint(1, MAX)
+
+
+class DistributionPointName(univ.Choice):
+    pass
+
+
+DistributionPointName.componentType = namedtype.NamedTypes(
+    namedtype.NamedType('fullName',
+                        GeneralNames().subtype(implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 0))),
+    namedtype.NamedType('nameRelativeToCRLIssuer', RelativeDistinguishedName().subtype(
+        implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 1)))
+)
+
+
+class ReasonFlags(univ.BitString):
+    pass
+
+
+ReasonFlags.namedValues = namedval.NamedValues(
+    ('unused', 0),
+    ('keyCompromise', 1),
+    ('cACompromise', 2),
+    ('affiliationChanged', 3),
+    ('superseded', 4),
+    ('cessationOfOperation', 5),
+    ('certificateHold', 6),
+    ('privilegeWithdrawn', 7),
+    ('aACompromise', 8)
+)
+
+
+class IssuingDistributionPoint(univ.Sequence):
+    pass
+
+
+IssuingDistributionPoint.componentType = namedtype.NamedTypes(
+    namedtype.OptionalNamedType('distributionPoint', DistributionPointName().subtype(
+        implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatConstructed, 0))),
+    namedtype.DefaultedNamedType('onlyContainsUserCerts', univ.Boolean().subtype(
+        implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 1)).subtype(value=0)),
+    namedtype.DefaultedNamedType('onlyContainsCACerts', univ.Boolean().subtype(
+        implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 2)).subtype(value=0)),
+    namedtype.OptionalNamedType('onlySomeReasons', ReasonFlags().subtype(
+        implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 3))),
+    namedtype.DefaultedNamedType('indirectCRL', univ.Boolean().subtype(
+        implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 4)).subtype(value=0)),
+    namedtype.DefaultedNamedType('onlyContainsAttributeCerts', univ.Boolean().subtype(
+        implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 5)).subtype(value=0))
+)
+
+id_ce_certificatePolicies = _buildOid(id_ce, 32)
+
+id_kp_emailProtection = _buildOid(id_kp, 4)
+
+
+class AccessDescription(univ.Sequence):
+    pass
+
+
+AccessDescription.componentType = namedtype.NamedTypes(
+    namedtype.NamedType('accessMethod', univ.ObjectIdentifier()),
+    namedtype.NamedType('accessLocation', GeneralName())
+)
+
+
+class IssuerAltName(GeneralNames):
+    pass
+
+
+id_ce_cRLDistributionPoints = _buildOid(id_ce, 31)
+
+holdInstruction = _buildOid(2, 2, 840, 10040, 2)
+
+id_holdinstruction_callissuer = _buildOid(holdInstruction, 2)
+
+id_ce_subjectDirectoryAttributes = _buildOid(id_ce, 9)
+
+id_ce_issuingDistributionPoint = _buildOid(id_ce, 28)
+
+
+class DistributionPoint(univ.Sequence):
+    pass
+
+
+DistributionPoint.componentType = namedtype.NamedTypes(
+    namedtype.OptionalNamedType('distributionPoint', DistributionPointName().subtype(
+        implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatConstructed, 0))),
+    namedtype.OptionalNamedType('reasons', ReasonFlags().subtype(
+        implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 1))),
+    namedtype.OptionalNamedType('cRLIssuer', GeneralNames().subtype(
+        implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 2)))
+)
+
+
+class CRLDistributionPoints(univ.SequenceOf):
+    pass
+
+
+CRLDistributionPoints.componentType = DistributionPoint()
+CRLDistributionPoints.sizeSpec = constraint.ValueSizeConstraint(1, MAX)
+
+
+class GeneralSubtrees(univ.SequenceOf):
+    pass
+
+
+GeneralSubtrees.componentType = GeneralSubtree()
+GeneralSubtrees.sizeSpec = constraint.ValueSizeConstraint(1, MAX)
+
+
+class NameConstraints(univ.Sequence):
+    pass
+
+
+NameConstraints.componentType = namedtype.NamedTypes(
+    namedtype.OptionalNamedType('permittedSubtrees', GeneralSubtrees().subtype(
+        implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 0))),
+    namedtype.OptionalNamedType('excludedSubtrees', GeneralSubtrees().subtype(
+        implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 1)))
+)
+
+
+class SubjectDirectoryAttributes(univ.SequenceOf):
+    pass
+
+
+SubjectDirectoryAttributes.componentType = Attribute()
+SubjectDirectoryAttributes.sizeSpec = constraint.ValueSizeConstraint(1, MAX)
+
+id_kp_OCSPSigning = _buildOid(id_kp, 9)
+
+id_kp_timeStamping = _buildOid(id_kp, 8)
+
+
+class DisplayText(univ.Choice):
+    pass
+
+
+DisplayText.componentType = namedtype.NamedTypes(
+    namedtype.NamedType('ia5String', char.IA5String().subtype(subtypeSpec=constraint.ValueSizeConstraint(1, 200))),
+    namedtype.NamedType('visibleString',
+                        char.VisibleString().subtype(subtypeSpec=constraint.ValueSizeConstraint(1, 200))),
+    namedtype.NamedType('bmpString', char.BMPString().subtype(subtypeSpec=constraint.ValueSizeConstraint(1, 200))),
+    namedtype.NamedType('utf8String', char.UTF8String().subtype(subtypeSpec=constraint.ValueSizeConstraint(1, 200)))
+)
+
+
+class NoticeReference(univ.Sequence):
+    pass
+
+
+NoticeReference.componentType = namedtype.NamedTypes(
+    namedtype.NamedType('organization', DisplayText()),
+    namedtype.NamedType('noticeNumbers', univ.SequenceOf(componentType=univ.Integer()))
+)
+
+
+class UserNotice(univ.Sequence):
+    pass
+
+
+UserNotice.componentType = namedtype.NamedTypes(
+    namedtype.OptionalNamedType('noticeRef', NoticeReference()),
+    namedtype.OptionalNamedType('explicitText', DisplayText())
+)
+
+
+class PolicyQualifierId(univ.ObjectIdentifier):
+    pass
+
+
+policyQualifierInfoMap = {
+
+}
+
+
+class PolicyQualifierInfo(univ.Sequence):
+    componentType = namedtype.NamedTypes(
+        namedtype.NamedType('policyQualifierId', PolicyQualifierId()),
+        namedtype.NamedType(
+            'qualifier', univ.Any(),
+            openType=opentype.OpenType('policyQualifierId', policyQualifierInfoMap)
+        )
+    )
+
+
+class CertPolicyId(univ.ObjectIdentifier):
+    pass
+
+
+class PolicyInformation(univ.Sequence):
+    pass
+
+
+PolicyInformation.componentType = namedtype.NamedTypes(
+    namedtype.NamedType('policyIdentifier', CertPolicyId()),
+    namedtype.OptionalNamedType('policyQualifiers', univ.SequenceOf(componentType=PolicyQualifierInfo()))
+)
+
+
+class CertificatePolicies(univ.SequenceOf):
+    pass
+
+
+CertificatePolicies.componentType = PolicyInformation()
+CertificatePolicies.sizeSpec = constraint.ValueSizeConstraint(1, MAX)
+
+
+class SubjectAltName(GeneralNames):
+    pass
+
+
+id_ce_basicConstraints = _buildOid(id_ce, 19)
+
+id_ce_authorityKeyIdentifier = _buildOid(id_ce, 35)
+
+id_kp_codeSigning = _buildOid(id_kp, 3)
+
+
+class BasicConstraints(univ.Sequence):
+    pass
+
+
+BasicConstraints.componentType = namedtype.NamedTypes(
+    namedtype.DefaultedNamedType('cA', univ.Boolean().subtype(value=0)),
+    namedtype.OptionalNamedType('pathLenConstraint',
+                                univ.Integer().subtype(subtypeSpec=constraint.ValueRangeConstraint(0, MAX)))
+)
+
+id_ce_certificateIssuer = _buildOid(id_ce, 29)
+
+
+class PolicyMappings(univ.SequenceOf):
+    pass
+
+
+PolicyMappings.componentType = univ.Sequence(
+    componentType=namedtype.NamedTypes(
+        namedtype.NamedType('issuerDomainPolicy', CertPolicyId()),
+        namedtype.NamedType('subjectDomainPolicy', CertPolicyId())
+    )
+)
+
+PolicyMappings.sizeSpec = constraint.ValueSizeConstraint(1, MAX)
+
+
+class InhibitAnyPolicy(SkipCerts):
+    pass
+
+
+anyPolicy = _buildOid(id_ce_certificatePolicies, 0)
+
+
+class CRLNumber(univ.Integer):
+    pass
+
+
+CRLNumber.subtypeSpec = constraint.ValueRangeConstraint(0, MAX)
+
+
+class BaseCRLNumber(CRLNumber):
+    pass
+
+
+id_ce_nameConstraints = _buildOid(id_ce, 30)
+
+id_kp_serverAuth = _buildOid(id_kp, 1)
+
+id_ce_freshestCRL = _buildOid(id_ce, 46)
+
+id_ce_cRLReasons = _buildOid(id_ce, 21)
+
+id_ce_extKeyUsage = _buildOid(id_ce, 37)
+
+
+class KeyIdentifier(univ.OctetString):
+    pass
+
+
+class AuthorityKeyIdentifier(univ.Sequence):
+    pass
+
+
+AuthorityKeyIdentifier.componentType = namedtype.NamedTypes(
+    namedtype.OptionalNamedType('keyIdentifier', KeyIdentifier().subtype(
+        implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 0))),
+    namedtype.OptionalNamedType('authorityCertIssuer', GeneralNames().subtype(
+        implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 1))),
+    namedtype.OptionalNamedType('authorityCertSerialNumber', CertificateSerialNumber().subtype(
+        implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 2)))
+)
+
+
+class FreshestCRL(CRLDistributionPoints):
+    pass
+
+
+id_ce_policyConstraints = _buildOid(id_ce, 36)
+
+id_pe_authorityInfoAccess = _buildOid(id_pe, 1)
+
+
+class AuthorityInfoAccessSyntax(univ.SequenceOf):
+    pass
+
+
+AuthorityInfoAccessSyntax.componentType = AccessDescription()
+AuthorityInfoAccessSyntax.sizeSpec = constraint.ValueSizeConstraint(1, MAX)
+
+id_holdinstruction_none = _buildOid(holdInstruction, 1)
+
+
+class CPSuri(char.IA5String):
+    pass
+
+
+id_pe_subjectInfoAccess = _buildOid(id_pe, 11)
+
+
+class SubjectKeyIdentifier(KeyIdentifier):
+    pass
+
+
+id_ce_subjectAltName = _buildOid(id_ce, 17)
+
+
+class KeyPurposeId(univ.ObjectIdentifier):
+    pass
+
+
+class ExtKeyUsageSyntax(univ.SequenceOf):
+    pass
+
+
+ExtKeyUsageSyntax.componentType = KeyPurposeId()
+ExtKeyUsageSyntax.sizeSpec = constraint.ValueSizeConstraint(1, MAX)
+
+
+class HoldInstructionCode(univ.ObjectIdentifier):
+    pass
+
+
+id_ce_deltaCRLIndicator = _buildOid(id_ce, 27)
+
+id_ce_keyUsage = _buildOid(id_ce, 15)
+
+id_ce_holdInstructionCode = _buildOid(id_ce, 23)
+
+
+class SubjectInfoAccessSyntax(univ.SequenceOf):
+    pass
+
+
+SubjectInfoAccessSyntax.componentType = AccessDescription()
+SubjectInfoAccessSyntax.sizeSpec = constraint.ValueSizeConstraint(1, MAX)
+
+
+class InvalidityDate(useful.GeneralizedTime):
+    pass
+
+
+class KeyUsage(univ.BitString):
+    pass
+
+
+KeyUsage.namedValues = namedval.NamedValues(
+    ('digitalSignature', 0),
+    ('nonRepudiation', 1),
+    ('keyEncipherment', 2),
+    ('dataEncipherment', 3),
+    ('keyAgreement', 4),
+    ('keyCertSign', 5),
+    ('cRLSign', 6),
+    ('encipherOnly', 7),
+    ('decipherOnly', 8)
+)
+
+id_ce_invalidityDate = _buildOid(id_ce, 24)
+
+id_ce_policyMappings = _buildOid(id_ce, 33)
+
+anyExtendedKeyUsage = _buildOid(id_ce_extKeyUsage, 0)
+
+id_ce_privateKeyUsagePeriod = _buildOid(id_ce, 16)
+
+id_ce_cRLNumber = _buildOid(id_ce, 20)
+
+
+class CertificateIssuer(GeneralNames):
+    pass
+
+
+id_holdinstruction_reject = _buildOid(holdInstruction, 3)
+
+
+class PolicyConstraints(univ.Sequence):
+    pass
+
+
+PolicyConstraints.componentType = namedtype.NamedTypes(
+    namedtype.OptionalNamedType('requireExplicitPolicy',
+                                SkipCerts().subtype(implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 0))),
+    namedtype.OptionalNamedType('inhibitPolicyMapping',
+                                SkipCerts().subtype(implicitTag=tag.Tag(tag.tagClassContext, tag.tagFormatSimple, 1)))
+)
+
+id_kp_clientAuth = _buildOid(id_kp, 2)
+
+id_ce_subjectKeyIdentifier = _buildOid(id_ce, 14)
+
+id_ce_inhibitAnyPolicy = _buildOid(id_ce, 54)
+
+# map of ORAddress ExtensionAttribute type to ExtensionAttribute value
+
+_oraddressExtensionAttributeMapUpdate = {
+    common_name: CommonName(),
+    teletex_common_name: TeletexCommonName(),
+    teletex_organization_name: TeletexOrganizationName(),
+    teletex_personal_name: TeletexPersonalName(),
+    teletex_organizational_unit_names: TeletexOrganizationalUnitNames(),
+    pds_name: PDSName(),
+    physical_delivery_country_name: PhysicalDeliveryCountryName(),
+    postal_code: PostalCode(),
+    physical_delivery_office_name: PhysicalDeliveryOfficeName(),
+    physical_delivery_office_number: PhysicalDeliveryOfficeNumber(),
+    extension_OR_address_components: ExtensionORAddressComponents(),
+    physical_delivery_personal_name: PhysicalDeliveryPersonalName(),
+    physical_delivery_organization_name: PhysicalDeliveryOrganizationName(),
+    extension_physical_delivery_address_components: ExtensionPhysicalDeliveryAddressComponents(),
+    unformatted_postal_address: UnformattedPostalAddress(),
+    street_address: StreetAddress(),
+    post_office_box_address: PostOfficeBoxAddress(),
+    poste_restante_address: PosteRestanteAddress(),
+    unique_postal_name: UniquePostalName(),
+    local_postal_attributes: LocalPostalAttributes(),
+    extended_network_address: ExtendedNetworkAddress(),
+    terminal_type: TerminalType(),
+    teletex_domain_defined_attributes: TeletexDomainDefinedAttributes(),
+}
+
+oraddressExtensionAttributeMap.update(_oraddressExtensionAttributeMapUpdate)
+
+
+# map of AttributeType -> AttributeValue
+
+_certificateAttributesMapUpdate = {
+    id_at_name: X520name(),
+    id_at_surname: X520name(),
+    id_at_givenName: X520name(),
+    id_at_initials: X520name(),
+    id_at_generationQualifier: X520name(),
+    id_at_commonName: X520CommonName(),
+    id_at_localityName: X520LocalityName(),
+    id_at_stateOrProvinceName: X520StateOrProvinceName(),
+    id_at_organizationName: X520OrganizationName(),
+    id_at_organizationalUnitName: X520OrganizationalUnitName(),
+    id_at_title: X520Title(),
+    id_at_dnQualifier: X520dnQualifier(),
+    id_at_countryName: X520countryName(),
+    id_at_serialNumber: X520SerialNumber(),
+    id_at_pseudonym: X520Pseudonym(),
+    id_domainComponent: DomainComponent(),
+    id_emailAddress: EmailAddress(),
+}
+
+certificateAttributesMap.update(_certificateAttributesMapUpdate)
+
+
+# map of Certificate Extension OIDs to Extensions
+
+_certificateExtensionsMap = {
+    id_ce_authorityKeyIdentifier: AuthorityKeyIdentifier(),
+    id_ce_subjectKeyIdentifier: SubjectKeyIdentifier(),
+    id_ce_keyUsage: KeyUsage(),
+    id_ce_privateKeyUsagePeriod: PrivateKeyUsagePeriod(),
+    id_ce_certificatePolicies: CertificatePolicies(),
+    id_ce_policyMappings: PolicyMappings(),
+    id_ce_subjectAltName: SubjectAltName(),
+    id_ce_issuerAltName: IssuerAltName(),
+    id_ce_subjectDirectoryAttributes: SubjectDirectoryAttributes(),
+    id_ce_basicConstraints: BasicConstraints(),
+    id_ce_nameConstraints: NameConstraints(),
+    id_ce_policyConstraints: PolicyConstraints(),
+    id_ce_extKeyUsage: ExtKeyUsageSyntax(),
+    id_ce_cRLDistributionPoints: CRLDistributionPoints(),
+    id_pe_authorityInfoAccess: AuthorityInfoAccessSyntax(),
+    id_ce_cRLNumber: univ.Integer(),
+    id_ce_deltaCRLIndicator: BaseCRLNumber(),
+    id_ce_issuingDistributionPoint: IssuingDistributionPoint(),
+    id_ce_cRLReasons: CRLReason(),
+    id_ce_holdInstructionCode: univ.ObjectIdentifier(),
+    id_ce_invalidityDate: useful.GeneralizedTime(),
+    id_ce_certificateIssuer: GeneralNames(),
+}
+
+certificateExtensionsMap.update(_certificateExtensionsMap)

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/pyasn1_modules/rfc5916.py

@@ -0,0 +1,35 @@
+#
+# This file is part of pyasn1-modules software.
+#
+# Created by Russ Housley.
+#
+# Copyright (c) 2019, Vigil Security, LLC
+# License: http://snmplabs.com/pyasn1/license.html
+#
+# Device Owner Attribute
+#
+# ASN.1 source from:
+# https://www.rfc-editor.org/rfc/rfc5916.txt
+#
+
+from pyasn1.type import univ
+
+from pyasn1_modules import rfc5280
+
+
+# Device Owner Attribute
+
+id_deviceOwner = univ.ObjectIdentifier((2, 16, 840, 1, 101, 2, 1, 5, 69))
+
+at_deviceOwner = rfc5280.Attribute()
+at_deviceOwner['type'] = id_deviceOwner
+at_deviceOwner['values'][0] = univ.ObjectIdentifier()
+
+
+# Add to the map of Attribute Type OIDs to Attributes in rfc5280.py.
+
+_certificateAttributesMapUpdate = {
+    id_deviceOwner: univ.ObjectIdentifier(),
+}
+
+rfc5280.certificateAttributesMap.update(_certificateAttributesMapUpdate)

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/pyasn1_modules/rfc5990.py

@@ -0,0 +1,237 @@
+#
+# This file is part of pyasn1-modules software.
+#
+# Created by Russ Housley with assistance from asn1ate v.0.6.0.
+#
+# Copyright (c) 2019, Vigil Security, LLC
+# License: http://snmplabs.com/pyasn1/license.html
+#
+# Use of the RSA-KEM Key Transport Algorithm in the CMS
+#
+# ASN.1 source from:
+# https://www.rfc-editor.org/rfc/rfc5990.txt
+#
+
+from pyasn1.type import constraint
+from pyasn1.type import namedtype
+from pyasn1.type import univ
+
+from pyasn1_modules import rfc5280
+
+MAX = float('inf')
+
+def _OID(*components):
+    output = []
+    for x in tuple(components):
+        if isinstance(x, univ.ObjectIdentifier):
+            output.extend(list(x))
+        else:
+            output.append(int(x))
+    return univ.ObjectIdentifier(output)
+
+
+# Imports from RFC 5280
+
+AlgorithmIdentifier = rfc5280.AlgorithmIdentifier
+
+
+# Useful types and definitions
+
+class NullParms(univ.Null):
+    pass
+
+
+# Object identifier arcs
+
+is18033_2 = _OID(1, 0, 18033, 2)
+
+nistAlgorithm = _OID(2, 16, 840, 1, 101, 3, 4)
+
+pkcs_1 = _OID(1, 2, 840, 113549, 1, 1)
+
+x9_44 = _OID(1, 3, 133, 16, 840, 9, 44)
+
+x9_44_components = _OID(x9_44, 1)
+
+
+# Types for algorithm identifiers
+
+class Camellia_KeyWrappingScheme(AlgorithmIdentifier):
+    pass
+
+class DataEncapsulationMechanism(AlgorithmIdentifier):
+    pass
+
+class KDF2_HashFunction(AlgorithmIdentifier):
+    pass
+
+class KDF3_HashFunction(AlgorithmIdentifier):
+    pass
+
+class KeyDerivationFunction(AlgorithmIdentifier):
+    pass
+
+class KeyEncapsulationMechanism(AlgorithmIdentifier):
+    pass
+
+class X9_SymmetricKeyWrappingScheme(AlgorithmIdentifier):
+    pass
+
+
+# RSA-KEM Key Transport Algorithm
+
+id_rsa_kem = _OID(1, 2, 840, 113549, 1, 9, 16, 3, 14)
+
+
+class GenericHybridParameters(univ.Sequence):
+    pass
+
+GenericHybridParameters.componentType = namedtype.NamedTypes(
+    namedtype.NamedType('kem', KeyEncapsulationMechanism()),
+    namedtype.NamedType('dem', DataEncapsulationMechanism())
+)
+
+
+rsa_kem = AlgorithmIdentifier()
+rsa_kem['algorithm'] = id_rsa_kem
+rsa_kem['parameters'] = GenericHybridParameters()
+
+
+# KEM-RSA Key Encapsulation Mechanism
+
+id_kem_rsa = _OID(is18033_2, 2, 4)
+
+
+class KeyLength(univ.Integer):
+    pass
+
+KeyLength.subtypeSpec = constraint.ValueRangeConstraint(1, MAX)
+
+
+class RsaKemParameters(univ.Sequence):
+    pass
+
+RsaKemParameters.componentType = namedtype.NamedTypes(
+    namedtype.NamedType('keyDerivationFunction', KeyDerivationFunction()),
+    namedtype.NamedType('keyLength', KeyLength())
+)
+
+
+kem_rsa = AlgorithmIdentifier()
+kem_rsa['algorithm'] = id_kem_rsa
+kem_rsa['parameters'] = RsaKemParameters()
+
+
+# Key Derivation Functions
+
+id_kdf_kdf2 = _OID(x9_44_components, 1)
+
+id_kdf_kdf3 = _OID(x9_44_components, 2)
+
+
+kdf2 = AlgorithmIdentifier()
+kdf2['algorithm'] = id_kdf_kdf2
+kdf2['parameters'] = KDF2_HashFunction()
+
+kdf3 = AlgorithmIdentifier()
+kdf3['algorithm'] = id_kdf_kdf3
+kdf3['parameters'] = KDF3_HashFunction()
+
+
+# Hash Functions
+
+id_sha1 = _OID(1, 3, 14, 3, 2, 26)
+
+id_sha224 = _OID(2, 16, 840, 1, 101, 3, 4, 2, 4)
+
+id_sha256 = _OID(2, 16, 840, 1, 101, 3, 4, 2, 1)
+
+id_sha384 = _OID(2, 16, 840, 1, 101, 3, 4, 2, 2)
+
+id_sha512 = _OID(2, 16, 840, 1, 101, 3, 4, 2, 3)
+
+
+sha1 = AlgorithmIdentifier()
+sha1['algorithm'] = id_sha1
+sha1['parameters'] = univ.Null("")
+
+sha224 = AlgorithmIdentifier()
+sha224['algorithm'] = id_sha224
+sha224['parameters'] = univ.Null("")
+
+sha256 = AlgorithmIdentifier()
+sha256['algorithm'] = id_sha256
+sha256['parameters'] = univ.Null("")
+
+sha384 = AlgorithmIdentifier()
+sha384['algorithm'] = id_sha384
+sha384['parameters'] = univ.Null("")
+
+sha512 = AlgorithmIdentifier()
+sha512['algorithm'] = id_sha512
+sha512['parameters'] = univ.Null("")
+
+
+# Symmetric Key-Wrapping Schemes
+
+id_aes128_Wrap = _OID(nistAlgorithm, 1, 5)
+
+id_aes192_Wrap = _OID(nistAlgorithm, 1, 25)
+
+id_aes256_Wrap = _OID(nistAlgorithm, 1, 45)
+
+id_alg_CMS3DESwrap = _OID(1, 2, 840, 113549, 1, 9, 16, 3, 6)
+
+id_camellia128_Wrap = _OID(1, 2, 392, 200011, 61, 1, 1, 3, 2)
+
+id_camellia192_Wrap = _OID(1, 2, 392, 200011, 61, 1, 1, 3, 3)
+
+id_camellia256_Wrap = _OID(1, 2, 392, 200011, 61, 1, 1, 3, 4)
+
+
+aes128_Wrap = AlgorithmIdentifier()
+aes128_Wrap['algorithm'] = id_aes128_Wrap
+# aes128_Wrap['parameters'] are absent
+
+aes192_Wrap = AlgorithmIdentifier()
+aes192_Wrap['algorithm'] = id_aes128_Wrap
+# aes192_Wrap['parameters'] are absent
+
+aes256_Wrap = AlgorithmIdentifier()
+aes256_Wrap['algorithm'] = id_sha256
+# aes256_Wrap['parameters'] are absent
+
+tdes_Wrap = AlgorithmIdentifier()
+tdes_Wrap['algorithm'] = id_alg_CMS3DESwrap
+tdes_Wrap['parameters'] = univ.Null("")
+
+camellia128_Wrap = AlgorithmIdentifier()
+camellia128_Wrap['algorithm'] = id_camellia128_Wrap
+# camellia128_Wrap['parameters'] are absent
+
+camellia192_Wrap = AlgorithmIdentifier()
+camellia192_Wrap['algorithm'] = id_camellia192_Wrap
+# camellia192_Wrap['parameters'] are absent
+
+camellia256_Wrap = AlgorithmIdentifier()
+camellia256_Wrap['algorithm'] = id_camellia256_Wrap
+# camellia256_Wrap['parameters'] are absent
+
+
+# Update the Algorithm Identifier map in rfc5280.py.
+# Note that the ones that must not have parameters are not added to the map.
+
+_algorithmIdentifierMapUpdate = {
+    id_rsa_kem: GenericHybridParameters(),
+    id_kem_rsa: RsaKemParameters(),
+    id_kdf_kdf2: KDF2_HashFunction(),
+    id_kdf_kdf3: KDF3_HashFunction(),
+    id_sha1: univ.Null(),
+    id_sha224: univ.Null(),
+    id_sha256: univ.Null(),
+    id_sha384: univ.Null(),
+    id_sha512: univ.Null(),
+    id_alg_CMS3DESwrap: univ.Null(),
+}
+
+rfc5280.algorithmIdentifierMap.update(_algorithmIdentifierMapUpdate)

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/pyasn1_modules/rfc6187.py

@@ -0,0 +1,22 @@
+#
+# This file is part of pyasn1-modules software.
+#
+# Created by Russ Housley.
+#
+# Copyright (c) 2019, Vigil Security, LLC
+# License: http://snmplabs.com/pyasn1/license.html
+#
+# X.509v3 Certificates for Secure Shell Authentication
+#
+# ASN.1 source from:
+# https://www.rfc-editor.org/rfc/rfc6187.txt
+#
+
+from pyasn1.type import univ
+
+id_pkix = univ.ObjectIdentifier('1.3.6.1.5.5.7')
+
+id_kp = id_pkix + (3, )
+
+id_kp_secureShellClient = id_kp + (21, )
+id_kp_secureShellServer = id_kp + (22, )

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/pyasn1_modules/rfc7633.py

@@ -0,0 +1,38 @@
+#
+# This file is part of pyasn1-modules software.
+#
+# Created by Russ Housley with some assistance from asn1ate v.0.6.0.
+#
+# Copyright (c) 2019, Vigil Security, LLC
+# License: http://snmplabs.com/pyasn1/license.html
+#
+# Transport Layer Security (TLS) Feature Certificate Extension
+#
+# ASN.1 source from:
+# https://www.rfc-editor.org/rfc/rfc7633.txt
+#
+
+from pyasn1.type import univ
+
+from pyasn1_modules import rfc5280
+
+
+# TLS Features Extension
+
+id_pe = univ.ObjectIdentifier('1.3.6.1.5.5.7.1')
+
+id_pe_tlsfeature = id_pe + (24, )
+
+
+class Features(univ.SequenceOf):
+    componentType = univ.Integer()
+
+
+# Map of Certificate Extension OIDs to Extensions added to the
+# ones that are in rfc5280.py
+
+_certificateExtensionsMapUpdate = {
+    id_pe_tlsfeature: Features(),
+}
+
+rfc5280.certificateExtensionsMap.update(_certificateExtensionsMapUpdate)

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/pyasn1_modules/rfc7773.py

@@ -0,0 +1,52 @@
+#
+# This file is part of pyasn1-modules software.
+#
+# Created by Russ Housley with some assistance from asn1ate v.0.6.0.
+#
+# Copyright (c) 2019, Vigil Security, LLC
+# License: http://snmplabs.com/pyasn1/license.html
+#
+# Authentication Context Certificate Extension
+#
+# ASN.1 source from:
+# https://www.rfc-editor.org/rfc/rfc7773.txt
+#
+
+from pyasn1.type import char
+from pyasn1.type import constraint
+from pyasn1.type import namedtype
+from pyasn1.type import univ
+
+from pyasn1_modules import rfc5280
+
+MAX = float('inf')
+
+
+# Authentication Context Extension
+
+e_legnamnden = univ.ObjectIdentifier('1.2.752.201')
+
+id_eleg_ce = e_legnamnden + (5, )
+
+id_ce_authContext = id_eleg_ce + (1, )
+
+
+class AuthenticationContext(univ.Sequence):
+    componentType = namedtype.NamedTypes(
+        namedtype.NamedType('contextType', char.UTF8String()),
+        namedtype.OptionalNamedType('contextInfo', char.UTF8String())
+    )
+
+class AuthenticationContexts(univ.SequenceOf):
+    componentType = AuthenticationContext()
+    subtypeSpec=constraint.ValueSizeConstraint(1, MAX)
+
+
+# Map of Certificate Extension OIDs to Extensions added to the
+# ones that are in rfc5280.py
+
+_certificateExtensionsMapUpdate = {
+    id_ce_authContext: AuthenticationContexts(),
+}
+
+rfc5280.certificateExtensionsMap.update(_certificateExtensionsMapUpdate)

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/pyasn1_modules/rfc8358.py

@@ -0,0 +1,50 @@
+#
+# This file is part of pyasn1-modules software.
+#
+# Created by Russ Housley.
+#
+# Copyright (c) 2019, Vigil Security, LLC
+# License: http://snmplabs.com/pyasn1/license.html
+#
+# Digital Signatures on Internet-Draft Documents
+#
+# ASN.1 source from:
+# https://www.rfc-editor.org/rfc/rfc8358.txt
+#
+
+from pyasn1.type import univ
+
+from pyasn1_modules import rfc5652
+
+
+id_ct = univ.ObjectIdentifier('1.2.840.113549.1.9.16.1')
+
+id_ct_asciiTextWithCRLF = id_ct + (27, )
+
+id_ct_epub = id_ct + (39, )
+
+id_ct_htmlWithCRLF = id_ct + (38, )
+
+id_ct_pdf = id_ct + (29, )
+
+id_ct_postscript = id_ct + (30, )
+
+id_ct_utf8TextWithCRLF = id_ct + (37, )
+
+id_ct_xml = id_ct + (28, )
+
+
+# Map of Content Type OIDs to Content Types is added to the
+# ones that are in rfc5652.py
+
+_cmsContentTypesMapUpdate = {
+    id_ct_asciiTextWithCRLF: univ.OctetString(),
+    id_ct_epub: univ.OctetString(),
+    id_ct_htmlWithCRLF: univ.OctetString(),
+    id_ct_pdf: univ.OctetString(),
+    id_ct_postscript: univ.OctetString(),
+    id_ct_utf8TextWithCRLF: univ.OctetString(),
+    id_ct_xml: univ.OctetString(),
+}
+
+rfc5652.cmsContentTypesMap.update(_cmsContentTypesMapUpdate)

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/pyasn1_modules/rfc8410.py

@@ -0,0 +1,43 @@
+# This file is being contributed to pyasn1-modules software.
+#
+# Created by Russ Housley.
+#
+# Copyright (c) 2019, Vigil Security, LLC
+# License: http://snmplabs.com/pyasn1/license.html
+#
+# Algorithm Identifiers for Ed25519, Ed448, X25519, and X448
+#
+# ASN.1 source from:
+# https://www.rfc-editor.org/rfc/rfc8410.txt
+
+from pyasn1.type import univ
+from pyasn1_modules import rfc3565
+from pyasn1_modules import rfc4055
+from pyasn1_modules import rfc5280
+
+
+class SignatureAlgorithmIdentifier(rfc5280.AlgorithmIdentifier):
+    pass
+
+
+class KeyEncryptionAlgorithmIdentifier(rfc5280.AlgorithmIdentifier):
+    pass
+
+
+class CurvePrivateKey(univ.OctetString):
+    pass
+
+
+id_X25519 = univ.ObjectIdentifier('1.3.101.110')
+
+id_X448 = univ.ObjectIdentifier('1.3.101.111')
+
+id_Ed25519 = univ.ObjectIdentifier('1.3.101.112')
+
+id_Ed448 = univ.ObjectIdentifier('1.3.101.113')
+
+id_sha512 = rfc4055.id_sha512
+
+id_aes128_wrap = rfc3565.id_aes128_wrap
+
+id_aes256_wrap = rfc3565.id_aes256_wrap

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

@@ -0,0 +1,120 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# 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.
+# ==============================================================================
+"""TensorBoard is a webapp for understanding TensorFlow runs and graphs."""
+
+
+from tensorboard import lazy as _lazy
+from tensorboard import version as _version
+
+# TensorBoard public API.
+__all__ = [
+    "__version__",
+    "errors",
+    "notebook",
+    "program",
+    "summary",
+]
+
+
+# Please be careful when changing the structure of this file.
+#
+# The lazy imports in this file must use `importlib.import_module`, not
+# `import tensorboard.foo` or `from tensorboard import foo`, or it will
+# be impossible to reload the TensorBoard module without breaking these
+# top-level public APIs. This has to do with the gory details of
+# Python's module system. Take `tensorboard.notebook` as an example:
+#
+#   - When the `tensorboard` module (that's us!) is initialized, its
+#     `notebook` attribute is initialized to a new LazyModule. The
+#     actual `tensorboard.notebook` submodule is not loaded.
+#
+#   - When the `tensorboard.notebook` submodule is first loaded, Python
+#     _reassigns_ the `notebook` attribute on the `tensorboard` module
+#     object to point to the underlying `tensorboard.notebook` module
+#     object, rather than its former LazyModule value. This occurs
+#     whether the module is loaded via the lazy module or directly as an
+#     import:
+#
+#       - import tensorboard; tensorboard.notebook.start(...)  # one way
+#       - from tensorboard import notebook  # other way; same effect
+#
+#   - When the `tensorboard` module is reloaded, its `notebook`
+#     attribute is once again bound to a (new) LazyModule, while the
+#     `tensorboard.notebook` module object is unaffected and still
+#     exists in `sys.modules`. But then...
+#
+#   - When the new LazyModule is forced, it must resolve to the existing
+#     `tensorboard.notebook` module object rather than itself (which
+#     just creates a stack overflow). If the LazyModule load function
+#     uses `import tensorboard.notebook; return tensorboard.notebook`,
+#     then the first statement will do _nothing_ because the
+#     `tensorboard.notebook` module is already loaded, and the second
+#     statement will return the LazyModule itself. The same goes for the
+#     `from tensorboard import notebook` form. We need to ensure that
+#     the submodule is loaded and then pull the actual module object out
+#     of `sys.modules`... which is exactly what `importlib` handles for
+#     us.
+#
+# See <https://github.com/tensorflow/tensorboard/issues/1989> for
+# additional discussion.
+
+
+@_lazy.lazy_load("tensorboard.data")
+def data():
+    import importlib
+
+    return importlib.import_module("tensorboard.data")
+
+
+@_lazy.lazy_load("tensorboard.errors")
+def errors():
+    import importlib
+
+    return importlib.import_module("tensorboard.errors")
+
+
+@_lazy.lazy_load("tensorboard.notebook")
+def notebook():
+    import importlib
+
+    return importlib.import_module("tensorboard.notebook")
+
+
+@_lazy.lazy_load("tensorboard.program")
+def program():
+    import importlib
+
+    return importlib.import_module("tensorboard.program")
+
+
+@_lazy.lazy_load("tensorboard.summary")
+def summary():
+    import importlib
+
+    return importlib.import_module("tensorboard.summary")
+
+
+def load_ipython_extension(ipython):
+    """IPython API entry point.
+
+    Only intended to be called by the IPython runtime.
+
+    See:
+      https://ipython.readthedocs.io/en/stable/config/extensions/index.html
+    """
+    notebook._load_ipython_extension(ipython)
+
+
+__version__ = _version.VERSION

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/tensorboard/assets.py

@@ -0,0 +1,36 @@
+# Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+#
+# 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.
+# ==============================================================================
+"""Bindings for TensorBoard frontend assets."""
+
+import os
+
+from tensorboard.util import tb_logging
+
+logger = tb_logging.get_logger()
+
+
+def get_default_assets_zip_provider():
+    """Try to get a function to provide frontend assets.
+
+    Returns:
+      Either (a) a callable that takes no arguments and returns an open
+      file handle to a Zip archive of frontend assets, or (b) `None`, if
+      the frontend assets cannot be found.
+    """
+    path = os.path.join(os.path.dirname(__file__), "webfiles.zip")
+    if not os.path.exists(path):
+        logger.warning("webfiles.zip static assets not found: %s", path)
+        return None
+    return lambda: open(path, "rb")

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/tensorboard/auth.py

@@ -0,0 +1,102 @@
+# Copyright 2020 The TensorFlow Authors. All Rights Reserved.
+#
+# 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.
+# ==============================================================================
+"""Experimental framework for authentication in TensorBoard."""
+
+import abc
+
+
+class AuthProvider(metaclass=abc.ABCMeta):
+    """Authentication provider for a specific kind of credential."""
+
+    def authenticate(self, environ):
+        """Produce an opaque auth token from a WSGI request environment.
+
+        Args:
+          environ: A WSGI environment `dict`; see PEP 3333.
+
+        Returns:
+          A Python object representing an auth token. The representation
+          and semantics depend on the particular `AuthProvider`
+          implementation.
+
+        Raises:
+          Exception: Any error, usually `tensorboard.errors.PublicError`
+            subclasses (like `PermissionDenied`) but also possibly a
+            custom error type that should propagate to a WSGI middleware
+            for effecting a redirect-driven auth flow.
+        """
+        pass
+
+
+class AuthContext(object):
+    """Authentication context within the scope of a single request.
+
+    Auth providers are keyed within an `AuthContext` by arbitrary
+    unique keys. It may often make sense for the key used for an
+    auth provider to simply be that provider's type object.
+    """
+
+    def __init__(self, providers, environ):
+        """Create an auth context.
+
+        Args:
+          providers: A mapping from provider keys (opaque values) to
+            `AuthProvider` implementations.
+          environ: A WSGI environment (see PEP 3333).
+        """
+        self._environ = environ
+        self._providers = providers
+        self._cache = {}
+
+    @classmethod
+    def empty(cls):
+        """Create an auth context with no registered providers.
+
+        Returns:
+          A new `AuthContext` value for which any call to `get` will
+          fail with a `KeyError`.
+        """
+        # Use an empty dict for the environ. This is not a valid WSGI
+        # environment, but it doesn't matter because it's never used.
+        return cls({}, {})
+
+    def get(self, provider_key):
+        """Get an auth token from the auth provider with the given key.
+
+        If successful, the result will be cached on this auth context.
+        If unsuccessful, nothing will be cached, so a future call will
+        invoke the underlying `AuthProvider.authenticate` method again.
+
+        This method is not thread-safe. If multiple threads share an
+        auth context for a single request, then they must synchronize
+        externally when calling this method.
+
+        Returns:
+          The result of `provider.authenticate(...)` for the auth
+          provider specified by `provider_key`.
+
+        Raises:
+          KeyError: If the given `provider_key` does not correspond to
+            any registered `AuthProvider`.
+          Exception: As raised by the underlying `AuthProvider`.
+        """
+        provider = self._providers[provider_key]
+        sentinel = object()
+        value = self._cache.get(provider_key, sentinel)
+        if value is not sentinel:
+            return value
+        value = provider.authenticate(self._environ)
+        self._cache[provider_key] = value
+        return value

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/tensorboard/context.py

@@ -0,0 +1,130 @@
+# Copyright 2020 The TensorFlow Authors. All Rights Reserved.
+#
+# 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.
+# ==============================================================================
+"""Request-scoped context."""
+
+from tensorboard import auth as auth_lib
+
+
+# A `RequestContext` value is stored on WSGI environments under this key.
+_WSGI_KEY = "tensorboard.request_context"
+
+
+class RequestContext(object):
+    """Container of request-scoped values.
+
+    This context is for cross-cutting concerns: authentication,
+    authorization, auditing, internationalization, logging, and so on.
+    It is not simply for passing commonly used parameters to functions.
+
+    `RequestContext` values are to be treated as immutable.
+
+    Fields:
+      auth: An `AuthContext`, which may be empty but is never `None`.
+      remote_ip: An `ipaddress.IPv4Address` or `ipaddress.IPv6Address` or None.
+        Best guess of the IP Address of the end user.
+      x_forwarded_for: A tuple of `ipaddress.IPv4Address` or `ipaddress.IPv6Address`,
+        which may be empty but is never None. This should be parsed value of X-Forwarded-For
+        HTTP header from the request.
+      client_feature_flags: A dict of string to arbitrary type. These represent
+        feature flag key/value pairs sent by the client application. Usage of
+        client_feature_flags should know the name of the feature flag key and
+        should know and validate the type of the value.
+    """
+
+    def __init__(
+        self,
+        auth=None,
+        remote_ip=None,
+        x_forwarded_for=None,
+        client_feature_flags=None,
+    ):
+        """Create a request context.
+
+        The argument list is sorted and may be extended in the future;
+        therefore, callers must pass only named arguments to this
+        initializer.
+
+        Args:
+          See "Fields" on class docstring. All arguments are optional
+          and will be replaced with default values if appropriate.
+        """
+        self._auth = auth if auth is not None else auth_lib.AuthContext.empty()
+        self._remote_ip = remote_ip
+        self._x_forwarded_for = x_forwarded_for or ()
+        self._client_feature_flags = client_feature_flags or {}
+
+    @property
+    def auth(self):
+        return self._auth
+
+    @property
+    def remote_ip(self):
+        return self._remote_ip
+
+    @property
+    def x_forwarded_for(self):
+        return self._x_forwarded_for
+
+    @property
+    def client_feature_flags(self):
+        return self._client_feature_flags
+
+    def replace(self, **kwargs):
+        """Create a copy of this context with updated key-value pairs.
+
+        Analogous to `namedtuple._replace`. For example, to create a new
+        request context like `ctx` but with auth context `auth`, call
+        `ctx.replace(auth=auth)`.
+
+        Args:
+          As to `__init__`.
+
+        Returns:
+          A new context like this one but with the specified updates.
+        """
+        kwargs.setdefault("auth", self.auth)
+        kwargs.setdefault("remote_ip", self.remote_ip)
+        kwargs.setdefault("x_forwarded_for", self.x_forwarded_for)
+        kwargs.setdefault("client_feature_flags", self.client_feature_flags)
+        return type(self)(**kwargs)
+
+
+def from_environ(environ):
+    """Get a `RequestContext` from a WSGI environment.
+
+    See also `set_in_environ`.
+
+    Args:
+      environ: A WSGI environment (see PEP 3333).
+
+    Returns:
+      The `RequestContext` stored in the WSGI environment, or an empty
+      `RequestContext` if none is stored.
+    """
+    result = environ.get(_WSGI_KEY)
+    return result if result is not None else RequestContext()
+
+
+def set_in_environ(environ, ctx):
+    """Set the `RequestContext` in a WSGI environment.
+
+    After `set_in_environ(e, ctx)`, `from_environ(e) is ctx`. The input
+    environment is mutated.
+
+    Args:
+      environ: A WSGI environment to update.
+      ctx: A new `RequestContext` value.
+    """
+    environ[_WSGI_KEY] = ctx

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/tensorboard/data_compat.py

@@ -0,0 +1,160 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# 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.
+# ==============================================================================
+"""Utilities to migrate legacy protos to their modern equivalents."""
+
+
+import numpy as np
+
+from tensorboard.compat.proto import event_pb2
+from tensorboard.compat.proto import summary_pb2
+from tensorboard.plugins.audio import metadata as audio_metadata
+from tensorboard.plugins.histogram import metadata as histogram_metadata
+from tensorboard.plugins.image import metadata as image_metadata
+from tensorboard.plugins.scalar import metadata as scalar_metadata
+from tensorboard.util import tensor_util
+
+
+def migrate_event(event):
+    if not event.HasField("summary"):
+        return event
+    old_values = event.summary.value
+    new_values = [migrate_value(value) for value in old_values]
+    # Optimization: Don't create a new event if there were no changes.
+    if len(old_values) == len(new_values) and all(
+        x is y for (x, y) in zip(old_values, new_values)
+    ):
+        return event
+    result = event_pb2.Event()
+    result.CopyFrom(event)
+    del result.summary.value[:]
+    result.summary.value.extend(new_values)
+    return result
+
+
+def migrate_value(value):
+    """Convert `value` to a new-style value, if necessary and possible.
+
+    An "old-style" value is a value that uses any `value` field other than
+    the `tensor` field. A "new-style" value is a value that uses the
+    `tensor` field. TensorBoard continues to support old-style values on
+    disk; this method converts them to new-style values so that further
+    code need only deal with one data format.
+
+    Arguments:
+      value: A `Summary.Value` object. This argument is not modified.
+
+    Returns:
+      If the `value` is an old-style value for which there is a new-style
+      equivalent, the result is the new-style value. Otherwise---if the
+      value is already new-style or does not yet have a new-style
+      equivalent---the value will be returned unchanged.
+
+    :type value: Summary.Value
+    :rtype: Summary.Value
+    """
+    handler = {
+        "histo": _migrate_histogram_value,
+        "image": _migrate_image_value,
+        "audio": _migrate_audio_value,
+        "simple_value": _migrate_scalar_value,
+    }.get(value.WhichOneof("value"))
+    return handler(value) if handler else value
+
+
+def make_summary(tag, metadata, data):
+    tensor_proto = tensor_util.make_tensor_proto(data)
+    return summary_pb2.Summary.Value(
+        tag=tag, metadata=metadata, tensor=tensor_proto
+    )
+
+
+def _migrate_histogram_value(value):
+    """Convert `old-style` histogram value to `new-style`.
+
+    The "old-style" format can have outermost bucket limits of -DBL_MAX and
+    DBL_MAX, which are problematic for visualization. We replace those here
+    with the actual min and max values seen in the input data, but then in
+    order to avoid introducing "backwards" buckets (where left edge > right
+    edge), we first must drop all empty buckets on the left and right ends.
+    """
+    histogram_value = value.histo
+    bucket_counts = histogram_value.bucket
+    # Find the indices of the leftmost and rightmost non-empty buckets.
+    n = len(bucket_counts)
+    start = next((i for i in range(n) if bucket_counts[i] > 0), n)
+    end = next((i for i in reversed(range(n)) if bucket_counts[i] > 0), -1)
+    if start > end:
+        # If all input buckets were empty, treat it as a zero-bucket
+        # new-style histogram.
+        buckets = np.zeros([0, 3], dtype=np.float32)
+    else:
+        # Discard empty buckets on both ends, and keep only the "inner"
+        # edges from the remaining buckets. Note that bucket indices range
+        # from `start` to `end` inclusive, but bucket_limit indices are
+        # exclusive of `end` - this is because bucket_limit[i] is the
+        # right-hand edge for bucket[i].
+        bucket_counts = bucket_counts[start : end + 1]
+        inner_edges = histogram_value.bucket_limit[start:end]
+        # Use min as the left-hand limit for the first non-empty bucket.
+        bucket_lefts = [histogram_value.min] + inner_edges
+        # Use max as the right-hand limit for the last non-empty bucket.
+        bucket_rights = inner_edges + [histogram_value.max]
+        buckets = np.array(
+            [bucket_lefts, bucket_rights, bucket_counts], dtype=np.float32
+        ).transpose()
+
+    summary_metadata = histogram_metadata.create_summary_metadata(
+        display_name=value.metadata.display_name or value.tag,
+        description=value.metadata.summary_description,
+    )
+
+    return make_summary(value.tag, summary_metadata, buckets)
+
+
+def _migrate_image_value(value):
+    image_value = value.image
+    data = [
+        str(image_value.width).encode("ascii"),
+        str(image_value.height).encode("ascii"),
+        image_value.encoded_image_string,
+    ]
+
+    summary_metadata = image_metadata.create_summary_metadata(
+        display_name=value.metadata.display_name or value.tag,
+        description=value.metadata.summary_description,
+        converted_to_tensor=True,
+    )
+    return make_summary(value.tag, summary_metadata, data)
+
+
+def _migrate_audio_value(value):
+    audio_value = value.audio
+    data = [[audio_value.encoded_audio_string, b""]]  # empty label
+    summary_metadata = audio_metadata.create_summary_metadata(
+        display_name=value.metadata.display_name or value.tag,
+        description=value.metadata.summary_description,
+        encoding=audio_metadata.Encoding.Value("WAV"),
+        converted_to_tensor=True,
+    )
+    return make_summary(value.tag, summary_metadata, data)
+
+
+def _migrate_scalar_value(value):
+    scalar_value = value.simple_value
+    summary_metadata = scalar_metadata.create_summary_metadata(
+        display_name=value.metadata.display_name or value.tag,
+        description=value.metadata.summary_description,
+    )
+    return make_summary(value.tag, summary_metadata, scalar_value)

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/tensorboard/dataclass_compat.py

@@ -0,0 +1,225 @@
+# Copyright 2020 The TensorFlow Authors. All Rights Reserved.
+#
+# 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.
+# ==============================================================================
+"""Utilities to migrate legacy summaries/events to generic data form.
+
+For legacy summaries, this populates the `SummaryMetadata.data_class`
+field and makes any necessary transformations to the tensor value. For
+`graph_def` events, this creates a new summary event.
+
+This should be effected after the `data_compat` transformation.
+"""
+
+
+from tensorboard.compat.proto import event_pb2
+from tensorboard.compat.proto import summary_pb2
+from tensorboard.plugins.audio import metadata as audio_metadata
+from tensorboard.plugins.custom_scalar import (
+    metadata as custom_scalars_metadata,
+)
+from tensorboard.plugins.graph import metadata as graphs_metadata
+from tensorboard.plugins.histogram import metadata as histograms_metadata
+from tensorboard.plugins.hparams import metadata as hparams_metadata
+from tensorboard.plugins.image import metadata as images_metadata
+from tensorboard.plugins.mesh import metadata as mesh_metadata
+from tensorboard.plugins.pr_curve import metadata as pr_curves_metadata
+from tensorboard.plugins.scalar import metadata as scalars_metadata
+from tensorboard.plugins.text import metadata as text_metadata
+from tensorboard.util import tensor_util
+
+
+def migrate_event(event, initial_metadata):
+    """Migrate an event to a sequence of events.
+
+    Args:
+      event: An `event_pb2.Event`. The caller transfers ownership of the
+        event to this method; the event may be mutated, and may or may
+        not appear in the returned sequence.
+      initial_metadata: Map from tag name (string) to `SummaryMetadata`
+        proto for the initial occurrence of the given tag within the
+        enclosing run. While loading a given run, the caller should
+        always pass the same dictionary here, initially `{}`; this
+        function will mutate it and reuse it for future calls.
+
+    Returns:
+      A sequence of `event_pb2.Event`s to use instead of `event`.
+    """
+    what = event.WhichOneof("what")
+    if what == "graph_def":
+        return _migrate_graph_event(event)
+    if what == "tagged_run_metadata":
+        return _migrate_tagged_run_metadata_event(event)
+    if what == "summary":
+        return _migrate_summary_event(event, initial_metadata)
+    return (event,)
+
+
+def _migrate_graph_event(old_event):
+    result = event_pb2.Event()
+    result.wall_time = old_event.wall_time
+    result.step = old_event.step
+    value = result.summary.value.add(tag=graphs_metadata.RUN_GRAPH_NAME)
+    graph_bytes = old_event.graph_def
+    value.tensor.CopyFrom(tensor_util.make_tensor_proto([graph_bytes]))
+    value.metadata.plugin_data.plugin_name = graphs_metadata.PLUGIN_NAME
+    # `value.metadata.plugin_data.content` left empty
+    value.metadata.data_class = summary_pb2.DATA_CLASS_BLOB_SEQUENCE
+    # As long as the graphs plugin still reads the old format, keep both
+    # the old event and the new event to maintain compatibility.
+    return (old_event, result)
+
+
+def _migrate_tagged_run_metadata_event(old_event):
+    result = event_pb2.Event()
+    result.wall_time = old_event.wall_time
+    result.step = old_event.step
+    trm = old_event.tagged_run_metadata
+    value = result.summary.value.add(tag=trm.tag)
+    value.tensor.CopyFrom(tensor_util.make_tensor_proto([trm.run_metadata]))
+    value.metadata.plugin_data.plugin_name = (
+        graphs_metadata.PLUGIN_NAME_TAGGED_RUN_METADATA
+    )
+    # `value.metadata.plugin_data.content` left empty
+    value.metadata.data_class = summary_pb2.DATA_CLASS_BLOB_SEQUENCE
+    return (result,)
+
+
+def _migrate_summary_event(event, initial_metadata):
+    values = event.summary.value
+    new_values = [
+        new for old in values for new in _migrate_value(old, initial_metadata)
+    ]
+    # Optimization: Don't create a new event if there were no shallow
+    # changes (there may still have been in-place changes).
+    if len(values) == len(new_values) and all(
+        x is y for (x, y) in zip(values, new_values)
+    ):
+        return (event,)
+    del event.summary.value[:]
+    event.summary.value.extend(new_values)
+    return (event,)
+
+
+def _migrate_value(value, initial_metadata):
+    """Convert an old value to a stream of new values. May mutate."""
+    metadata = initial_metadata.get(value.tag)
+    initial = False
+    if metadata is None:
+        initial = True
+        # Retain a copy of the initial metadata, so that even after we
+        # update its data class we know whether to also transform later
+        # events in this time series.
+        metadata = summary_pb2.SummaryMetadata()
+        metadata.CopyFrom(value.metadata)
+        initial_metadata[value.tag] = metadata
+    if metadata.data_class != summary_pb2.DATA_CLASS_UNKNOWN:
+        return (value,)
+    plugin_name = metadata.plugin_data.plugin_name
+    if plugin_name == histograms_metadata.PLUGIN_NAME:
+        return _migrate_histogram_value(value)
+    if plugin_name == images_metadata.PLUGIN_NAME:
+        return _migrate_image_value(value)
+    if plugin_name == audio_metadata.PLUGIN_NAME:
+        return _migrate_audio_value(value)
+    if plugin_name == scalars_metadata.PLUGIN_NAME:
+        return _migrate_scalar_value(value)
+    if plugin_name == text_metadata.PLUGIN_NAME:
+        return _migrate_text_value(value)
+    if plugin_name == hparams_metadata.PLUGIN_NAME:
+        return _migrate_hparams_value(value)
+    if plugin_name == pr_curves_metadata.PLUGIN_NAME:
+        return _migrate_pr_curve_value(value)
+    if plugin_name == mesh_metadata.PLUGIN_NAME:
+        return _migrate_mesh_value(value)
+    if plugin_name == custom_scalars_metadata.PLUGIN_NAME:
+        return _migrate_custom_scalars_value(value)
+    if plugin_name in [
+        graphs_metadata.PLUGIN_NAME_RUN_METADATA,
+        graphs_metadata.PLUGIN_NAME_RUN_METADATA_WITH_GRAPH,
+        graphs_metadata.PLUGIN_NAME_KERAS_MODEL,
+    ]:
+        return _migrate_graph_sub_plugin_value(value)
+    return (value,)
+
+
+def _migrate_scalar_value(value):
+    if value.HasField("metadata"):
+        value.metadata.data_class = summary_pb2.DATA_CLASS_SCALAR
+    return (value,)
+
+
+def _migrate_histogram_value(value):
+    if value.HasField("metadata"):
+        value.metadata.data_class = summary_pb2.DATA_CLASS_TENSOR
+    return (value,)
+
+
+def _migrate_image_value(value):
+    if value.HasField("metadata"):
+        value.metadata.data_class = summary_pb2.DATA_CLASS_BLOB_SEQUENCE
+    return (value,)
+
+
+def _migrate_text_value(value):
+    if value.HasField("metadata"):
+        value.metadata.data_class = summary_pb2.DATA_CLASS_TENSOR
+    return (value,)
+
+
+def _migrate_audio_value(value):
+    if value.HasField("metadata"):
+        value.metadata.data_class = summary_pb2.DATA_CLASS_BLOB_SEQUENCE
+    tensor = value.tensor
+    # Project out just the first axis: actual audio clips.
+    stride = 1
+    while len(tensor.tensor_shape.dim) > 1:
+        stride *= tensor.tensor_shape.dim.pop().size
+    if stride != 1:
+        tensor.string_val[:] = tensor.string_val[::stride]
+    return (value,)
+
+
+def _migrate_hparams_value(value):
+    if value.HasField("metadata"):
+        value.metadata.data_class = summary_pb2.DATA_CLASS_TENSOR
+    if not value.HasField("tensor"):
+        value.tensor.CopyFrom(hparams_metadata.NULL_TENSOR)
+    return (value,)
+
+
+def _migrate_pr_curve_value(value):
+    if value.HasField("metadata"):
+        value.metadata.data_class = summary_pb2.DATA_CLASS_TENSOR
+    return (value,)
+
+
+def _migrate_mesh_value(value):
+    if value.HasField("metadata"):
+        value.metadata.data_class = summary_pb2.DATA_CLASS_TENSOR
+    return (value,)
+
+
+def _migrate_custom_scalars_value(value):
+    if value.HasField("metadata"):
+        value.metadata.data_class = summary_pb2.DATA_CLASS_TENSOR
+    return (value,)
+
+
+def _migrate_graph_sub_plugin_value(value):
+    if value.HasField("metadata"):
+        value.metadata.data_class = summary_pb2.DATA_CLASS_BLOB_SEQUENCE
+    shape = value.tensor.tensor_shape.dim
+    if not shape:
+        shape.add(size=1)
+    return (value,)

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/tensorboard/default.py

@@ -0,0 +1,145 @@
+# Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+#
+# 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.
+# ==============================================================================
+"""Collection of first-party plugins.
+
+This module exists to isolate tensorboard.program from the potentially
+heavyweight build dependencies for first-party plugins. This way people
+doing custom builds of TensorBoard have the option to only pay for the
+dependencies they want.
+
+This module also grants the flexibility to those doing custom builds, to
+automatically inherit the centrally-maintained list of standard plugins,
+for less repetition.
+"""
+
+
+import logging
+
+import pkg_resources
+
+from tensorboard.backend import experimental_plugin
+from tensorboard.plugins.audio import audio_plugin
+from tensorboard.plugins.core import core_plugin
+from tensorboard.plugins.custom_scalar import custom_scalars_plugin
+from tensorboard.plugins.debugger_v2 import debugger_v2_plugin
+from tensorboard.plugins.distribution import distributions_plugin
+from tensorboard.plugins.graph import graphs_plugin
+from tensorboard.plugins.histogram import histograms_plugin
+from tensorboard.plugins.hparams import hparams_plugin
+from tensorboard.plugins.image import images_plugin
+from tensorboard.plugins.metrics import metrics_plugin
+from tensorboard.plugins.pr_curve import pr_curves_plugin
+from tensorboard.plugins.profile_redirect import profile_redirect_plugin
+from tensorboard.plugins.scalar import scalars_plugin
+from tensorboard.plugins.text import text_plugin
+from tensorboard.plugins.text_v2 import text_v2_plugin
+from tensorboard.plugins.mesh import mesh_plugin
+from tensorboard.plugins.npmi import npmi_plugin
+
+
+logger = logging.getLogger(__name__)
+
+
+class ExperimentalTextV2Plugin(
+    text_v2_plugin.TextV2Plugin, experimental_plugin.ExperimentalPlugin
+):
+    """Angular Text Plugin marked as experimental."""
+
+    pass
+
+
+class ExperimentalNpmiPlugin(
+    npmi_plugin.NpmiPlugin, experimental_plugin.ExperimentalPlugin
+):
+    """Angular nPMI Plugin marked as experimental."""
+
+    pass
+
+
+# Ordering matters. The order in which these lines appear determines the
+# ordering of tabs in TensorBoard's GUI.
+_PLUGINS = [
+    core_plugin.CorePluginLoader(include_debug_info=True),
+    metrics_plugin.MetricsPlugin,
+    scalars_plugin.ScalarsPlugin,
+    custom_scalars_plugin.CustomScalarsPlugin,
+    images_plugin.ImagesPlugin,
+    audio_plugin.AudioPlugin,
+    debugger_v2_plugin.DebuggerV2Plugin,
+    graphs_plugin.GraphsPlugin,
+    distributions_plugin.DistributionsPlugin,
+    histograms_plugin.HistogramsPlugin,
+    text_plugin.TextPlugin,
+    pr_curves_plugin.PrCurvesPlugin,
+    profile_redirect_plugin.ProfileRedirectPluginLoader,
+    hparams_plugin.HParamsPlugin,
+    mesh_plugin.MeshPlugin,
+    ExperimentalTextV2Plugin,
+    ExperimentalNpmiPlugin,
+]
+
+
+def get_plugins():
+    """Returns a list specifying all known TensorBoard plugins.
+
+    This includes both first-party, statically bundled plugins and
+    dynamic plugins.
+
+    This list can be passed to the `tensorboard.program.TensorBoard` API.
+
+    Returns:
+      The list of default first-party plugins.
+    """
+    return get_static_plugins() + get_dynamic_plugins()
+
+
+def get_static_plugins():
+    """Returns a list specifying TensorBoard's default first-party plugins.
+
+    Plugins are specified in this list either via a TBLoader instance to load the
+    plugin, or the TBPlugin class itself which will be loaded using a BasicLoader.
+
+    This list can be passed to the `tensorboard.program.TensorBoard` API.
+
+    Returns:
+      The list of default first-party plugins.
+
+    :rtype: list[Type[base_plugin.TBLoader] | Type[base_plugin.TBPlugin]]
+    """
+
+    return _PLUGINS[:]
+
+
+def get_dynamic_plugins():
+    """Returns a list specifying TensorBoard's dynamically loaded plugins.
+
+    A dynamic TensorBoard plugin is specified using entry_points [1] and it is
+    the robust way to integrate plugins into TensorBoard.
+
+    This list can be passed to the `tensorboard.program.TensorBoard` API.
+
+    Returns:
+      The list of dynamic plugins.
+
+    :rtype: list[Type[base_plugin.TBLoader] | Type[base_plugin.TBPlugin]]
+
+    [1]: https://packaging.python.org/specifications/entry-points/
+    """
+    return [
+        entry_point.resolve()
+        for entry_point in pkg_resources.iter_entry_points(
+            "tensorboard_plugins"
+        )
+    ]

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/tensorboard/errors.py

@@ -0,0 +1,130 @@
+# Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+#
+# 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.
+# ==============================================================================
+"""Error codes (experimental module).
+
+These types represent a subset of the Google error codes [1], which are
+also used by TensorFlow, gRPC, et al.
+
+When an HTTP handler raises one of these errors, the TensorBoard core
+application will catch it and automatically serve a properly formatted
+response with the error message.
+
+[1]: https://github.com/googleapis/googleapis/blob/master/google/rpc/code.proto
+"""
+
+
+class PublicError(RuntimeError):
+    """An error whose text does not contain sensitive information.
+
+    Fields:
+      http_code: Integer between 400 and 599 inclusive (e.g., 404).
+      headers: List of additional key-value pairs to include in the
+        response body, like `[("Allow", "GET")]` for HTTP 405 or
+        `[("WWW-Authenticate", "Digest")]` for HTTP 401. May be empty.
+    """
+
+    http_code = 500  # default; subclasses should override
+
+    def __init__(self, details):
+        super(PublicError, self).__init__(details)
+        self.headers = []
+
+
+class InvalidArgumentError(PublicError):
+    """Client specified an invalid argument.
+
+    The text of this error is assumed not to contain sensitive data,
+    and so may appear in (e.g.) the response body of a failed HTTP
+    request.
+
+    Corresponds to HTTP 400 Bad Request or Google error code `INVALID_ARGUMENT`.
+    """
+
+    http_code = 400
+
+    def __init__(self, details=None):
+        msg = _format_message("Invalid argument", details)
+        super(InvalidArgumentError, self).__init__(msg)
+
+
+class NotFoundError(PublicError):
+    """Some requested entity (e.g., file or directory) was not found.
+
+    The text of this error is assumed not to contain sensitive data,
+    and so may appear in (e.g.) the response body of a failed HTTP
+    request.
+
+    Corresponds to HTTP 404 Not Found or Google error code `NOT_FOUND`.
+    """
+
+    http_code = 404
+
+    def __init__(self, details=None):
+        msg = _format_message("Not found", details)
+        super(NotFoundError, self).__init__(msg)
+
+
+class UnauthenticatedError(PublicError):
+    """Request does not have valid authentication credentials for the operation.
+
+    The text of this error is assumed not to contain sensitive data,
+    and so may appear in (e.g.) the response body of a failed HTTP
+    request.
+
+    Corresponds to HTTP 401 Unauthorized (despite the name) or Google
+    error code `UNAUTHENTICATED`. HTTP 401 responses are required to
+    contain a `WWW-Authenticate` challenge, so `UnauthenticatedError`
+    values are, too.
+    """
+
+    http_code = 401
+
+    def __init__(self, details=None, *, challenge):
+        """Initialize an `UnauthenticatedError`.
+
+        Args;
+          details: Optional public, user-facing error message, as a
+            string or any value that can be converted to string, or
+            `None` to omit details.
+          challenge: String value of the `WWW-Authenticate` HTTP header
+            as described in RFC 7235.
+        """
+        msg = _format_message("Unauthenticated", details)
+        super(UnauthenticatedError, self).__init__(msg)
+        self.headers.append(("WWW-Authenticate", challenge))
+
+
+class PermissionDeniedError(PublicError):
+    """The caller does not have permission to execute the specified operation.
+
+    The text of this error is assumed not to contain sensitive data,
+    and so may appear in (e.g.) the response body of a failed HTTP
+    request.
+
+    Corresponds to HTTP 403 Forbidden or Google error code `PERMISSION_DENIED`.
+    """
+
+    http_code = 403
+
+    def __init__(self, details=None):
+        msg = _format_message("Permission denied", details)
+        super(PermissionDeniedError, self).__init__(msg)
+
+
+def _format_message(code_name, details):
+    if details is None:
+        return code_name
+    else:
+        return "%s: %s" % (code_name, details)

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/tensorboard/lazy.py

@@ -0,0 +1,100 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# 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.
+# ==============================================================================
+"""TensorBoard is a webapp for understanding TensorFlow runs and graphs."""
+
+
+import functools
+import threading
+import types
+
+
+def lazy_load(name):
+    """Decorator to define a function that lazily loads the module 'name'.
+
+    This can be used to defer importing troublesome dependencies - e.g. ones that
+    are large and infrequently used, or that cause a dependency cycle -
+    until they are actually used.
+
+    Args:
+      name: the fully-qualified name of the module; typically the last segment
+        of 'name' matches the name of the decorated function
+
+    Returns:
+      Decorator function that produces a lazy-loading module 'name' backed by the
+      underlying decorated function.
+    """
+
+    def wrapper(load_fn):
+        # Wrap load_fn to call it exactly once and update __dict__ afterwards to
+        # make future lookups efficient (only failed lookups call __getattr__).
+        @_memoize
+        def load_once(self):
+            if load_once.loading:
+                raise ImportError(
+                    "Circular import when resolving LazyModule %r" % name
+                )
+            load_once.loading = True
+            try:
+                module = load_fn()
+            finally:
+                load_once.loading = False
+            self.__dict__.update(module.__dict__)
+            load_once.loaded = True
+            return module
+
+        load_once.loading = False
+        load_once.loaded = False
+
+        # Define a module that proxies getattr() and dir() to the result of calling
+        # load_once() the first time it's needed. The class is nested so we can close
+        # over load_once() and avoid polluting the module's attrs with our own state.
+        class LazyModule(types.ModuleType):
+            def __getattr__(self, attr_name):
+                return getattr(load_once(self), attr_name)
+
+            def __dir__(self):
+                return dir(load_once(self))
+
+            def __repr__(self):
+                if load_once.loaded:
+                    return "<%r via LazyModule (loaded)>" % load_once(self)
+                return (
+                    "<module %r via LazyModule (not yet loaded)>"
+                    % self.__name__
+                )
+
+        return LazyModule(name)
+
+    return wrapper
+
+
+def _memoize(f):
+    """Memoizing decorator for f, which must have exactly 1 hashable
+    argument."""
+    nothing = object()  # Unique "no value" sentinel object.
+    cache = {}
+    # Use a reentrant lock so that if f references the resulting wrapper we die
+    # with recursion depth exceeded instead of deadlocking.
+    lock = threading.RLock()
+
+    @functools.wraps(f)
+    def wrapper(arg):
+        if cache.get(arg, nothing) is nothing:
+            with lock:
+                if cache.get(arg, nothing) is nothing:
+                    cache[arg] = f(arg)
+        return cache[arg]
+
+    return wrapper

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/tensorboard/main.py

@@ -0,0 +1,53 @@
+# Copyright 2015 The TensorFlow Authors. All Rights Reserved.
+#
+# 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.
+# ==============================================================================
+"""TensorBoard main module.
+
+This module ties together `tensorboard.program` and
+`tensorboard.default_plugins` to provide standard TensorBoard. It's
+meant to be tiny and act as little other than a config file. Those
+wishing to customize the set of plugins or static assets that
+TensorBoard uses can swap out this file with their own.
+"""
+
+import sys
+
+from absl import app
+from tensorboard import default
+from tensorboard import main_lib
+from tensorboard import program
+from tensorboard.plugins import base_plugin
+from tensorboard.uploader import uploader_subcommand
+from tensorboard.util import tb_logging
+
+logger = tb_logging.get_logger()
+
+
+def run_main():
+    """Initializes flags and calls main()."""
+    main_lib.global_init()
+
+    tensorboard = program.TensorBoard(
+        plugins=default.get_plugins(),
+        subcommands=[uploader_subcommand.UploaderSubcommand()],
+    )
+    try:
+        app.run(tensorboard.main, flags_parser=tensorboard.configure)
+    except base_plugin.FlagsError as e:
+        print("Error: %s" % e, file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    run_main()

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/tensorboard/main_lib.py

@@ -0,0 +1,47 @@
+# Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+#
+# 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.
+# ==============================================================================
+"""Helpers for TensorBoard main module."""
+
+import os
+import sys
+
+import absl.logging
+
+from tensorboard.compat import tf
+
+
+def global_init():
+    """Modifies the global environment for running TensorBoard as main.
+
+    This functions changes global state in the Python process, so it should
+    not be called from library routines.
+    """
+    # TF versions prior to 1.15.0 included default GCS filesystem caching logic
+    # that interacted pathologically with the pattern of reads used by TensorBoard
+    # for logdirs. See: https://github.com/tensorflow/tensorboard/issues/1225
+    # The problematic behavior was fixed in 1.15.0 by
+    # https://github.com/tensorflow/tensorflow/commit/e43b94649d3e1ac5d538e4eca9166b899511d681
+    # but for older versions of TF, we avoid a regression by setting this env var to
+    # disable the cache, which must be done before the first import of tensorflow.
+    os.environ["GCS_READ_CACHE_DISABLED"] = "1"
+
+    if getattr(tf, "__version__", "stub") == "stub":
+        print(
+            "TensorFlow installation not found - running with reduced feature set.",
+            file=sys.stderr,
+        )
+
+    # Only emit log messages at WARNING and above by default to reduce spam.
+    absl.logging.set_verbosity(absl.logging.WARNING)

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/tensorboard/manager.py

@@ -0,0 +1,474 @@
+# Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+#
+# 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.
+# ==============================================================================
+"""Private utilities for managing multiple TensorBoard processes."""
+
+
+import base64
+import collections
+import datetime
+import errno
+import json
+import os
+import subprocess
+import tempfile
+import time
+
+
+from tensorboard import version
+from tensorboard.util import tb_logging
+
+
+# Type descriptors for `TensorBoardInfo` fields.
+#
+# We represent timestamps as int-seconds-since-epoch rather than
+# datetime objects to work around a bug in Python on Windows. See:
+# https://github.com/tensorflow/tensorboard/issues/2017.
+_FieldType = collections.namedtuple(
+    "_FieldType",
+    (
+        "serialized_type",
+        "runtime_type",
+        "serialize",
+        "deserialize",
+    ),
+)
+_type_int = _FieldType(
+    serialized_type=int,
+    runtime_type=int,
+    serialize=lambda n: n,
+    deserialize=lambda n: n,
+)
+_type_str = _FieldType(
+    serialized_type=str,  # `json.loads` always gives Unicode
+    runtime_type=str,
+    serialize=str,
+    deserialize=str,
+)
+
+# Information about a running TensorBoard instance.
+_TENSORBOARD_INFO_FIELDS = collections.OrderedDict(
+    (
+        ("version", _type_str),
+        ("start_time", _type_int),  # seconds since epoch
+        ("pid", _type_int),
+        ("port", _type_int),
+        ("path_prefix", _type_str),  # may be empty
+        ("logdir", _type_str),  # may be empty
+        ("db", _type_str),  # may be empty
+        ("cache_key", _type_str),  # opaque, as given by `cache_key` below
+    )
+)
+TensorBoardInfo = collections.namedtuple(
+    "TensorBoardInfo",
+    _TENSORBOARD_INFO_FIELDS,
+)
+
+
+def data_source_from_info(info):
+    """Format the data location for the given TensorBoardInfo.
+
+    Args:
+      info: A TensorBoardInfo value.
+
+    Returns:
+      A human-readable string describing the logdir or database connection
+      used by the server: e.g., "logdir /tmp/logs".
+    """
+    if info.db:
+        return "db %s" % info.db
+    else:
+        return "logdir %s" % info.logdir
+
+
+def _info_to_string(info):
+    """Convert a `TensorBoardInfo` to string form to be stored on disk.
+
+    The format returned by this function is opaque and should only be
+    interpreted by `_info_from_string`.
+
+    Args:
+      info: A valid `TensorBoardInfo` object.
+
+    Raises:
+      ValueError: If any field on `info` is not of the correct type.
+
+    Returns:
+      A string representation of the provided `TensorBoardInfo`.
+    """
+    for key in _TENSORBOARD_INFO_FIELDS:
+        field_type = _TENSORBOARD_INFO_FIELDS[key]
+        if not isinstance(getattr(info, key), field_type.runtime_type):
+            raise ValueError(
+                "expected %r of type %s, but found: %r"
+                % (key, field_type.runtime_type, getattr(info, key))
+            )
+    if info.version != version.VERSION:
+        raise ValueError(
+            "expected 'version' to be %r, but found: %r"
+            % (version.VERSION, info.version)
+        )
+    json_value = {
+        k: _TENSORBOARD_INFO_FIELDS[k].serialize(getattr(info, k))
+        for k in _TENSORBOARD_INFO_FIELDS
+    }
+    return json.dumps(json_value, sort_keys=True, indent=4)
+
+
+def _info_from_string(info_string):
+    """Parse a `TensorBoardInfo` object from its string representation.
+
+    Args:
+      info_string: A string representation of a `TensorBoardInfo`, as
+        produced by a previous call to `_info_to_string`.
+
+    Returns:
+      A `TensorBoardInfo` value.
+
+    Raises:
+      ValueError: If the provided string is not valid JSON, or if it is
+        missing any required fields, or if any field is of incorrect type.
+    """
+
+    try:
+        json_value = json.loads(info_string)
+    except ValueError:
+        raise ValueError("invalid JSON: %r" % (info_string,))
+    if not isinstance(json_value, dict):
+        raise ValueError("not a JSON object: %r" % (json_value,))
+    expected_keys = frozenset(_TENSORBOARD_INFO_FIELDS)
+    actual_keys = frozenset(json_value)
+    missing_keys = expected_keys - actual_keys
+    if missing_keys:
+        raise ValueError(
+            "TensorBoardInfo missing keys: %r" % (sorted(missing_keys),)
+        )
+    # For forward compatibility, silently ignore unknown keys.
+
+    # Validate and deserialize fields.
+    fields = {}
+    for key in _TENSORBOARD_INFO_FIELDS:
+        field_type = _TENSORBOARD_INFO_FIELDS[key]
+        if not isinstance(json_value[key], field_type.serialized_type):
+            raise ValueError(
+                "expected %r of type %s, but found: %r"
+                % (key, field_type.serialized_type, json_value[key])
+            )
+        fields[key] = field_type.deserialize(json_value[key])
+
+    return TensorBoardInfo(**fields)
+
+
+def cache_key(working_directory, arguments, configure_kwargs):
+    """Compute a `TensorBoardInfo.cache_key` field.
+
+    The format returned by this function is opaque. Clients may only
+    inspect it by comparing it for equality with other results from this
+    function.
+
+    Args:
+      working_directory: The directory from which TensorBoard was launched
+        and relative to which paths like `--logdir` and `--db` are
+        resolved.
+      arguments: The command-line args to TensorBoard, as `sys.argv[1:]`.
+        Should be a list (or tuple), not an unparsed string. If you have a
+        raw shell command, use `shlex.split` before passing it to this
+        function.
+      configure_kwargs: A dictionary of additional argument values to
+        override the textual `arguments`, with the same semantics as in
+        `tensorboard.program.TensorBoard.configure`. May be an empty
+        dictionary.
+
+    Returns:
+      A string such that if two (prospective or actual) TensorBoard
+      invocations have the same cache key then it is safe to use one in
+      place of the other. The converse is not guaranteed: it is often safe
+      to change the order of TensorBoard arguments, or to explicitly set
+      them to their default values, or to move them between `arguments`
+      and `configure_kwargs`, but such invocations may yield distinct
+      cache keys.
+    """
+    if not isinstance(arguments, (list, tuple)):
+        raise TypeError(
+            "'arguments' should be a list of arguments, but found: %r "
+            "(use `shlex.split` if given a string)" % (arguments,)
+        )
+    datum = {
+        "working_directory": working_directory,
+        "arguments": arguments,
+        "configure_kwargs": configure_kwargs,
+    }
+    raw = base64.b64encode(
+        json.dumps(datum, sort_keys=True, separators=(",", ":")).encode("utf-8")
+    )
+    # `raw` is of type `bytes`, even though it only contains ASCII
+    # characters; we want it to be `str` in both Python 2 and 3.
+    return str(raw.decode("ascii"))
+
+
+def _get_info_dir():
+    """Get path to directory in which to store info files.
+
+    The directory returned by this function is "owned" by this module. If
+    the contents of the directory are modified other than via the public
+    functions of this module, subsequent behavior is undefined.
+
+    The directory will be created if it does not exist.
+    """
+    path = os.path.join(tempfile.gettempdir(), ".tensorboard-info")
+    try:
+        os.makedirs(path)
+    except OSError as e:
+        if e.errno == errno.EEXIST and os.path.isdir(path):
+            pass
+        else:
+            raise
+    else:
+        os.chmod(path, 0o777)
+    return path
+
+
+def _get_info_file_path():
+    """Get path to info file for the current process.
+
+    As with `_get_info_dir`, the info directory will be created if it
+    does not exist.
+    """
+    return os.path.join(_get_info_dir(), "pid-%d.info" % os.getpid())
+
+
+def write_info_file(tensorboard_info):
+    """Write TensorBoardInfo to the current process's info file.
+
+    This should be called by `main` once the server is ready. When the
+    server shuts down, `remove_info_file` should be called.
+
+    Args:
+      tensorboard_info: A valid `TensorBoardInfo` object.
+
+    Raises:
+      ValueError: If any field on `info` is not of the correct type.
+    """
+    payload = "%s\n" % _info_to_string(tensorboard_info)
+    with open(_get_info_file_path(), "w") as outfile:
+        outfile.write(payload)
+
+
+def remove_info_file():
+    """Remove the current process's TensorBoardInfo file, if it exists.
+
+    If the file does not exist, no action is taken and no error is
+    raised.
+    """
+    try:
+        os.unlink(_get_info_file_path())
+    except OSError as e:
+        if e.errno == errno.ENOENT:
+            # The user may have wiped their temporary directory or something.
+            # Not a problem: we're already in the state that we want to be in.
+            pass
+        else:
+            raise
+
+
+def get_all():
+    """Return TensorBoardInfo values for running TensorBoard processes.
+
+    This function may not provide a perfect snapshot of the set of running
+    processes. Its result set may be incomplete if the user has cleaned
+    their /tmp/ directory while TensorBoard processes are running. It may
+    contain extraneous entries if TensorBoard processes exited uncleanly
+    (e.g., with SIGKILL or SIGQUIT).
+
+    Entries in the info directory that do not represent valid
+    `TensorBoardInfo` values will be silently ignored.
+
+    Returns:
+      A fresh list of `TensorBoardInfo` objects.
+    """
+    info_dir = _get_info_dir()
+    results = []
+    for filename in os.listdir(info_dir):
+        filepath = os.path.join(info_dir, filename)
+        try:
+            with open(filepath) as infile:
+                contents = infile.read()
+        except IOError as e:
+            if e.errno == errno.EACCES:
+                # May have been written by this module in a process whose
+                # `umask` includes some bits of 0o444.
+                continue
+            else:
+                raise
+        try:
+            info = _info_from_string(contents)
+        except ValueError:
+            # Ignore unrecognized files, logging at debug only.
+            tb_logging.get_logger().debug(
+                "invalid info file: %r",
+                filepath,
+                exc_info=True,
+            )
+        else:
+            results.append(info)
+    return results
+
+
+# The following five types enumerate the possible return values of the
+# `start` function.
+
+# Indicates that a call to `start` was compatible with an existing
+# TensorBoard process, which can be reused according to the provided
+# info.
+StartReused = collections.namedtuple("StartReused", ("info",))
+
+# Indicates that a call to `start` successfully launched a new
+# TensorBoard process, which is available with the provided info.
+StartLaunched = collections.namedtuple("StartLaunched", ("info",))
+
+# Indicates that a call to `start` tried to launch a new TensorBoard
+# instance, but the subprocess exited with the given exit code and
+# output streams. (If the contents of the output streams are no longer
+# available---e.g., because the user has emptied /tmp/---then the
+# corresponding values will be `None`.)
+StartFailed = collections.namedtuple(
+    "StartFailed",
+    (
+        "exit_code",  # int, as `Popen.returncode` (negative for signal)
+        "stdout",  # str, or `None` if the stream could not be read
+        "stderr",  # str, or `None` if the stream could not be read
+    ),
+)
+
+# Indicates that a call to `start` failed to invoke the subprocess.
+#
+# If the TensorBoard executable was chosen via the `TENSORBOARD_BINARY`
+# environment variable, then the `explicit_binary` field contains the
+# path to that binary; otherwise, the field is `None`.
+StartExecFailed = collections.namedtuple(
+    "StartExecFailed",
+    (
+        "os_error",  # `OSError` due to `Popen` invocation
+        "explicit_binary",  # `str` or `None`; see type-level comment
+    ),
+)
+
+# Indicates that a call to `start` launched a TensorBoard process, but
+# that process neither exited nor wrote its info file within the allowed
+# timeout period. The process may still be running under the included
+# PID.
+StartTimedOut = collections.namedtuple("StartTimedOut", ("pid",))
+
+
+def start(arguments, timeout=datetime.timedelta(seconds=60)):
+    """Start a new TensorBoard instance, or reuse a compatible one.
+
+    If the cache key determined by the provided arguments and the current
+    working directory (see `cache_key`) matches the cache key of a running
+    TensorBoard process (see `get_all`), that process will be reused.
+
+    Otherwise, a new TensorBoard process will be spawned with the provided
+    arguments, using the `tensorboard` binary from the system path.
+
+    Args:
+      arguments: List of strings to be passed as arguments to
+        `tensorboard`. (If you have a raw command-line string, see
+        `shlex.split`.)
+      timeout: `datetime.timedelta` object describing how long to wait for
+        the subprocess to initialize a TensorBoard server and write its
+        `TensorBoardInfo` file. If the info file is not written within
+        this time period, `start` will assume that the subprocess is stuck
+        in a bad state, and will give up on waiting for it and return a
+        `StartTimedOut` result. Note that in such a case the subprocess
+        will not be killed. Default value is 60 seconds.
+
+    Returns:
+      A `StartReused`, `StartLaunched`, `StartFailed`, or `StartTimedOut`
+      object.
+    """
+    this_cache_key = cache_key(
+        working_directory=os.getcwd(),
+        arguments=arguments,
+        configure_kwargs={},
+    )
+    match = _find_matching_instance(this_cache_key)
+    if match:
+        return StartReused(info=match)
+
+    (stdout_fd, stdout_path) = tempfile.mkstemp(prefix=".tensorboard-stdout-")
+    (stderr_fd, stderr_path) = tempfile.mkstemp(prefix=".tensorboard-stderr-")
+    start_time_seconds = time.time()
+    explicit_tb = os.environ.get("TENSORBOARD_BINARY", None)
+    try:
+        p = subprocess.Popen(
+            ["tensorboard" if explicit_tb is None else explicit_tb] + arguments,
+            stdout=stdout_fd,
+            stderr=stderr_fd,
+        )
+    except OSError as e:
+        return StartExecFailed(os_error=e, explicit_binary=explicit_tb)
+    finally:
+        os.close(stdout_fd)
+        os.close(stderr_fd)
+
+    poll_interval_seconds = 0.5
+    end_time_seconds = start_time_seconds + timeout.total_seconds()
+    while time.time() < end_time_seconds:
+        time.sleep(poll_interval_seconds)
+        subprocess_result = p.poll()
+        if subprocess_result is not None:
+            return StartFailed(
+                exit_code=subprocess_result,
+                stdout=_maybe_read_file(stdout_path),
+                stderr=_maybe_read_file(stderr_path),
+            )
+        info = _find_matching_instance(this_cache_key)
+        if info:
+            # Don't check that `info.pid == p.pid`, since on Windows that may
+            # not be the case: see #4300.
+            return StartLaunched(info=info)
+    else:
+        return StartTimedOut(pid=p.pid)
+
+
+def _find_matching_instance(cache_key):
+    """Find a running TensorBoard instance compatible with the cache key.
+
+    Returns:
+      A `TensorBoardInfo` object, or `None` if none matches the cache key.
+    """
+    infos = get_all()
+    candidates = [info for info in infos if info.cache_key == cache_key]
+    for candidate in sorted(candidates, key=lambda x: x.port):
+        # TODO(@wchargin): Check here that the provided port is still live.
+        return candidate
+    return None
+
+
+def _maybe_read_file(filename):
+    """Read the given file, if it exists.
+
+    Args:
+      filename: A path to a file.
+
+    Returns:
+      A string containing the file contents, or `None` if the file does
+      not exist.
+    """
+    try:
+        with open(filename) as infile:
+            return infile.read()
+    except IOError as e:
+        if e.errno == errno.ENOENT:
+            return None

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/tensorboard/notebook.py

@@ -0,0 +1,443 @@
+# Copyright 2019 The TensorFlow Authors. All Rights Reserved.
+# 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.
+# ==============================================================================
+"""Utilities for using TensorBoard in notebook contexts, like Colab.
+
+These APIs are experimental and subject to change.
+"""
+
+
+import datetime
+import errno
+import html
+import json
+import os
+import random
+import shlex
+import textwrap
+import time
+
+from tensorboard import manager
+
+
+# Return values for `_get_context` (see that function's docs for
+# details).
+_CONTEXT_COLAB = "_CONTEXT_COLAB"
+_CONTEXT_IPYTHON = "_CONTEXT_IPYTHON"
+_CONTEXT_NONE = "_CONTEXT_NONE"
+
+
+def _get_context():
+    """Determine the most specific context that we're in.
+
+    Returns:
+      _CONTEXT_COLAB: If in Colab with an IPython notebook context.
+      _CONTEXT_IPYTHON: If not in Colab, but we are in an IPython notebook
+        context (e.g., from running `jupyter notebook` at the command
+        line).
+      _CONTEXT_NONE: Otherwise (e.g., by running a Python script at the
+        command-line or using the `ipython` interactive shell).
+    """
+    # In Colab, the `google.colab` module is available, but the shell
+    # returned by `IPython.get_ipython` does not have a `get_trait`
+    # method.
+    try:
+        import google.colab  # noqa: F401
+        import IPython
+    except ImportError:
+        pass
+    else:
+        if IPython.get_ipython() is not None:
+            # We'll assume that we're in a Colab notebook context.
+            return _CONTEXT_COLAB
+
+    # In an IPython command line shell or Jupyter notebook, we can
+    # directly query whether we're in a notebook context.
+    try:
+        import IPython
+    except ImportError:
+        pass
+    else:
+        ipython = IPython.get_ipython()
+        if ipython is not None and ipython.has_trait("kernel"):
+            return _CONTEXT_IPYTHON
+
+    # Otherwise, we're not in a known notebook context.
+    return _CONTEXT_NONE
+
+
+def load_ipython_extension(ipython):
+    """Deprecated: use `%load_ext tensorboard` instead.
+
+    Raises:
+      RuntimeError: Always.
+    """
+    raise RuntimeError(
+        "Use '%load_ext tensorboard' instead of '%load_ext tensorboard.notebook'."
+    )
+
+
+def _load_ipython_extension(ipython):
+    """Load the TensorBoard notebook extension.
+
+    Intended to be called from `%load_ext tensorboard`. Do not invoke this
+    directly.
+
+    Args:
+      ipython: An `IPython.InteractiveShell` instance.
+    """
+    _register_magics(ipython)
+
+
+def _register_magics(ipython):
+    """Register IPython line/cell magics.
+
+    Args:
+      ipython: An `InteractiveShell` instance.
+    """
+    ipython.register_magic_function(
+        _start_magic,
+        magic_kind="line",
+        magic_name="tensorboard",
+    )
+
+
+def _start_magic(line):
+    """Implementation of the `%tensorboard` line magic."""
+    return start(line)
+
+
+def start(args_string):
+    """Launch and display a TensorBoard instance as if at the command line.
+
+    Args:
+      args_string: Command-line arguments to TensorBoard, to be
+        interpreted by `shlex.split`: e.g., "--logdir ./logs --port 0".
+        Shell metacharacters are not supported: e.g., "--logdir 2>&1" will
+        point the logdir at the literal directory named "2>&1".
+    """
+    context = _get_context()
+    try:
+        import IPython
+        import IPython.display
+    except ImportError:
+        IPython = None
+
+    if context == _CONTEXT_NONE:
+        handle = None
+        print("Launching TensorBoard...")
+    else:
+        handle = IPython.display.display(
+            IPython.display.Pretty("Launching TensorBoard..."),
+            display_id=True,
+        )
+
+    def print_or_update(message):
+        if handle is None:
+            print(message)
+        else:
+            handle.update(IPython.display.Pretty(message))
+
+    parsed_args = shlex.split(args_string, comments=True, posix=True)
+    start_result = manager.start(parsed_args)
+
+    if isinstance(start_result, manager.StartLaunched):
+        _display(
+            port=start_result.info.port,
+            print_message=False,
+            display_handle=handle,
+        )
+
+    elif isinstance(start_result, manager.StartReused):
+        template = (
+            "Reusing TensorBoard on port {port} (pid {pid}), started {delta} ago. "
+            "(Use '!kill {pid}' to kill it.)"
+        )
+        message = template.format(
+            port=start_result.info.port,
+            pid=start_result.info.pid,
+            delta=_time_delta_from_info(start_result.info),
+        )
+        print_or_update(message)
+        _display(
+            port=start_result.info.port,
+            print_message=False,
+            display_handle=None,
+        )
+
+    elif isinstance(start_result, manager.StartFailed):
+
+        def format_stream(name, value):
+            if value == "":
+                return ""
+            elif value is None:
+                return "\n<could not read %s>" % name
+            else:
+                return "\nContents of %s:\n%s" % (name, value.strip())
+
+        message = (
+            "ERROR: Failed to launch TensorBoard (exited with %d).%s%s"
+            % (
+                start_result.exit_code,
+                format_stream("stderr", start_result.stderr),
+                format_stream("stdout", start_result.stdout),
+            )
+        )
+        print_or_update(message)
+
+    elif isinstance(start_result, manager.StartExecFailed):
+        the_tensorboard_binary = (
+            "%r (set by the `TENSORBOARD_BINARY` environment variable)"
+            % (start_result.explicit_binary,)
+            if start_result.explicit_binary is not None
+            else "`tensorboard`"
+        )
+        if start_result.os_error.errno == errno.ENOENT:
+            message = (
+                "ERROR: Could not find %s. Please ensure that your PATH contains "
+                "an executable `tensorboard` program, or explicitly specify the path "
+                "to a TensorBoard binary by setting the `TENSORBOARD_BINARY` "
+                "environment variable." % (the_tensorboard_binary,)
+            )
+        else:
+            message = "ERROR: Failed to start %s: %s" % (
+                the_tensorboard_binary,
+                start_result.os_error,
+            )
+        print_or_update(textwrap.fill(message))
+
+    elif isinstance(start_result, manager.StartTimedOut):
+        message = (
+            "ERROR: Timed out waiting for TensorBoard to start. "
+            "It may still be running as pid %d." % start_result.pid
+        )
+        print_or_update(message)
+
+    else:
+        raise TypeError(
+            "Unexpected result from `manager.start`: %r.\n"
+            "This is a TensorBoard bug; please report it." % start_result
+        )
+
+
+def _time_delta_from_info(info):
+    """Format the elapsed time for the given TensorBoardInfo.
+
+    Args:
+      info: A TensorBoardInfo value.
+
+    Returns:
+      A human-readable string describing the time since the server
+      described by `info` started: e.g., "2 days, 0:48:58".
+    """
+    delta_seconds = int(time.time()) - info.start_time
+    return str(datetime.timedelta(seconds=delta_seconds))
+
+
+def display(port=None, height=None):
+    """Display a TensorBoard instance already running on this machine.
+
+    Args:
+      port: The port on which the TensorBoard server is listening, as an
+        `int`, or `None` to automatically select the most recently
+        launched TensorBoard.
+      height: The height of the frame into which to render the TensorBoard
+        UI, as an `int` number of pixels, or `None` to use a default value
+        (currently 800).
+    """
+    _display(port=port, height=height, print_message=True, display_handle=None)
+
+
+def _display(port=None, height=None, print_message=False, display_handle=None):
+    """Internal version of `display`.
+
+    Args:
+      port: As with `display`.
+      height: As with `display`.
+      print_message: True to print which TensorBoard instance was selected
+        for display (if applicable), or False otherwise.
+      display_handle: If not None, an IPython display handle into which to
+        render TensorBoard.
+    """
+    if height is None:
+        height = 800
+
+    if port is None:
+        infos = manager.get_all()
+        if not infos:
+            raise ValueError(
+                "Can't display TensorBoard: no known instances running."
+            )
+        else:
+            info = max(manager.get_all(), key=lambda x: x.start_time)
+            port = info.port
+    else:
+        infos = [i for i in manager.get_all() if i.port == port]
+        info = max(infos, key=lambda x: x.start_time) if infos else None
+
+    if print_message:
+        if info is not None:
+            message = (
+                "Selecting TensorBoard with {data_source} "
+                "(started {delta} ago; port {port}, pid {pid})."
+            ).format(
+                data_source=manager.data_source_from_info(info),
+                delta=_time_delta_from_info(info),
+                port=info.port,
+                pid=info.pid,
+            )
+            print(message)
+        else:
+            # The user explicitly provided a port, and we don't have any
+            # additional information. There's nothing useful to say.
+            pass
+
+    fn = {
+        _CONTEXT_COLAB: _display_colab,
+        _CONTEXT_IPYTHON: _display_ipython,
+        _CONTEXT_NONE: _display_cli,
+    }[_get_context()]
+    return fn(port=port, height=height, display_handle=display_handle)
+
+
+def _display_colab(port, height, display_handle):
+    """Display a TensorBoard instance in a Colab output frame.
+
+    The Colab VM is not directly exposed to the network, so the Colab
+    runtime provides a service worker tunnel to proxy requests from the
+    end user's browser through to servers running on the Colab VM: the
+    output frame may issue requests to https://localhost:<port> (HTTPS
+    only), which will be forwarded to the specified port on the VM.
+
+    It does not suffice to create an `iframe` and let the service worker
+    redirect its traffic (`<iframe src="https://localhost:6006">`),
+    because for security reasons service workers cannot intercept iframe
+    traffic. Instead, we manually fetch the TensorBoard index page with an
+    XHR in the output frame, and inject the raw HTML into `document.body`.
+
+    By default, the TensorBoard web app requests resources against
+    relative paths, like `./data/logdir`. Within the output frame, these
+    requests must instead hit `https://localhost:<port>/data/logdir`. To
+    redirect them, we change the document base URI, which transparently
+    affects all requests (XHRs and resources alike).
+    """
+    import IPython.display
+
+    shell = """
+        (async () => {
+            const url = new URL(await google.colab.kernel.proxyPort(%PORT%, {'cache': true}));
+            url.searchParams.set('tensorboardColab', 'true');
+            const iframe = document.createElement('iframe');
+            iframe.src = url;
+            iframe.setAttribute('width', '100%');
+            iframe.setAttribute('height', '%HEIGHT%');
+            iframe.setAttribute('frameborder', 0);
+            document.body.appendChild(iframe);
+        })();
+    """
+    replacements = [
+        ("%PORT%", "%d" % port),
+        ("%HEIGHT%", "%d" % height),
+    ]
+    for (k, v) in replacements:
+        shell = shell.replace(k, v)
+    script = IPython.display.Javascript(shell)
+
+    if display_handle:
+        display_handle.update(script)
+    else:
+        IPython.display.display(script)
+
+
+def _display_ipython(port, height, display_handle):
+    import IPython.display
+
+    frame_id = "tensorboard-frame-{:08x}".format(random.getrandbits(64))
+    shell = """
+      <iframe id="%HTML_ID%" width="100%" height="%HEIGHT%" frameborder="0">
+      </iframe>
+      <script>
+        (function() {
+          const frame = document.getElementById(%JSON_ID%);
+          const url = new URL(%URL%, window.location);
+          const port = %PORT%;
+          if (port) {
+            url.port = port;
+          }
+          frame.src = url;
+        })();
+      </script>
+    """
+    proxy_url = os.environ.get("TENSORBOARD_PROXY_URL")
+    if proxy_url is not None:
+        # Allow %PORT% in $TENSORBOARD_PROXY_URL
+        proxy_url = proxy_url.replace("%PORT%", "%d" % port)
+        replacements = [
+            ("%HTML_ID%", html.escape(frame_id, quote=True)),
+            ("%JSON_ID%", json.dumps(frame_id)),
+            ("%HEIGHT%", "%d" % height),
+            ("%PORT%", "0"),
+            ("%URL%", json.dumps(proxy_url)),
+        ]
+    else:
+        replacements = [
+            ("%HTML_ID%", html.escape(frame_id, quote=True)),
+            ("%JSON_ID%", json.dumps(frame_id)),
+            ("%HEIGHT%", "%d" % height),
+            ("%PORT%", "%d" % port),
+            ("%URL%", json.dumps("/")),
+        ]
+
+    for (k, v) in replacements:
+        shell = shell.replace(k, v)
+    iframe = IPython.display.HTML(shell)
+    if display_handle:
+        display_handle.update(iframe)
+    else:
+        IPython.display.display(iframe)
+
+
+def _display_cli(port, height, display_handle):
+    del height  # unused
+    del display_handle  # unused
+    message = "Please visit http://localhost:%d in a web browser." % port
+    print(message)
+
+
+def list():
+    """Print a listing of known running TensorBoard instances.
+
+    TensorBoard instances that were killed uncleanly (e.g., with SIGKILL
+    or SIGQUIT) may appear in this list even if they are no longer
+    running. Conversely, this list may be missing some entries if your
+    operating system's temporary directory has been cleared since a
+    still-running TensorBoard instance started.
+    """
+    infos = manager.get_all()
+    if not infos:
+        print("No known TensorBoard instances running.")
+        return
+
+    print("Known TensorBoard instances:")
+    for info in infos:
+        template = (
+            "  - port {port}: {data_source} (started {delta} ago; pid {pid})"
+        )
+        print(
+            template.format(
+                port=info.port,
+                data_source=manager.data_source_from_info(info),
+                delta=_time_delta_from_info(info),
+                pid=info.pid,
+            )
+        )

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/tensorboard/plugin_util.py

@@ -0,0 +1,242 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# 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.
+# ==============================================================================
+"""Provides utilities that may be especially useful to plugins."""
+
+
+import threading
+
+from tensorboard._vendor.bleach.sanitizer import Cleaner
+
+# pylint: disable=g-bad-import-order
+# Google-only: import markdown_freewisdom
+import markdown
+
+from tensorboard import context as _context
+from tensorboard.backend import experiment_id as _experiment_id
+from tensorboard.util import tb_logging
+
+
+logger = tb_logging.get_logger()
+
+_ALLOWED_ATTRIBUTES = {
+    "a": ["href", "title"],
+    "img": ["src", "title", "alt"],
+}
+
+_ALLOWED_TAGS = [
+    "ul",
+    "ol",
+    "li",
+    "p",
+    "pre",
+    "code",
+    "blockquote",
+    "h1",
+    "h2",
+    "h3",
+    "h4",
+    "h5",
+    "h6",
+    "hr",
+    "br",
+    "strong",
+    "em",
+    "a",
+    "img",
+    "table",
+    "thead",
+    "tbody",
+    "td",
+    "tr",
+    "th",
+]
+
+# Cache Markdown converter to avoid expensive initialization at each
+# call to `markdown_to_safe_html`. Cache a different instance per thread.
+class _MarkdownStore(threading.local):
+    def __init__(self):
+        self.markdown = markdown.Markdown(
+            extensions=[
+                "markdown.extensions.tables",
+                "markdown.extensions.fenced_code",
+            ]
+        )
+
+
+_MARKDOWN_STORE = _MarkdownStore()
+
+
+# Cache Cleaner to avoid expensive initialization at each call to `clean`.
+# Cache a different instance per thread.
+class _CleanerStore(threading.local):
+    def __init__(self):
+        self.cleaner = Cleaner(
+            tags=_ALLOWED_TAGS, attributes=_ALLOWED_ATTRIBUTES
+        )
+
+
+_CLEANER_STORE = _CleanerStore()
+
+
+def safe_html(unsafe_string):
+    """Return the input as a str, sanitized for insertion into the DOM.
+
+    Arguments:
+      unsafe_string: A Unicode string or UTF-8--encoded bytestring
+        possibly containing unsafe HTML markup.
+
+    Returns:
+      A string containing safe HTML.
+    """
+    total_null_bytes = 0
+    if isinstance(unsafe_string, bytes):
+        unsafe_string = unsafe_string.decode("utf-8")
+    return _CLEANER_STORE.cleaner.clean(unsafe_string)
+
+
+def markdown_to_safe_html(markdown_string):
+    """Convert Markdown to HTML that's safe to splice into the DOM.
+
+    Arguments:
+      markdown_string: A Unicode string or UTF-8--encoded bytestring
+        containing Markdown source. Markdown tables are supported.
+
+    Returns:
+      A string containing safe HTML.
+    """
+    return markdowns_to_safe_html([markdown_string], lambda xs: xs[0])
+
+
+def markdowns_to_safe_html(markdown_strings, combine):
+    """Convert multiple Markdown documents to one safe HTML document.
+
+    One could also achieve this by calling `markdown_to_safe_html`
+    multiple times and combining the results. Compared to that approach,
+    this function may be faster, because HTML sanitization (which can be
+    expensive) is performed only once rather than once per input. It may
+    also be less precise: if one of the input documents has unsafe HTML
+    that is sanitized away, that sanitization might affect other
+    documents, even if those documents are safe.
+
+    Args:
+      markdown_strings: List of Markdown source strings to convert, as
+        Unicode strings or UTF-8--encoded bytestrings. Markdown tables
+        are supported.
+      combine: Callback function that takes a list of unsafe HTML
+        strings of the same shape as `markdown_strings` and combines
+        them into a single unsafe HTML string, which will be sanitized
+        and returned.
+
+    Returns:
+      A string containing safe HTML.
+    """
+    unsafe_htmls = []
+    total_null_bytes = 0
+
+    for source in markdown_strings:
+        # Convert to utf-8 whenever we have a binary input.
+        if isinstance(source, bytes):
+            source_decoded = source.decode("utf-8")
+            # Remove null bytes and warn if there were any, since it probably means
+            # we were given a bad encoding.
+            source = source_decoded.replace("\x00", "")
+            total_null_bytes += len(source_decoded) - len(source)
+        unsafe_html = _MARKDOWN_STORE.markdown.convert(source)
+        unsafe_htmls.append(unsafe_html)
+
+    unsafe_combined = combine(unsafe_htmls)
+    sanitized_combined = _CLEANER_STORE.cleaner.clean(unsafe_combined)
+
+    warning = ""
+    if total_null_bytes:
+        warning = (
+            "<!-- WARNING: discarded %d null bytes in markdown string "
+            "after UTF-8 decoding -->\n"
+        ) % total_null_bytes
+
+    return warning + sanitized_combined
+
+
+def context(environ):
+    """Get a TensorBoard `RequestContext` from a WSGI environment.
+
+    Returns:
+      A `RequestContext` value.
+    """
+    return _context.from_environ(environ)
+
+
+def experiment_id(environ):
+    """Determine the experiment ID associated with a WSGI request.
+
+    Each request to TensorBoard has an associated experiment ID, which is
+    always a string and may be empty. This experiment ID should be passed
+    to data providers.
+
+    Args:
+      environ: A WSGI environment `dict`. For a Werkzeug request, this is
+        `request.environ`.
+
+    Returns:
+      A experiment ID, as a possibly-empty `str`.
+    """
+    return environ.get(_experiment_id.WSGI_ENVIRON_KEY, "")
+
+
+class _MetadataVersionChecker:
+    """TensorBoard-internal utility for warning when data is too new.
+
+    Specify a maximum known `version` number as stored in summary
+    metadata, and automatically reject and warn on data from newer
+    versions. This keeps a (single) bit of internal state to handle
+    logging a warning to the user at most once.
+
+    This should only be used by plugins bundled with TensorBoard, since
+    it may instruct users to upgrade their copy of TensorBoard.
+    """
+
+    def __init__(self, data_kind, latest_known_version):
+        """Initialize a `_MetadataVersionChecker`.
+
+        Args:
+          data_kind: A human-readable description of the kind of data
+            being read, like "scalar" or "histogram" or "PR curve".
+          latest_known_version: Highest tolerated value of `version`,
+            like `0`.
+        """
+        self._data_kind = data_kind
+        self._latest_known_version = latest_known_version
+        self._warned = False
+
+    def ok(self, version, run, tag):
+        """Test whether `version` is permitted, else complain."""
+        if 0 <= version <= self._latest_known_version:
+            return True
+        self._maybe_warn(version, run, tag)
+        return False
+
+    def _maybe_warn(self, version, run, tag):
+        if self._warned:
+            return
+        self._warned = True
+        logger.warning(
+            "Some %s data is too new to be read by this version of TensorBoard. "
+            "Upgrading TensorBoard may fix this. "
+            "(sample: run %r, tag %r, data version %r)",
+            self._data_kind,
+            run,
+            tag,
+            version,
+        )

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/tensorboard/program.py

@@ -0,0 +1,893 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# 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.
+# ==============================================================================
+"""Utilities for TensorBoard command line program.
+
+This is a lightweight module for bringing up a TensorBoard HTTP server
+or emulating the `tensorboard` shell command.
+
+Those wishing to create custom builds of TensorBoard can use this module
+by swapping out `tensorboard.main` with the custom definition that
+modifies the set of plugins and static assets.
+
+This module does not depend on first-party plugins or the default web
+server assets. Those are defined in `tensorboard.default`.
+"""
+
+
+from abc import ABCMeta
+from abc import abstractmethod
+import argparse
+import atexit
+from collections import defaultdict
+import errno
+import logging
+import mimetypes
+import os
+import shlex
+import signal
+import socket
+import sys
+import threading
+import time
+import urllib.parse
+
+from absl import flags as absl_flags
+from absl.flags import argparse_flags
+from werkzeug import serving
+
+from tensorboard import manager
+from tensorboard import version
+from tensorboard.backend import application
+from tensorboard.backend.event_processing import data_ingester as local_ingester
+from tensorboard.backend.event_processing import event_file_inspector as efi
+from tensorboard.data import server_ingester
+from tensorboard.plugins.core import core_plugin
+from tensorboard.util import tb_logging
+
+
+logger = tb_logging.get_logger()
+
+# Default subcommand name. This is a user-facing CLI and should not change.
+_SERVE_SUBCOMMAND_NAME = "serve"
+# Internal flag name used to store which subcommand was invoked.
+_SUBCOMMAND_FLAG = "__tensorboard_subcommand"
+
+# Message printed when we actually use the data server, so that users are not
+# caught terribly by surprise.
+_DATA_SERVER_ADVISORY_MESSAGE = """
+NOTE: Using experimental fast data loading logic. To disable, pass
+    "--load_fast=false" and report issues on GitHub. More details:
+    https://github.com/tensorflow/tensorboard/issues/4784
+
+"""
+
+# Message printed with `--load_fast=true` if the data server could not start up.
+# To be formatted with one `DataServerStartupError` interpoland.
+_DATA_SERVER_STARTUP_ERROR_MESSAGE_TEMPLATE = """\
+Could not start data server: %s.
+    Try with --load_fast=false and report issues on GitHub. Details:
+    https://github.com/tensorflow/tensorboard/issues/4784
+"""
+
+
+class TensorBoard(object):
+    """Class for running TensorBoard.
+
+    Fields:
+      plugin_loaders: Set from plugins passed to constructor.
+      assets_zip_provider: Set by constructor.
+      server_class: Set by constructor.
+      flags: An argparse.Namespace set by the configure() method.
+      cache_key: As `manager.cache_key`; set by the configure() method.
+    """
+
+    def __init__(
+        self,
+        plugins=None,
+        assets_zip_provider=None,
+        server_class=None,
+        subcommands=None,
+    ):
+        """Creates new instance.
+
+        Args:
+          plugins: A list of TensorBoard plugins to load, as TBPlugin classes or
+            TBLoader instances or classes. If not specified, defaults to first-party
+            plugins.
+          assets_zip_provider: A function that provides a zip file containing
+            assets to the application. If `None`, the default TensorBoard web
+            assets will be used. (If building from source, your binary must
+            explicitly depend on `//tensorboard:assets_lib` if you pass `None`.)
+          server_class: An optional factory for a `TensorBoardServer` to use
+            for serving the TensorBoard WSGI app. If provided, its callable
+            signature should match that of `TensorBoardServer.__init__`.
+
+        :type plugins:
+          list[
+            base_plugin.TBLoader | Type[base_plugin.TBLoader] |
+            Type[base_plugin.TBPlugin]
+          ]
+        """
+        if plugins is None:
+            from tensorboard import default
+
+            plugins = default.get_plugins()
+        if assets_zip_provider is None:
+            try:
+                from tensorboard import assets
+            except ImportError as e:
+                # `tensorboard.assets` is not a strict Bazel dep; clients are
+                # required to either depend on `//tensorboard:assets_lib` or
+                # pass a valid assets provider.
+                raise ImportError(
+                    "No `assets_zip_provider` given, but `tensorboard.assets` "
+                    "could not be imported to resolve defaults"
+                ) from e
+            assets_zip_provider = assets.get_default_assets_zip_provider()
+        if server_class is None:
+            server_class = create_port_scanning_werkzeug_server
+        if subcommands is None:
+            subcommands = []
+        self.plugin_loaders = [
+            application.make_plugin_loader(p) for p in plugins
+        ]
+        self.assets_zip_provider = assets_zip_provider
+        self.server_class = server_class
+        self.subcommands = {}
+        for subcommand in subcommands:
+            name = subcommand.name()
+            if name in self.subcommands or name == _SERVE_SUBCOMMAND_NAME:
+                raise ValueError("Duplicate subcommand name: %r" % name)
+            self.subcommands[name] = subcommand
+        self.flags = None
+
+    def configure(self, argv=("",), **kwargs):
+        """Configures TensorBoard behavior via flags.
+
+        This method will populate the "flags" property with an argparse.Namespace
+        representing flag values parsed from the provided argv list, overridden by
+        explicit flags from remaining keyword arguments.
+
+        Args:
+          argv: Can be set to CLI args equivalent to sys.argv; the first arg is
+            taken to be the name of the path being executed.
+          kwargs: Additional arguments will override what was parsed from
+            argv. They must be passed as Python data structures, e.g.
+            `foo=1` rather than `foo="1"`.
+
+        Returns:
+          Either argv[:1] if argv was non-empty, or [''] otherwise, as a mechanism
+          for absl.app.run() compatibility.
+
+        Raises:
+          ValueError: If flag values are invalid.
+        """
+
+        base_parser = argparse_flags.ArgumentParser(
+            prog="tensorboard",
+            description=(
+                "TensorBoard is a suite of web applications for "
+                "inspecting and understanding your TensorFlow runs "
+                "and graphs. https://github.com/tensorflow/tensorboard "
+            ),
+        )
+        subparsers = base_parser.add_subparsers(
+            help="TensorBoard subcommand (defaults to %r)"
+            % _SERVE_SUBCOMMAND_NAME
+        )
+
+        serve_subparser = subparsers.add_parser(
+            _SERVE_SUBCOMMAND_NAME,
+            help="start local TensorBoard server (default subcommand)",
+        )
+        serve_subparser.set_defaults(
+            **{_SUBCOMMAND_FLAG: _SERVE_SUBCOMMAND_NAME}
+        )
+
+        if len(argv) < 2 or argv[1].startswith("-"):
+            # This invocation, if valid, must not use any subcommands: we
+            # don't permit flags before the subcommand name.
+            serve_parser = base_parser
+        else:
+            # This invocation, if valid, must use a subcommand: we don't take
+            # any positional arguments to `serve`.
+            serve_parser = serve_subparser
+
+        for (name, subcommand) in self.subcommands.items():
+            subparser = subparsers.add_parser(
+                name,
+                help=subcommand.help(),
+                description=subcommand.description(),
+            )
+            subparser.set_defaults(**{_SUBCOMMAND_FLAG: name})
+            subcommand.define_flags(subparser)
+
+        for loader in self.plugin_loaders:
+            loader.define_flags(serve_parser)
+
+        arg0 = argv[0] if argv else ""
+
+        flags = base_parser.parse_args(argv[1:])  # Strip binary name from argv.
+        if getattr(flags, _SUBCOMMAND_FLAG, None) is None:
+            # Manually assign default value rather than using `set_defaults`
+            # on the base parser to work around Python bug #9351 on old
+            # versions of `argparse`: <https://bugs.python.org/issue9351>
+            setattr(flags, _SUBCOMMAND_FLAG, _SERVE_SUBCOMMAND_NAME)
+
+        self.cache_key = manager.cache_key(
+            working_directory=os.getcwd(),
+            arguments=argv[1:],
+            configure_kwargs=kwargs,
+        )
+        if arg0:
+            # Only expose main module Abseil flags as TensorBoard native flags.
+            # This is the same logic Abseil's ArgumentParser uses for determining
+            # which Abseil flags to include in the short helpstring.
+            for flag in set(absl_flags.FLAGS.get_key_flags_for_module(arg0)):
+                if hasattr(flags, flag.name):
+                    raise ValueError("Conflicting Abseil flag: %s" % flag.name)
+                setattr(flags, flag.name, flag.value)
+        for k, v in kwargs.items():
+            if not hasattr(flags, k):
+                raise ValueError("Unknown TensorBoard flag: %s" % k)
+            setattr(flags, k, v)
+        if getattr(flags, _SUBCOMMAND_FLAG) == _SERVE_SUBCOMMAND_NAME:
+            for loader in self.plugin_loaders:
+                loader.fix_flags(flags)
+        self.flags = flags
+        return [arg0]
+
+    def main(self, ignored_argv=("",)):
+        """Blocking main function for TensorBoard.
+
+        This method is called by `tensorboard.main.run_main`, which is the
+        standard entrypoint for the tensorboard command line program. The
+        configure() method must be called first.
+
+        Args:
+          ignored_argv: Do not pass. Required for Abseil compatibility.
+
+        Returns:
+          Process exit code, i.e. 0 if successful or non-zero on failure. In
+          practice, an exception will most likely be raised instead of
+          returning non-zero.
+
+        :rtype: int
+        """
+        self._install_signal_handler(signal.SIGTERM, "SIGTERM")
+        self._fix_mime_types()
+        subcommand_name = getattr(self.flags, _SUBCOMMAND_FLAG)
+        if subcommand_name == _SERVE_SUBCOMMAND_NAME:
+            runner = self._run_serve_subcommand
+        else:
+            runner = self.subcommands[subcommand_name].run
+        return runner(self.flags) or 0
+
+    def _run_serve_subcommand(self, flags):
+        # TODO(#2801): Make `--version` a flag on only the base parser, not `serve`.
+        if flags.version_tb:
+            print(version.VERSION)
+            return 0
+        if flags.inspect:
+            # TODO(@wchargin): Convert `inspect` to a normal subcommand?
+            logger.info(
+                "Not bringing up TensorBoard, but inspecting event files."
+            )
+            event_file = os.path.expanduser(flags.event_file)
+            efi.inspect(flags.logdir, event_file, flags.tag)
+            return 0
+        try:
+            server = self._make_server()
+            server.print_serving_message()
+            self._register_info(server)
+            server.serve_forever()
+            return 0
+        except TensorBoardServerException as e:
+            logger.error(e.msg)
+            sys.stderr.write("ERROR: %s\n" % e.msg)
+            sys.stderr.flush()
+            return -1
+
+    def launch(self):
+        """Python API for launching TensorBoard.
+
+        This method is the same as main() except it launches TensorBoard in
+        a separate permanent thread. The configure() method must be called
+        first.
+
+        Returns:
+          The URL of the TensorBoard web server.
+
+        :rtype: str
+        """
+        # Make it easy to run TensorBoard inside other programs, e.g. Colab.
+        server = self._make_server()
+        thread = threading.Thread(
+            target=server.serve_forever, name="TensorBoard"
+        )
+        thread.daemon = True
+        thread.start()
+        return server.get_url()
+
+    def _register_info(self, server):
+        """Write a TensorBoardInfo file and arrange for its cleanup.
+
+        Args:
+          server: The result of `self._make_server()`.
+        """
+        server_url = urllib.parse.urlparse(server.get_url())
+        info = manager.TensorBoardInfo(
+            version=version.VERSION,
+            start_time=int(time.time()),
+            port=server_url.port,
+            pid=os.getpid(),
+            path_prefix=self.flags.path_prefix,
+            logdir=self.flags.logdir or self.flags.logdir_spec,
+            db=self.flags.db,
+            cache_key=self.cache_key,
+        )
+        atexit.register(manager.remove_info_file)
+        manager.write_info_file(info)
+
+    def _install_signal_handler(self, signal_number, signal_name):
+        """Set a signal handler to gracefully exit on the given signal.
+
+        When this process receives the given signal, it will run `atexit`
+        handlers and then exit with `0`.
+
+        Args:
+          signal_number: The numeric code for the signal to handle, like
+            `signal.SIGTERM`.
+          signal_name: The human-readable signal name.
+        """
+        # Note to maintainers: Google-internal code overrides this
+        # method (cf. cl/334534610). Double-check changes before
+        # modifying API.
+
+        old_signal_handler = None  # set below
+
+        def handler(handled_signal_number, frame):
+            # In case we catch this signal again while running atexit
+            # handlers, take the hint and actually die.
+            signal.signal(signal_number, signal.SIG_DFL)
+            sys.stderr.write(
+                "TensorBoard caught %s; exiting...\n" % signal_name
+            )
+            # The main thread is the only non-daemon thread, so it suffices to
+            # exit hence.
+            if old_signal_handler not in (signal.SIG_IGN, signal.SIG_DFL):
+                old_signal_handler(handled_signal_number, frame)
+            sys.exit(0)
+
+        old_signal_handler = signal.signal(signal_number, handler)
+
+    def _fix_mime_types(self):
+        """Fix incorrect entries in the `mimetypes` registry.
+
+        On Windows, the Python standard library's `mimetypes` reads in
+        mappings from file extension to MIME type from the Windows
+        registry. Other applications can and do write incorrect values
+        to this registry, which causes `mimetypes.guess_type` to return
+        incorrect values, which causes TensorBoard to fail to render on
+        the frontend.
+
+        This method hard-codes the correct mappings for certain MIME
+        types that are known to be either used by TensorBoard or
+        problematic in general.
+        """
+        # Known to be problematic when Visual Studio is installed:
+        # <https://github.com/tensorflow/tensorboard/issues/3120>
+        mimetypes.add_type("text/javascript", ".js")
+        # Not known to be problematic, but used by TensorBoard:
+        mimetypes.add_type("font/woff2", ".woff2")
+        mimetypes.add_type("text/html", ".html")
+
+    def _start_subprocess_data_ingester(self):
+        """Creates, starts, and returns a `SubprocessServerDataIngester`."""
+        flags = self.flags
+        server_binary = server_ingester.get_server_binary()
+        ingester = server_ingester.SubprocessServerDataIngester(
+            server_binary=server_binary,
+            logdir=flags.logdir,
+            reload_interval=flags.reload_interval,
+            channel_creds_type=flags.grpc_creds_type,
+            samples_per_plugin=flags.samples_per_plugin,
+            extra_flags=shlex.split(flags.extra_data_server_flags),
+        )
+        ingester.start()
+        return ingester
+
+    def _make_data_ingester(self):
+        """Determines the right data ingester, starts it, and returns it."""
+        flags = self.flags
+        if flags.grpc_data_provider:
+            ingester = server_ingester.ExistingServerDataIngester(
+                flags.grpc_data_provider,
+                channel_creds_type=flags.grpc_creds_type,
+            )
+            ingester.start()
+            return ingester
+
+        if flags.load_fast == "true":
+            try:
+                return self._start_subprocess_data_ingester()
+            except server_ingester.NoDataServerError as e:
+                msg = "Option --load_fast=true not available: %s\n" % e
+                sys.stderr.write(msg)
+                sys.exit(1)
+            except server_ingester.DataServerStartupError as e:
+                msg = _DATA_SERVER_STARTUP_ERROR_MESSAGE_TEMPLATE % e
+                sys.stderr.write(msg)
+                sys.exit(1)
+
+        if flags.load_fast == "auto" and _should_use_data_server(flags):
+            try:
+                ingester = self._start_subprocess_data_ingester()
+                sys.stderr.write(_DATA_SERVER_ADVISORY_MESSAGE)
+                sys.stderr.flush()
+                return ingester
+            except server_ingester.NoDataServerError as e:
+                logger.info("No data server: %s", e)
+            except server_ingester.DataServerStartupError as e:
+                logger.info(
+                    "Data server error: %s; falling back to multiplexer", e
+                )
+
+        ingester = local_ingester.LocalDataIngester(flags)
+        ingester.start()
+        return ingester
+
+    def _make_data_provider(self):
+        """Returns `(data_provider, deprecated_multiplexer)`."""
+        ingester = self._make_data_ingester()
+        # Stash ingester so that it can avoid GCing Windows file handles.
+        # (See comment in `SubprocessServerDataIngester.start` for details.)
+        self._ingester = ingester
+
+        deprecated_multiplexer = None
+        if isinstance(ingester, local_ingester.LocalDataIngester):
+            deprecated_multiplexer = ingester.deprecated_multiplexer
+        return (ingester.data_provider, deprecated_multiplexer)
+
+    def _make_server(self):
+        """Constructs the TensorBoard WSGI app and instantiates the server."""
+        (data_provider, deprecated_multiplexer) = self._make_data_provider()
+        app = application.TensorBoardWSGIApp(
+            self.flags,
+            self.plugin_loaders,
+            data_provider,
+            self.assets_zip_provider,
+            deprecated_multiplexer,
+        )
+        return self.server_class(app, self.flags)
+
+
+def _should_use_data_server(flags):
+    if flags.logdir_spec and not flags.logdir:
+        logger.info(
+            "Note: --logdir_spec is not supported with --load_fast behavior; "
+            "falling back to slower Python-only load path. To use the data "
+            "server, replace --logdir_spec with --logdir."
+        )
+        return False
+    if not flags.logdir:
+        # Using some other legacy mode; not supported.
+        return False
+    if "://" in flags.logdir and not flags.logdir.startswith("gs://"):
+        logger.info(
+            "Note: --load_fast behavior only supports local and GCS (gs://) "
+            "paths; falling back to slower Python-only load path."
+        )
+        return False
+    if flags.detect_file_replacement is True:
+        logger.info(
+            "Note: --detect_file_replacement=true is not supported with "
+            "--load_fast behavior; falling back to slower Python-only load "
+            "path."
+        )
+        return False
+    return True
+
+
+class TensorBoardSubcommand(metaclass=ABCMeta):
+    """Experimental private API for defining subcommands to tensorboard(1)."""
+
+    @abstractmethod
+    def name(self):
+        """Name of this subcommand, as specified on the command line.
+
+        This must be unique across all subcommands.
+
+        Returns:
+          A string.
+        """
+        pass
+
+    @abstractmethod
+    def define_flags(self, parser):
+        """Configure an argument parser for this subcommand.
+
+        Flags whose names start with two underscores (e.g., `__foo`) are
+        reserved for use by the runtime and must not be defined by
+        subcommands.
+
+        Args:
+          parser: An `argparse.ArgumentParser` scoped to this subcommand,
+            which this function should mutate.
+        """
+        pass
+
+    @abstractmethod
+    def run(self, flags):
+        """Execute this subcommand with user-provided flags.
+
+        Args:
+          flags: An `argparse.Namespace` object with all defined flags.
+
+        Returns:
+          An `int` exit code, or `None` as an alias for `0`.
+        """
+        pass
+
+    def help(self):
+        """Short, one-line help text to display on `tensorboard --help`."""
+        return None
+
+    def description(self):
+        """Description to display on `tensorboard SUBCOMMAND --help`."""
+        return None
+
+
+class TensorBoardServer(metaclass=ABCMeta):
+    """Class for customizing TensorBoard WSGI app serving."""
+
+    @abstractmethod
+    def __init__(self, wsgi_app, flags):
+        """Create a flag-configured HTTP server for TensorBoard's WSGI app.
+
+        Args:
+          wsgi_app: The TensorBoard WSGI application to create a server for.
+          flags: argparse.Namespace instance of TensorBoard flags.
+        """
+        raise NotImplementedError()
+
+    @abstractmethod
+    def serve_forever(self):
+        """Blocking call to start serving the TensorBoard server."""
+        raise NotImplementedError()
+
+    @abstractmethod
+    def get_url(self):
+        """Returns a URL at which this server should be reachable."""
+        raise NotImplementedError()
+
+    def print_serving_message(self):
+        """Prints a user-friendly message prior to server start.
+
+        This will be called just before `serve_forever`.
+        """
+        sys.stderr.write(
+            "TensorBoard %s at %s (Press CTRL+C to quit)\n"
+            % (version.VERSION, self.get_url())
+        )
+        sys.stderr.flush()
+
+
+class TensorBoardServerException(Exception):
+    """Exception raised by TensorBoardServer for user-friendly errors.
+
+    Subclasses of TensorBoardServer can raise this exception in order to
+    generate a clean error message for the user rather than a
+    stacktrace.
+    """
+
+    def __init__(self, msg):
+        self.msg = msg
+
+
+class TensorBoardPortInUseError(TensorBoardServerException):
+    """Error raised when attempting to bind to a port that is in use.
+
+    This should be raised when it is expected that binding to another
+    similar port would succeed. It is used as a signal to indicate that
+    automatic port searching should continue rather than abort.
+    """
+
+    pass
+
+
+def with_port_scanning(cls):
+    """Create a server factory that performs port scanning.
+
+    This function returns a callable whose signature matches the
+    specification of `TensorBoardServer.__init__`, using `cls` as an
+    underlying implementation. It passes through `flags` unchanged except
+    in the case that `flags.port is None`, in which case it repeatedly
+    instantiates the underlying server with new port suggestions.
+
+    Args:
+      cls: A valid implementation of `TensorBoardServer`. This class's
+        initializer should raise a `TensorBoardPortInUseError` upon
+        failing to bind to a port when it is expected that binding to
+        another nearby port might succeed.
+
+        The initializer for `cls` will only ever be invoked with `flags`
+        such that `flags.port is not None`.
+
+    Returns:
+      A function that implements the `__init__` contract of
+      `TensorBoardServer`.
+    """
+
+    def init(wsgi_app, flags):
+        # base_port: what's the first port to which we should try to bind?
+        # should_scan: if that fails, shall we try additional ports?
+        # max_attempts: how many ports shall we try?
+        should_scan = flags.port is None
+        base_port = (
+            core_plugin.DEFAULT_PORT if flags.port is None else flags.port
+        )
+
+        if base_port > 0xFFFF:
+            raise TensorBoardServerException(
+                "TensorBoard cannot bind to port %d > %d" % (base_port, 0xFFFF)
+            )
+        max_attempts = 100 if should_scan else 1
+        base_port = min(base_port + max_attempts, 0x10000) - max_attempts
+
+        for port in range(base_port, base_port + max_attempts):
+            subflags = argparse.Namespace(**vars(flags))
+            subflags.port = port
+            try:
+                return cls(wsgi_app=wsgi_app, flags=subflags)
+            except TensorBoardPortInUseError:
+                if not should_scan:
+                    raise
+        # All attempts failed to bind.
+        raise TensorBoardServerException(
+            "TensorBoard could not bind to any port around %s "
+            "(tried %d times)" % (base_port, max_attempts)
+        )
+
+    return init
+
+
+class _WSGIRequestHandler(serving.WSGIRequestHandler):
+    """Custom subclass of Werkzeug request handler to use HTTP/1.1."""
+
+    # The default on the http.server is HTTP/1.0 for legacy reasons:
+    # https://docs.python.org/3/library/http.server.html#http.server.BaseHTTPRequestHandler.protocol_version
+    # Override here to use HTTP/1.1 to avoid needing a new TCP socket and Python
+    # thread for each HTTP request. The tradeoff is we must always specify the
+    # Content-Length header, or do chunked encoding for streaming.
+    protocol_version = "HTTP/1.1"
+
+
+class WerkzeugServer(serving.ThreadedWSGIServer, TensorBoardServer):
+    """Implementation of TensorBoardServer using the Werkzeug dev server."""
+
+    # ThreadedWSGIServer handles this in werkzeug 0.12+ but we allow 0.11.x.
+    daemon_threads = True
+
+    def __init__(self, wsgi_app, flags):
+        self._flags = flags
+        host = flags.host
+        port = flags.port
+
+        self._auto_wildcard = flags.bind_all
+        if self._auto_wildcard:
+            # Serve on all interfaces, and attempt to serve both IPv4 and IPv6
+            # traffic through one socket.
+            host = self._get_wildcard_address(port)
+        elif host is None:
+            host = "localhost"
+
+        self._host = host
+        self._url = None  # Will be set by get_url() below
+
+        self._fix_werkzeug_logging()
+        try:
+            super(WerkzeugServer, self).__init__(
+                host, port, wsgi_app, _WSGIRequestHandler
+            )
+        except socket.error as e:
+            if hasattr(errno, "EACCES") and e.errno == errno.EACCES:
+                raise TensorBoardServerException(
+                    "TensorBoard must be run as superuser to bind to port %d"
+                    % port
+                )
+            elif hasattr(errno, "EADDRINUSE") and e.errno == errno.EADDRINUSE:
+                if port == 0:
+                    raise TensorBoardServerException(
+                        "TensorBoard unable to find any open port"
+                    )
+                else:
+                    raise TensorBoardPortInUseError(
+                        "TensorBoard could not bind to port %d, it was already in use"
+                        % port
+                    )
+            elif (
+                hasattr(errno, "EADDRNOTAVAIL")
+                and e.errno == errno.EADDRNOTAVAIL
+            ):
+                raise TensorBoardServerException(
+                    "TensorBoard could not bind to unavailable address %s"
+                    % host
+                )
+            elif (
+                hasattr(errno, "EAFNOSUPPORT") and e.errno == errno.EAFNOSUPPORT
+            ):
+                raise TensorBoardServerException(
+                    "Tensorboard could not bind to unsupported address family %s"
+                    % host
+                )
+            # Raise the raw exception if it wasn't identifiable as a user error.
+            raise
+
+    def _get_wildcard_address(self, port):
+        """Returns a wildcard address for the port in question.
+
+        This will attempt to follow the best practice of calling
+        getaddrinfo() with a null host and AI_PASSIVE to request a
+        server-side socket wildcard address. If that succeeds, this
+        returns the first IPv6 address found, or if none, then returns
+        the first IPv4 address. If that fails, then this returns the
+        hardcoded address "::" if socket.has_ipv6 is True, else
+        "0.0.0.0".
+        """
+        fallback_address = "::" if socket.has_ipv6 else "0.0.0.0"
+        if hasattr(socket, "AI_PASSIVE"):
+            try:
+                addrinfos = socket.getaddrinfo(
+                    None,
+                    port,
+                    socket.AF_UNSPEC,
+                    socket.SOCK_STREAM,
+                    socket.IPPROTO_TCP,
+                    socket.AI_PASSIVE,
+                )
+            except socket.gaierror as e:
+                logger.warning(
+                    "Failed to auto-detect wildcard address, assuming %s: %s",
+                    fallback_address,
+                    str(e),
+                )
+                return fallback_address
+            addrs_by_family = defaultdict(list)
+            for family, _, _, _, sockaddr in addrinfos:
+                # Format of the "sockaddr" socket address varies by address family,
+                # but [0] is always the IP address portion.
+                addrs_by_family[family].append(sockaddr[0])
+            if hasattr(socket, "AF_INET6") and addrs_by_family[socket.AF_INET6]:
+                return addrs_by_family[socket.AF_INET6][0]
+            if hasattr(socket, "AF_INET") and addrs_by_family[socket.AF_INET]:
+                return addrs_by_family[socket.AF_INET][0]
+        logger.warning(
+            "Failed to auto-detect wildcard address, assuming %s",
+            fallback_address,
+        )
+        return fallback_address
+
+    def server_bind(self):
+        """Override to set custom options on the socket."""
+        if self._flags.reuse_port:
+            try:
+                socket.SO_REUSEPORT
+            except AttributeError:
+                raise TensorBoardServerException(
+                    "TensorBoard --reuse_port option is not supported on this platform"
+                )
+            self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)
+
+        # Enable IPV4 mapping for IPV6 sockets when desired.
+        # The main use case for this is so that when no host is specified,
+        # TensorBoard can listen on all interfaces for both IPv4 and IPv6
+        # connections, rather than having to choose v4 or v6 and hope the
+        # browser didn't choose the other one.
+        socket_is_v6 = (
+            hasattr(socket, "AF_INET6")
+            and self.socket.family == socket.AF_INET6
+        )
+        has_v6only_option = hasattr(socket, "IPPROTO_IPV6") and hasattr(
+            socket, "IPV6_V6ONLY"
+        )
+        if self._auto_wildcard and socket_is_v6 and has_v6only_option:
+            try:
+                self.socket.setsockopt(
+                    socket.IPPROTO_IPV6, socket.IPV6_V6ONLY, 0
+                )
+            except socket.error as e:
+                # Log a warning on failure to dual-bind, except for EAFNOSUPPORT
+                # since that's expected if IPv4 isn't supported at all (IPv6-only).
+                if (
+                    hasattr(errno, "EAFNOSUPPORT")
+                    and e.errno != errno.EAFNOSUPPORT
+                ):
+                    logger.warning(
+                        "Failed to dual-bind to IPv4 wildcard: %s", str(e)
+                    )
+        super(WerkzeugServer, self).server_bind()
+
+    def handle_error(self, request, client_address):
+        """Override to get rid of noisy EPIPE errors."""
+        del request  # unused
+        # Kludge to override a SocketServer.py method so we can get rid of noisy
+        # EPIPE errors. They're kind of a red herring as far as errors go. For
+        # example, `curl -N http://localhost:6006/ | head` will cause an EPIPE.
+        exc_info = sys.exc_info()
+        e = exc_info[1]
+        if isinstance(e, IOError) and e.errno == errno.EPIPE:
+            logger.warning(
+                "EPIPE caused by %s in HTTP serving" % str(client_address)
+            )
+        else:
+            logger.error("HTTP serving error", exc_info=exc_info)
+
+    def get_url(self):
+        if not self._url:
+            if self._auto_wildcard:
+                display_host = socket.getfqdn()
+                # Confirm that the connection is open, otherwise change to `localhost`
+                try:
+                    socket.create_connection(
+                        (display_host, self.server_port), timeout=1
+                    )
+                except socket.error as e:
+                    display_host = "localhost"
+
+            else:
+                host = self._host
+                display_host = (
+                    "[%s]" % host
+                    if ":" in host and not host.startswith("[")
+                    else host
+                )
+            self._url = "http://%s:%d%s/" % (
+                display_host,
+                self.server_port,
+                self._flags.path_prefix.rstrip("/"),
+            )
+        return self._url
+
+    def print_serving_message(self):
+        if self._flags.host is None and not self._flags.bind_all:
+            sys.stderr.write(
+                "Serving TensorBoard on localhost; to expose to the network, "
+                "use a proxy or pass --bind_all\n"
+            )
+            sys.stderr.flush()
+        super(WerkzeugServer, self).print_serving_message()
+
+    def _fix_werkzeug_logging(self):
+        """Fix werkzeug logging setup so it inherits TensorBoard's log level.
+
+        This addresses a change in werkzeug 0.15.0+ [1] that causes it set its own
+        log level to INFO regardless of the root logger configuration. We instead
+        want werkzeug to inherit TensorBoard's root logger log level (set via absl
+        to WARNING by default).
+
+        [1]: https://github.com/pallets/werkzeug/commit/4cf77d25858ff46ac7e9d64ade054bf05b41ce12
+        """
+        # Log once at DEBUG to force werkzeug to initialize its singleton logger,
+        # which sets the logger level to INFO it if is unset, and then access that
+        # object via logging.getLogger('werkzeug') to durably revert the level to
+        # unset (and thus make messages logged to it inherit the root logger level).
+        self.log(
+            "debug", "Fixing werkzeug logger to inherit TensorBoard log level"
+        )
+        logging.getLogger("werkzeug").setLevel(logging.NOTSET)
+
+
+create_port_scanning_werkzeug_server = with_port_scanning(WerkzeugServer)

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

@@ -0,0 +1,18 @@
+# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
+#
+# 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.
+# ==============================================================================
+
+"""Contains the version string."""
+
+VERSION = "2.11.2"

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/torch/__config__.py

@@ -0,0 +1,20 @@
+import torch
+
+
+def show():
+    """
+    Return a human-readable string with descriptions of the
+    configuration of PyTorch.
+    """
+    return torch._C._show_config()
+
+# TODO: In principle, we could provide more structured version/config
+# information here. For now only CXX_FLAGS is exposed, as Timer
+# uses them.
+def _cxx_flags():
+    """Returns the CXX_FLAGS used when building PyTorch."""
+    return torch._C._cxx_flags()
+
+def parallel_info():
+    r"""Returns detailed string with parallelization settings"""
+    return torch._C._parallel_info()

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/torch/__future__.py

@@ -0,0 +1,19 @@
+"""
+This global flag controls whether to assign new tensors to the parameters
+instead of changing the existing parameters in-place when converting an `nn.Module`
+using the following methods:
+1. `module.cuda()` / `.cpu()` (for moving `module` between devices)
+2. `module.float()` / `.double()` / `.half()` (for converting `module` to a different dtype)
+3. `module.to()` / `.type()` (for changing `module`'s device or dtype)
+4. `module._apply(fn)` (for generic functions applied to `module`)
+
+Default: False
+"""
+_overwrite_module_params_on_conversion = False
+
+def set_overwrite_module_params_on_conversion(value):
+    global _overwrite_module_params_on_conversion
+    _overwrite_module_params_on_conversion = value
+
+def get_overwrite_module_params_on_conversion():
+    return _overwrite_module_params_on_conversion

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

@@ -0,0 +1,960 @@
+
+r"""
+The torch package contains data structures for multi-dimensional
+tensors and defines mathematical operations over these tensors.
+Additionally, it provides many utilities for efficient serializing of
+Tensors and arbitrary types, and other useful utilities.
+
+It has a CUDA counterpart, that enables you to run your tensor computations
+on an NVIDIA GPU with compute capability >= 3.0.
+"""
+
+import os
+import sys
+import platform
+import textwrap
+import ctypes
+import warnings
+import inspect
+if sys.version_info < (3,):
+    raise Exception("Python 2 has reached end-of-life and is no longer supported by PyTorch.")
+
+from ._utils import _import_dotted_name, classproperty
+from ._utils_internal import get_file_path, prepare_multiprocessing_environment, \
+    USE_RTLD_GLOBAL_WITH_LIBTORCH, USE_GLOBAL_DEPS
+# TODO(torch_deploy) figure out how to freeze version.py in fbcode build
+if sys.executable == 'torch_deploy':
+    __version__ = "torch-deploy-1.8"
+else:
+    from .torch_version import __version__ as __version__
+
+from ._six import string_classes as _string_classes
+
+from typing import Set, Type, TYPE_CHECKING, Union, Callable
+import builtins
+
+__all__ = [
+    'typename', 'is_tensor', 'is_storage', 'set_default_tensor_type',
+    'set_rng_state', 'get_rng_state', 'manual_seed', 'initial_seed', 'seed',
+    'save', 'load', 'set_printoptions', 'chunk', 'split', 'stack', 'matmul',
+    'no_grad', 'enable_grad', 'rand', 'randn', 'inference_mode',
+    'DoubleStorage', 'FloatStorage', 'LongStorage', 'IntStorage',
+    'ShortStorage', 'CharStorage', 'ByteStorage', 'BoolStorage',
+    '_TypedStorage',
+    'DoubleTensor', 'FloatTensor', 'LongTensor', 'IntTensor',
+    'ShortTensor', 'CharTensor', 'ByteTensor', 'BoolTensor', 'Tensor',
+    'lobpcg', 'use_deterministic_algorithms',
+    'are_deterministic_algorithms_enabled',
+    'is_deterministic_algorithms_warn_only_enabled',
+    'set_deterministic_debug_mode', 'get_deterministic_debug_mode',
+    'set_float32_matmul_precision', 'get_float32_matmul_precision',
+    'set_warn_always', 'is_warn_always_enabled',
+]
+
+################################################################################
+# Load the extension module
+################################################################################
+
+if sys.platform == 'win32':
+    pfiles_path = os.getenv('ProgramFiles', 'C:\\Program Files')
+    py_dll_path = os.path.join(sys.exec_prefix, 'Library', 'bin')
+    th_dll_path = os.path.join(os.path.dirname(__file__), 'lib')
+
+    # When users create a virtualenv that inherits the base environment,
+    # we will need to add the corresponding library directory into
+    # DLL search directories. Otherwise, it will rely on `PATH` which
+    # is dependent on user settings.
+    if sys.exec_prefix != sys.base_exec_prefix:
+        base_py_dll_path = os.path.join(sys.base_exec_prefix, 'Library', 'bin')
+    else:
+        base_py_dll_path = ''
+
+    dll_paths = list(filter(os.path.exists, [th_dll_path, py_dll_path, base_py_dll_path]))
+
+    if all([not os.path.exists(os.path.join(p, 'nvToolsExt64_1.dll')) for p in dll_paths]):
+        nvtoolsext_dll_path = os.path.join(
+            os.getenv('NVTOOLSEXT_PATH', os.path.join(pfiles_path, 'NVIDIA Corporation', 'NvToolsExt')), 'bin', 'x64')
+    else:
+        nvtoolsext_dll_path = ''
+
+    from .version import cuda as cuda_version
+    import glob
+    if cuda_version and all([not glob.glob(os.path.join(p, 'cudart64*.dll')) for p in dll_paths]):
+        cuda_version_1 = cuda_version.replace('.', '_')
+        cuda_path_var = 'CUDA_PATH_V' + cuda_version_1
+        default_path = os.path.join(pfiles_path, 'NVIDIA GPU Computing Toolkit', 'CUDA', 'v' + cuda_version)
+        cuda_path = os.path.join(os.getenv(cuda_path_var, default_path), 'bin')
+    else:
+        cuda_path = ''
+
+    dll_paths.extend(filter(os.path.exists, [nvtoolsext_dll_path, cuda_path]))
+
+    kernel32 = ctypes.WinDLL('kernel32.dll', use_last_error=True)
+    with_load_library_flags = hasattr(kernel32, 'AddDllDirectory')
+    prev_error_mode = kernel32.SetErrorMode(0x0001)
+
+    kernel32.LoadLibraryW.restype = ctypes.c_void_p
+    if with_load_library_flags:
+        kernel32.AddDllDirectory.restype = ctypes.c_void_p
+        kernel32.LoadLibraryExW.restype = ctypes.c_void_p
+
+    for dll_path in dll_paths:
+        if sys.version_info >= (3, 8):
+            os.add_dll_directory(dll_path)
+        elif with_load_library_flags:
+            res = kernel32.AddDllDirectory(dll_path)
+            if res is None:
+                err = ctypes.WinError(ctypes.get_last_error())
+                err.strerror += f' Error adding "{dll_path}" to the DLL directories.'
+                raise err
+
+    try:
+        ctypes.CDLL('vcruntime140.dll')
+        ctypes.CDLL('msvcp140.dll')
+        ctypes.CDLL('vcruntime140_1.dll')
+    except OSError:
+        print('''Microsoft Visual C++ Redistributable is not installed, this may lead to the DLL load failure.
+                 It can be downloaded at https://aka.ms/vs/16/release/vc_redist.x64.exe''')
+
+    dlls = glob.glob(os.path.join(th_dll_path, '*.dll'))
+    path_patched = False
+    for dll in dlls:
+        is_loaded = False
+        if with_load_library_flags:
+            res = kernel32.LoadLibraryExW(dll, None, 0x00001100)
+            last_error = ctypes.get_last_error()
+            if res is None and last_error != 126:
+                err = ctypes.WinError(last_error)
+                err.strerror += f' Error loading "{dll}" or one of its dependencies.'
+                raise err
+            elif res is not None:
+                is_loaded = True
+        if not is_loaded:
+            if not path_patched:
+                os.environ['PATH'] = ';'.join(dll_paths + [os.environ['PATH']])
+                path_patched = True
+            res = kernel32.LoadLibraryW(dll)
+            if res is None:
+                err = ctypes.WinError(ctypes.get_last_error())
+                err.strerror += f' Error loading "{dll}" or one of its dependencies.'
+                raise err
+
+    kernel32.SetErrorMode(prev_error_mode)
+
+
+# See Note [Global dependencies]
+def _load_global_deps():
+    if platform.system() == 'Windows' or sys.executable == 'torch_deploy':
+        return
+
+    lib_name = 'libtorch_global_deps' + ('.dylib' if platform.system() == 'Darwin' else '.so')
+    here = os.path.abspath(__file__)
+    lib_path = os.path.join(os.path.dirname(here), 'lib', lib_name)
+
+    ctypes.CDLL(lib_path, mode=ctypes.RTLD_GLOBAL)
+
+
+if (USE_RTLD_GLOBAL_WITH_LIBTORCH or os.getenv('TORCH_USE_RTLD_GLOBAL')) and \
+        platform.system() != 'Windows':
+    # Do it the hard way.  You might want to load libtorch with RTLD_GLOBAL in a
+    # few circumstances:
+    #
+    #   1. You're in a build environment (e.g., fbcode) where
+    #      libtorch_global_deps is not available, but you still need
+    #      to get mkl to link in with RTLD_GLOBAL or it will just
+    #      not work.
+    #
+    #   2. You're trying to run PyTorch under UBSAN and you need
+    #      to ensure that only one copy of libtorch is loaded, so
+    #      vptr checks work properly
+    #
+    # If you're using this setting, you must verify that all the libraries
+    # you load consistently use the same libstdc++, or you may have
+    # mysterious segfaults.
+    #
+    import os as _dl_flags
+    if not hasattr(_dl_flags, 'RTLD_GLOBAL') or not hasattr(_dl_flags, 'RTLD_LAZY'):
+        try:
+            # next try if DLFCN exists
+            import DLFCN as _dl_flags  # type: ignore[import, no-redef]
+        except ImportError:
+            # as a last attempt, use compile-time constants
+            import torch._dl as _dl_flags  # type: ignore[import, no-redef]
+    old_flags = sys.getdlopenflags()
+    sys.setdlopenflags(_dl_flags.RTLD_GLOBAL | _dl_flags.RTLD_LAZY)
+    from torch._C import *  # noqa: F403
+    sys.setdlopenflags(old_flags)
+    del old_flags
+    del _dl_flags
+
+else:
+    # Easy way.  You want this most of the time, because it will prevent
+    # C++ symbols from libtorch clobbering C++ symbols from other
+    # libraries, leading to mysterious segfaults.
+    #
+    # If building in an environment where libtorch_global_deps isn't available
+    # like parts of fbsource, but where RTLD_GLOBAL causes segfaults, you will
+    # want USE_RTLD_GLOBAL_WITH_LIBTORCH = False and USE_GLOBAL_DEPS = False
+    #
+    # See Note [Global dependencies]
+    if USE_GLOBAL_DEPS:
+        _load_global_deps()
+    from torch._C import *  # noqa: F403
+
+# Appease the type checker; ordinarily this binding is inserted by the
+# torch._C module initialization code in C
+if TYPE_CHECKING:
+    import torch._C as _C
+
+# Check to see if we can load C extensions, and if not provide some guidance
+# on what the problem might be.
+try:
+    # _initExtension is chosen (arbitrarily) as a sentinel.
+    from torch._C import _initExtension
+except ImportError:
+    import torch._C as _C_for_compiled_check
+
+    # The __file__ check only works for Python 3.7 and above.
+    if sys.version_info >= (3, 7) and _C_for_compiled_check.__file__ is None:
+        raise ImportError(textwrap.dedent('''
+            Failed to load PyTorch C extensions:
+                It appears that PyTorch has loaded the `torch/_C` folder
+                of the PyTorch repository rather than the C extensions which
+                are expected in the `torch._C` namespace. This can occur when
+                using the `install` workflow. e.g.
+                    $ python setup.py install && python -c "import torch"
+
+                This error can generally be solved using the `develop` workflow
+                    $ python setup.py develop && python -c "import torch"  # This should succeed
+                or by running Python from a different directory.
+            ''').strip()) from None
+    raise  # If __file__ is not None the cause is unknown, so just re-raise.
+
+for name in dir(_C):
+    if name[0] != '_' and not name.endswith('Base'):
+        __all__.append(name)
+        obj = getattr(_C, name)
+        if (isinstance(obj, Callable) or inspect.isclass(obj)):  # type: ignore[arg-type]
+            if (obj.__module__ != 'torch'):
+                # TODO: fix their module from C++ side
+                if name not in ['DisableTorchFunction', 'Generator']:
+                    obj.__module__ = 'torch'
+
+if not TYPE_CHECKING:
+    # issue 38137 and python issue 43367. Submodules of a C extension are
+    # non-standard, and attributes of those submodules cannot be pickled since
+    # pickle expect to be able to import them as "from _C.sub import attr"
+    # which fails with "_C is not a package
+    for attr in dir(_C):
+        candidate = getattr(_C, attr)
+        if type(candidate) is type(_C):
+            # submodule
+            if f'torch._C.{attr}' not in sys.modules:
+                sys.modules[f'torch._C.{attr}'] = candidate
+
+
+################################################################################
+# Define basic utilities
+################################################################################
+
+
+def typename(o):
+    if isinstance(o, torch.Tensor):
+        return o.type()
+
+    module = ''
+    class_name = ''
+    if hasattr(o, '__module__') and o.__module__ != 'builtins' \
+            and o.__module__ != '__builtin__' and o.__module__ is not None:
+        module = o.__module__ + '.'
+
+    if hasattr(o, '__qualname__'):
+        class_name = o.__qualname__
+    elif hasattr(o, '__name__'):
+        class_name = o.__name__
+    else:
+        class_name = o.__class__.__name__
+
+    return module + class_name
+
+
+def is_tensor(obj):
+    r"""Returns True if `obj` is a PyTorch tensor.
+
+    Note that this function is simply doing ``isinstance(obj, Tensor)``.
+    Using that ``isinstance`` check is better for typechecking with mypy,
+    and more explicit - so it's recommended to use that instead of
+    ``is_tensor``.
+
+    Args:
+        obj (Object): Object to test
+    Example::
+
+        >>> x=torch.tensor([1,2,3])
+        >>> torch.is_tensor(x)
+        True
+
+    """
+    return isinstance(obj, torch.Tensor)
+
+
+def is_storage(obj):
+    r"""Returns True if `obj` is a PyTorch storage object.
+
+    Args:
+        obj (Object): Object to test
+    """
+    return type(obj) in _storage_classes
+
+
+def set_default_tensor_type(t):
+    r"""Sets the default ``torch.Tensor`` type to floating point tensor type
+    ``t``. This type will also be used as default floating point type for
+    type inference in :func:`torch.tensor`.
+
+    The default floating point tensor type is initially ``torch.FloatTensor``.
+
+    Args:
+        t (type or string): the floating point tensor type or its name
+
+    Example::
+
+        >>> torch.tensor([1.2, 3]).dtype    # initial default for floating point is torch.float32
+        torch.float32
+        >>> torch.set_default_tensor_type(torch.DoubleTensor)
+        >>> torch.tensor([1.2, 3]).dtype    # a new floating point tensor
+        torch.float64
+
+    """
+    if isinstance(t, _string_classes):
+        t = _import_dotted_name(t)
+    _C._set_default_tensor_type(t)
+
+
+def set_default_dtype(d):
+    r"""
+
+    Sets the default floating point dtype to :attr:`d`. Supports torch.float32
+    and torch.float64 as inputs. Other dtypes may be accepted without complaint
+    but are not supported and are unlikely to work as expected.
+
+    When PyTorch is initialized its default floating point dtype is torch.float32,
+    and the intent of set_default_dtype(torch.float64) is to facilitate NumPy-like
+    type inference. The default floating point dtype is used to:
+
+    1. Implicitly determine the default complex dtype. When the default floating point
+       type is float32 the default complex dtype is complex64, and when the default
+       floating point type is float64 the default complex type is complex128.
+    2. Infer the dtype for tensors constructed using Python floats or complex Python
+       numbers. See examples below.
+    3. Determine the result of type promotion between bool and integer tensors and
+       Python floats and complex Python numbers.
+
+    Args:
+        d (:class:`torch.dtype`): the floating point dtype to make the default.
+                                  Either torch.float32 or torch.float64.
+
+    Example:
+        >>> # initial default for floating point is torch.float32
+        >>> # Python floats are interpreted as float32
+        >>> torch.tensor([1.2, 3]).dtype
+        torch.float32
+        >>> # initial default for floating point is torch.complex64
+        >>> # Complex Python numbers are interpreted as complex64
+        >>> torch.tensor([1.2, 3j]).dtype
+        torch.complex64
+
+        >>> torch.set_default_dtype(torch.float64)
+
+        >>> # Python floats are now interpreted as float64
+        >>> torch.tensor([1.2, 3]).dtype    # a new floating point tensor
+        torch.float64
+        >>> # Complex Python numbers are now interpreted as complex128
+        >>> torch.tensor([1.2, 3j]).dtype   # a new complex tensor
+        torch.complex128
+
+    """
+    _C._set_default_dtype(d)
+
+def use_deterministic_algorithms(mode, *, warn_only=False):
+    r""" Sets whether PyTorch operations must use "deterministic"
+    algorithms. That is, algorithms which, given the same input, and when
+    run on the same software and hardware, always produce the same output.
+    When enabled, operations will use deterministic algorithms when available,
+    and if only nondeterministic algorithms are available they will throw a
+    :class:`RuntimeError` when called.
+
+    .. note:: :func:`torch.set_deterministic_debug_mode` offers an alternative
+        interface for this feature.
+
+    The following normally-nondeterministic operations will act
+    deterministically when ``mode=True``:
+
+        * :class:`torch.nn.Conv1d` when called on CUDA tensor
+        * :class:`torch.nn.Conv2d` when called on CUDA tensor
+        * :class:`torch.nn.Conv3d` when called on CUDA tensor
+        * :class:`torch.nn.ConvTranspose1d` when called on CUDA tensor
+        * :class:`torch.nn.ConvTranspose2d` when called on CUDA tensor
+        * :class:`torch.nn.ConvTranspose3d` when called on CUDA tensor
+        * :func:`torch.bmm` when called on sparse-dense CUDA tensors
+        * :func:`torch.Tensor.__getitem__` when attempting to differentiate a CPU tensor
+          and the index is a list of tensors
+        * :func:`torch.Tensor.index_put` with ``accumulate=False``
+        * :func:`torch.Tensor.index_put` with ``accumulate=True`` when called on a CPU
+          tensor
+        * :func:`torch.Tensor.put_` with ``accumulate=True`` when called on a CPU
+          tensor
+        * :func:`torch.Tensor.scatter_add_` when ``input`` dimension is one and called
+          on a CUDA tensor
+        * :func:`torch.gather` when ``input`` dimension is one and called
+          on a CUDA tensor that requires grad
+        * :func:`torch.index_add` when called on CUDA tensor
+        * :func:`torch.index_select` when attempting to differentiate a CUDA tensor
+        * :func:`torch.repeat_interleave` when attempting to differentiate a CUDA tensor
+        * :func:`torch.Tensor.index_copy` when called on a CPU or CUDA tensor
+
+    The following normally-nondeterministic operations will throw a
+    :class:`RuntimeError` when ``mode=True``:
+
+        * :class:`torch.nn.AvgPool3d` when attempting to differentiate a CUDA tensor
+        * :class:`torch.nn.AdaptiveAvgPool2d` when attempting to differentiate a CUDA tensor
+        * :class:`torch.nn.AdaptiveAvgPool3d` when attempting to differentiate a CUDA tensor
+        * :class:`torch.nn.MaxPool3d` when attempting to differentiate a CUDA tensor
+        * :class:`torch.nn.AdaptiveMaxPool2d` when attempting to differentiate a CUDA tensor
+        * :class:`torch.nn.FractionalMaxPool2d` when attempting to differentiate a CUDA tensor
+        * :class:`torch.nn.FractionalMaxPool3d` when attempting to differentiate a CUDA tensor
+        * :func:`torch.nn.functional.interpolate` when attempting to differentiate a CUDA tensor
+          and one of the following modes is used:
+
+          - ``linear``
+          - ``bilinear``
+          - ``bicubic``
+          - ``trilinear``
+
+        * :class:`torch.nn.ReflectionPad1d` when attempting to differentiate a CUDA tensor
+        * :class:`torch.nn.ReflectionPad2d` when attempting to differentiate a CUDA tensor
+        * :class:`torch.nn.ReflectionPad3d` when attempting to differentiate a CUDA tensor
+        * :class:`torch.nn.ReplicationPad1d` when attempting to differentiate a CUDA tensor
+        * :class:`torch.nn.ReplicationPad2d` when attempting to differentiate a CUDA tensor
+        * :class:`torch.nn.ReplicationPad3d` when attempting to differentiate a CUDA tensor
+        * :class:`torch.nn.NLLLoss` when called on a CUDA tensor
+        * :class:`torch.nn.CTCLoss` when attempting to differentiate a CUDA tensor
+        * :class:`torch.nn.EmbeddingBag` when attempting to differentiate a CUDA tensor when
+          ``mode='max'``
+        * :func:`torch.Tensor.scatter_add_` when ``input`` dimension is larger than one
+          and called on a CUDA tensor
+        * :func:`torch.gather` when ``input`` dimension is larger than one
+          and called on a CUDA tensor that requires grad
+        * :func:`torch.Tensor.put_` when ``accumulate=False``
+        * :func:`torch.Tensor.put_` when ``accumulate=True`` and called on a CUDA tensor
+        * :func:`torch.histc` when called on a CUDA tensor
+        * :func:`torch.bincount` when called on a CUDA tensor
+        * :func:`torch.kthvalue` with called on a CUDA tensor
+        * :func:`torch.median` with indices output when called on a CUDA tensor
+        * :func:`torch.nn.functional.grid_sample` when attempting to differentiate a CUDA tensor
+
+    A handful of CUDA operations are nondeterministic if the CUDA version is
+    10.2 or greater, unless the environment variable ``CUBLAS_WORKSPACE_CONFIG=:4096:8``
+    or ``CUBLAS_WORKSPACE_CONFIG=:16:8`` is set. See the CUDA documentation for more
+    details: `<https://docs.nvidia.com/cuda/cublas/index.html#cublasApi_reproducibility>`_
+    If one of these environment variable configurations is not set, a :class:`RuntimeError`
+    will be raised from these operations when called with CUDA tensors:
+
+        * :func:`torch.mm`
+        * :func:`torch.mv`
+        * :func:`torch.bmm`
+
+    Note that deterministic operations tend to have worse performance than
+    nondeterministic operations.
+
+    .. note::
+
+        This flag does not detect or prevent nondeterministic behavior caused
+        by calling an inplace operation on a tensor with an internal memory
+        overlap or by giving such a tensor as the :attr:`out` argument for an
+        operation. In these cases, multiple writes of different data may target
+        a single memory location, and the order of writes is not guaranteed.
+
+    Args:
+        mode (:class:`bool`): If True, makes potentially nondeterministic
+            operations switch to a deterministic algorithm or throw a runtime
+            error. If False, allows nondeterministic operations.
+
+    Keyword args:
+        warn_only (:class:`bool`, optional): If True, operations that do not
+            have a deterministic implementation will throw a warning instead of
+            an error. Default: ``False``
+
+    Example::
+
+        >>> torch.use_deterministic_algorithms(True)
+
+        # Forward mode nondeterministic error
+        >>> torch.randn(10).index_copy(0, torch.tensor([0]), torch.randn(1))
+        ...
+        RuntimeError: index_copy does not have a deterministic implementation...
+
+        # Backward mode nondeterministic error
+        >>> torch.randn(10, requires_grad=True, device='cuda').index_select(0, torch.tensor([0], device='cuda')).backward()
+        ...
+        RuntimeError: index_add_cuda_ does not have a deterministic implementation...
+    """
+    _C._set_deterministic_algorithms(mode, warn_only=warn_only)
+
+def are_deterministic_algorithms_enabled():
+    r"""Returns True if the global deterministic flag is turned on. Refer to
+    :func:`torch.use_deterministic_algorithms` documentation for more details.
+    """
+    return _C._get_deterministic_algorithms()
+
+def is_deterministic_algorithms_warn_only_enabled():
+    r"""Returns True if the global deterministic flag is set to warn only.
+    Refer to :func:`torch.use_deterministic_algorithms` documentation for more
+    details.
+    """
+    return _C._get_deterministic_algorithms_warn_only()
+
+def set_deterministic_debug_mode(debug_mode: Union[builtins.int, str]) -> None:
+    r"""Sets the debug mode for deterministic operations.
+
+    .. note:: This is an alternative interface for
+        :func:`torch.use_deterministic_algorithms`. Refer to that function's
+        documentation for details about affected operations.
+
+    Args:
+        debug_mode(str or int): If "default" or 0, don't error or warn on
+            nondeterministic operations. If "warn" or 1, warn on
+            nondeterministic operations. If "error" or 2, error on
+            nondeterministic operations.
+    """
+
+    # NOTE: builtins.int is used here because int in this scope resolves
+    # to torch.int
+    if not isinstance(debug_mode, (builtins.int, str)):
+        raise TypeError(f'debug_mode must be str or int, but got {type(debug_mode)}')
+
+    if isinstance(debug_mode, str):
+        if debug_mode == 'default':
+            debug_mode = 0
+        elif debug_mode == 'warn':
+            debug_mode = 1
+        elif debug_mode == 'error':
+            debug_mode = 2
+        else:
+            raise RuntimeError(
+                'invalid value of debug_mode, expected one of `default`, '
+                f'`warn`, `error`, but got {debug_mode}')
+
+    if debug_mode == 0:
+        _C._set_deterministic_algorithms(False)
+    elif debug_mode == 1:
+        _C._set_deterministic_algorithms(True, warn_only=True)
+    elif debug_mode == 2:
+        _C._set_deterministic_algorithms(True)
+    else:
+        raise RuntimeError(
+            'invalid value of debug_mode, expected 0, 1, or 2, '
+            f'but got {debug_mode}')
+
+def get_deterministic_debug_mode() -> builtins.int:
+    r"""Returns the current value of the debug mode for deterministic
+    operations. Refer to :func:`torch.set_deterministic_debug_mode`
+    documentation for more details.
+    """
+
+    if _C._get_deterministic_algorithms():
+        if _C._get_deterministic_algorithms_warn_only():
+            return 1
+        else:
+            return 2
+    else:
+        return 0
+
+def get_float32_matmul_precision() -> builtins.str:
+    r"""Returns the current value of float32 matrix multiplication precision. Refer to
+    :func:`torch.set_float32_matmul_precision` documentation for more details.
+    """
+    return _C._get_float32_matmul_precision()
+
+def set_float32_matmul_precision(precision):
+    r"""Sets the internal precision of float32 matrix multiplications.
+
+    Running float32 matrix multiplications in lower precision may significantly increase
+    performance, and in some programs the loss of precision has a negligible impact.
+
+    Supports three settings:
+
+        * "highest", float32 matrix multiplications use the float32 datatype for
+          internal computations.
+        * "high", float32 matrix multiplications use the TensorFloat32 or bfloat16_3x
+          datatypes for internal computations, if fast matrix multiplication algorithms
+          using those datatypes internally are available. Otherwise float32
+          matrix multiplications are computed as if the precision is "highest".
+        * "medium", float32 matrix multiplications use the bfloat16 datatype for
+          internal computations, if a fast matrix multiplication algorithm
+          using that datatype internally is available. Otherwise float32
+          matrix multiplications are computed as if the precision is "high".
+
+    .. note::
+
+        This does not change the output dtype of float32 matrix multiplications,
+        it controls how the internal computation of the matrix multiplication is performed.
+
+    .. note::
+
+        This does not change the precision of convolution operations. Other flags,
+        like `torch.backends.cudnn.allow_tf32`, may control the precision of convolution
+        operations.
+
+    .. note::
+
+        This flag currently only affects one native device type: CUDA.
+        If "high" or "medium" are set then the TensorFloat32 datatype will be used
+        when computing float32 matrix multiplications, equivalent to setting
+        `torch.backends.cuda.matmul.allow_tf32 = True`. When "highest" (the default)
+        is set then the float32 datatype is used for internal computations, equivalent
+        to setting `torch.backends.cuda.matmul.allow_tf32 = False`.
+
+    Args:
+        precision(str): can be set to "highest" (default), "high", or "medium" (see above).
+
+    """
+    _C._set_float32_matmul_precision(precision)
+
+def set_warn_always(b):
+    r"""When this flag is False (default) then some PyTorch warnings may only
+    appear once per process. This helps avoid excessive warning information.
+    Setting it to True causes these warnings to always appear, which may be
+    helpful when debugging.
+
+    Args:
+        b (:class:`bool`): If True, force warnings to always be emitted
+                           If False, set to the default behaviour
+    """
+    _C._set_warnAlways(b)
+
+def is_warn_always_enabled():
+    r"""Returns True if the global warn_always flag is turned on. Refer to
+    :func:`torch.set_warn_always` documentation for more details.
+    """
+    return _C._get_warnAlways()
+
+################################################################################
+# Define numeric constants
+################################################################################
+
+# For Python Array API (https://data-apis.org/array-api/latest/API_specification/constants.html) and
+# NumPy consistency (https://numpy.org/devdocs/reference/constants.html)
+from math import e , nan , inf , pi
+__all__.extend(['e', 'pi', 'nan', 'inf'])
+
+################################################################################
+# Define Storage and Tensor classes
+################################################################################
+
+from ._tensor import Tensor
+from .storage import _StorageBase, _TypedStorage, _LegacyStorage, _UntypedStorage
+
+# NOTE: New <type>Storage classes should never be added. When adding a new
+# dtype, use torch.storage._TypedStorage directly.
+
+class ByteStorage(_LegacyStorage):
+    @classproperty
+    def dtype(self):
+        return torch.uint8
+
+class DoubleStorage(_LegacyStorage):
+    @classproperty
+    def dtype(self):
+        return torch.double
+
+class FloatStorage(_LegacyStorage):
+    @classproperty
+    def dtype(self):
+        return torch.float
+
+class HalfStorage(_LegacyStorage):
+    @classproperty
+    def dtype(self):
+        return torch.half
+
+class LongStorage(_LegacyStorage):
+    @classproperty
+    def dtype(self):
+        return torch.long
+
+class IntStorage(_LegacyStorage):
+    @classproperty
+    def dtype(self):
+        return torch.int
+
+class ShortStorage(_LegacyStorage):
+    @classproperty
+    def dtype(self):
+        return torch.short
+
+class CharStorage(_LegacyStorage):
+    @classproperty
+    def dtype(self):
+        return torch.int8
+
+class BoolStorage(_LegacyStorage):
+    @classproperty
+    def dtype(self):
+        return torch.bool
+
+class BFloat16Storage(_LegacyStorage):
+    @classproperty
+    def dtype(self):
+        return torch.bfloat16
+
+class ComplexDoubleStorage(_LegacyStorage):
+    @classproperty
+    def dtype(self):
+        return torch.cdouble
+
+class ComplexFloatStorage(_LegacyStorage):
+    @classproperty
+    def dtype(self):
+        return torch.cfloat
+
+class QUInt8Storage(_LegacyStorage):
+    @classproperty
+    def dtype(self):
+        return torch.quint8
+
+class QInt8Storage(_LegacyStorage):
+    @classproperty
+    def dtype(self):
+        return torch.qint8
+
+class QInt32Storage(_LegacyStorage):
+    @classproperty
+    def dtype(self):
+        return torch.qint32
+
+class QUInt4x2Storage(_LegacyStorage):
+    @classproperty
+    def dtype(self):
+        return torch.quint4x2
+
+class QUInt2x4Storage(_LegacyStorage):
+    @classproperty
+    def dtype(self):
+        return torch.quint2x4
+
+_storage_classes = {
+    _UntypedStorage, DoubleStorage, FloatStorage, LongStorage, IntStorage,
+    ShortStorage, CharStorage, ByteStorage, HalfStorage, BoolStorage,
+    QUInt8Storage, QInt8Storage, QInt32Storage, BFloat16Storage,
+    ComplexFloatStorage, ComplexDoubleStorage, QUInt4x2Storage, QUInt2x4Storage,
+    _TypedStorage
+}
+
+# The _tensor_classes set is initialized by the call to _C._initialize_tensor_type_bindings()
+_tensor_classes: Set[Type] = set()
+
+# If you edit these imports, please update torch/__init__.py.in as well
+from .random import set_rng_state, get_rng_state, manual_seed, initial_seed, seed
+from .serialization import save, load
+from ._tensor_str import set_printoptions
+
+################################################################################
+# Initialize extension
+################################################################################
+
+def manager_path():
+    if platform.system() == 'Windows' or sys.executable == 'torch_deploy':
+        return b""
+    path = get_file_path('torch', 'bin', 'torch_shm_manager')
+    prepare_multiprocessing_environment(get_file_path('torch'))
+    if not os.path.exists(path):
+        raise RuntimeError("Unable to find torch_shm_manager at " + path)
+    return path.encode('utf-8')
+
+from torch.amp import autocast
+
+# Shared memory manager needs to know the exact location of manager executable
+_C._initExtension(manager_path())
+del manager_path
+
+# Appease the type checker: it can't deal with direct setting of globals().
+# Note that we will see "too many" functions when reexporting this way; there
+# is not a good way to fix this problem.  Perhaps, try to redesign VariableFunctions
+# so that this import is good enough
+if TYPE_CHECKING:
+    # Some type signatures pulled in from _VariableFunctions here clash with
+    # signatures already imported. For now these clashes are ignored; see
+    # PR #43339 for details.
+    from torch._C._VariableFunctions import *  # type: ignore[misc] # noqa: F403
+
+# Ops not to be exposed in `torch` namespace,
+# mostly helper ops.
+PRIVATE_OPS = (
+    'unique_dim',
+)
+
+for name in dir(_C._VariableFunctions):
+    if name.startswith('__') or name in PRIVATE_OPS:
+        continue
+    obj = getattr(_C._VariableFunctions, name)
+    obj.__module__ = 'torch'
+    globals()[name] = obj
+    if not name.startswith("_"):
+        __all__.append(name)
+
+################################################################################
+# Import interface functions defined in Python
+################################################################################
+
+# needs to be after the above ATen bindings so we can overwrite from Python side
+from .functional import *  # noqa: F403
+
+
+################################################################################
+# Remove unnecessary members
+################################################################################
+
+del _StorageBase
+del _LegacyStorage
+
+################################################################################
+# Define _assert
+################################################################################
+
+# needs to be before the submodule imports to avoid circular dependencies
+def _assert(condition, message):
+    r"""A wrapper around Python's assert which is symbolically traceable.
+    """
+    from .overrides import has_torch_function, handle_torch_function
+
+    if type(condition) is not torch.Tensor and has_torch_function((condition,)):
+        return handle_torch_function(_assert, (condition,), condition, message)
+    assert condition, message
+
+################################################################################
+# Import most common subpackages
+################################################################################
+
+# Use the redundant form so that type checkers know that these are a part of
+# the public API. The "regular" import lines are there solely for the runtime
+# side effect of adding to the imported module's members for other users.
+from torch import cuda as cuda
+from torch import cpu as cpu
+from torch import autograd as autograd
+from torch.autograd import (
+    no_grad as no_grad,
+    enable_grad as enable_grad,
+    set_grad_enabled as set_grad_enabled,
+    inference_mode as inference_mode,
+)
+from torch import fft as fft
+from torch import futures as futures
+from torch import nn as nn
+from torch import optim as optim
+import torch.optim._multi_tensor
+from torch import multiprocessing as multiprocessing
+from torch import sparse as sparse
+from torch import special as special
+import torch.utils.backcompat
+from torch import onnx as onnx
+from torch import jit as jit
+from torch import linalg as linalg
+from torch import hub as hub
+from torch import random as random
+from torch import distributions as distributions
+from torch import testing as testing
+import torch.backends.cuda
+import torch.backends.mps
+import torch.backends.cudnn
+import torch.backends.mkl
+import torch.backends.mkldnn
+import torch.backends.openmp
+import torch.backends.quantized
+import torch.utils.data
+from torch import __config__ as __config__
+from torch import __future__ as __future__
+from torch import profiler as profiler
+
+# Quantized, sparse, AO, etc. should be last to get imported, as nothing
+# is expected to depend on them.
+import torch.nn.intrinsic
+import torch.nn.quantizable
+import torch.nn.quantized
+# AO depends on nn, as well as quantized stuff -- so should be after those.
+from torch import ao as ao
+
+_C._init_names(list(torch._storage_classes))
+
+# attach docstrings to torch and tensor functions
+from . import _torch_docs, _tensor_docs, _storage_docs
+del _torch_docs, _tensor_docs, _storage_docs
+
+
+def compiled_with_cxx11_abi():
+    r"""Returns whether PyTorch was built with _GLIBCXX_USE_CXX11_ABI=1"""
+    return _C._GLIBCXX_USE_CXX11_ABI
+
+
+# Import the ops "namespace"
+from torch._ops import ops
+from torch._classes import classes
+
+# quantization depends on torch.fx
+# Import quantization
+from torch import quantization as quantization
+
+# Import the quasi random sampler
+from torch import quasirandom as quasirandom
+
+# If you are seeing this, it means that this call site was not checked if
+# the memory format could be preserved, and it was switched to old default
+# behaviour of contiguous
+legacy_contiguous_format = contiguous_format
+
+# Register fork handler to initialize OpenMP in child processes (see gh-28389)
+from torch.multiprocessing._atfork import register_after_fork
+register_after_fork(torch.get_num_threads)
+del register_after_fork
+
+# Import tools that require fully imported torch (for applying
+# torch.jit.script as a decorator, for instance):
+from ._lobpcg import lobpcg as lobpcg
+
+# These were previously defined in native_functions.yaml and appeared on the
+# `torch` namespace, but we moved them to c10 dispatch to facilitate custom
+# class usage. We add these lines here to preserve backward compatibility.
+quantized_lstm = torch.ops.aten.quantized_lstm
+quantized_gru = torch.ops.aten.quantized_gru
+
+from torch.utils.dlpack import from_dlpack, to_dlpack
+
+# Import experimental masked operations support. See
+# [RFC-0016](https://github.com/pytorch/rfcs/pull/27) for more
+# information.
+from . import _masked
+
+# Import removed ops with error message about removal
+from ._linalg_utils import solve
+
+
+def _register_device_module(device_type, module):
+    r"""Register an external runtime module of the specific :attr:`device_type`
+    supported by torch.
+
+    After the :attr:`module` is registered correctly, the user can refer
+    the external runtime module as part of torch with attribute torch.xxx.
+    """
+    # Make sure the device_type represent a supported device type for torch.
+    device_type = torch.device(device_type).type
+    m = sys.modules[__name__]
+    if hasattr(m, device_type):
+        raise RuntimeError("The runtime module of '{}' has already "
+                           "been registered with '{}'".format(device_type, getattr(m, device_type)))
+    setattr(m, device_type, module)
+
+# expose return_types
+from . import return_types
+if sys.executable != 'torch_deploy':
+    from . import library
+    from . import _meta_registrations

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/torch/_appdirs.py

@@ -0,0 +1,643 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Copyright (c) 2005-2010 ActiveState Software Inc.
+# Copyright (c) 2013 Eddy Petrișor
+
+# flake8: noqa
+
+"""
+This file is directly from
+https://github.com/ActiveState/appdirs/blob/3fe6a83776843a46f20c2e5587afcffe05e03b39/appdirs.py
+
+The license of https://github.com/ActiveState/appdirs copied below:
+
+
+# This is the MIT license
+
+Copyright (c) 2010 ActiveState Software 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.
+"""
+
+"""Utilities for determining application-specific dirs.
+
+See <https://github.com/ActiveState/appdirs> for details and usage.
+"""
+# Dev Notes:
+# - MSDN on where to store app data files:
+#   http://support.microsoft.com/default.aspx?scid=kb;en-us;310294#XSLTH3194121123120121120120
+# - Mac OS X: http://developer.apple.com/documentation/MacOSX/Conceptual/BPFileSystem/index.html
+# - XDG spec for Un*x: https://standards.freedesktop.org/basedir-spec/basedir-spec-latest.html
+
+__version__ = "1.4.4"
+__version_info__ = tuple(int(segment) for segment in __version__.split("."))
+
+
+import sys
+import os
+
+unicode = str
+
+if sys.platform.startswith('java'):
+    import platform
+    os_name = platform.java_ver()[3][0]
+    if os_name.startswith('Windows'): # "Windows XP", "Windows 7", etc.
+        system = 'win32'
+    elif os_name.startswith('Mac'): # "Mac OS X", etc.
+        system = 'darwin'
+    else: # "Linux", "SunOS", "FreeBSD", etc.
+        # Setting this to "linux2" is not ideal, but only Windows or Mac
+        # are actually checked for and the rest of the module expects
+        # *sys.platform* style strings.
+        system = 'linux2'
+else:
+    system = sys.platform
+
+
+
+def user_data_dir(appname=None, appauthor=None, version=None, roaming=False):
+    r"""Return full path to the user-specific data dir for this application.
+
+        "appname" is the name of application.
+            If None, just the system directory is returned.
+        "appauthor" (only used on Windows) is the name of the
+            appauthor or distributing body for this application. Typically
+            it is the owning company name. This falls back to appname. You may
+            pass False to disable it.
+        "version" is an optional version path element to append to the
+            path. You might want to use this if you want multiple versions
+            of your app to be able to run independently. If used, this
+            would typically be "<major>.<minor>".
+            Only applied when appname is present.
+        "roaming" (boolean, default False) can be set True to use the Windows
+            roaming appdata directory. That means that for users on a Windows
+            network setup for roaming profiles, this user data will be
+            sync'd on login. See
+            <http://technet.microsoft.com/en-us/library/cc766489(WS.10).aspx>
+            for a discussion of issues.
+
+    Typical user data directories are:
+        Mac OS X:               ~/Library/Application Support/<AppName>
+        Unix:                   ~/.local/share/<AppName>    # or in $XDG_DATA_HOME, if defined
+        Win XP (not roaming):   C:\Documents and Settings\<username>\Application Data\<AppAuthor>\<AppName>
+        Win XP (roaming):       C:\Documents and Settings\<username>\Local Settings\Application Data\<AppAuthor>\<AppName>
+        Win 7  (not roaming):   C:\Users\<username>\AppData\Local\<AppAuthor>\<AppName>
+        Win 7  (roaming):       C:\Users\<username>\AppData\Roaming\<AppAuthor>\<AppName>
+
+    For Unix, we follow the XDG spec and support $XDG_DATA_HOME.
+    That means, by default "~/.local/share/<AppName>".
+    """
+    if system == "win32":
+        if appauthor is None:
+            appauthor = appname
+        const = roaming and "CSIDL_APPDATA" or "CSIDL_LOCAL_APPDATA"
+        path = os.path.normpath(_get_win_folder(const))
+        if appname:
+            if appauthor is not False:
+                path = os.path.join(path, appauthor, appname)
+            else:
+                path = os.path.join(path, appname)
+    elif system == 'darwin':
+        path = os.path.expanduser('~/Library/Application Support/')
+        if appname:
+            path = os.path.join(path, appname)
+    else:
+        path = os.getenv('XDG_DATA_HOME', os.path.expanduser("~/.local/share"))
+        if appname:
+            path = os.path.join(path, appname)
+    if appname and version:
+        path = os.path.join(path, version)
+    return path
+
+
+def site_data_dir(appname=None, appauthor=None, version=None, multipath=False):
+    r"""Return full path to the user-shared data dir for this application.
+
+        "appname" is the name of application.
+            If None, just the system directory is returned.
+        "appauthor" (only used on Windows) is the name of the
+            appauthor or distributing body for this application. Typically
+            it is the owning company name. This falls back to appname. You may
+            pass False to disable it.
+        "version" is an optional version path element to append to the
+            path. You might want to use this if you want multiple versions
+            of your app to be able to run independently. If used, this
+            would typically be "<major>.<minor>".
+            Only applied when appname is present.
+        "multipath" is an optional parameter only applicable to *nix
+            which indicates that the entire list of data dirs should be
+            returned. By default, the first item from XDG_DATA_DIRS is
+            returned, or '/usr/local/share/<AppName>',
+            if XDG_DATA_DIRS is not set
+
+    Typical site data directories are:
+        Mac OS X:   /Library/Application Support/<AppName>
+        Unix:       /usr/local/share/<AppName> or /usr/share/<AppName>
+        Win XP:     C:\Documents and Settings\All Users\Application Data\<AppAuthor>\<AppName>
+        Vista:      (Fail! "C:\ProgramData" is a hidden *system* directory on Vista.)
+        Win 7:      C:\ProgramData\<AppAuthor>\<AppName>   # Hidden, but writeable on Win 7.
+
+    For Unix, this is using the $XDG_DATA_DIRS[0] default.
+
+    WARNING: Do not use this on Windows. See the Vista-Fail note above for why.
+    """
+    if system == "win32":
+        if appauthor is None:
+            appauthor = appname
+        path = os.path.normpath(_get_win_folder("CSIDL_COMMON_APPDATA"))
+        if appname:
+            if appauthor is not False:
+                path = os.path.join(path, appauthor, appname)
+            else:
+                path = os.path.join(path, appname)
+    elif system == 'darwin':
+        path = os.path.expanduser('/Library/Application Support')
+        if appname:
+            path = os.path.join(path, appname)
+    else:
+        # XDG default for $XDG_DATA_DIRS
+        # only first, if multipath is False
+        path = os.getenv('XDG_DATA_DIRS',
+                         os.pathsep.join(['/usr/local/share', '/usr/share']))
+        pathlist = [os.path.expanduser(x.rstrip(os.sep)) for x in path.split(os.pathsep)]
+        if appname:
+            if version:
+                appname = os.path.join(appname, version)
+            pathlist = [os.sep.join([x, appname]) for x in pathlist]
+
+        if multipath:
+            path = os.pathsep.join(pathlist)
+        else:
+            path = pathlist[0]
+        return path
+
+    if appname and version:
+        path = os.path.join(path, version)
+    return path
+
+
+def user_config_dir(appname=None, appauthor=None, version=None, roaming=False):
+    r"""Return full path to the user-specific config dir for this application.
+
+        "appname" is the name of application.
+            If None, just the system directory is returned.
+        "appauthor" (only used on Windows) is the name of the
+            appauthor or distributing body for this application. Typically
+            it is the owning company name. This falls back to appname. You may
+            pass False to disable it.
+        "version" is an optional version path element to append to the
+            path. You might want to use this if you want multiple versions
+            of your app to be able to run independently. If used, this
+            would typically be "<major>.<minor>".
+            Only applied when appname is present.
+        "roaming" (boolean, default False) can be set True to use the Windows
+            roaming appdata directory. That means that for users on a Windows
+            network setup for roaming profiles, this user data will be
+            sync'd on login. See
+            <http://technet.microsoft.com/en-us/library/cc766489(WS.10).aspx>
+            for a discussion of issues.
+
+    Typical user config directories are:
+        Mac OS X:               ~/Library/Preferences/<AppName>
+        Unix:                   ~/.config/<AppName>     # or in $XDG_CONFIG_HOME, if defined
+        Win *:                  same as user_data_dir
+
+    For Unix, we follow the XDG spec and support $XDG_CONFIG_HOME.
+    That means, by default "~/.config/<AppName>".
+    """
+    if system == "win32":
+        path = user_data_dir(appname, appauthor, None, roaming)
+    elif system == 'darwin':
+        path = os.path.expanduser('~/Library/Preferences/')
+        if appname:
+            path = os.path.join(path, appname)
+    else:
+        path = os.getenv('XDG_CONFIG_HOME', os.path.expanduser("~/.config"))
+        if appname:
+            path = os.path.join(path, appname)
+    if appname and version:
+        path = os.path.join(path, version)
+    return path
+
+
+def site_config_dir(appname=None, appauthor=None, version=None, multipath=False):
+    r"""Return full path to the user-shared data dir for this application.
+
+        "appname" is the name of application.
+            If None, just the system directory is returned.
+        "appauthor" (only used on Windows) is the name of the
+            appauthor or distributing body for this application. Typically
+            it is the owning company name. This falls back to appname. You may
+            pass False to disable it.
+        "version" is an optional version path element to append to the
+            path. You might want to use this if you want multiple versions
+            of your app to be able to run independently. If used, this
+            would typically be "<major>.<minor>".
+            Only applied when appname is present.
+        "multipath" is an optional parameter only applicable to *nix
+            which indicates that the entire list of config dirs should be
+            returned. By default, the first item from XDG_CONFIG_DIRS is
+            returned, or '/etc/xdg/<AppName>', if XDG_CONFIG_DIRS is not set
+
+    Typical site config directories are:
+        Mac OS X:   same as site_data_dir
+        Unix:       /etc/xdg/<AppName> or $XDG_CONFIG_DIRS[i]/<AppName> for each value in
+                    $XDG_CONFIG_DIRS
+        Win *:      same as site_data_dir
+        Vista:      (Fail! "C:\ProgramData" is a hidden *system* directory on Vista.)
+
+    For Unix, this is using the $XDG_CONFIG_DIRS[0] default, if multipath=False
+
+    WARNING: Do not use this on Windows. See the Vista-Fail note above for why.
+    """
+    if system == 'win32':
+        path = site_data_dir(appname, appauthor)
+        if appname and version:
+            path = os.path.join(path, version)
+    elif system == 'darwin':
+        path = os.path.expanduser('/Library/Preferences')
+        if appname:
+            path = os.path.join(path, appname)
+    else:
+        # XDG default for $XDG_CONFIG_DIRS
+        # only first, if multipath is False
+        path = os.getenv('XDG_CONFIG_DIRS', '/etc/xdg')
+        pathlist = [os.path.expanduser(x.rstrip(os.sep)) for x in path.split(os.pathsep)]
+        if appname:
+            if version:
+                appname = os.path.join(appname, version)
+            pathlist = [os.sep.join([x, appname]) for x in pathlist]
+
+        if multipath:
+            path = os.pathsep.join(pathlist)
+        else:
+            path = pathlist[0]
+    return path
+
+
+def user_cache_dir(appname=None, appauthor=None, version=None, opinion=True):
+    r"""Return full path to the user-specific cache dir for this application.
+
+        "appname" is the name of application.
+            If None, just the system directory is returned.
+        "appauthor" (only used on Windows) is the name of the
+            appauthor or distributing body for this application. Typically
+            it is the owning company name. This falls back to appname. You may
+            pass False to disable it.
+        "version" is an optional version path element to append to the
+            path. You might want to use this if you want multiple versions
+            of your app to be able to run independently. If used, this
+            would typically be "<major>.<minor>".
+            Only applied when appname is present.
+        "opinion" (boolean) can be False to disable the appending of
+            "Cache" to the base app data dir for Windows. See
+            discussion below.
+
+    Typical user cache directories are:
+        Mac OS X:   ~/Library/Caches/<AppName>
+        Unix:       ~/.cache/<AppName> (XDG default)
+        Win XP:     C:\Documents and Settings\<username>\Local Settings\Application Data\<AppAuthor>\<AppName>\Cache
+        Vista:      C:\Users\<username>\AppData\Local\<AppAuthor>\<AppName>\Cache
+
+    On Windows the only suggestion in the MSDN docs is that local settings go in
+    the `CSIDL_LOCAL_APPDATA` directory. This is identical to the non-roaming
+    app data dir (the default returned by `user_data_dir` above). Apps typically
+    put cache data somewhere *under* the given dir here. Some examples:
+        ...\Mozilla\Firefox\Profiles\<ProfileName>\Cache
+        ...\Acme\SuperApp\Cache\1.0
+    OPINION: This function appends "Cache" to the `CSIDL_LOCAL_APPDATA` value.
+    This can be disabled with the `opinion=False` option.
+    """
+    if system == "win32":
+        if appauthor is None:
+            appauthor = appname
+        path = os.path.normpath(_get_win_folder("CSIDL_LOCAL_APPDATA"))
+        if appname:
+            if appauthor is not False:
+                path = os.path.join(path, appauthor, appname)
+            else:
+                path = os.path.join(path, appname)
+            if opinion:
+                path = os.path.join(path, "Cache")
+    elif system == 'darwin':
+        path = os.path.expanduser('~/Library/Caches')
+        if appname:
+            path = os.path.join(path, appname)
+    else:
+        path = os.getenv('XDG_CACHE_HOME', os.path.expanduser('~/.cache'))
+        if appname:
+            path = os.path.join(path, appname)
+    if appname and version:
+        path = os.path.join(path, version)
+    return path
+
+
+def user_state_dir(appname=None, appauthor=None, version=None, roaming=False):
+    r"""Return full path to the user-specific state dir for this application.
+
+        "appname" is the name of application.
+            If None, just the system directory is returned.
+        "appauthor" (only used on Windows) is the name of the
+            appauthor or distributing body for this application. Typically
+            it is the owning company name. This falls back to appname. You may
+            pass False to disable it.
+        "version" is an optional version path element to append to the
+            path. You might want to use this if you want multiple versions
+            of your app to be able to run independently. If used, this
+            would typically be "<major>.<minor>".
+            Only applied when appname is present.
+        "roaming" (boolean, default False) can be set True to use the Windows
+            roaming appdata directory. That means that for users on a Windows
+            network setup for roaming profiles, this user data will be
+            sync'd on login. See
+            <http://technet.microsoft.com/en-us/library/cc766489(WS.10).aspx>
+            for a discussion of issues.
+
+    Typical user state directories are:
+        Mac OS X:  same as user_data_dir
+        Unix:      ~/.local/state/<AppName>   # or in $XDG_STATE_HOME, if defined
+        Win *:     same as user_data_dir
+
+    For Unix, we follow this Debian proposal <https://wiki.debian.org/XDGBaseDirectorySpecification#state>
+    to extend the XDG spec and support $XDG_STATE_HOME.
+
+    That means, by default "~/.local/state/<AppName>".
+    """
+    if system in ["win32", "darwin"]:
+        path = user_data_dir(appname, appauthor, None, roaming)
+    else:
+        path = os.getenv('XDG_STATE_HOME', os.path.expanduser("~/.local/state"))
+        if appname:
+            path = os.path.join(path, appname)
+    if appname and version:
+        path = os.path.join(path, version)
+    return path
+
+
+def user_log_dir(appname=None, appauthor=None, version=None, opinion=True):
+    r"""Return full path to the user-specific log dir for this application.
+
+        "appname" is the name of application.
+            If None, just the system directory is returned.
+        "appauthor" (only used on Windows) is the name of the
+            appauthor or distributing body for this application. Typically
+            it is the owning company name. This falls back to appname. You may
+            pass False to disable it.
+        "version" is an optional version path element to append to the
+            path. You might want to use this if you want multiple versions
+            of your app to be able to run independently. If used, this
+            would typically be "<major>.<minor>".
+            Only applied when appname is present.
+        "opinion" (boolean) can be False to disable the appending of
+            "Logs" to the base app data dir for Windows, and "log" to the
+            base cache dir for Unix. See discussion below.
+
+    Typical user log directories are:
+        Mac OS X:   ~/Library/Logs/<AppName>
+        Unix:       ~/.cache/<AppName>/log  # or under $XDG_CACHE_HOME if defined
+        Win XP:     C:\Documents and Settings\<username>\Local Settings\Application Data\<AppAuthor>\<AppName>\Logs
+        Vista:      C:\Users\<username>\AppData\Local\<AppAuthor>\<AppName>\Logs
+
+    On Windows the only suggestion in the MSDN docs is that local settings
+    go in the `CSIDL_LOCAL_APPDATA` directory. (Note: I'm interested in
+    examples of what some windows apps use for a logs dir.)
+
+    OPINION: This function appends "Logs" to the `CSIDL_LOCAL_APPDATA`
+    value for Windows and appends "log" to the user cache dir for Unix.
+    This can be disabled with the `opinion=False` option.
+    """
+    if system == "darwin":
+        path = os.path.join(
+            os.path.expanduser('~/Library/Logs'),
+            appname)
+    elif system == "win32":
+        path = user_data_dir(appname, appauthor, version)
+        version = False
+        if opinion:
+            path = os.path.join(path, "Logs")
+    else:
+        path = user_cache_dir(appname, appauthor, version)
+        version = False
+        if opinion:
+            path = os.path.join(path, "log")
+    if appname and version:
+        path = os.path.join(path, version)
+    return path
+
+
+class AppDirs(object):
+    """Convenience wrapper for getting application dirs."""
+    def __init__(self, appname=None, appauthor=None, version=None,
+            roaming=False, multipath=False):
+        self.appname = appname
+        self.appauthor = appauthor
+        self.version = version
+        self.roaming = roaming
+        self.multipath = multipath
+
+    @property
+    def user_data_dir(self):
+        return user_data_dir(self.appname, self.appauthor,
+                             version=self.version, roaming=self.roaming)
+
+    @property
+    def site_data_dir(self):
+        return site_data_dir(self.appname, self.appauthor,
+                             version=self.version, multipath=self.multipath)
+
+    @property
+    def user_config_dir(self):
+        return user_config_dir(self.appname, self.appauthor,
+                               version=self.version, roaming=self.roaming)
+
+    @property
+    def site_config_dir(self):
+        return site_config_dir(self.appname, self.appauthor,
+                             version=self.version, multipath=self.multipath)
+
+    @property
+    def user_cache_dir(self):
+        return user_cache_dir(self.appname, self.appauthor,
+                              version=self.version)
+
+    @property
+    def user_state_dir(self):
+        return user_state_dir(self.appname, self.appauthor,
+                              version=self.version)
+
+    @property
+    def user_log_dir(self):
+        return user_log_dir(self.appname, self.appauthor,
+                            version=self.version)
+
+
+#---- internal support stuff
+
+def _get_win_folder_from_registry(csidl_name):
+    """This is a fallback technique at best. I'm not sure if using the
+    registry for this guarantees us the correct answer for all CSIDL_*
+    names.
+    """
+    import winreg as _winreg
+
+    shell_folder_name = {
+        "CSIDL_APPDATA": "AppData",
+        "CSIDL_COMMON_APPDATA": "Common AppData",
+        "CSIDL_LOCAL_APPDATA": "Local AppData",
+    }[csidl_name]
+
+    key = _winreg.OpenKey(
+        _winreg.HKEY_CURRENT_USER,
+        r"Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders"
+    )
+    dir, type = _winreg.QueryValueEx(key, shell_folder_name)
+    return dir
+
+
+def _get_win_folder_with_pywin32(csidl_name):
+    from win32com.shell import shellcon, shell
+    dir = shell.SHGetFolderPath(0, getattr(shellcon, csidl_name), 0, 0)
+    # Try to make this a unicode path because SHGetFolderPath does
+    # not return unicode strings when there is unicode data in the
+    # path.
+    try:
+        dir = unicode(dir)
+
+        # Downgrade to short path name if have highbit chars. See
+        # <http://bugs.activestate.com/show_bug.cgi?id=85099>.
+        has_high_char = False
+        for c in dir:
+            if ord(c) > 255:
+                has_high_char = True
+                break
+        if has_high_char:
+            try:
+                import win32api
+                dir = win32api.GetShortPathName(dir)
+            except ImportError:
+                pass
+    except UnicodeError:
+        pass
+    return dir
+
+
+def _get_win_folder_with_ctypes(csidl_name):
+    import ctypes
+
+    csidl_const = {
+        "CSIDL_APPDATA": 26,
+        "CSIDL_COMMON_APPDATA": 35,
+        "CSIDL_LOCAL_APPDATA": 28,
+    }[csidl_name]
+
+    buf = ctypes.create_unicode_buffer(1024)
+    ctypes.windll.shell32.SHGetFolderPathW(None, csidl_const, None, 0, buf)
+
+    # Downgrade to short path name if have highbit chars. See
+    # <http://bugs.activestate.com/show_bug.cgi?id=85099>.
+    has_high_char = False
+    for c in buf:
+        if ord(c) > 255:
+            has_high_char = True
+            break
+    if has_high_char:
+        buf2 = ctypes.create_unicode_buffer(1024)
+        if ctypes.windll.kernel32.GetShortPathNameW(buf.value, buf2, 1024):
+            buf = buf2
+
+    return buf.value
+
+def _get_win_folder_with_jna(csidl_name):
+    import array
+    from com.sun import jna
+    from com.sun.jna.platform import win32
+
+    buf_size = win32.WinDef.MAX_PATH * 2
+    buf = array.zeros('c', buf_size)
+    shell = win32.Shell32.INSTANCE
+    shell.SHGetFolderPath(None, getattr(win32.ShlObj, csidl_name), None, win32.ShlObj.SHGFP_TYPE_CURRENT, buf)
+    dir = jna.Native.toString(buf.tostring()).rstrip("\0")
+
+    # Downgrade to short path name if have highbit chars. See
+    # <http://bugs.activestate.com/show_bug.cgi?id=85099>.
+    has_high_char = False
+    for c in dir:
+        if ord(c) > 255:
+            has_high_char = True
+            break
+    if has_high_char:
+        buf = array.zeros('c', buf_size)
+        kernel = win32.Kernel32.INSTANCE
+        if kernel.GetShortPathName(dir, buf, buf_size):
+            dir = jna.Native.toString(buf.tostring()).rstrip("\0")
+
+    return dir
+
+if system == "win32":
+    try:
+        import win32com.shell
+        _get_win_folder = _get_win_folder_with_pywin32
+    except ImportError:
+        try:
+            from ctypes import windll
+            _get_win_folder = _get_win_folder_with_ctypes
+        except ImportError:
+            try:
+                import com.sun.jna
+                _get_win_folder = _get_win_folder_with_jna
+            except ImportError:
+                _get_win_folder = _get_win_folder_from_registry
+
+
+#---- self test code
+
+if __name__ == "__main__":
+    appname = "MyApp"
+    appauthor = "MyCompany"
+
+    props = ("user_data_dir",
+             "user_config_dir",
+             "user_cache_dir",
+             "user_state_dir",
+             "user_log_dir",
+             "site_data_dir",
+             "site_config_dir")
+
+    print("-- app dirs %s --" % __version__)
+
+    print("-- app dirs (with optional 'version')")
+    dirs = AppDirs(appname, appauthor, version="1.0")
+    for prop in props:
+        print("%s: %s" % (prop, getattr(dirs, prop)))
+
+    print("\n-- app dirs (without optional 'version')")
+    dirs = AppDirs(appname, appauthor)
+    for prop in props:
+        print("%s: %s" % (prop, getattr(dirs, prop)))
+
+    print("\n-- app dirs (without optional 'appauthor')")
+    dirs = AppDirs(appname)
+    for prop in props:
+        print("%s: %s" % (prop, getattr(dirs, prop)))
+
+    print("\n-- app dirs (with disabled 'appauthor')")
+    dirs = AppDirs(appname, appauthor=False)
+    for prop in props:
+        print("%s: %s" % (prop, getattr(dirs, prop)))

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/torch/_linalg_utils.py

@@ -0,0 +1,108 @@
+"""Various linear algebra utility methods for internal use.
+
+"""
+
+from torch import Tensor
+import torch
+
+from typing import Optional, Tuple
+
+
+def is_sparse(A):
+    """Check if tensor A is a sparse tensor"""
+    if isinstance(A, torch.Tensor):
+        return A.layout == torch.sparse_coo
+
+    error_str = "expected Tensor"
+    if not torch.jit.is_scripting():
+        error_str += " but got {}".format(type(A))
+    raise TypeError(error_str)
+
+def get_floating_dtype(A):
+    """Return the floating point dtype of tensor A.
+
+    Integer types map to float32.
+    """
+    dtype = A.dtype
+    if dtype in (torch.float16, torch.float32, torch.float64):
+        return dtype
+    return torch.float32
+
+
+def matmul(A: Optional[Tensor], B: Tensor) -> Tensor:
+    """Multiply two matrices.
+
+    If A is None, return B. A can be sparse or dense. B is always
+    dense.
+    """
+    if A is None:
+        return B
+    if is_sparse(A):
+        return torch.sparse.mm(A, B)
+    return torch.matmul(A, B)
+
+
+def conjugate(A):
+    """Return conjugate of tensor A.
+
+    .. note:: If A's dtype is not complex, A is returned.
+    """
+    if A.is_complex():
+        return A.conj()
+    return A
+
+
+def transpose(A):
+    """Return transpose of a matrix or batches of matrices.
+    """
+    ndim = len(A.shape)
+    return A.transpose(ndim - 1, ndim - 2)
+
+
+def transjugate(A):
+    """Return transpose conjugate of a matrix or batches of matrices.
+    """
+    return conjugate(transpose(A))
+
+
+def bform(X: Tensor, A: Optional[Tensor], Y: Tensor) -> Tensor:
+    """Return bilinear form of matrices: :math:`X^T A Y`.
+    """
+    return matmul(transpose(X), matmul(A, Y))
+
+
+def qform(A: Optional[Tensor], S: Tensor):
+    """Return quadratic form :math:`S^T A S`.
+    """
+    return bform(S, A, S)
+
+
+def basis(A):
+    """Return orthogonal basis of A columns.
+    """
+    if A.is_cuda:
+        # torch.orgqr is not available in CUDA
+        Q = torch.linalg.qr(A).Q
+    else:
+        Q = torch.orgqr(*torch.geqrf(A))
+    return Q
+
+
+def symeig(A: Tensor, largest: Optional[bool] = False) -> Tuple[Tensor, Tensor]:
+    """Return eigenpairs of A with specified ordering.
+    """
+    if largest is None:
+        largest = False
+    E, Z = torch.linalg.eigh(A, UPLO='U')
+    # assuming that E is ordered
+    if largest:
+        E = torch.flip(E, dims=(-1,))
+        Z = torch.flip(Z, dims=(-1,))
+    return E, Z
+
+# This function was deprecated and removed
+# This nice error message can be removed in version 1.13+
+def solve(input: Tensor, A: Tensor, *, out=None) -> Tuple[Tensor, Tensor]:
+    raise RuntimeError(
+        "This function was deprecated since version 1.9 and is now removed. Please use the `torch.linalg.solve` function instead.",
+    )

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/torch/_meta_registrations.py

@@ -0,0 +1,140 @@
+import torch
+from torch._prims import utils
+
+meta_lib = torch.library.Library("aten", "IMPL", "Meta")
+
+def check(b, s):
+    if not b:
+        raise RuntimeError(s)
+
+def toRealValueType(dtype):
+    from_complex = {
+        torch.complex32: torch.half,
+        torch.cfloat: torch.float,
+        torch.cdouble: torch.double
+    }
+    return from_complex.get(dtype, dtype)
+
+# Implementations below are taken from https://github.com/albanD/subclass_zoo/blob/main/python_meta_tensor.py
+@torch.library.impl(meta_lib, "index_select")
+def meta_index_select(self, dim, index):
+    result_size = list(self.size())
+    if self.dim() > 0:
+        result_size[dim] = index.numel()
+    return self.new_empty(result_size)
+
+@torch.library.impl(meta_lib, "index_select.out")
+def meta_index_select_out(self, dim, index, out):
+    torch._resize_output_(out, self.size(), self.device)
+    return out.copy_(torch.index_select(self, dim, index))
+
+@torch.library.impl(meta_lib, "abs")
+def meta_abs(self):
+    if self.is_complex():
+        float_type = toRealValueType(self.dtype)
+        return self.new_empty(self.size(), dtype=float_type)
+    else:
+        return self.new_empty(self.size())
+
+@torch.library.impl(meta_lib, "abs.out")
+def meta_abs_out(self, out):
+    torch._resize_output_(out, self.size(), self.device)
+    return out.copy_(torch.abs(self))
+
+@torch.library.impl(meta_lib, "max")
+def meta_max(self):
+    return self.new_empty(())
+
+@torch.library.impl(meta_lib, "min")
+def meta_min(self):
+    return self.new_empty(())
+
+def squareCheckInputs(self, f_name):
+    assert self.dim() >= 2, f"{f_name}: The input tensor must have at least 2 dimensions."
+    # TODO: I think the error message has the -2 and -1 swapped.  If you fix
+    # it fix the C++ squareCheckInputs too
+    assert self.size(-1) == self.size(-2), \
+        f"{f_name}: A must be batches of square matrices, but they are {self.size(-1)} by {self.size(-2)} matrices"
+
+def checkUplo(uplo: str):
+    uplo_uppercase = uplo.upper()
+    assert len(uplo) == 1 and uplo_uppercase == 'U' or uplo_uppercase == 'L', \
+        f"Expected UPLO argument to be 'L' or 'U', but got {uplo}"
+
+@torch.library.impl(meta_lib, "linalg_eigh")
+def meta_linalg_eigh(self, uplo="L"):
+    squareCheckInputs(self, "linalg_eigh")
+    checkUplo(uplo)
+    real_dtype = toRealValueType(self.dtype)
+    assert self.dim() >= 2
+    values = self.new_empty(self.shape, dtype=real_dtype)
+    values.transpose_(-2, -1)
+    vectors = self.new_empty(self.shape[:-1])
+    return (values, vectors)
+
+@torch.library.impl(meta_lib, "reflection_pad2d")
+def meta_pad2d(self, padding):
+    valid_dims = self.size(1) != 0 and self.size(2) != 0
+    check(
+        (self.ndim == 3 and valid_dims)
+        or (self.ndim == 4 and valid_dims and self.size(3) != 0),
+        f"3D or 4D (batch mode) tensor expected for input, but got: {self}"
+    )
+    if self.ndim == 4:
+        nbatch, nplane, input_h, input_w = self.shape
+    else:
+        nbatch = 1
+        nplane, input_h, input_w = self.shape
+
+    pad_l, pad_r, pad_t, pad_b = padding
+
+    output_h = input_h + pad_t + pad_b
+    output_w = input_w + pad_l + pad_r
+
+    if self.ndim == 3:
+        return self.new_empty((nplane, output_h, output_w))
+    else:
+        return self.new_empty((nbatch, nplane, output_h, output_w))
+
+@torch.library.impl(meta_lib, "dot")
+def meta_dot(self, tensor):
+    check(
+        self.dim() == 1 and tensor.dim() == 1,
+        f"1D tensors expected, but got {self.dim()}D and {tensor.dim()}D tensors"
+    )
+    return self.new_empty(())
+
+@torch.library.impl(meta_lib, "var_mean.correction")
+def meta_var_mean_correction(self, dim, *, correction, keepdim=False):
+    dim = utils.reduction_dims(self.shape, dim)
+    if keepdim:
+        output_shape = tuple(self.shape[i] if i not in dim else 1 for i in range(self.ndim))
+    else:
+        output_shape = utils.compute_reduction_output_shape(self.shape, dim)
+    result1 = self.new_empty(output_shape, dtype=toRealValueType(self.dtype))
+    result2 = self.new_empty(output_shape)
+    return result1, result2
+
+@torch.library.impl(meta_lib, "inverse")
+def meta_inverse(self):
+    # Bug: https://github.com/pytorch/pytorch/issues/77498
+    if self.numel() == 0:
+        return torch.empty_like(self)
+    r = self.new_empty(self.shape)
+    r.transpose_(-2, -1)
+    return r
+
+@torch.library.impl(meta_lib, "bernoulli.out")
+def meta_bernoulli(self, *, generator=None, out):
+    torch._resize_output_(out, self.size(), self.device)
+    return out
+
+@torch.library.impl(meta_lib, "_adaptive_avg_pool2d")
+def meta_adaptive_avg_pool2d(self, output_size):
+    check(self.ndim == 3 or self.ndim == 4, f"Expected 3D or 4D tensor, but got {self.shape}")
+    return self.new_empty(self.shape[:-2] + tuple(output_size))
+
+@torch.library.impl(meta_lib, "_adaptive_avg_pool3d")
+def meta_adaptive_avg_pool3d(self, output_size):
+    check(self.ndim == 4 or self.ndim == 5, f"Expected 4D or 5D tensor, but got {self.shape}")
+    return self.new_empty(self.shape[:-3] + tuple(output_size))

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/torch/_namedtensor_internals.py

@@ -0,0 +1,142 @@
+from collections import OrderedDict
+
+"""
+This file contains helper functions that implement experimental functionality
+for named tensors in python. All of these are experimental, unstable, and
+subject to change or deletion.
+"""
+
+
+def check_serializing_named_tensor(tensor):
+    if tensor.has_names():
+        raise RuntimeError(
+            "NYI: Named tensors don't support serialization. Please drop "
+            "names via `tensor = tensor.rename(None)` before serialization.")
+
+
+def build_dim_map(tensor):
+    """Returns a map of { dim: dim_name } where dim is a name if the dim is named
+    and the dim index otherwise."""
+    return OrderedDict([(idx if name is None else name, name)
+                        for idx, name in enumerate(tensor.names)])
+
+
+def unzip_namedshape(namedshape):
+    if isinstance(namedshape, OrderedDict):
+        namedshape = namedshape.items()
+    if not hasattr(namedshape, '__iter__') and not isinstance(namedshape, tuple):
+        raise RuntimeError(
+            'Expected namedshape to be OrderedDict or iterable of tuples, got: {}'
+            .format(type(namedshape)))
+    if len(namedshape) == 0:
+        raise RuntimeError('Expected namedshape to non-empty.')
+    return zip(*namedshape)
+
+
+def namer_api_name(inplace):
+    if inplace:
+        return 'rename_'
+    else:
+        return 'rename'
+
+
+def is_ellipsis(item):
+    return item == Ellipsis or item == '...'
+
+def single_ellipsis_index(names, fn_name):
+    ellipsis_indices = [i for i, name in enumerate(names) if is_ellipsis(name)]
+    if len(ellipsis_indices) >= 2:
+        raise RuntimeError('{}: More than one Ellipsis (\'...\') found in names ('
+                           '{}). This function supports up to one Ellipsis.'
+                           .format(fn_name, names))
+    if len(ellipsis_indices) == 1:
+        return ellipsis_indices[0]
+    return None
+
+def expand_single_ellipsis(numel_pre_glob, numel_post_glob, names):
+    return names[numel_pre_glob:len(names) - numel_post_glob]
+
+
+def replace_ellipsis_by_position(ellipsis_idx, names, tensor_names):
+    globbed_names = expand_single_ellipsis(ellipsis_idx, len(names) - ellipsis_idx - 1, tensor_names)
+    return names[:ellipsis_idx] + globbed_names + names[ellipsis_idx + 1:]
+
+
+def resolve_ellipsis(names, tensor_names, fn_name):
+    """
+    Expands ... inside `names` to be equal to a list of names from `tensor_names`.
+    """
+    ellipsis_idx = single_ellipsis_index(names, fn_name)
+    if ellipsis_idx is None:
+        return names
+    return replace_ellipsis_by_position(ellipsis_idx, names, tensor_names)
+
+
+def update_names_with_list(tensor, names, inplace):
+    # Special case for tensor.rename(None)
+    if len(names) == 1 and names[0] is None:
+        return tensor._update_names(None, inplace)
+
+    return tensor._update_names(
+        resolve_ellipsis(names, tensor.names, namer_api_name(inplace)), inplace)
+
+
+def update_names_with_mapping(tensor, rename_map, inplace):
+    dim_map = build_dim_map(tensor)
+    for old_dim in rename_map.keys():
+        new_dim = rename_map[old_dim]
+        if old_dim in dim_map.keys():
+            dim_map[old_dim] = new_dim
+        else:
+            raise RuntimeError(('{api_name}: Tried to rename dim \'{old_dim}\' to dim '
+                                '{new_dim} in Tensor[{dims}] but dim \'{old_dim}\' does not exist')
+                               .format(old_dim=old_dim, new_dim=new_dim, dims=tensor.names,
+                                       api_name=namer_api_name(inplace)))
+    return tensor._update_names(tuple(dim_map.values()), inplace)
+
+
+def update_names(tensor, names, rename_map, inplace):
+    """There are two usages:
+
+    tensor.rename(*names) returns a view on tensor with named dims `names`.
+    `names` must be of length `tensor.dim()`; otherwise, if '...' is in `names`,
+    then it is expanded greedily to be equal to the corresponding names from
+    `tensor.names`.
+
+    For example,
+    ```
+    >>> x = torch.empty(2, 3, 5, 7, names=('N', 'C', 'H', 'W'))
+    >>> x.rename('...', 'height', 'width').names
+    ('N', 'C', 'height', 'width')
+
+    >>> x.rename('batch', '...', 'width').names
+    ('batch', 'C', 'H', 'width')
+    ```
+
+    tensor.rename(**rename_map) returns a view on tensor that has rename dims
+        as specified in the mapping `rename_map`.
+
+    For example,
+    ```
+    >>> x = torch.empty(2, 3, 5, 7, names=('N', 'C', 'H', 'W'))
+    >>> x.rename(W='width', H='height').names
+    ('N', 'C', 'height', 'width')
+    ```
+
+    Finally, tensor.rename has an in-place version called tensor.rename_.
+    """
+    has_names = len(names) > 0
+    has_rename_pairs = bool(rename_map)
+    if has_names and has_rename_pairs:
+        raise RuntimeError('{api_name}: This function takes either positional '
+                           'args or keyword args, but not both. Use tensor.{api_name}(*names) '
+                           'to name dims and tensor.{api_name}(**rename_map) to rename '
+                           'dims.'.format(api_name=namer_api_name(inplace)))
+
+    # Special case for tensor.rename(*[]), which is valid for a 0 dim tensor.
+    if not has_names and not has_rename_pairs:
+        return update_names_with_list(tensor, names, inplace)
+
+    if has_names:
+        return update_names_with_list(tensor, names, inplace)
+    return update_names_with_mapping(tensor, rename_map, inplace)