Add files using upload-large-folder tool

.gitattributes

@@ -294,3 +294,6 @@ my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/h5py/utils.
 my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/h5py/h5fd.cpython-38-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/h5py/defs.cpython-38-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/h5py/h5d.cpython-38-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/h5py/h5f.cpython-38-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/wrapt/_wrappers.cpython-38-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/h5py/h5.cpython-38-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text

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

@@ -0,0 +1,181 @@
+'''
+OpenCV Python binary extension loader
+'''
+import os
+import importlib
+import sys
+
+__all__ = []
+
+try:
+    import numpy
+    import numpy.core.multiarray
+except ImportError:
+    print('OpenCV bindings requires "numpy" package.')
+    print('Install it via command:')
+    print('    pip install numpy')
+    raise
+
+# TODO
+# is_x64 = sys.maxsize > 2**32
+
+
+def __load_extra_py_code_for_module(base, name, enable_debug_print=False):
+    module_name = "{}.{}".format(__name__, name)
+    export_module_name = "{}.{}".format(base, name)
+    native_module = sys.modules.pop(module_name, None)
+    try:
+        py_module = importlib.import_module(module_name)
+    except ImportError as err:
+        if enable_debug_print:
+            print("Can't load Python code for module:", module_name,
+                  ". Reason:", err)
+        # Extension doesn't contain extra py code
+        return False
+
+    if not hasattr(base, name):
+        setattr(sys.modules[base], name, py_module)
+    sys.modules[export_module_name] = py_module
+    # If it is C extension module it is already loaded by cv2 package
+    if native_module:
+        setattr(py_module, "_native", native_module)
+        for k, v in filter(lambda kv: not hasattr(py_module, kv[0]),
+                           native_module.__dict__.items()):
+            if enable_debug_print: print('    symbol({}): {} = {}'.format(name, k, v))
+            setattr(py_module, k, v)
+    return True
+
+
+def __collect_extra_submodules(enable_debug_print=False):
+    def modules_filter(module):
+        return all((
+             # module is not internal
+             not module.startswith("_"),
+             not module.startswith("python-"),
+             # it is not a file
+             os.path.isdir(os.path.join(_extra_submodules_init_path, module))
+        ))
+    if sys.version_info[0] < 3:
+        if enable_debug_print:
+            print("Extra submodules is loaded only for Python 3")
+        return []
+
+    __INIT_FILE_PATH = os.path.abspath(__file__)
+    _extra_submodules_init_path = os.path.dirname(__INIT_FILE_PATH)
+    return filter(modules_filter, os.listdir(_extra_submodules_init_path))
+
+
+def bootstrap():
+    import sys
+
+    import copy
+    save_sys_path = copy.copy(sys.path)
+
+    if hasattr(sys, 'OpenCV_LOADER'):
+        print(sys.path)
+        raise ImportError('ERROR: recursion is detected during loading of "cv2" binary extensions. Check OpenCV installation.')
+    sys.OpenCV_LOADER = True
+
+    DEBUG = False
+    if hasattr(sys, 'OpenCV_LOADER_DEBUG'):
+        DEBUG = True
+
+    import platform
+    if DEBUG: print('OpenCV loader: os.name="{}"  platform.system()="{}"'.format(os.name, str(platform.system())))
+
+    LOADER_DIR = os.path.dirname(os.path.abspath(os.path.realpath(__file__)))
+
+    PYTHON_EXTENSIONS_PATHS = []
+    BINARIES_PATHS = []
+
+    g_vars = globals()
+    l_vars = locals().copy()
+
+    if sys.version_info[:2] < (3, 0):
+        from . load_config_py2 import exec_file_wrapper
+    else:
+        from . load_config_py3 import exec_file_wrapper
+
+    def load_first_config(fnames, required=True):
+        for fname in fnames:
+            fpath = os.path.join(LOADER_DIR, fname)
+            if not os.path.exists(fpath):
+                if DEBUG: print('OpenCV loader: config not found, skip: {}'.format(fpath))
+                continue
+            if DEBUG: print('OpenCV loader: loading config: {}'.format(fpath))
+            exec_file_wrapper(fpath, g_vars, l_vars)
+            return True
+        if required:
+            raise ImportError('OpenCV loader: missing configuration file: {}. Check OpenCV installation.'.format(fnames))
+
+    load_first_config(['config.py'], True)
+    load_first_config([
+        'config-{}.{}.py'.format(sys.version_info[0], sys.version_info[1]),
+        'config-{}.py'.format(sys.version_info[0])
+    ], True)
+
+    if DEBUG: print('OpenCV loader: PYTHON_EXTENSIONS_PATHS={}'.format(str(l_vars['PYTHON_EXTENSIONS_PATHS'])))
+    if DEBUG: print('OpenCV loader: BINARIES_PATHS={}'.format(str(l_vars['BINARIES_PATHS'])))
+
+    applySysPathWorkaround = False
+    if hasattr(sys, 'OpenCV_REPLACE_SYS_PATH_0'):
+        applySysPathWorkaround = True
+    else:
+        try:
+            BASE_DIR = os.path.dirname(LOADER_DIR)
+            if sys.path[0] == BASE_DIR or os.path.realpath(sys.path[0]) == BASE_DIR:
+                applySysPathWorkaround = True
+        except:
+            if DEBUG: print('OpenCV loader: exception during checking workaround for sys.path[0]')
+            pass  # applySysPathWorkaround is False
+
+    for p in reversed(l_vars['PYTHON_EXTENSIONS_PATHS']):
+        sys.path.insert(1 if not applySysPathWorkaround else 0, p)
+
+    if os.name == 'nt':
+        if sys.version_info[:2] >= (3, 8):  # https://github.com/python/cpython/pull/12302
+            for p in l_vars['BINARIES_PATHS']:
+                try:
+                    os.add_dll_directory(p)
+                except Exception as e:
+                    if DEBUG: print('Failed os.add_dll_directory(): '+ str(e))
+                    pass
+        os.environ['PATH'] = ';'.join(l_vars['BINARIES_PATHS']) + ';' + os.environ.get('PATH', '')
+        if DEBUG: print('OpenCV loader: PATH={}'.format(str(os.environ['PATH'])))
+    else:
+        # amending of LD_LIBRARY_PATH works for sub-processes only
+        os.environ['LD_LIBRARY_PATH'] = ':'.join(l_vars['BINARIES_PATHS']) + ':' + os.environ.get('LD_LIBRARY_PATH', '')
+
+    if DEBUG: print("Relink everything from native cv2 module to cv2 package")
+
+    py_module = sys.modules.pop("cv2")
+
+    native_module = importlib.import_module("cv2")
+
+    sys.modules["cv2"] = py_module
+    setattr(py_module, "_native", native_module)
+
+    for item_name, item in filter(lambda kv: kv[0] not in ("__file__", "__loader__", "__spec__",
+                                                           "__name__", "__package__"),
+                                  native_module.__dict__.items()):
+        if item_name not in g_vars:
+            g_vars[item_name] = item
+
+    sys.path = save_sys_path  # multiprocessing should start from bootstrap code (https://github.com/opencv/opencv/issues/18502)
+
+    try:
+        del sys.OpenCV_LOADER
+    except Exception as e:
+        if DEBUG:
+            print("Exception during delete OpenCV_LOADER:", e)
+
+    if DEBUG: print('OpenCV loader: binary extension... OK')
+
+    for submodule in __collect_extra_submodules(DEBUG):
+        if __load_extra_py_code_for_module("cv2", submodule, DEBUG):
+            if DEBUG: print("Extra Python code for", submodule, "is loaded")
+
+    if DEBUG: print('OpenCV loader: DONE')
+
+
+bootstrap()

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/cv2/load_config_py3.py

@@ -0,0 +1,9 @@
+# flake8: noqa
+import os
+import sys
+
+if sys.version_info[:2] >= (3, 0):
+    def exec_file_wrapper(fpath, g_vars, l_vars):
+        with open(fpath) as f:
+            code = compile(f.read(), os.path.basename(fpath), 'exec')
+            exec(code, g_vars, l_vars)

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/docker_pycreds-0.4.0.dist-info/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/docker_pycreds-0.4.0.dist-info/METADATA

