Add files using upload-large-folder tool

.gitattributes

@@ -297,3 +297,9 @@ my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/h5py/h5d.cp
 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/scikit_learn.libs/libgomp-a34b3233.so.1.0.0 filter=lfs diff=lfs merge=lfs -text
+my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/h5py/h5t.cpython-38-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/torchaudio/_torchaudio.so filter=lfs diff=lfs merge=lfs -text
+my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/Pillow.libs/libpng16-52f22300.so.16.37.0 filter=lfs diff=lfs merge=lfs -text
+my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/scikit_image.libs/libgomp-a34b3233.so.1.0.0 filter=lfs diff=lfs merge=lfs -text
+my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/scipy.libs/libquadmath-96973f99.so.0.0.0 filter=lfs diff=lfs merge=lfs -text

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/Pillow.libs/libpng16-52f22300.so.16.37.0

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

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/cryptography-3.4.8.dist-info/INSTALLER

@@ -0,0 +1 @@
+conda

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/cryptography-3.4.8.dist-info/LICENSE

@@ -0,0 +1,6 @@
+This software is made available under the terms of *either* of the licenses
+found in LICENSE.APACHE or LICENSE.BSD. Contributions to cryptography are made
+under the terms of *both* these licenses.
+
+The code used in the OS random engine is derived from CPython, and is licensed
+under the terms of the PSF License Agreement.

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/cryptography-3.4.8.dist-info/LICENSE.APACHE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        https://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
+
+       https://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/cryptography-3.4.8.dist-info/LICENSE.PSF

@@ -0,0 +1,41 @@
+1. This LICENSE AGREEMENT is between the Python Software Foundation ("PSF"), and
+   the Individual or Organization ("Licensee") accessing and otherwise using Python
+   2.7.12 software in source or binary form and its associated documentation.
+
+2. Subject to the terms and conditions of this License Agreement, PSF hereby
+   grants Licensee a nonexclusive, royalty-free, world-wide license to reproduce,
+   analyze, test, perform and/or display publicly, prepare derivative works,
+   distribute, and otherwise use Python 2.7.12 alone or in any derivative
+   version, provided, however, that PSF's License Agreement and PSF's notice of
+   copyright, i.e., "Copyright © 2001-2016 Python Software Foundation; All Rights
+   Reserved" are retained in Python 2.7.12 alone or in any derivative version
+   prepared by Licensee.
+
+3. In the event Licensee prepares a derivative work that is based on or
+   incorporates Python 2.7.12 or any part thereof, and wants to make the
+   derivative work available to others as provided herein, then Licensee hereby
+   agrees to include in any such work a brief summary of the changes made to Python
+   2.7.12.
+
+4. PSF is making Python 2.7.12 available to Licensee on an "AS IS" basis.
+   PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED.  BY WAY OF
+   EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND DISCLAIMS ANY REPRESENTATION OR
+   WARRANTY OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE
+   USE OF PYTHON 2.7.12 WILL NOT INFRINGE ANY THIRD PARTY RIGHTS.
+
+5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON 2.7.12
+   FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS A RESULT OF
+   MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON 2.7.12, OR ANY DERIVATIVE
+   THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
+
+6. This License Agreement will automatically terminate upon a material breach of
+   its terms and conditions.
+
+7. Nothing in this License Agreement shall be deemed to create any relationship
+   of agency, partnership, or joint venture between PSF and Licensee.  This License
+   Agreement does not grant permission to use PSF trademarks or trade name in a
+   trademark sense to endorse or promote products or services of Licensee, or any
+   third party.
+
+8. By copying, installing or otherwise using Python 2.7.12, Licensee agrees
+   to be bound by the terms and conditions of this License Agreement.

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/cryptography-3.4.8.dist-info/RECORD

@@ -0,0 +1,189 @@
+cryptography-3.4.8.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+cryptography-3.4.8.dist-info/LICENSE,sha256=Q9rSzHUqtyHNmp827OcPtTq3cTVR8tPYaU2OjFoG1uI,323
+cryptography-3.4.8.dist-info/LICENSE.APACHE,sha256=qsc7MUj20dcRHbyjIJn2jSbGRMaBOuHk8F9leaomY_4,11360
+cryptography-3.4.8.dist-info/LICENSE.BSD,sha256=YCxMdILeZHndLpeTzaJ15eY9dz2s0eymiSMqtwCPtPs,1532
+cryptography-3.4.8.dist-info/LICENSE.PSF,sha256=aT7ApmKzn5laTyUrA6YiKUVHDBtvEsoCkY5O_g32S58,2415
+cryptography-3.4.8.dist-info/METADATA,sha256=YmATOFBmnPoAnlGZIf8XwOw2GGEcUv9QGgqgusVOqNs,5171
+cryptography-3.4.8.dist-info/RECORD,,
+cryptography-3.4.8.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cryptography-3.4.8.dist-info/WHEEL,sha256=lZtnO0mZxqr35T145kHCmb-YnzMXkVWJhJ6jnbb7-XE,103
+cryptography-3.4.8.dist-info/direct_url.json,sha256=id5KSvB64YamuPh3QnIux4QOgiFnFq41ltIFKfgnthc,108
+cryptography-3.4.8.dist-info/top_level.txt,sha256=rR2wh6A6juD02TBZNJqqonh8x9UP9Sa5Z9Hl1pCPCiM,31
+cryptography/__about__.py,sha256=Gma4uMyERDaqXMloHsN56Lo-XunkiH9-joZKZJPG5a8,805
+cryptography/__init__.py,sha256=qZ9_96xJ8au-AKkdk2Kq60RKN7zGaim_8YY_rAy3_QY,511
+cryptography/__pycache__/__about__.cpython-38.pyc,,
+cryptography/__pycache__/__init__.cpython-38.pyc,,
+cryptography/__pycache__/exceptions.cpython-38.pyc,,
+cryptography/__pycache__/fernet.cpython-38.pyc,,
+cryptography/__pycache__/utils.cpython-38.pyc,,
+cryptography/exceptions.py,sha256=W25jw80RaAL0NOppZt48x1LSmgqaZqAObTtUExWCh3k,1194
+cryptography/fernet.py,sha256=Kn_d3z5YFnFP2t9pbX9wpsm7nvlrY7oKO3XLthdstmg,6538
+cryptography/hazmat/__init__.py,sha256=OYlvgprzULzZlsf3yYTsd6VUVyQmpsbHjgJdNnsyRwE,418
+cryptography/hazmat/__pycache__/__init__.cpython-38.pyc,,
+cryptography/hazmat/__pycache__/_der.cpython-38.pyc,,
+cryptography/hazmat/__pycache__/_oid.cpython-38.pyc,,
+cryptography/hazmat/__pycache__/_types.cpython-38.pyc,,
+cryptography/hazmat/_der.py,sha256=1Kf4nwKRUt56KpG3a9Idgn0YFeUcnYecoN60p5oZRcA,5221
+cryptography/hazmat/_oid.py,sha256=GVsyziASzIVcnAP_C7dx4czeI_VIccYu9GNV03rWjI0,2372
+cryptography/hazmat/_types.py,sha256=TWd5Q_pS_iDOoUdP3MrYbNbPwwM2hSdONh7230eByto,646
+cryptography/hazmat/backends/__init__.py,sha256=StVq0WWDbGTx0nsqMxVclREpGYp4j467m-k87xuDQRY,576
+cryptography/hazmat/backends/__pycache__/__init__.cpython-38.pyc,,
+cryptography/hazmat/backends/__pycache__/interfaces.cpython-38.pyc,,
+cryptography/hazmat/backends/interfaces.py,sha256=7_PB6ZpxcRhPSXrZcseOy1u9nQcdb6jXpgf_FDliPQU,10472
+cryptography/hazmat/backends/openssl/__init__.py,sha256=7rpz1Z3eV9vZy_d2iLrwC8Oz0vEruDFrjJlc6W2ZDXA,271
+cryptography/hazmat/backends/openssl/__pycache__/__init__.cpython-38.pyc,,
+cryptography/hazmat/backends/openssl/__pycache__/aead.cpython-38.pyc,,
+cryptography/hazmat/backends/openssl/__pycache__/backend.cpython-38.pyc,,
+cryptography/hazmat/backends/openssl/__pycache__/ciphers.cpython-38.pyc,,
+cryptography/hazmat/backends/openssl/__pycache__/cmac.cpython-38.pyc,,
+cryptography/hazmat/backends/openssl/__pycache__/decode_asn1.cpython-38.pyc,,
+cryptography/hazmat/backends/openssl/__pycache__/dh.cpython-38.pyc,,
+cryptography/hazmat/backends/openssl/__pycache__/dsa.cpython-38.pyc,,
+cryptography/hazmat/backends/openssl/__pycache__/ec.cpython-38.pyc,,
+cryptography/hazmat/backends/openssl/__pycache__/ed25519.cpython-38.pyc,,
+cryptography/hazmat/backends/openssl/__pycache__/ed448.cpython-38.pyc,,
+cryptography/hazmat/backends/openssl/__pycache__/encode_asn1.cpython-38.pyc,,
+cryptography/hazmat/backends/openssl/__pycache__/hashes.cpython-38.pyc,,
+cryptography/hazmat/backends/openssl/__pycache__/hmac.cpython-38.pyc,,
+cryptography/hazmat/backends/openssl/__pycache__/ocsp.cpython-38.pyc,,
+cryptography/hazmat/backends/openssl/__pycache__/poly1305.cpython-38.pyc,,
+cryptography/hazmat/backends/openssl/__pycache__/rsa.cpython-38.pyc,,
+cryptography/hazmat/backends/openssl/__pycache__/utils.cpython-38.pyc,,
+cryptography/hazmat/backends/openssl/__pycache__/x25519.cpython-38.pyc,,
+cryptography/hazmat/backends/openssl/__pycache__/x448.cpython-38.pyc,,
+cryptography/hazmat/backends/openssl/__pycache__/x509.cpython-38.pyc,,
+cryptography/hazmat/backends/openssl/aead.py,sha256=zt8ZQ-JethHblWEfwAnB5-09JIL9K8qU1NXwPTjeVYA,5700
+cryptography/hazmat/backends/openssl/backend.py,sha256=HC-d83ZUru3Z11Q7UnjFuko8Jp-ZEHCjzkpocJEfctM,105287
+cryptography/hazmat/backends/openssl/ciphers.py,sha256=fUn5DLrbhI_upLKMvU0aX2_An1dOX8T14PgdZXZr6hU,8611
+cryptography/hazmat/backends/openssl/cmac.py,sha256=KXcwF1XlY0Ew6sTBqPj0I1vr62dfMwCjeV3qBosIw8s,2846
+cryptography/hazmat/backends/openssl/decode_asn1.py,sha256=9s52X0DBtY4zSM0-nPze7A7nho3aM5nCbRa5T4bCvEU,32254
+cryptography/hazmat/backends/openssl/dh.py,sha256=cVPA_PKT4BlT4OvHiJm5ZIDmxNeXBnWy2My4uz8wYpo,10565
+cryptography/hazmat/backends/openssl/dsa.py,sha256=eyWzcpZggJuHLD4U3F9-neLyUqIoEN0MAiSwPIcEw2I,10684
+cryptography/hazmat/backends/openssl/ec.py,sha256=AOKJntDH0-vRCH_BquHiC8RpkM4ENFv509IX7Myuong,13371
+cryptography/hazmat/backends/openssl/ed25519.py,sha256=bSlMfJedRoyzZXoJeaehj_0H_j6Ye5doQHgnib602-Q,5789
+cryptography/hazmat/backends/openssl/ed448.py,sha256=dpJf1zt_o8vfVcXYi_PD8d9H-jBbYEp-d6ZIYDKlC1s,5743
+cryptography/hazmat/backends/openssl/encode_asn1.py,sha256=aiTahXPWVoG-e_0a8aSlE-OIosoT605P_SKZOpB-mJM,23988
+cryptography/hazmat/backends/openssl/hashes.py,sha256=_XZc3glydVD88e0qoHqvOuQ_0xfl2sq0ywfZF4dH91s,3090
+cryptography/hazmat/backends/openssl/hmac.py,sha256=ATz-rzSjGiRjL9_I5WJRO3R7QCiujd0izNqYrqPAHsA,2933
+cryptography/hazmat/backends/openssl/ocsp.py,sha256=pV4Js2tyOcZPdeeNjFl835COi200yRTt-0PUx9MRGlY,14617
+cryptography/hazmat/backends/openssl/poly1305.py,sha256=0hJDAb4pl9dJ_2xgt-XkNfyFA6U_IFXCe5jzOg7gkG0,2327
+cryptography/hazmat/backends/openssl/rsa.py,sha256=3GaXjh3j2LwK4idwSHfaqxVMhhDPKftw8CerJDyRLmQ,20919
+cryptography/hazmat/backends/openssl/utils.py,sha256=k3i_ARXsPvGTEtUUbnWkg9CkiJgPP4Y0VTTLtOEzEmU,2283
+cryptography/hazmat/backends/openssl/x25519.py,sha256=kCnWzuchrJn1Nne4zeotKvlkMty9p3VuM8y1EWo70vQ,4622
+cryptography/hazmat/backends/openssl/x448.py,sha256=8OKYMNXDR7UlViU3sNIH5qmLMGP7J-F3OeEaRK0aots,4141
+cryptography/hazmat/backends/openssl/x509.py,sha256=mbiJfQrTu_G3jttY_FXRZvqZ8wkjiHcMiPsPlwVHyOg,22831
+cryptography/hazmat/bindings/__init__.py,sha256=s9oKCQ2ycFdXoERdS1imafueSkBsL9kvbyfghaauZ9Y,180
+cryptography/hazmat/bindings/__pycache__/__init__.cpython-38.pyc,,
+cryptography/hazmat/bindings/_openssl.abi3.so,sha256=PnatPMQXvFl3qIjIdZuEUvpwbX7xKE8920rex6Y2u6g,915208
+cryptography/hazmat/bindings/_padding.abi3.so,sha256=onQk-dheo-36oyeufSX-XN2G_z0sbtrz-_qT5dd2iLk,16568
+cryptography/hazmat/bindings/_rust.abi3.so,sha256=PdNgtLAf8-ZO9SLwuCwvQqoRh-6l4iiJOqQybltT5KU,1741984
+cryptography/hazmat/bindings/openssl/__init__.py,sha256=s9oKCQ2ycFdXoERdS1imafueSkBsL9kvbyfghaauZ9Y,180
+cryptography/hazmat/bindings/openssl/__pycache__/__init__.cpython-38.pyc,,
+cryptography/hazmat/bindings/openssl/__pycache__/_conditional.cpython-38.pyc,,
+cryptography/hazmat/bindings/openssl/__pycache__/binding.cpython-38.pyc,,
+cryptography/hazmat/bindings/openssl/_conditional.py,sha256=2yZw_Ekya_GKKWUMzUbj3yYrLFZQNproXx1N4HL7TbU,8251
+cryptography/hazmat/bindings/openssl/binding.py,sha256=mIwnL3fICywOLt-iXZIvw2ijSaOIvdYs1Lwk2FUcxYs,5812
+cryptography/hazmat/primitives/__init__.py,sha256=s9oKCQ2ycFdXoERdS1imafueSkBsL9kvbyfghaauZ9Y,180
+cryptography/hazmat/primitives/__pycache__/__init__.cpython-38.pyc,,
+cryptography/hazmat/primitives/__pycache__/_asymmetric.cpython-38.pyc,,
+cryptography/hazmat/primitives/__pycache__/_cipheralgorithm.cpython-38.pyc,,
+cryptography/hazmat/primitives/__pycache__/_serialization.cpython-38.pyc,,
+cryptography/hazmat/primitives/__pycache__/cmac.cpython-38.pyc,,
+cryptography/hazmat/primitives/__pycache__/constant_time.cpython-38.pyc,,
+cryptography/hazmat/primitives/__pycache__/hashes.cpython-38.pyc,,
+cryptography/hazmat/primitives/__pycache__/hmac.cpython-38.pyc,,
+cryptography/hazmat/primitives/__pycache__/keywrap.cpython-38.pyc,,
+cryptography/hazmat/primitives/__pycache__/padding.cpython-38.pyc,,
+cryptography/hazmat/primitives/__pycache__/poly1305.cpython-38.pyc,,
+cryptography/hazmat/primitives/_asymmetric.py,sha256=nVJwmxkakirAXfFp410pC4kY_CinzN5FSJwhEn2IE34,485
+cryptography/hazmat/primitives/_cipheralgorithm.py,sha256=sV8-SjhhY4WtHsaLI7e2x4o2cYAAqP8YWBjhC6k1u10,1000
+cryptography/hazmat/primitives/_serialization.py,sha256=nl1g48RG17TWhegK8WKlBlXquMae_lmUSzgZnEqdwbU,1307
+cryptography/hazmat/primitives/asymmetric/__init__.py,sha256=DwsPrun2J00dimo7mq73llEb-O-N4qaOwEx5SwQbleI,909
+cryptography/hazmat/primitives/asymmetric/__pycache__/__init__.cpython-38.pyc,,
+cryptography/hazmat/primitives/asymmetric/__pycache__/dh.cpython-38.pyc,,
+cryptography/hazmat/primitives/asymmetric/__pycache__/dsa.cpython-38.pyc,,
+cryptography/hazmat/primitives/asymmetric/__pycache__/ec.cpython-38.pyc,,
+cryptography/hazmat/primitives/asymmetric/__pycache__/ed25519.cpython-38.pyc,,
+cryptography/hazmat/primitives/asymmetric/__pycache__/ed448.cpython-38.pyc,,
+cryptography/hazmat/primitives/asymmetric/__pycache__/padding.cpython-38.pyc,,
+cryptography/hazmat/primitives/asymmetric/__pycache__/rsa.cpython-38.pyc,,
+cryptography/hazmat/primitives/asymmetric/__pycache__/utils.cpython-38.pyc,,
+cryptography/hazmat/primitives/asymmetric/__pycache__/x25519.cpython-38.pyc,,
+cryptography/hazmat/primitives/asymmetric/__pycache__/x448.cpython-38.pyc,,
+cryptography/hazmat/primitives/asymmetric/dh.py,sha256=dyNhMSOqPNPVuVtvpUNVwPiPHkeqFrKy6lYSPTn4VqI,6303
+cryptography/hazmat/primitives/asymmetric/dsa.py,sha256=TdeZwnJq8ODqcoreu4jr1LFoFYtxA_z_6mhF8dYc5Yg,8116
+cryptography/hazmat/primitives/asymmetric/ec.py,sha256=1e0IpF8SbzrKPbPD4BYTazOaVrVCXMd406x5hzlB3_0,14613
+cryptography/hazmat/primitives/asymmetric/ed25519.py,sha256=Q42f1Cpnlt9UTSfh29T8xcdEgiNaiWr2Wic3sL_eJnk,2719
+cryptography/hazmat/primitives/asymmetric/ed448.py,sha256=SmBsd5pf3RaJoVxETIAcXC_DB6YGsrJUOrWE1BPx3T0,2630
+cryptography/hazmat/primitives/asymmetric/padding.py,sha256=ETdsTtHWSER0ZmTWoCVnWPkG9wvBIxGtal-e6xxl0i4,2115
+cryptography/hazmat/primitives/asymmetric/rsa.py,sha256=Ekxr0B_O2IUre0kw_oIiLJNtx46ADqC6caypjI6d_0w,12004
+cryptography/hazmat/primitives/asymmetric/utils.py,sha256=prIqN-UBc7RfOzFMgM8ON2s3DX8MrXeUlUH1LnmG8gg,1225
+cryptography/hazmat/primitives/asymmetric/x25519.py,sha256=-nbaGlgT1sufO9Ic-urwKDql8Da0U3GL6hZJIMqHgVc,2588
+cryptography/hazmat/primitives/asymmetric/x448.py,sha256=38mR8pqTBFWz5Emv9cQGlqtv_Qg37Bmrla0kRc2HmrU,2549
+cryptography/hazmat/primitives/ciphers/__init__.py,sha256=njx_RoatYaxZD0rYhYGi84WQnTZkMSpK67UfWIqkQpE,582
+cryptography/hazmat/primitives/ciphers/__pycache__/__init__.cpython-38.pyc,,
+cryptography/hazmat/primitives/ciphers/__pycache__/aead.cpython-38.pyc,,
+cryptography/hazmat/primitives/ciphers/__pycache__/algorithms.cpython-38.pyc,,
+cryptography/hazmat/primitives/ciphers/__pycache__/base.cpython-38.pyc,,
+cryptography/hazmat/primitives/ciphers/__pycache__/modes.cpython-38.pyc,,
+cryptography/hazmat/primitives/ciphers/aead.py,sha256=eKzVH2mf-5aFSaBOG9JnJAAd7XBnf9w4BH2Uu2ZT01w,6833
+cryptography/hazmat/primitives/ciphers/algorithms.py,sha256=EEJCTrUCe8iHN2O1f_bwR2UqhOemhi53-34WsQ6DddI,3829
+cryptography/hazmat/primitives/ciphers/base.py,sha256=w8_AWJwX1PrWpvjeB-_RF3iobalR3Hu3HIMDOMr92c8,7164
+cryptography/hazmat/primitives/ciphers/modes.py,sha256=mOnOgXyoD0N9NsSOkZvA8qMA3V5O7HubVwYiWVJvRFs,6549
+cryptography/hazmat/primitives/cmac.py,sha256=Kkzk8VQHe-_cYeVab24S4ODMWJOZkC4bLWLvCoMWyvQ,2158
+cryptography/hazmat/primitives/constant_time.py,sha256=6bkW00QjhKusdgsQbexXhMlGX0XRN59XNmxWS2W38NA,387
+cryptography/hazmat/primitives/hashes.py,sha256=cLNJcKKsI8E6ZhENKkppsJ_8S6W97y0tHzXa-ABBhtY,6051
+cryptography/hazmat/primitives/hmac.py,sha256=rhrLt6LwlzbIvnqpmOQVT6L_4Xd9xBsUBunPCkHcvWs,2332
+cryptography/hazmat/primitives/kdf/__init__.py,sha256=DcZhzfLG8d8IYBH771lGTVU5S87OQDpu3nrfOwZnsmA,715
+cryptography/hazmat/primitives/kdf/__pycache__/__init__.cpython-38.pyc,,
+cryptography/hazmat/primitives/kdf/__pycache__/concatkdf.cpython-38.pyc,,
+cryptography/hazmat/primitives/kdf/__pycache__/hkdf.cpython-38.pyc,,
+cryptography/hazmat/primitives/kdf/__pycache__/kbkdf.cpython-38.pyc,,
+cryptography/hazmat/primitives/kdf/__pycache__/pbkdf2.cpython-38.pyc,,
+cryptography/hazmat/primitives/kdf/__pycache__/scrypt.cpython-38.pyc,,
+cryptography/hazmat/primitives/kdf/__pycache__/x963kdf.cpython-38.pyc,,
+cryptography/hazmat/primitives/kdf/concatkdf.py,sha256=F9wepne-IRmhTZ9J4H_XLDI0Rl8LccY6wvhVA0jQ4Tc,4576
+cryptography/hazmat/primitives/kdf/hkdf.py,sha256=doR70wjOcA56hxhhQtV2M-ekajjjr5hoT5F8KMxoZdo,3807
+cryptography/hazmat/primitives/kdf/kbkdf.py,sha256=teuWbRvCZShWiRnv0eg-sXrxm-g7Ss02Ulb3vVbzPvc,5195
+cryptography/hazmat/primitives/kdf/pbkdf2.py,sha256=4HaLcppspYe8od6vur0E408qYgQPjJKtI9kDrWesIdo,2261
+cryptography/hazmat/primitives/kdf/scrypt.py,sha256=vCMYGRp-Q--9DxiDQHbkVVRXkhrQTR0qkC0LriV6Hy8,2248
+cryptography/hazmat/primitives/kdf/x963kdf.py,sha256=N5-2KOA2Z-7kAxjhhU5quNcRpmThyQC5dhU-Cw95jWk,2458
+cryptography/hazmat/primitives/keywrap.py,sha256=ibpVZ19OGcoEVrSE7cizdoMDdRDaqcATeVRK5_4MCO4,5927
+cryptography/hazmat/primitives/padding.py,sha256=PYlgTNHZUYROnQZ1oeeqKm1WyzkqLlwIpRUgdASHOG8,6193
+cryptography/hazmat/primitives/poly1305.py,sha256=_Dtv6oCMn94rAhQ6pjie9mO_MiDLVL5It3Z5sdpCU3c,1711
+cryptography/hazmat/primitives/serialization/__init__.py,sha256=RALEthF7wRjlMyTvSq09XmKQey74tsSdDCCsDaD6yQU,1129
+cryptography/hazmat/primitives/serialization/__pycache__/__init__.cpython-38.pyc,,
+cryptography/hazmat/primitives/serialization/__pycache__/base.cpython-38.pyc,,
+cryptography/hazmat/primitives/serialization/__pycache__/pkcs12.cpython-38.pyc,,
+cryptography/hazmat/primitives/serialization/__pycache__/pkcs7.cpython-38.pyc,,
+cryptography/hazmat/primitives/serialization/__pycache__/ssh.cpython-38.pyc,,
+cryptography/hazmat/primitives/serialization/base.py,sha256=OYqk2UnIR5IAKP1QRNifhoQw-HX3etcWudn3W2JVIyg,1440
+cryptography/hazmat/primitives/serialization/pkcs12.py,sha256=JuWr5Vqz6zEpjh3j7ME1SCk3TFDNhONjQds_Se7XpFg,2270
+cryptography/hazmat/primitives/serialization/pkcs7.py,sha256=CsmnGEbtLKm2o6D7h_a-EvHQOfwlHxrV96VkjnrNX7s,5223
+cryptography/hazmat/primitives/serialization/ssh.py,sha256=doX0irj_Q1wd1N_JU-Xic_5zUkMH_zZKcQUUOB-axGk,22293
+cryptography/hazmat/primitives/twofactor/__init__.py,sha256=ZHo4zwWidFP2RWFl8luiNuYkVMZPghzx54izPNSCtD4,222
+cryptography/hazmat/primitives/twofactor/__pycache__/__init__.cpython-38.pyc,,
+cryptography/hazmat/primitives/twofactor/__pycache__/hotp.cpython-38.pyc,,
+cryptography/hazmat/primitives/twofactor/__pycache__/totp.cpython-38.pyc,,
+cryptography/hazmat/primitives/twofactor/__pycache__/utils.cpython-38.pyc,,
+cryptography/hazmat/primitives/twofactor/hotp.py,sha256=JXph-N0S8CDM-laRoV_G-Welhn7PvcpgXTxRbp_yEjk,2826
+cryptography/hazmat/primitives/twofactor/totp.py,sha256=2GTFsdUdA585-N_sqfPhlBBWDY-ExaH1HKH1p3XPWmk,1912
+cryptography/hazmat/primitives/twofactor/utils.py,sha256=8TG5oyaz8CxHCXqqh26iAny9w_W1e9SgVdCZaeEzOwU,982
+cryptography/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cryptography/utils.py,sha256=dyYUz2jr1tTsYQ3SaX3_cBYu720kopdatNy_83L1Mkc,4861
+cryptography/x509/__init__.py,sha256=4_Xsv7yVMCGbpIbSgc4SPxDX-3Mn83gN07Us1PAM_eA,7634
+cryptography/x509/__pycache__/__init__.cpython-38.pyc,,
+cryptography/x509/__pycache__/base.cpython-38.pyc,,
+cryptography/x509/__pycache__/certificate_transparency.cpython-38.pyc,,
+cryptography/x509/__pycache__/extensions.cpython-38.pyc,,
+cryptography/x509/__pycache__/general_name.cpython-38.pyc,,
+cryptography/x509/__pycache__/name.cpython-38.pyc,,
+cryptography/x509/__pycache__/ocsp.cpython-38.pyc,,
+cryptography/x509/__pycache__/oid.cpython-38.pyc,,
+cryptography/x509/base.py,sha256=duSe4bIuBiJ5g2NC8-VSxDfqHZ0CEEcXZKhcBGq-eeA,28193
+cryptography/x509/certificate_transparency.py,sha256=rzJvxd1FVfc5gOjUT-T2VF5vcOC597UrrI_5JJwZprI,979
+cryptography/x509/extensions.py,sha256=M-n_8gEjO5_03ufGHoK_6w8YSSiNyWvHUJ5Kgq5zoN4,54019
+cryptography/x509/general_name.py,sha256=5dld2ktZnCEg3l14UyKk6DSlzFHXlc6WxW5J8R8Mk-Q,8161
+cryptography/x509/name.py,sha256=PpRua5nWFLZtOg77XdaybGVNspO8ZvQ7ddNDn203vys,8529
+cryptography/x509/ocsp.py,sha256=ERB5osTWbNieLj945Xoq0NjBkzqodo_WBL7ORaC2fDg,14738
+cryptography/x509/oid.py,sha256=1PxP9Pr_lh77zqyvTJefeRozK3VYaRlNmWfYfDWr2Ak,12619

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/cryptography-3.4.8.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.37.0)
+Root-Is-Purelib: false
+Tag: cp38-cp38-linux_x86_64
+

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/cryptography-3.4.8.dist-info/top_level.txt

@@ -0,0 +1,3 @@
+_openssl
+_padding
+cryptography

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

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

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

@@ -0,0 +1,4 @@
+# flake8: noqa
+from .store import Store
+from .errors import StoreError, CredentialsNotFound
+from .constants import *

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/dockerpycreds/constants.py

@@ -0,0 +1,4 @@
+PROGRAM_PREFIX = 'docker-credential-'
+DEFAULT_LINUX_STORE = 'secretservice'
+DEFAULT_OSX_STORE = 'osxkeychain'
+DEFAULT_WIN32_STORE = 'wincred'

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

@@ -0,0 +1,25 @@
+class StoreError(RuntimeError):
+    pass
+
+
+class CredentialsNotFound(StoreError):
+    pass
+
+
+class InitializationError(StoreError):
+    pass
+
+
+def process_store_error(cpe, program):
+    message = cpe.output.decode('utf-8')
+    if 'credentials not found in native keychain' in message:
+        return CredentialsNotFound(
+            'No matching credentials in {0}'.format(
+                program
+            )
+        )
+    return StoreError(
+        'Credentials store {0} exited with "{1}".'.format(
+            program, cpe.output.decode('utf-8').strip()
+        )
+    )

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/dockerpycreds/store.py

@@ -0,0 +1,107 @@
+import json
+import os
+import subprocess
+
+import six
+
+from . import constants
+from . import errors
+from .utils import create_environment_dict
+from .utils import find_executable
+
+
+class Store(object):
+    def __init__(self, program, environment=None):
+        """ Create a store object that acts as an interface to
+            perform the basic operations for storing, retrieving
+            and erasing credentials using `program`.
+        """
+        self.program = constants.PROGRAM_PREFIX + program
+        self.exe = find_executable(self.program)
+        self.environment = environment
+        if self.exe is None:
+            raise errors.InitializationError(
+                '{0} not installed or not available in PATH'.format(
+                    self.program
+                )
+            )
+
+    def get(self, server):
+        """ Retrieve credentials for `server`. If no credentials are found,
+            a `StoreError` will be raised.
+        """
+        if not isinstance(server, six.binary_type):
+            server = server.encode('utf-8')
+        data = self._execute('get', server)
+        result = json.loads(data.decode('utf-8'))
+
+        # docker-credential-pass will return an object for inexistent servers
+        # whereas other helpers will exit with returncode != 0. For
+        # consistency, if no significant data is returned,
+        # raise CredentialsNotFound
+        if result['Username'] == '' and result['Secret'] == '':
+            raise errors.CredentialsNotFound(
+                'No matching credentials in {}'.format(self.program)
+            )
+
+        return result
+
+    def store(self, server, username, secret):
+        """ Store credentials for `server`. Raises a `StoreError` if an error
+            occurs.
+        """
+        data_input = json.dumps({
+            'ServerURL': server,
+            'Username': username,
+            'Secret': secret
+        }).encode('utf-8')
+        return self._execute('store', data_input)
+
+    def erase(self, server):
+        """ Erase credentials for `server`. Raises a `StoreError` if an error
+            occurs.
+        """
+        if not isinstance(server, six.binary_type):
+            server = server.encode('utf-8')
+        self._execute('erase', server)
+
+    def list(self):
+        """ List stored credentials. Requires v0.4.0+ of the helper.
+        """
+        data = self._execute('list', None)
+        return json.loads(data.decode('utf-8'))
+
+    def _execute(self, subcmd, data_input):
+        output = None
+        env = create_environment_dict(self.environment)
+        try:
+            if six.PY3:
+                output = subprocess.check_output(
+                    [self.exe, subcmd], input=data_input, env=env,
+                )
+            else:
+                process = subprocess.Popen(
+                    [self.exe, subcmd], stdin=subprocess.PIPE,
+                    stdout=subprocess.PIPE, env=env,
+                )
+                output, err = process.communicate(data_input)
+                if process.returncode != 0:
+                    raise subprocess.CalledProcessError(
+                        returncode=process.returncode, cmd='', output=output
+                    )
+        except subprocess.CalledProcessError as e:
+            raise errors.process_store_error(e, self.program)
+        except OSError as e:
+            if e.errno == os.errno.ENOENT:
+                raise errors.StoreError(
+                    '{0} not installed or not available in PATH'.format(
+                        self.program
+                    )
+                )
+            else:
+                raise errors.StoreError(
+                    'Unexpected OS error "{0}", errno={1}'.format(
+                        e.strerror, e.errno
+                    )
+                )
+        return output

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

@@ -0,0 +1,38 @@
+import distutils.spawn
+import os
+import sys
+
+
+def find_executable(executable, path=None):
+    """
+    As distutils.spawn.find_executable, but on Windows, look up
+    every extension declared in PATHEXT instead of just `.exe`
+    """
+    if sys.platform != 'win32':
+        return distutils.spawn.find_executable(executable, path)
+
+    if path is None:
+        path = os.environ['PATH']
+
+    paths = path.split(os.pathsep)
+    extensions = os.environ.get('PATHEXT', '.exe').split(os.pathsep)
+    base, ext = os.path.splitext(executable)
+
+    if not os.path.isfile(executable):
+        for p in paths:
+            for ext in extensions:
+                f = os.path.join(p, base + ext)
+                if os.path.isfile(f):
+                    return f
+        return None
+    else:
+        return executable
+
+
+def create_environment_dict(overrides):
+    """
+    Create and return a copy of os.environ with the specified overrides
+    """
+    result = os.environ.copy()
+    result.update(overrides or {})
+    return result

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

@@ -0,0 +1,2 @@
+version = "0.4.0"
+version_info = tuple([int(d) for d in version.split("-")[0].split(".")])

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

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Alex Rogozhnikov
+
+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/einops-0.4.1.dist-info/METADATA

@@ -0,0 +1,309 @@
+Metadata-Version: 2.1
+Name: einops
+Version: 0.4.1
+Summary: A new flavour of deep learning operations
+Home-page: https://github.com/arogozhnikov/einops
+Author: Alex Rogozhnikov
+License: UNKNOWN
+Keywords: deep learning,neural networks,tensor manipulation,machine learning,scientific computations,einops
+Platform: UNKNOWN
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3 
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+<!-- this link magically rendered as video, unfortunately not in docs -->
+
+<!-- https://user-images.githubusercontent.com/6318811/116849688-0ca41c00-aba4-11eb-8ccf-74744f6cbc23.mp4 -->
+
+<a href='http://arogozhnikov.github.io/images/einops/einops_video.mp4' >
+<div align="center">
+  <img src="http://arogozhnikov.github.io/images/einops/einops_video.gif" alt="einops package examples" />
+  <br>
+  <small><a href='http://arogozhnikov.github.io/images/einops/einops_video.mp4'>This video in high quality (mp4)</a></small>
+  <br><br>
+</div>
+</a>
+
+# einops 
+[![Run tests](https://github.com/arogozhnikov/einops/actions/workflows/run_tests.yml/badge.svg)](https://github.com/arogozhnikov/einops/actions/workflows/run_tests.yml)
+[![PyPI version](https://badge.fury.io/py/einops.svg)](https://badge.fury.io/py/einops)
+[![Documentation](https://img.shields.io/badge/documentation-link-blue.svg)](https://einops.rocks/)
+![Supported python versions](https://raw.githubusercontent.com/arogozhnikov/einops/master/docs/resources/python_badge.svg)
+
+
+Flexible and powerful tensor operations for readable and reliable code. 
+Supports numpy, pytorch, tensorflow, jax, and [others](#supported-frameworks).
+
+## Recent updates:
+
+- torch.jit.script is supported for pytorch layers
+- powerful EinMix added to einops. [Einmix tutorial notebook](https://github.com/arogozhnikov/einops/blob/master/docs/3-einmix-layer.ipynb) 
+
+<!--<div align="center">
+  <img src="http://arogozhnikov.github.io/images/einops/einops_logo_350x350.png" 
+  alt="einops package logo" width="250" height="250" />
+  <br><br>
+</div> -->
+
+## Tweets 
+
+> In case you need convincing arguments for setting aside time to learn about einsum and einops...
+[Tim Rocktäschel, FAIR](https://twitter.com/_rockt/status/1230818967205425152)
+
+> Writing better code with PyTorch and einops 👌
+[Andrej Karpathy, AI at Tesla](https://twitter.com/karpathy/status/1290826075916779520)
+
+> Slowly but surely, einops is seeping in to every nook and cranny of my code. If you find yourself shuffling around bazillion dimensional tensors, this might change your life
+[Nasim Rahaman, MILA (Montreal)](https://twitter.com/nasim_rahaman/status/1216022614755463169)
+
+[More testimonials](https://einops.rocks/pages/testimonials/)
+
+## Contents
+
+- [Installation](#Installation)
+- [Documentation](https://einops.rocks/)
+- [Tutorial](#Tutorials) 
+- [API micro-reference](#API)
+- [Why using einops](#Why-using-einops-notation)
+- [Supported frameworks](#Supported-frameworks)
+- [Contributing](#Contributing)
+- [Repository](https://github.com/arogozhnikov/einops) and [discussions](https://github.com/arogozhnikov/einops/discussions)
+
+## Installation  <a name="Installation"></a>
+
+Plain and simple:
+```bash
+pip install einops
+```
+
+<!--
+`einops` has no mandatory dependencies (code examples also require jupyter, pillow + backends). 
+To obtain the latest github version 
+
+```bash
+pip install https://github.com/arogozhnikov/einops/archive/master.zip
+```
+-->
+
+## Tutorials <a name="Tutorials"></a>
+
+Tutorials are the most convenient way to see `einops` in action
+
+- part 1: [einops fundamentals](https://github.com/arogozhnikov/einops/blob/master/docs/1-einops-basics.ipynb) 
+- part 2: [einops for deep learning](https://github.com/arogozhnikov/einops/blob/master/docs/2-einops-for-deep-learning.ipynb)
+- part 3: [improve pytorch code with einops](https://arogozhnikov.github.io/einops/pytorch-examples.html)   
+
+
+## API <a name="API"></a>
+
+`einops` has a minimalistic yet powerful API.
+
+Three operations provided ([einops tutorial](https://github.com/arogozhnikov/einops/blob/master/docs/) 
+shows those cover stacking, reshape, transposition, squeeze/unsqueeze, repeat, tile, concatenate, view and numerous reductions)
+
+```python
+from einops import rearrange, reduce, repeat
+# rearrange elements according to the pattern
+output_tensor = rearrange(input_tensor, 't b c -> b c t')
+# combine rearrangement and reduction
+output_tensor = reduce(input_tensor, 'b c (h h2) (w w2) -> b h w c', 'mean', h2=2, w2=2)
+# copy along a new axis 
+output_tensor = repeat(input_tensor, 'h w -> h w c', c=3)
+```
+And two corresponding layers (`einops` keeps a separate version for each framework) with the same API.
+
+```python
+from einops.layers.chainer import Rearrange, Reduce
+from einops.layers.gluon import Rearrange, Reduce
+from einops.layers.keras import Rearrange, Reduce
+from einops.layers.torch import Rearrange, Reduce
+from einops.layers.tensorflow import Rearrange, Reduce
+```
+
+Layers behave similarly to operations and have the same parameters 
+(with the exception of the first argument, which is passed during call)
+
+```python
+layer = Rearrange(pattern, **axes_lengths)
+layer = Reduce(pattern, reduction, **axes_lengths)
+
+# apply created layer to a tensor / variable
+x = layer(x)
+```
+
+Example of using layers within a model:
+```python
+# example given for pytorch, but code in other frameworks is almost identical  
+from torch.nn import Sequential, Conv2d, MaxPool2d, Linear, ReLU
+from einops.layers.torch import Rearrange
+
+model = Sequential(
+    Conv2d(3, 6, kernel_size=5),
+    MaxPool2d(kernel_size=2),
+    Conv2d(6, 16, kernel_size=5),
+    MaxPool2d(kernel_size=2),
+    # flattening
+    Rearrange('b c h w -> b (c h w)'),  
+    Linear(16*5*5, 120), 
+    ReLU(),
+    Linear(120, 10), 
+)
+```
+
+<!---
+Additionally two auxiliary functions provided
+```python
+from einops import asnumpy, parse_shape
+# einops.asnumpy converts tensors of imperative frameworks to numpy
+numpy_tensor = asnumpy(input_tensor)
+# einops.parse_shape gives a shape of axes of interest 
+parse_shape(input_tensor, 'batch _ h w') # e.g {'batch': 64, 'h': 128, 'w': 160}
+```
+-->
+
+## Naming <a name="Naming"></a>
+
+`einops` stands for Einstein-Inspired Notation for operations 
+(though "Einstein operations" is more attractive and easier to remember).
+
+Notation was loosely inspired by Einstein summation (in particular by `numpy.einsum` operation).
+
+## Why use `einops` notation?! <a name="Why-using-einops-notation"></a>
+
+
+### Semantic information (being verbose in expectations)
+
+```python
+y = x.view(x.shape[0], -1)
+y = rearrange(x, 'b c h w -> b (c h w)')
+```
+While these two lines are doing the same job in *some* context,
+the second one provides information about the input and output.
+In other words, `einops` focuses on interface: *what is the input and output*, not *how* the output is computed.
+
+The next operation looks similar:
+
+```python
+y = rearrange(x, 'time c h w -> time (c h w)')
+```
+but it gives the reader a hint: 
+this is not an independent batch of images we are processing, 
+but rather a sequence (video). 
+
+Semantic information makes the code easier to read and maintain. 
+
+### Convenient checks
+
+Reconsider the same example:
+
+```python
+y = x.view(x.shape[0], -1) # x: (batch, 256, 19, 19)
+y = rearrange(x, 'b c h w -> b (c h w)')
+```
+The second line checks that the input has four dimensions, 
+but you can also specify particular dimensions. 
+That's opposed to just writing comments about shapes since 
+[comments don't work and don't prevent mistakes](https://medium.freecodecamp.org/code-comments-the-good-the-bad-and-the-ugly-be9cc65fbf83)
+as we know   
+```python
+y = x.view(x.shape[0], -1) # x: (batch, 256, 19, 19)
+y = rearrange(x, 'b c h w -> b (c h w)', c=256, h=19, w=19)
+```
+
+### Result is strictly determined
+
+Below we have at least two ways to define the depth-to-space operation
+```python
+# depth-to-space
+rearrange(x, 'b c (h h2) (w w2) -> b (c h2 w2) h w', h2=2, w2=2)
+rearrange(x, 'b c (h h2) (w w2) -> b (h2 w2 c) h w', h2=2, w2=2)
+```
+There are at least four more ways to do it. Which one is used by the framework?
+
+These details are ignored, since *usually* it makes no difference, 
+but it can make a big difference (e.g. if you use grouped convolutions in the next stage), 
+and you'd like to specify this in your code.
+
+
+### Uniformity
+
+```python
+reduce(x, 'b c (x dx) -> b c x', 'max', dx=2)
+reduce(x, 'b c (x dx) (y dy) -> b c x y', 'max', dx=2, dy=3)
+reduce(x, 'b c (x dx) (y dy) (z dz) -> b c x y z', 'max', dx=2, dy=3, dz=4)
+```
+These examples demonstrated that we don't use separate operations for 1d/2d/3d pooling, 
+those are all defined in a uniform way. 
+
+Space-to-depth and depth-to space are defined in many frameworks but how about width-to-height? Here you go:
+
+```python
+rearrange(x, 'b c h (w w2) -> b c (h w2) w', w2=2)
+```
+
+### Framework independent behavior
+
+Even simple functions are defined differently by different frameworks
+
+```python
+y = x.flatten() # or flatten(x)
+```
+
+Suppose `x`'s shape was `(3, 4, 5)`, then `y` has shape ...
+
+- numpy, cupy, chainer, pytorch: `(60,)`
+- keras, tensorflow.layers, mxnet and gluon: `(3, 20)`
+
+`einops` works the same way in all frameworks.
+
+### Independence of framework terminology
+
+Example: `tile` vs `repeat` causes lots of confusion. To copy image along width:
+```python
+np.tile(image, (1, 2))    # in numpy
+image.repeat(1, 2)        # pytorch's repeat ~ numpy's tile
+```
+
+With einops you don't need to decipher which axis was repeated:
+```python
+repeat(image, 'h w -> h (tile w)', tile=2)  # in numpy
+repeat(image, 'h w -> h (tile w)', tile=2)  # in pytorch
+repeat(image, 'h w -> h (tile w)', tile=2)  # in tf
+repeat(image, 'h w -> h (tile w)', tile=2)  # in jax
+repeat(image, 'h w -> h (tile w)', tile=2)  # in mxnet
+... (etc.)
+```
+
+Testimonials provide user's perspective on the same question. 
+
+## Supported frameworks <a name="Supported-frameworks"></a>
+
+Einops works with ...
+
+- [numpy](http://www.numpy.org/)
+- [pytorch](https://pytorch.org/)
+- [tensorflow](https://www.tensorflow.org/)
+- [jax](https://github.com/google/jax)
+- [cupy](https://cupy.chainer.org/)
+- [chainer](https://chainer.org/)
+- [gluon](https://gluon.mxnet.io/)
+- [tf.keras](https://www.tensorflow.org/guide/keras)
+- [mxnet](https://mxnet.apache.org/) (experimental)
+
+
+## Contributing <a name="Contributing"></a>
+
+Best ways to contribute are
+
+- spread the word about `einops`
+- if you like explaining things, more tutorials/tear-downs of implementations is welcome
+- tutorials in other languages are very welcome
+- do you have project/code example to share? Let me know in github discussions
+- use `einops` in your papers!
+
+## Supported python versions
+
+`einops` works with python 3.6 or later. 
+
+

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

@@ -0,0 +1,31 @@
+einops-0.4.1.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+einops-0.4.1.dist-info/LICENSE,sha256=MNmENkKW9R_67K1LAe4SfpUlDFBokY1LZvyWIGcj5DQ,1073
+einops-0.4.1.dist-info/METADATA,sha256=UdOBa4tijnwPJI48dGASJt4-czHTJ4LLiY4dfdRXffI,10737
+einops-0.4.1.dist-info/RECORD,,
+einops-0.4.1.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+einops-0.4.1.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
+einops-0.4.1.dist-info/top_level.txt,sha256=zh9ckJ4QUP-fUBSO5-UKAcNKvC_lzMGMYS6_nnoT4Tc,7
+einops/__init__.py,sha256=8uWtV9MPDvreSsu6VG0E-j2TlxrckMGW2Zy5fCRFu6I,297
+einops/__pycache__/__init__.cpython-38.pyc,,
+einops/__pycache__/_backends.cpython-38.pyc,,
+einops/__pycache__/_torch_specific.cpython-38.pyc,,
+einops/__pycache__/einops.cpython-38.pyc,,
+einops/__pycache__/parsing.cpython-38.pyc,,
+einops/_backends.py,sha256=xyh2XysbubzGMqyRZPu8ld5-1bob693ESp6vkZR4gV8,17132
+einops/_torch_specific.py,sha256=-VuZFXozi6GPtKQFWvb7BhzswyOfjByXGG0GLvvhDXg,2804
+einops/einops.py,sha256=LkY-JdbOUqf_GtuiskedET4aaSs0yJKfVaLoBwS6UP8,27879
+einops/layers/__init__.py,sha256=JHwHQUP5sBIYhSwRrjhZYxGIdw8-UTEWUPbeEduBuBY,2824
+einops/layers/__pycache__/__init__.cpython-38.pyc,,
+einops/layers/__pycache__/_einmix.cpython-38.pyc,,
+einops/layers/__pycache__/chainer.cpython-38.pyc,,
+einops/layers/__pycache__/gluon.cpython-38.pyc,,
+einops/layers/__pycache__/keras.cpython-38.pyc,,
+einops/layers/__pycache__/tensorflow.cpython-38.pyc,,
+einops/layers/__pycache__/torch.cpython-38.pyc,,
+einops/layers/_einmix.py,sha256=k1Wt5z7KmJF9nj345ZhUXeRBcV1D2bNkz35yF82zB_E,8249
+einops/layers/chainer.py,sha256=VisqqyZiEpDl7NdCSjVSa4u7aXgZuNpA0hglkfGydiM,1927
+einops/layers/gluon.py,sha256=Ll85s1OWKqRAhSwFS33jQwbTicD1MnhrH4lbnlqvoPU,2101
+einops/layers/keras.py,sha256=RTsR-aim1Sco5VXI2W1Qs639hJRJ0hWIilTZCs3Ftn4,212
+einops/layers/tensorflow.py,sha256=xNsVaKIMoB2kZeSeFUKXq29LWz-Fppt2K2aRln5s0-Y,3269
+einops/layers/torch.py,sha256=IOdwPR2uL_ZFuzWthGz6p-8af1zg801UmjB8uTBA5HY,2379
+einops/parsing.py,sha256=75hvgp6iWvvLUe67IaQujmox1tjvF9ZsBMaXQYnQmqU,6637

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/einops-0.4.1.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/einops-0.4.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+einops

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

@@ -0,0 +1,51 @@
+"""
+A platform independent file lock that supports the with-statement.
+
+.. autodata:: filelock.__version__
+   :no-value:
+
+"""
+from __future__ import annotations
+
+import sys
+import warnings
+from typing import TYPE_CHECKING
+
+from ._api import AcquireReturnProxy, BaseFileLock
+from ._error import Timeout
+from ._soft import SoftFileLock
+from ._unix import UnixFileLock, has_fcntl
+from ._windows import WindowsFileLock
+from .version import version
+
+#: version of the project as a string
+__version__: str = version
+
+
+if sys.platform == "win32":  # pragma: win32 cover
+    _FileLock: type[BaseFileLock] = WindowsFileLock
+else:  # pragma: win32 no cover # noqa: PLR5501
+    if has_fcntl:
+        _FileLock: type[BaseFileLock] = UnixFileLock
+    else:
+        _FileLock = SoftFileLock
+        if warnings is not None:
+            warnings.warn("only soft file lock is available", stacklevel=2)
+
+if TYPE_CHECKING:
+    FileLock = SoftFileLock
+else:
+    #: Alias for the lock, which should be used for the current platform.
+    FileLock = _FileLock
+
+
+__all__ = [
+    "__version__",
+    "FileLock",
+    "SoftFileLock",
+    "Timeout",
+    "UnixFileLock",
+    "WindowsFileLock",
+    "BaseFileLock",
+    "AcquireReturnProxy",
+]

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

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from typing import Any
+
+
+class Timeout(TimeoutError):  # noqa: N818
+    """Raised when the lock could not be acquired in *timeout* seconds."""
+
+    def __init__(self, lock_file: str) -> None:
+        super().__init__()
+        self._lock_file = lock_file
+
+    def __reduce__(self) -> str | tuple[Any, ...]:
+        return self.__class__, (self._lock_file,)  # Properly pickle the exception
+
+    def __str__(self) -> str:
+        return f"The file lock '{self._lock_file}' could not be acquired."
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}({self.lock_file!r})"
+
+    @property
+    def lock_file(self) -> str:
+        """:return: The path of the file lock."""
+        return self._lock_file
+
+
+__all__ = [
+    "Timeout",
+]

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

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+import os
+import sys
+from contextlib import suppress
+from errno import EACCES, EEXIST
+from pathlib import Path
+
+from ._api import BaseFileLock
+from ._util import ensure_directory_exists, raise_on_not_writable_file
+
+
+class SoftFileLock(BaseFileLock):
+    """Simply watches the existence of the lock file."""
+
+    def _acquire(self) -> None:
+        raise_on_not_writable_file(self.lock_file)
+        ensure_directory_exists(self.lock_file)
+        # first check for exists and read-only mode as the open will mask this case as EEXIST
+        flags = (
+            os.O_WRONLY  # open for writing only
+            | os.O_CREAT
+            | os.O_EXCL  # together with above raise EEXIST if the file specified by filename exists
+            | os.O_TRUNC  # truncate the file to zero byte
+        )
+        try:
+            file_handler = os.open(self.lock_file, flags, self._context.mode)
+        except OSError as exception:  # re-raise unless expected exception
+            if not (
+                exception.errno == EEXIST  # lock already exist
+                or (exception.errno == EACCES and sys.platform == "win32")  # has no access to this lock
+            ):  # pragma: win32 no cover
+                raise
+        else:
+            self._context.lock_file_fd = file_handler
+
+    def _release(self) -> None:
+        assert self._context.lock_file_fd is not None  # noqa: S101
+        os.close(self._context.lock_file_fd)  # the lock file is definitely not None
+        self._context.lock_file_fd = None
+        with suppress(OSError):  # the file is already deleted and that's what we want
+            Path(self.lock_file).unlink()
+
+
+__all__ = [
+    "SoftFileLock",
+]

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

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+import os
+import sys
+from contextlib import suppress
+from errno import EACCES
+from pathlib import Path
+from typing import cast
+
+from ._api import BaseFileLock
+from ._util import ensure_directory_exists, raise_on_not_writable_file
+
+if sys.platform == "win32":  # pragma: win32 cover
+    import msvcrt
+
+    class WindowsFileLock(BaseFileLock):
+        """Uses the :func:`msvcrt.locking` function to hard lock the lock file on Windows systems."""
+
+        def _acquire(self) -> None:
+            raise_on_not_writable_file(self.lock_file)
+            ensure_directory_exists(self.lock_file)
+            flags = (
+                os.O_RDWR  # open for read and write
+                | os.O_CREAT  # create file if not exists
+                | os.O_TRUNC  # truncate file if not empty
+            )
+            try:
+                fd = os.open(self.lock_file, flags, self._context.mode)
+            except OSError as exception:
+                if exception.errno != EACCES:  # has no access to this lock
+                    raise
+            else:
+                try:
+                    msvcrt.locking(fd, msvcrt.LK_NBLCK, 1)
+                except OSError as exception:
+                    os.close(fd)  # close file first
+                    if exception.errno != EACCES:  # file is already locked
+                        raise
+                else:
+                    self._context.lock_file_fd = fd
+
+        def _release(self) -> None:
+            fd = cast(int, self._context.lock_file_fd)
+            self._context.lock_file_fd = None
+            msvcrt.locking(fd, msvcrt.LK_UNLCK, 1)
+            os.close(fd)
+
+            with suppress(OSError):  # Probably another instance of the application hat acquired the file lock.
+                Path(self.lock_file).unlink()
+
+else:  # pragma: win32 no cover
+
+    class WindowsFileLock(BaseFileLock):
+        """Uses the :func:`msvcrt.locking` function to hard lock the lock file on Windows systems."""
+
+        def _acquire(self) -> None:
+            raise NotImplementedError
+
+        def _release(self) -> None:
+            raise NotImplementedError
+
+
+__all__ = [
+    "WindowsFileLock",
+]

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

@@ -0,0 +1,16 @@
+# file generated by setuptools_scm
+# don't change, don't track in version control
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple, Union
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '3.13.1'
+__version_tuple__ = version_tuple = (3, 13, 1)

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

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

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/joblib/_dask.py

@@ -0,0 +1,364 @@
+from __future__ import print_function, division, absolute_import
+
+import asyncio
+import concurrent.futures
+import contextlib
+
+import time
+from uuid import uuid4
+import weakref
+
+from .parallel import AutoBatchingMixin, ParallelBackendBase, BatchedCalls
+from .parallel import parallel_backend
+
+try:
+    import distributed
+except ImportError:
+    distributed = None
+
+if distributed is not None:
+    from dask.utils import funcname, itemgetter
+    from dask.sizeof import sizeof
+    from dask.distributed import (
+        Client,
+        as_completed,
+        get_client,
+        secede,
+        rejoin
+    )
+    from distributed.utils import thread_state
+
+    try:
+        # asyncio.TimeoutError, Python3-only error thrown by recent versions of
+        # distributed
+        from distributed.utils import TimeoutError as _TimeoutError
+    except ImportError:
+        from tornado.gen import TimeoutError as _TimeoutError
+
+
+def is_weakrefable(obj):
+    try:
+        weakref.ref(obj)
+        return True
+    except TypeError:
+        return False
+
+
+class _WeakKeyDictionary:
+    """A variant of weakref.WeakKeyDictionary for unhashable objects.
+
+    This datastructure is used to store futures for broadcasted data objects
+    such as large numpy arrays or pandas dataframes that are not hashable and
+    therefore cannot be used as keys of traditional python dicts.
+
+    Furthermore using a dict with id(array) as key is not safe because the
+    Python is likely to reuse id of recently collected arrays.
+    """
+
+    def __init__(self):
+        self._data = {}
+
+    def __getitem__(self, obj):
+        ref, val = self._data[id(obj)]
+        if ref() is not obj:
+            # In case of a race condition with on_destroy.
+            raise KeyError(obj)
+        return val
+
+    def __setitem__(self, obj, value):
+        key = id(obj)
+        try:
+            ref, _ = self._data[key]
+            if ref() is not obj:
+                # In case of race condition with on_destroy.
+                raise KeyError(obj)
+        except KeyError:
+            # Insert the new entry in the mapping along with a weakref
+            # callback to automatically delete the entry from the mapping
+            # as soon as the object used as key is garbage collected.
+            def on_destroy(_):
+                del self._data[key]
+            ref = weakref.ref(obj, on_destroy)
+        self._data[key] = ref, value
+
+    def __len__(self):
+        return len(self._data)
+
+    def clear(self):
+        self._data.clear()
+
+
+def _funcname(x):
+    try:
+        if isinstance(x, list):
+            x = x[0][0]
+    except Exception:
+        pass
+    return funcname(x)
+
+
+def _make_tasks_summary(tasks):
+    """Summarize of list of (func, args, kwargs) function calls"""
+    unique_funcs = {func for func, args, kwargs in tasks}
+
+    if len(unique_funcs) == 1:
+        mixed = False
+    else:
+        mixed = True
+    return len(tasks), mixed, _funcname(tasks)
+
+
+class Batch:
+    """dask-compatible wrapper that executes a batch of tasks"""
+    def __init__(self, tasks):
+        # collect some metadata from the tasks to ease Batch calls
+        # introspection when debugging
+        self._num_tasks, self._mixed, self._funcname = _make_tasks_summary(
+            tasks
+        )
+
+    def __call__(self, tasks=None):
+        results = []
+        with parallel_backend('dask'):
+            for func, args, kwargs in tasks:
+                results.append(func(*args, **kwargs))
+        return results
+
+    def __repr__(self):
+        descr = f"batch_of_{self._funcname}_{self._num_tasks}_calls"
+        if self._mixed:
+            descr = "mixed_" + descr
+        return descr
+
+
+def _joblib_probe_task():
+    # Noop used by the joblib connector to probe when workers are ready.
+    pass
+
+
+class DaskDistributedBackend(AutoBatchingMixin, ParallelBackendBase):
+    MIN_IDEAL_BATCH_DURATION = 0.2
+    MAX_IDEAL_BATCH_DURATION = 1.0
+    supports_timeout = True
+
+    def __init__(self, scheduler_host=None, scatter=None,
+                 client=None, loop=None, wait_for_workers_timeout=10,
+                 **submit_kwargs):
+        super().__init__()
+
+        if distributed is None:
+            msg = ("You are trying to use 'dask' as a joblib parallel backend "
+                   "but dask is not installed. Please install dask "
+                   "to fix this error.")
+            raise ValueError(msg)
+
+        if client is None:
+            if scheduler_host:
+                client = Client(scheduler_host, loop=loop,
+                                set_as_default=False)
+            else:
+                try:
+                    client = get_client()
+                except ValueError as e:
+                    msg = ("To use Joblib with Dask first create a Dask Client"
+                           "\n\n"
+                           "    from dask.distributed import Client\n"
+                           "    client = Client()\n"
+                           "or\n"
+                           "    client = Client('scheduler-address:8786')")
+                    raise ValueError(msg) from e
+
+        self.client = client
+
+        if scatter is not None and not isinstance(scatter, (list, tuple)):
+            raise TypeError("scatter must be a list/tuple, got "
+                            "`%s`" % type(scatter).__name__)
+
+        if scatter is not None and len(scatter) > 0:
+            # Keep a reference to the scattered data to keep the ids the same
+            self._scatter = list(scatter)
+            scattered = self.client.scatter(scatter, broadcast=True)
+            self.data_futures = {id(x): f for x, f in zip(scatter, scattered)}
+        else:
+            self._scatter = []
+            self.data_futures = {}
+        self.wait_for_workers_timeout = wait_for_workers_timeout
+        self.submit_kwargs = submit_kwargs
+        self.waiting_futures = as_completed(
+            [],
+            loop=client.loop,
+            with_results=True,
+            raise_errors=False
+        )
+        self._results = {}
+        self._callbacks = {}
+
+    async def _collect(self):
+        while self._continue:
+            async for future, result in self.waiting_futures:
+                cf_future = self._results.pop(future)
+                callback = self._callbacks.pop(future)
+                if future.status == "error":
+                    typ, exc, tb = result
+                    cf_future.set_exception(exc)
+                else:
+                    cf_future.set_result(result)
+                    callback(result)
+            await asyncio.sleep(0.01)
+
+    def __reduce__(self):
+        return (DaskDistributedBackend, ())
+
+    def get_nested_backend(self):
+        return DaskDistributedBackend(client=self.client), -1
+
+    def configure(self, n_jobs=1, parallel=None, **backend_args):
+        self.parallel = parallel
+        return self.effective_n_jobs(n_jobs)
+
+    def start_call(self):
+        self._continue = True
+        self.client.loop.add_callback(self._collect)
+        self.call_data_futures = _WeakKeyDictionary()
+
+    def stop_call(self):
+        # The explicit call to clear is required to break a cycling reference
+        # to the futures.
+        self._continue = False
+        # wait for the future collection routine (self._backend._collect) to
+        # finish in order to limit asyncio warnings due to aborting _collect
+        # during a following backend termination call
+        time.sleep(0.01)
+        self.call_data_futures.clear()
+
+    def effective_n_jobs(self, n_jobs):
+        effective_n_jobs = sum(self.client.ncores().values())
+        if effective_n_jobs != 0 or not self.wait_for_workers_timeout:
+            return effective_n_jobs
+
+        # If there is no worker, schedule a probe task to wait for the workers
+        # to come up and be available. If the dask cluster is in adaptive mode
+        # task might cause the cluster to provision some workers.
+        try:
+            self.client.submit(_joblib_probe_task).result(
+                timeout=self.wait_for_workers_timeout)
+        except _TimeoutError as e:
+            error_msg = (
+                "DaskDistributedBackend has no worker after {} seconds. "
+                "Make sure that workers are started and can properly connect "
+                "to the scheduler and increase the joblib/dask connection "
+                "timeout with:\n\n"
+                "parallel_backend('dask', wait_for_workers_timeout={})"
+            ).format(self.wait_for_workers_timeout,
+                     max(10, 2 * self.wait_for_workers_timeout))
+            raise TimeoutError(error_msg) from e
+        return sum(self.client.ncores().values())
+
+    async def _to_func_args(self, func):
+        itemgetters = dict()
+
+        # Futures that are dynamically generated during a single call to
+        # Parallel.__call__.
+        call_data_futures = getattr(self, 'call_data_futures', None)
+
+        async def maybe_to_futures(args):
+            out = []
+            for arg in args:
+                arg_id = id(arg)
+                if arg_id in itemgetters:
+                    out.append(itemgetters[arg_id])
+                    continue
+
+                f = self.data_futures.get(arg_id, None)
+                if f is None and call_data_futures is not None:
+                    try:
+                        f = await call_data_futures[arg]
+                    except KeyError:
+                        pass
+                    if f is None:
+                        if is_weakrefable(arg) and sizeof(arg) > 1e3:
+                            # Automatically scatter large objects to some of
+                            # the workers to avoid duplicated data transfers.
+                            # Rely on automated inter-worker data stealing if
+                            # more workers need to reuse this data
+                            # concurrently.
+                            # set hash=False - nested scatter calls (i.e
+                            # calling client.scatter inside a dask worker)
+                            # using hash=True often raise CancelledError,
+                            # see dask/distributed#3703
+                            _coro = self.client.scatter(
+                                arg,
+                                asynchronous=True,
+                                hash=False
+                            )
+                            # Centralize the scattering of identical arguments
+                            # between concurrent apply_async callbacks by
+                            # exposing the running coroutine in
+                            # call_data_futures before it completes.
+                            t = asyncio.Task(_coro)
+                            call_data_futures[arg] = t
+
+                            f = await t
+
+                if f is not None:
+                    out.append(f)
+                else:
+                    out.append(arg)
+            return out
+
+        tasks = []
+        for f, args, kwargs in func.items:
+            args = list(await maybe_to_futures(args))
+            kwargs = dict(zip(kwargs.keys(),
+                              await maybe_to_futures(kwargs.values())))
+            tasks.append((f, args, kwargs))
+
+        return (Batch(tasks), tasks)
+
+    def apply_async(self, func, callback=None):
+
+        cf_future = concurrent.futures.Future()
+        cf_future.get = cf_future.result  # achieve AsyncResult API
+
+        async def f(func, callback):
+            batch, tasks = await self._to_func_args(func)
+            key = f'{repr(batch)}-{uuid4().hex}'
+
+            dask_future = self.client.submit(
+                batch, tasks=tasks, key=key, **self.submit_kwargs
+            )
+            self.waiting_futures.add(dask_future)
+            self._callbacks[dask_future] = callback
+            self._results[dask_future] = cf_future
+
+        self.client.loop.add_callback(f, func, callback)
+
+        return cf_future
+
+    def abort_everything(self, ensure_ready=True):
+        """ Tell the client to cancel any task submitted via this instance
+
+        joblib.Parallel will never access those results
+        """
+        with self.waiting_futures.lock:
+            self.waiting_futures.futures.clear()
+            while not self.waiting_futures.queue.empty():
+                self.waiting_futures.queue.get()
+
+    @contextlib.contextmanager
+    def retrieval_context(self):
+        """Override ParallelBackendBase.retrieval_context to avoid deadlocks.
+
+        This removes thread from the worker's thread pool (using 'secede').
+        Seceding avoids deadlock in nested parallelism settings.
+        """
+        # See 'joblib.Parallel.__call__' and 'joblib.Parallel.retrieve' for how
+        # this is used.
+        if hasattr(thread_state, 'execution_state'):
+            # we are in a worker. Secede to avoid deadlock.
+            secede()
+
+        yield
+
+        if hasattr(thread_state, 'execution_state'):
+            rejoin()

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/joblib/_parallel_backends.py

@@ -0,0 +1,610 @@
+"""
+Backends for embarrassingly parallel code.
+"""
+
+import gc
+import os
+import warnings
+import threading
+import functools
+import contextlib
+from abc import ABCMeta, abstractmethod
+
+from .my_exceptions import WorkerInterrupt
+from ._multiprocessing_helpers import mp
+
+if mp is not None:
+    from .pool import MemmappingPool
+    from multiprocessing.pool import ThreadPool
+    from .executor import get_memmapping_executor
+
+    # Compat between concurrent.futures and multiprocessing TimeoutError
+    from multiprocessing import TimeoutError
+    from concurrent.futures._base import TimeoutError as CfTimeoutError
+    from .externals.loky import process_executor, cpu_count
+
+
+class ParallelBackendBase(metaclass=ABCMeta):
+    """Helper abc which defines all methods a ParallelBackend must implement"""
+
+    supports_timeout = False
+    supports_inner_max_num_threads = False
+    nesting_level = None
+
+    def __init__(self, nesting_level=None, inner_max_num_threads=None,
+                 **kwargs):
+        super().__init__(**kwargs)
+        self.nesting_level = nesting_level
+        self.inner_max_num_threads = inner_max_num_threads
+
+    MAX_NUM_THREADS_VARS = [
+        'OMP_NUM_THREADS', 'OPENBLAS_NUM_THREADS', 'MKL_NUM_THREADS',
+        'BLIS_NUM_THREADS', 'VECLIB_MAXIMUM_THREADS', 'NUMBA_NUM_THREADS',
+        'NUMEXPR_NUM_THREADS',
+    ]
+
+    TBB_ENABLE_IPC_VAR = "ENABLE_IPC"
+
+    @abstractmethod
+    def effective_n_jobs(self, n_jobs):
+        """Determine the number of jobs that can actually run in parallel
+
+        n_jobs is the number of workers requested by the callers. Passing
+        n_jobs=-1 means requesting all available workers for instance matching
+        the number of CPU cores on the worker host(s).
+
+        This method should return a guesstimate of the number of workers that
+        can actually perform work concurrently. The primary use case is to make
+        it possible for the caller to know in how many chunks to slice the
+        work.
+
+        In general working on larger data chunks is more efficient (less
+        scheduling overhead and better use of CPU cache prefetching heuristics)
+        as long as all the workers have enough work to do.
+        """
+
+    @abstractmethod
+    def apply_async(self, func, callback=None):
+        """Schedule a func to be run"""
+
+    def configure(self, n_jobs=1, parallel=None, prefer=None, require=None,
+                  **backend_args):
+        """Reconfigure the backend and return the number of workers.
+
+        This makes it possible to reuse an existing backend instance for
+        successive independent calls to Parallel with different parameters.
+        """
+        self.parallel = parallel
+        return self.effective_n_jobs(n_jobs)
+
+    def start_call(self):
+        """Call-back method called at the beginning of a Parallel call"""
+
+    def stop_call(self):
+        """Call-back method called at the end of a Parallel call"""
+
+    def terminate(self):
+        """Shutdown the workers and free the shared memory."""
+
+    def compute_batch_size(self):
+        """Determine the optimal batch size"""
+        return 1
+
+    def batch_completed(self, batch_size, duration):
+        """Callback indicate how long it took to run a batch"""
+
+    def get_exceptions(self):
+        """List of exception types to be captured."""
+        return []
+
+    def abort_everything(self, ensure_ready=True):
+        """Abort any running tasks
+
+        This is called when an exception has been raised when executing a tasks
+        and all the remaining tasks will be ignored and can therefore be
+        aborted to spare computation resources.
+
+        If ensure_ready is True, the backend should be left in an operating
+        state as future tasks might be re-submitted via that same backend
+        instance.
+
+        If ensure_ready is False, the implementer of this method can decide
+        to leave the backend in a closed / terminated state as no new task
+        are expected to be submitted to this backend.
+
+        Setting ensure_ready to False is an optimization that can be leveraged
+        when aborting tasks via killing processes from a local process pool
+        managed by the backend it-self: if we expect no new tasks, there is no
+        point in re-creating new workers.
+        """
+        # Does nothing by default: to be overridden in subclasses when
+        # canceling tasks is possible.
+        pass
+
+    def get_nested_backend(self):
+        """Backend instance to be used by nested Parallel calls.
+
+        By default a thread-based backend is used for the first level of
+        nesting. Beyond, switch to sequential backend to avoid spawning too
+        many threads on the host.
+        """
+        nesting_level = getattr(self, 'nesting_level', 0) + 1
+        if nesting_level > 1:
+            return SequentialBackend(nesting_level=nesting_level), None
+        else:
+            return ThreadingBackend(nesting_level=nesting_level), None
+
+    @contextlib.contextmanager
+    def retrieval_context(self):
+        """Context manager to manage an execution context.
+
+        Calls to Parallel.retrieve will be made inside this context.
+
+        By default, this does nothing. It may be useful for subclasses to
+        handle nested parallelism. In particular, it may be required to avoid
+        deadlocks if a backend manages a fixed number of workers, when those
+        workers may be asked to do nested Parallel calls. Without
+        'retrieval_context' this could lead to deadlock, as all the workers
+        managed by the backend may be "busy" waiting for the nested parallel
+        calls to finish, but the backend has no free workers to execute those
+        tasks.
+        """
+        yield
+
+    def _prepare_worker_env(self, n_jobs):
+        """Return environment variables limiting threadpools in external libs.
+
+        This function return a dict containing environment variables to pass
+        when creating a pool of process. These environment variables limit the
+        number of threads to `n_threads` for OpenMP, MKL, Accelerated and
+        OpenBLAS libraries in the child processes.
+        """
+        explicit_n_threads = self.inner_max_num_threads
+        default_n_threads = str(max(cpu_count() // n_jobs, 1))
+
+        # Set the inner environment variables to self.inner_max_num_threads if
+        # it is given. Else, default to cpu_count // n_jobs unless the variable
+        # is already present in the parent process environment.
+        env = {}
+        for var in self.MAX_NUM_THREADS_VARS:
+            if explicit_n_threads is None:
+                var_value = os.environ.get(var, None)
+                if var_value is None:
+                    var_value = default_n_threads
+            else:
+                var_value = str(explicit_n_threads)
+
+            env[var] = var_value
+
+        if self.TBB_ENABLE_IPC_VAR not in os.environ:
+            # To avoid over-subscription when using TBB, let the TBB schedulers
+            # use Inter Process Communication to coordinate:
+            env[self.TBB_ENABLE_IPC_VAR] = "1"
+        return env
+
+    @staticmethod
+    def in_main_thread():
+        return isinstance(threading.current_thread(), threading._MainThread)
+
+
+class SequentialBackend(ParallelBackendBase):
+    """A ParallelBackend which will execute all batches sequentially.
+
+    Does not use/create any threading objects, and hence has minimal
+    overhead. Used when n_jobs == 1.
+    """
+
+    uses_threads = True
+    supports_sharedmem = True
+
+    def effective_n_jobs(self, n_jobs):
+        """Determine the number of jobs which are going to run in parallel"""
+        if n_jobs == 0:
+            raise ValueError('n_jobs == 0 in Parallel has no meaning')
+        return 1
+
+    def apply_async(self, func, callback=None):
+        """Schedule a func to be run"""
+        result = ImmediateResult(func)
+        if callback:
+            callback(result)
+        return result
+
+    def get_nested_backend(self):
+        # import is not top level to avoid cyclic import errors.
+        from .parallel import get_active_backend
+
+        # SequentialBackend should neither change the nesting level, the
+        # default backend or the number of jobs. Just return the current one.
+        return get_active_backend()
+
+
+class PoolManagerMixin(object):
+    """A helper class for managing pool of workers."""
+
+    _pool = None
+
+    def effective_n_jobs(self, n_jobs):
+        """Determine the number of jobs which are going to run in parallel"""
+        if n_jobs == 0:
+            raise ValueError('n_jobs == 0 in Parallel has no meaning')
+        elif mp is None or n_jobs is None:
+            # multiprocessing is not available or disabled, fallback
+            # to sequential mode
+            return 1
+        elif n_jobs < 0:
+            n_jobs = max(cpu_count() + 1 + n_jobs, 1)
+        return n_jobs
+
+    def terminate(self):
+        """Shutdown the process or thread pool"""
+        if self._pool is not None:
+            self._pool.close()
+            self._pool.terminate()  # terminate does a join()
+            self._pool = None
+
+    def _get_pool(self):
+        """Used by apply_async to make it possible to implement lazy init"""
+        return self._pool
+
+    def apply_async(self, func, callback=None):
+        """Schedule a func to be run"""
+        return self._get_pool().apply_async(
+            SafeFunction(func), callback=callback)
+
+    def abort_everything(self, ensure_ready=True):
+        """Shutdown the pool and restart a new one with the same parameters"""
+        self.terminate()
+        if ensure_ready:
+            self.configure(n_jobs=self.parallel.n_jobs, parallel=self.parallel,
+                           **self.parallel._backend_args)
+
+
+class AutoBatchingMixin(object):
+    """A helper class for automagically batching jobs."""
+
+    # In seconds, should be big enough to hide multiprocessing dispatching
+    # overhead.
+    # This settings was found by running benchmarks/bench_auto_batching.py
+    # with various parameters on various platforms.
+    MIN_IDEAL_BATCH_DURATION = .2
+
+    # Should not be too high to avoid stragglers: long jobs running alone
+    # on a single worker while other workers have no work to process any more.
+    MAX_IDEAL_BATCH_DURATION = 2
+
+    # Batching counters default values
+    _DEFAULT_EFFECTIVE_BATCH_SIZE = 1
+    _DEFAULT_SMOOTHED_BATCH_DURATION = 0.0
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self._effective_batch_size = self._DEFAULT_EFFECTIVE_BATCH_SIZE
+        self._smoothed_batch_duration = self._DEFAULT_SMOOTHED_BATCH_DURATION
+
+    def compute_batch_size(self):
+        """Determine the optimal batch size"""
+        old_batch_size = self._effective_batch_size
+        batch_duration = self._smoothed_batch_duration
+        if (batch_duration > 0 and
+                batch_duration < self.MIN_IDEAL_BATCH_DURATION):
+            # The current batch size is too small: the duration of the
+            # processing of a batch of task is not large enough to hide
+            # the scheduling overhead.
+            ideal_batch_size = int(old_batch_size *
+                                   self.MIN_IDEAL_BATCH_DURATION /
+                                   batch_duration)
+            # Multiply by two to limit oscilations between min and max.
+            ideal_batch_size *= 2
+
+            # dont increase the batch size too fast to limit huge batch sizes
+            # potentially leading to starving worker
+            batch_size = min(2 * old_batch_size, ideal_batch_size)
+
+            batch_size = max(batch_size, 1)
+
+            self._effective_batch_size = batch_size
+            if self.parallel.verbose >= 10:
+                self.parallel._print(
+                    "Batch computation too fast (%.4fs.) "
+                    "Setting batch_size=%d.", (batch_duration, batch_size))
+        elif (batch_duration > self.MAX_IDEAL_BATCH_DURATION and
+              old_batch_size >= 2):
+            # The current batch size is too big. If we schedule overly long
+            # running batches some CPUs might wait with nothing left to do
+            # while a couple of CPUs a left processing a few long running
+            # batches. Better reduce the batch size a bit to limit the
+            # likelihood of scheduling such stragglers.
+
+            # decrease the batch size quickly to limit potential starving
+            ideal_batch_size = int(
+                old_batch_size * self.MIN_IDEAL_BATCH_DURATION / batch_duration
+            )
+            # Multiply by two to limit oscilations between min and max.
+            batch_size = max(2 * ideal_batch_size, 1)
+            self._effective_batch_size = batch_size
+            if self.parallel.verbose >= 10:
+                self.parallel._print(
+                    "Batch computation too slow (%.4fs.) "
+                    "Setting batch_size=%d.", (batch_duration, batch_size))
+        else:
+            # No batch size adjustment
+            batch_size = old_batch_size
+
+        if batch_size != old_batch_size:
+            # Reset estimation of the smoothed mean batch duration: this
+            # estimate is updated in the multiprocessing apply_async
+            # CallBack as long as the batch_size is constant. Therefore
+            # we need to reset the estimate whenever we re-tune the batch
+            # size.
+            self._smoothed_batch_duration = \
+                self._DEFAULT_SMOOTHED_BATCH_DURATION
+
+        return batch_size
+
+    def batch_completed(self, batch_size, duration):
+        """Callback indicate how long it took to run a batch"""
+        if batch_size == self._effective_batch_size:
+            # Update the smoothed streaming estimate of the duration of a batch
+            # from dispatch to completion
+            old_duration = self._smoothed_batch_duration
+            if old_duration == self._DEFAULT_SMOOTHED_BATCH_DURATION:
+                # First record of duration for this batch size after the last
+                # reset.
+                new_duration = duration
+            else:
+                # Update the exponentially weighted average of the duration of
+                # batch for the current effective size.
+                new_duration = 0.8 * old_duration + 0.2 * duration
+            self._smoothed_batch_duration = new_duration
+
+    def reset_batch_stats(self):
+        """Reset batch statistics to default values.
+
+        This avoids interferences with future jobs.
+        """
+        self._effective_batch_size = self._DEFAULT_EFFECTIVE_BATCH_SIZE
+        self._smoothed_batch_duration = self._DEFAULT_SMOOTHED_BATCH_DURATION
+
+
+class ThreadingBackend(PoolManagerMixin, ParallelBackendBase):
+    """A ParallelBackend which will use a thread pool to execute batches in.
+
+    This is a low-overhead backend but it suffers from the Python Global
+    Interpreter Lock if the called function relies a lot on Python objects.
+    Mostly useful when the execution bottleneck is a compiled extension that
+    explicitly releases the GIL (for instance a Cython loop wrapped in a "with
+    nogil" block or an expensive call to a library such as NumPy).
+
+    The actual thread pool is lazily initialized: the actual thread pool
+    construction is delayed to the first call to apply_async.
+
+    ThreadingBackend is used as the default backend for nested calls.
+    """
+
+    supports_timeout = True
+    uses_threads = True
+    supports_sharedmem = True
+
+    def configure(self, n_jobs=1, parallel=None, **backend_args):
+        """Build a process or thread pool and return the number of workers"""
+        n_jobs = self.effective_n_jobs(n_jobs)
+        if n_jobs == 1:
+            # Avoid unnecessary overhead and use sequential backend instead.
+            raise FallbackToBackend(
+                SequentialBackend(nesting_level=self.nesting_level))
+        self.parallel = parallel
+        self._n_jobs = n_jobs
+        return n_jobs
+
+    def _get_pool(self):
+        """Lazily initialize the thread pool
+
+        The actual pool of worker threads is only initialized at the first
+        call to apply_async.
+        """
+        if self._pool is None:
+            self._pool = ThreadPool(self._n_jobs)
+        return self._pool
+
+
+class MultiprocessingBackend(PoolManagerMixin, AutoBatchingMixin,
+                             ParallelBackendBase):
+    """A ParallelBackend which will use a multiprocessing.Pool.
+
+    Will introduce some communication and memory overhead when exchanging
+    input and output data with the with the worker Python processes.
+    However, does not suffer from the Python Global Interpreter Lock.
+    """
+
+    supports_timeout = True
+
+    def effective_n_jobs(self, n_jobs):
+        """Determine the number of jobs which are going to run in parallel.
+
+        This also checks if we are attempting to create a nested parallel
+        loop.
+        """
+        if mp is None:
+            return 1
+
+        if mp.current_process().daemon:
+            # Daemonic processes cannot have children
+            if n_jobs != 1:
+                warnings.warn(
+                    'Multiprocessing-backed parallel loops cannot be nested,'
+                    ' setting n_jobs=1',
+                    stacklevel=3)
+            return 1
+
+        if process_executor._CURRENT_DEPTH > 0:
+            # Mixing loky and multiprocessing in nested loop is not supported
+            if n_jobs != 1:
+                warnings.warn(
+                    'Multiprocessing-backed parallel loops cannot be nested,'
+                    ' below loky, setting n_jobs=1',
+                    stacklevel=3)
+            return 1
+
+        elif not (self.in_main_thread() or self.nesting_level == 0):
+            # Prevent posix fork inside in non-main posix threads
+            if n_jobs != 1:
+                warnings.warn(
+                    'Multiprocessing-backed parallel loops cannot be nested'
+                    ' below threads, setting n_jobs=1',
+                    stacklevel=3)
+            return 1
+
+        return super(MultiprocessingBackend, self).effective_n_jobs(n_jobs)
+
+    def configure(self, n_jobs=1, parallel=None, prefer=None, require=None,
+                  **memmappingpool_args):
+        """Build a process or thread pool and return the number of workers"""
+        n_jobs = self.effective_n_jobs(n_jobs)
+        if n_jobs == 1:
+            raise FallbackToBackend(
+                SequentialBackend(nesting_level=self.nesting_level))
+
+        # Make sure to free as much memory as possible before forking
+        gc.collect()
+        self._pool = MemmappingPool(n_jobs, **memmappingpool_args)
+        self.parallel = parallel
+        return n_jobs
+
+    def terminate(self):
+        """Shutdown the process or thread pool"""
+        super(MultiprocessingBackend, self).terminate()
+        self.reset_batch_stats()
+
+
+class LokyBackend(AutoBatchingMixin, ParallelBackendBase):
+    """Managing pool of workers with loky instead of multiprocessing."""
+
+    supports_timeout = True
+    supports_inner_max_num_threads = True
+
+    def configure(self, n_jobs=1, parallel=None, prefer=None, require=None,
+                  idle_worker_timeout=300, **memmappingexecutor_args):
+        """Build a process executor and return the number of workers"""
+        n_jobs = self.effective_n_jobs(n_jobs)
+        if n_jobs == 1:
+            raise FallbackToBackend(
+                SequentialBackend(nesting_level=self.nesting_level))
+
+        self._workers = get_memmapping_executor(
+            n_jobs, timeout=idle_worker_timeout,
+            env=self._prepare_worker_env(n_jobs=n_jobs),
+            context_id=parallel._id, **memmappingexecutor_args)
+        self.parallel = parallel
+        return n_jobs
+
+    def effective_n_jobs(self, n_jobs):
+        """Determine the number of jobs which are going to run in parallel"""
+        if n_jobs == 0:
+            raise ValueError('n_jobs == 0 in Parallel has no meaning')
+        elif mp is None or n_jobs is None:
+            # multiprocessing is not available or disabled, fallback
+            # to sequential mode
+            return 1
+        elif mp.current_process().daemon:
+            # Daemonic processes cannot have children
+            if n_jobs != 1:
+                warnings.warn(
+                    'Loky-backed parallel loops cannot be called in a'
+                    ' multiprocessing, setting n_jobs=1',
+                    stacklevel=3)
+            return 1
+        elif not (self.in_main_thread() or self.nesting_level == 0):
+            # Prevent posix fork inside in non-main posix threads
+            if n_jobs != 1:
+                warnings.warn(
+                    'Loky-backed parallel loops cannot be nested below '
+                    'threads, setting n_jobs=1',
+                    stacklevel=3)
+            return 1
+        elif n_jobs < 0:
+            n_jobs = max(cpu_count() + 1 + n_jobs, 1)
+        return n_jobs
+
+    def apply_async(self, func, callback=None):
+        """Schedule a func to be run"""
+        future = self._workers.submit(SafeFunction(func))
+        future.get = functools.partial(self.wrap_future_result, future)
+        if callback is not None:
+            future.add_done_callback(callback)
+        return future
+
+    @staticmethod
+    def wrap_future_result(future, timeout=None):
+        """Wrapper for Future.result to implement the same behaviour as
+        AsyncResults.get from multiprocessing."""
+        try:
+            return future.result(timeout=timeout)
+        except CfTimeoutError as e:
+            raise TimeoutError from e
+
+    def terminate(self):
+        if self._workers is not None:
+            # Don't terminate the workers as we want to reuse them in later
+            # calls, but cleanup the temporary resources that the Parallel call
+            # created. This 'hack' requires a private, low-level operation.
+            self._workers._temp_folder_manager._unlink_temporary_resources(
+                context_id=self.parallel._id
+            )
+            self._workers = None
+
+        self.reset_batch_stats()
+
+    def abort_everything(self, ensure_ready=True):
+        """Shutdown the workers and restart a new one with the same parameters
+        """
+        self._workers.terminate(kill_workers=True)
+        self._workers = None
+
+        if ensure_ready:
+            self.configure(n_jobs=self.parallel.n_jobs, parallel=self.parallel)
+
+
+class ImmediateResult(object):
+    def __init__(self, batch):
+        # Don't delay the application, to avoid keeping the input
+        # arguments in memory
+        self.results = batch()
+
+    def get(self):
+        return self.results
+
+
+class SafeFunction(object):
+    """Wrapper that handles the serialization of exception tracebacks.
+
+    TODO python2_drop: check whether SafeFunction is still needed since we
+    dropped support for Python 2. If not needed anymore it should be
+    deprecated.
+
+    If an exception is triggered when calling the inner function, a copy of
+    the full traceback is captured to make it possible to serialize
+    it so that it can be rendered in a different Python process.
+
+    """
+    def __init__(self, func):
+        self.func = func
+
+    def __call__(self, *args, **kwargs):
+        try:
+            return self.func(*args, **kwargs)
+        except KeyboardInterrupt as e:
+            # We capture the KeyboardInterrupt and reraise it as
+            # something different, as multiprocessing does not
+            # interrupt processing for a KeyboardInterrupt
+            raise WorkerInterrupt() from e
+        except BaseException:
+            # Rely on Python 3 built-in Remote Traceback reporting
+            raise
+
+
+class FallbackToBackend(Exception):
+    """Raised when configuration should fallback to another backend"""
+
+    def __init__(self, backend):
+        self.backend = backend

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/joblib/_store_backends.py

@@ -0,0 +1,414 @@
+"""Storage providers backends for Memory caching."""
+
+import re
+import os
+import os.path
+import datetime
+import json
+import shutil
+import warnings
+import collections
+import operator
+import threading
+from abc import ABCMeta, abstractmethod
+
+from .backports import concurrency_safe_rename
+from .disk import mkdirp, memstr_to_bytes, rm_subdirs
+from . import numpy_pickle
+
+CacheItemInfo = collections.namedtuple('CacheItemInfo',
+                                       'path size last_access')
+
+
+def concurrency_safe_write(object_to_write, filename, write_func):
+    """Writes an object into a unique file in a concurrency-safe way."""
+    thread_id = id(threading.current_thread())
+    temporary_filename = '{}.thread-{}-pid-{}'.format(
+        filename, thread_id, os.getpid())
+    write_func(object_to_write, temporary_filename)
+
+    return temporary_filename
+
+
+class StoreBackendBase(metaclass=ABCMeta):
+    """Helper Abstract Base Class which defines all methods that
+       a StorageBackend must implement."""
+
+    location = None
+
+    @abstractmethod
+    def _open_item(self, f, mode):
+        """Opens an item on the store and return a file-like object.
+
+        This method is private and only used by the StoreBackendMixin object.
+
+        Parameters
+        ----------
+        f: a file-like object
+            The file-like object where an item is stored and retrieved
+        mode: string, optional
+            the mode in which the file-like object is opened allowed valued are
+            'rb', 'wb'
+
+        Returns
+        -------
+        a file-like object
+        """
+
+    @abstractmethod
+    def _item_exists(self, location):
+        """Checks if an item location exists in the store.
+
+        This method is private and only used by the StoreBackendMixin object.
+
+        Parameters
+        ----------
+        location: string
+            The location of an item. On a filesystem, this corresponds to the
+            absolute path, including the filename, of a file.
+
+        Returns
+        -------
+        True if the item exists, False otherwise
+        """
+
+    @abstractmethod
+    def _move_item(self, src, dst):
+        """Moves an item from src to dst in the store.
+
+        This method is private and only used by the StoreBackendMixin object.
+
+        Parameters
+        ----------
+        src: string
+            The source location of an item
+        dst: string
+            The destination location of an item
+        """
+
+    @abstractmethod
+    def create_location(self, location):
+        """Creates a location on the store.
+
+        Parameters
+        ----------
+        location: string
+            The location in the store. On a filesystem, this corresponds to a
+            directory.
+        """
+
+    @abstractmethod
+    def clear_location(self, location):
+        """Clears a location on the store.
+
+        Parameters
+        ----------
+        location: string
+            The location in the store. On a filesystem, this corresponds to a
+            directory or a filename absolute path
+        """
+
+    @abstractmethod
+    def get_items(self):
+        """Returns the whole list of items available in the store.
+
+        Returns
+        -------
+        The list of items identified by their ids (e.g filename in a
+        filesystem).
+        """
+
+    @abstractmethod
+    def configure(self, location, verbose=0, backend_options=dict()):
+        """Configures the store.
+
+        Parameters
+        ----------
+        location: string
+            The base location used by the store. On a filesystem, this
+            corresponds to a directory.
+        verbose: int
+            The level of verbosity of the store
+        backend_options: dict
+            Contains a dictionnary of named paremeters used to configure the
+            store backend.
+        """
+
+
+class StoreBackendMixin(object):
+    """Class providing all logic for managing the store in a generic way.
+
+    The StoreBackend subclass has to implement 3 methods: create_location,
+    clear_location and configure. The StoreBackend also has to provide
+    a private _open_item, _item_exists and _move_item methods. The _open_item
+    method has to have the same signature as the builtin open and return a
+    file-like object.
+    """
+
+    def load_item(self, path, verbose=1, msg=None):
+        """Load an item from the store given its path as a list of
+           strings."""
+        full_path = os.path.join(self.location, *path)
+
+        if verbose > 1:
+            if verbose < 10:
+                print('{0}...'.format(msg))
+            else:
+                print('{0} from {1}'.format(msg, full_path))
+
+        mmap_mode = (None if not hasattr(self, 'mmap_mode')
+                     else self.mmap_mode)
+
+        filename = os.path.join(full_path, 'output.pkl')
+        if not self._item_exists(filename):
+            raise KeyError("Non-existing item (may have been "
+                           "cleared).\nFile %s does not exist" % filename)
+
+        # file-like object cannot be used when mmap_mode is set
+        if mmap_mode is None:
+            with self._open_item(filename, "rb") as f:
+                item = numpy_pickle.load(f)
+        else:
+            item = numpy_pickle.load(filename, mmap_mode=mmap_mode)
+        return item
+
+    def dump_item(self, path, item, verbose=1):
+        """Dump an item in the store at the path given as a list of
+           strings."""
+        try:
+            item_path = os.path.join(self.location, *path)
+            if not self._item_exists(item_path):
+                self.create_location(item_path)
+            filename = os.path.join(item_path, 'output.pkl')
+            if verbose > 10:
+                print('Persisting in %s' % item_path)
+
+            def write_func(to_write, dest_filename):
+                with self._open_item(dest_filename, "wb") as f:
+                    numpy_pickle.dump(to_write, f,
+                                      compress=self.compress)
+
+            self._concurrency_safe_write(item, filename, write_func)
+        except:  # noqa: E722
+            " Race condition in the creation of the directory "
+
+    def clear_item(self, path):
+        """Clear the item at the path, given as a list of strings."""
+        item_path = os.path.join(self.location, *path)
+        if self._item_exists(item_path):
+            self.clear_location(item_path)
+
+    def contains_item(self, path):
+        """Check if there is an item at the path, given as a list of
+           strings"""
+        item_path = os.path.join(self.location, *path)
+        filename = os.path.join(item_path, 'output.pkl')
+
+        return self._item_exists(filename)
+
+    def get_item_info(self, path):
+        """Return information about item."""
+        return {'location': os.path.join(self.location,
+                                         *path)}
+
+    def get_metadata(self, path):
+        """Return actual metadata of an item."""
+        try:
+            item_path = os.path.join(self.location, *path)
+            filename = os.path.join(item_path, 'metadata.json')
+            with self._open_item(filename, 'rb') as f:
+                return json.loads(f.read().decode('utf-8'))
+        except:  # noqa: E722
+            return {}
+
+    def store_metadata(self, path, metadata):
+        """Store metadata of a computation."""
+        try:
+            item_path = os.path.join(self.location, *path)
+            self.create_location(item_path)
+            filename = os.path.join(item_path, 'metadata.json')
+
+            def write_func(to_write, dest_filename):
+                with self._open_item(dest_filename, "wb") as f:
+                    f.write(json.dumps(to_write).encode('utf-8'))
+
+            self._concurrency_safe_write(metadata, filename, write_func)
+        except:  # noqa: E722
+            pass
+
+    def contains_path(self, path):
+        """Check cached function is available in store."""
+        func_path = os.path.join(self.location, *path)
+        return self.object_exists(func_path)
+
+    def clear_path(self, path):
+        """Clear all items with a common path in the store."""
+        func_path = os.path.join(self.location, *path)
+        if self._item_exists(func_path):
+            self.clear_location(func_path)
+
+    def store_cached_func_code(self, path, func_code=None):
+        """Store the code of the cached function."""
+        func_path = os.path.join(self.location, *path)
+        if not self._item_exists(func_path):
+            self.create_location(func_path)
+
+        if func_code is not None:
+            filename = os.path.join(func_path, "func_code.py")
+            with self._open_item(filename, 'wb') as f:
+                f.write(func_code.encode('utf-8'))
+
+    def get_cached_func_code(self, path):
+        """Store the code of the cached function."""
+        path += ['func_code.py', ]
+        filename = os.path.join(self.location, *path)
+        try:
+            with self._open_item(filename, 'rb') as f:
+                return f.read().decode('utf-8')
+        except:  # noqa: E722
+            raise
+
+    def get_cached_func_info(self, path):
+        """Return information related to the cached function if it exists."""
+        return {'location': os.path.join(self.location, *path)}
+
+    def clear(self):
+        """Clear the whole store content."""
+        self.clear_location(self.location)
+
+    def reduce_store_size(self, bytes_limit):
+        """Reduce store size to keep it under the given bytes limit."""
+        items_to_delete = self._get_items_to_delete(bytes_limit)
+
+        for item in items_to_delete:
+            if self.verbose > 10:
+                print('Deleting item {0}'.format(item))
+            try:
+                self.clear_location(item.path)
+            except OSError:
+                # Even with ignore_errors=True shutil.rmtree can raise OSError
+                # with:
+                # [Errno 116] Stale file handle if another process has deleted
+                # the folder already.
+                pass
+
+    def _get_items_to_delete(self, bytes_limit):
+        """Get items to delete to keep the store under a size limit."""
+        if isinstance(bytes_limit, str):
+            bytes_limit = memstr_to_bytes(bytes_limit)
+
+        items = self.get_items()
+        size = sum(item.size for item in items)
+
+        to_delete_size = size - bytes_limit
+        if to_delete_size < 0:
+            return []
+
+        # We want to delete first the cache items that were accessed a
+        # long time ago
+        items.sort(key=operator.attrgetter('last_access'))
+
+        items_to_delete = []
+        size_so_far = 0
+
+        for item in items:
+            if size_so_far > to_delete_size:
+                break
+
+            items_to_delete.append(item)
+            size_so_far += item.size
+
+        return items_to_delete
+
+    def _concurrency_safe_write(self, to_write, filename, write_func):
+        """Writes an object into a file in a concurrency-safe way."""
+        temporary_filename = concurrency_safe_write(to_write,
+                                                    filename, write_func)
+        self._move_item(temporary_filename, filename)
+
+    def __repr__(self):
+        """Printable representation of the store location."""
+        return '{class_name}(location="{location}")'.format(
+            class_name=self.__class__.__name__, location=self.location)
+
+
+class FileSystemStoreBackend(StoreBackendBase, StoreBackendMixin):
+    """A StoreBackend used with local or network file systems."""
+
+    _open_item = staticmethod(open)
+    _item_exists = staticmethod(os.path.exists)
+    _move_item = staticmethod(concurrency_safe_rename)
+
+    def clear_location(self, location):
+        """Delete location on store."""
+        if (location == self.location):
+            rm_subdirs(location)
+        else:
+            shutil.rmtree(location, ignore_errors=True)
+
+    def create_location(self, location):
+        """Create object location on store"""
+        mkdirp(location)
+
+    def get_items(self):
+        """Returns the whole list of items available in the store."""
+        items = []
+
+        for dirpath, _, filenames in os.walk(self.location):
+            is_cache_hash_dir = re.match('[a-f0-9]{32}',
+                                         os.path.basename(dirpath))
+
+            if is_cache_hash_dir:
+                output_filename = os.path.join(dirpath, 'output.pkl')
+                try:
+                    last_access = os.path.getatime(output_filename)
+                except OSError:
+                    try:
+                        last_access = os.path.getatime(dirpath)
+                    except OSError:
+                        # The directory has already been deleted
+                        continue
+
+                last_access = datetime.datetime.fromtimestamp(last_access)
+                try:
+                    full_filenames = [os.path.join(dirpath, fn)
+                                      for fn in filenames]
+                    dirsize = sum(os.path.getsize(fn)
+                                  for fn in full_filenames)
+                except OSError:
+                    # Either output_filename or one of the files in
+                    # dirpath does not exist any more. We assume this
+                    # directory is being cleaned by another process already
+                    continue
+
+                items.append(CacheItemInfo(dirpath, dirsize,
+                                           last_access))
+
+        return items
+
+    def configure(self, location, verbose=1, backend_options=None):
+        """Configure the store backend.
+
+        For this backend, valid store options are 'compress' and 'mmap_mode'
+        """
+        if backend_options is None:
+            backend_options = {}
+
+        # setup location directory
+        self.location = location
+        if not os.path.exists(self.location):
+            mkdirp(self.location)
+
+        # item can be stored compressed for faster I/O
+        self.compress = backend_options.get('compress', False)
+
+        # FileSystemStoreBackend can be used with mmap_mode options under
+        # certain conditions.
+        mmap_mode = backend_options.get('mmap_mode')
+        if self.compress and mmap_mode is not None:
+            warnings.warn('Compressed items cannot be memmapped in a '
+                          'filesystem store. Option will be ignored.',
+                          stacklevel=2)
+
+        self.mmap_mode = mmap_mode
+        self.verbose = verbose

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/joblib/backports.py

@@ -0,0 +1,78 @@
+"""
+Backports of fixes for joblib dependencies
+"""
+import os
+import time
+
+from distutils.version import LooseVersion
+from os.path import basename
+from multiprocessing import util
+
+
+try:
+    import numpy as np
+
+    def make_memmap(filename, dtype='uint8', mode='r+', offset=0,
+                    shape=None, order='C', unlink_on_gc_collect=False):
+        """Custom memmap constructor compatible with numpy.memmap.
+
+        This function:
+        - is a backport the numpy memmap offset fix (See
+          https://github.com/numpy/numpy/pull/8443 for more details.
+          The numpy fix is available starting numpy 1.13)
+        - adds ``unlink_on_gc_collect``, which specifies  explicitly whether
+          the process re-constructing the memmap owns a reference to the
+          underlying file. If set to True, it adds a finalizer to the
+          newly-created memmap that sends a maybe_unlink request for the
+          memmaped file to resource_tracker.
+        """
+        util.debug(
+            "[MEMMAP READ] creating a memmap (shape {}, filename {}, "
+            "pid {})".format(shape, basename(filename), os.getpid())
+        )
+
+        mm = np.memmap(filename, dtype=dtype, mode=mode, offset=offset,
+                       shape=shape, order=order)
+        if LooseVersion(np.__version__) < '1.13':
+            mm.offset = offset
+        if unlink_on_gc_collect:
+            from ._memmapping_reducer import add_maybe_unlink_finalizer
+            add_maybe_unlink_finalizer(mm)
+        return mm
+except ImportError:
+    def make_memmap(filename, dtype='uint8', mode='r+', offset=0,
+                    shape=None, order='C', unlink_on_gc_collect=False):
+        raise NotImplementedError(
+            "'joblib.backports.make_memmap' should not be used "
+            'if numpy is not installed.')
+
+
+if os.name == 'nt':
+    # https://github.com/joblib/joblib/issues/540
+    access_denied_errors = (5, 13)
+    from os import replace
+
+    def concurrency_safe_rename(src, dst):
+        """Renames ``src`` into ``dst`` overwriting ``dst`` if it exists.
+
+        On Windows os.replace can yield permission errors if executed by two
+        different processes.
+        """
+        max_sleep_time = 1
+        total_sleep_time = 0
+        sleep_time = 0.001
+        while total_sleep_time < max_sleep_time:
+            try:
+                replace(src, dst)
+                break
+            except Exception as exc:
+                if getattr(exc, 'winerror', None) in access_denied_errors:
+                    time.sleep(sleep_time)
+                    total_sleep_time += sleep_time
+                    sleep_time *= 2
+                else:
+                    raise
+        else:
+            raise
+else:
+    from os import replace as concurrency_safe_rename  # noqa

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/joblib/disk.py

@@ -0,0 +1,136 @@
+"""
+Disk management utilities.
+"""
+
+# Authors: Gael Varoquaux <gael dot varoquaux at normalesup dot org>
+#          Lars Buitinck
+# Copyright (c) 2010 Gael Varoquaux
+# License: BSD Style, 3 clauses.
+
+
+import os
+import sys
+import time
+import errno
+import shutil
+
+from multiprocessing import util
+
+
+try:
+    WindowsError
+except NameError:
+    WindowsError = OSError
+
+
+def disk_used(path):
+    """ Return the disk usage in a directory."""
+    size = 0
+    for file in os.listdir(path) + ['.']:
+        stat = os.stat(os.path.join(path, file))
+        if hasattr(stat, 'st_blocks'):
+            size += stat.st_blocks * 512
+        else:
+            # on some platform st_blocks is not available (e.g., Windows)
+            # approximate by rounding to next multiple of 512
+            size += (stat.st_size // 512 + 1) * 512
+    # We need to convert to int to avoid having longs on some systems (we
+    # don't want longs to avoid problems we SQLite)
+    return int(size / 1024.)
+
+
+def memstr_to_bytes(text):
+    """ Convert a memory text to its value in bytes.
+    """
+    kilo = 1024
+    units = dict(K=kilo, M=kilo ** 2, G=kilo ** 3)
+    try:
+        size = int(units[text[-1]] * float(text[:-1]))
+    except (KeyError, ValueError) as e:
+        raise ValueError(
+            "Invalid literal for size give: %s (type %s) should be "
+            "alike '10G', '500M', '50K'." % (text, type(text))) from e
+    return size
+
+
+def mkdirp(d):
+    """Ensure directory d exists (like mkdir -p on Unix)
+    No guarantee that the directory is writable.
+    """
+    try:
+        os.makedirs(d)
+    except OSError as e:
+        if e.errno != errno.EEXIST:
+            raise
+
+
+# if a rmtree operation fails in rm_subdirs, wait for this much time (in secs),
+# then retry up to RM_SUBDIRS_N_RETRY times. If it still fails, raise the
+# exception. this mecanism ensures that the sub-process gc have the time to
+# collect and close the memmaps before we fail.
+RM_SUBDIRS_RETRY_TIME = 0.1
+RM_SUBDIRS_N_RETRY = 5
+
+
+def rm_subdirs(path, onerror=None):
+    """Remove all subdirectories in this path.
+
+    The directory indicated by `path` is left in place, and its subdirectories
+    are erased.
+
+    If onerror is set, it is called to handle the error with arguments (func,
+    path, exc_info) where func is os.listdir, os.remove, or os.rmdir;
+    path is the argument to that function that caused it to fail; and
+    exc_info is a tuple returned by sys.exc_info().  If onerror is None,
+    an exception is raised.
+    """
+
+    # NOTE this code is adapted from the one in shutil.rmtree, and is
+    # just as fast
+
+    names = []
+    try:
+        names = os.listdir(path)
+    except os.error:
+        if onerror is not None:
+            onerror(os.listdir, path, sys.exc_info())
+        else:
+            raise
+
+    for name in names:
+        fullname = os.path.join(path, name)
+        delete_folder(fullname, onerror=onerror)
+
+
+def delete_folder(folder_path, onerror=None, allow_non_empty=True):
+    """Utility function to cleanup a temporary folder if it still exists."""
+    if os.path.isdir(folder_path):
+        if onerror is not None:
+            shutil.rmtree(folder_path, False, onerror)
+        else:
+            # allow the rmtree to fail once, wait and re-try.
+            # if the error is raised again, fail
+            err_count = 0
+            while True:
+                files = os.listdir(folder_path)
+                try:
+                    if len(files) == 0 or allow_non_empty:
+                        shutil.rmtree(
+                            folder_path, ignore_errors=False, onerror=None
+                        )
+                        util.debug(
+                            "Sucessfully deleted {}".format(folder_path))
+                        break
+                    else:
+                        raise OSError(
+                            "Expected empty folder {} but got {} "
+                            "files.".format(folder_path, len(files))
+                        )
+                except (OSError, WindowsError):
+                    err_count += 1
+                    if err_count > RM_SUBDIRS_N_RETRY:
+                        # the folder cannot be deleted right now. It maybe
+                        # because some temporary files have not been deleted
+                        # yet.
+                        raise
+                time.sleep(RM_SUBDIRS_RETRY_TIME)

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/joblib/func_inspect.py

@@ -0,0 +1,365 @@
+"""
+My own variation on function-specific inspect-like features.
+"""
+
+# Author: Gael Varoquaux <gael dot varoquaux at normalesup dot org>
+# Copyright (c) 2009 Gael Varoquaux
+# License: BSD Style, 3 clauses.
+
+import inspect
+import warnings
+import re
+import os
+import collections
+
+from itertools import islice
+from tokenize import open as open_py_source
+
+from .logger import pformat
+
+full_argspec_fields = ('args varargs varkw defaults kwonlyargs '
+                       'kwonlydefaults annotations')
+full_argspec_type = collections.namedtuple('FullArgSpec', full_argspec_fields)
+
+
+def get_func_code(func):
+    """ Attempts to retrieve a reliable function code hash.
+
+        The reason we don't use inspect.getsource is that it caches the
+        source, whereas we want this to be modified on the fly when the
+        function is modified.
+
+        Returns
+        -------
+        func_code: string
+            The function code
+        source_file: string
+            The path to the file in which the function is defined.
+        first_line: int
+            The first line of the code in the source file.
+
+        Notes
+        ------
+        This function does a bit more magic than inspect, and is thus
+        more robust.
+    """
+    source_file = None
+    try:
+        code = func.__code__
+        source_file = code.co_filename
+        if not os.path.exists(source_file):
+            # Use inspect for lambda functions and functions defined in an
+            # interactive shell, or in doctests
+            source_code = ''.join(inspect.getsourcelines(func)[0])
+            line_no = 1
+            if source_file.startswith('<doctest '):
+                source_file, line_no = re.match(
+                    r'\<doctest (.*\.rst)\[(.*)\]\>', source_file).groups()
+                line_no = int(line_no)
+                source_file = '<doctest %s>' % source_file
+            return source_code, source_file, line_no
+        # Try to retrieve the source code.
+        with open_py_source(source_file) as source_file_obj:
+            first_line = code.co_firstlineno
+            # All the lines after the function definition:
+            source_lines = list(islice(source_file_obj, first_line - 1, None))
+        return ''.join(inspect.getblock(source_lines)), source_file, first_line
+    except:
+        # If the source code fails, we use the hash. This is fragile and
+        # might change from one session to another.
+        if hasattr(func, '__code__'):
+            # Python 3.X
+            return str(func.__code__.__hash__()), source_file, -1
+        else:
+            # Weird objects like numpy ufunc don't have __code__
+            # This is fragile, as quite often the id of the object is
+            # in the repr, so it might not persist across sessions,
+            # however it will work for ufuncs.
+            return repr(func), source_file, -1
+
+
+def _clean_win_chars(string):
+    """Windows cannot encode some characters in filename."""
+    import urllib
+    if hasattr(urllib, 'quote'):
+        quote = urllib.quote
+    else:
+        # In Python 3, quote is elsewhere
+        import urllib.parse
+        quote = urllib.parse.quote
+    for char in ('<', '>', '!', ':', '\\'):
+        string = string.replace(char, quote(char))
+    return string
+
+
+def get_func_name(func, resolv_alias=True, win_characters=True):
+    """ Return the function import path (as a list of module names), and
+        a name for the function.
+
+        Parameters
+        ----------
+        func: callable
+            The func to inspect
+        resolv_alias: boolean, optional
+            If true, possible local aliases are indicated.
+        win_characters: boolean, optional
+            If true, substitute special characters using urllib.quote
+            This is useful in Windows, as it cannot encode some filenames
+    """
+    if hasattr(func, '__module__'):
+        module = func.__module__
+    else:
+        try:
+            module = inspect.getmodule(func)
+        except TypeError:
+            if hasattr(func, '__class__'):
+                module = func.__class__.__module__
+            else:
+                module = 'unknown'
+    if module is None:
+        # Happens in doctests, eg
+        module = ''
+    if module == '__main__':
+        try:
+            filename = os.path.abspath(inspect.getsourcefile(func))
+        except:
+            filename = None
+        if filename is not None:
+            # mangling of full path to filename
+            parts = filename.split(os.sep)
+            if parts[-1].startswith('<ipython-input'):
+                # We're in a IPython (or notebook) session. parts[-1] comes
+                # from func.__code__.co_filename and is of the form
+                # <ipython-input-N-XYZ>, where:
+                # - N is the cell number where the function was defined
+                # - XYZ is a hash representing the function's code (and name).
+                #   It will be consistent across sessions and kernel restarts,
+                #   and will change if the function's code/name changes
+                # We remove N so that cache is properly hit if the cell where
+                # the func is defined is re-exectuted.
+                # The XYZ hash should avoid collisions between functions with
+                # the same name, both within the same notebook but also across
+                # notebooks
+                splitted = parts[-1].split('-')
+                parts[-1] = '-'.join(splitted[:2] + splitted[3:])
+            elif len(parts) > 2 and parts[-2].startswith('ipykernel_'):
+                # In a notebook session (ipykernel). Filename seems to be 'xyz'
+                # of above. parts[-2] has the structure ipykernel_XXXXXX where
+                # XXXXXX is a six-digit number identifying the current run (?).
+                # If we split it off, the function again has the same
+                # identifier across runs.
+                parts[-2] = 'ipykernel'
+            filename = '-'.join(parts)
+            if filename.endswith('.py'):
+                filename = filename[:-3]
+            module = module + '-' + filename
+    module = module.split('.')
+    if hasattr(func, 'func_name'):
+        name = func.func_name
+    elif hasattr(func, '__name__'):
+        name = func.__name__
+    else:
+        name = 'unknown'
+    # Hack to detect functions not defined at the module-level
+    if resolv_alias:
+        # TODO: Maybe add a warning here?
+        if hasattr(func, 'func_globals') and name in func.func_globals:
+            if not func.func_globals[name] is func:
+                name = '%s-alias' % name
+    if inspect.ismethod(func):
+        # We need to add the name of the class
+        if hasattr(func, 'im_class'):
+            klass = func.im_class
+            module.append(klass.__name__)
+    if os.name == 'nt' and win_characters:
+        # Windows can't encode certain characters in filenames
+        name = _clean_win_chars(name)
+        module = [_clean_win_chars(s) for s in module]
+    return module, name
+
+
+def _signature_str(function_name, arg_sig):
+    """Helper function to output a function signature"""
+    return '{}{}'.format(function_name, arg_sig)
+
+
+def _function_called_str(function_name, args, kwargs):
+    """Helper function to output a function call"""
+    template_str = '{0}({1}, {2})'
+
+    args_str = repr(args)[1:-1]
+    kwargs_str = ', '.join('%s=%s' % (k, v)
+                           for k, v in kwargs.items())
+    return template_str.format(function_name, args_str,
+                               kwargs_str)
+
+
+def filter_args(func, ignore_lst, args=(), kwargs=dict()):
+    """ Filters the given args and kwargs using a list of arguments to
+        ignore, and a function specification.
+
+        Parameters
+        ----------
+        func: callable
+            Function giving the argument specification
+        ignore_lst: list of strings
+            List of arguments to ignore (either a name of an argument
+            in the function spec, or '*', or '**')
+        *args: list
+            Positional arguments passed to the function.
+        **kwargs: dict
+            Keyword arguments passed to the function
+
+        Returns
+        -------
+        filtered_args: list
+            List of filtered positional and keyword arguments.
+    """
+    args = list(args)
+    if isinstance(ignore_lst, str):
+        # Catch a common mistake
+        raise ValueError(
+            'ignore_lst must be a list of parameters to ignore '
+            '%s (type %s) was given' % (ignore_lst, type(ignore_lst)))
+    # Special case for functools.partial objects
+    if (not inspect.ismethod(func) and not inspect.isfunction(func)):
+        if ignore_lst:
+            warnings.warn('Cannot inspect object %s, ignore list will '
+                          'not work.' % func, stacklevel=2)
+        return {'*': args, '**': kwargs}
+    arg_sig = inspect.signature(func)
+    arg_names = []
+    arg_defaults = []
+    arg_kwonlyargs = []
+    arg_varargs = None
+    arg_varkw = None
+    for param in arg_sig.parameters.values():
+        if param.kind is param.POSITIONAL_OR_KEYWORD:
+            arg_names.append(param.name)
+        elif param.kind is param.KEYWORD_ONLY:
+            arg_names.append(param.name)
+            arg_kwonlyargs.append(param.name)
+        elif param.kind is param.VAR_POSITIONAL:
+            arg_varargs = param.name
+        elif param.kind is param.VAR_KEYWORD:
+            arg_varkw = param.name
+        if param.default is not param.empty:
+            arg_defaults.append(param.default)
+    if inspect.ismethod(func):
+        # First argument is 'self', it has been removed by Python
+        # we need to add it back:
+        args = [func.__self__, ] + args
+        # func is an instance method, inspect.signature(func) does not
+        # include self, we need to fetch it from the class method, i.e
+        # func.__func__
+        class_method_sig = inspect.signature(func.__func__)
+        self_name = next(iter(class_method_sig.parameters))
+        arg_names = [self_name] + arg_names
+    # XXX: Maybe I need an inspect.isbuiltin to detect C-level methods, such
+    # as on ndarrays.
+
+    _, name = get_func_name(func, resolv_alias=False)
+    arg_dict = dict()
+    arg_position = -1
+    for arg_position, arg_name in enumerate(arg_names):
+        if arg_position < len(args):
+            # Positional argument or keyword argument given as positional
+            if arg_name not in arg_kwonlyargs:
+                arg_dict[arg_name] = args[arg_position]
+            else:
+                raise ValueError(
+                    "Keyword-only parameter '%s' was passed as "
+                    'positional parameter for %s:\n'
+                    '     %s was called.'
+                    % (arg_name,
+                       _signature_str(name, arg_sig),
+                       _function_called_str(name, args, kwargs))
+                )
+
+        else:
+            position = arg_position - len(arg_names)
+            if arg_name in kwargs:
+                arg_dict[arg_name] = kwargs[arg_name]
+            else:
+                try:
+                    arg_dict[arg_name] = arg_defaults[position]
+                except (IndexError, KeyError) as e:
+                    # Missing argument
+                    raise ValueError(
+                        'Wrong number of arguments for %s:\n'
+                        '     %s was called.'
+                        % (_signature_str(name, arg_sig),
+                           _function_called_str(name, args, kwargs))
+                    ) from e
+
+    varkwargs = dict()
+    for arg_name, arg_value in sorted(kwargs.items()):
+        if arg_name in arg_dict:
+            arg_dict[arg_name] = arg_value
+        elif arg_varkw is not None:
+            varkwargs[arg_name] = arg_value
+        else:
+            raise TypeError("Ignore list for %s() contains an unexpected "
+                            "keyword argument '%s'" % (name, arg_name))
+
+    if arg_varkw is not None:
+        arg_dict['**'] = varkwargs
+    if arg_varargs is not None:
+        varargs = args[arg_position + 1:]
+        arg_dict['*'] = varargs
+
+    # Now remove the arguments to be ignored
+    for item in ignore_lst:
+        if item in arg_dict:
+            arg_dict.pop(item)
+        else:
+            raise ValueError("Ignore list: argument '%s' is not defined for "
+                             "function %s"
+                             % (item,
+                                _signature_str(name, arg_sig))
+                             )
+    # XXX: Return a sorted list of pairs?
+    return arg_dict
+
+
+def _format_arg(arg):
+    formatted_arg = pformat(arg, indent=2)
+    if len(formatted_arg) > 1500:
+        formatted_arg = '%s...' % formatted_arg[:700]
+    return formatted_arg
+
+
+def format_signature(func, *args, **kwargs):
+    # XXX: Should this use inspect.formatargvalues/formatargspec?
+    module, name = get_func_name(func)
+    module = [m for m in module if m]
+    if module:
+        module.append(name)
+        module_path = '.'.join(module)
+    else:
+        module_path = name
+    arg_str = list()
+    previous_length = 0
+    for arg in args:
+        formatted_arg = _format_arg(arg)
+        if previous_length > 80:
+            formatted_arg = '\n%s' % formatted_arg
+        previous_length = len(formatted_arg)
+        arg_str.append(formatted_arg)
+    arg_str.extend(['%s=%s' % (v, _format_arg(i)) for v, i in kwargs.items()])
+    arg_str = ', '.join(arg_str)
+
+    signature = '%s(%s)' % (name, arg_str)
+    return module_path, signature
+
+
+def format_call(func, args, kwargs, object_name="Memory"):
+    """ Returns a nicely formatted statement displaying the function
+        call with the given arguments.
+    """
+    path, signature = format_signature(func, *args, **kwargs)
+    msg = '%s\n[%s] Calling %s...\n%s' % (80 * '_', object_name,
+                                          path, signature)
+    return msg
+    # XXX: Not using logging framework
+    # self.debug(msg)

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/joblib/hashing.py

@@ -0,0 +1,266 @@
+"""
+Fast cryptographic hash of Python objects, with a special case for fast
+hashing of numpy arrays.
+"""
+
+# Author: Gael Varoquaux <gael dot varoquaux at normalesup dot org>
+# Copyright (c) 2009 Gael Varoquaux
+# License: BSD Style, 3 clauses.
+
+import pickle
+import hashlib
+import sys
+import types
+import struct
+import io
+import decimal
+
+
+Pickler = pickle._Pickler
+
+
+class _ConsistentSet(object):
+    """ Class used to ensure the hash of Sets is preserved
+        whatever the order of its items.
+    """
+    def __init__(self, set_sequence):
+        # Forces order of elements in set to ensure consistent hash.
+        try:
+            # Trying first to order the set assuming the type of elements is
+            # consistent and orderable.
+            # This fails on python 3 when elements are unorderable
+            # but we keep it in a try as it's faster.
+            self._sequence = sorted(set_sequence)
+        except (TypeError, decimal.InvalidOperation):
+            # If elements are unorderable, sorting them using their hash.
+            # This is slower but works in any case.
+            self._sequence = sorted((hash(e) for e in set_sequence))
+
+
+class _MyHash(object):
+    """ Class used to hash objects that won't normally pickle """
+
+    def __init__(self, *args):
+        self.args = args
+
+
+class Hasher(Pickler):
+    """ A subclass of pickler, to do cryptographic hashing, rather than
+        pickling.
+    """
+
+    def __init__(self, hash_name='md5'):
+        self.stream = io.BytesIO()
+        # By default we want a pickle protocol that only changes with
+        # the major python version and not the minor one
+        protocol = 3
+        Pickler.__init__(self, self.stream, protocol=protocol)
+        # Initialise the hash obj
+        self._hash = hashlib.new(hash_name)
+
+    def hash(self, obj, return_digest=True):
+        try:
+            self.dump(obj)
+        except pickle.PicklingError as e:
+            e.args += ('PicklingError while hashing %r: %r' % (obj, e),)
+            raise
+        dumps = self.stream.getvalue()
+        self._hash.update(dumps)
+        if return_digest:
+            return self._hash.hexdigest()
+
+    def save(self, obj):
+        if isinstance(obj, (types.MethodType, type({}.pop))):
+            # the Pickler cannot pickle instance methods; here we decompose
+            # them into components that make them uniquely identifiable
+            if hasattr(obj, '__func__'):
+                func_name = obj.__func__.__name__
+            else:
+                func_name = obj.__name__
+            inst = obj.__self__
+            if type(inst) == type(pickle):
+                obj = _MyHash(func_name, inst.__name__)
+            elif inst is None:
+                # type(None) or type(module) do not pickle
+                obj = _MyHash(func_name, inst)
+            else:
+                cls = obj.__self__.__class__
+                obj = _MyHash(func_name, inst, cls)
+        Pickler.save(self, obj)
+
+    def memoize(self, obj):
+        # We want hashing to be sensitive to value instead of reference.
+        # For example we want ['aa', 'aa'] and ['aa', 'aaZ'[:2]]
+        # to hash to the same value and that's why we disable memoization
+        # for strings
+        if isinstance(obj, (bytes, str)):
+            return
+        Pickler.memoize(self, obj)
+
+    # The dispatch table of the pickler is not accessible in Python
+    # 3, as these lines are only bugware for IPython, we skip them.
+    def save_global(self, obj, name=None, pack=struct.pack):
+        # We have to override this method in order to deal with objects
+        # defined interactively in IPython that are not injected in
+        # __main__
+        kwargs = dict(name=name, pack=pack)
+        del kwargs['pack']
+        try:
+            Pickler.save_global(self, obj, **kwargs)
+        except pickle.PicklingError:
+            Pickler.save_global(self, obj, **kwargs)
+            module = getattr(obj, "__module__", None)
+            if module == '__main__':
+                my_name = name
+                if my_name is None:
+                    my_name = obj.__name__
+                mod = sys.modules[module]
+                if not hasattr(mod, my_name):
+                    # IPython doesn't inject the variables define
+                    # interactively in __main__
+                    setattr(mod, my_name, obj)
+
+    dispatch = Pickler.dispatch.copy()
+    # builtin
+    dispatch[type(len)] = save_global
+    # type
+    dispatch[type(object)] = save_global
+    # classobj
+    dispatch[type(Pickler)] = save_global
+    # function
+    dispatch[type(pickle.dump)] = save_global
+
+    def _batch_setitems(self, items):
+        # forces order of keys in dict to ensure consistent hash.
+        try:
+            # Trying first to compare dict assuming the type of keys is
+            # consistent and orderable.
+            # This fails on python 3 when keys are unorderable
+            # but we keep it in a try as it's faster.
+            Pickler._batch_setitems(self, iter(sorted(items)))
+        except TypeError:
+            # If keys are unorderable, sorting them using their hash. This is
+            # slower but works in any case.
+            Pickler._batch_setitems(self, iter(sorted((hash(k), v)
+                                                      for k, v in items)))
+
+    def save_set(self, set_items):
+        # forces order of items in Set to ensure consistent hash
+        Pickler.save(self, _ConsistentSet(set_items))
+
+    dispatch[type(set())] = save_set
+
+
+class NumpyHasher(Hasher):
+    """ Special case the hasher for when numpy is loaded.
+    """
+
+    def __init__(self, hash_name='md5', coerce_mmap=False):
+        """
+            Parameters
+            ----------
+            hash_name: string
+                The hash algorithm to be used
+            coerce_mmap: boolean
+                Make no difference between np.memmap and np.ndarray
+                objects.
+        """
+        self.coerce_mmap = coerce_mmap
+        Hasher.__init__(self, hash_name=hash_name)
+        # delayed import of numpy, to avoid tight coupling
+        import numpy as np
+        self.np = np
+        if hasattr(np, 'getbuffer'):
+            self._getbuffer = np.getbuffer
+        else:
+            self._getbuffer = memoryview
+
+    def save(self, obj):
+        """ Subclass the save method, to hash ndarray subclass, rather
+            than pickling them. Off course, this is a total abuse of
+            the Pickler class.
+        """
+        if isinstance(obj, self.np.ndarray) and not obj.dtype.hasobject:
+            # Compute a hash of the object
+            # The update function of the hash requires a c_contiguous buffer.
+            if obj.shape == ():
+                # 0d arrays need to be flattened because viewing them as bytes
+                # raises a ValueError exception.
+                obj_c_contiguous = obj.flatten()
+            elif obj.flags.c_contiguous:
+                obj_c_contiguous = obj
+            elif obj.flags.f_contiguous:
+                obj_c_contiguous = obj.T
+            else:
+                # Cater for non-single-segment arrays: this creates a
+                # copy, and thus aleviates this issue.
+                # XXX: There might be a more efficient way of doing this
+                obj_c_contiguous = obj.flatten()
+
+            # memoryview is not supported for some dtypes, e.g. datetime64, see
+            # https://github.com/numpy/numpy/issues/4983. The
+            # workaround is to view the array as bytes before
+            # taking the memoryview.
+            self._hash.update(
+                self._getbuffer(obj_c_contiguous.view(self.np.uint8)))
+
+            # We store the class, to be able to distinguish between
+            # Objects with the same binary content, but different
+            # classes.
+            if self.coerce_mmap and isinstance(obj, self.np.memmap):
+                # We don't make the difference between memmap and
+                # normal ndarrays, to be able to reload previously
+                # computed results with memmap.
+                klass = self.np.ndarray
+            else:
+                klass = obj.__class__
+            # We also return the dtype and the shape, to distinguish
+            # different views on the same data with different dtypes.
+
+            # The object will be pickled by the pickler hashed at the end.
+            obj = (klass, ('HASHED', obj.dtype, obj.shape, obj.strides))
+        elif isinstance(obj, self.np.dtype):
+            # numpy.dtype consistent hashing is tricky to get right. This comes
+            # from the fact that atomic np.dtype objects are interned:
+            # ``np.dtype('f4') is np.dtype('f4')``. The situation is
+            # complicated by the fact that this interning does not resist a
+            # simple pickle.load/dump roundtrip:
+            # ``pickle.loads(pickle.dumps(np.dtype('f4'))) is not
+            # np.dtype('f4') Because pickle relies on memoization during
+            # pickling, it is easy to
+            # produce different hashes for seemingly identical objects, such as
+            # ``[np.dtype('f4'), np.dtype('f4')]``
+            # and ``[np.dtype('f4'), pickle.loads(pickle.dumps('f4'))]``.
+            # To prevent memoization from interfering with hashing, we isolate
+            # the serialization (and thus the pickle memoization) of each dtype
+            # using each time a different ``pickle.dumps`` call unrelated to
+            # the current Hasher instance.
+            self._hash.update("_HASHED_DTYPE".encode('utf-8'))
+            self._hash.update(pickle.dumps(obj))
+            return
+        Hasher.save(self, obj)
+
+
+def hash(obj, hash_name='md5', coerce_mmap=False):
+    """ Quick calculation of a hash to identify uniquely Python objects
+        containing numpy arrays.
+
+
+        Parameters
+        -----------
+        hash_name: 'md5' or 'sha1'
+            Hashing algorithm used. sha1 is supposedly safer, but md5 is
+            faster.
+        coerce_mmap: boolean
+            Make no difference between np.memmap and np.ndarray
+    """
+    valid_hash_names = ('md5', 'sha1')
+    if hash_name not in valid_hash_names:
+        raise ValueError("Valid options for 'hash_name' are {}. "
+                         "Got hash_name={!r} instead."
+                         .format(valid_hash_names, hash_name))
+    if 'numpy' in sys.modules:
+        hasher = NumpyHasher(hash_name=hash_name, coerce_mmap=coerce_mmap)
+    else:
+        hasher = Hasher(hash_name=hash_name)
+    return hasher.hash(obj)

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/joblib/numpy_pickle_compat.py

@@ -0,0 +1,243 @@
+"""Numpy pickle compatibility functions."""
+
+import pickle
+import os
+import zlib
+import inspect
+
+from io import BytesIO
+
+from .numpy_pickle_utils import _ZFILE_PREFIX
+from .numpy_pickle_utils import Unpickler
+from .numpy_pickle_utils import _ensure_native_byte_order
+
+def hex_str(an_int):
+    """Convert an int to an hexadecimal string."""
+    return '{:#x}'.format(an_int)
+
+
+def asbytes(s):
+    if isinstance(s, bytes):
+        return s
+    return s.encode('latin1')
+
+
+_MAX_LEN = len(hex_str(2 ** 64))
+_CHUNK_SIZE = 64 * 1024
+
+
+def read_zfile(file_handle):
+    """Read the z-file and return the content as a string.
+
+    Z-files are raw data compressed with zlib used internally by joblib
+    for persistence. Backward compatibility is not guaranteed. Do not
+    use for external purposes.
+    """
+    file_handle.seek(0)
+    header_length = len(_ZFILE_PREFIX) + _MAX_LEN
+    length = file_handle.read(header_length)
+    length = length[len(_ZFILE_PREFIX):]
+    length = int(length, 16)
+
+    # With python2 and joblib version <= 0.8.4 compressed pickle header is one
+    # character wider so we need to ignore an additional space if present.
+    # Note: the first byte of the zlib data is guaranteed not to be a
+    # space according to
+    # https://tools.ietf.org/html/rfc6713#section-2.1
+    next_byte = file_handle.read(1)
+    if next_byte != b' ':
+        # The zlib compressed data has started and we need to go back
+        # one byte
+        file_handle.seek(header_length)
+
+    # We use the known length of the data to tell Zlib the size of the
+    # buffer to allocate.
+    data = zlib.decompress(file_handle.read(), 15, length)
+    assert len(data) == length, (
+        "Incorrect data length while decompressing %s."
+        "The file could be corrupted." % file_handle)
+    return data
+
+
+def write_zfile(file_handle, data, compress=1):
+    """Write the data in the given file as a Z-file.
+
+    Z-files are raw data compressed with zlib used internally by joblib
+    for persistence. Backward compatibility is not guarantied. Do not
+    use for external purposes.
+    """
+    file_handle.write(_ZFILE_PREFIX)
+    length = hex_str(len(data))
+    # Store the length of the data
+    file_handle.write(asbytes(length.ljust(_MAX_LEN)))
+    file_handle.write(zlib.compress(asbytes(data), compress))
+
+###############################################################################
+# Utility objects for persistence.
+
+
+class NDArrayWrapper(object):
+    """An object to be persisted instead of numpy arrays.
+
+    The only thing this object does, is to carry the filename in which
+    the array has been persisted, and the array subclass.
+    """
+
+    def __init__(self, filename, subclass, allow_mmap=True):
+        """Constructor. Store the useful information for later."""
+        self.filename = filename
+        self.subclass = subclass
+        self.allow_mmap = allow_mmap
+
+    def read(self, unpickler):
+        """Reconstruct the array."""
+        filename = os.path.join(unpickler._dirname, self.filename)
+        # Load the array from the disk
+        # use getattr instead of self.allow_mmap to ensure backward compat
+        # with NDArrayWrapper instances pickled with joblib < 0.9.0
+        allow_mmap = getattr(self, 'allow_mmap', True)
+        kwargs = {}
+        if allow_mmap:
+            kwargs['mmap_mode'] = unpickler.mmap_mode
+        if "allow_pickle" in inspect.signature(unpickler.np.load).parameters:
+            # Required in numpy 1.16.3 and later to aknowledge the security
+            # risk.
+            kwargs["allow_pickle"] = True
+        array = unpickler.np.load(filename, **kwargs)
+
+        # Detect byte order mis-match and swap as needed.
+        array = _ensure_native_byte_order(array)
+
+        # Reconstruct subclasses. This does not work with old
+        # versions of numpy
+        if (hasattr(array, '__array_prepare__') and
+            self.subclass not in (unpickler.np.ndarray,
+                                  unpickler.np.memmap)):
+            # We need to reconstruct another subclass
+            new_array = unpickler.np.core.multiarray._reconstruct(
+                self.subclass, (0,), 'b')
+            return new_array.__array_prepare__(array)
+        else:
+            return array
+
+
+class ZNDArrayWrapper(NDArrayWrapper):
+    """An object to be persisted instead of numpy arrays.
+
+    This object store the Zfile filename in which
+    the data array has been persisted, and the meta information to
+    retrieve it.
+    The reason that we store the raw buffer data of the array and
+    the meta information, rather than array representation routine
+    (tobytes) is that it enables us to use completely the strided
+    model to avoid memory copies (a and a.T store as fast). In
+    addition saving the heavy information separately can avoid
+    creating large temporary buffers when unpickling data with
+    large arrays.
+    """
+
+    def __init__(self, filename, init_args, state):
+        """Constructor. Store the useful information for later."""
+        self.filename = filename
+        self.state = state
+        self.init_args = init_args
+
+    def read(self, unpickler):
+        """Reconstruct the array from the meta-information and the z-file."""
+        # Here we a simply reproducing the unpickling mechanism for numpy
+        # arrays
+        filename = os.path.join(unpickler._dirname, self.filename)
+        array = unpickler.np.core.multiarray._reconstruct(*self.init_args)
+        with open(filename, 'rb') as f:
+            data = read_zfile(f)
+        state = self.state + (data,)
+        array.__setstate__(state)
+        return array
+
+
+class ZipNumpyUnpickler(Unpickler):
+    """A subclass of the Unpickler to unpickle our numpy pickles."""
+
+    dispatch = Unpickler.dispatch.copy()
+
+    def __init__(self, filename, file_handle, mmap_mode=None):
+        """Constructor."""
+        self._filename = os.path.basename(filename)
+        self._dirname = os.path.dirname(filename)
+        self.mmap_mode = mmap_mode
+        self.file_handle = self._open_pickle(file_handle)
+        Unpickler.__init__(self, self.file_handle)
+        try:
+            import numpy as np
+        except ImportError:
+            np = None
+        self.np = np
+
+    def _open_pickle(self, file_handle):
+        return BytesIO(read_zfile(file_handle))
+
+    def load_build(self):
+        """Set the state of a newly created object.
+
+        We capture it to replace our place-holder objects,
+        NDArrayWrapper, by the array we are interested in. We
+        replace them directly in the stack of pickler.
+        """
+        Unpickler.load_build(self)
+        if isinstance(self.stack[-1], NDArrayWrapper):
+            if self.np is None:
+                raise ImportError("Trying to unpickle an ndarray, "
+                                  "but numpy didn't import correctly")
+            nd_array_wrapper = self.stack.pop()
+            array = nd_array_wrapper.read(self)
+            self.stack.append(array)
+
+    dispatch[pickle.BUILD[0]] = load_build
+
+
+def load_compatibility(filename):
+    """Reconstruct a Python object from a file persisted with joblib.dump.
+
+    This function ensures the compatibility with joblib old persistence format
+    (<= 0.9.3).
+
+    Parameters
+    -----------
+    filename: string
+        The name of the file from which to load the object
+
+    Returns
+    -------
+    result: any Python object
+        The object stored in the file.
+
+    See Also
+    --------
+    joblib.dump : function to save an object
+
+    Notes
+    -----
+
+    This function can load numpy array files saved separately during the
+    dump.
+    """
+    with open(filename, 'rb') as file_handle:
+        # We are careful to open the file handle early and keep it open to
+        # avoid race-conditions on renames. That said, if data is stored in
+        # companion files, moving the directory will create a race when
+        # joblib tries to access the companion files.
+        unpickler = ZipNumpyUnpickler(filename, file_handle=file_handle)
+        try:
+            obj = unpickler.load()
+        except UnicodeDecodeError as exc:
+            # More user-friendly error message
+            new_exc = ValueError(
+                'You may be trying to read with '
+                'python 3 a joblib pickle generated with python 2. '
+                'This feature is not supported by joblib.')
+            new_exc.__cause__ = exc
+            raise new_exc
+        finally:
+            if hasattr(unpickler, 'file_handle'):
+                unpickler.file_handle.close()
+        return obj

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/joblib/numpy_pickle_utils.py

@@ -0,0 +1,253 @@
+"""Utilities for fast persistence of big data, with optional compression."""
+
+# Author: Gael Varoquaux <gael dot varoquaux at normalesup dot org>
+# Copyright (c) 2009 Gael Varoquaux
+# License: BSD Style, 3 clauses.
+
+import pickle
+import io
+import sys
+import warnings
+import contextlib
+
+from .compressor import _ZFILE_PREFIX
+from .compressor import _COMPRESSORS
+
+try:
+    import numpy as np
+except ImportError:
+    np = None
+
+Unpickler = pickle._Unpickler
+Pickler = pickle._Pickler
+xrange = range
+
+
+try:
+    # The python standard library can be built without bz2 so we make bz2
+    # usage optional.
+    # see https://github.com/scikit-learn/scikit-learn/issues/7526 for more
+    # details.
+    import bz2
+except ImportError:
+    bz2 = None
+
+# Buffer size used in io.BufferedReader and io.BufferedWriter
+_IO_BUFFER_SIZE = 1024 ** 2
+
+
+def _is_raw_file(fileobj):
+    """Check if fileobj is a raw file object, e.g created with open."""
+    fileobj = getattr(fileobj, 'raw', fileobj)
+    return isinstance(fileobj, io.FileIO)
+
+
+def _get_prefixes_max_len():
+    # Compute the max prefix len of registered compressors.
+    prefixes = [len(compressor.prefix) for compressor in _COMPRESSORS.values()]
+    prefixes += [len(_ZFILE_PREFIX)]
+    return max(prefixes)
+
+
+def _is_numpy_array_byte_order_mismatch(array):
+    """Check if numpy array is having byte order mis-match"""
+    return ((sys.byteorder == 'big' and
+             (array.dtype.byteorder == '<' or
+              (array.dtype.byteorder == '|' and array.dtype.fields and
+               all(e[0].byteorder == '<'
+                   for e in array.dtype.fields.values())))) or
+            (sys.byteorder == 'little' and
+             (array.dtype.byteorder == '>' or
+              (array.dtype.byteorder == '|' and array.dtype.fields and
+               all(e[0].byteorder == '>'
+                   for e in array.dtype.fields.values())))))
+
+
+def _ensure_native_byte_order(array):
+    """Use the byte order of the host while preserving values
+
+    Does nothing if array already uses the system byte order.
+    """
+    if _is_numpy_array_byte_order_mismatch(array):
+        array = array.byteswap().newbyteorder('=')
+    return array
+
+
+###############################################################################
+# Cache file utilities
+def _detect_compressor(fileobj):
+    """Return the compressor matching fileobj.
+
+    Parameters
+    ----------
+    fileobj: file object
+
+    Returns
+    -------
+    str in {'zlib', 'gzip', 'bz2', 'lzma', 'xz', 'compat', 'not-compressed'}
+    """
+    # Read the magic number in the first bytes of the file.
+    max_prefix_len = _get_prefixes_max_len()
+    if hasattr(fileobj, 'peek'):
+        # Peek allows to read those bytes without moving the cursor in the
+        # file whic.
+        first_bytes = fileobj.peek(max_prefix_len)
+    else:
+        # Fallback to seek if the fileobject is not peekable.
+        first_bytes = fileobj.read(max_prefix_len)
+        fileobj.seek(0)
+
+    if first_bytes.startswith(_ZFILE_PREFIX):
+        return "compat"
+    else:
+        for name, compressor in _COMPRESSORS.items():
+            if first_bytes.startswith(compressor.prefix):
+                return name
+
+    return "not-compressed"
+
+
+def _buffered_read_file(fobj):
+    """Return a buffered version of a read file object."""
+    return io.BufferedReader(fobj, buffer_size=_IO_BUFFER_SIZE)
+
+
+def _buffered_write_file(fobj):
+    """Return a buffered version of a write file object."""
+    return io.BufferedWriter(fobj, buffer_size=_IO_BUFFER_SIZE)
+
+
+@contextlib.contextmanager
+def _read_fileobject(fileobj, filename, mmap_mode=None):
+    """Utility function opening the right fileobject from a filename.
+
+    The magic number is used to choose between the type of file object to open:
+    * regular file object (default)
+    * zlib file object
+    * gzip file object
+    * bz2 file object
+    * lzma file object (for xz and lzma compressor)
+
+    Parameters
+    ----------
+    fileobj: file object
+    compressor: str in {'zlib', 'gzip', 'bz2', 'lzma', 'xz', 'compat',
+                        'not-compressed'}
+    filename: str
+        filename path corresponding to the fileobj parameter.
+    mmap_mode: str
+        memory map mode that should be used to open the pickle file. This
+        parameter is useful to verify that the user is not trying to one with
+        compression. Default: None.
+
+    Returns
+    -------
+        a file like object
+
+    """
+    # Detect if the fileobj contains compressed data.
+    compressor = _detect_compressor(fileobj)
+
+    if compressor == 'compat':
+        # Compatibility with old pickle mode: simply return the input
+        # filename "as-is" and let the compatibility function be called by the
+        # caller.
+        warnings.warn("The file '%s' has been generated with a joblib "
+                      "version less than 0.10. "
+                      "Please regenerate this pickle file." % filename,
+                      DeprecationWarning, stacklevel=2)
+        yield filename
+    else:
+        if compressor in _COMPRESSORS:
+            # based on the compressor detected in the file, we open the
+            # correct decompressor file object, wrapped in a buffer.
+            compressor_wrapper = _COMPRESSORS[compressor]
+            inst = compressor_wrapper.decompressor_file(fileobj)
+            fileobj = _buffered_read_file(inst)
+
+        # Checking if incompatible load parameters with the type of file:
+        # mmap_mode cannot be used with compressed file or in memory buffers
+        # such as io.BytesIO.
+        if mmap_mode is not None:
+            if isinstance(fileobj, io.BytesIO):
+                warnings.warn('In memory persistence is not compatible with '
+                              'mmap_mode "%(mmap_mode)s" flag passed. '
+                              'mmap_mode option will be ignored.'
+                              % locals(), stacklevel=2)
+            elif compressor != 'not-compressed':
+                warnings.warn('mmap_mode "%(mmap_mode)s" is not compatible '
+                              'with compressed file %(filename)s. '
+                              '"%(mmap_mode)s" flag will be ignored.'
+                              % locals(), stacklevel=2)
+            elif not _is_raw_file(fileobj):
+                warnings.warn('"%(fileobj)r" is not a raw file, mmap_mode '
+                              '"%(mmap_mode)s" flag will be ignored.'
+                              % locals(), stacklevel=2)
+
+        yield fileobj
+
+
+def _write_fileobject(filename, compress=("zlib", 3)):
+    """Return the right compressor file object in write mode."""
+    compressmethod = compress[0]
+    compresslevel = compress[1]
+
+    if compressmethod in _COMPRESSORS.keys():
+        file_instance = _COMPRESSORS[compressmethod].compressor_file(
+            filename, compresslevel=compresslevel)
+        return _buffered_write_file(file_instance)
+    else:
+        file_instance = _COMPRESSORS['zlib'].compressor_file(
+            filename, compresslevel=compresslevel)
+        return _buffered_write_file(file_instance)
+
+
+# Utility functions/variables from numpy required for writing arrays.
+# We need at least the functions introduced in version 1.9 of numpy. Here,
+# we use the ones from numpy 1.10.2.
+BUFFER_SIZE = 2 ** 18  # size of buffer for reading npz files in bytes
+
+
+def _read_bytes(fp, size, error_template="ran out of data"):
+    """Read from file-like object until size bytes are read.
+
+    TODO python2_drop: is it still needed? The docstring mentions python 2.6
+    and it looks like this can be at least simplified ...
+
+    Raises ValueError if not EOF is encountered before size bytes are read.
+    Non-blocking objects only supported if they derive from io objects.
+
+    Required as e.g. ZipExtFile in python 2.6 can return less data than
+    requested.
+
+    This function was taken from numpy/lib/format.py in version 1.10.2.
+
+    Parameters
+    ----------
+    fp: file-like object
+    size: int
+    error_template: str
+
+    Returns
+    -------
+    a bytes object
+        The data read in bytes.
+
+    """
+    data = bytes()
+    while True:
+        # io files (default in python3) return None or raise on
+        # would-block, python2 file will truncate, probably nothing can be
+        # done about that.  note that regular files can't be non-blocking
+        try:
+            r = fp.read(size - len(data))
+            data += r
+            if len(r) == 0 or len(data) == size:
+                break
+        except io.BlockingIOError:
+            pass
+    if len(data) != size:
+        msg = "EOF: reading %s, expected %d bytes got %d"
+        raise ValueError(msg % (error_template, size, len(data)))
+    else:
+        return data

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/joblib/parallel.py

@@ -0,0 +1,1074 @@
+"""
+Helpers for embarrassingly parallel code.
+"""
+# Author: Gael Varoquaux < gael dot varoquaux at normalesup dot org >
+# Copyright: 2010, Gael Varoquaux
+# License: BSD 3 clause
+
+from __future__ import division
+
+import os
+import sys
+from math import sqrt
+import functools
+import time
+import threading
+import itertools
+from uuid import uuid4
+from numbers import Integral
+import warnings
+import queue
+
+from ._multiprocessing_helpers import mp
+
+from .logger import Logger, short_format_time
+from .disk import memstr_to_bytes
+from ._parallel_backends import (FallbackToBackend, MultiprocessingBackend,
+                                 ThreadingBackend, SequentialBackend,
+                                 LokyBackend)
+from .externals.cloudpickle import dumps, loads
+from .externals import loky
+
+# Make sure that those two classes are part of the public joblib.parallel API
+# so that 3rd party backend implementers can import them from here.
+from ._parallel_backends import AutoBatchingMixin  # noqa
+from ._parallel_backends import ParallelBackendBase  # noqa
+
+
+BACKENDS = {
+    'multiprocessing': MultiprocessingBackend,
+    'threading': ThreadingBackend,
+    'sequential': SequentialBackend,
+    'loky': LokyBackend,
+}
+# name of the backend used by default by Parallel outside of any context
+# managed by ``parallel_backend``.
+DEFAULT_BACKEND = 'loky'
+DEFAULT_N_JOBS = 1
+DEFAULT_THREAD_BACKEND = 'threading'
+
+# Thread local value that can be overridden by the ``parallel_backend`` context
+# manager
+_backend = threading.local()
+
+VALID_BACKEND_HINTS = ('processes', 'threads', None)
+VALID_BACKEND_CONSTRAINTS = ('sharedmem', None)
+
+
+def _register_dask():
+    """ Register Dask Backend if called with parallel_backend("dask") """
+    try:
+        from ._dask import DaskDistributedBackend
+        register_parallel_backend('dask', DaskDistributedBackend)
+    except ImportError as e:
+        msg = ("To use the dask.distributed backend you must install both "
+               "the `dask` and distributed modules.\n\n"
+               "See https://dask.pydata.org/en/latest/install.html for more "
+               "information.")
+        raise ImportError(msg) from e
+
+
+EXTERNAL_BACKENDS = {
+    'dask': _register_dask,
+}
+
+
+def get_active_backend(prefer=None, require=None, verbose=0):
+    """Return the active default backend"""
+    if prefer not in VALID_BACKEND_HINTS:
+        raise ValueError("prefer=%r is not a valid backend hint, "
+                         "expected one of %r" % (prefer, VALID_BACKEND_HINTS))
+    if require not in VALID_BACKEND_CONSTRAINTS:
+        raise ValueError("require=%r is not a valid backend constraint, "
+                         "expected one of %r"
+                         % (require, VALID_BACKEND_CONSTRAINTS))
+
+    if prefer == 'processes' and require == 'sharedmem':
+        raise ValueError("prefer == 'processes' and require == 'sharedmem'"
+                         " are inconsistent settings")
+    backend_and_jobs = getattr(_backend, 'backend_and_jobs', None)
+    if backend_and_jobs is not None:
+        # Try to use the backend set by the user with the context manager.
+        backend, n_jobs = backend_and_jobs
+        nesting_level = backend.nesting_level
+        supports_sharedmem = getattr(backend, 'supports_sharedmem', False)
+        if require == 'sharedmem' and not supports_sharedmem:
+            # This backend does not match the shared memory constraint:
+            # fallback to the default thead-based backend.
+            sharedmem_backend = BACKENDS[DEFAULT_THREAD_BACKEND](
+                nesting_level=nesting_level)
+            if verbose >= 10:
+                print("Using %s as joblib.Parallel backend instead of %s "
+                      "as the latter does not provide shared memory semantics."
+                      % (sharedmem_backend.__class__.__name__,
+                         backend.__class__.__name__))
+            return sharedmem_backend, DEFAULT_N_JOBS
+        else:
+            return backend_and_jobs
+
+    # We are outside of the scope of any parallel_backend context manager,
+    # create the default backend instance now.
+    backend = BACKENDS[DEFAULT_BACKEND](nesting_level=0)
+    supports_sharedmem = getattr(backend, 'supports_sharedmem', False)
+    uses_threads = getattr(backend, 'uses_threads', False)
+    if ((require == 'sharedmem' and not supports_sharedmem) or
+            (prefer == 'threads' and not uses_threads)):
+        # Make sure the selected default backend match the soft hints and
+        # hard constraints:
+        backend = BACKENDS[DEFAULT_THREAD_BACKEND](nesting_level=0)
+    return backend, DEFAULT_N_JOBS
+
+
+class parallel_backend(object):
+    """Change the default backend used by Parallel inside a with block.
+
+    If ``backend`` is a string it must match a previously registered
+    implementation using the ``register_parallel_backend`` function.
+
+    By default the following backends are available:
+
+    - 'loky': single-host, process-based parallelism (used by default),
+    - 'threading': single-host, thread-based parallelism,
+    - 'multiprocessing': legacy single-host, process-based parallelism.
+
+    'loky' is recommended to run functions that manipulate Python objects.
+    'threading' is a low-overhead alternative that is most efficient for
+    functions that release the Global Interpreter Lock: e.g. I/O-bound code or
+    CPU-bound code in a few calls to native code that explicitly releases the
+    GIL.
+
+    In addition, if the `dask` and `distributed` Python packages are installed,
+    it is possible to use the 'dask' backend for better scheduling of nested
+    parallel calls without over-subscription and potentially distribute
+    parallel calls over a networked cluster of several hosts.
+
+    It is also possible to use the distributed 'ray' backend for distributing
+    the workload to a cluster of nodes. To use the 'ray' joblib backend add
+    the following lines::
+
+     >>> from ray.util.joblib import register_ray  # doctest: +SKIP
+     >>> register_ray()  # doctest: +SKIP
+     >>> with parallel_backend("ray"):  # doctest: +SKIP
+     ...     print(Parallel()(delayed(neg)(i + 1) for i in range(5)))
+     [-1, -2, -3, -4, -5]
+
+    Alternatively the backend can be passed directly as an instance.
+
+    By default all available workers will be used (``n_jobs=-1``) unless the
+    caller passes an explicit value for the ``n_jobs`` parameter.
+
+    This is an alternative to passing a ``backend='backend_name'`` argument to
+    the ``Parallel`` class constructor. It is particularly useful when calling
+    into library code that uses joblib internally but does not expose the
+    backend argument in its own API.
+
+    >>> from operator import neg
+    >>> with parallel_backend('threading'):
+    ...     print(Parallel()(delayed(neg)(i + 1) for i in range(5)))
+    ...
+    [-1, -2, -3, -4, -5]
+
+    Warning: this function is experimental and subject to change in a future
+    version of joblib.
+
+    Joblib also tries to limit the oversubscription by limiting the number of
+    threads usable in some third-party library threadpools like OpenBLAS, MKL
+    or OpenMP. The default limit in each worker is set to
+    ``max(cpu_count() // effective_n_jobs, 1)`` but this limit can be
+    overwritten with the ``inner_max_num_threads`` argument which will be used
+    to set this limit in the child processes.
+
+    .. versionadded:: 0.10
+
+    """
+    def __init__(self, backend, n_jobs=-1, inner_max_num_threads=None,
+                 **backend_params):
+        if isinstance(backend, str):
+            if backend not in BACKENDS and backend in EXTERNAL_BACKENDS:
+                register = EXTERNAL_BACKENDS[backend]
+                register()
+
+            backend = BACKENDS[backend](**backend_params)
+
+        if inner_max_num_threads is not None:
+            msg = ("{} does not accept setting the inner_max_num_threads "
+                   "argument.".format(backend.__class__.__name__))
+            assert backend.supports_inner_max_num_threads, msg
+            backend.inner_max_num_threads = inner_max_num_threads
+
+        # If the nesting_level of the backend is not set previously, use the
+        # nesting level from the previous active_backend to set it
+        current_backend_and_jobs = getattr(_backend, 'backend_and_jobs', None)
+        if backend.nesting_level is None:
+            if current_backend_and_jobs is None:
+                nesting_level = 0
+            else:
+                nesting_level = current_backend_and_jobs[0].nesting_level
+
+            backend.nesting_level = nesting_level
+
+        # Save the backends info and set the active backend
+        self.old_backend_and_jobs = current_backend_and_jobs
+        self.new_backend_and_jobs = (backend, n_jobs)
+
+        _backend.backend_and_jobs = (backend, n_jobs)
+
+    def __enter__(self):
+        return self.new_backend_and_jobs
+
+    def __exit__(self, type, value, traceback):
+        self.unregister()
+
+    def unregister(self):
+        if self.old_backend_and_jobs is None:
+            if getattr(_backend, 'backend_and_jobs', None) is not None:
+                del _backend.backend_and_jobs
+        else:
+            _backend.backend_and_jobs = self.old_backend_and_jobs
+
+
+# Under Linux or OS X the default start method of multiprocessing
+# can cause third party libraries to crash. Under Python 3.4+ it is possible
+# to set an environment variable to switch the default start method from
+# 'fork' to 'forkserver' or 'spawn' to avoid this issue albeit at the cost
+# of causing semantic changes and some additional pool instantiation overhead.
+DEFAULT_MP_CONTEXT = None
+if hasattr(mp, 'get_context'):
+    method = os.environ.get('JOBLIB_START_METHOD', '').strip() or None
+    if method is not None:
+        DEFAULT_MP_CONTEXT = mp.get_context(method=method)
+
+
+class BatchedCalls(object):
+    """Wrap a sequence of (func, args, kwargs) tuples as a single callable"""
+
+    def __init__(self, iterator_slice, backend_and_jobs, reducer_callback=None,
+                 pickle_cache=None):
+        self.items = list(iterator_slice)
+        self._size = len(self.items)
+        self._reducer_callback = reducer_callback
+        if isinstance(backend_and_jobs, tuple):
+            self._backend, self._n_jobs = backend_and_jobs
+        else:
+            # this is for backward compatibility purposes. Before 0.12.6,
+            # nested backends were returned without n_jobs indications.
+            self._backend, self._n_jobs = backend_and_jobs, None
+        self._pickle_cache = pickle_cache if pickle_cache is not None else {}
+
+    def __call__(self):
+        # Set the default nested backend to self._backend but do not set the
+        # change the default number of processes to -1
+        with parallel_backend(self._backend, n_jobs=self._n_jobs):
+            return [func(*args, **kwargs)
+                    for func, args, kwargs in self.items]
+
+    def __reduce__(self):
+        if self._reducer_callback is not None:
+            self._reducer_callback()
+        # no need pickle the callback.
+        return (
+            BatchedCalls,
+            (self.items, (self._backend, self._n_jobs), None,
+             self._pickle_cache)
+        )
+
+    def __len__(self):
+        return self._size
+
+
+###############################################################################
+# CPU count that works also when multiprocessing has been disabled via
+# the JOBLIB_MULTIPROCESSING environment variable
+def cpu_count(only_physical_cores=False):
+    """Return the number of CPUs.
+
+    This delegates to loky.cpu_count that takes into account additional
+    constraints such as Linux CFS scheduler quotas (typically set by container
+    runtimes such as docker) and CPU affinity (for instance using the taskset
+    command on Linux).
+
+    If only_physical_cores is True, do not take hyperthreading / SMT logical
+    cores into account.
+    """
+    if mp is None:
+        return 1
+
+    return loky.cpu_count(only_physical_cores=only_physical_cores)
+
+
+###############################################################################
+# For verbosity
+
+def _verbosity_filter(index, verbose):
+    """ Returns False for indices increasingly apart, the distance
+        depending on the value of verbose.
+
+        We use a lag increasing as the square of index
+    """
+    if not verbose:
+        return True
+    elif verbose > 10:
+        return False
+    if index == 0:
+        return False
+    verbose = .5 * (11 - verbose) ** 2
+    scale = sqrt(index / verbose)
+    next_scale = sqrt((index + 1) / verbose)
+    return (int(next_scale) == int(scale))
+
+
+###############################################################################
+def delayed(function):
+    """Decorator used to capture the arguments of a function."""
+
+    def delayed_function(*args, **kwargs):
+        return function, args, kwargs
+    try:
+        delayed_function = functools.wraps(function)(delayed_function)
+    except AttributeError:
+        " functools.wraps fails on some callable objects "
+    return delayed_function
+
+
+###############################################################################
+class BatchCompletionCallBack(object):
+    """Callback used by joblib.Parallel's multiprocessing backend.
+
+    This callable is executed by the parent process whenever a worker process
+    has returned the results of a batch of tasks.
+
+    It is used for progress reporting, to update estimate of the batch
+    processing duration and to schedule the next batch of tasks to be
+    processed.
+
+    """
+    def __init__(self, dispatch_timestamp, batch_size, parallel):
+        self.dispatch_timestamp = dispatch_timestamp
+        self.batch_size = batch_size
+        self.parallel = parallel
+
+    def __call__(self, out):
+        self.parallel.n_completed_tasks += self.batch_size
+        this_batch_duration = time.time() - self.dispatch_timestamp
+
+        self.parallel._backend.batch_completed(self.batch_size,
+                                               this_batch_duration)
+        self.parallel.print_progress()
+        with self.parallel._lock:
+            if self.parallel._original_iterator is not None:
+                self.parallel.dispatch_next()
+
+
+###############################################################################
+def register_parallel_backend(name, factory, make_default=False):
+    """Register a new Parallel backend factory.
+
+    The new backend can then be selected by passing its name as the backend
+    argument to the Parallel class. Moreover, the default backend can be
+    overwritten globally by setting make_default=True.
+
+    The factory can be any callable that takes no argument and return an
+    instance of ``ParallelBackendBase``.
+
+    Warning: this function is experimental and subject to change in a future
+    version of joblib.
+
+    .. versionadded:: 0.10
+
+    """
+    BACKENDS[name] = factory
+    if make_default:
+        global DEFAULT_BACKEND
+        DEFAULT_BACKEND = name
+
+
+def effective_n_jobs(n_jobs=-1):
+    """Determine the number of jobs that can actually run in parallel
+
+    n_jobs is the number of workers requested by the callers. Passing n_jobs=-1
+    means requesting all available workers for instance matching the number of
+    CPU cores on the worker host(s).
+
+    This method should return a guesstimate of the number of workers that can
+    actually perform work concurrently with the currently enabled default
+    backend. The primary use case is to make it possible for the caller to know
+    in how many chunks to slice the work.
+
+    In general working on larger data chunks is more efficient (less scheduling
+    overhead and better use of CPU cache prefetching heuristics) as long as all
+    the workers have enough work to do.
+
+    Warning: this function is experimental and subject to change in a future
+    version of joblib.
+
+    .. versionadded:: 0.10
+
+    """
+    backend, backend_n_jobs = get_active_backend()
+    if n_jobs is None:
+        n_jobs = backend_n_jobs
+    return backend.effective_n_jobs(n_jobs=n_jobs)
+
+
+###############################################################################
+class Parallel(Logger):
+    ''' Helper class for readable parallel mapping.
+
+        Read more in the :ref:`User Guide <parallel>`.
+
+        Parameters
+        -----------
+        n_jobs: int, default: None
+            The maximum number of concurrently running jobs, such as the number
+            of Python worker processes when backend="multiprocessing"
+            or the size of the thread-pool when backend="threading".
+            If -1 all CPUs are used. If 1 is given, no parallel computing code
+            is used at all, which is useful for debugging. For n_jobs below -1,
+            (n_cpus + 1 + n_jobs) are used. Thus for n_jobs = -2, all
+            CPUs but one are used.
+            None is a marker for 'unset' that will be interpreted as n_jobs=1
+            (sequential execution) unless the call is performed under a
+            parallel_backend context manager that sets another value for
+            n_jobs.
+        backend: str, ParallelBackendBase instance or None, default: 'loky'
+            Specify the parallelization backend implementation.
+            Supported backends are:
+
+            - "loky" used by default, can induce some
+              communication and memory overhead when exchanging input and
+              output data with the worker Python processes.
+            - "multiprocessing" previous process-based backend based on
+              `multiprocessing.Pool`. Less robust than `loky`.
+            - "threading" is a very low-overhead backend but it suffers
+              from the Python Global Interpreter Lock if the called function
+              relies a lot on Python objects. "threading" is mostly useful
+              when the execution bottleneck is a compiled extension that
+              explicitly releases the GIL (for instance a Cython loop wrapped
+              in a "with nogil" block or an expensive call to a library such
+              as NumPy).
+            - finally, you can register backends by calling
+              register_parallel_backend. This will allow you to implement
+              a backend of your liking.
+
+            It is not recommended to hard-code the backend name in a call to
+            Parallel in a library. Instead it is recommended to set soft hints
+            (prefer) or hard constraints (require) so as to make it possible
+            for library users to change the backend from the outside using the
+            parallel_backend context manager.
+        prefer: str in {'processes', 'threads'} or None, default: None
+            Soft hint to choose the default backend if no specific backend
+            was selected with the parallel_backend context manager. The
+            default process-based backend is 'loky' and the default
+            thread-based backend is 'threading'. Ignored if the ``backend``
+            parameter is specified.
+        require: 'sharedmem' or None, default None
+            Hard constraint to select the backend. If set to 'sharedmem',
+            the selected backend will be single-host and thread-based even
+            if the user asked for a non-thread based backend with
+            parallel_backend.
+        verbose: int, optional
+            The verbosity level: if non zero, progress messages are
+            printed. Above 50, the output is sent to stdout.
+            The frequency of the messages increases with the verbosity level.
+            If it more than 10, all iterations are reported.
+        timeout: float, optional
+            Timeout limit for each task to complete.  If any task takes longer
+            a TimeOutError will be raised. Only applied when n_jobs != 1
+        pre_dispatch: {'all', integer, or expression, as in '3*n_jobs'}
+            The number of batches (of tasks) to be pre-dispatched.
+            Default is '2*n_jobs'. When batch_size="auto" this is reasonable
+            default and the workers should never starve.
+        batch_size: int or 'auto', default: 'auto'
+            The number of atomic tasks to dispatch at once to each
+            worker. When individual evaluations are very fast, dispatching
+            calls to workers can be slower than sequential computation because
+            of the overhead. Batching fast computations together can mitigate
+            this.
+            The ``'auto'`` strategy keeps track of the time it takes for a batch
+            to complete, and dynamically adjusts the batch size to keep the time
+            on the order of half a second, using a heuristic. The initial batch
+            size is 1.
+            ``batch_size="auto"`` with ``backend="threading"`` will dispatch
+            batches of a single task at a time as the threading backend has
+            very little overhead and using larger batch size has not proved to
+            bring any gain in that case.
+        temp_folder: str, optional
+            Folder to be used by the pool for memmapping large arrays
+            for sharing memory with worker processes. If None, this will try in
+            order:
+
+            - a folder pointed by the JOBLIB_TEMP_FOLDER environment
+              variable,
+            - /dev/shm if the folder exists and is writable: this is a
+              RAM disk filesystem available by default on modern Linux
+              distributions,
+            - the default system temporary folder that can be
+              overridden with TMP, TMPDIR or TEMP environment
+              variables, typically /tmp under Unix operating systems.
+
+            Only active when backend="loky" or "multiprocessing".
+        max_nbytes int, str, or None, optional, 1M by default
+            Threshold on the size of arrays passed to the workers that
+            triggers automated memory mapping in temp_folder. Can be an int
+            in Bytes, or a human-readable string, e.g., '1M' for 1 megabyte.
+            Use None to disable memmapping of large arrays.
+            Only active when backend="loky" or "multiprocessing".
+        mmap_mode: {None, 'r+', 'r', 'w+', 'c'}, default: 'r'
+            Memmapping mode for numpy arrays passed to workers. None will 
+            disable memmapping, other modes defined in the numpy.memmap doc:
+            https://numpy.org/doc/stable/reference/generated/numpy.memmap.html
+            Also, see 'max_nbytes' parameter documentation for more details.
+
+        Notes
+        -----
+
+        This object uses workers to compute in parallel the application of a
+        function to many different arguments. The main functionality it brings
+        in addition to using the raw multiprocessing or concurrent.futures API
+        are (see examples for details):
+
+        * More readable code, in particular since it avoids
+          constructing list of arguments.
+
+        * Easier debugging:
+            - informative tracebacks even when the error happens on
+              the client side
+            - using 'n_jobs=1' enables to turn off parallel computing
+              for debugging without changing the codepath
+            - early capture of pickling errors
+
+        * An optional progress meter.
+
+        * Interruption of multiprocesses jobs with 'Ctrl-C'
+
+        * Flexible pickling control for the communication to and from
+          the worker processes.
+
+        * Ability to use shared memory efficiently with worker
+          processes for large numpy-based datastructures.
+
+        Examples
+        --------
+
+        A simple example:
+
+        >>> from math import sqrt
+        >>> from joblib import Parallel, delayed
+        >>> Parallel(n_jobs=1)(delayed(sqrt)(i**2) for i in range(10))
+        [0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0]
+
+        Reshaping the output when the function has several return
+        values:
+
+        >>> from math import modf
+        >>> from joblib import Parallel, delayed
+        >>> r = Parallel(n_jobs=1)(delayed(modf)(i/2.) for i in range(10))
+        >>> res, i = zip(*r)
+        >>> res
+        (0.0, 0.5, 0.0, 0.5, 0.0, 0.5, 0.0, 0.5, 0.0, 0.5)
+        >>> i
+        (0.0, 0.0, 1.0, 1.0, 2.0, 2.0, 3.0, 3.0, 4.0, 4.0)
+
+        The progress meter: the higher the value of `verbose`, the more
+        messages:
+
+        >>> from time import sleep
+        >>> from joblib import Parallel, delayed
+        >>> r = Parallel(n_jobs=2, verbose=10)(delayed(sleep)(.2) for _ in range(10)) #doctest: +SKIP
+        [Parallel(n_jobs=2)]: Done   1 tasks      | elapsed:    0.6s
+        [Parallel(n_jobs=2)]: Done   4 tasks      | elapsed:    0.8s
+        [Parallel(n_jobs=2)]: Done  10 out of  10 | elapsed:    1.4s finished
+
+        Traceback example, note how the line of the error is indicated
+        as well as the values of the parameter passed to the function that
+        triggered the exception, even though the traceback happens in the
+        child process:
+
+        >>> from heapq import nlargest
+        >>> from joblib import Parallel, delayed
+        >>> Parallel(n_jobs=2)(delayed(nlargest)(2, n) for n in (range(4), 'abcde', 3)) #doctest: +SKIP
+        #...
+        ---------------------------------------------------------------------------
+        Sub-process traceback:
+        ---------------------------------------------------------------------------
+        TypeError                                          Mon Nov 12 11:37:46 2012
+        PID: 12934                                    Python 2.7.3: /usr/bin/python
+        ...........................................................................
+        /usr/lib/python2.7/heapq.pyc in nlargest(n=2, iterable=3, key=None)
+            419         if n >= size:
+            420             return sorted(iterable, key=key, reverse=True)[:n]
+            421
+            422     # When key is none, use simpler decoration
+            423     if key is None:
+        --> 424         it = izip(iterable, count(0,-1))                    # decorate
+            425         result = _nlargest(n, it)
+            426         return map(itemgetter(0), result)                   # undecorate
+            427
+            428     # General case, slowest method
+         TypeError: izip argument #1 must support iteration
+        ___________________________________________________________________________
+
+
+        Using pre_dispatch in a producer/consumer situation, where the
+        data is generated on the fly. Note how the producer is first
+        called 3 times before the parallel loop is initiated, and then
+        called to generate new data on the fly:
+
+        >>> from math import sqrt
+        >>> from joblib import Parallel, delayed
+        >>> def producer():
+        ...     for i in range(6):
+        ...         print('Produced %s' % i)
+        ...         yield i
+        >>> out = Parallel(n_jobs=2, verbose=100, pre_dispatch='1.5*n_jobs')(
+        ...                delayed(sqrt)(i) for i in producer()) #doctest: +SKIP
+        Produced 0
+        Produced 1
+        Produced 2
+        [Parallel(n_jobs=2)]: Done 1 jobs     | elapsed:  0.0s
+        Produced 3
+        [Parallel(n_jobs=2)]: Done 2 jobs     | elapsed:  0.0s
+        Produced 4
+        [Parallel(n_jobs=2)]: Done 3 jobs     | elapsed:  0.0s
+        Produced 5
+        [Parallel(n_jobs=2)]: Done 4 jobs     | elapsed:  0.0s
+        [Parallel(n_jobs=2)]: Done 6 out of 6 | elapsed:  0.0s remaining: 0.0s
+        [Parallel(n_jobs=2)]: Done 6 out of 6 | elapsed:  0.0s finished
+
+    '''
+    def __init__(self, n_jobs=None, backend=None, verbose=0, timeout=None,
+                 pre_dispatch='2 * n_jobs', batch_size='auto',
+                 temp_folder=None, max_nbytes='1M', mmap_mode='r',
+                 prefer=None, require=None):
+        active_backend, context_n_jobs = get_active_backend(
+            prefer=prefer, require=require, verbose=verbose)
+        nesting_level = active_backend.nesting_level
+        if backend is None and n_jobs is None:
+            # If we are under a parallel_backend context manager, look up
+            # the default number of jobs and use that instead:
+            n_jobs = context_n_jobs
+        if n_jobs is None:
+            # No specific context override and no specific value request:
+            # default to 1.
+            n_jobs = 1
+        self.n_jobs = n_jobs
+        self.verbose = verbose
+        self.timeout = timeout
+        self.pre_dispatch = pre_dispatch
+        self._ready_batches = queue.Queue()
+        self._id = uuid4().hex
+        self._reducer_callback = None
+
+        if isinstance(max_nbytes, str):
+            max_nbytes = memstr_to_bytes(max_nbytes)
+
+        self._backend_args = dict(
+            max_nbytes=max_nbytes,
+            mmap_mode=mmap_mode,
+            temp_folder=temp_folder,
+            prefer=prefer,
+            require=require,
+            verbose=max(0, self.verbose - 50),
+        )
+        if DEFAULT_MP_CONTEXT is not None:
+            self._backend_args['context'] = DEFAULT_MP_CONTEXT
+        elif hasattr(mp, "get_context"):
+            self._backend_args['context'] = mp.get_context()
+
+        if backend is None:
+            backend = active_backend
+
+        elif isinstance(backend, ParallelBackendBase):
+            # Use provided backend as is, with the current nesting_level if it
+            # is not set yet.
+            if backend.nesting_level is None:
+                backend.nesting_level = nesting_level
+
+        elif hasattr(backend, 'Pool') and hasattr(backend, 'Lock'):
+            # Make it possible to pass a custom multiprocessing context as
+            # backend to change the start method to forkserver or spawn or
+            # preload modules on the forkserver helper process.
+            self._backend_args['context'] = backend
+            backend = MultiprocessingBackend(nesting_level=nesting_level)
+        else:
+            try:
+                backend_factory = BACKENDS[backend]
+            except KeyError as e:
+                raise ValueError("Invalid backend: %s, expected one of %r"
+                                 % (backend, sorted(BACKENDS.keys()))) from e
+            backend = backend_factory(nesting_level=nesting_level)
+
+        if (require == 'sharedmem' and
+                not getattr(backend, 'supports_sharedmem', False)):
+            raise ValueError("Backend %s does not support shared memory"
+                             % backend)
+
+        if (batch_size == 'auto' or isinstance(batch_size, Integral) and
+                batch_size > 0):
+            self.batch_size = batch_size
+        else:
+            raise ValueError(
+                "batch_size must be 'auto' or a positive integer, got: %r"
+                % batch_size)
+
+        self._backend = backend
+        self._output = None
+        self._jobs = list()
+        self._managed_backend = False
+
+        # This lock is used coordinate the main thread of this process with
+        # the async callback thread of our the pool.
+        self._lock = threading.RLock()
+
+    def __enter__(self):
+        self._managed_backend = True
+        self._initialize_backend()
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self._terminate_backend()
+        self._managed_backend = False
+
+    def _initialize_backend(self):
+        """Build a process or thread pool and return the number of workers"""
+        try:
+            n_jobs = self._backend.configure(n_jobs=self.n_jobs, parallel=self,
+                                             **self._backend_args)
+            if self.timeout is not None and not self._backend.supports_timeout:
+                warnings.warn(
+                    'The backend class {!r} does not support timeout. '
+                    "You have set 'timeout={}' in Parallel but "
+                    "the 'timeout' parameter will not be used.".format(
+                        self._backend.__class__.__name__,
+                        self.timeout))
+
+        except FallbackToBackend as e:
+            # Recursively initialize the backend in case of requested fallback.
+            self._backend = e.backend
+            n_jobs = self._initialize_backend()
+
+        return n_jobs
+
+    def _effective_n_jobs(self):
+        if self._backend:
+            return self._backend.effective_n_jobs(self.n_jobs)
+        return 1
+
+    def _terminate_backend(self):
+        if self._backend is not None:
+            self._backend.terminate()
+
+    def _dispatch(self, batch):
+        """Queue the batch for computing, with or without multiprocessing
+
+        WARNING: this method is not thread-safe: it should be only called
+        indirectly via dispatch_one_batch.
+
+        """
+        # If job.get() catches an exception, it closes the queue:
+        if self._aborting:
+            return
+
+        self.n_dispatched_tasks += len(batch)
+        self.n_dispatched_batches += 1
+
+        dispatch_timestamp = time.time()
+        cb = BatchCompletionCallBack(dispatch_timestamp, len(batch), self)
+        with self._lock:
+            job_idx = len(self._jobs)
+            job = self._backend.apply_async(batch, callback=cb)
+            # A job can complete so quickly than its callback is
+            # called before we get here, causing self._jobs to
+            # grow. To ensure correct results ordering, .insert is
+            # used (rather than .append) in the following line
+            self._jobs.insert(job_idx, job)
+
+    def dispatch_next(self):
+        """Dispatch more data for parallel processing
+
+        This method is meant to be called concurrently by the multiprocessing
+        callback. We rely on the thread-safety of dispatch_one_batch to protect
+        against concurrent consumption of the unprotected iterator.
+
+        """
+        if not self.dispatch_one_batch(self._original_iterator):
+            self._iterating = False
+            self._original_iterator = None
+
+    def dispatch_one_batch(self, iterator):
+        """Prefetch the tasks for the next batch and dispatch them.
+
+        The effective size of the batch is computed here.
+        If there are no more jobs to dispatch, return False, else return True.
+
+        The iterator consumption and dispatching is protected by the same
+        lock so calling this function should be thread safe.
+
+        """
+        if self.batch_size == 'auto':
+            batch_size = self._backend.compute_batch_size()
+        else:
+            # Fixed batch size strategy
+            batch_size = self.batch_size
+
+        with self._lock:
+            # to ensure an even distribution of the workolad between workers,
+            # we look ahead in the original iterators more than batch_size
+            # tasks - However, we keep consuming only one batch at each
+            # dispatch_one_batch call. The extra tasks are stored in a local
+            # queue, _ready_batches, that is looked-up prior to re-consuming
+            # tasks from the origal iterator.
+            try:
+                tasks = self._ready_batches.get(block=False)
+            except queue.Empty:
+                # slice the iterator n_jobs * batchsize items at a time. If the
+                # slice returns less than that, then the current batchsize puts
+                # too much weight on a subset of workers, while other may end
+                # up starving. So in this case, re-scale the batch size
+                # accordingly to distribute evenly the last items between all
+                # workers.
+                n_jobs = self._cached_effective_n_jobs
+                big_batch_size = batch_size * n_jobs
+
+                islice = list(itertools.islice(iterator, big_batch_size))
+                if len(islice) == 0:
+                    return False
+                elif (iterator is self._original_iterator
+                      and len(islice) < big_batch_size):
+                    # We reached the end of the original iterator (unless
+                    # iterator is the ``pre_dispatch``-long initial slice of
+                    # the original iterator) -- decrease the batch size to
+                    # account for potential variance in the batches running
+                    # time.
+                    final_batch_size = max(1, len(islice) // (10 * n_jobs))
+                else:
+                    final_batch_size = max(1, len(islice) // n_jobs)
+
+                # enqueue n_jobs batches in a local queue
+                for i in range(0, len(islice), final_batch_size):
+                    tasks = BatchedCalls(islice[i:i + final_batch_size],
+                                         self._backend.get_nested_backend(),
+                                         self._reducer_callback,
+                                         self._pickle_cache)
+                    self._ready_batches.put(tasks)
+
+                # finally, get one task.
+                tasks = self._ready_batches.get(block=False)
+            if len(tasks) == 0:
+                # No more tasks available in the iterator: tell caller to stop.
+                return False
+            else:
+                self._dispatch(tasks)
+                return True
+
+    def _print(self, msg, msg_args):
+        """Display the message on stout or stderr depending on verbosity"""
+        # XXX: Not using the logger framework: need to
+        # learn to use logger better.
+        if not self.verbose:
+            return
+        if self.verbose < 50:
+            writer = sys.stderr.write
+        else:
+            writer = sys.stdout.write
+        msg = msg % msg_args
+        writer('[%s]: %s\n' % (self, msg))
+
+    def print_progress(self):
+        """Display the process of the parallel execution only a fraction
+           of time, controlled by self.verbose.
+        """
+        if not self.verbose:
+            return
+        elapsed_time = time.time() - self._start_time
+
+        # Original job iterator becomes None once it has been fully
+        # consumed : at this point we know the total number of jobs and we are
+        # able to display an estimation of the remaining time based on already
+        # completed jobs. Otherwise, we simply display the number of completed
+        # tasks.
+        if self._original_iterator is not None:
+            if _verbosity_filter(self.n_dispatched_batches, self.verbose):
+                return
+            self._print('Done %3i tasks      | elapsed: %s',
+                        (self.n_completed_tasks,
+                         short_format_time(elapsed_time), ))
+        else:
+            index = self.n_completed_tasks
+            # We are finished dispatching
+            total_tasks = self.n_dispatched_tasks
+            # We always display the first loop
+            if not index == 0:
+                # Display depending on the number of remaining items
+                # A message as soon as we finish dispatching, cursor is 0
+                cursor = (total_tasks - index + 1 -
+                          self._pre_dispatch_amount)
+                frequency = (total_tasks // self.verbose) + 1
+                is_last_item = (index + 1 == total_tasks)
+                if (is_last_item or cursor % frequency):
+                    return
+            remaining_time = (elapsed_time / index) * \
+                             (self.n_dispatched_tasks - index * 1.0)
+            # only display status if remaining time is greater or equal to 0
+            self._print('Done %3i out of %3i | elapsed: %s remaining: %s',
+                        (index,
+                         total_tasks,
+                         short_format_time(elapsed_time),
+                         short_format_time(remaining_time),
+                         ))
+
+    def retrieve(self):
+        self._output = list()
+        while self._iterating or len(self._jobs) > 0:
+            if len(self._jobs) == 0:
+                # Wait for an async callback to dispatch new jobs
+                time.sleep(0.01)
+                continue
+            # We need to be careful: the job list can be filling up as
+            # we empty it and Python list are not thread-safe by default hence
+            # the use of the lock
+            with self._lock:
+                job = self._jobs.pop(0)
+
+            try:
+                if getattr(self._backend, 'supports_timeout', False):
+                    self._output.extend(job.get(timeout=self.timeout))
+                else:
+                    self._output.extend(job.get())
+
+            except BaseException as exception:
+                # Note: we catch any BaseException instead of just Exception
+                # instances to also include KeyboardInterrupt.
+
+                # Stop dispatching any new job in the async callback thread
+                self._aborting = True
+
+                # If the backend allows it, cancel or kill remaining running
+                # tasks without waiting for the results as we will raise
+                # the exception we got back to the caller instead of returning
+                # any result.
+                backend = self._backend
+                if (backend is not None and
+                        hasattr(backend, 'abort_everything')):
+                    # If the backend is managed externally we need to make sure
+                    # to leave it in a working state to allow for future jobs
+                    # scheduling.
+                    ensure_ready = self._managed_backend
+                    backend.abort_everything(ensure_ready=ensure_ready)
+                raise
+
+    def __call__(self, iterable):
+        if self._jobs:
+            raise ValueError('This Parallel instance is already running')
+        # A flag used to abort the dispatching of jobs in case an
+        # exception is found
+        self._aborting = False
+
+        if not self._managed_backend:
+            n_jobs = self._initialize_backend()
+        else:
+            n_jobs = self._effective_n_jobs()
+
+        if isinstance(self._backend, LokyBackend):
+            # For the loky backend, we add a callback executed when reducing
+            # BatchCalls, that makes the loky executor use a temporary folder
+            # specific to this Parallel object when pickling temporary memmaps.
+            # This callback is necessary to ensure that several Parallel
+            # objects using the same resuable executor don't use the same
+            # temporary resources.
+
+            def _batched_calls_reducer_callback():
+                # Relevant implementation detail: the following lines, called
+                # when reducing BatchedCalls, are called in a thread-safe
+                # situation, meaning that the context of the temporary folder
+                # manager will not be changed in between the callback execution
+                # and the end of the BatchedCalls pickling. The reason is that
+                # pickling (the only place where set_current_context is used)
+                # is done from a single thread (the queue_feeder_thread).
+                self._backend._workers._temp_folder_manager.set_current_context(  # noqa
+                    self._id
+                )
+            self._reducer_callback = _batched_calls_reducer_callback
+
+        # self._effective_n_jobs should be called in the Parallel.__call__
+        # thread only -- store its value in an attribute for further queries.
+        self._cached_effective_n_jobs = n_jobs
+
+        backend_name = self._backend.__class__.__name__
+        if n_jobs == 0:
+            raise RuntimeError("%s has no active worker." % backend_name)
+
+        self._print("Using backend %s with %d concurrent workers.",
+                    (backend_name, n_jobs))
+        if hasattr(self._backend, 'start_call'):
+            self._backend.start_call()
+        iterator = iter(iterable)
+        pre_dispatch = self.pre_dispatch
+
+        if pre_dispatch == 'all' or n_jobs == 1:
+            # prevent further dispatch via multiprocessing callback thread
+            self._original_iterator = None
+            self._pre_dispatch_amount = 0
+        else:
+            self._original_iterator = iterator
+            if hasattr(pre_dispatch, 'endswith'):
+                pre_dispatch = eval(pre_dispatch)
+            self._pre_dispatch_amount = pre_dispatch = int(pre_dispatch)
+
+            # The main thread will consume the first pre_dispatch items and
+            # the remaining items will later be lazily dispatched by async
+            # callbacks upon task completions.
+
+            # TODO: this iterator should be batch_size * n_jobs
+            iterator = itertools.islice(iterator, self._pre_dispatch_amount)
+
+        self._start_time = time.time()
+        self.n_dispatched_batches = 0
+        self.n_dispatched_tasks = 0
+        self.n_completed_tasks = 0
+        # Use a caching dict for callables that are pickled with cloudpickle to
+        # improve performances. This cache is used only in the case of
+        # functions that are defined in the __main__ module, functions that are
+        # defined locally (inside another function) and lambda expressions.
+        self._pickle_cache = dict()
+        try:
+            # Only set self._iterating to True if at least a batch
+            # was dispatched. In particular this covers the edge
+            # case of Parallel used with an exhausted iterator. If
+            # self._original_iterator is None, then this means either
+            # that pre_dispatch == "all", n_jobs == 1 or that the first batch
+            # was very quick and its callback already dispatched all the
+            # remaining jobs.
+            self._iterating = False
+            if self.dispatch_one_batch(iterator):
+                self._iterating = self._original_iterator is not None
+
+            while self.dispatch_one_batch(iterator):
+                pass
+
+            if pre_dispatch == "all" or n_jobs == 1:
+                # The iterable was consumed all at once by the above for loop.
+                # No need to wait for async callbacks to trigger to
+                # consumption.
+                self._iterating = False
+
+            with self._backend.retrieval_context():
+                self.retrieve()
+            # Make sure that we get a last message telling us we are done
+            elapsed_time = time.time() - self._start_time
+            self._print('Done %3i out of %3i | elapsed: %s finished',
+                        (len(self._output), len(self._output),
+                         short_format_time(elapsed_time)))
+        finally:
+            if hasattr(self._backend, 'stop_call'):
+                self._backend.stop_call()
+            if not self._managed_backend:
+                self._terminate_backend()
+            self._jobs = list()
+            self._pickle_cache = None
+        output = self._output
+        self._output = None
+        return output
+
+    def __repr__(self):
+        return '%s(n_jobs=%s)' % (self.__class__.__name__, self.n_jobs)

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/joblib/pool.py

@@ -0,0 +1,352 @@
+"""Custom implementation of multiprocessing.Pool with custom pickler.
+
+This module provides efficient ways of working with data stored in
+shared memory with numpy.memmap arrays without inducing any memory
+copy between the parent and child processes.
+
+This module should not be imported if multiprocessing is not
+available as it implements subclasses of multiprocessing Pool
+that uses a custom alternative to SimpleQueue.
+
+"""
+# Author: Olivier Grisel <olivier.grisel@ensta.org>
+# Copyright: 2012, Olivier Grisel
+# License: BSD 3 clause
+
+import copyreg
+import sys
+import warnings
+from time import sleep
+
+try:
+    WindowsError
+except NameError:
+    WindowsError = type(None)
+
+from pickle import Pickler
+
+from pickle import HIGHEST_PROTOCOL
+from io import BytesIO
+
+from ._memmapping_reducer import get_memmapping_reducers
+from ._memmapping_reducer import TemporaryResourcesManager
+from ._multiprocessing_helpers import mp, assert_spawning
+
+# We need the class definition to derive from it, not the multiprocessing.Pool
+# factory function
+from multiprocessing.pool import Pool
+
+try:
+    import numpy as np
+except ImportError:
+    np = None
+
+
+###############################################################################
+# Enable custom pickling in Pool queues
+
+class CustomizablePickler(Pickler):
+    """Pickler that accepts custom reducers.
+
+    TODO python2_drop : can this be simplified ?
+
+    HIGHEST_PROTOCOL is selected by default as this pickler is used
+    to pickle ephemeral datastructures for interprocess communication
+    hence no backward compatibility is required.
+
+    `reducers` is expected to be a dictionary with key/values
+    being `(type, callable)` pairs where `callable` is a function that
+    give an instance of `type` will return a tuple `(constructor,
+    tuple_of_objects)` to rebuild an instance out of the pickled
+    `tuple_of_objects` as would return a `__reduce__` method. See the
+    standard library documentation on pickling for more details.
+
+    """
+
+    # We override the pure Python pickler as its the only way to be able to
+    # customize the dispatch table without side effects in Python 2.7
+    # to 3.2. For Python 3.3+ leverage the new dispatch_table
+    # feature from https://bugs.python.org/issue14166 that makes it possible
+    # to use the C implementation of the Pickler which is faster.
+
+    def __init__(self, writer, reducers=None, protocol=HIGHEST_PROTOCOL):
+        Pickler.__init__(self, writer, protocol=protocol)
+        if reducers is None:
+            reducers = {}
+        if hasattr(Pickler, 'dispatch'):
+            # Make the dispatch registry an instance level attribute instead of
+            # a reference to the class dictionary under Python 2
+            self.dispatch = Pickler.dispatch.copy()
+        else:
+            # Under Python 3 initialize the dispatch table with a copy of the
+            # default registry
+            self.dispatch_table = copyreg.dispatch_table.copy()
+        for type, reduce_func in reducers.items():
+            self.register(type, reduce_func)
+
+    def register(self, type, reduce_func):
+        """Attach a reducer function to a given type in the dispatch table."""
+        if hasattr(Pickler, 'dispatch'):
+            # Python 2 pickler dispatching is not explicitly customizable.
+            # Let us use a closure to workaround this limitation.
+            def dispatcher(self, obj):
+                reduced = reduce_func(obj)
+                self.save_reduce(obj=obj, *reduced)
+            self.dispatch[type] = dispatcher
+        else:
+            self.dispatch_table[type] = reduce_func
+
+
+class CustomizablePicklingQueue(object):
+    """Locked Pipe implementation that uses a customizable pickler.
+
+    This class is an alternative to the multiprocessing implementation
+    of SimpleQueue in order to make it possible to pass custom
+    pickling reducers, for instance to avoid memory copy when passing
+    memory mapped datastructures.
+
+    `reducers` is expected to be a dict with key / values being
+    `(type, callable)` pairs where `callable` is a function that, given an
+    instance of `type`, will return a tuple `(constructor, tuple_of_objects)`
+    to rebuild an instance out of the pickled `tuple_of_objects` as would
+    return a `__reduce__` method.
+
+    See the standard library documentation on pickling for more details.
+    """
+
+    def __init__(self, context, reducers=None):
+        self._reducers = reducers
+        self._reader, self._writer = context.Pipe(duplex=False)
+        self._rlock = context.Lock()
+        if sys.platform == 'win32':
+            self._wlock = None
+        else:
+            self._wlock = context.Lock()
+        self._make_methods()
+
+    def __getstate__(self):
+        assert_spawning(self)
+        return (self._reader, self._writer, self._rlock, self._wlock,
+                self._reducers)
+
+    def __setstate__(self, state):
+        (self._reader, self._writer, self._rlock, self._wlock,
+         self._reducers) = state
+        self._make_methods()
+
+    def empty(self):
+        return not self._reader.poll()
+
+    def _make_methods(self):
+        self._recv = recv = self._reader.recv
+        racquire, rrelease = self._rlock.acquire, self._rlock.release
+
+        def get():
+            racquire()
+            try:
+                return recv()
+            finally:
+                rrelease()
+
+        self.get = get
+
+        if self._reducers:
+            def send(obj):
+                buffer = BytesIO()
+                CustomizablePickler(buffer, self._reducers).dump(obj)
+                self._writer.send_bytes(buffer.getvalue())
+            self._send = send
+        else:
+            self._send = send = self._writer.send
+        if self._wlock is None:
+            # writes to a message oriented win32 pipe are atomic
+            self.put = send
+        else:
+            wlock_acquire, wlock_release = (
+                self._wlock.acquire, self._wlock.release)
+
+            def put(obj):
+                wlock_acquire()
+                try:
+                    return send(obj)
+                finally:
+                    wlock_release()
+
+            self.put = put
+
+
+class PicklingPool(Pool):
+    """Pool implementation with customizable pickling reducers.
+
+    This is useful to control how data is shipped between processes
+    and makes it possible to use shared memory without useless
+    copies induces by the default pickling methods of the original
+    objects passed as arguments to dispatch.
+
+    `forward_reducers` and `backward_reducers` are expected to be
+    dictionaries with key/values being `(type, callable)` pairs where
+    `callable` is a function that, given an instance of `type`, will return a
+    tuple `(constructor, tuple_of_objects)` to rebuild an instance out of the
+    pickled `tuple_of_objects` as would return a `__reduce__` method.
+    See the standard library documentation about pickling for more details.
+
+    """
+
+    def __init__(self, processes=None, forward_reducers=None,
+                 backward_reducers=None, **kwargs):
+        if forward_reducers is None:
+            forward_reducers = dict()
+        if backward_reducers is None:
+            backward_reducers = dict()
+        self._forward_reducers = forward_reducers
+        self._backward_reducers = backward_reducers
+        poolargs = dict(processes=processes)
+        poolargs.update(kwargs)
+        super(PicklingPool, self).__init__(**poolargs)
+
+    def _setup_queues(self):
+        context = getattr(self, '_ctx', mp)
+        self._inqueue = CustomizablePicklingQueue(context,
+                                                  self._forward_reducers)
+        self._outqueue = CustomizablePicklingQueue(context,
+                                                   self._backward_reducers)
+        self._quick_put = self._inqueue._send
+        self._quick_get = self._outqueue._recv
+
+
+class MemmappingPool(PicklingPool):
+    """Process pool that shares large arrays to avoid memory copy.
+
+    This drop-in replacement for `multiprocessing.pool.Pool` makes
+    it possible to work efficiently with shared memory in a numpy
+    context.
+
+    Existing instances of numpy.memmap are preserved: the child
+    suprocesses will have access to the same shared memory in the
+    original mode except for the 'w+' mode that is automatically
+    transformed as 'r+' to avoid zeroing the original data upon
+    instantiation.
+
+    Furthermore large arrays from the parent process are automatically
+    dumped to a temporary folder on the filesystem such as child
+    processes to access their content via memmapping (file system
+    backed shared memory).
+
+    Note: it is important to call the terminate method to collect
+    the temporary folder used by the pool.
+
+    Parameters
+    ----------
+    processes: int, optional
+        Number of worker processes running concurrently in the pool.
+    initializer: callable, optional
+        Callable executed on worker process creation.
+    initargs: tuple, optional
+        Arguments passed to the initializer callable.
+    temp_folder: (str, callable) optional
+        If str:
+          Folder to be used by the pool for memmapping large arrays
+          for sharing memory with worker processes. If None, this will try in
+          order:
+          - a folder pointed by the JOBLIB_TEMP_FOLDER environment variable,
+          - /dev/shm if the folder exists and is writable: this is a RAMdisk
+            filesystem available by default on modern Linux distributions,
+          - the default system temporary folder that can be overridden
+            with TMP, TMPDIR or TEMP environment variables, typically /tmp
+            under Unix operating systems.
+        if callable:
+            An callable in charge of dynamically resolving a temporary folder
+            for memmapping large arrays.
+    max_nbytes int or None, optional, 1e6 by default
+        Threshold on the size of arrays passed to the workers that
+        triggers automated memory mapping in temp_folder.
+        Use None to disable memmapping of large arrays.
+    mmap_mode: {'r+', 'r', 'w+', 'c'}
+        Memmapping mode for numpy arrays passed to workers.
+        See 'max_nbytes' parameter documentation for more details.
+    forward_reducers: dictionary, optional
+        Reducers used to pickle objects passed from master to worker
+        processes: see below.
+    backward_reducers: dictionary, optional
+        Reducers used to pickle return values from workers back to the
+        master process.
+    verbose: int, optional
+        Make it possible to monitor how the communication of numpy arrays
+        with the subprocess is handled (pickling or memmapping)
+    prewarm: bool or str, optional, "auto" by default.
+        If True, force a read on newly memmapped array to make sure that OS
+        pre-cache it in memory. This can be useful to avoid concurrent disk
+        access when the same data array is passed to different worker
+        processes. If "auto" (by default), prewarm is set to True, unless the
+        Linux shared memory partition /dev/shm is available and used as temp
+        folder.
+
+    `forward_reducers` and `backward_reducers` are expected to be
+    dictionaries with key/values being `(type, callable)` pairs where
+    `callable` is a function that give an instance of `type` will return
+    a tuple `(constructor, tuple_of_objects)` to rebuild an instance out
+    of the pickled `tuple_of_objects` as would return a `__reduce__`
+    method. See the standard library documentation on pickling for more
+    details.
+
+    """
+
+    def __init__(self, processes=None, temp_folder=None, max_nbytes=1e6,
+                 mmap_mode='r', forward_reducers=None, backward_reducers=None,
+                 verbose=0, context_id=None, prewarm=False, **kwargs):
+
+        if context_id is not None:
+            warnings.warn('context_id is deprecated and ignored in joblib'
+                          ' 0.9.4 and will be removed in 0.11',
+                          DeprecationWarning)
+
+        manager = TemporaryResourcesManager(temp_folder)
+        self._temp_folder_manager = manager
+
+        # The usage of a temp_folder_resolver over a simple temp_folder is
+        # superfluous for multiprocessing pools, as they don't get reused, see
+        # get_memmapping_executor for more details. We still use it for code
+        # simplicity.
+        forward_reducers, backward_reducers = \
+            get_memmapping_reducers(
+                temp_folder_resolver=manager.resolve_temp_folder_name,
+                max_nbytes=max_nbytes, mmap_mode=mmap_mode,
+                forward_reducers=forward_reducers,
+                backward_reducers=backward_reducers, verbose=verbose,
+                unlink_on_gc_collect=False, prewarm=prewarm)
+
+        poolargs = dict(
+            processes=processes,
+            forward_reducers=forward_reducers,
+            backward_reducers=backward_reducers)
+        poolargs.update(kwargs)
+        super(MemmappingPool, self).__init__(**poolargs)
+
+    def terminate(self):
+        n_retries = 10
+        for i in range(n_retries):
+            try:
+                super(MemmappingPool, self).terminate()
+                break
+            except OSError as e:
+                if isinstance(e, WindowsError):
+                    # Workaround  occasional "[Error 5] Access is denied" issue
+                    # when trying to terminate a process under windows.
+                    sleep(0.1)
+                    if i + 1 == n_retries:
+                        warnings.warn("Failed to terminate worker processes in"
+                                      " multiprocessing pool: %r" % e)
+        self._temp_folder_manager._unlink_temporary_resources()
+
+    @property
+    def _temp_folder(self):
+        # Legacy property in tests. could be removed if we refactored the
+        # memmapping tests. SHOULD ONLY BE USED IN TESTS!
+        # We cache this property because it is called late in the tests - at
+        # this point, all context have been unregistered, and
+        # resolve_temp_folder_name raises an error.
+        if getattr(self, '_cached_temp_folder', None) is not None:
+            return self._cached_temp_folder
+        else:
+            self._cached_temp_folder = self._temp_folder_manager.resolve_temp_folder_name()  # noqa
+            return self._cached_temp_folder

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/joblib/testing.py

@@ -0,0 +1,77 @@
+"""
+Helper for testing.
+"""
+
+import sys
+import warnings
+import os.path
+import re
+import subprocess
+import threading
+
+import pytest
+import _pytest
+
+
+raises = pytest.raises
+warns = pytest.warns
+SkipTest = _pytest.runner.Skipped
+skipif = pytest.mark.skipif
+fixture = pytest.fixture
+parametrize = pytest.mark.parametrize
+timeout = pytest.mark.timeout
+xfail = pytest.mark.xfail
+param = pytest.param
+
+
+def warnings_to_stdout():
+    """ Redirect all warnings to stdout.
+    """
+    showwarning_orig = warnings.showwarning
+
+    def showwarning(msg, cat, fname, lno, file=None, line=0):
+        showwarning_orig(msg, cat, os.path.basename(fname), line, sys.stdout)
+
+    warnings.showwarning = showwarning
+    # warnings.simplefilter('always')
+
+
+def check_subprocess_call(cmd, timeout=5, stdout_regex=None,
+                          stderr_regex=None):
+    """Runs a command in a subprocess with timeout in seconds.
+
+    Also checks returncode is zero, stdout if stdout_regex is set, and
+    stderr if stderr_regex is set.
+    """
+    proc = subprocess.Popen(cmd, stdout=subprocess.PIPE,
+                            stderr=subprocess.PIPE)
+
+    def kill_process():
+        warnings.warn("Timeout running {}".format(cmd))
+        proc.kill()
+
+    timer = threading.Timer(timeout, kill_process)
+    try:
+        timer.start()
+        stdout, stderr = proc.communicate()
+        stdout, stderr = stdout.decode(), stderr.decode()
+        if proc.returncode != 0:
+            message = (
+                'Non-zero return code: {}.\nStdout:\n{}\n'
+                'Stderr:\n{}').format(
+                    proc.returncode, stdout, stderr)
+            raise ValueError(message)
+
+        if (stdout_regex is not None and
+                not re.search(stdout_regex, stdout)):
+            raise ValueError(
+                "Unexpected stdout: {!r} does not match:\n{!r}".format(
+                    stdout_regex, stdout))
+        if (stderr_regex is not None and
+                not re.search(stderr_regex, stderr)):
+            raise ValueError(
+                "Unexpected stderr: {!r} does not match:\n{!r}".format(
+                    stderr_regex, stderr))
+
+    finally:
+        timer.cancel()

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

@@ -0,0 +1,92 @@
+"""
+Machine Learning module for NeuroImaging in python
+--------------------------------------------------
+
+Documentation is available in the docstrings and online at
+http://nilearn.github.io.
+
+Contents
+--------
+Nilearn aims at simplifying the use of the scikit-learn package in the context of
+neuroimaging. It provides specific input/output functions, algorithms and
+visualization tools.
+
+Submodules
+---------
+datasets                --- Utilities to download NeuroImaging datasets
+decoding                --- Decoding tools and algorithms
+decomposition           --- Includes a subject level variant of the ICA
+                            algorithm called Canonical ICA
+connectome              --- Set of tools for computing functional connectivity matrices
+                            and for sparse multi-subjects learning of Gaussian graphical models
+image                   --- Set of functions defining mathematical operations
+                            working on Niimg-like objects
+maskers                 --- Includes scikit-learn transformers.
+masking                 --- Utilities to compute and operate on brain masks
+interfaces              --- Includes tools to preprocess neuro-imaging data
+                            from various common interfaces like fMRIPrep.
+mass_univariate         --- Defines a Massively Univariate Linear Model
+                            estimated with OLS and permutation test
+plotting                --- Plotting code for nilearn
+region                  --- Set of functions for extracting region-defined
+                            signals, clustering methods, connected regions extraction
+signal                  --- Set of preprocessing functions for time series
+"""
+
+import gzip
+import os
+import sys
+import pkg_resources
+import warnings
+
+from .version import (
+    _check_module_dependencies, __version__, _compare_version
+)
+
+# Workaround issue discovered in intel-openmp 2019.5:
+# https://github.com/ContinuumIO/anaconda-issues/issues/11294
+#
+# see also https://github.com/scikit-learn/scikit-learn/pull/15020
+os.environ.setdefault("KMP_INIT_AT_FORK", "FALSE")
+
+
+def _py36_deprecation_warning():
+    py36_warning = ("Python 3.6 support is deprecated and will be removed in "
+                    "release 0.10 of Nilearn. Consider switching to "
+                    "Python 3.8 or 3.9.")
+    warnings.filterwarnings('once', message=py36_warning)
+    warnings.warn(message=py36_warning,
+                  category=FutureWarning,
+                  stacklevel=3)
+
+
+def _python_deprecation_warnings():
+    if sys.version_info.major == 3 and sys.version_info.minor == 6:
+        _py36_deprecation_warning()
+
+
+_check_module_dependencies()
+_python_deprecation_warnings()
+
+
+# Monkey-patch gzip to have faster reads on large gzip files
+if hasattr(gzip.GzipFile, 'max_read_chunk'):
+    gzip.GzipFile.max_read_chunk = 100 * 1024 * 1024  # 100Mb
+
+# Boolean controlling the default globbing technique when using check_niimg
+# and the os.path.expanduser usage in CacheMixin.
+# Default value it True, set it to False to completely deactivate this
+# behavior.
+EXPAND_PATH_WILDCARDS = True
+
+# Boolean controlling whether the joblib caches should be
+# flushed if the version of certain modules changes (eg nibabel, as it
+# does not respect the backward compatibility in some of its internal
+# structures
+# This  is used in nilearn._utils.cache_mixin
+CHECK_CACHE_VERSION = True
+
+# list all submodules available in nilearn and version
+__all__ = ['datasets', 'decoding', 'decomposition', 'connectome',
+           'image', 'maskers', 'masking', 'interfaces', 'mass_univariate',
+           'plotting', 'regions', 'signal', 'surface', '__version__']

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/nilearn/conftest.py

@@ -0,0 +1,51 @@
+
+import numpy as np
+import pytest
+
+from _pytest.doctest import DoctestItem
+
+# we need to import these fixtures even if not used in this module
+from nilearn.datasets._testing import request_mocker  # noqa: F401
+from nilearn.datasets._testing import temp_nilearn_data_dir  # noqa: F401
+from nilearn.version import _compare_version
+
+
+collect_ignore = ["datasets/data/convert_templates.py"]
+
+
+try:
+    import matplotlib  # noqa: F401
+except ImportError:
+    collect_ignore.extend(['plotting', 'reporting'])
+    matplotlib = None
+
+
+def pytest_configure(config):
+    """Use Agg so that no figures pop up."""
+    if matplotlib is not None:
+        matplotlib.use('Agg', force=True)
+
+
+@pytest.fixture(autouse=True)
+def close_all():
+    """Close all matplotlib figures."""
+    yield
+    if matplotlib is not None:
+        import matplotlib.pyplot as plt
+        plt.close('all')  # takes < 1 us so just always do it
+
+
+def pytest_collection_modifyitems(items):
+    # numpy changed the str/repr formatting of numpy arrays in 1.14.
+    # We want to run doctests only for numpy >= 1.14.Adapted from scikit-learn
+    if _compare_version(np.__version__, '<', '1.14'):
+        reason = 'doctests are only run for numpy >= 1.14'
+        skip_doctests = True
+    else:
+        skip_doctests = False
+
+    if skip_doctests:
+        skip_marker = pytest.mark.skip(reason=reason)
+        for item in items:
+            if isinstance(item, DoctestItem):
+                item.add_marker(skip_marker)

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/nilearn/masking.py

@@ -0,0 +1,940 @@
+"""
+Utilities to compute and operate on brain masks
+"""
+# Authors: Gael Varoquaux, Alexandre Abraham, Philippe Gervais, Ana Luisa Pinho
+# License: simplified BSD
+import warnings
+import numbers
+
+import numpy as np
+from scipy import ndimage
+from joblib import Parallel, delayed
+
+from sklearn.utils import deprecated
+from . import _utils
+from .image import get_data, new_img_like, resampling
+from ._utils import fill_doc
+from ._utils.cache_mixin import cache
+from ._utils.ndimage import largest_connected_component, get_border_data
+from ._utils.niimg import _safe_get_data
+from .datasets import (load_mni152_template, load_mni152_gm_template,
+                       load_mni152_wm_template)
+
+
+class MaskWarning(UserWarning):
+    "A class to always raise warnings"
+
+
+warnings.simplefilter("always", MaskWarning)
+
+
+def _load_mask_img(mask_img, allow_empty=False):
+    """Check that a mask is valid, ie with two values including 0 and load it.
+
+    Parameters
+    ----------
+    mask_img : Niimg-like object
+        See https://nilearn.github.io/stable/manipulating_images/input_output.html  # noqa:E501
+        The mask to check.
+
+    allow_empty : :obj:`bool`, optional
+        Allow loading an empty mask (full of 0 values).
+        Default=False.
+
+    Returns
+    -------
+    mask : :class:`numpy.ndarray`
+        Boolean version of the mask.
+
+    mask_affine: None or (4,4) array-like
+        Affine of the mask.
+    """
+    mask_img = _utils.check_niimg_3d(mask_img)
+    mask = _safe_get_data(mask_img, ensure_finite=True)
+    values = np.unique(mask)
+
+    if len(values) == 1:
+        # We accept a single value if it is not 0 (full true mask).
+        if values[0] == 0 and not allow_empty:
+            raise ValueError(
+                'The mask is invalid as it is empty: it masks all data.')
+    elif len(values) == 2:
+        # If there are 2 different values, one of them must be 0 (background)
+        if 0 not in values:
+            raise ValueError('Background of the mask must be represented with'
+                             '0. Given mask contains: %s.' % values)
+    elif len(values) != 2:
+        # If there are more than 2 values, the mask is invalid
+        raise ValueError('Given mask is not made of 2 values: %s'
+                         '. Cannot interpret as true or false'
+                         % values)
+
+    mask = _utils.as_ndarray(mask, dtype=bool)
+    return mask, mask_img.affine
+
+
+def _extrapolate_out_mask(data, mask, iterations=1):
+    """Extrapolate values outside of the mask."""
+    if iterations > 1:
+        data, mask = _extrapolate_out_mask(data, mask,
+                                           iterations=iterations - 1)
+    new_mask = ndimage.binary_dilation(mask)
+    larger_mask = np.zeros(np.array(mask.shape) + 2, dtype=bool)
+    larger_mask[1:-1, 1:-1, 1:-1] = mask
+    # Use nans as missing value: ugly
+    masked_data = np.zeros(larger_mask.shape + data.shape[3:])
+    masked_data[1:-1, 1:-1, 1:-1] = data.copy()
+    masked_data[np.logical_not(larger_mask)] = np.nan
+    outer_shell = larger_mask.copy()
+    outer_shell[1:-1, 1:-1, 1:-1] = np.logical_xor(new_mask, mask)
+    outer_shell_x, outer_shell_y, outer_shell_z = np.where(outer_shell)
+    extrapolation = list()
+    for i, j, k in [(1, 0, 0), (-1, 0, 0),
+                    (0, 1, 0), (0, -1, 0),
+                    (0, 0, 1), (0, 0, -1)]:
+        this_x = outer_shell_x + i
+        this_y = outer_shell_y + j
+        this_z = outer_shell_z + k
+        extrapolation.append(masked_data[this_x, this_y, this_z])
+
+    extrapolation = np.array(extrapolation)
+    extrapolation = (np.nansum(extrapolation, axis=0) /
+                     np.sum(np.isfinite(extrapolation), axis=0))
+    extrapolation[np.logical_not(np.isfinite(extrapolation))] = 0
+    new_data = np.zeros_like(masked_data)
+    new_data[outer_shell] = extrapolation
+    new_data[larger_mask] = masked_data[larger_mask]
+    return new_data[1:-1, 1:-1, 1:-1], new_mask
+
+
+#
+# Utilities to compute masks
+#
+@_utils.fill_doc
+def intersect_masks(mask_imgs, threshold=0.5, connected=True):
+    """Compute intersection of several masks.
+
+    Given a list of input mask images, generate the output image which
+    is the threshold-level intersection of the inputs.
+
+    Parameters
+    ----------
+    mask_imgs : :obj:`list` of Niimg-like objects
+        See https://nilearn.github.io/stable/manipulating_images/input_output.html  # noqa:E501
+        3D individual masks with same shape and affine.
+
+    threshold : :obj:`float`, optional
+        Gives the level of the intersection, must be within [0, 1].
+        threshold=1 corresponds to keeping the intersection of all
+        masks, whereas threshold=0 is the union of all masks.
+        Default=0.5.
+    %(connected)s
+        Default=True.
+
+    Returns
+    -------
+    grp_mask : 3D :class:`nibabel.nifti1.Nifti1Image`
+        Intersection of all masks.
+    """
+    if len(mask_imgs) == 0:
+        raise ValueError('No mask provided for intersection')
+    grp_mask = None
+    first_mask, ref_affine = _load_mask_img(mask_imgs[0], allow_empty=True)
+    ref_shape = first_mask.shape
+    if threshold > 1:
+        raise ValueError('The threshold should be smaller than 1')
+    if threshold < 0:
+        raise ValueError('The threshold should be greater than 0')
+    threshold = min(threshold, 1 - 1.e-7)
+
+    for this_mask in mask_imgs:
+        mask, affine = _load_mask_img(this_mask, allow_empty=True)
+        if np.any(affine != ref_affine):
+            raise ValueError("All masks should have the same affine")
+        if np.any(mask.shape != ref_shape):
+            raise ValueError("All masks should have the same shape")
+
+        if grp_mask is None:
+            # We use int here because there may be a lot of masks to merge
+            grp_mask = _utils.as_ndarray(mask, dtype=int)
+        else:
+            # If this_mask is floating point and grp_mask is integer, numpy 2
+            # casting rules raise an error for in-place addition. Hence we do
+            # it long-hand.
+            # XXX should the masks be coerced to int before addition?
+            grp_mask += mask
+
+    grp_mask = grp_mask > (threshold * len(list(mask_imgs)))
+
+    if np.any(grp_mask > 0) and connected:
+        grp_mask = largest_connected_component(grp_mask)
+    grp_mask = _utils.as_ndarray(grp_mask, dtype=np.int8)
+    return new_img_like(_utils.check_niimg_3d(mask_imgs[0]), grp_mask,
+                        ref_affine)
+
+
+def _post_process_mask(mask, affine, opening=2, connected=True,
+                       warning_msg=""):
+    """Helper function for mask computing functions.
+
+    Performs opening and keep only largest connected component is
+    ``connected=True``.
+    """
+    if opening:
+        opening = int(opening)
+        mask = ndimage.binary_erosion(mask, iterations=opening)
+    mask_any = mask.any()
+    if not mask_any:
+        warnings.warn("Computed an empty mask. %s" % warning_msg,
+                      MaskWarning, stacklevel=2)
+    if connected and mask_any:
+        mask = largest_connected_component(mask)
+    if opening:
+        mask = ndimage.binary_dilation(mask, iterations=2 * opening)
+        mask = ndimage.binary_erosion(mask, iterations=opening)
+    return mask, affine
+
+
+@_utils.fill_doc
+def compute_epi_mask(epi_img, lower_cutoff=0.2, upper_cutoff=0.85,
+                     connected=True, opening=2, exclude_zeros=False,
+                     ensure_finite=True,
+                     target_affine=None, target_shape=None,
+                     memory=None, verbose=0,):
+    """Compute a brain mask from :term:`fMRI` data in 3D or
+    4D :class:`numpy.ndarray`.
+
+    This is based on an heuristic proposed by T.Nichols:
+    find the least dense point of the histogram, between fractions
+    ``lower_cutoff`` and ``upper_cutoff`` of the total image histogram.
+
+    .. note::
+
+        In case of failure, it is usually advisable to
+        increase ``lower_cutoff``.
+
+    Parameters
+    ----------
+    epi_img : Niimg-like object
+        See https://nilearn.github.io/stable/manipulating_images/input_output.html  # noqa:E501
+        :term:`EPI` image, used to compute the mask.
+        3D and 4D images are accepted.
+
+        .. note::
+            If a 3D image is given, we suggest to use the mean image.
+
+    %(lower_cutoff)s
+        Default=0.2.
+    %(upper_cutoff)s
+        Default=0.85.
+    %(connected)s
+        Default=True.
+    %(opening)s
+        Default=2.
+    ensure_finite : :obj:`bool`
+        If ensure_finite is True, the non-finite values (NaNs and infs)
+        found in the images will be replaced by zeros
+        Default=True.
+
+    exclude_zeros : :obj:`bool`, optional
+        Consider zeros as missing values for the computation of the
+        threshold. This option is useful if the images have been
+        resliced with a large padding of zeros.
+        Default=False.
+    %(target_affine)s
+
+        .. note::
+            This parameter is passed to :func:`nilearn.image.resample_img`.
+
+    %(target_shape)s
+
+        .. note::
+            This parameter is passed to :func:`nilearn.image.resample_img`.
+
+    %(memory)s
+    %(verbose0)s
+
+    Returns
+    -------
+    mask : :class:`nibabel.nifti1.Nifti1Image`
+        The brain mask (3D image).
+    """
+    if verbose > 0:
+        print("EPI mask computation")
+
+    # Delayed import to avoid circular imports
+    from .image.image import _compute_mean
+    mean_epi, affine = \
+        cache(_compute_mean, memory)(epi_img, target_affine=target_affine,
+                                     target_shape=target_shape,
+                                     smooth=(1 if opening else False))
+
+    if ensure_finite:
+        # Get rid of memmapping
+        mean_epi = _utils.as_ndarray(mean_epi)
+        # SPM tends to put NaNs in the data outside the brain
+        mean_epi[np.logical_not(np.isfinite(mean_epi))] = 0
+    sorted_input = np.sort(np.ravel(mean_epi))
+    if exclude_zeros:
+        sorted_input = sorted_input[sorted_input != 0]
+    lower_cutoff = int(np.floor(lower_cutoff * len(sorted_input)))
+    upper_cutoff = min(int(np.floor(upper_cutoff * len(sorted_input))),
+                       len(sorted_input) - 1)
+
+    delta = sorted_input[lower_cutoff + 1:upper_cutoff + 1] \
+        - sorted_input[lower_cutoff:upper_cutoff]
+    ia = delta.argmax()
+    threshold = 0.5 * (sorted_input[ia + lower_cutoff] +
+                       sorted_input[ia + lower_cutoff + 1])
+
+    mask = mean_epi >= threshold
+
+    mask, affine = _post_process_mask(mask, affine, opening=opening,
+                                      connected=connected,
+                                      warning_msg="Are you sure that input "
+                                      "data are EPI images not detrended. ")
+    return new_img_like(epi_img, mask, affine)
+
+
+@_utils.fill_doc
+def compute_multi_epi_mask(epi_imgs, lower_cutoff=0.2, upper_cutoff=0.85,
+                           connected=True, opening=2, threshold=0.5,
+                           target_affine=None, target_shape=None,
+                           exclude_zeros=False, n_jobs=1,
+                           memory=None, verbose=0):
+    """Compute a common mask for several sessions or subjects
+    of :term:`fMRI` data.
+
+    Uses the mask-finding algorithms to extract masks for each session
+    or subject, and then keep only the main connected component of the
+    a given fraction of the intersection of all the masks.
+
+    Parameters
+    ----------
+    epi_imgs : :obj:`list` of Niimg-like objects
+        See https://nilearn.github.io/stable/manipulating_images/input_output.html  # noqa:E501
+        A list of arrays, each item being a subject or a session.
+        3D and 4D images are accepted.
+
+        .. note::
+
+            If 3D images are given, we suggest to use the mean image
+            of each session.
+
+    threshold : :obj:`float`, optional
+        The inter-session threshold: the fraction of the
+        total number of sessions in for which a :term:`voxel` must be
+        in the mask to be kept in the common mask.
+        threshold=1 corresponds to keeping the intersection of all
+        masks, whereas threshold=0 is the union of all masks.
+    %(lower_cutoff)s
+        Default=0.2.
+    %(upper_cutoff)s
+        Default=0.85.
+    %(connected)s
+        Default=True.
+    exclude_zeros : :obj:`bool`, optional
+        Consider zeros as missing values for the computation of the
+        threshold. This option is useful if the images have been
+        resliced with a large padding of zeros.
+        Default=False.
+    %(target_affine)s
+
+        .. note::
+            This parameter is passed to :func:`nilearn.image.resample_img`.
+
+    %(target_shape)s
+
+        .. note::
+            This parameter is passed to :func:`nilearn.image.resample_img`.
+
+    %(memory)s
+    %(n_jobs)s
+
+    Returns
+    -------
+    mask : 3D :class:`nibabel.nifti1.Nifti1Image`
+        The brain mask.
+    """
+    if len(epi_imgs) == 0:
+        raise TypeError('An empty object - %r - was passed instead of an '
+                        'image or a list of images' % epi_imgs)
+    masks = Parallel(n_jobs=n_jobs, verbose=verbose)(
+        delayed(compute_epi_mask)(epi_img,
+                                  lower_cutoff=lower_cutoff,
+                                  upper_cutoff=upper_cutoff,
+                                  connected=connected,
+                                  opening=opening,
+                                  exclude_zeros=exclude_zeros,
+                                  target_affine=target_affine,
+                                  target_shape=target_shape,
+                                  memory=memory)
+        for epi_img in epi_imgs)
+
+    mask = intersect_masks(masks, connected=connected, threshold=threshold)
+    return mask
+
+
+@_utils.fill_doc
+def compute_background_mask(data_imgs, border_size=2,
+                            connected=False, opening=False,
+                            target_affine=None, target_shape=None,
+                            memory=None, verbose=0):
+    """Compute a brain mask for the images by guessing the value of the
+    background from the border of the image.
+
+    Parameters
+    ----------
+    data_imgs : Niimg-like object
+        See https://nilearn.github.io/stable/manipulating_images/input_output.html  # noqa:E501
+        Images used to compute the mask. 3D and 4D images are accepted.
+
+        .. note::
+
+            If a 3D image is given, we suggest to use the mean image.
+
+    %(border_size)s
+        Default=2.
+    %(connected)s
+        Default=False.
+    %(opening)s
+        Default=False.
+    %(target_affine)s
+
+        .. note::
+            This parameter is passed to :func:`nilearn.image.resample_img`.
+
+    %(target_shape)s
+
+        .. note::
+            This parameter is passed to :func:`nilearn.image.resample_img`.
+
+    %(memory)s
+    %(verbose0)s
+
+    Returns
+    -------
+    mask : :class:`nibabel.nifti1.Nifti1Image`
+        The brain mask (3D image).
+    """
+    if verbose > 0:
+        print("Background mask computation")
+
+    data_imgs = _utils.check_niimg(data_imgs)
+
+    # Delayed import to avoid circular imports
+    from .image.image import _compute_mean
+    data, affine = cache(_compute_mean, memory)(data_imgs,
+                                                target_affine=target_affine,
+                                                target_shape=target_shape,
+                                                smooth=False)
+
+    if np.isnan(get_border_data(data, border_size)).any():
+        # We absolutely need to catter for NaNs as a background:
+        # SPM does that by default
+        mask = np.logical_not(np.isnan(data))
+    else:
+        background = np.median(get_border_data(data, border_size))
+        mask = data != background
+
+    mask, affine = _post_process_mask(mask, affine, opening=opening,
+                                      connected=connected,
+                                      warning_msg="Are you sure that input "
+                                      "images have a homogeneous background.")
+    return new_img_like(data_imgs, mask, affine)
+
+
+@_utils.fill_doc
+def compute_multi_background_mask(data_imgs, border_size=2, upper_cutoff=0.85,
+                                  connected=True, opening=2, threshold=0.5,
+                                  target_affine=None, target_shape=None,
+                                  exclude_zeros=False, n_jobs=1,
+                                  memory=None, verbose=0):
+    """Compute a common mask for several sessions or subjects of data.
+
+    Uses the mask-finding algorithms to extract masks for each session
+    or subject, and then keep only the main connected component of the
+    a given fraction of the intersection of all the masks.
+
+    Parameters
+    ----------
+    data_imgs : :obj:`list` of Niimg-like objects
+        See https://nilearn.github.io/stable/manipulating_images/input_output.html  # noqa:E501
+        A list of arrays, each item being a subject or a session.
+        3D and 4D images are accepted.
+
+        .. note::
+            If 3D images are given, we suggest to use the mean image
+            of each session.
+
+    threshold : :obj:`float`, optional
+        The inter-session threshold: the fraction of the
+        total number of session in for which a :term:`voxel` must be
+        in the mask to be kept in the common mask.
+        threshold=1 corresponds to keeping the intersection of all
+        masks, whereas threshold=0 is the union of all masks.
+    %(border_size)s
+        Default=2.
+    %(connected)s
+        Default=True.
+    %(target_affine)s
+
+        .. note::
+            This parameter is passed to :func:`nilearn.image.resample_img`.
+
+    %(target_shape)s
+
+        .. note::
+            This parameter is passed to :func:`nilearn.image.resample_img`.
+
+    %(memory)s
+    %(n_jobs)s
+
+    Returns
+    -------
+    mask : 3D :class:`nibabel.nifti1.Nifti1Image`
+        The brain mask.
+    """
+    if len(data_imgs) == 0:
+        raise TypeError('An empty object - %r - was passed instead of an '
+                        'image or a list of images' % data_imgs)
+    masks = Parallel(n_jobs=n_jobs, verbose=verbose)(
+        delayed(compute_background_mask)(img,
+                                         border_size=border_size,
+                                         connected=connected,
+                                         opening=opening,
+                                         target_affine=target_affine,
+                                         target_shape=target_shape,
+                                         memory=memory)
+        for img in data_imgs)
+
+    mask = intersect_masks(masks, connected=connected, threshold=threshold)
+    return mask
+
+
+@_utils.fill_doc
+def compute_brain_mask(target_img, threshold=.5, connected=True, opening=2,
+                       memory=None, verbose=0, mask_type='whole-brain'):
+    """Compute the whole-brain, grey-matter or white-matter mask.
+    This mask is calculated using MNI152 1mm-resolution template mask onto the
+    target image.
+
+    Parameters
+    ----------
+    target_img : Niimg-like object
+        See https://nilearn.github.io/stable/manipulating_images/input_output.html  # noqa:E501
+        Images used to compute the mask. 3D and 4D images are accepted.
+        Only the shape and affine of ``target_img`` will be used here.
+
+    threshold : :obj:`float`, optional
+        The value under which the :term:`MNI` template is cut off.
+        Default=0.5
+    %(connected)s
+        Default=True.
+    %(opening)s
+        Default=2.
+    %(memory)s
+    %(verbose0)s
+    %(mask_type)s
+
+        .. versionadded:: 0.8.1
+
+    Returns
+    -------
+    mask : :class:`nibabel.nifti1.Nifti1Image`
+        The whole-brain mask (3D image).
+    """
+    if verbose > 0:
+        print("Template", mask_type, "mask computation")
+
+    target_img = _utils.check_niimg(target_img)
+
+    if mask_type == 'whole-brain':
+        template = load_mni152_template(resolution=1)
+    elif mask_type == 'gm':
+        template = load_mni152_gm_template(resolution=1)
+    elif mask_type == 'wm':
+        template = load_mni152_wm_template(resolution=1)
+    else:
+        raise ValueError(f"Unknown mask type {mask_type}. "
+                         "Only 'whole-brain', 'gm' or 'wm' are accepted.")
+
+    resampled_template = cache(resampling.resample_to_img, memory)(
+        template, target_img)
+
+    mask = (get_data(resampled_template) >= threshold).astype("int8")
+
+    warning_message = (f"{mask_type} mask is empty, "
+                       "lower the threshold or check your input FOV")
+    mask, affine = _post_process_mask(mask, target_img.affine, opening=opening,
+                                      connected=connected,
+                                      warning_msg=warning_message)
+
+    return new_img_like(target_img, mask, affine)
+
+
+@deprecated("Function 'compute_multi_gray_matter_mask' has been renamed to "
+            "'compute_multi_brain_mask' and 'compute_multi_gray_matter_mask' "
+            "will be removed in release 0.10.0")
+@_utils.fill_doc
+def compute_multi_gray_matter_mask(target_imgs, threshold=.5,
+                                   connected=True, opening=2,
+                                   memory=None, verbose=0, n_jobs=1, **kwargs):
+    """Compute a mask corresponding to the gray matter part of the brain for
+    a list of images.
+
+    The gray matter part is calculated through the resampling of MNI152
+    template gray matter mask onto the target image
+
+    Parameters
+    ----------
+    target_imgs : :obj:`list` of Niimg-like object
+        See https://nilearn.github.io/stable/manipulating_images/input_output.html  # noqa:E501
+        Images used to compute the mask. 3D and 4D images are accepted.
+
+        .. note::
+            The images in this list must be of same shape and affine.
+            The mask is calculated with the first element of the list
+            for only the shape/affine of the image is used for this
+            masking strategy.
+
+    threshold : :obj:`float`, optional
+        The value under which the :term:`MNI` template is cut off.
+        Default=0.5.
+    %(connected)s
+        Default=True.
+    %(opening)s
+        Default=2.
+    %(memory)s
+    %(verbose0)s
+    %(n_jobs)s
+
+        .. note::
+            Argument not used but kept to fit the API.
+
+    **kwargs : optional arguments
+        arguments such as 'target_affine' are used in the call of other
+        masking strategies, which then would raise an error for this function
+        which does not need such arguments.
+
+    Returns
+    -------
+    mask : :class:`nibabel.nifti1.Nifti1Image`
+        The brain mask (3D image).
+
+    See also
+    --------
+    nilearn.masking.compute_brain_mask
+    """
+    return compute_multi_brain_mask(target_imgs=target_imgs,
+                                    threshold=threshold, connected=connected,
+                                    opening=opening, memory=memory,
+                                    verbose=verbose, n_jobs=n_jobs,
+                                    mask_type='whole-brain', **kwargs)
+
+
+@_utils.fill_doc
+def compute_multi_brain_mask(target_imgs, threshold=.5, connected=True,
+                             opening=2, memory=None, verbose=0, n_jobs=1,
+                             mask_type='whole-brain', **kwargs):
+    """Compute the whole-brain, grey-matter or white-matter mask for a list of
+    images. The mask is calculated through the resampling of the corresponding
+    MNI152 template mask onto the target image.
+
+    .. versionadded:: 0.8.1
+
+    Parameters
+    ----------
+    target_imgs : :obj:`list` of Niimg-like object
+        See https://nilearn.github.io/stable/manipulating_images/input_output.html  # noqa:E501
+        Images used to compute the mask. 3D and 4D images are accepted.
+
+        .. note::
+            The images in this list must be of same shape and affine.
+            The mask is calculated with the first element of the list
+            for only the shape/affine of the image is used for this
+            masking strategy.
+
+    threshold : :obj:`float`, optional
+        The value under which the :term:`MNI` template is cut off.
+        Default=0.5.
+    %(connected)s
+        Default=True.
+    %(opening)s
+        Default=2.
+    %(mask_type)s
+    %(memory)s
+    %(verbose0)s
+    %(n_jobs)s
+
+        .. note::
+            Argument not used but kept to fit the API
+
+    **kwargs : optional arguments
+        Arguments such as 'target_affine' are used in the call of other
+        masking strategies, which then would raise an error for this function
+        which does not need such arguments.
+
+    Returns
+    -------
+    mask : :class:`nibabel.nifti1.Nifti1Image`
+        The brain mask (3D image).
+
+    See also
+    --------
+    nilearn.masking.compute_brain_mask
+    """
+    if len(target_imgs) == 0:
+        raise TypeError('An empty object - %r - was passed instead of an '
+                        'image or a list of images' % target_imgs)
+
+    # Check images in the list have the same FOV without loading them in memory
+    imgs_generator = _utils.check_niimg(target_imgs, return_iterator=True)
+    for _ in imgs_generator:
+        pass
+
+    mask = compute_brain_mask(target_imgs[0], threshold=threshold,
+                              connected=connected, opening=opening,
+                              memory=memory, verbose=verbose,
+                              mask_type=mask_type)
+    return mask
+
+
+#
+# Time series extraction
+#
+
+@fill_doc
+def apply_mask(imgs, mask_img, dtype='f',
+               smoothing_fwhm=None, ensure_finite=True):
+    """Extract signals from images using specified mask.
+
+    Read the time series from the given Niimg-like object, using the mask.
+
+    Parameters
+    -----------
+    imgs : :obj:`list` of 4D Niimg-like objects
+        See https://nilearn.github.io/stable/manipulating_images/input_output.html  # noqa:E501
+        Images to be masked. list of lists of 3D images are also accepted.
+
+    mask_img : Niimg-like object
+        See https://nilearn.github.io/stable/manipulating_images/input_output.html  # noqa:E501
+        3D mask array: True where a :term:`voxel` should be used.
+
+    dtype: numpy dtype or 'f'
+        The dtype of the output, if 'f', any float output is acceptable
+        and if the data is stored on the disk as floats the data type
+        will not be changed.
+    %(smoothing_fwhm)s
+
+        .. note::
+
+            Implies ensure_finite=True.
+
+    ensure_finite : :obj:`bool`
+        If ensure_finite is True, the non-finite values (NaNs and
+        infs) found in the images will be replaced by zeros.
+        Default=True.
+
+    Returns
+    --------
+    session_series : :class:`numpy.ndarray`
+        2D array of series with shape (image number, :term:`voxel` number)
+
+    Notes
+    -----
+    When using smoothing, ``ensure_finite`` is set to True, as non-finite
+    values would spread across the image.
+    """
+    mask_img = _utils.check_niimg_3d(mask_img)
+    mask, mask_affine = _load_mask_img(mask_img)
+    mask_img = new_img_like(mask_img, mask, mask_affine)
+    return _apply_mask_fmri(imgs, mask_img, dtype=dtype,
+                            smoothing_fwhm=smoothing_fwhm,
+                            ensure_finite=ensure_finite)
+
+
+def _apply_mask_fmri(imgs, mask_img, dtype='f',
+                     smoothing_fwhm=None, ensure_finite=True):
+    """Same as :func:`nilearn.masking.apply_mask`.
+
+    The only difference with :func:`nilearn.masking.apply_mask` is that
+    some costly checks on ``mask_img`` are not performed: ``mask_img`` is
+    assumed to contain only two different values (this is checked for in
+    :func:`nilearn.masking.apply_mask`, not in this function).
+    """
+    mask_img = _utils.check_niimg_3d(mask_img)
+    mask_affine = mask_img.affine
+    mask_data = _utils.as_ndarray(get_data(mask_img),
+                                  dtype=bool)
+
+    if smoothing_fwhm is not None:
+        ensure_finite = True
+
+    imgs_img = _utils.check_niimg(imgs)
+    affine = imgs_img.affine[:3, :3]
+
+    if not np.allclose(mask_affine, imgs_img.affine):
+        raise ValueError('Mask affine: \n%s\n is different from img affine:'
+                         '\n%s' % (str(mask_affine),
+                                   str(imgs_img.affine)))
+
+    if not mask_data.shape == imgs_img.shape[:3]:
+        raise ValueError('Mask shape: %s is different from img shape:%s'
+                         % (str(mask_data.shape), str(imgs_img.shape[:3])))
+
+    # All the following has been optimized for C order.
+    # Time that may be lost in conversion here is regained multiple times
+    # afterward, especially if smoothing is applied.
+    series = _safe_get_data(imgs_img)
+
+    if dtype == 'f':
+        if series.dtype.kind == 'f':
+            dtype = series.dtype
+        else:
+            dtype = np.float32
+    series = _utils.as_ndarray(series, dtype=dtype, order="C",
+                               copy=True)
+    del imgs_img  # frees a lot of memory
+
+    # Delayed import to avoid circular imports
+    from .image.image import _smooth_array
+    _smooth_array(series, affine, fwhm=smoothing_fwhm,
+                  ensure_finite=ensure_finite, copy=False)
+    return series[mask_data].T
+
+
+def _unmask_3d(X, mask, order="C"):
+    """Take masked data and bring them back to 3D (space only).
+
+    Parameters
+    ----------
+    X : :class:`numpy.ndarray`
+        Masked data. shape: (features,)
+
+    mask : Niimg-like object
+        See https://nilearn.github.io/stable/manipulating_images/input_output.html  # noqa:E501
+        Mask. mask.ndim must be equal to 3, and dtype *must* be bool.
+    """
+    if mask.dtype != bool:
+        raise TypeError("mask must be a boolean array")
+    if X.ndim != 1:
+        raise TypeError("X must be a 1-dimensional array")
+    n_features = mask.sum()
+    if X.shape[0] != n_features:
+        raise TypeError('X must be of shape (samples, %d).' % n_features)
+
+    data = np.zeros(
+        (mask.shape[0], mask.shape[1], mask.shape[2]),
+        dtype=X.dtype, order=order)
+    data[mask] = X
+    return data
+
+
+def _unmask_4d(X, mask, order="C"):
+    """Take masked data and bring them back to 4D.
+
+    Parameters
+    ----------
+    X : :class:`numpy.ndarray`
+        Masked data. shape: (samples, features)
+
+    mask : :class:`numpy.ndarray`
+        Mask. mask.ndim must be equal to 4, and dtype *must* be bool.
+
+    Returns
+    -------
+    data : :class:`numpy.ndarray`
+        Unmasked data.
+        Shape: (mask.shape[0], mask.shape[1], mask.shape[2], X.shape[0])
+    """
+    if mask.dtype != bool:
+        raise TypeError("mask must be a boolean array")
+    if X.ndim != 2:
+        raise TypeError("X must be a 2-dimensional array")
+    n_features = mask.sum()
+    if X.shape[1] != n_features:
+        raise TypeError('X must be of shape (samples, %d).' % n_features)
+
+    data = np.zeros(mask.shape + (X.shape[0],), dtype=X.dtype, order=order)
+    data[mask, :] = X.T
+    return data
+
+
+def unmask(X, mask_img, order="F"):
+    """Take masked data and bring them back into 3D/4D.
+
+    This function can be applied to a list of masked data.
+
+    Parameters
+    ----------
+    X : :class:`numpy.ndarray` (or :obj:`list` of)
+        Masked data. shape: (samples #, features #).
+        If X is one-dimensional, it is assumed that samples# == 1.
+
+    mask_img : Niimg-like object
+        See https://nilearn.github.io/stable/manipulating_images/input_output.html  # noqa:E501
+        Must be 3-dimensional.
+
+    Returns
+    -------
+    data : :class:`nibabel.nifti1.Nifti1Image`
+        Unmasked data. Depending on the shape of X, data can have
+        different shapes:
+
+        - X.ndim == 2:
+          Shape: (mask.shape[0], mask.shape[1], mask.shape[2], X.shape[0])
+        - X.ndim == 1:
+          Shape: (mask.shape[0], mask.shape[1], mask.shape[2])
+    """
+    # Handle lists. This can be a list of other lists / arrays, or a list or
+    # numbers. In the latter case skip.
+    if isinstance(X, list) and not isinstance(X[0], numbers.Number):
+        ret = []
+        for x in X:
+            ret.append(unmask(x, mask_img, order=order))  # 1-level recursion
+        return ret
+
+    # The code after this block assumes that X is an ndarray; ensure this
+    X = np.asanyarray(X)
+
+    mask_img = _utils.check_niimg_3d(mask_img)
+    mask, affine = _load_mask_img(mask_img)
+
+    if np.ndim(X) == 2:
+        unmasked = _unmask_4d(X, mask, order=order)
+    elif np.ndim(X) == 1:
+        unmasked = _unmask_3d(X, mask, order=order)
+    else:
+        raise TypeError("Masked data X must be 2D or 1D array; "
+                        "got shape: %s" % str(X.shape))
+
+    return new_img_like(mask_img, unmasked, affine)
+
+
+def _unmask_from_to_3d_array(w, mask):
+    """Unmask an image into whole brain, with off-mask :term:`voxels<voxel>`
+    set to 0.
+
+    Used as a stand-alone function in low-level decoding (SpaceNet) and
+    clustering (ReNA) functions.
+
+    Parameters
+    ----------
+    w : :class:`numpy.ndarray`, shape (n_features,)
+      The image to be unmasked.
+
+    mask : :class:`numpy.ndarray`, shape (nx, ny, nz)
+      The mask used in the unmasking operation. It is required that
+      ``mask.sum() == n_features``.
+
+    Returns
+    -------
+    out : 3D :class:`numpy.ndarray` (same shape as `mask`)
+        The unmasked version of `w`.
+    """
+    if mask.sum() != len(w):
+        raise ValueError("Expecting mask.sum() == len(w).")
+    out = np.zeros(mask.shape, dtype=w.dtype)
+    out[mask] = w
+    return out

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/nilearn/signal.py

@@ -0,0 +1,870 @@
+"""
+Preprocessing functions for time series.
+
+All functions in this module should take X matrices with samples x
+features
+"""
+# Authors: Alexandre Abraham, Gael Varoquaux, Philippe Gervais
+# License: simplified BSD
+
+import warnings
+
+import numpy as np
+import pandas as pd
+from scipy import linalg, signal as sp_signal
+from sklearn.utils import gen_even_slices, as_float_array
+
+from ._utils.numpy_conversions import csv_to_array, as_ndarray
+from ._utils import fill_doc
+
+
+availiable_filters = ['butterworth',
+                      'cosine'
+                      ]
+
+
+def _standardize(signals, detrend=False, standardize='zscore'):
+    """Center and standardize a given signal (time is along first axis).
+
+    Parameters
+    ----------
+    signals : :class:`numpy.ndarray`
+        Timeseries to standardize.
+
+    detrend : :obj:`bool`, optional
+        If detrending of timeseries is requested.
+        Default=False.
+
+    standardize : {'zscore', 'psc', True, False}, optional
+        Strategy to standardize the signal:
+
+            - 'zscore': The signal is z-scored. Timeseries are shifted
+              to zero mean and scaled to unit variance.
+            - 'psc':  Timeseries are shifted to zero mean value and scaled
+              to percent signal change (as compared to original mean signal).
+            - True: The signal is z-scored (same as option `zscore`).
+              Timeseries are shifted to zero mean and scaled to unit variance.
+            - False: Do not standardize the data.
+
+        Default='zscore'.
+
+    Returns
+    -------
+    std_signals : :class:`numpy.ndarray`
+        Copy of signals, standardized.
+    """
+    if standardize not in [True, False, 'psc', 'zscore']:
+        raise ValueError('{} is no valid standardize strategy.'
+                         .format(standardize))
+
+    if detrend:
+        signals = _detrend(signals, inplace=False)
+    else:
+        signals = signals.copy()
+
+    if standardize:
+        if signals.shape[0] == 1:
+            warnings.warn('Standardization of 3D signal has been requested but '
+                          'would lead to zero values. Skipping.')
+            return signals
+
+        elif (standardize == 'zscore') or (standardize is True):
+            if not detrend:
+                # remove mean if not already detrended
+                signals = signals - signals.mean(axis=0)
+
+            std = signals.std(axis=0)
+            std[std < np.finfo(np.float64).eps] = 1.  # avoid numerical problems
+            signals /= std
+
+        elif standardize == 'psc':
+            mean_signal = signals.mean(axis=0)
+            invalid_ix = np.absolute(mean_signal) < np.finfo(np.float64).eps
+            signals = (signals - mean_signal) / np.absolute(mean_signal)
+            signals *= 100
+
+            if np.any(invalid_ix):
+                warnings.warn('psc standardization strategy is meaningless '
+                              'for features that have a mean of 0. '
+                              'These time series are set to 0.')
+                signals[:, invalid_ix] = 0
+
+    return signals
+
+
+def _mean_of_squares(signals, n_batches=20):
+    """Compute mean of squares for each signal.
+
+    This function is equivalent to:
+
+    .. code-block:: python
+
+        var = np.copy(signals)
+        var **= 2
+        var = var.mean(axis=0)
+
+    but uses a lot less memory.
+
+    Parameters
+    ----------
+    signals : :class:`numpy.ndarray`, shape (n_samples, n_features)
+        Signal whose mean of squares must be computed.
+
+    n_batches : :obj:`int`, optional
+        Number of batches to use in the computation.
+
+        .. note::
+            Tweaking this value can lead to variation of memory usage
+            and computation time. The higher the value, the lower the
+            memory consumption.
+
+        Default=20.
+
+    Returns
+    -------
+    var : :class:`numpy.ndarray`
+        1D array holding the mean of squares.
+    """
+    # No batching for small arrays
+    if signals.shape[1] < 500:
+        n_batches = 1
+
+    # Fastest for C order
+    var = np.empty(signals.shape[1])
+    for batch in gen_even_slices(signals.shape[1], n_batches):
+        tvar = np.copy(signals[:, batch])
+        tvar **= 2
+        var[batch] = tvar.mean(axis=0)
+
+    return var
+
+
+def _row_sum_of_squares(signals, n_batches=20):
+    """Compute sum of squares for each signal.
+
+    This function is equivalent to:
+
+    .. code-block:: python
+
+        signals **= 2
+        signals = signals.sum(axis=0)
+
+    but uses a lot less memory.
+
+    Parameters
+    ----------
+    signals : :class:`numpy.ndarray`, shape (n_samples, n_features)
+        Signal whose sum of squares must be computed.
+
+    n_batches : :obj:`int`, optional
+        Number of batches to use in the computation.
+
+        .. note::
+            Tweaking this value can lead to variation of memory usage
+            and computation time. The higher the value, the lower the
+            memory consumption.
+
+        Default=20.
+
+    Returns
+    -------
+    var : :class:`numpy.ndarray`
+        1D array holding the sum of squares.
+    """
+    # No batching for small arrays
+    if signals.shape[1] < 500:
+        n_batches = 1
+
+    # Fastest for C order
+    var = np.empty(signals.shape[1])
+    for batch in gen_even_slices(signals.shape[1], n_batches):
+        var[batch] = np.sum(signals[:, batch] ** 2, 0)
+
+    return var
+
+
+def _detrend(signals, inplace=False, type="linear", n_batches=10):
+    """Detrend columns of input array.
+
+    Signals are supposed to be columns of `signals`.
+    This function is significantly faster than :func:`scipy.signal.detrend`
+    on this case and uses a lot less memory.
+
+    Parameters
+    ----------
+    signals : :class:`numpy.ndarray`
+        This parameter must be two-dimensional.
+        Signals to detrend. A signal is a column.
+
+    inplace : :obj:`bool`, optional
+        Tells if the computation must be made inplace or not.
+        Default=False.
+
+    type : {"linear", "constant"}, optional
+        Detrending type, either "linear" or "constant".
+        See also :func:`scipy.signal.detrend`.
+        Default="linear".
+
+    n_batches : :obj:`int`, optional
+        Number of batches to use in the computation.
+
+        .. note::
+            Tweaking this value can lead to variation of memory usage
+            and computation time. The higher the value, the lower the
+            memory consumption.
+
+    Returns
+    -------
+    detrended_signals : :class:`numpy.ndarray`
+        Detrended signals. The shape is that of ``signals``.
+
+    Notes
+    -----
+    If a signal of length 1 is given, it is returned unchanged.
+    """
+    signals = as_float_array(signals, copy=not inplace)
+    if signals.shape[0] == 1:
+        warnings.warn('Detrending of 3D signal has been requested but '
+                      'would lead to zero values. Skipping.')
+        return signals
+
+    signals -= np.mean(signals, axis=0)
+    if type == "linear":
+        # Keeping "signals" dtype avoids some type conversion further down,
+        # and can save a lot of memory if dtype is single-precision.
+        regressor = np.arange(signals.shape[0], dtype=signals.dtype)
+        regressor -= regressor.mean()
+        std = np.sqrt((regressor ** 2).sum())
+        # avoid numerical problems
+        if not std < np.finfo(np.float64).eps:
+            regressor /= std
+        regressor = regressor[:, np.newaxis]
+
+        # No batching for small arrays
+        if signals.shape[1] < 500:
+            n_batches = 1
+
+        # This is fastest for C order.
+        for batch in gen_even_slices(signals.shape[1], n_batches):
+            signals[:, batch] -= np.dot(regressor[:, 0], signals[:, batch]
+                                        ) * regressor
+    return signals
+
+
+def _check_wn(btype, freq, nyq):
+    wn = freq / float(nyq)
+    if wn >= 1.:
+        # results looked unstable when the critical frequencies are
+        # exactly at the Nyquist frequency. See issue at SciPy
+        # https://github.com/scipy/scipy/issues/6265. Before, SciPy 1.0.0 ("wn
+        # should be btw 0 and 1"). But, after ("0 < wn < 1"). Due to unstable
+        # results as pointed in the issue above. Hence, we forced the
+        # critical frequencies to be slightly less than 1. but not 1.
+        wn = 1 - 10 * np.finfo(1.).eps
+        warnings.warn(
+            'The frequency specified for the %s pass filter is '
+            'too high to be handled by a digital filter (superior to '
+            'nyquist frequency). It has been lowered to %.2f (nyquist '
+            'frequency).' % (btype, wn))
+
+    if wn < 0.0: # equal to 0.0 is okay
+        wn = np.finfo(1.).eps
+        warnings.warn(
+            'The frequency specified for the %s pass filter is '
+            'too low to be handled by a digital filter (must be non-negative).'
+            ' It has been set to eps: %.5e' % (btype, wn))
+
+    return wn
+
+
+@fill_doc
+def butterworth(signals, sampling_rate, low_pass=None, high_pass=None,
+                order=5, copy=False):
+    """Apply a low-pass, high-pass or band-pass
+    `Butterworth filter <https://en.wikipedia.org/wiki/Butterworth_filter>`_.
+
+    Apply a filter to remove signal below the `low` frequency and above the
+    `high` frequency.
+
+    Parameters
+    ----------
+    signals : :class:`numpy.ndarray` (1D sequence or n_samples x n_sources)
+        Signals to be filtered. A signal is assumed to be a column
+        of `signals`.
+
+    sampling_rate : :obj:`float`
+        Number of samples per time unit (sample frequency).
+    %(low_pass)s
+    %(high_pass)s
+    order : :obj:`int`, optional
+        Order of the `Butterworth filter
+        <https://en.wikipedia.org/wiki/Butterworth_filter>`_.
+        When filtering signals, the filter has a decay to avoid ringing.
+        Increasing the order sharpens this decay. Be aware that very high
+        orders can lead to numerical instability.
+        Default=5.
+
+    copy : :obj:`bool`, optional
+        If False, `signals` is modified inplace, and memory consumption is
+        lower than for ``copy=True``, though computation time is higher.
+
+    Returns
+    -------
+    filtered_signals : :class:`numpy.ndarray`
+        Signals filtered according to the given parameters.
+    """
+    if low_pass is None and high_pass is None:
+        if copy:
+            return signals.copy()
+        else:
+            return signals
+
+    if low_pass is not None and high_pass is not None \
+            and high_pass >= low_pass:
+        raise ValueError(
+            "High pass cutoff frequency (%f) is greater or equal"
+            "to low pass filter frequency (%f). This case is not handled "
+            "by this function."
+            % (high_pass, low_pass))
+
+    nyq = sampling_rate * 0.5
+
+    critical_freq = []
+    if high_pass is not None:
+        btype = 'high'
+        critical_freq.append(_check_wn(btype, high_pass, nyq))
+
+    if low_pass is not None:
+        btype = 'low'
+        critical_freq.append(_check_wn(btype, low_pass, nyq))
+
+    if len(critical_freq) == 2:
+        btype = 'band'
+    else:
+        critical_freq = critical_freq[0]
+
+    b, a = sp_signal.butter(order, critical_freq, btype=btype, output='ba')
+    if signals.ndim == 1:
+        # 1D case
+        output = sp_signal.filtfilt(b, a, signals)
+        if copy:  # filtfilt does a copy in all cases.
+            signals = output
+        else:
+            signals[...] = output
+    else:
+        if copy:
+            # No way to save memory when a copy has been requested,
+            # because filtfilt does out-of-place processing
+            signals = sp_signal.filtfilt(b, a, signals, axis=0)
+        else:
+            # Lesser memory consumption, slower.
+            for timeseries in signals.T:
+                timeseries[:] = sp_signal.filtfilt(b, a, timeseries)
+
+            # results returned in-place
+
+    return signals
+
+
+@fill_doc
+def high_variance_confounds(series, n_confounds=5, percentile=2.,
+                            detrend=True):
+    """Return confounds time series extracted from series with highest
+    variance.
+
+    Parameters
+    ----------
+    series : :class:`numpy.ndarray`
+        Timeseries. A timeseries is a column in the "series" array.
+        shape (sample number, feature number)
+
+    n_confounds : :obj:`int`, optional
+        Number of confounds to return. Default=5.
+
+    percentile : :obj:`float`, optional
+        Highest-variance series percentile to keep before computing the
+        singular value decomposition, 0. <= `percentile` <= 100.
+        ``series.shape[0] * percentile / 100`` must be greater
+        than ``n_confounds``. Default=2.0.
+    %(detrend)s
+        Default=True.
+
+    Returns
+    -------
+    v : :class:`numpy.ndarray`
+        Highest variance confounds. Shape: (samples, n_confounds)
+
+    Notes
+    -----
+    This method is related to what has been published in the literature
+    as 'CompCor' :footcite:`BEHZADI200790`.
+
+    The implemented algorithm does the following:
+
+    - compute sum of squares for each time series (no mean removal)
+    - keep a given percentile of series with highest variances (percentile)
+    - compute an svd of the extracted series
+    - return a given number (n_confounds) of series from the svd with
+      highest singular values.
+
+    References
+    ----------
+    .. footbibliography::
+
+    See also
+    --------
+    nilearn.image.high_variance_confounds
+    """
+    if detrend:
+        series = _detrend(series)  # copy
+
+    # Retrieve the voxels|features with highest variance
+
+    # Compute variance without mean removal.
+    var = _mean_of_squares(series)
+    var_thr = np.nanpercentile(var, 100. - percentile)
+    series = series[:, var > var_thr]  # extract columns (i.e. features)
+    # Return the singular vectors with largest singular values
+    # We solve the symmetric eigenvalue problem here, increasing stability
+    s, u = linalg.eigh(series.dot(series.T) / series.shape[0])
+    ix_ = np.argsort(s)[::-1]
+    u = u[:, ix_[:n_confounds]].copy()
+    return u
+
+
+def _ensure_float(data):
+    "Make sure that data is a float type"
+    if not data.dtype.kind == 'f':
+        if data.dtype.itemsize == '8':
+            data = data.astype(np.float64)
+        else:
+            data = data.astype(np.float32)
+    return data
+
+
+@fill_doc
+def clean(signals, runs=None, detrend=True, standardize='zscore',
+          sample_mask=None, confounds=None, standardize_confounds=True,
+          filter='butterworth', low_pass=None, high_pass=None, t_r=2.5,
+          ensure_finite=False):
+    """Improve :term:`SNR` on masked :term:`fMRI` signals.
+
+    This function can do several things on the input signals, in
+    the following order:
+
+    - detrend
+    - low- and high-pass filter
+    - remove confounds
+    - standardize
+
+    Low-pass filtering improves specificity.
+
+    High-pass filtering should be kept small, to keep some sensitivity.
+
+    Filtering is only meaningful on evenly-sampled signals.
+
+    According to :footcite:`Lindquist407676`, removal of confounds will be done
+    orthogonally to temporal filters (low- and/or high-pass filters), if both
+    are specified.
+
+    Parameters
+    ----------
+    signals : :class:`numpy.ndarray`
+        Timeseries. Must have shape (instant number, features number).
+        This array is not modified.
+
+    runs : :class:`numpy.ndarray`, optional
+        Add a run level to the cleaning process. Each run will be
+        cleaned independently. Must be a 1D array of n_samples elements.
+        Default is None.
+
+    confounds : :class:`numpy.ndarray`, :obj:`str`,\
+    :class:`pandas.DataFrame` or :obj:`list` of
+        Confounds timeseries. Shape must be
+        (instant number, confound number), or just (instant number,)
+        The number of time instants in ``signals`` and ``confounds`` must be
+        identical (i.e. ``signals.shape[0] == confounds.shape[0]``).
+        If a string is provided, it is assumed to be the name of a csv file
+        containing signals as columns, with an optional one-line header.
+        If a list is provided, all confounds are removed from the input
+        signal, as if all were in the same array.
+        Default is None.
+
+    sample_mask : None, :class:`numpy.ndarray`, :obj:`list`,\
+    :obj:`tuple`, or :obj:`list` of
+        shape: (number of scans - number of volumes removed, )
+        Masks the niimgs along time/fourth dimension to perform scrubbing
+        (remove volumes with high motion) and/or non-steady-state volumes.
+        This masking step is applied before signal cleaning. When supplying run
+        information, sample_mask must be a list containing sets of indexes for
+        each run.
+
+            .. versionadded:: 0.8.0
+
+        Default is None.
+    %(t_r)s
+        Default=2.5.
+    filter : {'butterworth', 'cosine', False}, optional
+        Filtering methods:
+
+            - 'butterworth': perform butterworth filtering.
+            - 'cosine': generate discrete cosine transformation drift terms.
+            - False: Do not perform filtering.
+
+        Default='butterworth'.
+    %(low_pass)s
+
+        .. note::
+            `low_pass` is not implemented for filter='cosine'.
+
+    %(high_pass)s
+    %(detrend)s
+    standardize : {'zscore', 'psc', False}, optional
+        Strategy to standardize the signal:
+
+            - 'zscore': The signal is z-scored. Timeseries are shifted
+              to zero mean and scaled to unit variance.
+            - 'psc':  Timeseries are shifted to zero mean value and scaled
+              to percent signal change (as compared to original mean signal).
+            - True: The signal is z-scored (same as option `zscore`).
+              Timeseries are shifted to zero mean and scaled to unit variance.
+            - False: Do not standardize the data.
+
+        Default="zscore".
+    %(standardize_confounds)s
+    %(ensure_finite)s
+        Default=False.
+
+    Returns
+    -------
+    cleaned_signals : :class:`numpy.ndarray`
+        Input signals, cleaned. Same shape as `signals`.
+
+    Notes
+    -----
+    Confounds removal is based on a projection on the orthogonal
+    of the signal space. See :footcite:`Friston1994`.
+
+    Orthogonalization between temporal filters and confound removal is based on
+    suggestions in :footcite:`Lindquist407676`.
+
+    References
+    ----------
+    .. footbibliography::
+
+    See Also
+    --------
+    nilearn.image.clean_img
+    """
+    # Raise warning for some parameter combinations when confounds present
+    if confounds is not None:
+        _check_signal_parameters(detrend, standardize_confounds)
+
+    # Read confounds and signals
+    signals, runs, confounds = _sanitize_inputs(
+        signals, runs, confounds, sample_mask, ensure_finite
+    )
+    use_filter = _check_filter_parameters(filter, low_pass, high_pass, t_r)
+    # Restrict the signal to the orthogonal of the confounds
+    if runs is not None:
+        signals = _process_runs(signals, runs, detrend, standardize,
+                                   confounds, low_pass, high_pass, t_r)
+
+    # Detrend
+    # Detrend and filtering should apply to confounds, if confound presents
+    # keep filters orthogonal (according to Lindquist et al. (2018))
+    if detrend:
+        mean_signals = signals.mean(axis=0)
+        signals = _standardize(signals, standardize=False, detrend=detrend)
+        if confounds is not None:
+            confounds = _standardize(confounds, standardize=False,
+                                detrend=detrend)
+    if use_filter:
+        # check if filter parameters are satisfied and filter according to the strategy
+        signals, confounds = _filter_signal(signals, confounds, filter,
+                                            low_pass, high_pass, t_r)
+
+    # Remove confounds
+    if confounds is not None:
+        confounds = _standardize(confounds, standardize=standardize_confounds,
+                                 detrend=False)
+        if not standardize_confounds:
+            # Improve numerical stability by controlling the range of
+            # confounds. We don't rely on _standardize as it removes any
+            # constant contribution to confounds.
+            confound_max = np.max(np.abs(confounds), axis=0)
+            confound_max[confound_max == 0] = 1
+            confounds /= confound_max
+
+        # Pivoting in qr decomposition was added in scipy 0.10
+        Q, R, _ = linalg.qr(confounds, mode='economic', pivoting=True)
+        Q = Q[:, np.abs(np.diag(R)) > np.finfo(np.float64).eps * 100.]
+        signals -= Q.dot(Q.T).dot(signals)
+
+    # Standardize
+    if detrend and (standardize == 'psc'):
+        # If the signal is detrended, we have to know the original mean
+        # signal to calculate the psc.
+        signals = _standardize(signals + mean_signals, standardize=standardize,
+                               detrend=False)
+    else:
+        signals = _standardize(signals, standardize=standardize,
+                               detrend=False)
+
+    return signals
+
+
+def _filter_signal(signals, confounds, filter, low_pass, high_pass, t_r):
+    '''Filter signal based on provided strategy.'''
+    if filter == 'butterworth':
+        signals = butterworth(signals, sampling_rate=1. / t_r,
+                              low_pass=low_pass, high_pass=high_pass)
+        if confounds is not None:
+            # Apply low- and high-pass filters to keep filters orthogonal
+            # (according to Lindquist et al. (2018))
+            confounds = butterworth(confounds, sampling_rate=1. / t_r,
+                                    low_pass=low_pass, high_pass=high_pass)
+    elif filter == 'cosine':
+        from .glm.first_level.design_matrix import _cosine_drift
+        frame_times = np.arange(signals.shape[0]) * t_r
+        cosine_drift = _cosine_drift(high_pass, frame_times)
+        if confounds is None:
+            confounds = cosine_drift.copy()
+        else:
+            confounds = np.hstack((confounds, cosine_drift))
+    return signals, confounds
+
+
+def _process_runs(signals, runs, detrend, standardize, confounds,
+                  low_pass, high_pass, t_r):
+    """Process each run independently."""
+    if len(runs) != len(signals):
+        raise ValueError(
+            (
+                'The length of the run vector (%i) '
+                'does not match the length of the signals (%i)'
+            ) % (len(runs), len(signals))
+        )
+    for run in np.unique(runs):
+        run_confounds = None
+        if confounds is not None:
+            run_confounds = confounds[runs == run]
+        signals[runs == run, :] = \
+            clean(signals[runs == run],
+                  detrend=detrend, standardize=standardize,
+                  confounds=run_confounds, low_pass=low_pass,
+                  high_pass=high_pass, t_r=t_r)
+    return signals
+
+
+def _sanitize_inputs(signals, runs, confounds, sample_mask, ensure_finite):
+    """Clean up signals and confounds before processing."""
+    n_time = len(signals)  # original length of the signal
+    n_runs, runs = _sanitize_runs(n_time, runs)
+    confounds = _sanitize_confounds(n_time, n_runs, confounds)
+    sample_mask = _sanitize_sample_mask(n_time, n_runs, runs, sample_mask)
+    signals = _sanitize_signals(signals, ensure_finite)
+
+    if sample_mask is None:
+        return signals, runs, confounds
+
+    if confounds is not None:
+        confounds = confounds[sample_mask, :]
+    if runs is not None:
+        runs = runs[sample_mask]
+    return signals[sample_mask, :], runs, confounds
+
+
+def _sanitize_confounds(n_time, n_runs, confounds):
+    """Check confounds are the correct type. When passing multiple runs, ensure the
+    number of runs matches the sets of confound regressors.
+    """
+    if confounds is None:
+        return confounds
+
+    if not isinstance(confounds, (list, tuple, str, np.ndarray, pd.DataFrame)):
+        raise TypeError(
+            "confounds keyword has an unhandled type: %s" % confounds.__class__
+        )
+
+    if not isinstance(confounds, (list, tuple)):
+        confounds = (confounds,)
+
+    all_confounds = []
+    for confound in confounds:
+        confound = _sanitize_confound_dtype(n_time, confound)
+        all_confounds.append(confound)
+    confounds = np.hstack(all_confounds)
+    return _ensure_float(confounds)
+
+
+def _sanitize_sample_mask(n_time, n_runs, runs, sample_mask):
+    """Check sample_mask is the right data type and matches the run index."""
+    if sample_mask is None:
+        return sample_mask
+    if not isinstance(sample_mask, (list, tuple, np.ndarray)):
+        raise TypeError(
+            "sample_mask has an unhandled type: %s" % sample_mask.__class__
+        )
+    if not isinstance(sample_mask, (list, tuple)):
+        sample_mask = (sample_mask, )
+
+    if len(sample_mask) != n_runs:
+        raise ValueError(
+            "Number of sample_mask ({}) not matching "
+            "number of runs ({}).".format(len(sample_mask), n_runs)
+        )
+
+    if runs is None:
+        runs = np.zeros(n_time)
+
+    # handle multiple runs
+    masks = []
+    starting_index = 0
+    for i, current_mask in enumerate(sample_mask):
+        _check_sample_mask_index(i, n_runs, runs, current_mask)
+        current_mask += starting_index
+        masks.append(current_mask)
+        starting_index = sum(i == runs)
+    sample_mask = np.hstack(masks)
+    return sample_mask
+
+
+def _check_sample_mask_index(i, n_runs, runs, current_mask):
+    """Ensure the index in sample mask is valid."""
+    len_run = sum(i == runs)
+    len_current_mask = len(current_mask)
+    # sample_mask longer than signal
+    if len_current_mask > len_run:
+        raise IndexError(
+            "sample_mask {} of {} is has more timepoints than the current "
+            "run ;sample_mask contains {} index but the run has {} "
+            "timepoints.".format(
+                (i + 1), n_runs, len_current_mask, len_run
+            )
+        )
+    # sample_mask index exceed signal timepoints
+    invalid_index = current_mask[current_mask > len_run]
+    if invalid_index.size > 0:
+        raise IndexError(
+            "sample_mask {} of {} contains invalid index {}; "
+            "The signal contains {} time points.".format(
+                (i + 1), n_runs, invalid_index, len_run
+            )
+        )
+
+
+def _sanitize_runs(n_time, runs):
+    """Check runs are supplied in the correct format and detect the number of
+    unique runs.
+    """
+    if runs is not None and len(runs) != n_time:
+        raise ValueError(
+            (
+                "The length of the run vector (%i) "
+                "does not match the length of the signals (%i)"
+            )
+            % (len(runs), n_time)
+        )
+    n_runs = 1 if runs is None else len(np.unique(runs))
+    return n_runs, runs
+
+
+def _sanitize_confound_dtype(n_signal, confound):
+    """Check confound is the correct datatype."""
+    if isinstance(confound, pd.DataFrame):
+        confound = confound.values
+    if isinstance(confound, str):
+        filename = confound
+        confound = csv_to_array(filename)
+        if np.isnan(confound.flat[0]):
+            # There may be a header
+            confound = csv_to_array(filename, skip_header=1)
+        if confound.shape[0] != n_signal:
+            raise ValueError(
+                "Confound signal has an incorrect length"
+                "Signal length: {0}; confound length: {1}".format(
+                    n_signal, confound.shape[0])
+            )
+    elif isinstance(confound, np.ndarray):
+        if confound.ndim == 1:
+            confound = np.atleast_2d(confound).T
+        elif confound.ndim != 2:
+            raise ValueError("confound array has an incorrect number "
+                             "of dimensions: %d" % confound.ndim)
+        if confound.shape[0] != n_signal:
+            raise ValueError(
+                "Confound signal has an incorrect length"
+                "Signal length: {0}; confound length: {1}".format(
+                    n_signal, confound.shape[0])
+            )
+
+    else:
+        raise TypeError("confound has an unhandled type: %s"
+                        % confound.__class__)
+    return confound
+
+
+def _check_filter_parameters(filter, low_pass, high_pass, t_r):
+    """Check all filter related parameters are set correctly."""
+    if not filter:
+        if any(isinstance(item, float) for item in [low_pass, high_pass]):
+            warnings.warn(
+                "No filter type selected but cutoff frequency provided."
+                "Will not perform filtering."
+            )
+        return False
+    elif filter in availiable_filters:
+        if filter == 'cosine' and not all(isinstance(item, float)
+                                          for item in [t_r, high_pass]):
+            raise ValueError(
+                "Repetition time (t_r) and low cutoff frequency "
+                "(high_pass) must be specified for cosine filtering."
+                "t_r='{0}', high_pass='{1}'".format(t_r, high_pass)
+            )
+        if filter == 'butterworth':
+            if all(item is None for item in [low_pass, high_pass, t_r]):
+                # Butterworth was switched off by passing
+                # None to all these parameters
+                return False
+            if t_r is None:
+                raise ValueError("Repetition time (t_r) must be specified for "
+                                 "butterworth filtering.")
+            if any(isinstance(item, bool) for item in [low_pass, high_pass]):
+                raise TypeError(
+                    "high/low pass must be float or None but you provided "
+                    "high_pass='{0}', low_pass='{1}'"
+                    .format(high_pass, low_pass)
+                )
+        return True
+    else:
+        raise ValueError("Filter method {} not implemented.".format(filter))
+
+
+def _sanitize_signals(signals, ensure_finite):
+    """Ensure signals are in the correct state."""
+    if not isinstance(ensure_finite, bool):
+        raise ValueError("'ensure_finite' must be boolean type True or False "
+                         "but you provided ensure_finite={0}"
+                         .format(ensure_finite))
+    signals = signals.copy()
+    if not isinstance(signals, np.ndarray):
+        signals = as_ndarray(signals)
+    if ensure_finite:
+        mask = np.logical_not(np.isfinite(signals))
+        if mask.any():
+            signals[mask] = 0
+    return _ensure_float(signals)
+
+
+def _check_signal_parameters(detrend, standardize_confounds):
+    """Raise warning if the combination is illogical"""
+    if not detrend and not standardize_confounds:
+        warnings.warn("When confounds are provided, one must perform detrend "
+                      "and/or standardize confounds. You provided "
+                      "detrend={0}, standardize_confounds={1}. If confounds "
+                      "were not standardized or demeaned before passing to "
+                      "signal.clean signal will not be correctly "
+                      "cleaned. ".format(
+                          detrend, standardize_confounds)
+                      )

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

@@ -0,0 +1,183 @@
+# *- encoding: utf-8 -*-
+"""
+nilearn version, required package versions, and utilities for checking
+"""
+# Author: Loic Esteve, Ben Cipollini
+# License: simplified BSD
+
+# PEP0440 compatible formatted version, see:
+# https://www.python.org/dev/peps/pep-0440/
+#
+# Generic release markers:
+# X.Y
+# X.Y.Z # For bugfix releases
+#
+# Admissible pre-release markers:
+# X.YaN # Alpha release
+# X.YbN # Beta release
+# X.YrcN # Release Candidate
+# X.Y # Final release
+#
+# Dev branch marker is: 'X.Y.dev' or 'X.Y.devN' where N is an integer.
+# 'X.Y.dev0' is the canonical version of 'X.Y.dev'
+#
+__version__ = '0.9.1'
+
+_NILEARN_INSTALL_MSG = 'See %s for installation information.' % (
+    'http://nilearn.github.io/introduction.html#installation')
+
+import operator
+
+# This is a tuple to preserve order, so that dependencies are checked
+#   in some meaningful order (more => less 'core').
+REQUIRED_MODULE_METADATA = (
+    ('numpy', {
+        'min_version': '1.16',
+        'required_at_installation': True,
+        'install_info': _NILEARN_INSTALL_MSG}),
+    ('scipy', {
+        'min_version': '1.2',
+        'required_at_installation': True,
+        'install_info': _NILEARN_INSTALL_MSG}),
+    ('sklearn', {
+        'min_version': '0.21',
+        'required_at_installation': True,
+        'install_info': _NILEARN_INSTALL_MSG}),
+    ('joblib', {
+        'min_version': '0.12',
+        'required_at_installation': True,
+        'install_info': _NILEARN_INSTALL_MSG}),
+    ('nibabel', {
+        'min_version': '2.5',
+        'required_at_installation': False}),
+    ('pandas', {
+        'min_version': '0.24.0',
+        'required_at_installation': True,
+        'install_info': _NILEARN_INSTALL_MSG}),
+    ("requests", {
+        "min_version": "2",
+        "required_at_installation": False
+    })
+)
+
+OPTIONAL_MATPLOTLIB_MIN_VERSION = '2.0'
+
+
+def _import_module_with_version_check(
+        module_name,
+        minimum_version,
+        install_info=None):
+    """Check that module is installed with a recent enough version."""
+    try:
+        module = __import__(module_name)
+    except ImportError as exc:
+        user_friendly_info = ('Module "{0}" could not be found. {1}').format(
+            module_name,
+            install_info or 'Please install it properly to use nilearn.')
+        exc.args += (user_friendly_info,)
+        # Necessary for Python 3 because the repr/str of ImportError
+        # objects was changed in Python 3
+        if hasattr(exc, 'msg'):
+            exc.msg += '. ' + user_friendly_info
+        raise
+
+    # Avoid choking on modules with no __version__ attribute
+    module_version = getattr(module, '__version__', '0.0.0')
+
+    version_too_old = (
+        not _compare_version(module_version, '>=', minimum_version)
+    )
+
+    if version_too_old:
+        message = (
+            'A {module_name} version of at least {minimum_version} '
+            'is required to use nilearn. {module_version} was found. '
+            'Please upgrade {module_name}').format(
+                module_name=module_name,
+                minimum_version=minimum_version,
+                module_version=module_version)
+
+        raise ImportError(message)
+
+    return module
+
+
+VERSION_OPERATORS = {
+    "==": operator.eq,
+    "!=": operator.ne,
+    ">": operator.gt,
+    ">=": operator.ge,
+    "<": operator.lt,
+    "<=": operator.le,
+}
+
+
+def _compare_version(version_a, operator, version_b):
+    """Compare two version strings via a user-specified operator.
+
+    ``distutils`` has been deprecated since Python 3.10 and is scheduled
+    for removal from the standard library with the release of Python 3.12.
+    For version comparisons, we use setuptools's `parse_version` if available.
+
+    Note: This function is inspired from MNE-Python.
+    See https://github.com/mne-tools/mne-python/blob/main/mne/fixes.py
+
+    Parameters
+    ----------
+    version_a : :obj:`str`
+        First version string.
+
+    operator : {'==', '!=','>', '<', '>=', '<='}
+        Operator to compare ``version_a`` and ``version_b`` in the form of
+        ``version_a operator version_b``.
+
+    version_b : :obj:`str`
+        Second version string.
+
+    Returns
+    -------
+    result : :obj:`bool`
+        The result of the version comparison.
+
+    """
+    # TODO:
+    # The setuptools doc encourages the use of importlib.metadata instead
+    # of pkg_resources. However, importlib.metadata is only part of the stdlib
+    # for Python >= 3.8. When Nilearn will only support Python >= 3.8,
+    # please consider changing the following line to:
+    # from importlib.metadata import version as parse
+    try:
+        from pkg_resources import parse_version as parse  # noqa:F401
+    except ImportError:
+        from distutils.version import LooseVersion as parse  # noqa:F401
+    if operator not in VERSION_OPERATORS:
+        raise ValueError(
+            "'_compare_version' received an unexpected "
+            "operator {0}.".format(operator)
+        )
+    return VERSION_OPERATORS[operator](parse(version_a), parse(version_b))
+
+
+def _check_module_dependencies(is_nilearn_installing=False):
+    """Throw an exception if nilearn dependencies are not installed.
+
+    Parameters
+    ----------
+    is_nilearn_installing: boolean
+        if True, only error on missing packages that cannot be auto-installed.
+        if False, error on any missing package.
+
+    Throws
+    -------
+    ImportError
+    """
+
+    for (module_name, module_metadata) in REQUIRED_MODULE_METADATA:
+        if not (is_nilearn_installing and
+                not module_metadata['required_at_installation']):
+            # Skip check only when installing and it's a module that
+            # will be auto-installed.
+            _import_module_with_version_check(
+                module_name=module_name,
+                minimum_version=module_metadata['min_version'],
+                install_info=module_metadata.get('install_info'))

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/pyDeprecate-0.3.1.dist-info/INSTALLER

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

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/pyDeprecate-0.3.1.dist-info/LICENSE

@@ -0,0 +1,27 @@
+Copyright (c) 2020-2021, Jiri Borovec
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice,
+this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+this list of conditions and the following disclaimer in the documentation
+and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors
+may be used to endorse or promote products derived from this software without
+specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/pyDeprecate-0.3.1.dist-info/METADATA

@@ -0,0 +1,335 @@
+Metadata-Version: 2.1
+Name: pyDeprecate
+Version: 0.3.1
+Summary: Deprecation tooling
+Home-page: https://borda.github.io/pyDeprecate
+Author: Jiri Borovec
+Author-email: jiri.borovec@fel.cvut.cz
+License: MIT
+Project-URL: Source Code, https://github.com/Borda/pyDeprecate
+Keywords: python,development,deprecation
+Platform: UNKNOWN
+Classifier: Environment :: Console
+Classifier: Natural Language :: English
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# pyDeprecate
+
+**Simple tooling for marking deprecated functions or classes and re-routing to the new successors' instance.**
+
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/pyDeprecate)](https://pypi.org/project/pyDeprecate/)
+[![PyPI Status](https://badge.fury.io/py/pyDeprecate.svg)](https://badge.fury.io/py/pyDeprecate)
+[![PyPI Status](https://pepy.tech/badge/pyDeprecate)](https://pepy.tech/project/pyDeprecate)
+[![Conda](https://img.shields.io/conda/v/conda-forge/pyDeprecate?label=conda&color=success)](https://anaconda.org/conda-forge/pyDeprecate)
+![Conda](https://img.shields.io/conda/dn/conda-forge/pyDeprecate)
+[![license](https://img.shields.io/badge/License-MIT-blue.svg)](https://github.com/Borda/pyDeprecate/blob/master/LICENSE)
+
+[![CI testing](https://github.com/Borda/pyDeprecate/actions/workflows/ci_testing.yml/badge.svg?tag=0.3.1)](https://github.com/Borda/pyDeprecate/actions/workflows/ci_testing.yml)
+[![Code formatting](https://github.com/Borda/pyDeprecate/actions/workflows/code-format.yml/badge.svg?tag=0.3.1)](https://github.com/Borda/pyDeprecate/actions/workflows/code-format.yml)
+[![codecov](https://codecov.io/gh/Borda/pyDeprecate/release/0.3.1/graph/badge.svg?token=BG7RQ86UJA)](https://codecov.io/gh/Borda/pyDeprecate)
+[![CodeFactor](https://www.codefactor.io/repository/github/borda/pydeprecate/badge)](https://www.codefactor.io/repository/github/borda/pydeprecate)
+[![pre-commit.ci status](https://results.pre-commit.ci/badge/github/Borda/pyDeprecate/main.svg)](https://results.pre-commit.ci/latest/github/Borda/pyDeprecate/main)
+
+<!--
+[![Language grade: Python](https://img.shields.io/lgtm/grade/python/g/Borda/pyDeprecate.svg?logo=lgtm&logoWidth=18)](https://lgtm.com/projects/g/Borda/pyDeprecate/context:python)
+-->
+
+---
+
+The common use-case is moving your functions across codebase or outsourcing some functionalities to new packages.
+For most of these cases, you want to hold some compatibility, so you cannot simply remove past function, and also for some time you want to warn users that functionality they have been using is moved and not it is deprecated in favor of another function (which shall be used instead) and soon it will be removed completely.
+
+Another good aspect is to do not overwhelm a user with too many warnings, so per function/class, this warning is raised only N times in the preferable stream (warning, logger, etc.).
+
+## Installation
+
+Simple installation from PyPI:
+```bash
+pip install pyDeprecate
+```
+
+<details>
+  <summary>Other installations</summary>
+
+  Simply install with pip from source:
+  ```bash
+  pip install https://github.com/Borda/pyDeprecate/archive/main.zip
+  ```
+
+</details>
+
+## Use-cases
+
+The functionality is kept simple and all default shall be reasonable, but still you can do extra customization such as:
+
+* define user warning message and preferable stream
+* extended argument mapping to target function/method
+* define deprecation logic for self arguments
+* specify warning count per:
+    - called function (for func deprecation)
+    - used arguments (for argument deprecation)
+* define conditional skip (e.g. depending on some package version)
+
+In particular the target values (cases):
+
+- _None_ - raise only warning message (ignore all argument mapping)
+- _True_ - deprecation some argument of itself (argument mapping shall be specified)
+- _Callable_ - forward call to new methods (optional also argument mapping or extras)
+
+### Simple function forwarding
+
+It is very straight forward, you forward your function call to new function and all arguments are mapped:
+
+```python
+def base_sum(a: int = 0, b: int = 3) -> int:
+    """My new function anywhere in codebase or even other package."""
+    return a + b
+
+# ---------------------------
+
+from deprecate import deprecated
+
+@deprecated(target=base_sum, deprecated_in="0.1", remove_in="0.5")
+def depr_sum(a: int, b: int = 5) -> int:
+    """
+    My deprecated function which now has empty body
+     as all calls are routed to the new function.
+    """
+    pass  # or you can just place docstring as one above
+
+# call this function will raise deprecation warning:
+#   The `depr_sum` was deprecated since v0.1 in favor of `__main__.base_sum`.
+#   It will be removed in v0.5.
+print(depr_sum(1, 2))
+```
+<details>
+  <summary>sample output:</summary>
+  ```
+  3
+  ```
+</details>
+
+### Advanced target argument mapping
+
+Another more complex example is using argument mapping is:
+
+
+<details>
+  <summary>Advanced example</summary>
+
+  ```python
+  import logging
+  from sklearn.metrics import accuracy_score
+  from deprecate import deprecated, void
+
+  @deprecated(
+    # use standard sklearn accuracy implementation
+    target=accuracy_score,
+    # custom warning stream
+    stream=logging.warning,
+    # number or warnings per lifetime (with -1 for always_
+    num_warns=5,
+    # custom message template
+    template_mgs="`%(source_name)s` was deprecated, use `%(target_path)s`",
+    # as target args are different, define mapping from source to target func
+    args_mapping={'preds': 'y_pred', 'target': 'y_true', 'blabla': None}
+  )
+  def depr_accuracy(preds: list, target: list, blabla: float) -> float:
+      """My deprecated function which is mapping to sklearn accuracy."""
+      # to stop complain your IDE about unused argument you can use void/empty function
+      return void(preds, target, blabla)
+
+  # call this function will raise deprecation warning:
+  #   WARNING:root:`depr_accuracy` was deprecated, use `sklearn.metrics.accuracy_score`
+  print(depr_accuracy([1, 0, 1, 2], [0, 1, 1, 2], 1.23))
+  ```
+  sample output:
+  ```
+  0.5
+  ```
+
+</details>
+
+
+### Deprecation warning only
+
+Base use-case with no forwarding and just raising warning :
+
+```python
+from deprecate import deprecated
+
+@deprecated(target=None, deprecated_in="0.1", remove_in="0.5")
+def my_sum(a: int, b: int = 5) -> int:
+    """My deprecated function which still has to have implementation."""
+    return a + b
+
+# call this function will raise deprecation warning:
+#   The `my_sum` was deprecated since v0.1. It will be removed in v0.5.
+print(my_sum(1, 2))
+```
+<details>
+  <summary>sample output:</summary>
+  ```
+  3
+  ```
+</details>
+
+### Self argument mapping
+
+We also support deprecation and argument mapping for the function itself:
+
+```python
+from deprecate import deprecated
+
+@deprecated(
+  # define as depreaction some self argument - mapping
+  target=True, args_mapping={'coef': 'new_coef'},
+  # common version info
+  deprecated_in="0.2", remove_in="0.4",
+)
+def any_pow(base: float, coef: float = 0, new_coef: float = 0) -> float:
+    """My function with deprecated argument `coef` mapped to `new_coef`."""
+    return base ** new_coef
+
+# call this function will raise deprecation warning:
+#   The `any_pow` uses deprecated arguments: `coef` -> `new_coef`.
+#   They were deprecated since v0.2 and will be removed in v0.4.
+print(any_pow(2, 3))
+```
+<details>
+  <summary>sample output:</summary>
+  ```
+  8
+  ```
+</details>
+
+### Multiple deprecation levels
+
+Eventually you can set multiple deprecation levels via chaining deprecation arguments as each could be deprecated in another version:
+
+<details>
+  <summary>Multiple deprecation levels</summary>
+
+  ```python
+  from deprecate import deprecated
+
+  @deprecated(
+    True, "0.3", "0.6", args_mapping=dict(c1='nc1'),
+    template_mgs="Depr: v%(deprecated_in)s rm v%(remove_in)s for args: %(argument_map)s."
+  )
+  @deprecated(
+    True, "0.4", "0.7", args_mapping=dict(nc1='nc2'),
+    template_mgs="Depr: v%(deprecated_in)s rm v%(remove_in)s for args: %(argument_map)s."
+  )
+  def any_pow(base, c1: float = 0, nc1: float = 0, nc2: float = 2) -> float:
+      return base**nc2
+
+  # call this function will raise deprecation warning:
+  #   DeprecationWarning('Depr: v0.3 rm v0.6 for args: `c1` -> `nc1`.')
+  #   DeprecationWarning('Depr: v0.4 rm v0.7 for args: `nc1` -> `nc2`.')
+  print(any_pow(2, 3))
+  ```
+  sample output:
+  ```
+  8
+  ```
+
+</details>
+
+### Conditional skip
+
+Conditional skip of which can be used for mapping between different target functions depending on additional input such as package version
+
+```python
+from deprecate import deprecated
+
+FAKE_VERSION = 1
+
+def version_greater_1():
+    return FAKE_VERSION > 1
+
+@deprecated(
+  True, "0.3", "0.6", args_mapping=dict(c1='nc1'), skip_if=version_greater_1
+)
+def skip_pow(base, c1: float = 1, nc1: float = 1) -> float:
+    return base**(c1 - nc1)
+
+# call this function will raise deprecation warning
+print(skip_pow(2, 3))
+
+# change the fake versions
+FAKE_VERSION = 2
+
+# Will not raise any warning
+print(skip_pow(2, 3))
+```
+<details>
+  <summary>sample output:</summary>
+  ```
+  0.25
+  4
+  ```
+</details>
+
+This can be beneficial with multiple deprecation levels shown above...
+
+### Class deprecation
+
+This case can be quite complex as you may deprecate just some methods, here we show full class deprecation:
+
+```python
+class NewCls:
+    """My new class anywhere in the codebase or other package."""
+
+    def __init__(self, c: float, d: str = "abc"):
+        self.my_c = c
+        self.my_d = d
+
+# ---------------------------
+
+from deprecate import deprecated, void
+
+class PastCls(NewCls):
+    """
+    The deprecated class shall be inherited from the successor class
+     to hold all methods.
+    """
+
+    @deprecated(target=NewCls, deprecated_in="0.2", remove_in="0.4")
+    def __init__(self, c: int, d: str = "efg"):
+        """
+        You place the decorator around __init__ as you want
+         to warn user just at the time of creating object.
+        """
+        return void(c, d)
+
+# call this function will raise deprecation warning:
+#   The `PastCls` was deprecated since v0.2 in favor of `__main__.NewCls`.
+#   It will be removed in v0.4.
+inst = PastCls(7)
+print(inst.my_c)  # returns: 7
+print(inst.my_d)  # returns: "efg"
+```
+<details>
+  <summary>sample output:</summary>
+  ```
+  7
+  efg
+  ```
+</details>
+
+## Contribution
+
+Have you faced this in past or even now, do you have good ideas for improvement, all is welcome!
+
+

my_container_sandbox/workspace/anaconda3/lib/python3.8/site-packages/pyDeprecate-0.3.1.dist-info/RECORD

@@ -0,0 +1,13 @@
+deprecate/__init__.py,sha256=37Y-nppyEVah9PsRW7D7MpOK3tcD0De-skCst_ajOdo,546
+deprecate/__pycache__/__init__.cpython-38.pyc,,
+deprecate/__pycache__/deprecation.cpython-38.pyc,,
+deprecate/__pycache__/utils.cpython-38.pyc,,
+deprecate/deprecation.py,sha256=FtZNg7SjB-ZTP2cs6NChzR6joIvfB8VWUWNdvDDicTk,12622
+deprecate/utils.py,sha256=5nyZjgm8rxgpaQUwLWTebTt4cE9HE4nx2HpQDkIFmTU,1869
+pyDeprecate-0.3.1.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+pyDeprecate-0.3.1.dist-info/LICENSE,sha256=5Ekt3qiROL3RpcpWxvJ20J4roFW1qjyfBndPq1rDmEw,1488
+pyDeprecate-0.3.1.dist-info/METADATA,sha256=ET6d0pHoG_SezgJi1RLzqZDoXi8QLOvnvBBk_bjzo1U,10837
+pyDeprecate-0.3.1.dist-info/RECORD,,
+pyDeprecate-0.3.1.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyDeprecate-0.3.1.dist-info/WHEEL,sha256=OqRkF0eY5GHssMorFjlbTIq072vpHpF60fIQA6lS9xA,92
+pyDeprecate-0.3.1.dist-info/top_level.txt,sha256=JoS3qR1D0-NtCnKrbT4roM65b8LE7ETaLj3AOdlTU1E,10