@@ -0,0 +1,62 @@
+Metadata-Version: 2.1
+Name: docker-pycreds
+Version: 0.4.0
+Summary: Python bindings for the docker credentials store API
+Home-page: https://github.com/shin-/dockerpy-creds
+Author: UNKNOWN
+Author-email: UNKNOWN
+License: Apache License 2.0
+Platform: UNKNOWN
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Other Environment
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 2.6
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.3
+Classifier: Programming Language :: Python :: 3.4
+Classifier: Programming Language :: Python :: 3.5
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Topic :: Utilities
+Classifier: License :: OSI Approved :: Apache Software License
+Requires-Dist: six (>=1.4.0)
+
+# docker-pycreds
+
+[![CircleCI](https://circleci.com/gh/shin-/dockerpy-creds/tree/master.svg?style=svg)](https://circleci.com/gh/shin-/dockerpy-creds/tree/master)
+
+Python bindings for the docker credentials store API
+
+## Credentials store info
+
+[Docker documentation page](https://docs.docker.com/engine/reference/commandline/login/#/credentials-store)
+
+## Requirements
+
+On top of the dependencies in `requirements.txt`, the `docker-credential`
+executable for the platform must be installed on the user's system.
+
+## API usage
+
+```python
+
+import dockerpycreds
+
+store = dockerpycreds.Store('secretservice')
+store.store(
+    server='https://index.docker.io/v1/', username='johndoe',
+    secret='hunter2'
+)
+
+print(store.list())
+
+print(store.get('https://index.docker.io/v1/'))
+
+
+store.erase('https://index.docker.io/v1/')
+```
+
+

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/docker_pycreds-0.4.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+docker_pycreds-0.4.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+docker_pycreds-0.4.0.dist-info/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+docker_pycreds-0.4.0.dist-info/METADATA,sha256=FOmAKPL9hzMoIGVedpB45WzPyJmvEqUPoWIWElf5S18,1821
+docker_pycreds-0.4.0.dist-info/RECORD,,
+docker_pycreds-0.4.0.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+docker_pycreds-0.4.0.dist-info/WHEEL,sha256=CihQvCnsGZQBGAHLEUMf0IdA4fRduS_NBUTMgCTtvPM,110
+docker_pycreds-0.4.0.dist-info/top_level.txt,sha256=iHN9Ul5VnNovfI4c7fel4nGnEtE4BezC_IQ8_3meRVw,14
+dockerpycreds/__init__.py,sha256=vdD-zY6geCywLcpf8Naplshb5a5dc8czaWtbL7VdEDE,116
+dockerpycreds/__pycache__/__init__.cpython-38.pyc,,
+dockerpycreds/__pycache__/constants.cpython-38.pyc,,
+dockerpycreds/__pycache__/errors.cpython-38.pyc,,
+dockerpycreds/__pycache__/store.cpython-38.pyc,,
+dockerpycreds/__pycache__/utils.cpython-38.pyc,,
+dockerpycreds/__pycache__/version.cpython-38.pyc,,
+dockerpycreds/constants.py,sha256=5HjRGorpVvkamvLBI9yLPvur1E0glaq_ZhuRfbVA_bE,142
+dockerpycreds/errors.py,sha256=ghtvHruuU_wK_f90fnoep-yoVNx4t-OpYrB84v2yHjg,576
+dockerpycreds/store.py,sha256=uTjPxLKzqWanbCWe7fGVJyZX9PKv6QRE5omRSz6J4qE,3799
+dockerpycreds/utils.py,sha256=_ErlaAETnJEvPbBRdrLKBzKCB37eH0uncCdBySPIIKo,1020
+dockerpycreds/version.py,sha256=G-VpNfv2NAp81lTH0IeEq1qv9H2RSJW_Bn2UuwqxF_M,91

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/docker_pycreds-0.4.0.dist-info/WHEEL

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

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/docker_pycreds-0.4.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+dockerpycreds

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/einops-0.4.1.dist-info/INSTALLER

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

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/filelock/_api.py

@@ -0,0 +1,323 @@
+from __future__ import annotations
+
+import contextlib
+import logging
+import os
+import time
+import warnings
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from threading import local
+from typing import TYPE_CHECKING, Any, ClassVar
+from weakref import WeakValueDictionary
+
+from ._error import Timeout
+
+if TYPE_CHECKING:
+    import sys
+    from types import TracebackType
+
+    if sys.version_info >= (3, 11):  # pragma: no cover (py311+)
+        from typing import Self
+    else:  # pragma: no cover (<py311)
+        from typing_extensions import Self
+
+
+_LOGGER = logging.getLogger("filelock")
+
+
+# This is a helper class which is returned by :meth:`BaseFileLock.acquire` and wraps the lock to make sure __enter__
+# is not called twice when entering the with statement. If we would simply return *self*, the lock would be acquired
+# again in the *__enter__* method of the BaseFileLock, but not released again automatically. issue #37 (memory leak)
+class AcquireReturnProxy:
+    """A context aware object that will release the lock file when exiting."""
+
+    def __init__(self, lock: BaseFileLock) -> None:
+        self.lock = lock
+
+    def __enter__(self) -> BaseFileLock:
+        return self.lock
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> None:
+        self.lock.release()
+
+
+@dataclass
+class FileLockContext:
+    """A dataclass which holds the context for a ``BaseFileLock`` object."""
+
+    # The context is held in a separate class to allow optional use of thread local storage via the
+    # ThreadLocalFileContext class.
+
+    #: The path to the lock file.
+    lock_file: str
+
+    #: The default timeout value.
+    timeout: float
+
+    #: The mode for the lock files
+    mode: int
+
+    #: The file descriptor for the *_lock_file* as it is returned by the os.open() function, not None when lock held
+    lock_file_fd: int | None = None
+
+    #: The lock counter is used for implementing the nested locking mechanism.
+    lock_counter: int = 0  # When the lock is acquired is increased and the lock is only released, when this value is 0
+
+
+class ThreadLocalFileContext(FileLockContext, local):
+    """A thread local version of the ``FileLockContext`` class."""
+
+
+class BaseFileLock(ABC, contextlib.ContextDecorator):
+    """Abstract base class for a file lock object."""
+
+    _instances: ClassVar[WeakValueDictionary[str, BaseFileLock]] = WeakValueDictionary()
+
+    def __new__(  # noqa: PLR0913
+        cls,
+        lock_file: str | os.PathLike[str],
+        timeout: float = -1,  # noqa: ARG003
+        mode: int = 0o644,  # noqa: ARG003
+        thread_local: bool = True,  # noqa: ARG003, FBT001, FBT002
+        *,
+        is_singleton: bool = False,
+        **kwargs: dict[str, Any],  # capture remaining kwargs for subclasses  # noqa: ARG003
+    ) -> Self:
+        """Create a new lock object or if specified return the singleton instance for the lock file."""
+        if not is_singleton:
+            return super().__new__(cls)
+
+        instance = cls._instances.get(str(lock_file))
+        if not instance:
+            instance = super().__new__(cls)
+            cls._instances[str(lock_file)] = instance
+
+        return instance  # type: ignore[return-value] # https://github.com/python/mypy/issues/15322
+
+    def __init__(  # noqa: PLR0913
+        self,
+        lock_file: str | os.PathLike[str],
+        timeout: float = -1,
+        mode: int = 0o644,
+        thread_local: bool = True,  # noqa: FBT001, FBT002
+        *,
+        is_singleton: bool = False,
+    ) -> None:
+        """
+        Create a new lock object.
+
+        :param lock_file: path to the file
+        :param timeout: default timeout when acquiring the lock, in seconds. It will be used as fallback value in \
+            the acquire method, if no timeout value (``None``) is given. If you want to disable the timeout, set it \
+            to a negative value. A timeout of 0 means, that there is exactly one attempt to acquire the file lock.
+        :param mode: file permissions for the lockfile
+        :param thread_local: Whether this object's internal context should be thread local or not. If this is set to \
+            ``False`` then the lock will be reentrant across threads.
+        :param is_singleton: If this is set to ``True`` then only one instance of this class will be created \
+            per lock file. This is useful if you want to use the lock object for reentrant locking without needing \
+            to pass the same object around.
+        """
+        self._is_thread_local = thread_local
+        self._is_singleton = is_singleton
+
+        # Create the context. Note that external code should not work with the context directly  and should instead use
+        # properties of this class.
+        kwargs: dict[str, Any] = {
+            "lock_file": os.fspath(lock_file),
+            "timeout": timeout,
+            "mode": mode,
+        }
+        self._context: FileLockContext = (ThreadLocalFileContext if thread_local else FileLockContext)(**kwargs)
+
+    def is_thread_local(self) -> bool:
+        """:return: a flag indicating if this lock is thread local or not"""
+        return self._is_thread_local
+
+    @property
+    def is_singleton(self) -> bool:
+        """:return: a flag indicating if this lock is singleton or not"""
+        return self._is_singleton
+
+    @property
+    def lock_file(self) -> str:
+        """:return: path to the lock file"""
+        return self._context.lock_file
+
+    @property
+    def timeout(self) -> float:
+        """
+        :return: the default timeout value, in seconds
+
+        .. versionadded:: 2.0.0
+        """
+        return self._context.timeout
+
+    @timeout.setter
+    def timeout(self, value: float | str) -> None:
+        """
+        Change the default timeout value.
+
+        :param value: the new value, in seconds
+        """
+        self._context.timeout = float(value)
+
+    @abstractmethod
+    def _acquire(self) -> None:
+        """If the file lock could be acquired, self._context.lock_file_fd holds the file descriptor of the lock file."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def _release(self) -> None:
+        """Releases the lock and sets self._context.lock_file_fd to None."""
+        raise NotImplementedError
+
+    @property
+    def is_locked(self) -> bool:
+        """
+
+        :return: A boolean indicating if the lock file is holding the lock currently.
+
+        .. versionchanged:: 2.0.0
+
+            This was previously a method and is now a property.
+        """
+        return self._context.lock_file_fd is not None
+
+    @property
+    def lock_counter(self) -> int:
+        """:return: The number of times this lock has been acquired (but not yet released)."""
+        return self._context.lock_counter
+
+    def acquire(
+        self,
+        timeout: float | None = None,
+        poll_interval: float = 0.05,
+        *,
+        poll_intervall: float | None = None,
+        blocking: bool = True,
+    ) -> AcquireReturnProxy:
+        """
+        Try to acquire the file lock.
+
+        :param timeout: maximum wait time for acquiring the lock, ``None`` means use the default :attr:`~timeout` is and
+         if ``timeout < 0``, there is no timeout and this method will block until the lock could be acquired
+        :param poll_interval: interval of trying to acquire the lock file
+        :param poll_intervall: deprecated, kept for backwards compatibility, use ``poll_interval`` instead
+        :param blocking: defaults to True. If False, function will return immediately if it cannot obtain a lock on the
+         first attempt. Otherwise, this method will block until the timeout expires or the lock is acquired.
+        :raises Timeout: if fails to acquire lock within the timeout period
+        :return: a context object that will unlock the file when the context is exited
+
+        .. code-block:: python
+
+            # You can use this method in the context manager (recommended)
+            with lock.acquire():
+                pass
+
+            # Or use an equivalent try-finally construct:
+            lock.acquire()
+            try:
+                pass
+            finally:
+                lock.release()
+
+        .. versionchanged:: 2.0.0
+
+            This method returns now a *proxy* object instead of *self*,
+            so that it can be used in a with statement without side effects.
+
+        """
+        # Use the default timeout, if no timeout is provided.
+        if timeout is None:
+            timeout = self._context.timeout
+
+        if poll_intervall is not None:
+            msg = "use poll_interval instead of poll_intervall"
+            warnings.warn(msg, DeprecationWarning, stacklevel=2)
+            poll_interval = poll_intervall
+
+        # Increment the number right at the beginning. We can still undo it, if something fails.
+        self._context.lock_counter += 1
+
+        lock_id = id(self)
+        lock_filename = self.lock_file
+        start_time = time.perf_counter()
+        try:
+            while True:
+                if not self.is_locked:
+                    _LOGGER.debug("Attempting to acquire lock %s on %s", lock_id, lock_filename)
+                    self._acquire()
+                if self.is_locked:
+                    _LOGGER.debug("Lock %s acquired on %s", lock_id, lock_filename)
+                    break
+                if blocking is False:
+                    _LOGGER.debug("Failed to immediately acquire lock %s on %s", lock_id, lock_filename)
+                    raise Timeout(lock_filename)  # noqa: TRY301
+                if 0 <= timeout < time.perf_counter() - start_time:
+                    _LOGGER.debug("Timeout on acquiring lock %s on %s", lock_id, lock_filename)
+                    raise Timeout(lock_filename)  # noqa: TRY301
+                msg = "Lock %s not acquired on %s, waiting %s seconds ..."
+                _LOGGER.debug(msg, lock_id, lock_filename, poll_interval)
+                time.sleep(poll_interval)
+        except BaseException:  # Something did go wrong, so decrement the counter.
+            self._context.lock_counter = max(0, self._context.lock_counter - 1)
+            raise
+        return AcquireReturnProxy(lock=self)
+
+    def release(self, force: bool = False) -> None:  # noqa: FBT001, FBT002
+        """
+        Releases the file lock. Please note, that the lock is only completely released, if the lock counter is 0. Also
+        note, that the lock file itself is not automatically deleted.
+
+        :param force: If true, the lock counter is ignored and the lock is released in every case/
+        """
+        if self.is_locked:
+            self._context.lock_counter -= 1
+
+            if self._context.lock_counter == 0 or force:
+                lock_id, lock_filename = id(self), self.lock_file
+
+                _LOGGER.debug("Attempting to release lock %s on %s", lock_id, lock_filename)
+                self._release()
+                self._context.lock_counter = 0
+                _LOGGER.debug("Lock %s released on %s", lock_id, lock_filename)
+
+    def __enter__(self) -> Self:
+        """
+        Acquire the lock.
+
+        :return: the lock object
+        """
+        self.acquire()
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> None:
+        """
+        Release the lock.
+
+        :param exc_type: the exception type if raised
+        :param exc_value: the exception value if raised
+        :param traceback: the exception traceback if raised
+        """
+        self.release()
+
+    def __del__(self) -> None:
+        """Called when the lock object is deleted."""
+        self.release(force=True)
+
+
+__all__ = [
+    "BaseFileLock",
+    "AcquireReturnProxy",
+]

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/filelock/_unix.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+import os
+import sys
+from contextlib import suppress
+from errno import ENOSYS
+from typing import cast
+
+from ._api import BaseFileLock
+from ._util import ensure_directory_exists
+
+#: a flag to indicate if the fcntl API is available
+has_fcntl = False
+if sys.platform == "win32":  # pragma: win32 cover
+
+    class UnixFileLock(BaseFileLock):
+        """Uses the :func:`fcntl.flock` to hard lock the lock file on unix systems."""
+
+        def _acquire(self) -> None:
+            raise NotImplementedError
+
+        def _release(self) -> None:
+            raise NotImplementedError
+
+else:  # pragma: win32 no cover
+    try:
+        import fcntl
+    except ImportError:
+        pass
+    else:
+        has_fcntl = True
+
+    class UnixFileLock(BaseFileLock):
+        """Uses the :func:`fcntl.flock` to hard lock the lock file on unix systems."""
+
+        def _acquire(self) -> None:
+            ensure_directory_exists(self.lock_file)
+            open_flags = os.O_RDWR | os.O_CREAT | os.O_TRUNC
+            fd = os.open(self.lock_file, open_flags, self._context.mode)
+            with suppress(PermissionError):  # This locked is not owned by this UID
+                os.fchmod(fd, self._context.mode)
+            try:
+                fcntl.flock(fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
+            except OSError as exception:
+                os.close(fd)
+                if exception.errno == ENOSYS:  # NotImplemented error
+                    msg = "FileSystem does not appear to support flock; user SoftFileLock instead"
+                    raise NotImplementedError(msg) from exception
+            else:
+                self._context.lock_file_fd = fd
+
+        def _release(self) -> None:
+            # Do not remove the lockfile:
+            #   https://github.com/tox-dev/py-filelock/issues/31
+            #   https://stackoverflow.com/questions/17708885/flock-removing-locked-file-without-race-condition
+            fd = cast(int, self._context.lock_file_fd)
+            self._context.lock_file_fd = None
+            fcntl.flock(fd, fcntl.LOCK_UN)
+            os.close(fd)
+
+
+__all__ = [
+    "has_fcntl",
+    "UnixFileLock",
+]

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/filelock/_util.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+import os
+import stat
+import sys
+from errno import EACCES, EISDIR
+from pathlib import Path
+
+
+def raise_on_not_writable_file(filename: str) -> None:
+    """
+    Raise an exception if attempting to open the file for writing would fail.
+    This is done so files that will never be writable can be separated from
+    files that are writable but currently locked
+    :param filename: file to check
+    :raises OSError: as if the file was opened for writing.
+    """
+    try:  # use stat to do exists + can write to check without race condition
+        file_stat = os.stat(filename)  # noqa: PTH116
+    except OSError:
+        return  # swallow does not exist or other errors
+
+    if file_stat.st_mtime != 0:  # if os.stat returns but modification is zero that's an invalid os.stat - ignore it
+        if not (file_stat.st_mode & stat.S_IWUSR):
+            raise PermissionError(EACCES, "Permission denied", filename)
+
+        if stat.S_ISDIR(file_stat.st_mode):
+            if sys.platform == "win32":  # pragma: win32 cover
+                # On Windows, this is PermissionError
+                raise PermissionError(EACCES, "Permission denied", filename)
+            else:  # pragma: win32 no cover # noqa: RET506
+                # On linux / macOS, this is IsADirectoryError
+                raise IsADirectoryError(EISDIR, "Is a directory", filename)
+
+
+def ensure_directory_exists(filename: Path | str) -> None:
+    """
+    Ensure the directory containing the file exists (create it if necessary)
+    :param filename: file.
+    """
+    Path(filename).parent.mkdir(parents=True, exist_ok=True)
+
+
+__all__ = [
+    "raise_on_not_writable_file",
+    "ensure_directory_exists",
+]

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/h5py/h5.cpython-38-x86_64-linux-gnu.so

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

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/h5py/h5f.cpython-38-x86_64-linux-gnu.so

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

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/humanize-4.2.2.dist-info/INSTALLER

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

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/humanize-4.2.2.dist-info/METADATA

@@ -0,0 +1,264 @@
+Metadata-Version: 2.1
+Name: humanize
+Version: 4.2.2
+Summary: Python humanize utilities
+Home-page: https://github.com/python-humanize/humanize
+Author: Jason Moiron
+Author-email: jmoiron@jmoiron.net
+Maintainer: Hugo van Kemenade
+License: MIT
+Project-URL: Source, https://github.com/python-humanize/humanize
+Project-URL: Issue tracker, https://github.com/python-humanize/humanize/issues
+Project-URL: Funding, https://tidelift.com/subscription/pkg/pypi-humanize?utm_source=pypi-humanize&utm_medium=pypi
+Project-URL: Documentation, https://python-humanize.readthedocs.io/
+Project-URL: Release notes, https://github.com/python-humanize/humanize/releases
+Keywords: humanize time size
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Text Processing
+Classifier: Topic :: Text Processing :: General
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENCE
+Requires-Dist: importlib-metadata ; python_version < "3.8"
+Provides-Extra: tests
+Requires-Dist: freezegun ; extra == 'tests'
+Requires-Dist: pytest ; extra == 'tests'
+Requires-Dist: pytest-cov ; extra == 'tests'
+
+# humanize
+
+[![PyPI version](https://img.shields.io/pypi/v/humanize.svg?logo=pypi&logoColor=FFE873)](https://pypi.org/project/humanize/)
+[![Supported Python versions](https://img.shields.io/pypi/pyversions/humanize.svg?logo=python&logoColor=FFE873)](https://pypi.org/project/humanize/)
+[![Documentation Status](https://readthedocs.org/projects/python-humanize/badge/?version=latest)](https://python-humanize.readthedocs.io/en/latest/?badge=latest)
+[![PyPI downloads](https://img.shields.io/pypi/dm/humanize.svg)](https://pypistats.org/packages/humanize)
+[![GitHub Actions status](https://github.com/python-humanize/humanize/workflows/Test/badge.svg)](https://github.com/python-humanize/humanize/actions)
+[![codecov](https://codecov.io/gh/python-humanize/humanize/branch/main/graph/badge.svg)](https://codecov.io/gh/python-humanize/humanize)
+[![MIT License](https://img.shields.io/github/license/python-humanize/humanize.svg)](LICENCE)
+[![Tidelift](https://tidelift.com/badges/package/pypi/humanize)](https://tidelift.com/subscription/pkg/pypi-humanize?utm_source=pypi-humanize&utm_medium=badge)
+
+This modest package contains various common humanization utilities, like turning
+a number into a fuzzy human-readable duration ("3 minutes ago") or into a
+human-readable size or throughput. It is localized to:
+
+- Arabic
+- Bengali
+- Brazilian Portuguese
+- Catalan
+- Danish
+- Dutch
+- European Portuguese
+- Finnish
+- French
+- German
+- Indonesian
+- Italian
+- Japanese
+- Korean
+- Persian
+- Polish
+- Russian
+- Simplified Chinese
+- Slovak
+- Slovenian
+- Spanish
+- Swedish
+- Turkish
+- Ukrainian
+- Vietnamese
+
+## API reference
+
+[https://python-humanize.readthedocs.io](https://python-humanize.readthedocs.io)
+
+<!-- usage-start -->
+
+## Usage
+
+### Integer humanization
+
+```pycon
+>>> import humanize
+>>> humanize.intcomma(12345)
+'12,345'
+>>> humanize.intword(123455913)
+'123.5 million'
+>>> humanize.intword(12345591313)
+'12.3 billion'
+>>> humanize.apnumber(4)
+'four'
+>>> humanize.apnumber(41)
+'41'
+```
+
+### Date & time humanization
+
+```pycon
+>>> import humanize
+>>> import datetime as dt
+>>> humanize.naturalday(dt.datetime.now())
+'today'
+>>> humanize.naturaldelta(dt.timedelta(seconds=1001))
+'16 minutes'
+>>> humanize.naturalday(dt.datetime.now() - dt.timedelta(days=1))
+'yesterday'
+>>> humanize.naturalday(dt.date(2007, 6, 5))
+'Jun 05'
+>>> humanize.naturaldate(dt.date(2007, 6, 5))
+'Jun 05 2007'
+>>> humanize.naturaltime(dt.datetime.now() - dt.timedelta(seconds=1))
+'a second ago'
+>>> humanize.naturaltime(dt.datetime.now() - dt.timedelta(seconds=3600))
+'an hour ago'
+```
+
+### Precise time delta
+
+```pycon
+>>> import humanize
+>>> import datetime as dt
+>>> delta = dt.timedelta(seconds=3633, days=2, microseconds=123000)
+>>> humanize.precisedelta(delta)
+'2 days, 1 hour and 33.12 seconds'
+>>> humanize.precisedelta(delta, minimum_unit="microseconds")
+'2 days, 1 hour, 33 seconds and 123 milliseconds'
+>>> humanize.precisedelta(delta, suppress=["days"], format="%0.4f")
+'49 hours and 33.1230 seconds'
+```
+
+#### Smaller units
+
+If seconds are too large, set `minimum_unit` to milliseconds or microseconds:
+
+```pycon
+>>> import humanize
+>>> import datetime as dt
+>>> humanize.naturaldelta(dt.timedelta(seconds=2))
+'2 seconds'
+```
+
+```pycon
+>>> delta = dt.timedelta(milliseconds=4)
+>>> humanize.naturaldelta(delta)
+'a moment'
+>>> humanize.naturaldelta(delta, minimum_unit="milliseconds")
+'4 milliseconds'
+>>> humanize.naturaldelta(delta, minimum_unit="microseconds")
+'4 milliseconds'
+```
+
+```pycon
+>>> humanize.naturaltime(delta)
+'now'
+>>> humanize.naturaltime(delta, minimum_unit="milliseconds")
+'4 milliseconds ago'
+>>> humanize.naturaltime(delta, minimum_unit="microseconds")
+'4 milliseconds ago'
+```
+
+### File size humanization
+
+```pycon
+>>> import humanize
+>>> humanize.naturalsize(1_000_000)
+'1.0 MB'
+>>> humanize.naturalsize(1_000_000, binary=True)
+'976.6 KiB'
+>>> humanize.naturalsize(1_000_000, gnu=True)
+'976.6K'
+```
+
+### Human-readable floating point numbers
+
+```pycon
+>>> import humanize
+>>> humanize.fractional(1/3)
+'1/3'
+>>> humanize.fractional(1.5)
+'1 1/2'
+>>> humanize.fractional(0.3)
+'3/10'
+>>> humanize.fractional(0.333)
+'333/1000'
+>>> humanize.fractional(1)
+'1'
+```
+
+### Scientific notation
+
+```pycon
+>>> import humanize
+>>> humanize.scientific(0.3)
+'3.00 x 10⁻¹'
+>>> humanize.scientific(500)
+'5.00 x 10²'
+>>> humanize.scientific("20000")
+'2.00 x 10⁴'
+>>> humanize.scientific(1**10)
+'1.00 x 10⁰'
+>>> humanize.scientific(1**10, precision=1)
+'1.0 x 10⁰'
+>>> humanize.scientific(1**10, precision=0)
+'1 x 10⁰'
+```
+
+## Localization
+
+How to change locale at runtime:
+
+```pycon
+>>> import humanize
+>>> import datetime as dt
+>>> humanize.naturaltime(dt.timedelta(seconds=3))
+'3 seconds ago'
+>>> _t = humanize.i18n.activate("ru_RU")
+>>> humanize.naturaltime(dt.timedelta(seconds=3))
+'3 секунды назад'
+>>> humanize.i18n.deactivate()
+>>> humanize.naturaltime(dt.timedelta(seconds=3))
+'3 seconds ago'
+```
+
+You can pass additional parameter `path` to `activate` to specify a path to search
+locales in.
+
+```pycon
+>>> import humanize
+>>> humanize.i18n.activate("xx_XX")
+<...>
+FileNotFoundError: [Errno 2] No translation file found for domain: 'humanize'
+>>> humanize.i18n.activate("pt_BR", path="path/to/my/own/translation/")
+<gettext.GNUTranslations instance ...>
+```
+
+<!-- usage-end -->
+
+How to add new phrases to existing locale files:
+
+```console
+$ xgettext --from-code=UTF-8 -o humanize.pot -k'_' -k'N_' -k'P_:1c,2' -l python src/humanize/*.py  # extract new phrases
+$ msgmerge -U src/humanize/locale/ru_RU/LC_MESSAGES/humanize.po humanize.pot # add them to locale files
+```
+
+How to add a new locale:
+
+```console
+$ msginit -i humanize.pot -o humanize/locale/<locale name>/LC_MESSAGES/humanize.po --locale <locale name>
+```
+
+Where `<locale name>` is a locale abbreviation, eg. `en_GB`, `pt_BR` or just `ru`, `fr`
+etc.
+
+List the language at the top of this README.

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/humanize-4.2.2.dist-info/RECORD

@@ -0,0 +1,70 @@
+humanize-4.2.2.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+humanize-4.2.2.dist-info/LICENCE,sha256=i6bBgRKkMUAK08dD9wZwB5swJUXZiIT8LyipHDg6A4A,1078
+humanize-4.2.2.dist-info/METADATA,sha256=RceLVGyIQlQIoZ6XiIxa6J4Gn6WTbFoOD5dGgKlZusA,7672
+humanize-4.2.2.dist-info/RECORD,,
+humanize-4.2.2.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+humanize-4.2.2.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
+humanize-4.2.2.dist-info/top_level.txt,sha256=1B-bfyhHo8hE-z_Kn_iBhAmKipLlcRema3YIwAD3u5A,9
+humanize/__init__.py,sha256=eHXLDwlS7FrYU_GU0bCoUeYN6SPwz-UH0f2y1aBbTzo,959
+humanize/__pycache__/__init__.cpython-38.pyc,,
+humanize/__pycache__/filesize.cpython-38.pyc,,
+humanize/__pycache__/i18n.cpython-38.pyc,,
+humanize/__pycache__/number.cpython-38.pyc,,
+humanize/__pycache__/time.cpython-38.pyc,,
+humanize/filesize.py,sha256=-SZ1l1-SquKegx6kky5BM4S5HDslieExwXaiAdctvNA,2273
+humanize/i18n.py,sha256=i7WgiA02FSv2jpPCYOjmp6AQrFTQvhSbdBkbnGRimDQ,4625
+humanize/locale/ar/LC_MESSAGES/humanize.mo,sha256=eFh_sqyVD47W3cHxJcHwJBM4qbdP2nBI9QXjZnw3BBk,3856
+humanize/locale/ar/LC_MESSAGES/humanize.po,sha256=2QWYaZhxAQukPl5RmBFNsC4yE-1DTP5JunSmf4RlDXg,6933
+humanize/locale/bn_BD/LC_MESSAGES/humanize.mo,sha256=6NB9epGOIUwSsUY7lUD-aW9IFAdLw1z_TGIZen1Fb9w,2399
+humanize/locale/bn_BD/LC_MESSAGES/humanize.po,sha256=sM2dzgpJ6n8unSxSwA0jpBd4ZbUphm2k96vim1aTIgo,5554
+humanize/locale/ca_ES/LC_MESSAGES/humanize.mo,sha256=veqJwGHEzymT-ott8nPopAm2SZ4wto3yJRzU8JGXIG8,3345
+humanize/locale/ca_ES/LC_MESSAGES/humanize.po,sha256=bjUvQssMTmw2rjYoeam2r13j4CP_Efu8txHS_XzTsjA,6489
+humanize/locale/da_DK/LC_MESSAGES/humanize.mo,sha256=m_IEC2ajKBYYw9Sh-_CwYIX0-vrwIHQ6nacChzInfOI,3524
+humanize/locale/da_DK/LC_MESSAGES/humanize.po,sha256=C693HAYkm-1kMZVDul5pWPD0i93yu-xNGgKHRnDT6Zs,6619
+humanize/locale/de_DE/LC_MESSAGES/humanize.mo,sha256=Evtv5Sz2GCNTW7S413xfqRC-hmPiz-uKOgh5m2Cyf78,3291
+humanize/locale/de_DE/LC_MESSAGES/humanize.po,sha256=rg0H3I7F7Bbto35yEATC1CL54vviXaRhJ_I60XG4-0I,6647
+humanize/locale/es_ES/LC_MESSAGES/humanize.mo,sha256=WRam8vl8OU2O76EkwQmhMVeliuZKO3W2_6zP9yp63W0,3466
+humanize/locale/es_ES/LC_MESSAGES/humanize.po,sha256=TT3ln5Dbf4ykXY-G5JffiBt96vOFhc2NbR1WTtgOpxU,6594
+humanize/locale/fa_IR/LC_MESSAGES/humanize.mo,sha256=42B1yDpYHdrnMVev01aEr_BaLlq-gMvh17CfjTM1HBI,4010
+humanize/locale/fa_IR/LC_MESSAGES/humanize.po,sha256=XW0FDUzPO3WbDwiaCusFe3t68SNkU3JIIB6JB1TmfVQ,7124
+humanize/locale/fi_FI/LC_MESSAGES/humanize.mo,sha256=5lleMFhHuP2dkg01BewxrLcPWBE-W8CdCNWSme1E1kI,3369
+humanize/locale/fi_FI/LC_MESSAGES/humanize.po,sha256=yMiEAY0Wjzum2MoXbGIqLc_jK7DvZrasg5Wxk7_R-uo,6697
+humanize/locale/fr_FR/LC_MESSAGES/humanize.mo,sha256=dPGlVRVq25z1w8AZwgZQUuAGlnwTr1fsHr0V3Ou-5QM,2645
+humanize/locale/fr_FR/LC_MESSAGES/humanize.po,sha256=9ykifaVg2d9KXBqimfyOfPkyrAUUXG9XqdkZKZA98H4,6905
+humanize/locale/id_ID/LC_MESSAGES/humanize.mo,sha256=6kl6Wh4ROJODFTkIbhV6UQ2JKT1inQn9lDxUeEepUTw,3005
+humanize/locale/id_ID/LC_MESSAGES/humanize.po,sha256=HXhSoHca2AXAvz4k6pNTzyfvoTr22AmYgoUsosmeE8U,6057
+humanize/locale/it_IT/LC_MESSAGES/humanize.mo,sha256=2l-5qYLpZXG4bn--WH_eCKStUaVHwQ8owWpU626fv_E,3188
+humanize/locale/it_IT/LC_MESSAGES/humanize.po,sha256=hPp_0Li-IIERDMasXr7BRWQixeDR2R5RUvZTHLFURhU,6565
+humanize/locale/ja_JP/LC_MESSAGES/humanize.mo,sha256=QaWCy6xeudjHEhJZmrStFghg-Lax9KC55JbhiG8AFE8,2457
+humanize/locale/ja_JP/LC_MESSAGES/humanize.po,sha256=KEJS3VWc0BupyLag-SVRXv4H7Y6lk8_Kx7eghJJQVUU,6107
+humanize/locale/ko_KR/LC_MESSAGES/humanize.mo,sha256=yDaJCpAY79DonnPJQcx0E8nqjuHJvmlv523Zgw-pjpg,2016
+humanize/locale/ko_KR/LC_MESSAGES/humanize.po,sha256=KyilkPrVkuDWkerBoTcQDkEzetatFoYYe9Q2wGjlp2Q,7019
+humanize/locale/nl_NL/LC_MESSAGES/humanize.mo,sha256=pUzwmGiXcgEgepNqS4KrRLbJnCG2uNdZdfzCu_HFSJw,3258
+humanize/locale/nl_NL/LC_MESSAGES/humanize.po,sha256=OMANrojN8tR5zdwEZywhRwdgo5JtSO3k9507CRhQ5CQ,6604
+humanize/locale/pl_PL/LC_MESSAGES/humanize.mo,sha256=bNeJCcc2gsI3K4_usa_imigYISzGofwsrZ7X7iiC6Pw,3621
+humanize/locale/pl_PL/LC_MESSAGES/humanize.po,sha256=hcGIIqwX9xIuuEW7zwZSjJIXSDxmnG2bG6ABD3w1HKY,7148
+humanize/locale/pt_BR/LC_MESSAGES/humanize.mo,sha256=lElhHaH6FWRwZWit5vs3kQmh5b0bQXYfRY6zqdVXm5U,3184
+humanize/locale/pt_BR/LC_MESSAGES/humanize.po,sha256=WJDyBf3REPuI49q-u6-Hf5KsIdQJELY000HfbtS4eEo,6524
+humanize/locale/pt_PT/LC_MESSAGES/humanize.mo,sha256=AFoTysVc89o2EMopIngkO7vdvYmQE5BmczaWN1sjQI0,3403
+humanize/locale/pt_PT/LC_MESSAGES/humanize.po,sha256=OMgvxGlwlR_xr0-1Hj-tNFKnSpPzihXN7Es1TWCoIyQ,6567
+humanize/locale/ru_RU/LC_MESSAGES/humanize.mo,sha256=i-go1a1XjSR-PpWHBlpOst7DhoY-XlLTDP-paFJ68yY,4538
+humanize/locale/ru_RU/LC_MESSAGES/humanize.po,sha256=38CGjLgWEe8Ci287EZVQbUynVd2nInFvSfBmUBlJ1AA,7906
+humanize/locale/sk_SK/LC_MESSAGES/humanize.mo,sha256=0_mdWYPZhFsPpx5hWEUweV5_MCuIgXJIhE0gBI7qw1Y,3540
+humanize/locale/sk_SK/LC_MESSAGES/humanize.po,sha256=lEKJqzVEMjOeQrE-U_x-g2oOvVPMBq36FVTLxH8Xe5w,7180
+humanize/locale/sl_SI/LC_MESSAGES/humanize.mo,sha256=scf8JQb2OCHRuZLDjaaX4Sta1E1p7ff4XGqXE5GuJP8,3979
+humanize/locale/sl_SI/LC_MESSAGES/humanize.po,sha256=suLp80dryZpMUDWqtm9M6pXFmaojKQKpoPv89UAbMzo,7618
+humanize/locale/sv_SE/LC_MESSAGES/humanize.mo,sha256=Z8Guy6d2Cf2PGW7LFB5FOe4fy3uX5zQCITchn-3t7Ss,3498
+humanize/locale/sv_SE/LC_MESSAGES/humanize.po,sha256=ZB9DAMEWT8MbpC_i-dTSZVZ-n3V67xTft1SDCi3P4Lc,6596
+humanize/locale/tr_TR/LC_MESSAGES/humanize.mo,sha256=fgdMjVbGMQpV1FuMs366OCh4oGAPzdHHWfVGynbQ00E,3151
+humanize/locale/tr_TR/LC_MESSAGES/humanize.po,sha256=hWmHZ1b65Sw0f89JJncRpqPo6IXVD7yXA4lrA37hrg0,6479
+humanize/locale/uk_UA/LC_MESSAGES/humanize.mo,sha256=1Dgq35RkIlF_fUFvV9kayXEZZoD7ceRsViCweUsrZSM,4188
+humanize/locale/uk_UA/LC_MESSAGES/humanize.po,sha256=4bHPUlV0Kc5hFK12wrlMl2PCkW9FWIzgSkxUv0OEXEM,7661
+humanize/locale/vi_VN/LC_MESSAGES/humanize.mo,sha256=qN3hRa5kdPw49HwB4W8aonaiuUDrjyj-CbLswcEUbFQ,3164
+humanize/locale/vi_VN/LC_MESSAGES/humanize.po,sha256=9vvoquJBsPT1Il9W_a6Nh2LL8dvxn_JaBJCM7hwLQeg,6920
+humanize/locale/zh_CN/LC_MESSAGES/humanize.mo,sha256=l5MDM8l9QHK0Q2Y_cpDYZmyklnQAqy-dPSbt8Od5MxM,3011
+humanize/locale/zh_CN/LC_MESSAGES/humanize.po,sha256=nhwY-JtHt-QZctgy_HU-W56qfaTkv6brObpEJu8M9vc,6359
+humanize/locale/zh_HK/LC_MESSAGES/humanize.mo,sha256=nNSSvh4RQ6WXm6aVInM4cIk1zY3PKuUx6r5f7smTW6w,3323
+humanize/locale/zh_HK/LC_MESSAGES/humanize.po,sha256=s7eEhwtRjjRds8LskIzmVqxTAEm7-7aUbk04s3Vp0eE,6495
+humanize/number.py,sha256=E9FdEOrcZ2f5IHVEeZKaFE5NnMm9KT_4TAuZl69zWZE,14489
+humanize/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+humanize/time.py,sha256=8damCbq1kXF-VojBfwPPRZB9JjX0oG4-25y8nTOiS4Y,18278

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/humanize-4.2.2.dist-info/WHEEL

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

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/humanize-4.2.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+humanize

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

@@ -0,0 +1,8 @@
+""" imageio_ffmpeg, FFMPEG wrapper for Python.
+"""
+
+# flake8: noqa
+
+from ._definitions import __version__
+from ._utils import get_ffmpeg_exe, get_ffmpeg_version
+from ._io import count_frames_and_secs, read_frames, write_frames

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/imageio_ffmpeg/_definitions.py

@@ -0,0 +1,50 @@
+import sys
+import struct
+
+__version__ = "0.4.7"
+
+
+def get_platform():
+    bits = struct.calcsize("P") * 8
+    if sys.platform.startswith("linux"):
+        return "linux{}".format(bits)
+    elif sys.platform.startswith("freebsd"):
+        return "freebsd{}".format(bits)
+    elif sys.platform.startswith("win"):
+        return "win{}".format(bits)
+    elif sys.platform.startswith("cygwin"):
+        return "win{}".format(bits)
+    elif sys.platform.startswith("darwin"):
+        return "osx{}".format(bits)
+    else:  # pragma: no cover
+        return None
+
+
+# The Linux static builds (https://johnvansickle.com/ffmpeg/) are build
+# for Linux kernels 2.6.32 and up (at the time of writing, ffmpeg v4.1).
+# This corresponds to CentOS 6. This means we should use manylinux2010 and not
+# manylinux1.
+# manylinux1: https://www.python.org/dev/peps/pep-0513
+# manylinux2010: https://www.python.org/dev/peps/pep-0571
+
+
+# Platform string -> ffmpeg filename
+FNAME_PER_PLATFORM = {
+    "osx64": "ffmpeg-osx64-v4.2.2",  # 10.10+
+    "win32": "ffmpeg-win32-v4.2.2.exe",  # Windows 7+
+    "win64": "ffmpeg-win64-v4.2.2.exe",
+    # "linux32": "ffmpeg-linux32-v4.2.2",
+    "linux64": "ffmpeg-linux64-v4.2.2",  # Kernel 3.2.0+
+    "linuxaarch64": "ffmpeg-linuxaarch64-v4.2.2",
+}
+
+osxplats = "macosx_10_9_intel.macosx_10_9_x86_64.macosx_10_10_intel.macosx_10_10_x86_64"
+
+# Wheel tag -> platform string
+WHEEL_BUILDS = {
+    "py3-none-manylinux2010_x86_64": "linux64",
+    "py3-none-manylinux2014_aarch64": "linuxaarch64",
+    "py3-none-" + osxplats: "osx64",
+    "py3-none-win32": "win32",
+    "py3-none-win_amd64": "win64",
+}

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/imageio_ffmpeg/_io.py

@@ -0,0 +1,683 @@
+import sys
+import time
+import pathlib
+import subprocess
+from functools import lru_cache
+from collections import defaultdict
+
+from ._utils import get_ffmpeg_exe, _popen_kwargs, logger
+from ._parsing import LogCatcher, parse_ffmpeg_header, cvsecs
+
+
+ISWIN = sys.platform.startswith("win")
+
+h264_encoder_preference = defaultdict(lambda: -1)
+# The libx264 was the default encoder for a longe time with imageio
+h264_encoder_preference["libx264"] = 100
+
+# Encoder with the nvidia graphics card dedicated hardware
+h264_encoder_preference["h264_nvenc"] = 90
+# Deprecated names for the same encoder
+h264_encoder_preference["nvenc_h264"] = 90
+h264_encoder_preference["nvenc"] = 90
+
+# vaapi provides hardware encoding with intel integrated graphics chipsets
+h264_encoder_preference["h264_vaapi"] = 80
+
+# openh264 is cisco's open source encoder
+h264_encoder_preference["libopenh264"] = 70
+
+h264_encoder_preference["libx264rgb"] = 50
+
+
+def ffmpeg_test_encoder(encoder):
+    # Use the null streams to validate if we can encode anything
+    # https://trac.ffmpeg.org/wiki/Null
+    cmd = [
+        _get_exe(),
+        "-hide_banner",
+        "-f",
+        "lavfi",
+        "-i",
+        "nullsrc=s=256x256:d=8",
+        "-vcodec",
+        encoder,
+        "-f",
+        "null",
+        "-",
+    ]
+    p = subprocess.run(
+        cmd,
+        stdin=subprocess.PIPE,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+    )
+    return p.returncode == 0
+
+
+def get_compiled_h264_encoders():
+    cmd = [_get_exe(), "-hide_banner", "-encoders"]
+    p = subprocess.run(
+        cmd,
+        stdin=subprocess.PIPE,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+    )
+    stdout = p.stdout.decode().replace("\r", "")
+    # 2022/04/08: hmaarrfk
+    # I couldn't find a good way to get the list of available encoders from
+    # the ffmpeg command
+    # The ffmpeg command return a table that looks like
+    # Notice the leading space at the very beginning
+    # On ubuntu with libffmpeg-nvenc-dev we get
+    # $ ffmpeg -hide_banner -encoders | grep -i h.264
+    #
+    # Encoders:
+    #  V..... = Video
+    #  A..... = Audio
+    #  S..... = Subtitle
+    #  .F.... = Frame-level multithreading
+    #  ..S... = Slice-level multithreading
+    #  ...X.. = Codec is experimental
+    #  ....B. = Supports draw_horiz_band
+    #  .....D = Supports direct rendering method 1
+    #  ------
+    #  V..... libx264              libx264 H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10 (codec h264)
+    #  V..... libx264rgb           libx264 H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10 RGB (codec h264)
+    #  V....D h264_nvenc           NVIDIA NVENC H.264 encoder (codec h264)
+    #  V..... h264_omx             OpenMAX IL H.264 video encoder (codec h264)
+    #  V..... h264_qsv             H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10 (Intel Quick Sync Video acceleration) (codec h264)
+    #  V..... h264_v4l2m2m         V4L2 mem2mem H.264 encoder wrapper (codec h264)
+    #  V....D h264_vaapi           H.264/AVC (VAAPI) (codec h264)
+    #  V..... nvenc                NVIDIA NVENC H.264 encoder (codec h264)
+    #  V..... nvenc_h264           NVIDIA NVENC H.264 encoder (codec h264)
+    #
+    # However, just because ffmpeg was compiled with the options enabled
+    # it doesn't mean that it will be successful
+    header_footer = stdout.split("------")
+    footer = header_footer[1].strip("\n")
+    encoders = []
+    for line in footer.split("\n"):
+        # Strip to remove any leading spaces
+        line = line.strip()
+        encoder = line.split(" ")[1]
+
+        if encoder in h264_encoder_preference:
+            # These encoders are known to support H.264
+            # We forcibly include them in case their description changes to
+            # not include the string "H.264"
+            encoders.append(encoder)
+        elif (line[0] == "V") and ("H.264" in line):
+            encoders.append(encoder)
+
+    encoders.sort(reverse=True, key=lambda x: h264_encoder_preference[x])
+    if "h264_nvenc" in encoders:
+        # Remove deprecated names for the same encoder
+        for encoder in ["nvenc", "nvenc_h264"]:
+            if encoder in encoders:
+                encoders.remove(encoder)
+    # Return an immutable tuple to avoid users corrupting the lru_cache
+    return tuple(encoders)
+
+
+@lru_cache()
+def get_first_available_h264_encoder():
+    compiled_encoders = get_compiled_h264_encoders()
+    for encoder in compiled_encoders:
+        if ffmpeg_test_encoder(encoder):
+            return encoder
+    else:
+        raise RuntimeError(
+            "No valid H.264 encoder was found with the ffmpeg installation"
+        )
+
+
+@lru_cache()
+def _get_exe():
+    return get_ffmpeg_exe()
+
+
+def count_frames_and_secs(path):
+    """
+    Get the number of frames and number of seconds for the given video
+    file. Note that this operation can be quite slow for large files.
+
+    Disclaimer: I've seen this produce different results from actually reading
+    the frames with older versions of ffmpeg (2.x). Therefore I cannot say
+    with 100% certainty that the returned values are always exact.
+    """
+    # https://stackoverflow.com/questions/2017843/fetch-frame-count-with-ffmpeg
+
+    if isinstance(path, pathlib.PurePath):
+        path = str(path)
+    if not isinstance(path, str):
+        raise TypeError("Video path must be a string or pathlib.Path.")
+
+    cmd = [_get_exe(), "-i", path, "-map", "0:v:0", "-c", "copy", "-f", "null", "-"]
+    try:
+        out = subprocess.check_output(cmd, stderr=subprocess.STDOUT, **_popen_kwargs())
+    except subprocess.CalledProcessError as err:
+        out = err.output.decode(errors="ignore")
+        raise RuntimeError("FFMEG call failed with {}:\n{}".format(err.returncode, out))
+
+    # Note that other than with the subprocess calls below, ffmpeg wont hang here.
+    # Worst case Python will stop/crash and ffmpeg will continue running until done.
+
+    nframes = nsecs = None
+    for line in reversed(out.splitlines()):
+        if line.startswith(b"frame="):
+            line = line.decode(errors="ignore")
+            i = line.find("frame=")
+            if i >= 0:
+                s = line[i:].split("=", 1)[-1].lstrip().split(" ", 1)[0].strip()
+                nframes = int(s)
+            i = line.find("time=")
+            if i >= 0:
+                s = line[i:].split("=", 1)[-1].lstrip().split(" ", 1)[0].strip()
+                nsecs = cvsecs(*s.split(":"))
+            return nframes, nsecs
+
+    raise RuntimeError("Could not get number of frames")  # pragma: no cover
+
+
+def read_frames(
+    path,
+    pix_fmt="rgb24",
+    bpp=None,
+    input_params=None,
+    output_params=None,
+    bits_per_pixel=None,
+):
+    """
+    Create a generator to iterate over the frames in a video file.
+
+    It first yields a small metadata dictionary that contains:
+
+    * ffmpeg_version: the ffmpeg version in use (as a string).
+    * codec: a hint about the codec used to encode the video, e.g. "h264".
+    * source_size: the width and height of the encoded video frames.
+    * size: the width and height of the frames that will be produced.
+    * fps: the frames per second. Can be zero if it could not be detected.
+    * duration: duration in seconds. Can be zero if it could not be detected.
+
+    After that, it yields frames until the end of the video is reached. Each
+    frame is a bytes object.
+
+    This function makes no assumptions about the number of frames in
+    the data. For one because this is hard to predict exactly, but also
+    because it may depend on the provided output_params. If you want
+    to know the number of frames in a video file, use count_frames_and_secs().
+    It is also possible to estimate the number of frames from the fps and
+    duration, but note that even if both numbers are present, the resulting
+    value is not always correct.
+
+    Example:
+
+        gen = read_frames(path)
+        meta = gen.__next__()
+        for frame in gen:
+            print(len(frame))
+
+    Parameters:
+        path (str): the filename of the file to read from.
+        pix_fmt (str): the pixel format of the frames to be read.
+            The default is "rgb24" (frames are uint8 RGB images).
+        input_params (list): Additional ffmpeg input command line parameters.
+        output_params (list): Additional ffmpeg output command line parameters.
+        bits_per_pixel (int): The number of bits per pixel in the output frames.
+            This depends on the given pix_fmt. Default is 24 (RGB)
+        bpp (int): DEPRECATED, USE bits_per_pixel INSTEAD. The number of bytes per pixel in the output frames.
+            This depends on the given pix_fmt. Some pixel formats like yuv420p have 12 bits per pixel
+            and cannot be set in bytes as integer. For this reason the bpp argument is deprecated.
+    """
+
+    # ----- Input args
+
+    if isinstance(path, pathlib.PurePath):
+        path = str(path)
+    if not isinstance(path, str):
+        raise TypeError("Video path must be a string or pathlib.Path.")
+    # Note: Dont check whether it exists. The source could be e.g. a camera.
+
+    pix_fmt = pix_fmt or "rgb24"
+    bpp = bpp or 3
+    bits_per_pixel = bits_per_pixel or bpp * 8
+    input_params = input_params or []
+    output_params = output_params or []
+
+    assert isinstance(pix_fmt, str), "pix_fmt must be a string"
+    assert isinstance(bits_per_pixel, int), "bpp and bits_per_pixel must be an int"
+    assert isinstance(input_params, list), "input_params must be a list"
+    assert isinstance(output_params, list), "output_params must be a list"
+
+    # ----- Prepare
+
+    pre_output_params = ["-pix_fmt", pix_fmt, "-vcodec", "rawvideo", "-f", "image2pipe"]
+
+    cmd = [_get_exe()]
+    cmd += input_params + ["-i", path]
+    cmd += pre_output_params + output_params + ["-"]
+
+    p = subprocess.Popen(
+        cmd,
+        stdin=subprocess.PIPE,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        **_popen_kwargs(prevent_sigint=True)
+    )
+
+    log_catcher = LogCatcher(p.stderr)
+
+    # Init policy by which to terminate ffmpeg. May be set to "kill" later.
+    stop_policy = "timeout"  # not wait; ffmpeg should be able to quit quickly
+
+    # Enter try block directly after opening the process.
+    # We terminate ffmpeg in the finally clause.
+    # Generators are automatically closed when they get deleted,
+    # so the finally block is guaranteed to run.
+    try:
+
+        # ----- Load meta data
+
+        # Wait for the log catcher to get the meta information
+        etime = time.time() + 10.0
+        while log_catcher.is_alive() and not log_catcher.header and time.time() < etime:
+            time.sleep(0.01)
+
+        # Check whether we have the information
+        if not log_catcher.header:
+            err2 = log_catcher.get_text(0.2)
+            fmt = "Could not load meta information\n=== stderr ===\n{}"
+            raise IOError(fmt.format(err2))
+        elif "No such file or directory" in log_catcher.header:
+            raise IOError("{} not found! Wrong path?".format(path))
+
+        meta = parse_ffmpeg_header(log_catcher.header)
+        yield meta
+
+        # ----- Read frames
+
+        w, h = meta["size"]
+        framesize_bits = w * h * bits_per_pixel
+        framesize_bytes = framesize_bits / 8
+        assert (
+            framesize_bytes.is_integer()
+        ), "incorrect bits_per_pixel, framesize in bytes must be an int"
+        framesize_bytes = int(framesize_bytes)
+        framenr = 0
+
+        while True:
+            framenr += 1
+            try:
+                bb = bytes()
+                while len(bb) < framesize_bytes:
+                    extra_bytes = p.stdout.read(framesize_bytes - len(bb))
+                    if not extra_bytes:
+                        if len(bb) == 0:
+                            return
+                        else:
+                            raise RuntimeError(
+                                "End of file reached before full frame could be read."
+                            )
+                    bb += extra_bytes
+                yield bb
+            except Exception as err:
+                err1 = str(err)
+                err2 = log_catcher.get_text(0.4)
+                fmt = "Could not read frame {}:\n{}\n=== stderr ===\n{}"
+                raise RuntimeError(fmt.format(framenr, err1, err2))
+
+    except GeneratorExit:
+        # Note that GeneratorExit does not inherit from Exception but BaseException
+        pass
+
+    except Exception:
+        # Normal exceptions fall through
+        raise
+
+    except BaseException:
+        # Detect KeyboardInterrupt / SystemExit: don't wait for ffmpeg to quit
+        stop_policy = "kill"
+        raise
+
+    finally:
+        # Stop the LogCatcher thread, which reads from stderr.
+        log_catcher.stop_me()
+
+        # Make sure that ffmpeg is terminated.
+        if p.poll() is None:
+
+            # Ask ffmpeg to quit
+            try:
+                # I read somewhere that modern ffmpeg on Linux prefers a
+                # "ctrl-c", but tests so far suggests sending q is more robust.
+                # > p.send_signal(signal.SIGINT)
+                # Sending q via communicate works, but can hang (see #17)
+                # > p.communicate(b"q")
+                # So let's do similar to what communicate does, but without
+                # reading stdout (which may block). It looks like only closing
+                # stdout is enough (tried Windows+Linux), but let's play safe.
+                # Found that writing to stdin can cause "Invalid argument" on
+                # Windows # and "Broken Pipe" on Unix.
+                # p.stdin.write(b"q")  # commented out in v0.4.1
+                p.stdout.close()
+                p.stdin.close()
+                # p.stderr.close() -> not here, the log_catcher closes it
+            except Exception as err:  # pragma: no cover
+                logger.warning("Error while attempting stop ffmpeg (r): " + str(err))
+
+            if stop_policy == "timeout":
+                # Wait until timeout, produce a warning and kill if it still exists
+                try:
+                    etime = time.time() + 1.5
+                    while time.time() < etime and p.poll() is None:
+                        time.sleep(0.01)
+                finally:
+                    if p.poll() is None:  # pragma: no cover
+                        logger.warning("We had to kill ffmpeg to stop it.")
+                        p.kill()
+
+            else:  # stop_policy == "kill"
+                # Just kill it
+                p.kill()
+
+
+def write_frames(
+    path,
+    size,
+    pix_fmt_in="rgb24",
+    pix_fmt_out="yuv420p",
+    fps=16,
+    quality=5,
+    bitrate=None,
+    codec=None,
+    macro_block_size=16,
+    ffmpeg_log_level="warning",
+    ffmpeg_timeout=None,
+    input_params=None,
+    output_params=None,
+    audio_path=None,
+    audio_codec=None,
+):
+    """
+    Create a generator to write frames (bytes objects) into a video file.
+
+    The frames are written by using the generator's `send()` method. Frames
+    can be anything that can be written to a file. Typically these are
+    bytes objects, but c-contiguous Numpy arrays also work.
+
+    Example:
+
+        gen = write_frames(path, size)
+        gen.send(None)  # seed the generator
+        for frame in frames:
+            gen.send(frame)
+        gen.close()  # don't forget this
+
+    Parameters:
+        path (str): the filename to write to.
+        size (tuple): the width and height of the frames.
+        pix_fmt_in (str): the pixel format of incoming frames.
+            E.g. "gray", "gray8a", "rgb24", or "rgba". Default "rgb24".
+        pix_fmt_out (str): the pixel format to store frames. Default yuv420p".
+        fps (float): The frames per second. Default 16.
+        quality (float): A measure for quality between 0 and 10. Default 5.
+            Ignored if bitrate is given.
+        bitrate (str): The bitrate, e.g. "192k". The defaults are pretty good.
+        codec (str): The codec. Default "libx264" for .mp4 (if available from
+            the ffmpeg executable) or "msmpeg4" for .wmv.
+        macro_block_size (int): You probably want to align the size of frames
+            to this value to avoid image resizing. Default 16. Can be set
+            to 1 to avoid block alignment, though this is not recommended.
+        ffmpeg_log_level (str): The ffmpeg logging level. Default "warning".
+        ffmpeg_timeout (float): Timeout in seconds to wait for ffmpeg process
+            to finish. Value of 0 or None will wait forever (default). The time that
+            ffmpeg needs depends on CPU speed, compression, and frame size.
+        input_params (list): Additional ffmpeg input command line parameters.
+        output_params (list): Additional ffmpeg output command line parameters.
+        audio_path (str): A input file path for encoding with an audio stream.
+            Default None, no audio.
+        audio_codec (str): The audio codec to use if audio_path is provided.
+            "copy" will try to use audio_path's audio codec without re-encoding.
+            Default None, but some formats must have certain codecs specified.
+    """
+
+    # ----- Input args
+
+    if isinstance(path, pathlib.PurePath):
+        path = str(path)
+    if not isinstance(path, str):
+        raise TypeError("Video path must be a string or pathlib.Path.")
+
+    # The pix_fmt_out yuv420p is the best for the outpur to work in
+    # QuickTime and most other players. These players only support
+    # the YUV planar color space with 4:2:0 chroma subsampling for
+    # H.264 video. Otherwise, depending on the source, ffmpeg may
+    # output to a pixel format that may be incompatible with these
+    # players. See https://trac.ffmpeg.org/wiki/Encode/H.264#Encodingfordumbplayers
+
+    pix_fmt_in = pix_fmt_in or "rgb24"
+    pix_fmt_out = pix_fmt_out or "yuv420p"
+    fps = fps or 16
+    # bitrate, codec, macro_block_size can all be None or ...
+    macro_block_size = macro_block_size or 16
+    ffmpeg_log_level = ffmpeg_log_level or "warning"
+    input_params = input_params or []
+    output_params = output_params or []
+    ffmpeg_timeout = ffmpeg_timeout or 0
+
+    floatish = float, int
+    if isinstance(size, (tuple, list)):
+        assert len(size) == 2, "size must be a 2-tuple"
+        assert isinstance(size[0], int) and isinstance(
+            size[1], int
+        ), "size must be ints"
+        sizestr = "{:d}x{:d}".format(*size)
+    # elif isinstance(size, str):
+    #     assert "x" in size, "size as string must have format NxM"
+    #     sizestr = size
+    else:
+        assert False, "size must be str or tuple"
+    assert isinstance(pix_fmt_in, str), "pix_fmt_in must be str"
+    assert isinstance(pix_fmt_out, str), "pix_fmt_out must be str"
+    assert isinstance(fps, floatish), "fps must be float"
+    if quality is not None:
+        assert isinstance(quality, floatish), "quality must be float"
+        assert 1 <= quality <= 10, "quality must be between 1 and 10 inclusive"
+    assert isinstance(macro_block_size, int), "macro_block_size must be int"
+    assert isinstance(ffmpeg_log_level, str), "ffmpeg_log_level must be str"
+    assert isinstance(ffmpeg_timeout, floatish), "ffmpeg_timeout must be float"
+    assert isinstance(input_params, list), "input_params must be a list"
+    assert isinstance(output_params, list), "output_params must be a list"
+
+    # ----- Prepare
+
+    # Get parameters
+    if not codec:
+        if path.lower().endswith(".wmv"):
+            # This is a safer default codec on windows to get videos that
+            # will play in powerpoint and other apps. H264 is not always
+            # available on windows.
+            codec = "msmpeg4"
+        else:
+            codec = get_first_available_h264_encoder()
+
+    audio_params = ["-an"]
+    if audio_path is not None and not path.lower().endswith(".gif"):
+        audio_params = ["-i", audio_path]
+        if audio_codec is not None:
+            output_params += ["-acodec", audio_codec]
+        output_params += ["-map", "0:v:0", "-map", "1:a:0"]
+
+    # Get command
+    cmd = [_get_exe(), "-y", "-f", "rawvideo", "-vcodec", "rawvideo", "-s", sizestr]
+    cmd += ["-pix_fmt", pix_fmt_in, "-r", "{:.02f}".format(fps)] + input_params
+    cmd += ["-i", "-"] + audio_params
+    cmd += ["-vcodec", codec, "-pix_fmt", pix_fmt_out]
+
+    # Add fixed bitrate or variable bitrate compression flags
+    if bitrate is not None:
+        cmd += ["-b:v", str(bitrate)]
+    elif quality is not None:  # If None, then we don't add anything
+        quality = 1 - quality / 10.0
+        if codec == "libx264":
+            # crf ranges 0 to 51, 51 being worst.
+            quality = int(quality * 51)
+            cmd += ["-crf", str(quality)]  # for h264
+        else:  # Many codecs accept q:v
+            # q:v range can vary, 1-31, 31 being worst
+            # But q:v does not always have the same range.
+            # May need a way to find range for any codec.
+            quality = int(quality * 30) + 1
+            cmd += ["-qscale:v", str(quality)]  # for others
+
+    # Note, for most codecs, the image dimensions must be divisible by
+    # 16 the default for the macro_block_size is 16. Check if image is
+    # divisible, if not have ffmpeg upsize to nearest size and warn
+    # user they should correct input image if this is not desired.
+    if macro_block_size > 1:
+        if size[0] % macro_block_size > 0 or size[1] % macro_block_size > 0:
+            out_w = size[0]
+            out_h = size[1]
+            if size[0] % macro_block_size > 0:
+                out_w += macro_block_size - (size[0] % macro_block_size)
+            if size[1] % macro_block_size > 0:
+                out_h += macro_block_size - (size[1] % macro_block_size)
+            cmd += ["-vf", "scale={}:{}".format(out_w, out_h)]
+            logger.warning(
+                "IMAGEIO FFMPEG_WRITER WARNING: input image is not"
+                " divisible by macro_block_size={}, resizing from {} "
+                "to {} to ensure video compatibility with most codecs "
+                "and players. To prevent resizing, make your input "
+                "image divisible by the macro_block_size or set the "
+                "macro_block_size to 1 (risking incompatibility).".format(
+                    macro_block_size, size[:2], (out_w, out_h)
+                )
+            )
+
+    # Rather than redirect stderr to a pipe, just set minimal
+    # output from ffmpeg by default. That way if there are warnings
+    # the user will see them.
+    cmd += ["-v", ffmpeg_log_level]
+    cmd += output_params
+    cmd.append(path)
+    cmd_str = " ".join(cmd)
+    if any(
+        [level in ffmpeg_log_level for level in ("info", "verbose", "debug", "trace")]
+    ):
+        logger.info("RUNNING FFMPEG COMMAND: " + cmd_str)
+
+    # Launch process
+    p = subprocess.Popen(
+        cmd,
+        stdin=subprocess.PIPE,
+        stdout=subprocess.PIPE,
+        stderr=None,
+        **_popen_kwargs(prevent_sigint=True)
+    )
+
+    # Note that directing stderr to a pipe on windows will cause ffmpeg
+    # to hang if the buffer is not periodically cleared using
+    # StreamCatcher or other means.
+    # Setting bufsize to 0 or a small value does not seem to have much effect
+    # (tried on Windows and Linux). I suspect that ffmpeg buffers
+    # multiple frames (before encoding in a batch).
+
+    # Init policy by which to terminate ffmpeg. May be set to "kill" later.
+    stop_policy = "timeout"
+    if not ffmpeg_timeout:
+        stop_policy = "wait"
+
+    # ----- Write frames
+
+    # Enter try block directly after opening the process.
+    # We terminate ffmpeg in the finally clause.
+    # Generators are automatically closed when they get deleted,
+    # so the finally block is guaranteed to run.
+    try:
+
+        # Just keep going until the generator.close() is called (raises GeneratorExit).
+        # This could also happen when the generator is deleted somehow.
+        nframes = 0
+        while True:
+
+            # Get frame
+            bb = yield
+
+            # framesize = size[0] * size[1] * depth * bpp
+            # assert isinstance(bb, bytes), "Frame must be send as bytes"
+            # assert len(bb) == framesize, "Frame must have width*height*depth*bpp bytes"
+            # Actually, we accept anything that can be written to file.
+            # This e.g. allows writing numpy arrays without having to make a copy ...
+
+            # Write
+            try:
+                p.stdin.write(bb)
+            except Exception as err:
+                # Show the command and stderr from pipe
+                msg = (
+                    "{0:}\n\nFFMPEG COMMAND:\n{1:}\n\nFFMPEG STDERR "
+                    "OUTPUT:\n".format(err, cmd_str)
+                )
+                raise IOError(msg)
+
+            nframes += 1
+
+    except GeneratorExit:
+        # Note that GeneratorExit does not inherit from Exception but BaseException
+        # Detect premature closing
+        if nframes == 0:
+            logger.warning("No frames have been written; the written video is invalid.")
+
+    except Exception:
+        # Normal exceptions fall through
+        raise
+
+    except BaseException:
+        # Detect KeyboardInterrupt / SystemExit: don't wait for ffmpeg to quit
+        stop_policy = "kill"
+        raise
+
+    finally:
+
+        # Make sure that ffmpeg is terminated.
+        if p.poll() is None:
+
+            # Tell ffmpeg that we're done
+            try:
+                p.stdin.close()
+            except Exception as err:  # pragma: no cover
+                logger.warning("Error while attempting stop ffmpeg (w): " + str(err))
+
+            if stop_policy == "timeout":
+                # Wait until timeout, produce a warning and kill if it still exists
+                try:
+                    etime = time.time() + ffmpeg_timeout
+                    while (time.time() < etime) and p.poll() is None:
+                        time.sleep(0.01)
+                finally:
+                    if p.poll() is None:  # pragma: no cover
+                        logger.warning(
+                            "We had to kill ffmpeg to stop it. "
+                            + "Consider increasing ffmpeg_timeout, "
+                            + "or setting it to zero (no timeout)."
+                        )
+                        p.kill()
+
+            elif stop_policy == "wait":
+                # Wait forever, kill if it if we're interrupted
+                try:
+                    while p.poll() is None:
+                        time.sleep(0.01)
+                finally:  # the above can raise e.g. by ctrl-c or systemexit
+                    if p.poll() is None:  # pragma: no cover
+                        p.kill()
+
+            else:  #  stop_policy == "kill":
+                # Just kill it
+                p.kill()
+        # Just to be safe, wrap in try/except
+        try:
+            p.stdout.close()
+        except Exception:
+            pass

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/imageio_ffmpeg/_parsing.py

@@ -0,0 +1,201 @@
+import re
+import time
+import threading
+
+from ._utils import logger
+
+
+class LogCatcher(threading.Thread):
+    """Thread to keep reading from stderr so that the buffer does not
+    fill up and stalls the ffmpeg process. On stderr a message is send
+    on every few frames with some meta information. We only keep the
+    last ones.
+    """
+
+    def __init__(self, file):
+        self._file = file
+        self._header = ""
+        self._lines = []
+        self._remainder = b""
+        threading.Thread.__init__(self)
+        self.daemon = True  # do not let this thread hold up Python shutdown
+        self._should_stop = False
+        self.start()
+
+    def stop_me(self):
+        self._should_stop = True
+
+    @property
+    def header(self):
+        """Get header text. Empty string if the header is not yet parsed."""
+        return self._header
+
+    def get_text(self, timeout=0):
+        """Get the whole text written to stderr so far. To preserve
+        memory, only the last 50 to 100 frames are kept.
+
+        If a timeout is given, wait for this thread to finish. When
+        something goes wrong, we stop ffmpeg and want a full report of
+        stderr, but this thread might need a tiny bit more time.
+        """
+
+        # Wait?
+        if timeout > 0:
+            etime = time.time() + timeout
+            while self.is_alive() and time.time() < etime:  # pragma: no cover
+                time.sleep(0.01)
+        # Return str
+        lines = b"\n".join(self._lines)
+        return self._header + "\n" + lines.decode("utf-8", "ignore")
+
+    def run(self):
+
+        # Create ref here so it still exists even if Py is shutting down
+        limit_lines_local = limit_lines
+
+        while not self._should_stop:
+            time.sleep(0)
+            # Read one line. Detect when closed, and exit
+            try:
+                line = self._file.read(20)
+            except ValueError:  # pragma: no cover
+                break
+            if not line:
+                break
+            # Process to divide in lines
+            line = line.replace(b"\r", b"\n").replace(b"\n\n", b"\n")
+            lines = line.split(b"\n")
+            lines[0] = self._remainder + lines[0]
+            self._remainder = lines.pop(-1)
+            # Process each line
+            self._lines.extend(lines)
+            if not self._header:
+                if get_output_video_line(self._lines):
+                    header = b"\n".join(self._lines)
+                    self._header += header.decode("utf-8", "ignore")
+            elif self._lines:
+                self._lines = limit_lines_local(self._lines)
+
+        # Close the file when we're done
+        # See #61 and #69
+        try:
+            self._file.close()
+        except Exception:
+            pass
+
+
+def get_output_video_line(lines):
+    """Get the line that defines the video stream that ffmpeg outputs,
+    and which we read.
+    """
+    in_output = False
+    for line in lines:
+        sline = line.lstrip()
+        if sline.startswith(b"Output "):
+            in_output = True
+        elif in_output:
+            if sline.startswith(b"Stream ") and b" Video:" in sline:
+                return line
+
+
+def limit_lines(lines, N=32):
+    """When number of lines > 2*N, reduce to N."""
+    if len(lines) > 2 * N:
+        lines = [b"... showing only last few lines ..."] + lines[-N:]
+    return lines
+
+
+def cvsecs(*args):
+    """converts a time to second. Either cvsecs(min, secs) or
+    cvsecs(hours, mins, secs).
+    """
+    if len(args) == 1:
+        return float(args[0])
+    elif len(args) == 2:
+        return 60 * float(args[0]) + float(args[1])
+    elif len(args) == 3:
+        return 3600 * float(args[0]) + 60 * float(args[1]) + float(args[2])
+
+
+def parse_ffmpeg_header(text):
+    lines = text.splitlines()
+    meta = {}
+
+    # meta["header"] = text  # Can enable this for debugging
+
+    # Get version
+    ver = lines[0].split("version", 1)[-1].split("Copyright")[0]
+    meta["ffmpeg_version"] = ver.strip() + " " + lines[1].strip()
+
+    # get the output line that speaks about video
+    videolines = [
+        l for l in lines if l.lstrip().startswith("Stream ") and " Video: " in l
+    ]
+
+    # Codec and pix_fmt hint
+    line = videolines[0]
+    meta["codec"] = line.split("Video: ", 1)[-1].lstrip().split(" ", 1)[0].strip()
+    meta["pix_fmt"] = line.split("Video: ", 1)[-1].split(",")[1].strip()
+
+    # get the output line that speaks about audio
+    audiolines = [
+        l for l in lines if l.lstrip().startswith("Stream ") and " Audio: " in l
+    ]
+
+    if len(audiolines) > 0:
+        audio_line = audiolines[0]
+        meta["audio_codec"] = (
+            audio_line.split("Audio: ", 1)[-1].lstrip().split(" ", 1)[0].strip()
+        )
+
+    # get the frame rate.
+    # matches can be empty, see #171, assume nframes = inf
+    # the regexp omits values of "1k tbr" which seems a specific edge-case #262
+    # it seems that tbr is generally to be preferred #262
+    fps = 0
+    for line in (videolines[0], videolines[-1]):
+        matches = re.findall(r" ([0-9]+\.?[0-9]*) (tbr|fps)", line)
+        matches.sort(key=lambda x: x[1] == "tbr", reverse=True)
+        if matches:
+            fps = float(matches[0][0].strip())
+    meta["fps"] = fps
+
+    # get the size of the original stream, of the form 460x320 (w x h)
+    line = videolines[0]
+    match = re.search(" [0-9]*x[0-9]*(,| )", line)
+    parts = line[match.start() : match.end() - 1].split("x")
+    meta["source_size"] = tuple(map(int, parts))
+
+    # get the size of what we receive, of the form 460x320 (w x h)
+    line = videolines[-1]  # Pipe output
+    match = re.search(" [0-9]*x[0-9]*(,| )", line)
+    parts = line[match.start() : match.end() - 1].split("x")
+    meta["size"] = tuple(map(int, parts))
+
+    # Check the two sizes
+    if meta["source_size"] != meta["size"]:
+        logger.warning(
+            "The frame size for reading {} is "
+            "different from the source frame size {}.".format(
+                meta["size"], meta["source_size"]
+            )
+        )
+
+    # get the rotate metadata
+    reo_rotate = re.compile("rotate\s+:\s([0-9]+)")
+    match = reo_rotate.search(text)
+    rotate = 0
+    if match is not None:
+        rotate = match.groups()[0]
+    meta["rotate"] = int(rotate)
+
+    # get duration (in seconds)
+    line = [l for l in lines if "Duration: " in l][0]
+    match = re.search(" [0-9][0-9]:[0-9][0-9]:[0-9][0-9].[0-9][0-9]", line)
+    duration = 0
+    if match is not None:
+        hms = line[match.start() + 1 : match.end()].split(":")
+        duration = cvsecs(*hms)
+    meta["duration"] = duration
+
+    return meta

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/imageio_ffmpeg/_utils.py

@@ -0,0 +1,105 @@
+import os
+import sys
+import logging
+import subprocess
+from pkg_resources import resource_filename
+
+from ._definitions import get_platform, FNAME_PER_PLATFORM
+
+logger = logging.getLogger("imageio_ffmpeg")
+
+
+def get_ffmpeg_exe():
+    """
+    Get the ffmpeg executable file. This can be the binary defined by
+    the IMAGEIO_FFMPEG_EXE environment variable, the binary distributed
+    with imageio-ffmpeg, an ffmpeg binary installed with conda, or the
+    system ffmpeg (in that order). A RuntimeError is raised if no valid
+    ffmpeg could be found.
+    """
+
+    # 1. Try environment variable. - Dont test it: the user is explicit here!
+    exe = os.getenv("IMAGEIO_FFMPEG_EXE", None)
+    if exe:
+        return exe
+
+    plat = get_platform()
+
+    # 2. Try from here
+    bin_dir = resource_filename("imageio_ffmpeg", "binaries")
+    exe = os.path.join(bin_dir, FNAME_PER_PLATFORM.get(plat, ""))
+    if exe and os.path.isfile(exe) and _is_valid_exe(exe):
+        return exe
+
+    # 3. Try binary from conda package
+    # (installed e.g. via `conda install ffmpeg -c conda-forge`)
+    if plat.startswith("win"):
+        exe = os.path.join(sys.prefix, "Library", "bin", "ffmpeg.exe")
+    else:
+        exe = os.path.join(sys.prefix, "bin", "ffmpeg")
+    if exe and os.path.isfile(exe) and _is_valid_exe(exe):
+        return exe
+
+    # 4. Try system ffmpeg command
+    exe = "ffmpeg"
+    if _is_valid_exe(exe):
+        return exe
+
+    # Nothing was found
+    raise RuntimeError(
+        "No ffmpeg exe could be found. Install ffmpeg on your system, "
+        "or set the IMAGEIO_FFMPEG_EXE environment variable."
+    )
+
+
+def _popen_kwargs(prevent_sigint=False):
+    startupinfo = None
+    preexec_fn = None
+    creationflags = 0
+    if sys.platform.startswith("win"):
+        # Stops executable from flashing on Windows (see #22)
+        startupinfo = subprocess.STARTUPINFO()
+        startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
+    if prevent_sigint:
+        # Prevent propagation of sigint (see #4)
+        # https://stackoverflow.com/questions/5045771
+        if sys.platform.startswith("win"):
+            creationflags = 0x00000200
+        else:
+            preexec_fn = os.setpgrp  # the _pre_exec does not seem to work
+
+    falsy = ("", "0", "false", "no")
+    if os.getenv("IMAGEIO_FFMPEG_NO_PREVENT_SIGINT", "").lower() not in falsy:
+        # Unset preexec_fn to work around a strange hang on fork() (see #58)
+        preexec_fn = None
+
+    return {
+        "startupinfo": startupinfo,
+        "creationflags": creationflags,
+        "preexec_fn": preexec_fn,
+    }
+
+
+def _is_valid_exe(exe):
+    cmd = [exe, "-version"]
+    try:
+        with open(os.devnull, "w") as null:
+            subprocess.check_call(
+                cmd, stdout=null, stderr=subprocess.STDOUT, **_popen_kwargs()
+            )
+        return True
+    except (OSError, ValueError, subprocess.CalledProcessError):
+        return False
+
+
+def get_ffmpeg_version():
+    """
+    Get the version of the used ffmpeg executable (as a string).
+    """
+    exe = get_ffmpeg_exe()
+    line = subprocess.check_output([exe, "-version"], **_popen_kwargs()).split(
+        b"\n", 1
+    )[0]
+    line = line.decode(errors="ignore").strip()
+    version = line.split("version", 1)[-1].lstrip().split(" ", 1)[0].strip()
+    return version

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/opencv_python-4.9.0.80.dist-info/INSTALLER

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

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/opencv_python-4.9.0.80.dist-info/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Olli-Pekka Heinisuo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/opencv_python-4.9.0.80.dist-info/METADATA

@@ -0,0 +1,305 @@
+Metadata-Version: 2.1
+Name: opencv-python
+Version: 4.9.0.80
+Summary: Wrapper package for OpenCV python bindings.
+Home-page: https://github.com/opencv/opencv-python
+Maintainer: OpenCV Team
+License: Apache 2.0
+Platform: UNKNOWN
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Information Technology
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: Unix
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: C++
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Image Recognition
+Classifier: Topic :: Software Development
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE-3RD-PARTY.txt
+License-File: LICENSE.txt
+Requires-Dist: numpy >=1.13.3 ; python_version < "3.7"
+Requires-Dist: numpy >=1.21.0 ; python_version <= "3.9" and platform_system == "Darwin" and platform_machine == "arm64"
+Requires-Dist: numpy >=1.21.2 ; python_version >= "3.10"
+Requires-Dist: numpy >=1.21.4 ; python_version >= "3.10" and platform_system == "Darwin"
+Requires-Dist: numpy >=1.23.5 ; python_version >= "3.11"
+Requires-Dist: numpy >=1.26.0 ; python_version >= "3.12"
+Requires-Dist: numpy >=1.19.3 ; python_version >= "3.6" and platform_system == "Linux" and platform_machine == "aarch64"
+Requires-Dist: numpy >=1.17.0 ; python_version >= "3.7"
+Requires-Dist: numpy >=1.17.3 ; python_version >= "3.8"
+Requires-Dist: numpy >=1.19.3 ; python_version >= "3.9"
+
+[![Downloads](https://static.pepy.tech/badge/opencv-python)](http://pepy.tech/project/opencv-python)
+
+### Keep OpenCV Free
+
+OpenCV is raising funds to keep the library free for everyone, and we need the support of the entire community to do it. [Donate to OpenCV on IndieGoGo](http://igg.me/at/opencv5) to show your support.
+
+- [OpenCV on Wheels](#opencv-on-wheels)
+  - [Installation and Usage](#installation-and-usage)
+- [Frequently Asked Questions](#frequently-asked-questions)
+- [Documentation for opencv-python](#documentation-for-opencv-python)
+  - [CI build process](#ci-build-process)
+  - [Manual builds](#manual-builds)
+    - [Manual debug builds](#manual-debug-builds)
+    - [Source distributions](#source-distributions)
+  - [Licensing](#licensing)
+  - [Versioning](#versioning)
+  - [Releases](#releases)
+  - [Development builds](#development-builds)
+  - [Manylinux wheels](#manylinux-wheels)
+  - [Supported Python versions](#supported-python-versions)
+  - [Backward compatibility](#backward-compatibility)
+
+## OpenCV on Wheels
+
+Pre-built CPU-only OpenCV packages for Python.
+
+Check the manual build section if you wish to compile the bindings from source to enable additional modules such as CUDA.
+
+### Installation and Usage
+
+1. If you have previous/other manually installed (= not installed via ``pip``) version of OpenCV installed (e.g. cv2 module in the root of Python's site-packages), remove it before installation to avoid conflicts.
+2. Make sure that your `pip` version is up-to-date (19.3 is the minimum supported version): `pip install --upgrade pip`. Check version with `pip -V`. For example Linux distributions ship usually with very old `pip` versions which cause a lot of unexpected problems especially with the `manylinux` format.
+3. Select the correct package for your environment:
+
+    There are four different packages (see options 1, 2, 3 and 4 below) and you should **SELECT ONLY ONE OF THEM**. Do not install multiple different packages in the same environment. There is no plugin architecture: all the packages use the same namespace (`cv2`). If you installed multiple different packages in the same environment, uninstall them all with ``pip uninstall`` and reinstall only one package.
+
+    **a.** Packages for standard desktop environments (Windows, macOS, almost any GNU/Linux distribution)
+
+    - Option 1 - Main modules package: ``pip install opencv-python``
+    - Option 2 - Full package (contains both main modules and contrib/extra modules): ``pip install opencv-contrib-python`` (check contrib/extra modules listing from [OpenCV documentation](https://docs.opencv.org/master/))
+
+    **b.** Packages for server (headless) environments (such as Docker, cloud environments etc.), no GUI library dependencies
+
+    These packages are smaller than the two other packages above because they do not contain any GUI functionality (not compiled with Qt / other GUI components). This means that the packages avoid a heavy dependency chain to X11 libraries and you will have for example smaller Docker images as a result. You should always use these packages if you do not use `cv2.imshow` et al. or you are using some other package (such as PyQt) than OpenCV to create your GUI.
+
+    - Option 3 - Headless main modules package: ``pip install opencv-python-headless``
+    - Option 4 - Headless full package (contains both main modules and contrib/extra modules): ``pip install opencv-contrib-python-headless`` (check contrib/extra modules listing from [OpenCV documentation](https://docs.opencv.org/master/))
+
+4. Import the package:
+
+    ``import cv2``
+
+    All packages contain Haar cascade files. ``cv2.data.haarcascades`` can be used as a shortcut to the data folder. For example:
+
+    ``cv2.CascadeClassifier(cv2.data.haarcascades + "haarcascade_frontalface_default.xml")``
+
+5. Read [OpenCV documentation](https://docs.opencv.org/master/)
+
+6. Before opening a new issue, read the FAQ below and have a look at the other issues which are already open.
+
+Frequently Asked Questions
+--------------------------
+
+**Q: Do I need to install also OpenCV separately?**
+
+A: No, the packages are special wheel binary packages and they already contain statically built OpenCV binaries.
+
+**Q: Pip install fails with ``ModuleNotFoundError: No module named 'skbuild'``?**
+
+Since ``opencv-python`` version 4.3.0.\*, ``manylinux1`` wheels were replaced by ``manylinux2014`` wheels. If your pip is too old, it will try to use the new source distribution introduced in 4.3.0.38 to manually build OpenCV because it does not know how to install ``manylinux2014`` wheels. However, source build will also fail because of too old ``pip`` because it does not understand build dependencies in ``pyproject.toml``. To use the new ``manylinux2014`` pre-built wheels (or to build from source), your ``pip`` version must be >= 19.3. Please upgrade ``pip`` with ``pip install --upgrade pip``.
+
+**Q: Import fails on Windows: ``ImportError: DLL load failed: The specified module could not be found.``?**
+
+A: If the import fails on Windows, make sure you have [Visual C++ redistributable 2015](https://www.microsoft.com/en-us/download/details.aspx?id=48145) installed. If you are using older Windows version than Windows 10 and latest system updates are not installed, [Universal C Runtime](https://support.microsoft.com/en-us/help/2999226/update-for-universal-c-runtime-in-windows) might be also required.
+
+Windows N and KN editions do not include Media Feature Pack which is required by OpenCV. If you are using Windows N or KN edition, please install also [Windows Media Feature Pack](https://support.microsoft.com/en-us/help/3145500/media-feature-pack-list-for-windows-n-editions).
+
+If you have Windows Server 2012+, media DLLs are probably missing too; please install the Feature called "Media Foundation" in the Server Manager. Beware, some posts advise to install "Windows Server Essentials Media Pack", but this one requires the "Windows Server Essentials Experience" role, and this role will deeply affect your Windows Server configuration (by enforcing active directory integration etc.); so just installing the "Media Foundation" should be a safer choice.
+
+If the above does not help, check if you are using Anaconda. Old Anaconda versions have a bug which causes the error, see [this issue](https://github.com/opencv/opencv-python/issues/36) for a manual fix.
+
+If you still encounter the error after you have checked all the previous solutions, download [Dependencies](https://github.com/lucasg/Dependencies) and open the ``cv2.pyd`` (located usually at ``C:\Users\username\AppData\Local\Programs\Python\PythonXX\Lib\site-packages\cv2``) file with it to debug missing DLL issues.
+
+**Q: I have some other import errors?**
+
+A: Make sure you have removed old manual installations of OpenCV Python bindings (cv2.so or cv2.pyd in site-packages).
+
+**Q: Function foo() or method bar() returns wrong result, throws exception or crashes interpreter. What should I do?**
+
+A: The repository contains only OpenCV-Python package build scripts, but not OpenCV itself. Python bindings for OpenCV are developed in official OpenCV repository and it's the best place to report issues. Also please check [OpenCV wiki](https://github.com/opencv/opencv/wiki) and [the official OpenCV forum](https://forum.opencv.org/) before file new bugs.
+
+**Q: Why the packages do not include non-free algorithms?**
+
+A: Non-free algorithms such as SURF are not included in these packages because they are patented / non-free and therefore cannot be distributed as built binaries. Note that SIFT is included in the builds due to patent expiration since OpenCV versions 4.3.0 and 3.4.10. See this issue for more info: https://github.com/skvark/opencv-python/issues/126
+
+**Q: Why the package and import are different (opencv-python vs. cv2)?**
+
+A: It's easier for users to understand ``opencv-python`` than ``cv2`` and it makes it easier to find the package with search engines. `cv2` (old interface in old OpenCV versions was named as `cv`) is the name that OpenCV developers chose when they created the binding generators. This is kept as the import name to be consistent with different kind of tutorials around the internet. Changing the import name or behaviour would be also confusing to experienced users who are accustomed to the ``import cv2``.
+
+## Documentation for opencv-python
+
+[![Windows Build Status](https://github.com/opencv/opencv-python/actions/workflows/build_wheels_windows.yml/badge.svg)](https://github.com/opencv/opencv-python/actions/workflows/build_wheels_windows.yml)
+[![(Linux Build status)](https://github.com/opencv/opencv-python/actions/workflows/build_wheels_linux.yml/badge.svg)](https://github.com/opencv/opencv-python/actions/workflows/build_wheels_linux.yml)
+[![(Mac OS Build status)](https://github.com/opencv/opencv-python/actions/workflows/build_wheels_macos.yml/badge.svg)](https://github.com/opencv/opencv-python/actions/workflows/build_wheels_macos.yml)
+
+The aim of this repository is to provide means to package each new [OpenCV release](https://github.com/opencv/opencv/releases) for the most used Python versions and platforms.
+
+### CI build process
+
+The project is structured like a normal Python package with a standard ``setup.py`` file.
+The build process for a single entry in the build matrices is as follows (see for example `.github/workflows/build_wheels_linux.yml` file):
+
+0. In Linux and MacOS build: get OpenCV's optional C dependencies that we compile against
+
+1. Checkout repository and submodules
+
+   -  OpenCV is included as submodule and the version is updated
+      manually by maintainers when a new OpenCV release has been made
+   -  Contrib modules are also included as a submodule
+
+2. Find OpenCV version from the sources
+
+3. Build OpenCV
+
+   -  tests are disabled, otherwise build time increases too much
+   -  there are 4 build matrix entries for each build combination: with and without contrib modules, with and without GUI (headless)
+   -  Linux builds run in manylinux Docker containers (CentOS 5)
+   -  source distributions are separate entries in the build matrix
+
+4. Rearrange OpenCV's build result, add our custom files and generate wheel
+
+5. Linux and macOS wheels are transformed with auditwheel and delocate, correspondingly
+
+6. Install the generated wheel
+7. Test that Python can import the library and run some sanity checks
+8. Use twine to upload the generated wheel to PyPI (only in release builds)
+
+Steps 1--4 are handled by ``pip wheel``.
+
+The build can be customized with environment variables. In addition to any variables that OpenCV's build accepts, we recognize:
+
+- ``CI_BUILD``. Set to ``1`` to emulate the CI environment build behaviour. Used only in CI builds to force certain build flags on in ``setup.py``. Do not use this unless you know what you are doing.
+- ``ENABLE_CONTRIB`` and ``ENABLE_HEADLESS``. Set to ``1`` to build the contrib and/or headless version
+- ``ENABLE_JAVA``, Set to ``1`` to enable the Java client build.  This is disabled by default.
+- ``CMAKE_ARGS``. Additional arguments for OpenCV's CMake invocation. You can use this to make a custom build.
+
+See the next section for more info about manual builds outside the CI environment.
+
+### Manual builds
+
+If some dependency is not enabled in the pre-built wheels, you can also run the build locally to create a custom wheel.
+
+1. Clone this repository: `git clone --recursive https://github.com/opencv/opencv-python.git`
+2. ``cd opencv-python``
+    - you can use `git` to checkout some other version of OpenCV in the `opencv` and `opencv_contrib` submodules if needed
+3. Add custom Cmake flags if needed, for example: `export CMAKE_ARGS="-DSOME_FLAG=ON -DSOME_OTHER_FLAG=OFF"` (in Windows you need to set environment variables differently depending on Command Line or PowerShell)
+4. Select the package flavor which you wish to build with `ENABLE_CONTRIB` and `ENABLE_HEADLESS`: i.e. `export ENABLE_CONTRIB=1` if you wish to build `opencv-contrib-python`
+5. Run ``pip wheel . --verbose``. NOTE: make sure you have the latest ``pip`` version, the ``pip wheel`` command replaces the old ``python setup.py bdist_wheel`` command which does not support ``pyproject.toml``.
+    - this might take anything from 5 minutes to over 2 hours depending on your hardware
+6. Pip will print fresh will location at the end of build procedure. If you use old approach with `setup.py` file wheel package will be placed in `dist` folder. Package is ready and you can do with that whatever you wish.
+    - Optional: on Linux use some of the `manylinux` images as a build hosts if maximum portability is needed and run `auditwheel` for the wheel after build
+    - Optional: on macOS use ``delocate`` (same as ``auditwheel`` but for macOS) for better portability
+
+#### Manual debug builds
+
+In order to build `opencv-python` in an unoptimized debug build, you need to side-step the normal process a bit.
+
+1. Install the packages `scikit-build` and `numpy` via pip.
+2. Run the command `python setup.py bdist_wheel --build-type=Debug`.
+3. Install the generated wheel file in the `dist/` folder with `pip install dist/wheelname.whl`.
+
+If you would like the build produce all compiler commands, then the following combination of flags and environment variables has been tested to work on Linux:
+```
+export CMAKE_ARGS='-DCMAKE_VERBOSE_MAKEFILE=ON'
+export VERBOSE=1
+
+python3 setup.py bdist_wheel --build-type=Debug
+```
+
+See this issue for more discussion: https://github.com/opencv/opencv-python/issues/424
+
+#### Source distributions
+
+Since OpenCV version 4.3.0, also source distributions are provided in PyPI. This means that if your system is not compatible with any of the wheels in PyPI, ``pip`` will attempt to build OpenCV from sources. If you need a OpenCV version which is not available in PyPI as a source distribution, please follow the manual build guidance above instead of this one.
+
+You can also force ``pip`` to build the wheels from the source distribution. Some examples:
+
+- ``pip install --no-binary opencv-python opencv-python``
+- ``pip install --no-binary :all: opencv-python``
+
+If you need contrib modules or headless version, just change the package name (step 4 in the previous section is not needed). However, any additional CMake flags can be provided via environment variables as described in step 3 of the manual build section. If none are provided, OpenCV's CMake scripts will attempt to find and enable any suitable dependencies. Headless distributions have hard coded CMake flags which disable all possible GUI dependencies.
+
+On slow systems such as Raspberry Pi the full build may take several hours. On a 8-core Ryzen 7 3700X the build takes about 6 minutes.
+
+### Licensing
+
+Opencv-python package (scripts in this repository) is available under MIT license.
+
+OpenCV itself is available under [Apache 2](https://github.com/opencv/opencv/blob/master/LICENSE) license.
+
+Third party package licenses are at [LICENSE-3RD-PARTY.txt](https://github.com/opencv/opencv-python/blob/master/LICENSE-3RD-PARTY.txt).
+
+All wheels ship with [FFmpeg](http://ffmpeg.org) licensed under the [LGPLv2.1](http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html).
+
+Non-headless Linux wheels ship with [Qt 5](http://doc.qt.io/qt-5/lgpl.html) licensed under the [LGPLv3](http://www.gnu.org/licenses/lgpl-3.0.html).
+
+The packages include also other binaries. Full list of licenses can be found from [LICENSE-3RD-PARTY.txt](https://github.com/opencv/opencv-python/blob/master/LICENSE-3RD-PARTY.txt).
+
+### Versioning
+
+``find_version.py`` script searches for the version information from OpenCV sources and appends also a revision number specific to this repository to the version string. It saves the version information to ``version.py`` file under ``cv2`` in addition to some other flags.
+
+### Releases
+
+A release is made and uploaded to PyPI when a new tag is pushed to master branch. These tags differentiate packages (this repo might have modifications but OpenCV version stays same) and should be incremented sequentially. In practice, release version numbers look like this:
+
+``cv_major.cv_minor.cv_revision.package_revision`` e.g. ``3.1.0.0``
+
+The master branch follows OpenCV master branch releases. 3.4 branch follows OpenCV 3.4 bugfix releases.
+
+### Development builds
+
+Every commit to the master branch of this repo will be built. Possible build artifacts use local version identifiers:
+
+``cv_major.cv_minor.cv_revision+git_hash_of_this_repo`` e.g. ``3.1.0+14a8d39``
+
+These artifacts can't be and will not be uploaded to PyPI.
+
+### Manylinux wheels
+
+Linux wheels are built using [manylinux2014](https://github.com/pypa/manylinux). These wheels should work out of the box for most of the distros (which use GNU C standard library) out there since they are built against an old version of glibc.
+
+The default ``manylinux2014`` images have been extended with some OpenCV dependencies. See [Docker folder](https://github.com/skvark/opencv-python/tree/master/docker) for more info.
+
+### Supported Python versions
+
+Python 3.x compatible pre-built wheels are provided for the officially supported Python versions (not in EOL):
+
+- 3.7
+- 3.8
+- 3.9
+- 3.10
+- 3.11
+- 3.12
+
+### Backward compatibility
+
+Starting from 4.2.0 and 3.4.9 builds the macOS Travis build environment was updated to XCode 9.4. The change effectively dropped support for older than 10.13 macOS versions.
+
+Starting from 4.3.0 and 3.4.10 builds the Linux build environment was updated from `manylinux1` to `manylinux2014`. This dropped support for old Linux distributions.
+
+Starting from version 4.7.0 the Mac OS GitHub Actions build environment was update to version 11. Mac OS 10.x support depricated. See https://github.com/actions/runner-images/issues/5583
+
+Starting from version 4.9.0 the Mac OS GitHub Actions build environment was update to version 12. Mac OS 10.x support depricated by Brew and most of used packages.
+
+

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/opencv_python-4.9.0.80.dist-info/RECORD

@@ -0,0 +1,144 @@
+cv2/Error/__init__.pyi,sha256=A6NKtoMeZAvZWHC6DrJiwMVChY7LLxFfvuZ2dW4KSm8,4076
+cv2/LICENSE-3RD-PARTY.txt,sha256=ZKuaw_WkYDDW2Lvnl7aukYqNLQGG5HyiBLc0MbHrHMw,151157
+cv2/LICENSE.txt,sha256=CdcZBY54Kse8cbohyUThE2zeK7lXwOiIEh8CGNa18Cw,1070
+cv2/__init__.py,sha256=1tRL4PD5gcwFerwMFSN3tJbttHjR-mNVzgNfcR3JSyU,6575
+cv2/__init__.pyi,sha256=evrJ7NbPFLgLGRiXV2F72kL9oerfKLFBEqD-P5wcfxg,293784
+cv2/__pycache__/__init__.cpython-38.pyc,,
+cv2/__pycache__/config-3.cpython-38.pyc,,
+cv2/__pycache__/config.cpython-38.pyc,,
+cv2/__pycache__/load_config_py2.cpython-38.pyc,,
+cv2/__pycache__/load_config_py3.cpython-38.pyc,,
+cv2/__pycache__/version.cpython-38.pyc,,
+cv2/aruco/__init__.pyi,sha256=XOaNz4SbfQ0UFH8guZ9WgTybx8gekTOWr8452Yjz54E,13995
+cv2/barcode/__init__.pyi,sha256=rUP5152HBCKUQ3WUqPl2zS5nI2w9v-AHaCeXYqPglxk,1029
+cv2/config-3.py,sha256=mnqt9yS4IgAfXpY7Af1ON11F4su-Mo0sp7QqRAwIOhw,724
+cv2/config.py,sha256=l04tQJbuGpqaNB3xvzPhaXNoO_GsczAG3if_LyO8WE0,111
+cv2/cuda/__init__.pyi,sha256=gNkBAoEdrvkxwo4brAXNBCU_RDWixz575CWi2YEvYK4,16036
+cv2/cv2.abi3.so,sha256=jbX0ZuzuXpODBp5u45ca4U4wutGrGaS8801TfBQmLFE,65162889
+cv2/data/__init__.py,sha256=125Pcte_OtB55ZxjWg5ko8ugpnogZ1sRMyP48dtBCMw,70
+cv2/data/__pycache__/__init__.cpython-38.pyc,,
+cv2/data/haarcascade_eye.xml,sha256=ccxk_DBaNV3GAGeID2-71D3RVb1j7jhEZhob2jSy_Yw,341406
+cv2/data/haarcascade_eye_tree_eyeglasses.xml,sha256=4y-cZ5NcM-nRMx6xT6WFVP8Xg1wDdCZjvLl6iS6Talc,601661
+cv2/data/haarcascade_frontalcatface.xml,sha256=rCusk07yQoTviisunY5X7vhKwdaUO00R5cnoWE3Aacg,411388
+cv2/data/haarcascade_frontalcatface_extended.xml,sha256=_9DR0o8H0DdsidtMmEUAnChVzHbIz_dj1TMdyTYdqFQ,382918
+cv2/data/haarcascade_frontalface_alt.xml,sha256=YoHfE0Wcwhj_BH0Csq44WbEv8UqT_-iVL3sz-te5aXs,676709
+cv2/data/haarcascade_frontalface_alt2.xml,sha256=ewyWfZq7373gJeuceGlH0VG2QmBA0HqPlWLtj9kHJLQ,540616
+cv2/data/haarcascade_frontalface_alt_tree.xml,sha256=Dl7kfswTJp1U3XpV-LU3UhZ8Ulh3IId3MjiPsHigSAo,2689040
+cv2/data/haarcascade_frontalface_default.xml,sha256=D31FJ4ROtRTUpJSOgi2pD7sWo0oLu7xq3GSYdHpar7A,930127
+cv2/data/haarcascade_fullbody.xml,sha256=BBdFxx7vG1yGrvIk8XznWwQtMzFMyPZ1dCT4vYzTCqE,476827
+cv2/data/haarcascade_lefteye_2splits.xml,sha256=dMMjx4yBR1_JFY-sv7hmuwzKBr5B9XHfR9SsjQH5zkw,195369
+cv2/data/haarcascade_license_plate_rus_16stages.xml,sha256=TRxEv3obxOIE-iWwRu0Kz_1_cTzBP-KVi2l3Elxg3eo,47775
+cv2/data/haarcascade_lowerbody.xml,sha256=HmluHHxmxDmuIpz_-IcfQgN8NX6eHgkKK1nrwfj_XLs,395322
+cv2/data/haarcascade_profileface.xml,sha256=s5pKO-RVOdsUan_B0-dhopLBluuIQhGF5qYVswVeYS0,828514
+cv2/data/haarcascade_righteye_2splits.xml,sha256=TPDXK-pzB-mvfrmdSsvhXXEBpnwi_Nz77v1pKtN893Y,196170
+cv2/data/haarcascade_russian_plate_number.xml,sha256=gUy1lUaCr1cOWDYfnl-LW1E6QRJ3a7nsrO-fDkymwtc,75482
+cv2/data/haarcascade_smile.xml,sha256=TKHzBOq9C1rjAYDIGstT4Walhn5b4Xsxa9PzLP34fYo,188506
+cv2/data/haarcascade_upperbody.xml,sha256=cyirT9sVkvU9mNfqWxudkOAa9dlfISrzeMfrV5BIu18,785819
+cv2/detail/__init__.pyi,sha256=FXndW6oxsE46hjgKBezLvqJ_iEAcOCmNOAZSpbSM_-8,22374
+cv2/dnn/__init__.pyi,sha256=lmSN_5FJ1DrbXpIPe8iZijAK2LJDeVb-_3VOJswt6gc,22683
+cv2/fisheye/__init__.pyi,sha256=Oo9DhbwF5E2wsousnSQ9m4z6p-dMQGSxsTsDoO1Ni8g,7815
+cv2/flann/__init__.pyi,sha256=ZxYG07bhFyFRA2d1lbPmAm_KEknsTcE1_NNw_Ksz1HQ,2677
+cv2/gapi/__init__.py,sha256=6WBAjfq1FCiRADgYXGAKITHdBB6t0_jZ8hkTU8Biz-M,10298
+cv2/gapi/__init__.pyi,sha256=zCLTsHvmbiGmlDUXPWqOGdgFcj66_iw7FXiTr4Y91m0,14636
+cv2/gapi/__pycache__/__init__.cpython-38.pyc,,
+cv2/gapi/core/__init__.pyi,sha256=_3OM_ITOrZomn7gs4HM-DRk8ngbjWkdr26KrmH3t4ks,142
+cv2/gapi/core/cpu/__init__.pyi,sha256=MfRTDEPtcQekGnrvoaSSadxyylXPfa2lz8ucAkzjmh8,93
+cv2/gapi/core/fluid/__init__.pyi,sha256=MfRTDEPtcQekGnrvoaSSadxyylXPfa2lz8ucAkzjmh8,93
+cv2/gapi/core/ocl/__init__.pyi,sha256=MfRTDEPtcQekGnrvoaSSadxyylXPfa2lz8ucAkzjmh8,93
+cv2/gapi/ie/__init__.pyi,sha256=rbOXOU39Wpt9Lhh1o1qr7Zj7qljqAu6aqoYsm4433yQ,1117
+cv2/gapi/ie/detail/__init__.pyi,sha256=hGTS3yIiIq1B-djXgSQIPmeF7VDyeyucUuZOnd4O0OQ,269
+cv2/gapi/imgproc/__init__.pyi,sha256=UUtPJcDK_UaE_TKN8K9Oz1TEChCQHDDB_eTI08mVXmU,71
+cv2/gapi/imgproc/fluid/__init__.pyi,sha256=MfRTDEPtcQekGnrvoaSSadxyylXPfa2lz8ucAkzjmh8,93
+cv2/gapi/oak/__init__.pyi,sha256=Tb7YXytKxnBFZZ8qTqHSZsDEpRt2937NXtbOQK23Ksc,1734
+cv2/gapi/onnx/__init__.pyi,sha256=XAQ4M2p7kcm0gSL_2OJkjoI8h5AzlHQh6xDQEX7z5e4,1344
+cv2/gapi/onnx/ep/__init__.pyi,sha256=3a7nzkkajyZBbTM2FKOI2eGM3GKTNGId_ZNEhghdrkU,1239
+cv2/gapi/ot/__init__.pyi,sha256=XTMT90lnElxl_KfhFi5xDwQWvB0g5N8tf7Cgb8VHcAY,720
+cv2/gapi/ot/cpu/__init__.pyi,sha256=MfRTDEPtcQekGnrvoaSSadxyylXPfa2lz8ucAkzjmh8,93
+cv2/gapi/ov/__init__.pyi,sha256=3BqKzC_lV-wzhwu2cawCBvGbMG_zxt5D6anjhORXvuM,2647
+cv2/gapi/own/__init__.pyi,sha256=GzL91pOQQNsGcBGmZ_XDAXaLoF4N9qVgj_IaYzduSNc,69
+cv2/gapi/own/detail/__init__.pyi,sha256=sTC8JFcjDcVxnaFfFc-VmuxjHBg6RMzfafFHtS8yrFU,140
+cv2/gapi/render/__init__.pyi,sha256=S4FWzy_CJqqs3dPYl3bXJoLQSGeVZdoBK7EmHvbPVOM,66
+cv2/gapi/render/ocv/__init__.pyi,sha256=MfRTDEPtcQekGnrvoaSSadxyylXPfa2lz8ucAkzjmh8,93
+cv2/gapi/streaming/__init__.pyi,sha256=qIOndKlPMevrSglTW-vVugzy_n7nITT6lr_zrlUv9cI,813
+cv2/gapi/video/__init__.pyi,sha256=V0Emspufw7x2-knfd7kE8LnLjY_ujIz_TaxR_oIyAps,150
+cv2/gapi/wip/__init__.pyi,sha256=f7mz60ehM9yrK0_Vt28NP--WietDE65EjM5O91LVx5M,1086
+cv2/gapi/wip/draw/__init__.pyi,sha256=x2BhywI5C-uMHF1H6L9AwrgjRtKHFr032TOnqtE9a9Q,3162
+cv2/gapi/wip/gst/__init__.pyi,sha256=8VtSKP9duTmY7ETAACwzVEWP9xdDW0pW82UtL_8Z7Aw,467
+cv2/gapi/wip/onevpl/__init__.pyi,sha256=eLbVPey7JCU5YdRSUH6lLlD1eT-1s7YqZrQh6xNdIlo,397
+cv2/ipp/__init__.pyi,sha256=WSHVIqIT97vmudtuJjhOJYiZ0iBdYx4AtB0iJqtdD0o,223
+cv2/load_config_py2.py,sha256=xP_h2pObzfbN8tONV7CAQmGh94fQ-0t0HysrXDDlt_Q,151
+cv2/load_config_py3.py,sha256=A9wfETdKZnybfbEN1SdtZAsMLVsueGa0zO93JzK9OFI,262
+cv2/mat_wrapper/__init__.py,sha256=LGhjbGujJyyQ4A5WOOtOES5WbbbpmP-_aHUPQ2Vvnec,1099
+cv2/mat_wrapper/__pycache__/__init__.cpython-38.pyc,,
+cv2/misc/__init__.py,sha256=yr9PkxKslxRc87hhtIJRn5RommP9jaqksYr-ZDuj7cU,37
+cv2/misc/__pycache__/__init__.cpython-38.pyc,,
+cv2/misc/__pycache__/version.cpython-38.pyc,,
+cv2/misc/version.py,sha256=iTExq1jwGgAv3jtYQHRI8pSpmfzPsjkG9brsH0bdYhk,90
+cv2/ml/__init__.pyi,sha256=KGiSrNBU8YWqJzhV3owS_b_nKl_40EXwdGrmC1e41J4,22803
+cv2/ocl/__init__.pyi,sha256=HpZMIJBr7LcDWOvXAlfDd5aDzMCyDH3OVUcNtU6Zkfw,5455
+cv2/ogl/__init__.pyi,sha256=KxTX9DHYyXg2ipvOJiFeAsRivAjmvBkqeiLZV-0snII,1472
+cv2/parallel/__init__.pyi,sha256=tc5nNoWrTkD7VAfhbajumKF79LBolpqlKjYX-lY2__8,129
+cv2/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cv2/qt/fonts/DejaVuSans-Bold.ttf,sha256=5JIhu_F8A2EnQUMWn35vFthxX2XUnx2fIW6z1mFAAwg,672300
+cv2/qt/fonts/DejaVuSans-BoldOblique.ttf,sha256=c1891zgbb04MpRm3JiDHWqlT7o7om4jL5POMo8I9ank,611212
+cv2/qt/fonts/DejaVuSans-ExtraLight.ttf,sha256=kI1uyALygVXI3oYZK1p3qftBeS8HLgNSbwU2wjTz6aA,345204
+cv2/qt/fonts/DejaVuSans-Oblique.ttf,sha256=O8nAL-_K3VF-WhWLLzQjPdNU1n9DAkhtiOhLykZ9HUM,611556
+cv2/qt/fonts/DejaVuSans.ttf,sha256=FdotjxLmlQABscyCJcG6ct3OGTiDfTdwL_Ppv215vV4,720012
+cv2/qt/fonts/DejaVuSansCondensed-Bold.ttf,sha256=-GxtQKUv_itA8Z0Llyykuc40f8BNz8TQtOkneocSwN0,631992
+cv2/qt/fonts/DejaVuSansCondensed-BoldOblique.ttf,sha256=ZldpOhjs7-4mZ9nQ7LGrtoUk1ieZm9g2UDnBngS0I4E,580168
+cv2/qt/fonts/DejaVuSansCondensed-Oblique.ttf,sha256=SPmU6BKEZmq0v4nvTXMIWwf65sLH4oggqyQ-mUHEgp4,576004
+cv2/qt/fonts/DejaVuSansCondensed.ttf,sha256=afE1XJ7vCj0RpsBvPL8dRuq_2tzJk1iaO-k6RO2GeLQ,643852
+cv2/qt/plugins/platforms/libqxcb.so,sha256=b2rHw7D7EZh7mHrUsrhrQYsQDiF0sFYEoPlJkSAFdjE,29305
+cv2/samples/__init__.pyi,sha256=cjSW5vo2oMpIWHwP-3IY4hWjlKUTz8gd1MX7pLOCWKo,324
+cv2/segmentation/__init__.pyi,sha256=jwKBUCRaXhHAM3FdzpLuGucGfNLWxWu5CDfLOpkcan4,1739
+cv2/typing/__init__.py,sha256=HoaylcwVD3ZH1MQ0oTxswFmYExDxFkS7sAWW6BWOUg4,5137
+cv2/typing/__pycache__/__init__.cpython-38.pyc,,
+cv2/utils/__init__.py,sha256=fuw4GHHOXsxxKc-AadAEOKQq_I1Gr4G3yMlRvAbTP30,330
+cv2/utils/__init__.pyi,sha256=q7PpnVUH597R_sF7AGrsRVDOIGKflT0b77ll-mkmb7g,3592
+cv2/utils/__pycache__/__init__.cpython-38.pyc,,
+cv2/utils/fs/__init__.pyi,sha256=lu2cK1Dbd7wRTOTju_kVVCvU4mNB5v5hSVpBxSXXvJg,87
+cv2/utils/nested/__init__.pyi,sha256=n2J3aSxC2MrPKaKb4igY_d49luuuQqW7A_YTx6eZz9Q,573
+cv2/version.py,sha256=zQjL6v-wBgcqGFq6XRAWaa39FmWEY4sLTKCZ3hptMlI,92
+cv2/videoio_registry/__init__.pyi,sha256=h-7AlM3cFG5xxcPwZiVQ3n3ibe7BpGPlhgDcWOqZPA4,783
+opencv_python-4.9.0.80.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+opencv_python-4.9.0.80.dist-info/LICENSE-3RD-PARTY.txt,sha256=ZKuaw_WkYDDW2Lvnl7aukYqNLQGG5HyiBLc0MbHrHMw,151157
+opencv_python-4.9.0.80.dist-info/LICENSE.txt,sha256=CdcZBY54Kse8cbohyUThE2zeK7lXwOiIEh8CGNa18Cw,1070
+opencv_python-4.9.0.80.dist-info/METADATA,sha256=4D_lTzaeG8QbRfiIFZ3bazaqGAHPb_09sMx-2sGJPeM,20251
+opencv_python-4.9.0.80.dist-info/RECORD,,
+opencv_python-4.9.0.80.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+opencv_python-4.9.0.80.dist-info/WHEEL,sha256=EAtJEfUIJ_UiIhsbDQlddQslMIo1TSnut_vtG8YV5KA,142
+opencv_python-4.9.0.80.dist-info/top_level.txt,sha256=SY8vrf_sYOg99OP9euhz7q36pPy_2VK5vbeEWXwwSoc,4
+opencv_python.libs/libQt5Core-39545cc7.so.5.15.0,sha256=8bqvorqRNim_5obrAiVWgcIehuvtrDQJoykWMJecCVs,7333489
+opencv_python.libs/libQt5Gui-a7aedf18.so.5.15.0,sha256=_1PQrJUh1At_pGBnbLVhoKKObEU5CneH8jgSk5iyZOU,8856273
+opencv_python.libs/libQt5Test-c38a5234.so.5.15.0,sha256=ul3nnDMWl-Rqf3wtgIlxvcyDaR9t5MjxlYSssH2rZpE,419025
+opencv_python.libs/libQt5Widgets-e69d94fb.so.5.15.0,sha256=DHPfscZnGZ9rNQSDDdKfq0-96FuVq6V1xTLR7AuqGCY,8909633
+opencv_python.libs/libQt5XcbQpa-5b2d853e.so.5.15.0,sha256=lDdFucfIAfgXK3dA-pYKsYiCEnr0Fas3BZ1v0Wd3OWo,1796105
+opencv_python.libs/libX11-xcb-69166bdf.so.1.0.0,sha256=oIMXcY6MB8aPh8ogBGhuTdaxyFy06iw8-mTmO8o9WzU,8873
+opencv_python.libs/libXau-00ec42fe.so.6.0.0,sha256=JjysEtjYterX3CORw1X-n8k5lA4eoi7ZjuVqjLYc5oQ,17049
+opencv_python.libs/libavcodec-512f0acb.so.59.37.100,sha256=1rkzomPrXGOCDSOalbI613J191jX46XOmWT-kaRSr5E,13448513
+opencv_python.libs/libavformat-3ff1be5b.so.59.27.100,sha256=xxzCzbu3y-zOVzReNrHi53HygUswkSyV4hd6FGpbK_E,2571489
+opencv_python.libs/libavutil-a0a0531e.so.57.28.100,sha256=_HhiKqfwZH7fZ95HlYWD9p3ANOucUPLvqFPHvhxTq6Y,844673
+opencv_python.libs/libcrypto-0c9efecc.so.1.1,sha256=aQ4FPG5fBY-U4QjCcI7gc2DQ5dGkokgE9N6ZXkugD9s,3481345
+opencv_python.libs/libgfortran-91cc3cb1.so.3.0.0,sha256=VePrZzBsL_F-b4oIEOqg3LJulM2DkkxQZdUEDoeBRgg,1259665
+opencv_python.libs/libopenblas-r0-f650aae0.3.3.so,sha256=eewCtT9XPNcRaonwTDl0cwGOf9oFcgs1TUNQXBnUeVg,37325001
+opencv_python.libs/libpng16-7379b3c3.so.16.40.0,sha256=-ChEJT9joQEfhf4MZ0rIuU4N21x2VcTyBLh38q2m9ZA,1097009
+opencv_python.libs/libquadmath-96973f99.so.0.0.0,sha256=k0wi3tDn0WnE1GeIdslgUa3z2UVF2pYvYLQWWbB12js,247609
+opencv_python.libs/libssl-28bef1ac.so.1.1,sha256=3MoD1DoDL-u-QgZxgTrlZJpDvlPBflLEGO6RzVctbhE,736177
+opencv_python.libs/libswresample-2ec4394e.so.4.7.100,sha256=53S-M_Gn06zoAaUbYkdaMuLvXEWu2Mv1_YLkiW2oJ9I,132417
+opencv_python.libs/libswscale-2c3c8be7.so.6.7.100,sha256=Lp2HzwvDYmIHUUay0z4VqLo5jICmVQr3Z4uD1C1IXVA,619945
+opencv_python.libs/libvpx-e947aa05.so.8.0.1,sha256=WmdWKHzsqUpZZiaf6-C28vIJJ9CwK_yMkaR_eAz274g,3291065
+opencv_python.libs/libxcb-icccm-413c9f41.so.4.0.0,sha256=KrtUIHu46x9mIwMEkEYflhOFmYFjvUB3Ok1Dn9936eI,24377
+opencv_python.libs/libxcb-image-e82a276d.so.0.0.0,sha256=QYC_KsToCXKQ2u87uOb2WJmK6Z-S4yynjqYWiI3stTY,25601
+opencv_python.libs/libxcb-keysyms-21015570.so.1.0.0,sha256=PjX3WLcXNZucKONqtqBW4wPbmcaukPVyLPu2JCXZ7QQ,13209
+opencv_python.libs/libxcb-randr-a96a5a87.so.0.1.0,sha256=LZmVHqS5soTrAUfIJ4cy0BKHrBk0Q8cy7IBJFbhsHvY,93921
+opencv_python.libs/libxcb-render-637b984a.so.0.0.0,sha256=COOiubLk9Kv2S4wVA5QaRzgllJYpLLGXjYQAKM3hs2c,78105
+opencv_python.libs/libxcb-render-util-43ce00f5.so.0.0.0,sha256=N0OPbas7C-jZx7kb3--foJiJPc5odPSj-hdma1yRG2E,22161
+opencv_python.libs/libxcb-shape-25c2b258.so.0.0.0,sha256=8xHTe9DQmFzk-5HtT33th8bvgCroLJiEvXdAiN3i1io,21769
+opencv_python.libs/libxcb-shm-7a199f70.so.0.0.0,sha256=XrF9nlIKkNrLG9HkXnn_XIeIHPwr20hRrTWETbzVGwE,21377
+opencv_python.libs/libxcb-sync-89374f40.so.1.0.0,sha256=-w1wV0pfEQbSmW-QGzsRSADRNReahcQtlYgqIjKgHeE,35673
+opencv_python.libs/libxcb-util-4d666913.so.1.0.0,sha256=44mg7PRdg-AK2vHz0GT1yzW0iN8d_GUFvhFGlrLtMo8,26281
+opencv_python.libs/libxcb-xfixes-9be3ba6f.so.0.0.0,sha256=n5_94_1LwyIvg9S1I1dbu6a3ROBn28MQgT-maLnRtFM,45337
+opencv_python.libs/libxcb-xinerama-ae147f87.so.0.0.0,sha256=iUXAB0Ox6t7vVAJOQEzTK4GVjW3AbnHOFsWyxml6RNo,17529
+opencv_python.libs/libxcb-xkb-9ba31ab3.so.1.0.0,sha256=4toATK-D72nN4FjDv7ZCXjkMpU1Giroj5hr2ebVlOjk,157921
+opencv_python.libs/libxkbcommon-71ae2972.so.0.0.0,sha256=H8s4pka9HOHar2gq0pty5lv99noGM1snj46Z0LdTAhI,269865
+opencv_python.libs/libxkbcommon-x11-c65ed502.so.0.0.0,sha256=rW0xj4RCtgOJ1WRD7nOSLHXJdiSAPX0bafb8U52HQ4U,48105

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/opencv_python-4.9.0.80.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: skbuild 0.17.6
+Root-Is-Purelib: false
+Tag: cp37-abi3-manylinux_2_17_x86_64
+Tag: cp37-abi3-manylinux2014_x86_64
+

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/opencv_python-4.9.0.80.dist-info/top_level.txt

@@ -0,0 +1 @@
+cv2

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

@@ -0,0 +1,7 @@
+import sys
+
+# https://www.python.org/dev/peps/pep-0396/
+__version__ = '0.4.8'
+
+if sys.version_info[:2] < (2, 4):
+    raise RuntimeError('PyASN1 requires Python 2.4 or later')

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/pyasn1/debug.py

@@ -0,0 +1,157 @@
+#
+# This file is part of pyasn1 software.
+#
+# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# License: http://snmplabs.com/pyasn1/license.html
+#
+import logging
+import sys
+
+from pyasn1 import __version__
+from pyasn1 import error
+from pyasn1.compat.octets import octs2ints
+
+__all__ = ['Debug', 'setLogger', 'hexdump']
+
+DEBUG_NONE = 0x0000
+DEBUG_ENCODER = 0x0001
+DEBUG_DECODER = 0x0002
+DEBUG_ALL = 0xffff
+
+FLAG_MAP = {
+    'none': DEBUG_NONE,
+    'encoder': DEBUG_ENCODER,
+    'decoder': DEBUG_DECODER,
+    'all': DEBUG_ALL
+}
+
+LOGGEE_MAP = {}
+
+
+class Printer(object):
+    # noinspection PyShadowingNames
+    def __init__(self, logger=None, handler=None, formatter=None):
+        if logger is None:
+            logger = logging.getLogger('pyasn1')
+
+        logger.setLevel(logging.DEBUG)
+
+        if handler is None:
+            handler = logging.StreamHandler()
+
+        if formatter is None:
+            formatter = logging.Formatter('%(asctime)s %(name)s: %(message)s')
+
+        handler.setFormatter(formatter)
+        handler.setLevel(logging.DEBUG)
+        logger.addHandler(handler)
+
+        self.__logger = logger
+
+    def __call__(self, msg):
+        self.__logger.debug(msg)
+
+    def __str__(self):
+        return '<python logging>'
+
+
+if hasattr(logging, 'NullHandler'):
+    NullHandler = logging.NullHandler
+
+else:
+    # Python 2.6 and older
+    class NullHandler(logging.Handler):
+        def emit(self, record):
+            pass
+
+
+class Debug(object):
+    defaultPrinter = Printer()
+
+    def __init__(self, *flags, **options):
+        self._flags = DEBUG_NONE
+
+        if 'loggerName' in options:
+            # route our logs to parent logger
+            self._printer = Printer(
+                logger=logging.getLogger(options['loggerName']),
+                handler=NullHandler()
+            )
+
+        elif 'printer' in options:
+            self._printer = options.get('printer')
+
+        else:
+            self._printer = self.defaultPrinter
+
+        self._printer('running pyasn1 %s, debug flags %s' % (__version__, ', '.join(flags)))
+
+        for flag in flags:
+            inverse = flag and flag[0] in ('!', '~')
+            if inverse:
+                flag = flag[1:]
+            try:
+                if inverse:
+                    self._flags &= ~FLAG_MAP[flag]
+                else:
+                    self._flags |= FLAG_MAP[flag]
+            except KeyError:
+                raise error.PyAsn1Error('bad debug flag %s' % flag)
+
+            self._printer("debug category '%s' %s" % (flag, inverse and 'disabled' or 'enabled'))
+
+    def __str__(self):
+        return 'logger %s, flags %x' % (self._printer, self._flags)
+
+    def __call__(self, msg):
+        self._printer(msg)
+
+    def __and__(self, flag):
+        return self._flags & flag
+
+    def __rand__(self, flag):
+        return flag & self._flags
+
+_LOG = DEBUG_NONE
+
+
+def setLogger(userLogger):
+    global _LOG
+
+    if userLogger:
+        _LOG = userLogger
+    else:
+        _LOG = DEBUG_NONE
+
+    # Update registered logging clients
+    for module, (name, flags) in LOGGEE_MAP.items():
+        setattr(module, name, _LOG & flags and _LOG or DEBUG_NONE)
+
+
+def registerLoggee(module, name='LOG', flags=DEBUG_NONE):
+    LOGGEE_MAP[sys.modules[module]] = name, flags
+    setLogger(_LOG)
+    return _LOG
+
+
+def hexdump(octets):
+    return ' '.join(
+        ['%s%.2X' % (n % 16 == 0 and ('\n%.5d: ' % n) or '', x)
+         for n, x in zip(range(len(octets)), octs2ints(octets))]
+    )
+
+
+class Scope(object):
+    def __init__(self):
+        self._list = []
+
+    def __str__(self): return '.'.join(self._list)
+
+    def push(self, token):
+        self._list.append(token)
+
+    def pop(self):
+        return self._list.pop()
+
+
+scope = Scope()

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/pyasn1/error.py

@@ -0,0 +1,75 @@
+#
+# This file is part of pyasn1 software.
+#
+# Copyright (c) 2005-2019, Ilya Etingof <etingof@gmail.com>
+# License: http://snmplabs.com/pyasn1/license.html
+#
+
+
+class PyAsn1Error(Exception):
+    """Base pyasn1 exception
+
+    `PyAsn1Error` is the base exception class (based on
+    :class:`Exception`) that represents all possible ASN.1 related
+    errors.
+    """
+
+
+class ValueConstraintError(PyAsn1Error):
+    """ASN.1 type constraints violation exception
+
+    The `ValueConstraintError` exception indicates an ASN.1 value
+    constraint violation.
+
+    It might happen on value object instantiation (for scalar types) or on
+    serialization (for constructed types).
+    """
+
+
+class SubstrateUnderrunError(PyAsn1Error):
+    """ASN.1 data structure deserialization error
+
+    The `SubstrateUnderrunError` exception indicates insufficient serialised
+    data on input of a de-serialization codec.
+    """
+
+
+class PyAsn1UnicodeError(PyAsn1Error, UnicodeError):
+    """Unicode text processing error
+
+    The `PyAsn1UnicodeError` exception is a base class for errors relating to
+    unicode text de/serialization.
+
+    Apart from inheriting from :class:`PyAsn1Error`, it also inherits from
+    :class:`UnicodeError` to help the caller catching unicode-related errors.
+    """
+    def __init__(self, message, unicode_error=None):
+        if isinstance(unicode_error, UnicodeError):
+            UnicodeError.__init__(self, *unicode_error.args)
+        PyAsn1Error.__init__(self, message)
+
+
+class PyAsn1UnicodeDecodeError(PyAsn1UnicodeError, UnicodeDecodeError):
+    """Unicode text decoding error
+
+    The `PyAsn1UnicodeDecodeError` exception represents a failure to
+    deserialize unicode text.
+
+    Apart from inheriting from :class:`PyAsn1UnicodeError`, it also inherits
+    from :class:`UnicodeDecodeError` to help the caller catching unicode-related
+    errors.
+    """
+
+
+class PyAsn1UnicodeEncodeError(PyAsn1UnicodeError, UnicodeEncodeError):
+    """Unicode text encoding error
+
+    The `PyAsn1UnicodeEncodeError` exception represents a failure to
+    serialize unicode text.
+
+    Apart from inheriting from :class:`PyAsn1UnicodeError`, it also inherits
+    from :class:`UnicodeEncodeError` to help the caller catching
+    unicode-related errors.
+    """
+
+

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

@@ -0,0 +1,40 @@
+# flake8: noqa
+
+# Copyright (c) 2006-2012 Filip Wasilewski <http://en.ig.ma/>
+# Copyright (c) 2012-2020 The PyWavelets Developers
+#                         <https://github.com/PyWavelets/pywt>
+# See LICENSE for more details.
+
+"""
+Discrete forward and inverse wavelet transform, stationary wavelet transform,
+wavelet packets signal decomposition and reconstruction module.
+"""
+
+from __future__ import division, print_function, absolute_import
+
+from ._extensions._pywt import *
+from ._functions import *
+from ._multilevel import *
+from ._multidim import *
+from ._thresholding import *
+from ._wavelet_packets import *
+from ._dwt import *
+from ._swt import *
+from ._cwt import *
+from ._mra import *
+
+from . import data
+
+__all__ = [s for s in dir() if not s.startswith('_')]
+try:
+    # In Python 2.x the name of the tempvar leaks out of the list
+    # comprehension.  Delete it to not make it show up in the main namespace.
+    del s
+except NameError:
+    pass
+
+from pywt.version import version as __version__
+
+from ._pytesttester import PytestTester
+test = PytestTester(__name__)
+del PytestTester

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/pywt/_c99_config.py

@@ -0,0 +1,3 @@
+# Autogenerated file containing compile-time definitions
+
+_have_c99_complex = 1

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/pywt/_cwt.py

@@ -0,0 +1,203 @@
+from math import floor, ceil
+
+from ._extensions._pywt import (DiscreteContinuousWavelet, ContinuousWavelet,
+                                Wavelet, _check_dtype)
+from ._functions import integrate_wavelet, scale2frequency
+
+
+__all__ = ["cwt"]
+
+
+import numpy as np
+
+try:
+    # Prefer scipy.fft (new in SciPy 1.4)
+    import scipy.fft
+    fftmodule = scipy.fft
+    next_fast_len = fftmodule.next_fast_len
+except ImportError:
+    try:
+        import scipy.fftpack
+        fftmodule = scipy.fftpack
+        next_fast_len = fftmodule.next_fast_len
+    except ImportError:
+        fftmodule = np.fft
+
+        # provide a fallback so scipy is an optional requirement
+        def next_fast_len(n):
+            """Round up size to the nearest power of two.
+
+            Given a number of samples `n`, returns the next power of two
+            following this number to take advantage of FFT speedup.
+            This fallback is less efficient than `scipy.fftpack.next_fast_len`
+            """
+            return 2**ceil(np.log2(n))
+
+
+def cwt(data, scales, wavelet, sampling_period=1., method='conv', axis=-1):
+    """
+    cwt(data, scales, wavelet)
+
+    One dimensional Continuous Wavelet Transform.
+
+    Parameters
+    ----------
+    data : array_like
+        Input signal
+    scales : array_like
+        The wavelet scales to use. One can use
+        ``f = scale2frequency(wavelet, scale)/sampling_period`` to determine
+        what physical frequency, ``f``. Here, ``f`` is in hertz when the
+        ``sampling_period`` is given in seconds.
+    wavelet : Wavelet object or name
+        Wavelet to use
+    sampling_period : float
+        Sampling period for the frequencies output (optional).
+        The values computed for ``coefs`` are independent of the choice of
+        ``sampling_period`` (i.e. ``scales`` is not scaled by the sampling
+        period).
+    method : {'conv', 'fft'}, optional
+        The method used to compute the CWT. Can be any of:
+            - ``conv`` uses ``numpy.convolve``.
+            - ``fft`` uses frequency domain convolution.
+            - ``auto`` uses automatic selection based on an estimate of the
+              computational complexity at each scale.
+
+        The ``conv`` method complexity is ``O(len(scale) * len(data))``.
+        The ``fft`` method is ``O(N * log2(N))`` with
+        ``N = len(scale) + len(data) - 1``. It is well suited for large size
+        signals but slightly slower than ``conv`` on small ones.
+    axis: int, optional
+        Axis over which to compute the CWT. If not given, the last axis is
+        used.
+
+    Returns
+    -------
+    coefs : array_like
+        Continuous wavelet transform of the input signal for the given scales
+        and wavelet. The first axis of ``coefs`` corresponds to the scales.
+        The remaining axes match the shape of ``data``.
+    frequencies : array_like
+        If the unit of sampling period are seconds and given, than frequencies
+        are in hertz. Otherwise, a sampling period of 1 is assumed.
+
+    Notes
+    -----
+    Size of coefficients arrays depends on the length of the input array and
+    the length of given scales.
+
+    Examples
+    --------
+    >>> import pywt
+    >>> import numpy as np
+    >>> import matplotlib.pyplot as plt
+    >>> x = np.arange(512)
+    >>> y = np.sin(2*np.pi*x/32)
+    >>> coef, freqs=pywt.cwt(y,np.arange(1,129),'gaus1')
+    >>> plt.matshow(coef) # doctest: +SKIP
+    >>> plt.show() # doctest: +SKIP
+    ----------
+    >>> import pywt
+    >>> import numpy as np
+    >>> import matplotlib.pyplot as plt
+    >>> t = np.linspace(-1, 1, 200, endpoint=False)
+    >>> sig  = np.cos(2 * np.pi * 7 * t) + np.real(np.exp(-7*(t-0.4)**2)*np.exp(1j*2*np.pi*2*(t-0.4)))
+    >>> widths = np.arange(1, 31)
+    >>> cwtmatr, freqs = pywt.cwt(sig, widths, 'mexh')
+    >>> plt.imshow(cwtmatr, extent=[-1, 1, 1, 31], cmap='PRGn', aspect='auto',
+    ...            vmax=abs(cwtmatr).max(), vmin=-abs(cwtmatr).max())  # doctest: +SKIP
+    >>> plt.show() # doctest: +SKIP
+    """
+
+    # accept array_like input; make a copy to ensure a contiguous array
+    dt = _check_dtype(data)
+    data = np.asarray(data, dtype=dt)
+    dt_cplx = np.result_type(dt, np.complex64)
+    if not isinstance(wavelet, (ContinuousWavelet, Wavelet)):
+        wavelet = DiscreteContinuousWavelet(wavelet)
+    if np.isscalar(scales):
+        scales = np.array([scales])
+    if not np.isscalar(axis):
+        raise np.AxisError("axis must be a scalar.")
+
+    dt_out = dt_cplx if wavelet.complex_cwt else dt
+    out = np.empty((np.size(scales),) + data.shape, dtype=dt_out)
+    precision = 10
+    int_psi, x = integrate_wavelet(wavelet, precision=precision)
+    int_psi = np.conj(int_psi) if wavelet.complex_cwt else int_psi
+
+    # convert int_psi, x to the same precision as the data
+    dt_psi = dt_cplx if int_psi.dtype.kind == 'c' else dt
+    int_psi = np.asarray(int_psi, dtype=dt_psi)
+    x = np.asarray(x, dtype=data.real.dtype)
+
+    if method == 'fft':
+        size_scale0 = -1
+        fft_data = None
+    elif not method == 'conv':
+        raise ValueError("method must be 'conv' or 'fft'")
+
+    if data.ndim > 1:
+        # move axis to be transformed last (so it is contiguous)
+        data = data.swapaxes(-1, axis)
+
+        # reshape to (n_batch, data.shape[-1])
+        data_shape_pre = data.shape
+        data = data.reshape((-1, data.shape[-1]))
+
+    for i, scale in enumerate(scales):
+        step = x[1] - x[0]
+        j = np.arange(scale * (x[-1] - x[0]) + 1) / (scale * step)
+        j = j.astype(int)  # floor
+        if j[-1] >= int_psi.size:
+            j = np.extract(j < int_psi.size, j)
+        int_psi_scale = int_psi[j][::-1]
+
+        if method == 'conv':
+            if data.ndim == 1:
+                conv = np.convolve(data, int_psi_scale)
+            else:
+                # batch convolution via loop
+                conv_shape = list(data.shape)
+                conv_shape[-1] += int_psi_scale.size - 1
+                conv_shape = tuple(conv_shape)
+                conv = np.empty(conv_shape, dtype=dt_out)
+                for n in range(data.shape[0]):
+                    conv[n, :] = np.convolve(data[n], int_psi_scale)
+        else:
+            # The padding is selected for:
+            # - optimal FFT complexity
+            # - to be larger than the two signals length to avoid circular
+            #   convolution
+            size_scale = next_fast_len(
+                data.shape[-1] + int_psi_scale.size - 1
+            )
+            if size_scale != size_scale0:
+                # Must recompute fft_data when the padding size changes.
+                fft_data = fftmodule.fft(data, size_scale, axis=-1)
+            size_scale0 = size_scale
+            fft_wav = fftmodule.fft(int_psi_scale, size_scale, axis=-1)
+            conv = fftmodule.ifft(fft_wav * fft_data, axis=-1)
+            conv = conv[..., :data.shape[-1] + int_psi_scale.size - 1]
+
+        coef = - np.sqrt(scale) * np.diff(conv, axis=-1)
+        if out.dtype.kind != 'c':
+            coef = coef.real
+        # transform axis is always -1 due to the data reshape above
+        d = (coef.shape[-1] - data.shape[-1]) / 2.
+        if d > 0:
+            coef = coef[..., floor(d):-ceil(d)]
+        elif d < 0:
+            raise ValueError(
+                "Selected scale of {} too small.".format(scale))
+        if data.ndim > 1:
+            # restore original data shape and axis position
+            coef = coef.reshape(data_shape_pre)
+            coef = coef.swapaxes(axis, -1)
+        out[i, ...] = coef
+
+    frequencies = scale2frequency(wavelet, scales, precision)
+    if np.isscalar(frequencies):
+        frequencies = np.array([frequencies])
+    frequencies /= sampling_period
+    return out, frequencies

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/pywt/_doc_utils.py

@@ -0,0 +1,187 @@
+"""Utilities used to generate various figures in the documentation."""
+from itertools import product
+
+import numpy as np
+from matplotlib import pyplot as plt
+
+from ._dwt import pad
+
+__all__ = ['wavedec_keys', 'wavedec2_keys', 'draw_2d_wp_basis',
+           'draw_2d_fswavedecn_basis', 'boundary_mode_subplot']
+
+
+def wavedec_keys(level):
+    """Subband keys corresponding to a wavedec decomposition."""
+    approx = ''
+    coeffs = {}
+    for lev in range(level):
+        for k in ['a', 'd']:
+            coeffs[approx + k] = None
+        approx = 'a' * (lev + 1)
+        if lev < level - 1:
+            coeffs.pop(approx)
+    return list(coeffs.keys())
+
+
+def wavedec2_keys(level):
+    """Subband keys corresponding to a wavedec2 decomposition."""
+    approx = ''
+    coeffs = {}
+    for lev in range(level):
+        for k in ['a', 'h', 'v', 'd']:
+            coeffs[approx + k] = None
+        approx = 'a' * (lev + 1)
+        if lev < level - 1:
+            coeffs.pop(approx)
+    return list(coeffs.keys())
+
+
+def _box(bl, ur):
+    """(x, y) coordinates for the 4 lines making up a rectangular box.
+
+    Parameters
+    ==========
+    bl : float
+        The bottom left corner of the box
+    ur : float
+        The upper right corner of the box
+
+    Returns
+    =======
+    coords : 2-tuple
+        The first and second elements of the tuple are the x and y coordinates
+        of the box.
+    """
+    xl, xr = bl[0], ur[0]
+    yb, yt = bl[1], ur[1]
+    box_x = [xl, xr,
+             xr, xr,
+             xr, xl,
+             xl, xl]
+    box_y = [yb, yb,
+             yb, yt,
+             yt, yt,
+             yt, yb]
+    return (box_x, box_y)
+
+
+def _2d_wp_basis_coords(shape, keys):
+    # Coordinates of the lines to be drawn by draw_2d_wp_basis
+    coords = []
+    centers = {}  # retain center of boxes for use in labeling
+    for key in keys:
+        offset_x = offset_y = 0
+        for n, char in enumerate(key):
+            if char in ['h', 'd']:
+                offset_x += shape[0] // 2**(n + 1)
+            if char in ['v', 'd']:
+                offset_y += shape[1] // 2**(n + 1)
+        sx = shape[0] // 2**(n + 1)
+        sy = shape[1] // 2**(n + 1)
+        xc, yc = _box((offset_x, -offset_y),
+                      (offset_x + sx, -offset_y - sy))
+        coords.append((xc, yc))
+        centers[key] = (offset_x + sx // 2, -offset_y - sy // 2)
+    return coords, centers
+
+
+def draw_2d_wp_basis(shape, keys, fmt='k', plot_kwargs={}, ax=None,
+                     label_levels=0):
+    """Plot a 2D representation of a WaveletPacket2D basis."""
+    coords, centers = _2d_wp_basis_coords(shape, keys)
+    if ax is None:
+        fig, ax = plt.subplots(1, 1)
+    else:
+        fig = ax.get_figure()
+    for coord in coords:
+        ax.plot(coord[0], coord[1], fmt)
+    ax.set_axis_off()
+    ax.axis('square')
+    if label_levels > 0:
+        for key, c in centers.items():
+            if len(key) <= label_levels:
+                ax.text(c[0], c[1], key,
+                        horizontalalignment='center',
+                        verticalalignment='center')
+    return fig, ax
+
+
+def _2d_fswavedecn_coords(shape, levels):
+    coords = []
+    centers = {}  # retain center of boxes for use in labeling
+    for key in product(wavedec_keys(levels), repeat=2):
+        (key0, key1) = key
+        offsets = [0, 0]
+        widths = list(shape)
+        for n0, char in enumerate(key0):
+            if char in ['d']:
+                offsets[0] += shape[0] // 2**(n0 + 1)
+        for n1, char in enumerate(key1):
+            if char in ['d']:
+                offsets[1] += shape[1] // 2**(n1 + 1)
+        widths[0] = shape[0] // 2**(n0 + 1)
+        widths[1] = shape[1] // 2**(n1 + 1)
+        xc, yc = _box((offsets[0], -offsets[1]),
+                      (offsets[0] + widths[0], -offsets[1] - widths[1]))
+        coords.append((xc, yc))
+        centers[(key0, key1)] = (offsets[0] + widths[0] / 2,
+                                 -offsets[1] - widths[1] / 2)
+    return coords, centers
+
+
+def draw_2d_fswavedecn_basis(shape, levels, fmt='k', plot_kwargs={}, ax=None,
+                             label_levels=0):
+    """Plot a 2D representation of a WaveletPacket2D basis."""
+    coords, centers = _2d_fswavedecn_coords(shape, levels)
+    if ax is None:
+        fig, ax = plt.subplots(1, 1)
+    else:
+        fig = ax.get_figure()
+    for coord in coords:
+        ax.plot(coord[0], coord[1], fmt)
+    ax.set_axis_off()
+    ax.axis('square')
+    if label_levels > 0:
+        for key, c in centers.items():
+            lev = np.max([len(k) for k in key])
+            if lev <= label_levels:
+                ax.text(c[0], c[1], key,
+                        horizontalalignment='center',
+                        verticalalignment='center')
+    return fig, ax
+
+
+def boundary_mode_subplot(x, mode, ax, symw=True):
+    """Plot an illustration of the boundary mode in a subplot axis."""
+
+    # if odd-length, periodization replicates the last sample to make it even
+    if mode == 'periodization' and len(x) % 2 == 1:
+        x = np.concatenate((x, (x[-1], )))
+
+    npad = 2 * len(x)
+    t = np.arange(len(x) + 2 * npad)
+    xp = pad(x, (npad, npad), mode=mode)
+
+    ax.plot(t, xp, 'k.')
+    ax.set_title(mode)
+
+    # plot the original signal in red
+    if mode == 'periodization':
+        ax.plot(t[npad:npad + len(x) - 1], x[:-1], 'r.')
+    else:
+        ax.plot(t[npad:npad + len(x)], x, 'r.')
+
+    # add vertical bars indicating points of symmetry or boundary extension
+    o2 = np.ones(2)
+    left = npad
+    if symw:
+        step = len(x) - 1
+        rng = range(-2, 4)
+    else:
+        left -= 0.5
+        step = len(x)
+        rng = range(-2, 4)
+    if mode in ['smooth', 'constant', 'zero']:
+        rng = range(0, 2)
+    for rep in rng:
+        ax.plot((left + rep * step) * o2, [xp.min() - .5, xp.max() + .5], 'k-')

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/pywt/_dwt.py

@@ -0,0 +1,517 @@
+from numbers import Number
+
+import numpy as np
+
+from ._c99_config import _have_c99_complex
+from ._extensions._pywt import Wavelet, Modes, _check_dtype, wavelist
+from ._extensions._dwt import (dwt_single, dwt_axis, idwt_single, idwt_axis,
+                               upcoef as _upcoef, downcoef as _downcoef,
+                               dwt_max_level as _dwt_max_level,
+                               dwt_coeff_len as _dwt_coeff_len)
+from ._utils import string_types, _as_wavelet
+
+
+__all__ = ["dwt", "idwt", "downcoef", "upcoef", "dwt_max_level",
+           "dwt_coeff_len", "pad"]
+
+
+def dwt_max_level(data_len, filter_len):
+    r"""
+    dwt_max_level(data_len, filter_len)
+
+    Compute the maximum useful level of decomposition.
+
+    Parameters
+    ----------
+    data_len : int
+        Input data length.
+    filter_len : int, str or Wavelet
+        The wavelet filter length.  Alternatively, the name of a discrete
+        wavelet or a Wavelet object can be specified.
+
+    Returns
+    -------
+    max_level : int
+        Maximum level.
+
+    Notes
+    -----
+    The rational for the choice of levels is the maximum level where at least
+    one coefficient in the output is uncorrupted by edge effects caused by
+    signal extension.  Put another way, decomposition stops when the signal
+    becomes shorter than the FIR filter length for a given wavelet.  This
+    corresponds to:
+
+    .. max_level = floor(log2(data_len/(filter_len - 1)))
+
+    .. math::
+        \mathtt{max\_level} = \left\lfloor\log_2\left(\mathtt{
+            \frac{data\_len}{filter\_len - 1}}\right)\right\rfloor
+
+    Examples
+    --------
+    >>> import pywt
+    >>> w = pywt.Wavelet('sym5')
+    >>> pywt.dwt_max_level(data_len=1000, filter_len=w.dec_len)
+    6
+    >>> pywt.dwt_max_level(1000, w)
+    6
+    >>> pywt.dwt_max_level(1000, 'sym5')
+    6
+    """
+    if isinstance(filter_len, Wavelet):
+        filter_len = filter_len.dec_len
+    elif isinstance(filter_len, string_types):
+        if filter_len in wavelist(kind='discrete'):
+            filter_len = Wavelet(filter_len).dec_len
+        else:
+            raise ValueError(
+                ("'{}', is not a recognized discrete wavelet.  A list of "
+                 "supported wavelet names can be obtained via "
+                 "pywt.wavelist(kind='discrete')").format(filter_len))
+    elif not (isinstance(filter_len, Number) and filter_len % 1 == 0):
+        raise ValueError(
+            "filter_len must be an integer, discrete Wavelet object, or the "
+            "name of a discrete wavelet.")
+
+    if filter_len < 2:
+        raise ValueError("invalid wavelet filter length")
+
+    return _dwt_max_level(data_len, filter_len)
+
+
+def dwt_coeff_len(data_len, filter_len, mode):
+    """
+    dwt_coeff_len(data_len, filter_len, mode='symmetric')
+
+    Returns length of dwt output for given data length, filter length and mode
+
+    Parameters
+    ----------
+    data_len : int
+        Data length.
+    filter_len : int
+        Filter length.
+    mode : str, optional
+        Signal extension mode, see :ref:`Modes <ref-modes>`.
+
+    Returns
+    -------
+    len : int
+        Length of dwt output.
+
+    Notes
+    -----
+    For all modes except periodization::
+
+        len(cA) == len(cD) == floor((len(data) + wavelet.dec_len - 1) / 2)
+
+    for periodization mode ("per")::
+
+        len(cA) == len(cD) == ceil(len(data) / 2)
+
+    """
+    if isinstance(filter_len, Wavelet):
+        filter_len = filter_len.dec_len
+
+    return _dwt_coeff_len(data_len, filter_len, Modes.from_object(mode))
+
+
+def dwt(data, wavelet, mode='symmetric', axis=-1):
+    """
+    dwt(data, wavelet, mode='symmetric', axis=-1)
+
+    Single level Discrete Wavelet Transform.
+
+    Parameters
+    ----------
+    data : array_like
+        Input signal
+    wavelet : Wavelet object or name
+        Wavelet to use
+    mode : str, optional
+        Signal extension mode, see :ref:`Modes <ref-modes>`.
+    axis: int, optional
+        Axis over which to compute the DWT. If not given, the
+        last axis is used.
+
+    Returns
+    -------
+    (cA, cD) : tuple
+        Approximation and detail coefficients.
+
+    Notes
+    -----
+    Length of coefficients arrays depends on the selected mode.
+    For all modes except periodization:
+
+        ``len(cA) == len(cD) == floor((len(data) + wavelet.dec_len - 1) / 2)``
+
+    For periodization mode ("per"):
+
+        ``len(cA) == len(cD) == ceil(len(data) / 2)``
+
+    Examples
+    --------
+    >>> import pywt
+    >>> (cA, cD) = pywt.dwt([1, 2, 3, 4, 5, 6], 'db1')
+    >>> cA
+    array([ 2.12132034,  4.94974747,  7.77817459])
+    >>> cD
+    array([-0.70710678, -0.70710678, -0.70710678])
+
+    """
+    if not _have_c99_complex and np.iscomplexobj(data):
+        data = np.asarray(data)
+        cA_r, cD_r = dwt(data.real, wavelet, mode, axis)
+        cA_i, cD_i = dwt(data.imag, wavelet, mode, axis)
+        return (cA_r + 1j*cA_i, cD_r + 1j*cD_i)
+
+    # accept array_like input; make a copy to ensure a contiguous array
+    dt = _check_dtype(data)
+    data = np.asarray(data, dtype=dt, order='C')
+    mode = Modes.from_object(mode)
+    wavelet = _as_wavelet(wavelet)
+
+    if axis < 0:
+        axis = axis + data.ndim
+    if not 0 <= axis < data.ndim:
+        raise np.AxisError("Axis greater than data dimensions")
+
+    if data.ndim == 1:
+        cA, cD = dwt_single(data, wavelet, mode)
+        # TODO: Check whether this makes a copy
+        cA, cD = np.asarray(cA, dt), np.asarray(cD, dt)
+    else:
+        cA, cD = dwt_axis(data, wavelet, mode, axis=axis)
+
+    return (cA, cD)
+
+
+def idwt(cA, cD, wavelet, mode='symmetric', axis=-1):
+    """
+    idwt(cA, cD, wavelet, mode='symmetric', axis=-1)
+
+    Single level Inverse Discrete Wavelet Transform.
+
+    Parameters
+    ----------
+    cA : array_like or None
+        Approximation coefficients.  If None, will be set to array of zeros
+        with same shape as ``cD``.
+    cD : array_like or None
+        Detail coefficients.  If None, will be set to array of zeros
+        with same shape as ``cA``.
+    wavelet : Wavelet object or name
+        Wavelet to use
+    mode : str, optional (default: 'symmetric')
+        Signal extension mode, see :ref:`Modes <ref-modes>`.
+    axis: int, optional
+        Axis over which to compute the inverse DWT. If not given, the
+        last axis is used.
+
+    Returns
+    -------
+    rec: array_like
+        Single level reconstruction of signal from given coefficients.
+
+    Examples
+    --------
+    >>> import pywt
+    >>> (cA, cD) = pywt.dwt([1,2,3,4,5,6], 'db2', 'smooth')
+    >>> pywt.idwt(cA, cD, 'db2', 'smooth')
+    array([ 1.,  2.,  3.,  4.,  5.,  6.])
+
+    One of the neat features of ``idwt`` is that one of the ``cA`` and ``cD``
+    arguments can be set to None.  In that situation the reconstruction will be
+    performed using only the other one.  Mathematically speaking, this is
+    equivalent to passing a zero-filled array as one of the arguments.
+
+    >>> (cA, cD) = pywt.dwt([1,2,3,4,5,6], 'db2', 'smooth')
+    >>> A = pywt.idwt(cA, None, 'db2', 'smooth')
+    >>> D = pywt.idwt(None, cD, 'db2', 'smooth')
+    >>> A + D
+    array([ 1.,  2.,  3.,  4.,  5.,  6.])
+
+    """
+    # TODO: Lots of possible allocations to eliminate (zeros_like, asarray(rec))
+    # accept array_like input; make a copy to ensure a contiguous array
+
+    if cA is None and cD is None:
+        raise ValueError("At least one coefficient parameter must be "
+                         "specified.")
+
+    # for complex inputs: compute real and imaginary separately then combine
+    if not _have_c99_complex and (np.iscomplexobj(cA) or np.iscomplexobj(cD)):
+        if cA is None:
+            cD = np.asarray(cD)
+            cA = np.zeros_like(cD)
+        elif cD is None:
+            cA = np.asarray(cA)
+            cD = np.zeros_like(cA)
+        return (idwt(cA.real, cD.real, wavelet, mode, axis) +
+                1j*idwt(cA.imag, cD.imag, wavelet, mode, axis))
+
+    if cA is not None:
+        dt = _check_dtype(cA)
+        cA = np.asarray(cA, dtype=dt, order='C')
+    if cD is not None:
+        dt = _check_dtype(cD)
+        cD = np.asarray(cD, dtype=dt, order='C')
+
+    if cA is not None and cD is not None:
+        if cA.dtype != cD.dtype:
+            # need to upcast to common type
+            if cA.dtype.kind == 'c' or cD.dtype.kind == 'c':
+                dtype = np.complex128
+            else:
+                dtype = np.float64
+            cA = cA.astype(dtype)
+            cD = cD.astype(dtype)
+    elif cA is None:
+        cA = np.zeros_like(cD)
+    elif cD is None:
+        cD = np.zeros_like(cA)
+
+    # cA and cD should be same dimension by here
+    ndim = cA.ndim
+
+    mode = Modes.from_object(mode)
+    wavelet = _as_wavelet(wavelet)
+
+    if axis < 0:
+        axis = axis + ndim
+    if not 0 <= axis < ndim:
+        raise np.AxisError("Axis greater than coefficient dimensions")
+
+    if ndim == 1:
+        rec = idwt_single(cA, cD, wavelet, mode)
+    else:
+        rec = idwt_axis(cA, cD, wavelet, mode, axis=axis)
+
+    return rec
+
+
+def downcoef(part, data, wavelet, mode='symmetric', level=1):
+    """
+    downcoef(part, data, wavelet, mode='symmetric', level=1)
+
+    Partial Discrete Wavelet Transform data decomposition.
+
+    Similar to ``pywt.dwt``, but computes only one set of coefficients.
+    Useful when you need only approximation or only details at the given level.
+
+    Parameters
+    ----------
+    part : str
+        Coefficients type:
+
+        * 'a' - approximations reconstruction is performed
+        * 'd' - details reconstruction is performed
+
+    data : array_like
+        Input signal.
+    wavelet : Wavelet object or name
+        Wavelet to use
+    mode : str, optional
+        Signal extension mode, see :ref:`Modes <ref-modes>`.
+    level : int, optional
+        Decomposition level.  Default is 1.
+
+    Returns
+    -------
+    coeffs : ndarray
+        1-D array of coefficients.
+
+    See Also
+    --------
+    upcoef
+
+    """
+    if not _have_c99_complex and np.iscomplexobj(data):
+        return (downcoef(part, data.real, wavelet, mode, level) +
+                1j*downcoef(part, data.imag, wavelet, mode, level))
+    # accept array_like input; make a copy to ensure a contiguous array
+    dt = _check_dtype(data)
+    data = np.asarray(data, dtype=dt, order='C')
+    if data.ndim > 1:
+        raise ValueError("downcoef only supports 1d data.")
+    if part not in 'ad':
+        raise ValueError("Argument 1 must be 'a' or 'd', not '%s'." % part)
+    mode = Modes.from_object(mode)
+    wavelet = _as_wavelet(wavelet)
+    return np.asarray(_downcoef(part == 'a', data, wavelet, mode, level))
+
+
+def upcoef(part, coeffs, wavelet, level=1, take=0):
+    """
+    upcoef(part, coeffs, wavelet, level=1, take=0)
+
+    Direct reconstruction from coefficients.
+
+    Parameters
+    ----------
+    part : str
+        Coefficients type:
+        * 'a' - approximations reconstruction is performed
+        * 'd' - details reconstruction is performed
+    coeffs : array_like
+        Coefficients array to recontruct
+    wavelet : Wavelet object or name
+        Wavelet to use
+    level : int, optional
+        Multilevel reconstruction level.  Default is 1.
+    take : int, optional
+        Take central part of length equal to 'take' from the result.
+        Default is 0.
+
+    Returns
+    -------
+    rec : ndarray
+        1-D array with reconstructed data from coefficients.
+
+    See Also
+    --------
+    downcoef
+
+    Examples
+    --------
+    >>> import pywt
+    >>> data = [1,2,3,4,5,6]
+    >>> (cA, cD) = pywt.dwt(data, 'db2', 'smooth')
+    >>> pywt.upcoef('a', cA, 'db2') + pywt.upcoef('d', cD, 'db2')
+    array([-0.25      , -0.4330127 ,  1.        ,  2.        ,  3.        ,
+            4.        ,  5.        ,  6.        ,  1.78589838, -1.03108891])
+    >>> n = len(data)
+    >>> pywt.upcoef('a', cA, 'db2', take=n) + pywt.upcoef('d', cD, 'db2', take=n)
+    array([ 1.,  2.,  3.,  4.,  5.,  6.])
+
+    """
+    if not _have_c99_complex and np.iscomplexobj(coeffs):
+        return (upcoef(part, coeffs.real, wavelet, level, take) +
+                1j*upcoef(part, coeffs.imag, wavelet, level, take))
+    # accept array_like input; make a copy to ensure a contiguous array
+    dt = _check_dtype(coeffs)
+    coeffs = np.asarray(coeffs, dtype=dt, order='C')
+    if coeffs.ndim > 1:
+        raise ValueError("upcoef only supports 1d coeffs.")
+    wavelet = _as_wavelet(wavelet)
+    if part not in 'ad':
+        raise ValueError("Argument 1 must be 'a' or 'd', not '%s'." % part)
+    return np.asarray(_upcoef(part == 'a', coeffs, wavelet, level, take))
+
+
+def pad(x, pad_widths, mode):
+    """Extend a 1D signal using a given boundary mode.
+
+    This function operates like :func:`numpy.pad` but supports all signal
+    extension modes that can be used by PyWavelets discrete wavelet transforms.
+
+    Parameters
+    ----------
+    x : ndarray
+        The array to pad
+    pad_widths : {sequence, array_like, int}
+        Number of values padded to the edges of each axis.
+        ``((before_1, after_1), … (before_N, after_N))`` unique pad widths for
+        each axis. ``((before, after),)`` yields same before and after pad for
+        each axis. ``(pad,)`` or int is a shortcut for
+        ``before = after = pad width`` for all axes.
+    mode : str, optional
+        Signal extension mode, see :ref:`Modes <ref-modes>`.
+
+    Returns
+    -------
+    pad : ndarray
+        Padded array of rank equal to array with shape increased according to
+        ``pad_widths``.
+
+    Notes
+    -----
+    The performance of padding in dimensions > 1 may be substantially slower
+    for modes ``'smooth'`` and ``'antisymmetric'`` as these modes are not
+    supported efficiently by the underlying :func:`numpy.pad` function.
+
+    Note that the behavior of the ``'constant'`` mode here follows the
+    PyWavelets convention which is different from NumPy (it is equivalent to
+    ``mode='edge'`` in :func:`numpy.pad`).
+    """
+    x = np.asanyarray(x)
+
+    # process pad_widths exactly as in numpy.pad
+    pad_widths = np.array(pad_widths)
+    pad_widths = np.round(pad_widths).astype(np.intp, copy=False)
+    if pad_widths.min() < 0:
+        raise ValueError("pad_widths must be > 0")
+    pad_widths = np.broadcast_to(pad_widths, (x.ndim, 2)).tolist()
+
+    if mode in ['symmetric', 'reflect']:
+        xp = np.pad(x, pad_widths, mode=mode)
+    elif mode in ['periodic', 'periodization']:
+        if mode == 'periodization':
+            # Promote odd-sized dimensions to even length by duplicating the
+            # last value.
+            edge_pad_widths = [(0, x.shape[ax] % 2)
+                               for ax in range(x.ndim)]
+            x = np.pad(x, edge_pad_widths, mode='edge')
+        xp = np.pad(x, pad_widths, mode='wrap')
+    elif mode == 'zero':
+        xp = np.pad(x, pad_widths, mode='constant', constant_values=0)
+    elif mode == 'constant':
+        xp = np.pad(x, pad_widths, mode='edge')
+    elif mode == 'smooth':
+        def pad_smooth(vector, pad_width, iaxis, kwargs):
+            # smooth extension to left
+            left = vector[pad_width[0]]
+            slope_left = (left - vector[pad_width[0] + 1])
+            vector[:pad_width[0]] = \
+                left + np.arange(pad_width[0], 0, -1) * slope_left
+
+            # smooth extension to right
+            right = vector[-pad_width[1] - 1]
+            slope_right = (right - vector[-pad_width[1] - 2])
+            vector[-pad_width[1]:] = \
+                right + np.arange(1, pad_width[1] + 1) * slope_right
+            return vector
+        xp = np.pad(x, pad_widths, pad_smooth)
+    elif mode == 'antisymmetric':
+        def pad_antisymmetric(vector, pad_width, iaxis, kwargs):
+            # smooth extension to left
+            # implement by flipping portions symmetric padding
+            npad_l, npad_r = pad_width
+            vsize_nonpad = vector.size - npad_l - npad_r
+            # Note: must modify vector in-place
+            vector[:] = np.pad(vector[pad_width[0]:-pad_width[-1]],
+                               pad_width, mode='symmetric')
+            vp = vector
+            r_edge = npad_l + vsize_nonpad - 1
+            l_edge = npad_l
+            # width of each reflected segment
+            seg_width = vsize_nonpad
+            # flip reflected segments on the right of the original signal
+            n = 1
+            while r_edge <= vp.size:
+                segment_slice = slice(r_edge + 1,
+                                      min(r_edge + 1 + seg_width, vp.size))
+                if n % 2:
+                    vp[segment_slice] *= -1
+                r_edge += seg_width
+                n += 1
+
+            # flip reflected segments on the left of the original signal
+            n = 1
+            while l_edge >= 0:
+                segment_slice = slice(max(0, l_edge - seg_width), l_edge)
+                if n % 2:
+                    vp[segment_slice] *= -1
+                l_edge -= seg_width
+                n += 1
+            return vector
+        xp = np.pad(x, pad_widths, pad_antisymmetric)
+    elif mode == 'antireflect':
+        xp = np.pad(x, pad_widths, mode='reflect', reflect_type='odd')
+    else:
+        raise ValueError(
+            ("unsupported mode: {}. The supported modes are {}").format(
+                mode, Modes.modes))
+    return xp

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/pywt/_functions.py

@@ -0,0 +1,240 @@
+# Copyright (c) 2006-2012 Filip Wasilewski <http://en.ig.ma/>
+# Copyright (c) 2012-2016 The PyWavelets Developers
+#                         <https://github.com/PyWavelets/pywt>
+# See COPYING for license details.
+
+"""
+Other wavelet related functions.
+"""
+
+from __future__ import division, print_function, absolute_import
+
+import warnings
+
+import numpy as np
+from numpy.fft import fft
+
+from ._extensions._pywt import DiscreteContinuousWavelet, Wavelet, ContinuousWavelet
+
+
+__all__ = ["integrate_wavelet", "central_frequency", "scale2frequency", "qmf",
+           "orthogonal_filter_bank",
+           "intwave", "centrfrq", "scal2frq", "orthfilt"]
+
+
+_DEPRECATION_MSG = ("`{old}` has been renamed to `{new}` and will "
+                    "be removed in a future version of pywt.")
+
+
+def _integrate(arr, step):
+    integral = np.cumsum(arr)
+    integral *= step
+    return integral
+
+
+def intwave(*args, **kwargs):
+    msg = _DEPRECATION_MSG.format(old='intwave', new='integrate_wavelet')
+    warnings.warn(msg, DeprecationWarning)
+    return integrate_wavelet(*args, **kwargs)
+
+
+def centrfrq(*args, **kwargs):
+    msg = _DEPRECATION_MSG.format(old='centrfrq', new='central_frequency')
+    warnings.warn(msg, DeprecationWarning)
+    return central_frequency(*args, **kwargs)
+
+
+def scal2frq(*args, **kwargs):
+    msg = _DEPRECATION_MSG.format(old='scal2frq', new='scale2frequency')
+    warnings.warn(msg, DeprecationWarning)
+    return scale2frequency(*args, **kwargs)
+
+
+def orthfilt(*args, **kwargs):
+    msg = _DEPRECATION_MSG.format(old='orthfilt', new='orthogonal_filter_bank')
+    warnings.warn(msg, DeprecationWarning)
+    return orthogonal_filter_bank(*args, **kwargs)
+
+
+def integrate_wavelet(wavelet, precision=8):
+    """
+    Integrate `psi` wavelet function from -Inf to x using the rectangle
+    integration method.
+
+    Parameters
+    ----------
+    wavelet : Wavelet instance or str
+        Wavelet to integrate.  If a string, should be the name of a wavelet.
+    precision : int, optional
+        Precision that will be used for wavelet function
+        approximation computed with the wavefun(level=precision)
+        Wavelet's method (default: 8).
+
+    Returns
+    -------
+    [int_psi, x] :
+        for orthogonal wavelets
+    [int_psi_d, int_psi_r, x] :
+        for other wavelets
+
+
+    Examples
+    --------
+    >>> from pywt import Wavelet, integrate_wavelet
+    >>> wavelet1 = Wavelet('db2')
+    >>> [int_psi, x] = integrate_wavelet(wavelet1, precision=5)
+    >>> wavelet2 = Wavelet('bior1.3')
+    >>> [int_psi_d, int_psi_r, x] = integrate_wavelet(wavelet2, precision=5)
+
+    """
+    # FIXME: this function should really use scipy.integrate.quad
+
+    if type(wavelet) in (tuple, list):
+        msg = ("Integration of a general signal is deprecated "
+               "and will be removed in a future version of pywt.")
+        warnings.warn(msg, DeprecationWarning)
+    elif not isinstance(wavelet, (Wavelet, ContinuousWavelet)):
+        wavelet = DiscreteContinuousWavelet(wavelet)
+
+    if type(wavelet) in (tuple, list):
+        psi, x = np.asarray(wavelet[0]), np.asarray(wavelet[1])
+        step = x[1] - x[0]
+        return _integrate(psi, step), x
+
+    functions_approximations = wavelet.wavefun(precision)
+
+    if len(functions_approximations) == 2:      # continuous wavelet
+        psi, x = functions_approximations
+        step = x[1] - x[0]
+        return _integrate(psi, step), x
+
+    elif len(functions_approximations) == 3:    # orthogonal wavelet
+        phi, psi, x = functions_approximations
+        step = x[1] - x[0]
+        return _integrate(psi, step), x
+
+    else:                                       # biorthogonal wavelet
+        phi_d, psi_d, phi_r, psi_r, x = functions_approximations
+        step = x[1] - x[0]
+        return _integrate(psi_d, step), _integrate(psi_r, step), x
+
+
+def central_frequency(wavelet, precision=8):
+    """
+    Computes the central frequency of the `psi` wavelet function.
+
+    Parameters
+    ----------
+    wavelet : Wavelet instance, str or tuple
+        Wavelet to integrate.  If a string, should be the name of a wavelet.
+    precision : int, optional
+        Precision that will be used for wavelet function
+        approximation computed with the wavefun(level=precision)
+        Wavelet's method (default: 8).
+
+    Returns
+    -------
+    scalar
+
+    """
+
+    if not isinstance(wavelet, (Wavelet, ContinuousWavelet)):
+        wavelet = DiscreteContinuousWavelet(wavelet)
+
+    functions_approximations = wavelet.wavefun(precision)
+
+    if len(functions_approximations) == 2:
+        psi, x = functions_approximations
+    else:
+        # (psi, x)   for (phi, psi, x)
+        # (psi_d, x) for (phi_d, psi_d, phi_r, psi_r, x)
+        psi, x = functions_approximations[1], functions_approximations[-1]
+
+    domain = float(x[-1] - x[0])
+    assert domain > 0
+
+    index = np.argmax(abs(fft(psi)[1:])) + 2
+    if index > len(psi) / 2:
+        index = len(psi) - index + 2
+
+    return 1.0 / (domain / (index - 1))
+
+
+def scale2frequency(wavelet, scale, precision=8):
+    """
+
+    Parameters
+    ----------
+    wavelet : Wavelet instance or str
+        Wavelet to integrate.  If a string, should be the name of a wavelet.
+    scale : scalar
+    precision : int, optional
+        Precision that will be used for wavelet function approximation computed
+        with ``wavelet.wavefun(level=precision)``.  Default is 8.
+
+    Returns
+    -------
+    freq : scalar
+
+    """
+    return central_frequency(wavelet, precision=precision) / scale
+
+
+def qmf(filt):
+    """
+    Returns the Quadrature Mirror Filter(QMF).
+
+    The magnitude response of QMF is mirror image about `pi/2` of that of the
+    input filter.
+
+    Parameters
+    ----------
+    filt : array_like
+        Input filter for which QMF needs to be computed.
+
+    Returns
+    -------
+    qm_filter : ndarray
+        Quadrature mirror of the input filter.
+
+    """
+    qm_filter = np.array(filt)[::-1]
+    qm_filter[1::2] = -qm_filter[1::2]
+    return qm_filter
+
+
+def orthogonal_filter_bank(scaling_filter):
+    """
+    Returns the orthogonal filter bank.
+
+    The orthogonal filter bank consists of the HPFs and LPFs at
+    decomposition and reconstruction stage for the input scaling filter.
+
+    Parameters
+    ----------
+    scaling_filter : array_like
+        Input scaling filter (father wavelet).
+
+    Returns
+    -------
+    orth_filt_bank : tuple of 4 ndarrays
+        The orthogonal filter bank of the input scaling filter in the order :
+        1] Decomposition LPF
+        2] Decomposition HPF
+        3] Reconstruction LPF
+        4] Reconstruction HPF
+
+    """
+    if not (len(scaling_filter) % 2 == 0):
+        raise ValueError("`scaling_filter` length has to be even.")
+
+    scaling_filter = np.asarray(scaling_filter, dtype=np.float64)
+
+    rec_lo = np.sqrt(2) * scaling_filter / np.sum(scaling_filter)
+    dec_lo = rec_lo[::-1]
+
+    rec_hi = qmf(rec_lo)
+    dec_hi = rec_hi[::-1]
+
+    orth_filt_bank = (dec_lo, dec_hi, rec_lo, rec_hi)
+    return orth_filt_bank

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/pywt/_mra.py

@@ -0,0 +1,427 @@
+from functools import partial, reduce
+
+import numpy as np
+
+from ._multilevel import (_prep_axes_wavedecn, wavedec, wavedec2, wavedecn,
+                          waverec, waverec2, waverecn)
+from ._swt import iswt, iswt2, iswtn, swt, swt2, swt_max_level, swtn
+from ._utils import _modes_per_axis, _wavelets_per_axis
+
+__all__ = ["mra", "mra2", "mran", "imra", "imra2", "imran"]
+
+
+def mra(data, wavelet, level=None, axis=-1, transform='swt',
+        mode='periodization'):
+    """Forward 1D multiresolution analysis.
+
+    It is a projection onto the wavelet subspaces.
+
+    Parameters
+    ----------
+    data: array_like
+        Input data
+    wavelet : Wavelet object or name string
+        Wavelet to use
+    level : int, optional
+        Decomposition level (must be >= 0). If level is None (default) then it
+        will be calculated using the `dwt_max_level` function.
+    axis: int, optional
+        Axis over which to compute the DWT. If not given, the last axis is
+        used. Currently only available when ``transform='dwt'``.
+    transform : {'dwt', 'swt'}
+        Whether to use the DWT or SWT for the transforms.
+    mode : str, optional
+        Signal extension mode, see `Modes` (default: 'symmetric'). This option
+        is only used when transform='dwt'.
+
+    Returns
+    -------
+    [cAn, {details_level_n}, ... {details_level_1}] : list
+        For more information, see the detailed description in `wavedec`
+
+    See Also
+    --------
+    imra, swt
+
+    Notes
+    -----
+    This is sometimes referred to as an additive decomposition because the
+    inverse transform (``imra``) is just the sum of the coefficient arrays
+    [1]_. The decomposition using ``transform='dwt'`` corresponds to section
+    2.2 while that using an undecimated transform (``transform='swt'``) is
+    described in section 3.2 and appendix A.
+
+    This transform does not share the variance partition property of ``swt``
+    with `norm=True`. It does however, result in coefficients that are
+    temporally aligned regardless of the symmetry of the wavelet used.
+
+    The redundancy of this transform is ``(level + 1)``.
+
+    References
+    ----------
+    .. [1] Donald B. Percival and Harold O. Mofjeld. Analysis of Subtidal
+        Coastal Sea Level Fluctuations Using Wavelets. Journal of the American
+        Statistical Association Vol. 92, No. 439 (Sep., 1997), pp. 868-880.
+        https://doi.org/10.2307/2965551
+
+    """
+    if transform == 'swt':
+        if mode != 'periodization':
+            raise ValueError(
+                "transform swt only supports mode='periodization'")
+        kwargs = dict(wavelet=wavelet, axis=axis, norm=True)
+        forward = partial(swt, level=level, trim_approx=True, **kwargs)
+        inverse = partial(iswt, **kwargs)
+        is_swt = True
+    elif transform == 'dwt':
+        kwargs = dict(wavelet=wavelet, mode=mode, axis=axis)
+        forward = partial(wavedec, level=level, **kwargs)
+        inverse = partial(waverec, **kwargs)
+        is_swt = False
+    else:
+        raise ValueError("unrecognized transform: {}".format(transform))
+
+    wav_coeffs = forward(data)
+
+    mra_coeffs = []
+    nc = len(wav_coeffs)
+
+    if is_swt:
+        # replicate same zeros array to save memory
+        z = np.zeros_like(wav_coeffs[0])
+        tmp = [z, ] * nc
+    else:
+        # zero arrays have variable size in DWT case
+        tmp = [np.zeros_like(c) for c in wav_coeffs]
+
+    for j in range(nc):
+        # tmp has arrays of zeros except for the jth entry
+        tmp[j] = wav_coeffs[j]
+
+        # reconstruct
+        rec = inverse(tmp)
+        if rec.shape != data.shape:
+            # trim any excess coefficients
+            rec = rec[tuple([slice(sz) for sz in data.shape])]
+        mra_coeffs.append(rec)
+
+        # restore zeros
+        if is_swt:
+            tmp[j] = z
+        else:
+            tmp[j] = np.zeros_like(tmp[j])
+    return mra_coeffs
+
+
+def imra(mra_coeffs):
+    """Inverse 1D multiresolution analysis via summation.
+
+    Parameters
+    ----------
+    mra_coeffs : list of ndarray
+        Multiresolution analysis coefficients as returned by `mra`.
+
+    Returns
+    -------
+    rec : ndarray
+        The reconstructed signal.
+
+    See Also
+    --------
+    mra
+
+    References
+    ----------
+    .. [1] Donald B. Percival and Harold O. Mofjeld. Analysis of Subtidal
+        Coastal Sea Level Fluctuations Using Wavelets. Journal of the American
+        Statistical Association Vol. 92, No. 439 (Sep., 1997), pp. 868-880.
+        https://doi.org/10.2307/2965551
+    """
+    return reduce(lambda x, y: x + y, mra_coeffs)
+
+
+def mra2(data, wavelet, level=None, axes=(-2, -1), transform='swt2',
+         mode='periodization'):
+    """Forward 2D multiresolution analysis.
+
+    It is a projection onto wavelet subspaces.
+
+    Parameters
+    ----------
+    data: array_like
+        Input data
+    wavelet : Wavelet object or name string, or 2-tuple of wavelets
+        Wavelet to use.  This can also be a tuple containing a wavelet to
+        apply along each axis in `axes`.
+    level : int, optional
+        Decomposition level (must be >= 0). If level is None (default) then it
+        will be calculated using the `dwt_max_level` function.
+    axes : 2-tuple of ints, optional
+        Axes over which to compute the DWT. Repeated elements are not allowed.
+        Currently only available when ``transform='dwt2'``.
+    transform : {'dwt2', 'swt2'}
+        Whether to use the DWT or SWT for the transforms.
+    mode : str or 2-tuple of str, optional
+        Signal extension mode, see `Modes` (default: 'symmetric'). This option
+        is only used when transform='dwt2'.
+
+    Returns
+    -------
+    coeffs : list
+        For more information, see the detailed description in `wavedec2`
+
+    Notes
+    -----
+    This is sometimes referred to as an additive decomposition because the
+    inverse transform (``imra2``) is just the sum of the coefficient arrays
+    [1]_. The decomposition using ``transform='dwt'`` corresponds to section
+    2.2 while that using an undecimated transform (``transform='swt'``) is
+    described in section 3.2 and appendix A.
+
+    This transform does not share the variance partition property of ``swt2``
+    with `norm=True`. It does however, result in coefficients that are
+    temporally aligned regardless of the symmetry of the wavelet used.
+
+    The redundancy of this transform is ``3 * level + 1``.
+
+    See Also
+    --------
+    imra2, swt2
+
+    References
+    ----------
+    .. [1] Donald B. Percival and Harold O. Mofjeld. Analysis of Subtidal
+        Coastal Sea Level Fluctuations Using Wavelets. Journal of the American
+        Statistical Association Vol. 92, No. 439 (Sep., 1997), pp. 868-880.
+        https://doi.org/10.2307/2965551
+    """
+    if transform == 'swt2':
+        if mode != 'periodization':
+            raise ValueError(
+                "transform swt only supports mode='periodization'")
+        if level is None:
+            level = min(swt_max_level(s) for s in data.shape)
+        kwargs = dict(wavelet=wavelet, axes=axes, norm=True)
+        forward = partial(swt2, level=level, trim_approx=True, **kwargs)
+        inverse = partial(iswt2, **kwargs)
+    elif transform == 'dwt2':
+        kwargs = dict(wavelet=wavelet, mode=mode, axes=axes)
+        forward = partial(wavedec2, level=level, **kwargs)
+        inverse = partial(waverec2, **kwargs)
+    else:
+        raise ValueError("unrecognized transform: {}".format(transform))
+
+    wav_coeffs = forward(data)
+
+    mra_coeffs = []
+    nc = len(wav_coeffs)
+    z = np.zeros_like(wav_coeffs[0])
+    tmp = [z]
+    for j in range(1, nc):
+        tmp.append([np.zeros_like(c) for c in wav_coeffs[j]])
+
+    # tmp has arrays of zeros except for the jth entry
+    tmp[0] = wav_coeffs[0]
+    # reconstruct
+    rec = inverse(tmp)
+    if rec.shape != data.shape:
+        # trim any excess coefficients
+        rec = rec[tuple([slice(sz) for sz in data.shape])]
+    mra_coeffs.append(rec)
+    # restore zeros
+    tmp[0] = z
+
+    for j in range(1, nc):
+        dcoeffs = []
+        for n in range(3):
+            # tmp has arrays of zeros except for the jth entry
+            z = tmp[j][n]
+            tmp[j][n] = wav_coeffs[j][n]
+            # reconstruct
+            rec = inverse(tmp)
+            if rec.shape != data.shape:
+                # trim any excess coefficients
+                rec = rec[tuple([slice(sz) for sz in data.shape])]
+            dcoeffs.append(rec)
+            # restore zeros
+            tmp[j][n] = z
+        mra_coeffs.append(tuple(dcoeffs))
+    return mra_coeffs
+
+
+def imra2(mra_coeffs):
+    """Inverse 2D multiresolution analysis via summation.
+
+    Parameters
+    ----------
+    mra_coeffs : list
+        Multiresolution analysis coefficients as returned by `mra2`.
+
+    Returns
+    -------
+    rec : ndarray
+        The reconstructed signal.
+
+    See Also
+    --------
+    mra2
+
+    References
+    ----------
+    .. [1] Donald B. Percival and Harold O. Mofjeld. Analysis of Subtidal
+        Coastal Sea Level Fluctuations Using Wavelets. Journal of the American
+        Statistical Association Vol. 92, No. 439 (Sep., 1997), pp. 868-880.
+        https://doi.org/10.2307/2965551
+    """
+    rec = mra_coeffs[0]
+    for j in range(1, len(mra_coeffs)):
+        for n in range(3):
+            rec += mra_coeffs[j][n]
+    return rec
+
+
+def mran(data, wavelet, level=None, axes=None, transform='swtn',
+         mode='periodization'):
+    """Forward nD multiresolution analysis.
+
+    It is a projection onto the wavelet subspaces.
+
+    Parameters
+    ----------
+    data: array_like
+        Input data
+    wavelet : Wavelet object or name string, or tuple of wavelets
+        Wavelet to use. This can also be a tuple containing a wavelet to
+        apply along each axis in `axes`.
+    level : int, optional
+        Decomposition level (must be >= 0). If level is None (default) then it
+        will be calculated using the `dwt_max_level` function.
+    axes : tuple of ints, optional
+        Axes over which to compute the DWT. Repeated elements are not allowed.
+    transform : {'dwtn', 'swtn'}
+        Whether to use the DWT or SWT for the transforms.
+    mode : str or tuple of str, optional
+        Signal extension mode, see `Modes` (default: 'symmetric'). This option
+        is only used when transform='dwtn'.
+
+    Returns
+    -------
+    coeffs : list
+        For more information, see the detailed description in `wavedecn`.
+
+    See Also
+    --------
+    imran, swtn
+
+    Notes
+    -----
+    This is sometimes referred to as an additive decomposition because the
+    inverse transform (``imran``) is just the sum of the coefficient arrays
+    [1]_. The decomposition using ``transform='dwt'`` corresponds to section
+    2.2 while that using an undecimated transform (``transform='swt'``) is
+    described in section 3.2 and appendix A.
+
+    This transform does not share the variance partition property of ``swtn``
+    with `norm=True`. It does however, result in coefficients that are
+    temporally aligned regardless of the symmetry of the wavelet used.
+
+    The redundancy of this transform is ``(2**n - 1) * level + 1`` where ``n``
+    corresponds to the number of axes transformed.
+
+    References
+    ----------
+    .. [1] Donald B. Percival and Harold O. Mofjeld. Analysis of Subtidal
+        Coastal Sea Level Fluctuations Using Wavelets. Journal of the American
+        Statistical Association Vol. 92, No. 439 (Sep., 1997), pp. 868-880.
+        https://doi.org/10.2307/2965551
+    """
+    axes, axes_shapes, ndim_transform = _prep_axes_wavedecn(data.shape, axes)
+    wavelets = _wavelets_per_axis(wavelet, axes)
+
+    if transform == 'swtn':
+        if mode != 'periodization':
+            raise ValueError(
+                "transform swt only supports mode='periodization'")
+        if level is None:
+            level = min(swt_max_level(s) for s in data.shape)
+        kwargs = dict(wavelet=wavelets, axes=axes, norm=True)
+        forward = partial(swtn, level=level, trim_approx=True, **kwargs)
+        inverse = partial(iswtn, **kwargs)
+    elif transform == 'dwtn':
+        modes = _modes_per_axis(mode, axes)
+        kwargs = dict(wavelet=wavelets, mode=modes, axes=axes)
+        forward = partial(wavedecn, level=level, **kwargs)
+        inverse = partial(waverecn, **kwargs)
+    else:
+        raise ValueError("unrecognized transform: {}".format(transform))
+
+    wav_coeffs = forward(data)
+
+    mra_coeffs = []
+    nc = len(wav_coeffs)
+    z = np.zeros_like(wav_coeffs[0])
+    tmp = [z]
+    for j in range(1, nc):
+        tmp.append({k: np.zeros_like(v) for k, v in wav_coeffs[j].items()})
+
+    # tmp has arrays of zeros except for the jth entry
+    tmp[0] = wav_coeffs[0]
+    # reconstruct
+    rec = inverse(tmp)
+    if rec.shape != data.shape:
+        # trim any excess coefficients
+        rec = rec[tuple([slice(sz) for sz in data.shape])]
+    mra_coeffs.append(rec)
+    # restore zeros
+    tmp[0] = z
+
+    for j in range(1, nc):
+        dcoeffs = {}
+        dkeys = list(wav_coeffs[j].keys())
+        for k in dkeys:
+            # tmp has arrays of zeros except for the jth entry
+            z = tmp[j][k]
+            tmp[j][k] = wav_coeffs[j][k]
+            # tmp[j]['a' * len(k)] = z
+            # reconstruct
+            rec = inverse(tmp)
+            if rec.shape != data.shape:
+                # trim any excess coefficients
+                rec = rec[tuple([slice(sz) for sz in data.shape])]
+            dcoeffs[k] = rec
+            # restore zeros
+            tmp[j][k] = z
+            # tmp[j].pop('a' * len(k))
+        mra_coeffs.append(dcoeffs)
+    return mra_coeffs
+
+
+def imran(mra_coeffs):
+    """Inverse nD multiresolution analysis via summation.
+
+    Parameters
+    ----------
+    mra_coeffs : list
+        Multiresolution analysis coefficients as returned by `mra2`.
+
+    Returns
+    -------
+    rec : ndarray
+        The reconstructed signal.
+
+    See Also
+    --------
+    mran
+
+    References
+    ----------
+    .. [1] Donald B. Percival and Harold O. Mofjeld. Analysis of Subtidal
+        Coastal Sea Level Fluctuations Using Wavelets. Journal of the American
+        Statistical Association Vol. 92, No. 439 (Sep., 1997), pp. 868-880.
+        https://doi.org/10.2307/2965551
+    """
+    rec = mra_coeffs[0]
+    for j in range(1, len(mra_coeffs)):
+        for k, v in mra_coeffs[j].items():
+            rec += v
+    return rec

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/pywt/_multidim.py

@@ -0,0 +1,314 @@
+# Copyright (c) 2006-2012 Filip Wasilewski <http://en.ig.ma/>
+# Copyright (c) 2012-2016 The PyWavelets Developers
+#                         <https://github.com/PyWavelets/pywt>
+# See COPYING for license details.
+
+"""
+2D and nD Discrete Wavelet Transforms and Inverse Discrete Wavelet Transforms.
+"""
+
+from __future__ import division, print_function, absolute_import
+
+from itertools import product
+
+import numpy as np
+
+from ._c99_config import _have_c99_complex
+from ._extensions._dwt import dwt_axis, idwt_axis
+from ._utils import _wavelets_per_axis, _modes_per_axis
+
+
+__all__ = ['dwt2', 'idwt2', 'dwtn', 'idwtn']
+
+
+def dwt2(data, wavelet, mode='symmetric', axes=(-2, -1)):
+    """
+    2D Discrete Wavelet Transform.
+
+    Parameters
+    ----------
+    data : array_like
+        2D array with input data
+    wavelet : Wavelet object or name string, or 2-tuple of wavelets
+        Wavelet to use.  This can also be a tuple containing a wavelet to
+        apply along each axis in ``axes``.
+    mode : str or 2-tuple of strings, optional
+        Signal extension mode, see :ref:`Modes <ref-modes>`. This can
+        also be a tuple of modes specifying the mode to use on each axis in
+        ``axes``.
+    axes : 2-tuple of ints, optional
+        Axes over which to compute the DWT. Repeated elements mean the DWT will
+        be performed multiple times along these axes.
+
+    Returns
+    -------
+    (cA, (cH, cV, cD)) : tuple
+        Approximation, horizontal detail, vertical detail and diagonal
+        detail coefficients respectively.  Horizontal refers to array axis 0
+        (or ``axes[0]`` for user-specified ``axes``).
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> import pywt
+    >>> data = np.ones((4,4), dtype=np.float64)
+    >>> coeffs = pywt.dwt2(data, 'haar')
+    >>> cA, (cH, cV, cD) = coeffs
+    >>> cA
+    array([[ 2.,  2.],
+           [ 2.,  2.]])
+    >>> cV
+    array([[ 0.,  0.],
+           [ 0.,  0.]])
+
+    """
+    axes = tuple(axes)
+    data = np.asarray(data)
+    if len(axes) != 2:
+        raise ValueError("Expected 2 axes")
+    if data.ndim < len(np.unique(axes)):
+        raise ValueError("Input array has fewer dimensions than the specified "
+                         "axes")
+
+    coefs = dwtn(data, wavelet, mode, axes)
+    return coefs['aa'], (coefs['da'], coefs['ad'], coefs['dd'])
+
+
+def idwt2(coeffs, wavelet, mode='symmetric', axes=(-2, -1)):
+    """
+    2-D Inverse Discrete Wavelet Transform.
+
+    Reconstructs data from coefficient arrays.
+
+    Parameters
+    ----------
+    coeffs : tuple
+        (cA, (cH, cV, cD)) A tuple with approximation coefficients and three
+        details coefficients 2D arrays like from ``dwt2``.  If any of these
+        components are set to ``None``, it will be treated as zeros.
+    wavelet : Wavelet object or name string, or 2-tuple of wavelets
+        Wavelet to use.  This can also be a tuple containing a wavelet to
+        apply along each axis in ``axes``.
+    mode : str or 2-tuple of strings, optional
+        Signal extension mode, see :ref:`Modes <ref-modes>`. This can
+        also be a tuple of modes specifying the mode to use on each axis in
+        ``axes``.
+    axes : 2-tuple of ints, optional
+        Axes over which to compute the IDWT. Repeated elements mean the IDWT
+        will be performed multiple times along these axes.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> import pywt
+    >>> data = np.array([[1,2], [3,4]], dtype=np.float64)
+    >>> coeffs = pywt.dwt2(data, 'haar')
+    >>> pywt.idwt2(coeffs, 'haar')
+    array([[ 1.,  2.],
+           [ 3.,  4.]])
+
+    """
+    # L -low-pass data, H - high-pass data
+    LL, (HL, LH, HH) = coeffs
+    axes = tuple(axes)
+    if len(axes) != 2:
+        raise ValueError("Expected 2 axes")
+
+    coeffs = {'aa': LL, 'da': HL, 'ad': LH, 'dd': HH}
+    return idwtn(coeffs, wavelet, mode, axes)
+
+
+def dwtn(data, wavelet, mode='symmetric', axes=None):
+    """
+    Single-level n-dimensional Discrete Wavelet Transform.
+
+    Parameters
+    ----------
+    data : array_like
+        n-dimensional array with input data.
+    wavelet : Wavelet object or name string, or tuple of wavelets
+        Wavelet to use.  This can also be a tuple containing a wavelet to
+        apply along each axis in ``axes``.
+    mode : str or tuple of string, optional
+        Signal extension mode used in the decomposition,
+        see :ref:`Modes <ref-modes>`. This can also be a tuple of modes
+        specifying the mode to use on each axis in ``axes``.
+    axes : sequence of ints, optional
+        Axes over which to compute the DWT. Repeated elements mean the DWT will
+        be performed multiple times along these axes. A value of ``None`` (the
+        default) selects all axes.
+
+        Axes may be repeated, but information about the original size may be
+        lost if it is not divisible by ``2 ** nrepeats``. The reconstruction
+        will be larger, with additional values derived according to the
+        ``mode`` parameter. ``pywt.wavedecn`` should be used for multilevel
+        decomposition.
+
+    Returns
+    -------
+    coeffs : dict
+        Results are arranged in a dictionary, where key specifies
+        the transform type on each dimension and value is a n-dimensional
+        coefficients array.
+
+        For example, for a 2D case the result will look something like this::
+
+            {'aa': <coeffs>  # A(LL) - approx. on 1st dim, approx. on 2nd dim
+             'ad': <coeffs>  # V(LH) - approx. on 1st dim, det. on 2nd dim
+             'da': <coeffs>  # H(HL) - det. on 1st dim, approx. on 2nd dim
+             'dd': <coeffs>  # D(HH) - det. on 1st dim, det. on 2nd dim
+            }
+
+        For user-specified ``axes``, the order of the characters in the
+        dictionary keys map to the specified ``axes``.
+
+    """
+    data = np.asarray(data)
+    if not _have_c99_complex and np.iscomplexobj(data):
+        real = dwtn(data.real, wavelet, mode, axes)
+        imag = dwtn(data.imag, wavelet, mode, axes)
+        return dict((k, real[k] + 1j * imag[k]) for k in real.keys())
+
+    if data.dtype == np.dtype('object'):
+        raise TypeError("Input must be a numeric array-like")
+    if data.ndim < 1:
+        raise ValueError("Input data must be at least 1D")
+
+    if axes is None:
+        axes = range(data.ndim)
+    axes = [a + data.ndim if a < 0 else a for a in axes]
+
+    modes = _modes_per_axis(mode, axes)
+    wavelets = _wavelets_per_axis(wavelet, axes)
+
+    coeffs = [('', data)]
+    for axis, wav, mode in zip(axes, wavelets, modes):
+        new_coeffs = []
+        for subband, x in coeffs:
+            cA, cD = dwt_axis(x, wav, mode, axis)
+            new_coeffs.extend([(subband + 'a', cA),
+                               (subband + 'd', cD)])
+        coeffs = new_coeffs
+    return dict(coeffs)
+
+
+def _fix_coeffs(coeffs):
+    missing_keys = [k for k, v in coeffs.items() if v is None]
+    if missing_keys:
+        raise ValueError(
+            "The following detail coefficients were set to None:\n"
+            "{0}\n"
+            "For multilevel transforms, rather than setting\n"
+            "\tcoeffs[key] = None\n"
+            "use\n"
+            "\tcoeffs[key] = np.zeros_like(coeffs[key])\n".format(
+                missing_keys))
+
+    invalid_keys = [k for k, v in coeffs.items() if
+                    not set(k) <= set('ad')]
+    if invalid_keys:
+        raise ValueError(
+            "The following invalid keys were found in the detail "
+            "coefficient dictionary: {}.".format(invalid_keys))
+
+    key_lengths = [len(k) for k in coeffs.keys()]
+    if len(np.unique(key_lengths)) > 1:
+        raise ValueError(
+            "All detail coefficient names must have equal length.")
+
+    return dict((k, np.asarray(v)) for k, v in coeffs.items())
+
+
+def idwtn(coeffs, wavelet, mode='symmetric', axes=None):
+    """
+    Single-level n-dimensional Inverse Discrete Wavelet Transform.
+
+    Parameters
+    ----------
+    coeffs: dict
+        Dictionary as in output of ``dwtn``. Missing or ``None`` items
+        will be treated as zeros.
+    wavelet : Wavelet object or name string, or tuple of wavelets
+        Wavelet to use.  This can also be a tuple containing a wavelet to
+        apply along each axis in ``axes``.
+    mode : str or list of string, optional
+        Signal extension mode used in the decomposition,
+        see :ref:`Modes <ref-modes>`. This can also be a tuple of modes
+        specifying the mode to use on each axis in ``axes``.
+    axes : sequence of ints, optional
+        Axes over which to compute the IDWT. Repeated elements mean the IDWT
+        will be performed multiple times along these axes. A value of ``None``
+        (the default) selects all axes.
+
+        For the most accurate reconstruction, the axes should be provided in
+        the same order as they were provided to ``dwtn``.
+
+    Returns
+    -------
+    data: ndarray
+        Original signal reconstructed from input data.
+
+    """
+
+    # drop the keys corresponding to value = None
+    coeffs = dict((k, v) for k, v in coeffs.items() if v is not None)
+
+    # drop the keys corresponding to value = None
+    coeffs = dict((k, v) for k, v in coeffs.items() if v is not None)
+
+    # Raise error for invalid key combinations
+    coeffs = _fix_coeffs(coeffs)
+
+    if (not _have_c99_complex and
+            any(np.iscomplexobj(v) for v in coeffs.values())):
+        real_coeffs = dict((k, v.real) for k, v in coeffs.items())
+        imag_coeffs = dict((k, v.imag) for k, v in coeffs.items())
+        return (idwtn(real_coeffs, wavelet, mode, axes) +
+                1j * idwtn(imag_coeffs, wavelet, mode, axes))
+
+    # key length matches the number of axes transformed
+    ndim_transform = max(len(key) for key in coeffs.keys())
+
+    try:
+        coeff_shapes = (v.shape for k, v in coeffs.items()
+                        if v is not None and len(k) == ndim_transform)
+        coeff_shape = next(coeff_shapes)
+    except StopIteration:
+        raise ValueError("`coeffs` must contain at least one non-null wavelet "
+                         "band")
+    if any(s != coeff_shape for s in coeff_shapes):
+        raise ValueError("`coeffs` must all be of equal size (or None)")
+
+    if axes is None:
+        axes = range(ndim_transform)
+        ndim = ndim_transform
+    else:
+        ndim = len(coeff_shape)
+    axes = [a + ndim if a < 0 else a for a in axes]
+
+    modes = _modes_per_axis(mode, axes)
+    wavelets = _wavelets_per_axis(wavelet, axes)
+    for key_length, (axis, wav, mode) in reversed(
+            list(enumerate(zip(axes, wavelets, modes)))):
+        if axis < 0 or axis >= ndim:
+            raise np.AxisError("Axis greater than data dimensions")
+
+        new_coeffs = {}
+        new_keys = [''.join(coef) for coef in product('ad', repeat=key_length)]
+
+        for key in new_keys:
+            L = coeffs.get(key + 'a', None)
+            H = coeffs.get(key + 'd', None)
+            if L is not None and H is not None:
+                if L.dtype != H.dtype:
+                    # upcast to a common dtype (float64 or complex128)
+                    if L.dtype.kind == 'c' or H.dtype.kind == 'c':
+                        dtype = np.complex128
+                    else:
+                        dtype = np.float64
+                    L = np.asarray(L, dtype=dtype)
+                    H = np.asarray(H, dtype=dtype)
+            new_coeffs[key] = idwt_axis(L, H, wav, mode, axis)
+        coeffs = new_coeffs
+
+    return coeffs['']

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/pywt/_multilevel.py

@@ -0,0 +1,1561 @@
+# Copyright (c) 2006-2012 Filip Wasilewski <http://en.ig.ma/>
+# Copyright (c) 2012-2018 The PyWavelets Developers
+#                         <https://github.com/PyWavelets/pywt>
+# See COPYING for license details.
+
+"""
+Multilevel 1D and 2D Discrete Wavelet Transform
+and Inverse Discrete Wavelet Transform.
+"""
+
+from __future__ import division, print_function, absolute_import
+
+import numbers
+import warnings
+from itertools import product
+from copy import copy
+import numpy as np
+
+from ._extensions._pywt import Wavelet, Modes
+from ._extensions._dwt import dwt_max_level
+from ._dwt import dwt, idwt, dwt_coeff_len
+from ._multidim import dwt2, idwt2, dwtn, idwtn, _fix_coeffs
+from ._utils import _as_wavelet, _wavelets_per_axis, _modes_per_axis
+
+__all__ = ['wavedec', 'waverec', 'wavedec2', 'waverec2', 'wavedecn',
+           'waverecn', 'coeffs_to_array', 'array_to_coeffs', 'ravel_coeffs',
+           'unravel_coeffs', 'dwtn_max_level', 'wavedecn_size',
+           'wavedecn_shapes', 'fswavedecn', 'fswaverecn', 'FswavedecnResult']
+
+
+def _check_level(sizes, dec_lens, level):
+    if np.isscalar(sizes):
+        sizes = (sizes, )
+    if np.isscalar(dec_lens):
+        dec_lens = (dec_lens, )
+    max_level = np.min([dwt_max_level(s, d) for s, d in zip(sizes, dec_lens)])
+    if level is None:
+        level = max_level
+    elif level < 0:
+        raise ValueError(
+            "Level value of %d is too low . Minimum level is 0." % level)
+    elif level > max_level:
+        warnings.warn(
+            ("Level value of {} is too high: all coefficients will experience "
+             "boundary effects.").format(level))
+    return level
+
+
+def wavedec(data, wavelet, mode='symmetric', level=None, axis=-1):
+    """
+    Multilevel 1D Discrete Wavelet Transform of data.
+
+    Parameters
+    ----------
+    data: array_like
+        Input data
+    wavelet : Wavelet object or name string
+        Wavelet to use
+    mode : str, optional
+        Signal extension mode, see :ref:`Modes <ref-modes>`.
+    level : int, optional
+        Decomposition level (must be >= 0). If level is None (default) then it
+        will be calculated using the ``dwt_max_level`` function.
+    axis: int, optional
+        Axis over which to compute the DWT. If not given, the
+        last axis is used.
+
+    Returns
+    -------
+    [cA_n, cD_n, cD_n-1, ..., cD2, cD1] : list
+        Ordered list of coefficients arrays
+        where ``n`` denotes the level of decomposition. The first element
+        (``cA_n``) of the result is approximation coefficients array and the
+        following elements (``cD_n`` - ``cD_1``) are details coefficients
+        arrays.
+
+    Examples
+    --------
+    >>> from pywt import wavedec
+    >>> coeffs = wavedec([1,2,3,4,5,6,7,8], 'db1', level=2)
+    >>> cA2, cD2, cD1 = coeffs
+    >>> cD1
+    array([-0.70710678, -0.70710678, -0.70710678, -0.70710678])
+    >>> cD2
+    array([-2., -2.])
+    >>> cA2
+    array([  5.,  13.])
+
+    """
+    data = np.asarray(data)
+
+    wavelet = _as_wavelet(wavelet)
+    try:
+        axes_shape = data.shape[axis]
+    except IndexError:
+        raise np.AxisError("Axis greater than data dimensions")
+    level = _check_level(axes_shape, wavelet.dec_len, level)
+
+    coeffs_list = []
+
+    a = data
+    for i in range(level):
+        a, d = dwt(a, wavelet, mode, axis)
+        coeffs_list.append(d)
+
+    coeffs_list.append(a)
+    coeffs_list.reverse()
+
+    return coeffs_list
+
+
+def waverec(coeffs, wavelet, mode='symmetric', axis=-1):
+    """
+    Multilevel 1D Inverse Discrete Wavelet Transform.
+
+    Parameters
+    ----------
+    coeffs : array_like
+        Coefficients list [cAn, cDn, cDn-1, ..., cD2, cD1]
+    wavelet : Wavelet object or name string
+        Wavelet to use
+    mode : str, optional
+        Signal extension mode, see :ref:`Modes <ref-modes>`.
+    axis: int, optional
+        Axis over which to compute the inverse DWT. If not given, the
+        last axis is used.
+
+    Notes
+    -----
+    It may sometimes be desired to run ``waverec`` with some sets of
+    coefficients omitted.  This can best be done by setting the corresponding
+    arrays to zero arrays of matching shape and dtype.  Explicitly removing
+    list entries or setting them to None is not supported.
+
+    Specifically, to ignore detail coefficients at level 2, one could do::
+
+        coeffs[-2] == np.zeros_like(coeffs[-2])
+
+    Examples
+    --------
+    >>> import pywt
+    >>> coeffs = pywt.wavedec([1,2,3,4,5,6,7,8], 'db1', level=2)
+    >>> pywt.waverec(coeffs, 'db1')
+    array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.])
+    """
+
+    if not isinstance(coeffs, (list, tuple)):
+        raise ValueError("Expected sequence of coefficient arrays.")
+
+    if len(coeffs) < 1:
+        raise ValueError(
+            "Coefficient list too short (minimum 1 arrays required).")
+    elif len(coeffs) == 1:
+        # level 0 transform (just returns the approximation coefficients)
+        return coeffs[0]
+
+    a, ds = coeffs[0], coeffs[1:]
+
+    for d in ds:
+        if d is not None and not isinstance(d, np.ndarray):
+            raise ValueError((
+                "Unexpected detail coefficient type: {}. Detail coefficients "
+                "must be arrays as returned by wavedec. If you are using "
+                "pywt.array_to_coeffs or pywt.unravel_coeffs, please specify "
+                "output_format='wavedec'").format(type(d)))
+        if (a is not None) and (d is not None):
+            try:
+                if a.shape[axis] == d.shape[axis] + 1:
+                    a = a[tuple(slice(s) for s in d.shape)]
+                elif a.shape[axis] != d.shape[axis]:
+                    raise ValueError("coefficient shape mismatch")
+            except IndexError:
+                raise np.AxisError("Axis greater than coefficient dimensions")
+        a = idwt(a, d, wavelet, mode, axis)
+
+    return a
+
+
+def wavedec2(data, wavelet, mode='symmetric', level=None, axes=(-2, -1)):
+    """
+    Multilevel 2D Discrete Wavelet Transform.
+
+    Parameters
+    ----------
+    data : ndarray
+        2D input data
+    wavelet : Wavelet object or name string, or 2-tuple of wavelets
+        Wavelet to use.  This can also be a tuple containing a wavelet to
+        apply along each axis in ``axes``.
+    mode : str or 2-tuple of str, optional
+        Signal extension mode, see :ref:`Modes <ref-modes>`. This can
+        also be a tuple containing a mode to apply along each axis in ``axes``.
+    level : int, optional
+        Decomposition level (must be >= 0). If level is None (default) then it
+        will be calculated using the ``dwt_max_level`` function.
+    axes : 2-tuple of ints, optional
+        Axes over which to compute the DWT. Repeated elements are not allowed.
+
+    Returns
+    -------
+    [cAn, (cHn, cVn, cDn), ... (cH1, cV1, cD1)] : list
+        Coefficients list.  For user-specified ``axes``, ``cH*``
+        corresponds to ``axes[0]`` while ``cV*`` corresponds to ``axes[1]``.
+        The first element returned is the approximation coefficients for the
+        nth level of decomposition.  Remaining elements are tuples of detail
+        coefficients in descending order of decomposition level.
+        (i.e. ``cH1`` are the horizontal detail coefficients at the first
+        level)
+
+    Examples
+    --------
+    >>> import pywt
+    >>> import numpy as np
+    >>> coeffs = pywt.wavedec2(np.ones((4,4)), 'db1')
+    >>> # Levels:
+    >>> len(coeffs)-1
+    2
+    >>> pywt.waverec2(coeffs, 'db1')
+    array([[ 1.,  1.,  1.,  1.],
+           [ 1.,  1.,  1.,  1.],
+           [ 1.,  1.,  1.,  1.],
+           [ 1.,  1.,  1.,  1.]])
+    """
+    data = np.asarray(data)
+    if data.ndim < 2:
+        raise ValueError("Expected input data to have at least 2 dimensions.")
+
+    axes = tuple(axes)
+    if len(axes) != 2:
+        raise ValueError("Expected 2 axes")
+    if len(axes) != len(set(axes)):
+        raise ValueError("The axes passed to wavedec2 must be unique.")
+    try:
+        axes_sizes = [data.shape[ax] for ax in axes]
+    except IndexError:
+        raise np.AxisError("Axis greater than data dimensions")
+
+    wavelets = _wavelets_per_axis(wavelet, axes)
+    dec_lengths = [w.dec_len for w in wavelets]
+
+    level = _check_level(axes_sizes, dec_lengths, level)
+
+    coeffs_list = []
+
+    a = data
+    for i in range(level):
+        a, ds = dwt2(a, wavelet, mode, axes)
+        coeffs_list.append(ds)
+
+    coeffs_list.append(a)
+    coeffs_list.reverse()
+
+    return coeffs_list
+
+
+def waverec2(coeffs, wavelet, mode='symmetric', axes=(-2, -1)):
+    """
+    Multilevel 2D Inverse Discrete Wavelet Transform.
+
+    coeffs : list or tuple
+        Coefficients list [cAn, (cHn, cVn, cDn), ... (cH1, cV1, cD1)]
+    wavelet : Wavelet object or name string, or 2-tuple of wavelets
+        Wavelet to use.  This can also be a tuple containing a wavelet to
+        apply along each axis in ``axes``.
+    mode : str or 2-tuple of str, optional
+        Signal extension mode, see :ref:`Modes <ref-modes>`. This can
+        also be a tuple containing a mode to apply along each axis in ``axes``.
+    axes : 2-tuple of ints, optional
+        Axes over which to compute the IDWT. Repeated elements are not allowed.
+
+    Returns
+    -------
+    2D array of reconstructed data.
+
+    Notes
+    -----
+    It may sometimes be desired to run ``waverec2`` with some sets of
+    coefficients omitted.  This can best be done by setting the corresponding
+    arrays to zero arrays of matching shape and dtype.  Explicitly removing
+    list or tuple entries or setting them to None is not supported.
+
+    Specifically, to ignore all detail coefficients at level 2, one could do::
+
+        coeffs[-2] == tuple([np.zeros_like(v) for v in coeffs[-2]])
+
+    Examples
+    --------
+    >>> import pywt
+    >>> import numpy as np
+    >>> coeffs = pywt.wavedec2(np.ones((4,4)), 'db1')
+    >>> # Levels:
+    >>> len(coeffs)-1
+    2
+    >>> pywt.waverec2(coeffs, 'db1')
+    array([[ 1.,  1.,  1.,  1.],
+           [ 1.,  1.,  1.,  1.],
+           [ 1.,  1.,  1.,  1.],
+           [ 1.,  1.,  1.,  1.]])
+    """
+    if not isinstance(coeffs, (list, tuple)):
+        raise ValueError("Expected sequence of coefficient arrays.")
+
+    if len(axes) != len(set(axes)):
+        raise ValueError("The axes passed to waverec2 must be unique.")
+
+    if len(coeffs) < 1:
+        raise ValueError(
+            "Coefficient list too short (minimum 1 array required).")
+    elif len(coeffs) == 1:
+        # level 0 transform (just returns the approximation coefficients)
+        return coeffs[0]
+
+    a, ds = coeffs[0], coeffs[1:]
+    a = np.asarray(a)
+
+    for d in ds:
+        if not isinstance(d, (list, tuple)) or len(d) != 3:
+            raise ValueError((
+                "Unexpected detail coefficient type: {}. Detail coefficients "
+                "must be a 3-tuple of arrays as returned by wavedec2. If you "
+                "are using pywt.array_to_coeffs or pywt.unravel_coeffs, "
+                "please specify output_format='wavedec2'").format(type(d)))
+        d = tuple(np.asarray(coeff) if coeff is not None else None
+                  for coeff in d)
+        d_shapes = (coeff.shape for coeff in d if coeff is not None)
+        try:
+            d_shape = next(d_shapes)
+        except StopIteration:
+            idxs = slice(None), slice(None)
+        else:
+            if not all(s == d_shape for s in d_shapes):
+                raise ValueError("All detail shapes must be the same length.")
+            idxs = tuple(slice(None, -1 if a_len == d_len + 1 else None)
+                         for a_len, d_len in zip(a.shape, d_shape))
+        a = idwt2((a[idxs], d), wavelet, mode, axes)
+
+    return a
+
+
+def _prep_axes_wavedecn(shape, axes):
+    if len(shape) < 1:
+        raise ValueError("Expected at least 1D input data.")
+    ndim = len(shape)
+    if np.isscalar(axes):
+        axes = (axes, )
+    if axes is None:
+        axes = range(ndim)
+    else:
+        axes = tuple(axes)
+    if len(axes) != len(set(axes)):
+        raise ValueError("The axes passed to wavedecn must be unique.")
+    try:
+        axes_shapes = [shape[ax] for ax in axes]
+    except IndexError:
+        raise np.AxisError("Axis greater than data dimensions")
+    ndim_transform = len(axes)
+    return axes, axes_shapes, ndim_transform
+
+
+def wavedecn(data, wavelet, mode='symmetric', level=None, axes=None):
+    """
+    Multilevel nD Discrete Wavelet Transform.
+
+    Parameters
+    ----------
+    data : ndarray
+        nD input data
+    wavelet : Wavelet object or name string, or tuple of wavelets
+        Wavelet to use.  This can also be a tuple containing a wavelet to
+        apply along each axis in ``axes``.
+    mode : str or tuple of str, optional
+        Signal extension mode, see :ref:`Modes <ref-modes>`. This can
+        also be a tuple containing a mode to apply along each axis in ``axes``.
+    level : int, optional
+        Decomposition level (must be >= 0). If level is None (default) then it
+        will be calculated using the ``dwt_max_level`` function.
+    axes : sequence of ints, optional
+        Axes over which to compute the DWT. Axes may not be repeated. The
+        default is None, which means transform all axes
+        (``axes = range(data.ndim)``).
+
+    Returns
+    -------
+    [cAn, {details_level_n}, ... {details_level_1}] : list
+        Coefficients list.  Coefficients are listed in descending order of
+        decomposition level.  ``cAn`` are the approximation coefficients at
+        level ``n``.  Each ``details_level_i`` element is a dictionary
+        containing detail coefficients at level ``i`` of the decomposition. As
+        a concrete example, a 3D decomposition would have the following set of
+        keys in each ``details_level_i`` dictionary::
+
+            {'aad', 'ada', 'daa', 'add', 'dad', 'dda', 'ddd'}
+
+        where the order of the characters in each key map to the specified
+        ``axes``.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from pywt import wavedecn, waverecn
+    >>> coeffs = wavedecn(np.ones((4, 4, 4)), 'db1')
+    >>> # Levels:
+    >>> len(coeffs)-1
+    2
+    >>> waverecn(coeffs, 'db1')  # doctest: +NORMALIZE_WHITESPACE
+    array([[[ 1.,  1.,  1.,  1.],
+            [ 1.,  1.,  1.,  1.],
+            [ 1.,  1.,  1.,  1.],
+            [ 1.,  1.,  1.,  1.]],
+           [[ 1.,  1.,  1.,  1.],
+            [ 1.,  1.,  1.,  1.],
+            [ 1.,  1.,  1.,  1.],
+            [ 1.,  1.,  1.,  1.]],
+           [[ 1.,  1.,  1.,  1.],
+            [ 1.,  1.,  1.,  1.],
+            [ 1.,  1.,  1.,  1.],
+            [ 1.,  1.,  1.,  1.]],
+           [[ 1.,  1.,  1.,  1.],
+            [ 1.,  1.,  1.,  1.],
+            [ 1.,  1.,  1.,  1.],
+            [ 1.,  1.,  1.,  1.]]])
+
+    """
+    data = np.asarray(data)
+    axes, axes_shapes, ndim_transform = _prep_axes_wavedecn(data.shape, axes)
+    wavelets = _wavelets_per_axis(wavelet, axes)
+    dec_lengths = [w.dec_len for w in wavelets]
+
+    level = _check_level(axes_shapes, dec_lengths, level)
+
+    coeffs_list = []
+
+    a = data
+    for i in range(level):
+        coeffs = dwtn(a, wavelet, mode, axes)
+        a = coeffs.pop('a' * ndim_transform)
+        coeffs_list.append(coeffs)
+
+    coeffs_list.append(a)
+    coeffs_list.reverse()
+
+    return coeffs_list
+
+
+def _match_coeff_dims(a_coeff, d_coeff_dict):
+    # For each axis, compare the approximation coeff shape to one of the
+    # stored detail coeffs and truncate the last element along the axis
+    # if necessary.
+    if a_coeff is None:
+        return None
+    if not d_coeff_dict:
+        return a_coeff
+    d_coeff = d_coeff_dict[next(iter(d_coeff_dict))]
+    size_diffs = np.subtract(a_coeff.shape, d_coeff.shape)
+    if np.any((size_diffs < 0) | (size_diffs > 1)):
+        print(size_diffs)
+        raise ValueError("incompatible coefficient array sizes")
+    return a_coeff[tuple(slice(s) for s in d_coeff.shape)]
+
+
+def waverecn(coeffs, wavelet, mode='symmetric', axes=None):
+    """
+    Multilevel nD Inverse Discrete Wavelet Transform.
+
+    coeffs : array_like
+        Coefficients list [cAn, {details_level_n}, ... {details_level_1}]
+    wavelet : Wavelet object or name string, or tuple of wavelets
+        Wavelet to use.  This can also be a tuple containing a wavelet to
+        apply along each axis in ``axes``.
+    mode : str or tuple of str, optional
+        Signal extension mode, see :ref:`Modes <ref-modes>`. This can
+        also be a tuple containing a mode to apply along each axis in ``axes``.
+    axes : sequence of ints, optional
+        Axes over which to compute the IDWT.  Axes may not be repeated.
+
+    Returns
+    -------
+    nD array of reconstructed data.
+
+    Notes
+    -----
+    It may sometimes be desired to run ``waverecn`` with some sets of
+    coefficients omitted.  This can best be done by setting the corresponding
+    arrays to zero arrays of matching shape and dtype.  Explicitly removing
+    list or dictionary entries or setting them to None is not supported.
+
+    Specifically, to ignore all detail coefficients at level 2, one could do::
+
+        coeffs[-2] = {k: np.zeros_like(v) for k, v in coeffs[-2].items()}
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from pywt import wavedecn, waverecn
+    >>> coeffs = wavedecn(np.ones((4, 4, 4)), 'db1')
+    >>> # Levels:
+    >>> len(coeffs)-1
+    2
+    >>> waverecn(coeffs, 'db1')  # doctest: +NORMALIZE_WHITESPACE
+    array([[[ 1.,  1.,  1.,  1.],
+            [ 1.,  1.,  1.,  1.],
+            [ 1.,  1.,  1.,  1.],
+            [ 1.,  1.,  1.,  1.]],
+           [[ 1.,  1.,  1.,  1.],
+            [ 1.,  1.,  1.,  1.],
+            [ 1.,  1.,  1.,  1.],
+            [ 1.,  1.,  1.,  1.]],
+           [[ 1.,  1.,  1.,  1.],
+            [ 1.,  1.,  1.,  1.],
+            [ 1.,  1.,  1.,  1.],
+            [ 1.,  1.,  1.,  1.]],
+           [[ 1.,  1.,  1.,  1.],
+            [ 1.,  1.,  1.,  1.],
+            [ 1.,  1.,  1.,  1.],
+            [ 1.,  1.,  1.,  1.]]])
+
+    """
+    if len(coeffs) < 1:
+        raise ValueError(
+            "Coefficient list too short (minimum 1 array required).")
+
+    a, ds = coeffs[0], coeffs[1:]
+
+    # this dictionary check must be prior to the call to _fix_coeffs
+    if len(ds) > 0 and not all([isinstance(d, dict) for d in ds]):
+        raise ValueError((
+            "Unexpected detail coefficient type: {}. Detail coefficients "
+            "must be a dicionary of arrays as returned by wavedecn. If "
+            "you are using pywt.array_to_coeffs or pywt.unravel_coeffs, "
+            "please specify output_format='wavedecn'").format(type(ds[0])))
+
+    # Raise error for invalid key combinations
+    ds = list(map(_fix_coeffs, ds))
+
+    if not ds:
+        # level 0 transform (just returns the approximation coefficients)
+        return coeffs[0]
+    if a is None and not any(ds):
+        raise ValueError(
+            "At least one coefficient must contain a valid value.")
+
+    coeff_ndims = []
+    if a is not None:
+        a = np.asarray(a)
+        coeff_ndims.append(a.ndim)
+    for d in ds:
+        coeff_ndims += [v.ndim for k, v in d.items()]
+
+    # test that all coefficients have a matching number of dimensions
+    unique_coeff_ndims = np.unique(coeff_ndims)
+    if len(unique_coeff_ndims) == 1:
+        ndim = unique_coeff_ndims[0]
+    else:
+        raise ValueError(
+            "All coefficients must have a matching number of dimensions")
+
+    if np.isscalar(axes):
+        axes = (axes, )
+    if axes is None:
+        axes = range(ndim)
+    else:
+        axes = tuple(axes)
+    if len(axes) != len(set(axes)):
+        raise ValueError("The axes passed to waverecn must be unique.")
+    ndim_transform = len(axes)
+
+    for idx, d in enumerate(ds):
+        if a is None and not d:
+            continue
+        # The following if statement handles the case where the approximation
+        # coefficient returned at the previous level may exceed the size of the
+        # stored detail coefficients by 1 on any given axis.
+        if idx > 0:
+            a = _match_coeff_dims(a, d)
+        d['a' * ndim_transform] = a
+        a = idwtn(d, wavelet, mode, axes)
+
+    return a
+
+
+def _coeffs_wavedec_to_wavedecn(coeffs):
+    """Convert wavedec coefficients to the wavedecn format."""
+    if len(coeffs) == 0:
+        return coeffs
+    coeffs = copy(coeffs)
+    for n in range(1, len(coeffs)):
+        if coeffs[n] is None:
+            continue
+        if coeffs[n].ndim != 1:
+            raise ValueError("expected a 1D coefficient array")
+        coeffs[n] = dict(d=coeffs[n])
+    return coeffs
+
+
+def _coeffs_wavedec2_to_wavedecn(coeffs):
+    """Convert wavedec2 coefficients to the wavedecn format."""
+    if len(coeffs) == 0:
+        return coeffs
+    coeffs = copy(coeffs)
+    for n in range(1, len(coeffs)):
+        if not isinstance(coeffs[n], (tuple, list)) or len(coeffs[n]) != 3:
+            raise ValueError("expected a 3-tuple of detail coefficients")
+        (da, ad, dd) = coeffs[n]
+        if da is None or ad is None or dd is None:
+            raise ValueError(
+                "Expected numpy arrays of detail coefficients. Setting "
+                "coefficients to None is not supported.")
+        coeffs[n] = dict(ad=ad, da=da, dd=dd)
+    return coeffs
+
+
+def _determine_coeff_array_shape(coeffs, axes):
+    arr_shape = np.asarray(coeffs[0].shape)
+    axes = np.asarray(axes)  # axes that were transformed
+    ndim_transform = len(axes)
+    ncoeffs = coeffs[0].size
+    for d in coeffs[1:]:
+        arr_shape[axes] += np.asarray(d['d'*ndim_transform].shape)[axes]
+        for k, v in d.items():
+            ncoeffs += v.size
+    arr_shape = tuple(arr_shape.tolist())
+    # if the total number of coefficients doesn't equal the size of the array
+    # then tight packing is not possible.
+    is_tight_packing = (np.prod(arr_shape) == ncoeffs)
+    return arr_shape, is_tight_packing
+
+
+def _prepare_coeffs_axes(coeffs, axes):
+    """Helper function to check type of coeffs and axes.
+
+    This code is used by both coeffs_to_array and ravel_coeffs.
+    """
+    if not isinstance(coeffs, list) or len(coeffs) == 0:
+        raise ValueError("input must be a list of coefficients from wavedecn")
+    if coeffs[0] is None:
+        raise ValueError("coeffs_to_array does not support missing "
+                         "coefficients.")
+    if not isinstance(coeffs[0], np.ndarray):
+        raise ValueError("first list element must be a numpy array")
+    ndim = coeffs[0].ndim
+
+    if len(coeffs) > 1:
+        # convert wavedec or wavedec2 format coefficients to waverecn format
+        if isinstance(coeffs[1], dict):
+            pass
+        elif isinstance(coeffs[1], np.ndarray):
+            coeffs = _coeffs_wavedec_to_wavedecn(coeffs)
+        elif isinstance(coeffs[1], (tuple, list)):
+            coeffs = _coeffs_wavedec2_to_wavedecn(coeffs)
+        else:
+            raise ValueError("invalid coefficient list")
+
+    if len(coeffs) == 1:
+        # no detail coefficients were found
+        return coeffs, axes, ndim, None
+
+    # Determine the number of dimensions that were transformed via key length
+    ndim_transform = len(list(coeffs[1].keys())[0])
+    if axes is None:
+        if ndim_transform < ndim:
+            raise ValueError(
+                "coeffs corresponds to a DWT performed over only a subset of "
+                "the axes.  In this case, axes must be specified.")
+        axes = np.arange(ndim)
+
+    if len(axes) != ndim_transform:
+        raise ValueError(
+            "The length of axes doesn't match the number of dimensions "
+            "transformed.")
+
+    return coeffs, axes, ndim, ndim_transform
+
+
+def coeffs_to_array(coeffs, padding=0, axes=None):
+    """
+    Arrange a wavelet coefficient list from ``wavedecn`` into a single array.
+
+    Parameters
+    ----------
+
+    coeffs : array-like
+        Dictionary of wavelet coefficients as returned by pywt.wavedecn
+    padding : float or None, optional
+        The value to use for the background if the coefficients cannot be
+        tightly packed. If None, raise an error if the coefficients cannot be
+        tightly packed.
+    axes : sequence of ints, optional
+        Axes over which the DWT that created ``coeffs`` was performed.  The
+        default value of None corresponds to all axes.
+
+    Returns
+    -------
+    coeff_arr : array-like
+        Wavelet transform coefficient array.
+    coeff_slices : list
+        List of slices corresponding to each coefficient.  As a 2D example,
+        ``coeff_arr[coeff_slices[1]['dd']]`` would extract the first level
+        detail coefficients from ``coeff_arr``.
+
+    See Also
+    --------
+    array_to_coeffs : the inverse of coeffs_to_array
+
+    Notes
+    -----
+    Assume a 2D coefficient dictionary, c, from a two-level transform.
+
+    Then all 2D coefficients will be stacked into a single larger 2D array
+    as follows::
+
+        +---------------+---------------+-------------------------------+
+        |               |               |                               |
+        |     c[0]      |  c[1]['da']   |                               |
+        |               |               |                               |
+        +---------------+---------------+           c[2]['da']          |
+        |               |               |                               |
+        | c[1]['ad']    |  c[1]['dd']   |                               |
+        |               |               |                               |
+        +---------------+---------------+ ------------------------------+
+        |                               |                               |
+        |                               |                               |
+        |                               |                               |
+        |          c[2]['ad']           |           c[2]['dd']          |
+        |                               |                               |
+        |                               |                               |
+        |                               |                               |
+        +-------------------------------+-------------------------------+
+
+    If the transform was not performed with mode "periodization" or the signal
+    length was not a multiple of ``2**level``, coefficients at each subsequent
+    scale will not be exactly 1/2 the size of those at the previous level due
+    to additional coefficients retained to handle the boundary condition. In
+    these cases, the default setting of `padding=0` indicates to pad the
+    individual coefficient arrays with 0 as needed so that they can be stacked
+    into a single, contiguous array.
+
+    Examples
+    --------
+    >>> import pywt
+    >>> cam = pywt.data.camera()
+    >>> coeffs = pywt.wavedecn(cam, wavelet='db2', level=3)
+    >>> arr, coeff_slices = pywt.coeffs_to_array(coeffs)
+
+    """
+
+    coeffs, axes, ndim, ndim_transform = _prepare_coeffs_axes(coeffs, axes)
+
+    # initialize with the approximation coefficients.
+    a_coeffs = coeffs[0]
+    a_shape = a_coeffs.shape
+
+    if len(coeffs) == 1:
+        # only a single approximation coefficient array was found
+        return a_coeffs, [tuple([slice(None)] * ndim)]
+
+    # determine size of output and if tight packing is possible
+    arr_shape, is_tight_packing = _determine_coeff_array_shape(coeffs, axes)
+
+    # preallocate output array
+    if padding is None:
+        if not is_tight_packing:
+            raise ValueError("array coefficients cannot be tightly packed")
+        coeff_arr = np.empty(arr_shape, dtype=a_coeffs.dtype)
+    else:
+        coeff_arr = np.full(arr_shape, padding, dtype=a_coeffs.dtype)
+
+    a_slices = tuple([slice(s) for s in a_shape])
+    coeff_arr[a_slices] = a_coeffs
+
+    # initialize list of coefficient slices
+    coeff_slices = []
+    coeff_slices.append(a_slices)
+
+    # loop over the detail cofficients, adding them to coeff_arr
+    ds = coeffs[1:]
+    for coeff_dict in ds:
+        coeff_slices.append({})  # new dictionary for detail coefficients
+        if np.any([d is None for d in coeff_dict.values()]):
+            raise ValueError("coeffs_to_array does not support missing "
+                             "coefficients.")
+        d_shape = coeff_dict['d' * ndim_transform].shape
+        for key in coeff_dict.keys():
+            d = coeff_dict[key]
+            slice_array = [slice(None), ] * ndim
+            for i, let in enumerate(key):
+                ax_i = axes[i]  # axis corresponding to this transform index
+                if let == 'a':
+                    slice_array[ax_i] = slice(d.shape[ax_i])
+                elif let == 'd':
+                    slice_array[ax_i] = slice(a_shape[ax_i],
+                                              a_shape[ax_i] + d.shape[ax_i])
+                else:
+                    raise ValueError("unexpected letter: {}".format(let))
+            slice_array = tuple(slice_array)
+            coeff_arr[slice_array] = d
+            coeff_slices[-1][key] = slice_array
+        a_shape = [a_shape[n] + d_shape[n] for n in range(ndim)]
+    return coeff_arr, coeff_slices
+
+
+def array_to_coeffs(arr, coeff_slices, output_format='wavedecn'):
+    """
+    Convert a combined array of coefficients back to a list compatible with
+    ``waverecn``.
+
+    Parameters
+    ----------
+
+    arr : array-like
+        An array containing all wavelet coefficients.  This should have been
+        generated via ``coeffs_to_array``.
+    coeff_slices : list of tuples
+        List of slices corresponding to each coefficient as obtained from
+        ``array_to_coeffs``.
+    output_format : {'wavedec', 'wavedec2', 'wavedecn'}
+        Make the form of the coefficients compatible with this type of
+        multilevel transform.
+
+    Returns
+    -------
+    coeffs: array-like
+        Wavelet transform coefficient array.
+
+    See Also
+    --------
+    coeffs_to_array : the inverse of array_to_coeffs
+
+    Notes
+    -----
+    A single large array containing all coefficients will have subsets stored,
+    into a ``waverecn`` list, c, as indicated below::
+
+        +---------------+---------------+-------------------------------+
+        |               |               |                               |
+        |     c[0]      |  c[1]['da']   |                               |
+        |               |               |                               |
+        +---------------+---------------+           c[2]['da']          |
+        |               |               |                               |
+        | c[1]['ad']    |  c[1]['dd']   |                               |
+        |               |               |                               |
+        +---------------+---------------+ ------------------------------+
+        |                               |                               |
+        |                               |                               |
+        |                               |                               |
+        |          c[2]['ad']           |           c[2]['dd']          |
+        |                               |                               |
+        |                               |                               |
+        |                               |                               |
+        +-------------------------------+-------------------------------+
+
+    Examples
+    --------
+    >>> import pywt
+    >>> from numpy.testing import assert_array_almost_equal
+    >>> cam = pywt.data.camera()
+    >>> coeffs = pywt.wavedecn(cam, wavelet='db2', level=3)
+    >>> arr, coeff_slices = pywt.coeffs_to_array(coeffs)
+    >>> coeffs_from_arr = pywt.array_to_coeffs(arr, coeff_slices,
+    ...                                        output_format='wavedecn')
+    >>> cam_recon = pywt.waverecn(coeffs_from_arr, wavelet='db2')
+    >>> assert_array_almost_equal(cam, cam_recon)
+
+    """
+    arr = np.asarray(arr)
+    coeffs = []
+    if len(coeff_slices) == 0:
+        raise ValueError("empty list of coefficient slices")
+    else:
+        coeffs.append(arr[coeff_slices[0]])
+
+    # difference coefficients at each level
+    for n in range(1, len(coeff_slices)):
+        if output_format == 'wavedec':
+            d = arr[coeff_slices[n]['d']]
+        elif output_format == 'wavedec2':
+            d = (arr[coeff_slices[n]['da']],
+                 arr[coeff_slices[n]['ad']],
+                 arr[coeff_slices[n]['dd']])
+        elif output_format == 'wavedecn':
+            d = {}
+            for k, v in coeff_slices[n].items():
+                d[k] = arr[v]
+        else:
+            raise ValueError(
+                "Unrecognized output format: {}".format(output_format))
+        coeffs.append(d)
+    return coeffs
+
+
+def wavedecn_shapes(shape, wavelet, mode='symmetric', level=None, axes=None):
+    """Subband shapes for a multilevel nD discrete wavelet transform.
+
+    Parameters
+    ----------
+    shape : sequence of ints
+        The shape of the data to be transformed.
+    wavelet : Wavelet object or name string, or tuple of wavelets
+        Wavelet to use.  This can also be a tuple containing a wavelet to
+        apply along each axis in ``axes``.
+    mode : str or tuple of str, optional
+        Signal extension mode, see :ref:`Modes <ref-modes>`. This can
+        also be a tuple containing a mode to apply along each axis in ``axes``.
+    level : int, optional
+        Decomposition level (must be >= 0). If level is None (default) then it
+        will be calculated using the ``dwt_max_level`` function.
+    axes : sequence of ints, optional
+        Axes over which to compute the DWT. Axes may not be repeated. The
+        default is None, which means transform all axes
+        (``axes = range(data.ndim)``).
+
+    Returns
+    -------
+    shapes : [cAn, {details_level_n}, ... {details_level_1}] : list
+        Coefficients shape list.  Mirrors the output of ``wavedecn``, except
+        it contains only the shapes of the coefficient arrays rather than the
+        arrays themselves.
+
+    Examples
+    --------
+    >>> import pywt
+    >>> pywt.wavedecn_shapes((64, 32), wavelet='db2', level=3, axes=(0, ))
+    [(10, 32), {'d': (10, 32)}, {'d': (18, 32)}, {'d': (33, 32)}]
+    """
+    axes, axes_shapes, ndim_transform = _prep_axes_wavedecn(shape, axes)
+    wavelets = _wavelets_per_axis(wavelet, axes)
+    modes = _modes_per_axis(mode, axes)
+    dec_lengths = [w.dec_len for w in wavelets]
+
+    level = _check_level(min(axes_shapes), max(dec_lengths), level)
+
+    shapes = []
+    for i in range(level):
+        detail_keys = [''.join(c) for c in product('ad', repeat=len(axes))]
+        new_shapes = {k: list(shape) for k in detail_keys}
+        for axis, wav, mode in zip(axes, wavelets, modes):
+            s = dwt_coeff_len(shape[axis], filter_len=wav.dec_len, mode=mode)
+            for k in detail_keys:
+                new_shapes[k][axis] = s
+        for k, v in new_shapes.items():
+            new_shapes[k] = tuple(v)
+        shapes.append(new_shapes)
+        shape = new_shapes.pop('a' * ndim_transform)
+    shapes.append(shape)
+    shapes.reverse()
+    return shapes
+
+
+def wavedecn_size(shapes):
+    """Compute the total number of wavedecn coefficients.
+
+    Parameters
+    ----------
+    shapes : list of coefficient shapes
+        A set of coefficient shapes as returned by ``wavedecn_shapes``.
+        Alternatively, the user can specify a set of coefficients as returned
+        by ``wavedecn``.
+
+    Returns
+    -------
+    size : int
+        The total number of coefficients.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> import pywt
+    >>> data_shape = (64, 32)
+    >>> shapes = pywt.wavedecn_shapes(data_shape, 'db2', mode='periodization')
+    >>> pywt.wavedecn_size(shapes)
+    2048
+    >>> coeffs = pywt.wavedecn(np.ones(data_shape), 'sym4', mode='symmetric')
+    >>> pywt.wavedecn_size(coeffs)
+    3087
+    """
+    def _size(x):
+        """Size corresponding to ``x`` as either a shape tuple or ndarray."""
+        if isinstance(x, np.ndarray):
+            return x.size
+        else:
+            return np.prod(x)
+    ncoeffs = _size(shapes[0])
+    for d in shapes[1:]:
+        for k, v in d.items():
+            if v is None:
+                raise ValueError(
+                    "Setting coefficient arrays to None is not supported.")
+            ncoeffs += _size(v)
+    return ncoeffs
+
+
+def dwtn_max_level(shape, wavelet, axes=None):
+    """Compute the maximum level of decomposition for n-dimensional data.
+
+    This returns the maximum number of levels of decomposition suitable for use
+    with ``wavedec``, ``wavedec2`` or ``wavedecn``.
+
+    Parameters
+    ----------
+    shape : sequence of ints
+        Input data shape.
+    wavelet : Wavelet object or name string, or tuple of wavelets
+        Wavelet to use. This can also be a tuple containing a wavelet to
+        apply along each axis in ``axes``.
+    axes : sequence of ints, optional
+        Axes over which to compute the DWT. Axes may not be repeated.
+
+    Returns
+    -------
+    level : int
+        Maximum level.
+
+    Notes
+    -----
+    The level returned is the smallest ``dwt_max_level`` over all axes.
+
+    Examples
+    --------
+    >>> import pywt
+    >>> pywt.dwtn_max_level((64, 32), 'db2')
+    3
+    """
+    # Determine the axes and shape for the transform
+    axes, axes_shapes, ndim_transform = _prep_axes_wavedecn(shape, axes)
+
+    # initialize a Wavelet object per (transformed) axis
+    wavelets = _wavelets_per_axis(wavelet, axes)
+
+    # maximum level of decomposition per axis
+    max_levels = [dwt_max_level(n, wav.dec_len)
+                  for n, wav in zip(axes_shapes, wavelets)]
+    return min(max_levels)
+
+
+def ravel_coeffs(coeffs, axes=None):
+    """Ravel a set of multilevel wavelet coefficients into a single 1D array.
+
+    Parameters
+    ----------
+    coeffs : array-like
+        A list of multilevel wavelet coefficients as returned by
+        ``wavedec``, ``wavedec2`` or ``wavedecn``. This function is also
+        compatible with the output of ``swt``, ``swt2`` and ``swtn`` if those
+        functions were called with ``trim_approx=True``.
+    axes : sequence of ints, optional
+        Axes over which the DWT that created ``coeffs`` was performed. The
+        default value of None corresponds to all axes.
+
+    Returns
+    -------
+    coeff_arr : array-like
+        Wavelet transform coefficient array. All coefficients have been
+        concatenated into a single array.
+    coeff_slices : list
+        List of slices corresponding to each coefficient. As a 2D example,
+        ``coeff_arr[coeff_slices[1]['dd']]`` would extract the first level
+        detail coefficients from ``coeff_arr``.
+    coeff_shapes : list
+        List of shapes corresponding to each coefficient. For example, in 2D,
+        ``coeff_shapes[1]['dd']`` would contain the original shape of the first
+        level detail coefficients array.
+
+    See Also
+    --------
+    unravel_coeffs : the inverse of ravel_coeffs
+
+    Examples
+    --------
+    >>> import pywt
+    >>> cam = pywt.data.camera()
+    >>> coeffs = pywt.wavedecn(cam, wavelet='db2', level=3)
+    >>> arr, coeff_slices, coeff_shapes = pywt.ravel_coeffs(coeffs)
+
+    """
+    coeffs, axes, ndim, ndim_transform = _prepare_coeffs_axes(coeffs, axes)
+
+    # initialize with the approximation coefficients.
+    a_coeffs = coeffs[0]
+    a_size = a_coeffs.size
+
+    if len(coeffs) == 1:
+        # only a single approximation coefficient array was found
+        return a_coeffs.ravel(), [slice(a_size), ], [a_coeffs.shape, ]
+
+    # preallocate output array
+    arr_size = wavedecn_size(coeffs)
+    coeff_arr = np.empty((arr_size, ), dtype=a_coeffs.dtype)
+
+    a_slice = slice(a_size)
+    coeff_arr[a_slice] = a_coeffs.ravel()
+
+    # initialize list of coefficient slices
+    coeff_slices = []
+    coeff_shapes = []
+    coeff_slices.append(a_slice)
+    coeff_shapes.append(coeffs[0].shape)
+
+    # loop over the detail cofficients, embedding them in coeff_arr
+    ds = coeffs[1:]
+    offset = a_size
+    for coeff_dict in ds:
+        # new dictionaries for detail coefficient slices and shapes
+        coeff_slices.append({})
+        coeff_shapes.append({})
+        if np.any([d is None for d in coeff_dict.values()]):
+            raise ValueError("coeffs_to_array does not support missing "
+                             "coefficients.")
+        # sort to make sure key order is consistent across Python versions
+        keys = sorted(coeff_dict.keys())
+        for key in keys:
+            d = coeff_dict[key]
+            sl = slice(offset, offset + d.size)
+            offset += d.size
+            coeff_arr[sl] = d.ravel()
+            coeff_slices[-1][key] = sl
+            coeff_shapes[-1][key] = d.shape
+    return coeff_arr, coeff_slices, coeff_shapes
+
+
+def unravel_coeffs(arr, coeff_slices, coeff_shapes, output_format='wavedecn'):
+    """Unravel a raveled array of multilevel wavelet coefficients.
+
+    Parameters
+    ----------
+    arr : array-like
+        An array containing all wavelet coefficients. This should have been
+        generated by applying ``ravel_coeffs`` to the output of ``wavedec``,
+        ``wavedec2`` or ``wavedecn`` (or via ``swt``, ``swt2`` or ``swtn``
+        with ``trim_approx=True``).
+    coeff_slices : list of tuples
+        List of slices corresponding to each coefficient as obtained from
+        ``ravel_coeffs``.
+    coeff_shapes : list of tuples
+        List of shapes corresponding to each coefficient as obtained from
+        ``ravel_coeffs``.
+    output_format : {'wavedec', 'wavedec2', 'wavedecn', 'swt', 'swt2', 'swtn'}, optional
+        Make the form of the unraveled coefficients compatible with this type
+        of multilevel transform. The default is ``'wavedecn'``.
+
+    Returns
+    -------
+    coeffs: list
+        List of wavelet transform coefficients. The specific format of the list
+        elements is determined by ``output_format``.
+
+    See Also
+    --------
+    ravel_coeffs : the inverse of unravel_coeffs
+
+    Examples
+    --------
+    >>> import pywt
+    >>> from numpy.testing import assert_array_almost_equal
+    >>> cam = pywt.data.camera()
+    >>> coeffs = pywt.wavedecn(cam, wavelet='db2', level=3)
+    >>> arr, coeff_slices, coeff_shapes = pywt.ravel_coeffs(coeffs)
+    >>> coeffs_from_arr = pywt.unravel_coeffs(arr, coeff_slices, coeff_shapes,
+    ...                                       output_format='wavedecn')
+    >>> cam_recon = pywt.waverecn(coeffs_from_arr, wavelet='db2')
+    >>> assert_array_almost_equal(cam, cam_recon)
+
+    """
+    arr = np.asarray(arr)
+    coeffs = []
+    if len(coeff_slices) == 0:
+        raise ValueError("empty list of coefficient slices")
+    elif len(coeff_shapes) == 0:
+        raise ValueError("empty list of coefficient shapes")
+    elif len(coeff_shapes) != len(coeff_slices):
+        raise ValueError("coeff_shapes and coeff_slices have unequal length")
+    else:
+        coeffs.append(arr[coeff_slices[0]].reshape(coeff_shapes[0]))
+
+    # difference coefficients at each level
+    for n in range(1, len(coeff_slices)):
+        slice_dict = coeff_slices[n]
+        shape_dict = coeff_shapes[n]
+        if output_format in ['wavedec', 'swt']:
+            d = arr[slice_dict['d']].reshape(shape_dict['d'])
+        elif output_format in ['wavedec2', 'swt2']:
+            d = (arr[slice_dict['da']].reshape(shape_dict['da']),
+                 arr[slice_dict['ad']].reshape(shape_dict['ad']),
+                 arr[slice_dict['dd']].reshape(shape_dict['dd']))
+        elif output_format in ['wavedecn', 'swtn']:
+            d = {}
+            for k, v in coeff_slices[n].items():
+                d[k] = arr[v].reshape(shape_dict[k])
+        else:
+            raise ValueError(
+                "Unrecognized output format: {}".format(output_format))
+        coeffs.append(d)
+    return coeffs
+
+
+def _check_fswavedecn_axes(data, axes):
+    """Axes checks common to fswavedecn, fswaverecn."""
+    if len(axes) != len(set(axes)):
+        raise np.AxisError("The axes passed to fswavedecn must be unique.")
+    try:
+        [data.shape[ax] for ax in axes]
+    except IndexError:
+        raise np.AxisError("Axis greater than data dimensions")
+
+
+class FswavedecnResult(object):
+    """Object representing fully separable wavelet transform coefficients.
+
+    Parameters
+    ----------
+    coeffs : ndarray
+        The coefficient array.
+    coeff_slices : list
+        List of slices corresponding to each detail or approximation
+        coefficient array.
+    wavelets : list of pywt.DiscreteWavelet objects
+        The wavelets used.  Will be a list with length equal to
+        ``len(axes)``.
+    mode_enums : list of int
+        The border modes used.  Will be a list with length equal to
+        ``len(axes)``.
+    axes : tuple of int
+        The set of axes over which the transform was performed.
+
+    """
+    def __init__(self, coeffs, coeff_slices, wavelets, mode_enums,
+                 axes):
+        self._coeffs = coeffs
+        self._coeff_slices = coeff_slices
+        self._axes = axes
+        if not np.all(isinstance(w, Wavelet) for w in wavelets):
+            raise ValueError(
+                "wavelets must contain pywt.Wavelet objects")
+        self._wavelets = wavelets
+        if not np.all(isinstance(m, int) for m in mode_enums):
+            raise ValueError(
+                "mode_enums must be integers")
+        self._mode_enums = mode_enums
+
+    @property
+    def coeffs(self):
+        """ndarray: All coefficients stacked into a single array."""
+        return self._coeffs
+
+    @coeffs.setter
+    def coeffs(self, c):
+        if c.shape != self._coeffs.shape:
+            raise ValueError("new coefficient array must match the existing "
+                             "coefficient shape")
+        self._coeffs = c
+
+    @property
+    def coeff_slices(self):
+        """List: List of coefficient slices."""
+        return self._coeff_slices
+
+    @property
+    def ndim(self):
+        """int: Number of data dimensions."""
+        return self.coeffs.ndim
+
+    @property
+    def ndim_transform(self):
+        """int: Number of axes transformed."""
+        return len(self.axes)
+
+    @property
+    def axes(self):
+        """List of str: The axes the transform was performed along."""
+        return self._axes
+
+    @property
+    def levels(self):
+        """List of int: Levels of decomposition along each transformed axis."""
+        return [len(s) - 1 for s in self.coeff_slices]
+
+    @property
+    def wavelets(self):
+        """List of pywt.DiscreteWavelet: wavelet for each transformed axis."""
+        return self._wavelets
+
+    @property
+    def wavelet_names(self):
+        """List of pywt.DiscreteWavelet: wavelet for each transformed axis."""
+        return [w.name for w in self._wavelets]
+
+    @property
+    def modes(self):
+        """List of str: The border mode used along each transformed axis."""
+        names_dict = {getattr(Modes, mode): mode
+                      for mode in Modes.modes}
+        return [names_dict[m] for m in self._mode_enums]
+
+    def _get_coef_sl(self, levels):
+        sl = [slice(None), ] * self.ndim
+        for n, (ax, lev) in enumerate(zip(self.axes, levels)):
+            sl[ax] = self.coeff_slices[n][lev]
+        return tuple(sl)
+
+    @property
+    def approx(self):
+        """ndarray: The approximation coefficients."""
+        sl = self._get_coef_sl((0, )*self.ndim)
+        return self._coeffs[sl]
+
+    @approx.setter
+    def approx(self, a):
+        sl = self._get_coef_sl((0, )*self.ndim)
+        if self._coeffs[sl].shape != a.shape:
+            raise ValueError(
+                "x does not match the shape of the requested coefficient")
+        self._coeffs[sl] = a
+
+    def _validate_index(self, levels):
+        levels = tuple(levels)
+
+        if len(levels) != len(self.axes):
+            raise ValueError(
+                "levels must match the number of transformed axes")
+
+        # check that all elements are non-negative integers
+        if (not np.all([isinstance(lev, numbers.Number) for lev in levels]) or
+                np.any(np.asarray(levels) % 1 > 0) or
+                np.any([lev < 0 for lev in levels])):
+            raise ValueError("Index must be a tuple of non-negative integers")
+        # convert integer-valued floats to int
+        levels = tuple([int(lev) for lev in levels])
+
+        # check for out of range levels
+        if np.any([lev > maxlev for lev, maxlev in zip(levels, self.levels)]):
+            raise ValueError(
+                "Specified indices exceed the number of transform levels.")
+
+    def __getitem__(self, levels):
+        """Retrieve a coefficient subband.
+
+        Parameters
+        ----------
+        levels : tuple of int
+            The number of degrees of decomposition along each transformed
+            axis.
+        """
+        self._validate_index(levels)
+        sl = self._get_coef_sl(levels)
+        return self._coeffs[sl]
+
+    def __setitem__(self, levels, x):
+        """Assign values to a coefficient subband.
+
+        Parameters
+        ----------
+        levels : tuple of int
+            The number of degrees of decomposition along each transformed
+            axis.
+        x : ndarray
+            The data corresponding to assign. It must match the expected
+            shape and dtype of the specified subband.
+        """
+        self._validate_index(levels)
+        sl = self._get_coef_sl(levels)
+        current_dtype = self._coeffs[sl].dtype
+        if self._coeffs[sl].shape != x.shape:
+            raise ValueError(
+                "x does not match the shape of the requested coefficient")
+        if x.dtype != current_dtype:
+            warnings.warn("dtype mismatch:  converting the provided array to"
+                          "dtype {}".format(current_dtype))
+        self._coeffs[sl] = x
+
+    def detail_keys(self):
+        """Return a list of all detail coefficient keys.
+
+        Returns
+        -------
+        keys : list of str
+            List of all detail coefficient keys.
+        """
+        keys = list(product(*(range(l+1) for l in self.levels)))
+        keys.remove((0, )*len(self.axes))
+        return sorted(keys)
+
+
+def fswavedecn(data, wavelet, mode='symmetric', levels=None, axes=None):
+    """Fully Separable Wavelet Decomposition.
+
+    This is a variant of the multilevel discrete wavelet transform where all
+    levels of decomposition are performed along a single axis prior to moving
+    onto the next axis.  Unlike in ``wavedecn``, the number of levels of
+    decomposition are not required to be the same along each axis which can be
+    a benefit for anisotropic data.
+
+    Parameters
+    ----------
+    data: array_like
+        Input data
+    wavelet : Wavelet object or name string, or tuple of wavelets
+        Wavelet to use.  This can also be a tuple containing a wavelet to
+        apply along each axis in ``axes``.
+    mode : str or tuple of str, optional
+        Signal extension mode, see :ref:`Modes <ref-modes>`. This can
+        also be a tuple containing a mode to apply along each axis in ``axes``.
+    levels : int or sequence of ints, optional
+        Decomposition levels along each axis (must be >= 0). If an integer is
+        provided, the same number of levels are used for all axes. If
+        ``levels`` is None (default), ``dwt_max_level`` will be used to compute
+        the maximum number of levels possible for each axis.
+    axes : sequence of ints, optional
+        Axes over which to compute the transform. Axes may not be repeated. The
+        default is to transform along all axes.
+
+    Returns
+    -------
+    fswavedecn_result : FswavedecnResult object
+        Contains the wavelet coefficients, slice objects to allow obtaining
+        the coefficients per detail or approximation level, and more.
+        See ``FswavedecnResult`` for details.
+
+    Examples
+    --------
+    >>> from pywt import fswavedecn
+    >>> fs_result = fswavedecn(np.ones((32, 32)), 'sym2', levels=(1, 3))
+    >>> print(fs_result.detail_keys())
+    [(0, 1), (0, 2), (0, 3), (1, 0), (1, 1), (1, 2), (1, 3)]
+    >>> approx_coeffs = fs_result.approx
+    >>> detail_1_2 = fs_result[(1, 2)]
+
+
+    Notes
+    -----
+    This transformation has been variously referred to as the (fully) separable
+    wavelet transform (e.g. refs [1]_, [3]_), the tensor-product wavelet
+    ([2]_) or the hyperbolic wavelet transform ([4]_).  It is well suited to
+    data with anisotropic smoothness.
+
+    In [2]_ it was demonstrated that fully separable transform performs at
+    least as well as the DWT for image compression.  Computation time is a
+    factor 2 larger than that for the DWT.
+
+    See Also
+    --------
+    fswaverecn : inverse of fswavedecn
+
+    References
+    ----------
+    .. [1] PH Westerink. Subband Coding of Images. Ph.D. dissertation, Dept.
+       Elect. Eng., Inf. Theory Group, Delft Univ. Technol., Delft, The
+       Netherlands, 1989.  (see Section 2.3)
+       http://resolver.tudelft.nl/uuid:a4d195c3-1f89-4d66-913d-db9af0969509
+
+    .. [2] CP Rosiene and TQ Nguyen. Tensor-product wavelet vs. Mallat
+       decomposition: A comparative analysis, in Proc. IEEE Int. Symp.
+       Circuits and Systems, Orlando, FL, Jun. 1999, pp. 431-434.
+
+    .. [3] V Velisavljevic, B Beferull-Lozano, M Vetterli and PL Dragotti.
+       Directionlets: Anisotropic Multidirectional Representation With
+       Separable Filtering. IEEE Transactions on Image Processing, Vol. 15,
+       No. 7, July 2006.
+
+    .. [4] RA DeVore, SV Konyagin and VN Temlyakov. "Hyperbolic wavelet
+       approximation," Constr. Approx. 14 (1998), 1-26.
+    """
+    data = np.asarray(data)
+    if axes is None:
+        axes = tuple(np.arange(data.ndim))
+    _check_fswavedecn_axes(data, axes)
+
+    if levels is None or np.isscalar(levels):
+        levels = [levels, ] * len(axes)
+    if len(levels) != len(axes):
+        raise ValueError("levels must match the length of the axes list")
+
+    modes = _modes_per_axis(mode, axes)
+    wavelets = _wavelets_per_axis(wavelet, axes)
+
+    coeff_slices = [slice(None), ] * len(axes)
+    coeffs_arr = data
+    for ax_count, (ax, lev, wav, mode) in enumerate(
+            zip(axes, levels, wavelets, modes)):
+        coeffs = wavedec(coeffs_arr, wav, mode=mode, level=lev, axis=ax)
+
+        # Slice objects for accessing coefficient subsets.
+        # These can be used to access specific detail coefficient arrays
+        # (e.g. as needed for inverse transformation via fswaverecn).
+        c_shapes = [c.shape[ax] for c in coeffs]
+        c_offsets = np.cumsum([0, ] + c_shapes)
+        coeff_slices[ax_count] = [
+            slice(c_offsets[d], c_offsets[d+1]) for d in range(len(c_shapes))]
+
+        # stack the coefficients from all levels into a single array
+        coeffs_arr = np.concatenate(coeffs, axis=ax)
+
+    return FswavedecnResult(coeffs_arr, coeff_slices, wavelets, modes, axes)
+
+
+def fswaverecn(fswavedecn_result):
+    """Fully Separable Inverse Wavelet Reconstruction.
+
+    Parameters
+    ----------
+    fswavedecn_result : FswavedecnResult object
+        FswavedecnResult object from ``fswavedecn``.
+
+    Returns
+    -------
+    reconstructed : ndarray
+        Array of reconstructed data.
+
+    Notes
+    -----
+    This transformation has been variously referred to as the (fully) separable
+    wavelet transform (e.g. refs [1]_, [3]_), the tensor-product wavelet
+    ([2]_) or the hyperbolic wavelet transform ([4]_).  It is well suited to
+    data with anisotropic smoothness.
+
+    In [2]_ it was demonstrated that the fully separable transform performs at
+    least as well as the DWT for image compression. Computation time is a
+    factor 2 larger than that for the DWT.
+
+    See Also
+    --------
+    fswavedecn : inverse of fswaverecn
+
+    References
+    ----------
+    .. [1] PH Westerink. Subband Coding of Images. Ph.D. dissertation, Dept.
+       Elect. Eng., Inf. Theory Group, Delft Univ. Technol., Delft, The
+       Netherlands, 1989.  (see Section 2.3)
+       http://resolver.tudelft.nl/uuid:a4d195c3-1f89-4d66-913d-db9af0969509
+
+    .. [2] CP Rosiene and TQ Nguyen. Tensor-product wavelet vs. Mallat
+       decomposition: A comparative analysis, in Proc. IEEE Int. Symp.
+       Circuits and Systems, Orlando, FL, Jun. 1999, pp. 431-434.
+
+    .. [3] V Velisavljevic, B Beferull-Lozano, M Vetterli and PL Dragotti.
+       Directionlets: Anisotropic Multidirectional Representation With
+       Separable Filtering. IEEE Transactions on Image Processing, Vol. 15,
+       No. 7, July 2006.
+
+    .. [4] RA DeVore, SV Konyagin and VN Temlyakov. "Hyperbolic wavelet
+       approximation," Constr. Approx. 14 (1998), 1-26.
+    """
+    coeffs_arr = fswavedecn_result.coeffs
+    coeff_slices = fswavedecn_result.coeff_slices
+    axes = fswavedecn_result.axes
+    modes = fswavedecn_result.modes
+    wavelets = fswavedecn_result.wavelets
+
+    _check_fswavedecn_axes(coeffs_arr, axes)
+    if len(axes) != len(coeff_slices):
+        raise ValueError("dimension mismatch")
+
+    arr = coeffs_arr
+    csl = [slice(None), ] * arr.ndim
+    # for ax_count, (ax, wav, mode) in reversed(
+    #         list(enumerate(zip(axes, wavelets, modes)))):
+    for ax_count, (ax, wav, mode) in enumerate(zip(axes, wavelets, modes)):
+        coeffs = []
+        for sl in coeff_slices[ax_count]:
+            csl[ax] = sl
+            coeffs.append(arr[tuple(csl)])
+        csl[ax] = slice(None)
+        arr = waverec(coeffs, wav, mode=mode, axis=ax)
+    return arr

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/pywt/_pytest.py

@@ -0,0 +1,68 @@
+"""common test-related code."""
+import os
+import sys
+import multiprocessing
+import numpy as np
+import pytest
+
+
+__all__ = ['uses_matlab',   # skip if pymatbridge and Matlab unavailable
+           'uses_futures',  # skip if futures unavailable
+           'uses_pymatbridge',  # skip if no PYWT_XSLOW environment variable
+           'uses_precomputed',  # skip if PYWT_XSLOW environment variable found
+           'matlab_result_dict_cwt',   # dict with precomputed Matlab dwt data
+           'matlab_result_dict_dwt',   # dict with precomputed Matlab cwt data
+           'futures',      # the futures module or None
+           'max_workers',  # the number of workers available to futures
+           'size_set',     # the set of Matlab tests to run
+           ]
+
+try:
+    if sys.version_info[0] == 2:
+        import futures
+    else:
+        from concurrent import futures
+    max_workers = multiprocessing.cpu_count()
+    futures_available = True
+except ImportError:
+    futures_available = False
+    futures = None
+
+# check if pymatbridge + MATLAB tests should be run
+matlab_result_dict_dwt = None
+matlab_result_dict_cwt = None
+matlab_missing = True
+use_precomputed = True
+size_set = 'reduced'
+if 'PYWT_XSLOW' in os.environ:
+    try:
+        from pymatbridge import Matlab
+        mlab = Matlab()
+        matlab_missing = False
+        use_precomputed = False
+        size_set = 'full'
+    except ImportError:
+        print("To run Matlab compatibility tests you need to have MathWorks "
+              "MATLAB, MathWorks Wavelet Toolbox and the pymatbridge Python "
+              "package installed.")
+if use_precomputed:
+    # load dictionaries of precomputed results
+    data_dir = os.path.join(os.path.dirname(__file__), 'tests', 'data')
+    matlab_data_file_cwt = os.path.join(
+        data_dir, 'cwt_matlabR2015b_result.npz')
+    matlab_result_dict_cwt = np.load(matlab_data_file_cwt)
+
+    matlab_data_file_dwt = os.path.join(
+        data_dir, 'dwt_matlabR2012a_result.npz')
+    matlab_result_dict_dwt = np.load(matlab_data_file_dwt)
+
+uses_futures = pytest.mark.skipif(
+    not futures_available, reason='futures not available')
+uses_matlab = pytest.mark.skipif(
+    matlab_missing, reason='pymatbridge and/or Matlab not available')
+uses_pymatbridge = pytest.mark.skipif(
+    use_precomputed,
+    reason='PYWT_XSLOW set: skipping tests against precomputed Matlab results')
+uses_precomputed = pytest.mark.skipif(
+    not use_precomputed,
+    reason='PYWT_XSLOW not set: test against precomputed matlab tests')

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/pywt/_pytesttester.py

@@ -0,0 +1,164 @@
+"""
+Pytest test running.
+
+This module implements the ``test()`` function for NumPy modules. The usual
+boiler plate for doing that is to put the following in the module
+``__init__.py`` file::
+
+    from pywt._pytesttester import PytestTester
+    test = PytestTester(__name__).test
+    del PytestTester
+
+
+Warnings filtering and other runtime settings should be dealt with in the
+``pytest.ini`` file in the pywt repo root. The behavior of the test depends on
+whether or not that file is found as follows:
+
+* ``pytest.ini`` is present (develop mode)
+    All warnings except those explicily filtered out are raised as error.
+* ``pytest.ini`` is absent (release mode)
+    DeprecationWarnings and PendingDeprecationWarnings are ignored, other
+    warnings are passed through.
+
+In practice, tests run from the PyWavelets repo are run in develop mode. That
+includes the standard ``python runtests.py`` invocation.
+
+"""
+from __future__ import division, absolute_import, print_function
+
+import sys
+import os
+
+__all__ = ['PytestTester']
+
+
+def _show_pywt_info():
+    import pywt
+    from pywt._c99_config import _have_c99_complex
+    print("PyWavelets version %s" % pywt.__version__)
+    if _have_c99_complex:
+        print("Compiled with C99 complex support.")
+    else:
+        print("Compiled without C99 complex support.")
+
+
+class PytestTester(object):
+    """
+    Pytest test runner.
+
+    This class is made available in ``pywt.testing``, and a test function
+    is typically added to a package's __init__.py like so::
+
+      from pywt.testing import PytestTester
+      test = PytestTester(__name__).test
+      del PytestTester
+
+    Calling this test function finds and runs all tests associated with the
+    module and all its sub-modules.
+
+    Attributes
+    ----------
+    module_name : str
+        Full path to the package to test.
+
+    Parameters
+    ----------
+    module_name : module name
+        The name of the module to test.
+
+    """
+    def __init__(self, module_name):
+        self.module_name = module_name
+
+    def __call__(self, label='fast', verbose=1, extra_argv=None,
+                 doctests=False, coverage=False, durations=-1, tests=None):
+        """
+        Run tests for module using pytest.
+
+        Parameters
+        ----------
+        label : {'fast', 'full'}, optional
+            Identifies the tests to run. When set to 'fast', tests decorated
+            with `pytest.mark.slow` are skipped, when 'full', the slow marker
+            is ignored.
+        verbose : int, optional
+            Verbosity value for test outputs, in the range 1-3. Default is 1.
+        extra_argv : list, optional
+            List with any extra arguments to pass to pytests.
+        doctests : bool, optional
+            .. note:: Not supported
+        coverage : bool, optional
+            If True, report coverage of NumPy code. Default is False.
+            Requires installation of (pip) pytest-cov.
+        durations : int, optional
+            If < 0, do nothing, If 0, report time of all tests, if > 0,
+            report the time of the slowest `timer` tests. Default is -1.
+        tests : test or list of tests
+            Tests to be executed with pytest '--pyargs'
+
+        Returns
+        -------
+        result : bool
+            Return True on success, false otherwise.
+
+        Examples
+        --------
+        >>> result = np.lib.test() #doctest: +SKIP
+        ...
+        1023 passed, 2 skipped, 6 deselected, 1 xfailed in 10.39 seconds
+        >>> result
+        True
+
+        """
+        import pytest
+
+        module = sys.modules[self.module_name]
+        module_path = os.path.abspath(module.__path__[0])
+
+        # setup the pytest arguments
+        pytest_args = ["-l"]
+
+        # offset verbosity. The "-q" cancels a "-v".
+        pytest_args += ["-q"]
+
+        # Filter out annoying import messages. Want these in both develop and
+        # release mode.
+        pytest_args += [
+            "-W ignore:Not importing directory",
+            "-W ignore:numpy.dtype size changed",
+            "-W ignore:numpy.ufunc size changed", ]
+
+        if doctests:
+            raise ValueError("Doctests not supported")
+
+        if extra_argv:
+            pytest_args += list(extra_argv)
+
+        if verbose > 1:
+            pytest_args += ["-" + "v"*(verbose - 1)]
+
+        if coverage:
+            pytest_args += ["--cov=" + module_path]
+
+        if label == "fast":
+            pytest_args += ["-m", "not slow"]
+        elif label != "full":
+            pytest_args += ["-m", label]
+
+        if durations >= 0:
+            pytest_args += ["--durations=%s" % durations]
+
+        if tests is None:
+            tests = [self.module_name]
+
+        pytest_args += ["--pyargs"] + list(tests)
+
+        # run tests.
+        _show_pywt_info()
+
+        try:
+            code = pytest.main(pytest_args)
+        except SystemExit as exc:
+            code = exc.code
+
+        return code == 0

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/pywt/_swt.py

@@ -0,0 +1,824 @@
+import warnings
+from itertools import product
+
+import numpy as np
+
+from ._c99_config import _have_c99_complex
+from ._extensions._dwt import idwt_single
+from ._extensions._swt import swt_max_level, swt as _swt, swt_axis as _swt_axis
+from ._extensions._pywt import Wavelet, Modes, _check_dtype
+from ._multidim import idwt2, idwtn
+from ._utils import _as_wavelet, _wavelets_per_axis
+
+
+__all__ = ["swt", "swt_max_level", 'iswt', 'swt2', 'iswt2', 'swtn', 'iswtn']
+
+
+def _rescale_wavelet_filterbank(wavelet, sf):
+    wav = Wavelet(wavelet.name + 'r',
+                  [np.asarray(f) * sf for f in wavelet.filter_bank])
+
+    # copy attributes from the original wavelet
+    wav.orthogonal = wavelet.orthogonal
+    wav.biorthogonal = wavelet.biorthogonal
+    return wav
+
+
+def swt(data, wavelet, level=None, start_level=0, axis=-1,
+        trim_approx=False, norm=False):
+    """
+    Multilevel 1D stationary wavelet transform.
+
+    Parameters
+    ----------
+    data :
+        Input signal
+    wavelet :
+        Wavelet to use (Wavelet object or name)
+    level : int, optional
+        The number of decomposition steps to perform.
+    start_level : int, optional
+        The level at which the decomposition will begin (it allows one to
+        skip a given number of transform steps and compute
+        coefficients starting from start_level) (default: 0)
+    axis: int, optional
+        Axis over which to compute the SWT. If not given, the
+        last axis is used.
+    trim_approx : bool, optional
+        If True, approximation coefficients at the final level are retained.
+    norm : bool, optional
+        If True, transform is normalized so that the energy of the coefficients
+        will be equal to the energy of ``data``. In other words,
+        ``np.linalg.norm(data.ravel())`` will equal the norm of the
+        concatenated transform coefficients when ``trim_approx`` is True.
+
+    Returns
+    -------
+    coeffs : list
+        List of approximation and details coefficients pairs in order
+        similar to wavedec function::
+
+            [(cAn, cDn), ..., (cA2, cD2), (cA1, cD1)]
+
+        where n equals input parameter ``level``.
+
+        If ``start_level = m`` is given, then the beginning m steps are
+        skipped::
+
+            [(cAm+n, cDm+n), ..., (cAm+1, cDm+1), (cAm, cDm)]
+
+        If ``trim_approx`` is ``True``, then the output list is exactly as in
+        ``pywt.wavedec``, where the first coefficient in the list is the
+        approximation coefficient at the final level and the rest are the
+        detail coefficients::
+
+            [cAn, cDn, ..., cD2, cD1]
+
+    Notes
+    -----
+    The implementation here follows the "algorithm a-trous" and requires that
+    the signal length along the transformed axis be a multiple of ``2**level``.
+    If this is not the case, the user should pad up to an appropriate size
+    using a function such as ``numpy.pad``.
+
+    A primary benefit of this transform in comparison to its decimated
+    counterpart (``pywt.wavedecn``), is that it is shift-invariant. This comes
+    at cost of redundancy in the transform (the size of the output coefficients
+    is larger than the input).
+
+    When the following three conditions are true:
+
+        1. The wavelet is orthogonal
+        2. ``swt`` is called with ``norm=True``
+        3. ``swt`` is called with ``trim_approx=True``
+
+    the transform has the following additional properties that may be
+    desirable in applications:
+
+        1. energy is conserved
+        2. variance is partitioned across scales
+
+    When used with ``norm=True``, this transform is closely related to the
+    multiple-overlap DWT (MODWT) as popularized for time-series analysis,
+    although the underlying implementation is slightly different from the one
+    published in [1]_. Specifically, the implementation used here requires a
+    signal that is a multiple of ``2**level`` in length.
+
+    References
+    ----------
+    .. [1] DB Percival and AT Walden. Wavelet Methods for Time Series Analysis.
+        Cambridge University Press, 2000.
+    """
+
+    if not _have_c99_complex and np.iscomplexobj(data):
+        data = np.asarray(data)
+        kwargs = dict(wavelet=wavelet, level=level, start_level=start_level,
+                      trim_approx=trim_approx, axis=axis, norm=norm)
+        coeffs_real = swt(data.real, **kwargs)
+        coeffs_imag = swt(data.imag, **kwargs)
+        if not trim_approx:
+            coeffs_cplx = []
+            for (cA_r, cD_r), (cA_i, cD_i) in zip(coeffs_real, coeffs_imag):
+                coeffs_cplx.append((cA_r + 1j*cA_i, cD_r + 1j*cD_i))
+        else:
+            coeffs_cplx = [cr + 1j*ci
+                           for (cr, ci) in zip(coeffs_real, coeffs_imag)]
+        return coeffs_cplx
+
+    # accept array_like input; make a copy to ensure a contiguous array
+    dt = _check_dtype(data)
+    data = np.array(data, dtype=dt)
+
+    wavelet = _as_wavelet(wavelet)
+    if norm:
+        if not wavelet.orthogonal:
+            warnings.warn(
+                "norm=True, but the wavelet is not orthogonal: \n"
+                "\tThe conditions for energy preservation are not satisfied.")
+        wavelet = _rescale_wavelet_filterbank(wavelet, 1/np.sqrt(2))
+
+    if axis < 0:
+        axis = axis + data.ndim
+    if not 0 <= axis < data.ndim:
+        raise np.AxisError("Axis greater than data dimensions")
+
+    if level is None:
+        level = swt_max_level(data.shape[axis])
+
+    if data.ndim == 1:
+        ret = _swt(data, wavelet, level, start_level, trim_approx)
+    else:
+        ret = _swt_axis(data, wavelet, level, start_level, axis, trim_approx)
+    return ret
+
+
+def iswt(coeffs, wavelet, norm=False, axis=-1):
+    """
+    Multilevel 1D inverse discrete stationary wavelet transform.
+
+    Parameters
+    ----------
+    coeffs : array_like
+        Coefficients list of tuples::
+
+            [(cAn, cDn), ..., (cA2, cD2), (cA1, cD1)]
+
+        where cA is approximation, cD is details.  Index 1 corresponds to
+        ``start_level`` from ``pywt.swt``.
+    wavelet : Wavelet object or name string
+        Wavelet to use
+    norm : bool, optional
+        Controls the normalization used by the inverse transform. This must
+        be set equal to the value that was used by ``pywt.swt`` to preserve the
+        energy of a round-trip transform.
+
+    Returns
+    -------
+    1D array of reconstructed data.
+
+    Examples
+    --------
+    >>> import pywt
+    >>> coeffs = pywt.swt([1,2,3,4,5,6,7,8], 'db2', level=2)
+    >>> pywt.iswt(coeffs, 'db2')
+    array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.])
+    """
+    # copy to avoid modification of input data
+    # If swt was called with trim_approx=False, first element is a tuple
+    trim_approx = not isinstance(coeffs[0], (tuple, list))
+    cA = coeffs[0] if trim_approx else coeffs[0][0]
+    if cA.ndim > 1:
+        # convert to swtn coefficient format and call iswtn
+        if trim_approx:
+            coeffs_nd = [cA] + [{'d': d} for d in coeffs[1:]]
+        else:
+            coeffs_nd = [{'a': a, 'd': d} for a, d in coeffs]
+        return iswtn(coeffs_nd, wavelet, axes=(axis,), norm=norm)
+    elif axis != 0 and axis != -1:
+        raise np.AxisError("Axis greater than data dimensions")
+    if not _have_c99_complex and np.iscomplexobj(cA):
+        if trim_approx:
+            coeffs_real = [c.real for c in coeffs]
+            coeffs_imag = [c.imag for c in coeffs]
+        else:
+            coeffs_real = [(ca.real, cd.real) for ca, cd in coeffs]
+            coeffs_imag = [(ca.imag, cd.imag) for ca, cd in coeffs]
+        kwargs = dict(wavelet=wavelet, norm=norm)
+        y = iswt(coeffs_real, **kwargs)
+        return y + 1j * iswt(coeffs_imag, **kwargs)
+
+    if trim_approx:
+        coeffs = coeffs[1:]
+
+    if cA.ndim != 1:
+        raise ValueError("iswt only supports 1D data")
+
+    dt = _check_dtype(cA)
+    output = np.array(cA, dtype=dt, copy=True)
+
+    # num_levels, equivalent to the decomposition level, n
+    num_levels = len(coeffs)
+    wavelet = _as_wavelet(wavelet)
+    if norm:
+        wavelet = _rescale_wavelet_filterbank(wavelet, np.sqrt(2))
+    mode = Modes.from_object('periodization')
+    for j in range(num_levels, 0, -1):
+        step_size = int(pow(2, j-1))
+        last_index = step_size
+        if trim_approx:
+            cD = coeffs[-j]
+        else:
+            _, cD = coeffs[-j]
+        cD = np.asarray(cD, dtype=_check_dtype(cD))
+        if cD.dtype != output.dtype:
+            # upcast to a common dtype (float64 or complex128)
+            if output.dtype.kind == 'c' or cD.dtype.kind == 'c':
+                dtype = np.complex128
+            else:
+                dtype = np.float64
+            output = np.asarray(output, dtype=dtype)
+            cD = np.asarray(cD, dtype=dtype)
+        for first in range(last_index):  # 0 to last_index - 1
+
+            # Getting the indices that we will transform
+            indices = np.arange(first, len(cD), step_size)
+
+            # select the even indices
+            even_indices = indices[0::2]
+            # select the odd indices
+            odd_indices = indices[1::2]
+
+            # perform the inverse dwt on the selected indices,
+            # making sure to use periodic boundary conditions
+            # Note:  indexing with an array of ints returns a contiguous
+            #        copy as required by idwt_single.
+            x1 = idwt_single(output[even_indices],
+                             cD[even_indices],
+                             wavelet, mode)
+            x2 = idwt_single(output[odd_indices],
+                             cD[odd_indices],
+                             wavelet, mode)
+
+            # perform a circular shift right
+            x2 = np.roll(x2, 1)
+
+            # average and insert into the correct indices
+            output[indices] = (x1 + x2)/2.
+
+    return output
+
+
+def swt2(data, wavelet, level, start_level=0, axes=(-2, -1),
+         trim_approx=False, norm=False):
+    """
+    Multilevel 2D stationary wavelet transform.
+
+    Parameters
+    ----------
+    data : array_like
+        2D array with input data
+    wavelet : Wavelet object or name string, or 2-tuple of wavelets
+        Wavelet to use.  This can also be a tuple of wavelets to apply per
+        axis in ``axes``.
+    level : int
+        The number of decomposition steps to perform.
+    start_level : int, optional
+        The level at which the decomposition will start (default: 0)
+    axes : 2-tuple of ints, optional
+        Axes over which to compute the SWT. Repeated elements are not allowed.
+    trim_approx : bool, optional
+        If True, approximation coefficients at the final level are retained.
+    norm : bool, optional
+        If True, transform is normalized so that the energy of the coefficients
+        will be equal to the energy of ``data``. In other words,
+        ``np.linalg.norm(data.ravel())`` will equal the norm of the
+        concatenated transform coefficients when ``trim_approx`` is True.
+
+    Returns
+    -------
+    coeffs : list
+        Approximation and details coefficients (for ``start_level = m``).
+        If ``trim_approx`` is ``False``, approximation coefficients are
+        retained for all levels::
+
+            [
+                (cA_m+level,
+                    (cH_m+level, cV_m+level, cD_m+level)
+                ),
+                ...,
+                (cA_m+1,
+                    (cH_m+1, cV_m+1, cD_m+1)
+                ),
+                (cA_m,
+                    (cH_m, cV_m, cD_m)
+                )
+            ]
+
+        where cA is approximation, cH is horizontal details, cV is
+        vertical details, cD is diagonal details and m is ``start_level``.
+
+        If ``trim_approx`` is ``True``, approximation coefficients are only
+        retained at the final level of decomposition. This matches the format
+        used by ``pywt.wavedec2``::
+
+            [
+                cA_m+level,
+                (cH_m+level, cV_m+level, cD_m+level),
+                ...,
+                (cH_m+1, cV_m+1, cD_m+1),
+                (cH_m, cV_m, cD_m),
+            ]
+
+    Notes
+    -----
+    The implementation here follows the "algorithm a-trous" and requires that
+    the signal length along the transformed axes be a multiple of ``2**level``.
+    If this is not the case, the user should pad up to an appropriate size
+    using a function such as ``numpy.pad``.
+
+    A primary benefit of this transform in comparison to its decimated
+    counterpart (``pywt.wavedecn``), is that it is shift-invariant. This comes
+    at cost of redundancy in the transform (the size of the output coefficients
+    is larger than the input).
+
+    When the following three conditions are true:
+
+        1. The wavelet is orthogonal
+        2. ``swt2`` is called with ``norm=True``
+        3. ``swt2`` is called with ``trim_approx=True``
+
+    the transform has the following additional properties that may be
+    desirable in applications:
+
+        1. energy is conserved
+        2. variance is partitioned across scales
+
+    """
+    axes = tuple(axes)
+    data = np.asarray(data)
+    if len(axes) != 2:
+        raise ValueError("Expected 2 axes")
+    if len(axes) != len(set(axes)):
+        raise ValueError("The axes passed to swt2 must be unique.")
+    if data.ndim < len(np.unique(axes)):
+        raise ValueError("Input array has fewer dimensions than the specified "
+                         "axes")
+
+    coefs = swtn(data, wavelet, level, start_level, axes, trim_approx, norm)
+    ret = []
+    if trim_approx:
+        ret.append(coefs[0])
+        coefs = coefs[1:]
+    for c in coefs:
+        if trim_approx:
+            ret.append((c['da'], c['ad'], c['dd']))
+        else:
+            ret.append((c['aa'], (c['da'], c['ad'], c['dd'])))
+    return ret
+
+
+def iswt2(coeffs, wavelet, norm=False, axes=(-2, -1)):
+    """
+    Multilevel 2D inverse discrete stationary wavelet transform.
+
+    Parameters
+    ----------
+    coeffs : list
+        Approximation and details coefficients::
+
+            [
+                (cA_n,
+                    (cH_n, cV_n, cD_n)
+                ),
+                ...,
+                (cA_2,
+                    (cH_2, cV_2, cD_2)
+                ),
+                (cA_1,
+                    (cH_1, cV_1, cD_1)
+                )
+            ]
+
+        where cA is approximation, cH is horizontal details, cV is
+        vertical details, cD is diagonal details and n is the number of
+        levels.  Index 1 corresponds to ``start_level`` from ``pywt.swt2``.
+    wavelet : Wavelet object or name string, or 2-tuple of wavelets
+        Wavelet to use.  This can also be a 2-tuple of wavelets to apply per
+        axis.
+    norm : bool, optional
+        Controls the normalization used by the inverse transform. This must
+        be set equal to the value that was used by ``pywt.swt2`` to preserve
+        the energy of a round-trip transform.
+
+    Returns
+    -------
+    2D array of reconstructed data.
+
+    Examples
+    --------
+    >>> import pywt
+    >>> coeffs = pywt.swt2([[1,2,3,4],[5,6,7,8],
+    ...                     [9,10,11,12],[13,14,15,16]],
+    ...                    'db1', level=2)
+    >>> pywt.iswt2(coeffs, 'db1')
+    array([[  1.,   2.,   3.,   4.],
+           [  5.,   6.,   7.,   8.],
+           [  9.,  10.,  11.,  12.],
+           [ 13.,  14.,  15.,  16.]])
+
+    """
+
+    # If swt was called with trim_approx=False, first element is a tuple
+    trim_approx = not isinstance(coeffs[0], (tuple, list))
+    cA = coeffs[0] if trim_approx else coeffs[0][0]
+    if cA.ndim != 2 or axes != (-2, -1):
+        # convert to swtn coefficient format and call iswtn instead
+        if trim_approx:
+            coeffs_nd = [cA] + [{'da': h, 'ad': v, 'dd': d}
+                                for h, v, d in coeffs[1:]]
+        else:
+            coeffs_nd = [{'aa': a, 'da': h, 'ad': v, 'dd': d}
+                         for a, (h, v, d) in coeffs]
+        return iswtn(coeffs_nd, wavelet, axes=axes, norm=norm)
+    if not _have_c99_complex and np.iscomplexobj(cA):
+        if trim_approx:
+            coeffs_real = [cA.real]
+            coeffs_real += [(h.real, v.real, d.real) for h, v, d in coeffs[1:]]
+            coeffs_imag = [cA.imag]
+            coeffs_imag += [(h.imag, v.imag, d.imag) for h, v, d in coeffs[1:]]
+        else:
+            coeffs_real = [(a.real, (h.real, v.real, d.real))
+                            for a, (h, v, d) in coeffs]
+            coeffs_imag = [(a.imag, (h.imag, v.imag, d.imag))
+                            for a, (h, v, d) in coeffs]
+        kwargs = dict(wavelet=wavelet, norm=norm)
+        y = iswt2(coeffs_real, **kwargs)
+        return y + 1j * iswt2(coeffs_imag, **kwargs)
+
+    if trim_approx:
+        coeffs = coeffs[1:]
+
+    # copy to avoid modification of input data
+    dt = _check_dtype(cA)
+    output = np.array(cA, dtype=dt, copy=True)
+
+    if output.ndim != 2:
+        raise ValueError(
+            "iswt2 only supports 2D arrays.  see iswtn for a general "
+            "n-dimensionsal ISWT")
+    # num_levels, equivalent to the decomposition level, n
+    num_levels = len(coeffs)
+    wavelets = _wavelets_per_axis(wavelet, axes=(0, 1))
+    if norm:
+        wavelets = [_rescale_wavelet_filterbank(wav, np.sqrt(2))
+                    for wav in wavelets]
+
+    for j in range(num_levels):
+        step_size = int(pow(2, num_levels-j-1))
+        last_index = step_size
+        if trim_approx:
+            (cH, cV, cD) = coeffs[j]
+        else:
+            _, (cH, cV, cD) = coeffs[j]
+        # We are going to assume cH, cV, and cD are of equal size
+        if (cH.shape != cV.shape) or (cH.shape != cD.shape):
+            raise RuntimeError(
+                "Mismatch in shape of intermediate coefficient arrays")
+
+        # make sure output shares the common dtype
+        # (conversion of dtype for individual coeffs is handled within idwt2 )
+        common_dtype = np.result_type(*(
+            [dt, ] + [_check_dtype(c) for c in [cH, cV, cD]]))
+        if output.dtype != common_dtype:
+            output = output.astype(common_dtype)
+
+        for first_h in range(last_index):  # 0 to last_index - 1
+            for first_w in range(last_index):  # 0 to last_index - 1
+                # Getting the indices that we will transform
+                indices_h = slice(first_h, cH.shape[0], step_size)
+                indices_w = slice(first_w, cH.shape[1], step_size)
+
+                even_idx_h = slice(first_h, cH.shape[0], 2*step_size)
+                even_idx_w = slice(first_w, cH.shape[1], 2*step_size)
+                odd_idx_h = slice(first_h + step_size, cH.shape[0], 2*step_size)
+                odd_idx_w = slice(first_w + step_size, cH.shape[1], 2*step_size)
+
+                # perform the inverse dwt on the selected indices,
+                # making sure to use periodic boundary conditions
+                x1 = idwt2((output[even_idx_h, even_idx_w],
+                           (cH[even_idx_h, even_idx_w],
+                            cV[even_idx_h, even_idx_w],
+                            cD[even_idx_h, even_idx_w])),
+                           wavelets, 'periodization')
+                x2 = idwt2((output[even_idx_h, odd_idx_w],
+                           (cH[even_idx_h, odd_idx_w],
+                            cV[even_idx_h, odd_idx_w],
+                            cD[even_idx_h, odd_idx_w])),
+                           wavelets, 'periodization')
+                x3 = idwt2((output[odd_idx_h, even_idx_w],
+                           (cH[odd_idx_h, even_idx_w],
+                            cV[odd_idx_h, even_idx_w],
+                            cD[odd_idx_h, even_idx_w])),
+                           wavelets, 'periodization')
+                x4 = idwt2((output[odd_idx_h, odd_idx_w],
+                           (cH[odd_idx_h, odd_idx_w],
+                            cV[odd_idx_h, odd_idx_w],
+                            cD[odd_idx_h, odd_idx_w])),
+                           wavelets, 'periodization')
+
+                # perform a circular shifts
+                x2 = np.roll(x2, 1, axis=1)
+                x3 = np.roll(x3, 1, axis=0)
+                x4 = np.roll(x4, 1, axis=0)
+                x4 = np.roll(x4, 1, axis=1)
+                output[indices_h, indices_w] = (x1 + x2 + x3 + x4) / 4
+
+    return output
+
+
+def swtn(data, wavelet, level, start_level=0, axes=None, trim_approx=False,
+         norm=False):
+    """
+    n-dimensional stationary wavelet transform.
+
+    Parameters
+    ----------
+    data : array_like
+        n-dimensional array with input data.
+    wavelet : Wavelet object or name string, or tuple of wavelets
+        Wavelet to use.  This can also be a tuple of wavelets to apply per
+        axis in ``axes``.
+    level : int
+        The number of decomposition steps to perform.
+    start_level : int, optional
+        The level at which the decomposition will start (default: 0)
+    axes : sequence of ints, optional
+        Axes over which to compute the SWT. A value of ``None`` (the
+        default) selects all axes. Axes may not be repeated.
+    trim_approx : bool, optional
+        If True, approximation coefficients at the final level are retained.
+    norm : bool, optional
+        If True, transform is normalized so that the energy of the coefficients
+        will be equal to the energy of ``data``. In other words,
+        ``np.linalg.norm(data.ravel())`` will equal the norm of the
+        concatenated transform coefficients when ``trim_approx`` is True.
+
+    Returns
+    -------
+    [{coeffs_level_n}, ..., {coeffs_level_1}]: list of dict
+        Results for each level are arranged in a dictionary, where the key
+        specifies the transform type on each dimension and value is a
+        n-dimensional coefficients array.
+
+        For example, for a 2D case the result at a given level will look
+        something like this::
+
+            {'aa': <coeffs>  # A(LL) - approx. on 1st dim, approx. on 2nd dim
+             'ad': <coeffs>  # V(LH) - approx. on 1st dim, det. on 2nd dim
+             'da': <coeffs>  # H(HL) - det. on 1st dim, approx. on 2nd dim
+             'dd': <coeffs>  # D(HH) - det. on 1st dim, det. on 2nd dim
+            }
+
+        For user-specified ``axes``, the order of the characters in the
+        dictionary keys map to the specified ``axes``.
+
+        If ``trim_approx`` is ``True``, the first element of the list contains
+        the array of approximation coefficients from the final level of
+        decomposition, while the remaining coefficient dictionaries contain
+        only detail coefficients. This matches the behavior of `pywt.wavedecn`.
+
+    Notes
+    -----
+    The implementation here follows the "algorithm a-trous" and requires that
+    the signal length along the transformed axes be a multiple of ``2**level``.
+    If this is not the case, the user should pad up to an appropriate size
+    using a function such as ``numpy.pad``.
+
+    A primary benefit of this transform in comparison to its decimated
+    counterpart (``pywt.wavedecn``), is that it is shift-invariant. This comes
+    at cost of redundancy in the transform (the size of the output coefficients
+    is larger than the input).
+
+    When the following three conditions are true:
+
+        1. The wavelet is orthogonal
+        2. ``swtn`` is called with ``norm=True``
+        3. ``swtn`` is called with ``trim_approx=True``
+
+    the transform has the following additional properties that may be
+    desirable in applications:
+
+        1. energy is conserved
+        2. variance is partitioned across scales
+
+    """
+    data = np.asarray(data)
+    if not _have_c99_complex and np.iscomplexobj(data):
+        kwargs = dict(wavelet=wavelet, level=level, start_level=start_level,
+                      trim_approx=trim_approx, axes=axes, norm=norm)
+        real = swtn(data.real, **kwargs)
+        imag = swtn(data.imag, **kwargs)
+        if trim_approx:
+            cplx = [real[0] + 1j * imag[0]]
+            offset = 1
+        else:
+            cplx = []
+            offset = 0
+        for rdict, idict in zip(real[offset:], imag[offset:]):
+            cplx.append(
+                dict((k, rdict[k] + 1j * idict[k]) for k in rdict.keys()))
+        return cplx
+
+    if data.dtype == np.dtype('object'):
+        raise TypeError("Input must be a numeric array-like")
+    if data.ndim < 1:
+        raise ValueError("Input data must be at least 1D")
+
+    if axes is None:
+        axes = range(data.ndim)
+    axes = [a + data.ndim if a < 0 else a for a in axes]
+    if any(a < 0 or a >= data.ndim for a in axes):
+        raise np.AxisError("Axis greater than data dimensions")
+    if len(axes) != len(set(axes)):
+        raise ValueError("The axes passed to swtn must be unique.")
+    num_axes = len(axes)
+
+    wavelets = _wavelets_per_axis(wavelet, axes)
+    if norm:
+        if not np.all([wav.orthogonal for wav in wavelets]):
+            warnings.warn(
+                "norm=True, but the wavelets used are not orthogonal: \n"
+                "\tThe conditions for energy preservation are not satisfied.")
+        wavelets = [_rescale_wavelet_filterbank(wav, 1/np.sqrt(2))
+                    for wav in wavelets]
+    ret = []
+    for i in range(start_level, start_level + level):
+        coeffs = [('', data)]
+        for axis, wavelet in zip(axes, wavelets):
+            new_coeffs = []
+            for subband, x in coeffs:
+                cA, cD = _swt_axis(x, wavelet, level=1, start_level=i,
+                                   axis=axis)[0]
+                new_coeffs.extend([(subband + 'a', cA),
+                                   (subband + 'd', cD)])
+            coeffs = new_coeffs
+
+        coeffs = dict(coeffs)
+        ret.append(coeffs)
+
+        # data for the next level is the approximation coeffs from this level
+        data = coeffs['a' * num_axes]
+        if trim_approx:
+            coeffs.pop('a' * num_axes)
+    if trim_approx:
+        ret.append(data)
+    ret.reverse()
+    return ret
+
+
+def iswtn(coeffs, wavelet, axes=None, norm=False):
+    """
+    Multilevel nD inverse discrete stationary wavelet transform.
+
+    Parameters
+    ----------
+    coeffs : list
+        [{coeffs_level_n}, ..., {coeffs_level_1}]: list of dict
+    wavelet : Wavelet object or name string, or tuple of wavelets
+        Wavelet to use.  This can also be a tuple of wavelets to apply per
+        axis in ``axes``.
+    axes : sequence of ints, optional
+        Axes over which to compute the inverse SWT. Axes may not be repeated.
+        The default is ``None``, which means transform all axes
+        (``axes = range(data.ndim)``).
+    norm : bool, optional
+        Controls the normalization used by the inverse transform. This must
+        be set equal to the value that was used by ``pywt.swtn`` to preserve
+        the energy of a round-trip transform.
+
+    Returns
+    -------
+    nD array of reconstructed data.
+
+    Examples
+    --------
+    >>> import pywt
+    >>> coeffs = pywt.swtn([[1,2,3,4],[5,6,7,8],
+    ...                     [9,10,11,12],[13,14,15,16]],
+    ...                    'db1', level=2)
+    >>> pywt.iswtn(coeffs, 'db1')
+    array([[  1.,   2.,   3.,   4.],
+           [  5.,   6.,   7.,   8.],
+           [  9.,  10.,  11.,  12.],
+           [ 13.,  14.,  15.,  16.]])
+
+    """
+
+    # key length matches the number of axes transformed
+    ndim_transform = max(len(key) for key in coeffs[-1].keys())
+    trim_approx = not isinstance(coeffs[0], dict)
+    cA = coeffs[0] if trim_approx else coeffs[0]['a'*ndim_transform]
+
+    if not _have_c99_complex and np.iscomplexobj(cA):
+        if trim_approx:
+            coeffs_real = [coeffs[0].real]
+            coeffs_imag = [coeffs[0].imag]
+            coeffs = coeffs[1:]
+        else:
+            coeffs_real = []
+            coeffs_imag = []
+        coeffs_real += [{k: v.real for k, v in c.items()} for c in coeffs]
+        coeffs_imag += [{k: v.imag for k, v in c.items()} for c in coeffs]
+        kwargs = dict(wavelet=wavelet, axes=axes, norm=norm)
+        y = iswtn(coeffs_real, **kwargs)
+        return y + 1j * iswtn(coeffs_imag, **kwargs)
+
+    if trim_approx:
+        coeffs = coeffs[1:]
+
+    # copy to avoid modification of input data
+    dt = _check_dtype(cA)
+    output = np.array(cA, dtype=dt, copy=True)
+    ndim = output.ndim
+
+    if axes is None:
+        axes = range(output.ndim)
+    axes = [a + ndim if a < 0 else a for a in axes]
+    if len(axes) != len(set(axes)):
+        raise ValueError("The axes passed to swtn must be unique.")
+    if ndim_transform != len(axes):
+        raise ValueError("The number of axes used in iswtn must match the "
+                         "number of dimensions transformed in swtn.")
+
+    # num_levels, equivalent to the decomposition level, n
+    num_levels = len(coeffs)
+    wavelets = _wavelets_per_axis(wavelet, axes)
+    if norm:
+        wavelets = [_rescale_wavelet_filterbank(wav, np.sqrt(2))
+                    for wav in wavelets]
+
+    # initialize various slice objects used in the loops below
+    # these will remain slice(None) only on axes that aren't transformed
+    indices = [slice(None), ]*ndim
+    even_indices = [slice(None), ]*ndim
+    odd_indices = [slice(None), ]*ndim
+    odd_even_slices = [slice(None), ]*ndim
+
+    for j in range(num_levels):
+        step_size = int(pow(2, num_levels-j-1))
+        last_index = step_size
+        if not trim_approx:
+            a = coeffs[j].pop('a'*ndim_transform)  # will restore later
+        details = coeffs[j]
+        # make sure dtype matches the coarsest level approximation coefficients
+        common_dtype = np.result_type(*(
+            [dt, ] + [v.dtype for v in details.values()]))
+        if output.dtype != common_dtype:
+            output = output.astype(common_dtype)
+
+        # We assume all coefficient arrays are of equal size
+        shapes = [v.shape for k, v in details.items()]
+        if len(set(shapes)) != 1:
+            raise RuntimeError(
+                "Mismatch in shape of intermediate coefficient arrays")
+
+        # shape of a single coefficient array, excluding non-transformed axes
+        coeff_trans_shape = tuple([shapes[0][ax] for ax in axes])
+
+        # nested loop over all combinations of axis offsets at this level
+        for firsts in product(*([range(last_index), ]*ndim_transform)):
+            for first, sh, ax in zip(firsts, coeff_trans_shape, axes):
+                indices[ax] = slice(first, sh, step_size)
+                even_indices[ax] = slice(first, sh, 2*step_size)
+                odd_indices[ax] = slice(first+step_size, sh, 2*step_size)
+
+            # nested loop over all combinations of odd/even inidices
+            approx = output.copy()
+            output[tuple(indices)] = 0
+            ntransforms = 0
+            for odds in product(*([(0, 1), ]*ndim_transform)):
+                for o, ax in zip(odds, axes):
+                    if o:
+                        odd_even_slices[ax] = odd_indices[ax]
+                    else:
+                        odd_even_slices[ax] = even_indices[ax]
+                # extract the odd/even indices for all detail coefficients
+                details_slice = {}
+                for key, value in details.items():
+                    details_slice[key] = value[tuple(odd_even_slices)]
+                details_slice['a'*ndim_transform] = approx[
+                    tuple(odd_even_slices)]
+
+                # perform the inverse dwt on the selected indices,
+                # making sure to use periodic boundary conditions
+                x = idwtn(details_slice, wavelets, 'periodization', axes=axes)
+                for o, ax in zip(odds, axes):
+                    # circular shift along any odd indexed axis
+                    if o:
+                        x = np.roll(x, 1, axis=ax)
+                output[tuple(indices)] += x
+                ntransforms += 1
+            output[tuple(indices)] /= ntransforms  # normalize
+        if not trim_approx:
+            coeffs[j]['a'*ndim_transform] = a  # restore approx coeffs to dict
+    return output