diff --git a/AngularApp/prototype/src/app/cache.service.ts b/AngularApp/prototype/src/app/cache.service.ts
index b4269efad338906975cced9e0cc356e752b8b214..5519707db4804e972bf69f6df7f6f2e6285689e5 100644
--- a/AngularApp/prototype/src/app/cache.service.ts
+++ b/AngularApp/prototype/src/app/cache.service.ts
@@ -18,7 +18,7 @@ export class CacheService {
   private _queryWindow;
 
   public windowSize = 120;
-  public nrOfTables = 50;
+  public nrOfTables = 20;
   public hashSize = 4;
   public stepSize = 200;
   public querySelectionMode = true;
diff --git a/AngularApp/prototype/src/app/table-overview/table-overview.component.ts b/AngularApp/prototype/src/app/table-overview/table-overview.component.ts
index 870e6ac3de5d8cc84ba47ec449d84c845fde09ef..06ae9d0495fb096dd14bf8a5b70396826ce6af8b 100644
--- a/AngularApp/prototype/src/app/table-overview/table-overview.component.ts
+++ b/AngularApp/prototype/src/app/table-overview/table-overview.component.ts
@@ -105,17 +105,17 @@ export class TableOverviewComponent implements OnInit {
         return this.distanceMetric(hash1) - this.distanceMetric(hash2);
       });
       if (this.service.queryWindow) {
-        const queryEntry = this.calculateSignature(table.hash, this.service.queryWindow);
-        listOfWindows.push(table.entries[queryEntry]);
-        opacity = orderedHashes.map((hash: string) => {
-            return hash === queryEntry ? 1.0 : 0.5;
-          }
-        );
-        rank = table.entries[queryEntry].length;
+        // const queryEntry = this.calculateSignature(table.hash, this.service.queryWindow);
+        // listOfWindows.push(table.entries[queryEntry]);
+        // opacity = orderedHashes.map((hash: string) => {
+        //     return hash === queryEntry ? 1.0 : 0.5;
+        //   }
+        // );
+        // rank = table.entries[queryEntry].length;
       }
       this.subplots.push(
         {
-          rank: rank,
+          // rank: rank,
           data: [{
             x: orderedHashes.map((hash: string, i) => {
               return i; // Number('0b' + hash);
@@ -149,7 +149,7 @@ export class TableOverviewComponent implements OnInit {
         }
       );
     }
-    this.subplots.sort((plot1, plot2) => plot1.rank - plot2.rank);
+    // this.subplots.sort((plot1, plot2) => plot1.rank - plot2.rank);
     if (this.service.queryWindow) {
       const temp = await this.service.getAverageTableWindows(listOfWindows);
       this.averages = temp.map(x => this.averagePlot(x));
diff --git a/Flaskserver/.idea/workspace.xml b/Flaskserver/.idea/workspace.xml
index 726f3bfa53dfa0c408187f2f87006286d03ab9b3..15f10eee7766a640102aca61cb1d9a97e54a0f34 100644
--- a/Flaskserver/.idea/workspace.xml
+++ b/Flaskserver/.idea/workspace.xml
@@ -21,12 +21,8 @@
   <component name="ChangeListManager">
     <list default="true" id="556080ba-825c-4b55-a92a-867a4df4fb32" name="Default Changelist" comment="">
       <change beforePath="$PROJECT_DIR$/../AngularApp/prototype/src/app/cache.service.ts" beforeDir="false" afterPath="$PROJECT_DIR$/../AngularApp/prototype/src/app/cache.service.ts" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/../AngularApp/prototype/src/app/labeling-window/labeling-window.component.ts" beforeDir="false" afterPath="$PROJECT_DIR$/../AngularApp/prototype/src/app/labeling-window/labeling-window.component.ts" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/../AngularApp/prototype/src/app/overview-window/overview-window.component.ts" beforeDir="false" afterPath="$PROJECT_DIR$/../AngularApp/prototype/src/app/overview-window/overview-window.component.ts" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/../AngularApp/prototype/src/app/progress-view/progress-view.component.ts" beforeDir="false" afterPath="$PROJECT_DIR$/../AngularApp/prototype/src/app/progress-view/progress-view.component.ts" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/.idea/workspace.xml" beforeDir="false" afterPath="$PROJECT_DIR$/.idea/workspace.xml" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/main.py" beforeDir="false" afterPath="$PROJECT_DIR$/main.py" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/processed-data.npy" beforeDir="false" afterPath="$PROJECT_DIR$/processed-data.npy" afterDir="false" />
     </list>
     <option name="SHOW_DIALOG" value="false" />
     <option name="HIGHLIGHT_CONFLICTS" value="true" />
diff --git a/Flaskserver/__pycache__/main.cpython-38.pyc b/Flaskserver/__pycache__/main.cpython-38.pyc
index 875002c44004a2524747205af41dae154b485bee..be5cd6ca5f9978879375817b7fcd494188e39087 100644
Binary files a/Flaskserver/__pycache__/main.cpython-38.pyc and b/Flaskserver/__pycache__/main.cpython-38.pyc differ
diff --git a/Flaskserver/main.py b/Flaskserver/main.py
index f318a82b40e63ceee8b03f6d05c3868fa08e6d96..3fce2eb6660acfc276f315d7f2e48873ff4beec8 100644
--- a/Flaskserver/main.py
+++ b/Flaskserver/main.py
@@ -40,14 +40,13 @@ def read_data():
 def create_windows():
     t0 = time()
     if reload:
-        size = bbi.chromsizes('test.bigWig')['chr1']
         raw_data = request.json
         window_size = int(raw_data['parameters']["windowsize"])
         data = bigwig.chunk(
             'test.bigWig',
             12000,
-            12000 / window_size,
-            12000 / 6,
+            int(12000 / window_size),
+            int(12000 / 6),
             ['chr1'],
             verbose=True,
         )
@@ -59,16 +58,12 @@ def create_windows():
 @app.route('/create-tables', methods=['POST'])
 def create_tables():
     t0 = time()
-    print("loading")
     data = np.load('processed-data.npy')
-    print('Number of tables: ' + str(data.shape))
-    print(time()-t0)
     raw_data = orjson.loads(request.data)
-    print(time()-t0)
     window_size = int(raw_data['parameters']["windowsize"])
     hash_size = int(raw_data['parameters']["hashsize"])
     table_size = int(raw_data['parameters']["tablesize"])
-    data = np.array(data)
+
     print('Starting: ' + str(time()-t0))
     tables_hash_function = [np.random.uniform(-100, 100, size=(window_size, hash_size)) for _ in range(table_size)]
     print('Init time: ' + str(time() - t0))
diff --git a/Flaskserver/venv/Lib/site-packages/Flask-1.1.2.dist-info/INSTALLER b/Flaskserver/venv/Lib/site-packages/Flask-1.1.2.dist-info/INSTALLER
deleted file mode 100644
index a1b589e38a32041e49332e5e81c2d363dc418d68..0000000000000000000000000000000000000000
--- a/Flaskserver/venv/Lib/site-packages/Flask-1.1.2.dist-info/INSTALLER
+++ /dev/null
@@ -1 +0,0 @@
-pip
diff --git a/Flaskserver/venv/Lib/site-packages/Flask-1.1.2.dist-info/LICENSE.rst b/Flaskserver/venv/Lib/site-packages/Flask-1.1.2.dist-info/LICENSE.rst
deleted file mode 100644
index 9d227a0cc43c3268d15722b763bd94ad298645a1..0000000000000000000000000000000000000000
--- a/Flaskserver/venv/Lib/site-packages/Flask-1.1.2.dist-info/LICENSE.rst
+++ /dev/null
@@ -1,28 +0,0 @@
-Copyright 2010 Pallets
-
-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.
diff --git a/Flaskserver/venv/Lib/site-packages/Flask-1.1.2.dist-info/METADATA b/Flaskserver/venv/Lib/site-packages/Flask-1.1.2.dist-info/METADATA
deleted file mode 100644
index db7fcd17364ceb5e8b5b868895e64303cc8d0c07..0000000000000000000000000000000000000000
--- a/Flaskserver/venv/Lib/site-packages/Flask-1.1.2.dist-info/METADATA
+++ /dev/null
@@ -1,137 +0,0 @@
-Metadata-Version: 2.1
-Name: Flask
-Version: 1.1.2
-Summary: A simple framework for building complex web applications.
-Home-page: https://palletsprojects.com/p/flask/
-Author: Armin Ronacher
-Author-email: armin.ronacher@active-4.com
-Maintainer: Pallets
-Maintainer-email: contact@palletsprojects.com
-License: BSD-3-Clause
-Project-URL: Documentation, https://flask.palletsprojects.com/
-Project-URL: Code, https://github.com/pallets/flask
-Project-URL: Issue tracker, https://github.com/pallets/flask/issues
-Platform: UNKNOWN
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Environment :: Web Environment
-Classifier: Framework :: Flask
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: BSD License
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 2
-Classifier: Programming Language :: Python :: 2.7
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.5
-Classifier: Programming Language :: Python :: 3.6
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: Implementation :: CPython
-Classifier: Programming Language :: Python :: Implementation :: PyPy
-Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
-Classifier: Topic :: Internet :: WWW/HTTP :: WSGI :: Application
-Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: >=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*
-Requires-Dist: Werkzeug (>=0.15)
-Requires-Dist: Jinja2 (>=2.10.1)
-Requires-Dist: itsdangerous (>=0.24)
-Requires-Dist: click (>=5.1)
-Provides-Extra: dev
-Requires-Dist: pytest ; extra == 'dev'
-Requires-Dist: coverage ; extra == 'dev'
-Requires-Dist: tox ; extra == 'dev'
-Requires-Dist: sphinx ; extra == 'dev'
-Requires-Dist: pallets-sphinx-themes ; extra == 'dev'
-Requires-Dist: sphinxcontrib-log-cabinet ; extra == 'dev'
-Requires-Dist: sphinx-issues ; extra == 'dev'
-Provides-Extra: docs
-Requires-Dist: sphinx ; extra == 'docs'
-Requires-Dist: pallets-sphinx-themes ; extra == 'docs'
-Requires-Dist: sphinxcontrib-log-cabinet ; extra == 'docs'
-Requires-Dist: sphinx-issues ; extra == 'docs'
-Provides-Extra: dotenv
-Requires-Dist: python-dotenv ; extra == 'dotenv'
-
-Flask
-=====
-
-Flask is a lightweight `WSGI`_ web application framework. It is designed
-to make getting started quick and easy, with the ability to scale up to
-complex applications. It began as a simple wrapper around `Werkzeug`_
-and `Jinja`_ and has become one of the most popular Python web
-application frameworks.
-
-Flask offers suggestions, but doesn't enforce any dependencies or
-project layout. It is up to the developer to choose the tools and
-libraries they want to use. There are many extensions provided by the
-community that make adding new functionality easy.
-
-
-Installing
-----------
-
-Install and update using `pip`_:
-
-.. code-block:: text
-
-    pip install -U Flask
-
-
-A Simple Example
-----------------
-
-.. code-block:: python
-
-    from flask import Flask
-
-    app = Flask(__name__)
-
-    @app.route("/")
-    def hello():
-        return "Hello, World!"
-
-.. code-block:: text
-
-    $ env FLASK_APP=hello.py flask run
-     * Serving Flask app "hello"
-     * Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)
-
-
-Contributing
-------------
-
-For guidance on setting up a development environment and how to make a
-contribution to Flask, see the `contributing guidelines`_.
-
-.. _contributing guidelines: https://github.com/pallets/flask/blob/master/CONTRIBUTING.rst
-
-
-Donate
-------
-
-The Pallets organization develops and supports Flask and the libraries
-it uses. In order to grow the community of contributors and users, and
-allow the maintainers to devote more time to the projects, `please
-donate today`_.
-
-.. _please donate today: https://psfmember.org/civicrm/contribute/transact?reset=1&id=20
-
-
-Links
------
-
-* Website: https://palletsprojects.com/p/flask/
-* Documentation: https://flask.palletsprojects.com/
-* Releases: https://pypi.org/project/Flask/
-* Code: https://github.com/pallets/flask
-* Issue tracker: https://github.com/pallets/flask/issues
-* Test status: https://dev.azure.com/pallets/flask/_build
-* Official chat: https://discord.gg/t6rrQZH
-
-.. _WSGI: https://wsgi.readthedocs.io
-.. _Werkzeug: https://www.palletsprojects.com/p/werkzeug/
-.. _Jinja: https://www.palletsprojects.com/p/jinja/
-.. _pip: https://pip.pypa.io/en/stable/quickstart/
-
-
diff --git a/Flaskserver/venv/Lib/site-packages/Flask-1.1.2.dist-info/RECORD b/Flaskserver/venv/Lib/site-packages/Flask-1.1.2.dist-info/RECORD
deleted file mode 100644
index c1acc7716446c612139cabe6da7e9c263ea807fb..0000000000000000000000000000000000000000
--- a/Flaskserver/venv/Lib/site-packages/Flask-1.1.2.dist-info/RECORD
+++ /dev/null
@@ -1,48 +0,0 @@
-../../Scripts/flask.exe,sha256=tXDH2yw_IVFYBuQ5xdTtRi0Kra-qpPi8YOM5gicfUtA,103300
-Flask-1.1.2.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
-Flask-1.1.2.dist-info/LICENSE.rst,sha256=SJqOEQhQntmKN7uYPhHg9-HTHwvY-Zp5yESOf_N9B-o,1475
-Flask-1.1.2.dist-info/METADATA,sha256=3INpPWH6nKfZ33R2N-bQZy4TOe1wQCMweZc9mwcNrtc,4591
-Flask-1.1.2.dist-info/RECORD,,
-Flask-1.1.2.dist-info/WHEEL,sha256=8zNYZbwQSXoB9IfXOjPfeNwvAsALAjffgk27FqvCWbo,110
-Flask-1.1.2.dist-info/entry_points.txt,sha256=gBLA1aKg0OYR8AhbAfg8lnburHtKcgJLDU52BBctN0k,42
-Flask-1.1.2.dist-info/top_level.txt,sha256=dvi65F6AeGWVU0TBpYiC04yM60-FX1gJFkK31IKQr5c,6
-flask/__init__.py,sha256=YnA9wkwbJcnb_jTT-nMsMFeFE_UWt33khKzdHmMSuyI,1894
-flask/__main__.py,sha256=fjVtt3QTANXlpJCOv3Ha7d5H-76MwzSIOab7SFD9TEk,254
-flask/__pycache__/__init__.cpython-38.pyc,,
-flask/__pycache__/__main__.cpython-38.pyc,,
-flask/__pycache__/_compat.cpython-38.pyc,,
-flask/__pycache__/app.cpython-38.pyc,,
-flask/__pycache__/blueprints.cpython-38.pyc,,
-flask/__pycache__/cli.cpython-38.pyc,,
-flask/__pycache__/config.cpython-38.pyc,,
-flask/__pycache__/ctx.cpython-38.pyc,,
-flask/__pycache__/debughelpers.cpython-38.pyc,,
-flask/__pycache__/globals.cpython-38.pyc,,
-flask/__pycache__/helpers.cpython-38.pyc,,
-flask/__pycache__/logging.cpython-38.pyc,,
-flask/__pycache__/sessions.cpython-38.pyc,,
-flask/__pycache__/signals.cpython-38.pyc,,
-flask/__pycache__/templating.cpython-38.pyc,,
-flask/__pycache__/testing.cpython-38.pyc,,
-flask/__pycache__/views.cpython-38.pyc,,
-flask/__pycache__/wrappers.cpython-38.pyc,,
-flask/_compat.py,sha256=8KPT54Iig96TuLipdogLRHNYToIcg-xPhnSV5VRERnw,4099
-flask/app.py,sha256=tmEhx_XrIRP24vZg39dHMWFzJ2jj-YxIcd51LaIT5cE,98059
-flask/blueprints.py,sha256=vkdm8NusGsfZUeIfPdCluj733QFmiQcT4Sk1tuZLUjw,21400
-flask/cli.py,sha256=SIb22uq9wYBeB2tKMl0pYdhtZ1MAQyZtPL-3m6es4G0,31035
-flask/config.py,sha256=3dejvQRYfNHw_V7dCLMxU8UNFpL34xIKemN7gHZIZ8Y,10052
-flask/ctx.py,sha256=cks-omGedkxawHFo6bKIrdOHsJCAgg1i_NWw_htxb5U,16724
-flask/debughelpers.py,sha256=-whvPKuAoU8AZ9c1z_INuOeBgfYDqE1J2xNBsoriugU,6475
-flask/globals.py,sha256=OgcHb6_NCyX6-TldciOdKcyj4PNfyQwClxdMhvov6aA,1637
-flask/helpers.py,sha256=IHa578HU_3XAAo1wpXQv24MYRYO5TzaiDQQwvUIcE6Q,43074
-flask/json/__init__.py,sha256=6nITbZYiYOPB8Qfi1-dvsblwn01KRz8VOsMBIZyaYek,11988
-flask/json/__pycache__/__init__.cpython-38.pyc,,
-flask/json/__pycache__/tag.cpython-38.pyc,,
-flask/json/tag.py,sha256=vq9GOllg_0kTWKuVFrwmkeOQzR-jdBD23x-89JyCCQI,8306
-flask/logging.py,sha256=WcY5UkqTysGfmosyygSlXyZYGwOp3y-VsE6ehoJ48dk,3250
-flask/sessions.py,sha256=G0KsEkr_i1LG_wOINwFSOW3ts7Xbv4bNgEZKc7TRloc,14360
-flask/signals.py,sha256=yYLOed2x8WnQ7pirGalQYfpYpCILJ0LJhmNSrnWvjqw,2212
-flask/templating.py,sha256=F8E_IZXn9BGsjMzUJ5N_ACMyZdiFBp_SSEaUunvfZ7g,4939
-flask/testing.py,sha256=WXsciCQbHBP7xjHqNvOA4bT0k86GvSNpgzncfXLDEEg,10146
-flask/views.py,sha256=eeWnadLAj0QdQPLtjKipDetRZyG62CT2y7fNOFDJz0g,5802
-flask/wrappers.py,sha256=kgsvtZuMM6RQaDqhRbc5Pcj9vqTnaERl2pmXcdGL7LU,4736
diff --git a/Flaskserver/venv/Lib/site-packages/Flask-1.1.2.dist-info/WHEEL b/Flaskserver/venv/Lib/site-packages/Flask-1.1.2.dist-info/WHEEL
deleted file mode 100644
index 8b701e93c23159bc1f4145f779049ce0a6a6cf77..0000000000000000000000000000000000000000
--- a/Flaskserver/venv/Lib/site-packages/Flask-1.1.2.dist-info/WHEEL
+++ /dev/null
@@ -1,6 +0,0 @@
-Wheel-Version: 1.0
-Generator: bdist_wheel (0.33.6)
-Root-Is-Purelib: true
-Tag: py2-none-any
-Tag: py3-none-any
-
diff --git a/Flaskserver/venv/Lib/site-packages/Flask-1.1.2.dist-info/entry_points.txt b/Flaskserver/venv/Lib/site-packages/Flask-1.1.2.dist-info/entry_points.txt
deleted file mode 100644
index 1eb025200e62eb7e4f4c5d27a8498df07b84c5f2..0000000000000000000000000000000000000000
--- a/Flaskserver/venv/Lib/site-packages/Flask-1.1.2.dist-info/entry_points.txt
+++ /dev/null
@@ -1,3 +0,0 @@
-[console_scripts]
-flask = flask.cli:main
-
diff --git a/Flaskserver/venv/Lib/site-packages/Flask-1.1.2.dist-info/top_level.txt b/Flaskserver/venv/Lib/site-packages/Flask-1.1.2.dist-info/top_level.txt
deleted file mode 100644
index 7e1060246fd6746a14204539a72e199a25469a05..0000000000000000000000000000000000000000
--- a/Flaskserver/venv/Lib/site-packages/Flask-1.1.2.dist-info/top_level.txt
+++ /dev/null
@@ -1 +0,0 @@
-flask
diff --git a/Flaskserver/venv/Lib/site-packages/Jinja2-2.11.2.dist-info/INSTALLER b/Flaskserver/venv/Lib/site-packages/Jinja2-2.11.2.dist-info/INSTALLER
deleted file mode 100644
index a1b589e38a32041e49332e5e81c2d363dc418d68..0000000000000000000000000000000000000000
--- a/Flaskserver/venv/Lib/site-packages/Jinja2-2.11.2.dist-info/INSTALLER
+++ /dev/null
@@ -1 +0,0 @@
-pip
diff --git a/Flaskserver/venv/Lib/site-packages/Jinja2-2.11.2.dist-info/LICENSE.rst b/Flaskserver/venv/Lib/site-packages/Jinja2-2.11.2.dist-info/LICENSE.rst
deleted file mode 100644
index c37cae49ec77ad6ebb25568c1605f1fee5313cfb..0000000000000000000000000000000000000000
--- a/Flaskserver/venv/Lib/site-packages/Jinja2-2.11.2.dist-info/LICENSE.rst
+++ /dev/null
@@ -1,28 +0,0 @@
-Copyright 2007 Pallets
-
-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.
diff --git a/Flaskserver/venv/Lib/site-packages/Jinja2-2.11.2.dist-info/METADATA b/Flaskserver/venv/Lib/site-packages/Jinja2-2.11.2.dist-info/METADATA
deleted file mode 100644
index 55c0f82692c5a56768a741095b7d4fb3872b4df5..0000000000000000000000000000000000000000
--- a/Flaskserver/venv/Lib/site-packages/Jinja2-2.11.2.dist-info/METADATA
+++ /dev/null
@@ -1,106 +0,0 @@
-Metadata-Version: 2.1
-Name: Jinja2
-Version: 2.11.2
-Summary: A very fast and expressive template engine.
-Home-page: https://palletsprojects.com/p/jinja/
-Author: Armin Ronacher
-Author-email: armin.ronacher@active-4.com
-Maintainer: Pallets
-Maintainer-email: contact@palletsprojects.com
-License: BSD-3-Clause
-Project-URL: Documentation, https://jinja.palletsprojects.com/
-Project-URL: Code, https://github.com/pallets/jinja
-Project-URL: Issue tracker, https://github.com/pallets/jinja/issues
-Platform: UNKNOWN
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Environment :: Web Environment
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: BSD License
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 2
-Classifier: Programming Language :: Python :: 2.7
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.5
-Classifier: Programming Language :: Python :: 3.6
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: Implementation :: CPython
-Classifier: Programming Language :: Python :: Implementation :: PyPy
-Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Classifier: Topic :: Text Processing :: Markup :: HTML
-Requires-Python: >=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*
-Description-Content-Type: text/x-rst
-Requires-Dist: MarkupSafe (>=0.23)
-Provides-Extra: i18n
-Requires-Dist: Babel (>=0.8) ; extra == 'i18n'
-
-Jinja
-=====
-
-Jinja is a fast, expressive, extensible templating engine. Special
-placeholders in the template allow writing code similar to Python
-syntax. Then the template is passed data to render the final document.
-
-It includes:
-
--   Template inheritance and inclusion.
--   Define and import macros within templates.
--   HTML templates can use autoescaping to prevent XSS from untrusted
-    user input.
--   A sandboxed environment can safely render untrusted templates.
--   AsyncIO support for generating templates and calling async
-    functions.
--   I18N support with Babel.
--   Templates are compiled to optimized Python code just-in-time and
-    cached, or can be compiled ahead-of-time.
--   Exceptions point to the correct line in templates to make debugging
-    easier.
--   Extensible filters, tests, functions, and even syntax.
-
-Jinja's philosophy is that while application logic belongs in Python if
-possible, it shouldn't make the template designer's job difficult by
-restricting functionality too much.
-
-
-Installing
-----------
-
-Install and update using `pip`_:
-
-.. code-block:: text
-
-    $ pip install -U Jinja2
-
-.. _pip: https://pip.pypa.io/en/stable/quickstart/
-
-
-In A Nutshell
--------------
-
-.. code-block:: jinja
-
-    {% extends "base.html" %}
-    {% block title %}Members{% endblock %}
-    {% block content %}
-      <ul>
-      {% for user in users %}
-        <li><a href="{{ user.url }}">{{ user.username }}</a></li>
-      {% endfor %}
-      </ul>
-    {% endblock %}
-
-
-Links
------
-
--   Website: https://palletsprojects.com/p/jinja/
--   Documentation: https://jinja.palletsprojects.com/
--   Releases: https://pypi.org/project/Jinja2/
--   Code: https://github.com/pallets/jinja
--   Issue tracker: https://github.com/pallets/jinja/issues
--   Test status: https://dev.azure.com/pallets/jinja/_build
--   Official chat: https://discord.gg/t6rrQZH
-
-
diff --git a/Flaskserver/venv/Lib/site-packages/Jinja2-2.11.2.dist-info/RECORD b/Flaskserver/venv/Lib/site-packages/Jinja2-2.11.2.dist-info/RECORD
deleted file mode 100644
index d1a691f9e5731808876ed1aa9819cb316b1cbd73..0000000000000000000000000000000000000000
--- a/Flaskserver/venv/Lib/site-packages/Jinja2-2.11.2.dist-info/RECORD
+++ /dev/null
@@ -1,61 +0,0 @@
-Jinja2-2.11.2.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
-Jinja2-2.11.2.dist-info/LICENSE.rst,sha256=O0nc7kEF6ze6wQ-vG-JgQI_oXSUrjp3y4JefweCUQ3s,1475
-Jinja2-2.11.2.dist-info/METADATA,sha256=5ZHRZoIRAMHsJPnqhlJ622_dRPsYePYJ-9EH4-Ry7yI,3535
-Jinja2-2.11.2.dist-info/RECORD,,
-Jinja2-2.11.2.dist-info/WHEEL,sha256=kGT74LWyRUZrL4VgLh6_g12IeVl_9u9ZVhadrgXZUEY,110
-Jinja2-2.11.2.dist-info/entry_points.txt,sha256=Qy_DkVo6Xj_zzOtmErrATe8lHZhOqdjpt3e4JJAGyi8,61
-Jinja2-2.11.2.dist-info/top_level.txt,sha256=PkeVWtLb3-CqjWi1fO29OCbj55EhX_chhKrCdrVe_zs,7
-jinja2/__init__.py,sha256=0QCM_jKKDM10yzSdHRVV4mQbCbDqf0GN0GirAqibn9Y,1549
-jinja2/__pycache__/__init__.cpython-38.pyc,,
-jinja2/__pycache__/_compat.cpython-38.pyc,,
-jinja2/__pycache__/_identifier.cpython-38.pyc,,
-jinja2/__pycache__/asyncfilters.cpython-38.pyc,,
-jinja2/__pycache__/asyncsupport.cpython-38.pyc,,
-jinja2/__pycache__/bccache.cpython-38.pyc,,
-jinja2/__pycache__/compiler.cpython-38.pyc,,
-jinja2/__pycache__/constants.cpython-38.pyc,,
-jinja2/__pycache__/debug.cpython-38.pyc,,
-jinja2/__pycache__/defaults.cpython-38.pyc,,
-jinja2/__pycache__/environment.cpython-38.pyc,,
-jinja2/__pycache__/exceptions.cpython-38.pyc,,
-jinja2/__pycache__/ext.cpython-38.pyc,,
-jinja2/__pycache__/filters.cpython-38.pyc,,
-jinja2/__pycache__/idtracking.cpython-38.pyc,,
-jinja2/__pycache__/lexer.cpython-38.pyc,,
-jinja2/__pycache__/loaders.cpython-38.pyc,,
-jinja2/__pycache__/meta.cpython-38.pyc,,
-jinja2/__pycache__/nativetypes.cpython-38.pyc,,
-jinja2/__pycache__/nodes.cpython-38.pyc,,
-jinja2/__pycache__/optimizer.cpython-38.pyc,,
-jinja2/__pycache__/parser.cpython-38.pyc,,
-jinja2/__pycache__/runtime.cpython-38.pyc,,
-jinja2/__pycache__/sandbox.cpython-38.pyc,,
-jinja2/__pycache__/tests.cpython-38.pyc,,
-jinja2/__pycache__/utils.cpython-38.pyc,,
-jinja2/__pycache__/visitor.cpython-38.pyc,,
-jinja2/_compat.py,sha256=B6Se8HjnXVpzz9-vfHejn-DV2NjaVK-Iewupc5kKlu8,3191
-jinja2/_identifier.py,sha256=EdgGJKi7O1yvr4yFlvqPNEqV6M1qHyQr8Gt8GmVTKVM,1775
-jinja2/asyncfilters.py,sha256=XJtYXTxFvcJ5xwk6SaDL4S0oNnT0wPYvXBCSzc482fI,4250
-jinja2/asyncsupport.py,sha256=ZBFsDLuq3Gtji3Ia87lcyuDbqaHZJRdtShZcqwpFnSQ,7209
-jinja2/bccache.py,sha256=3Pmp4jo65M9FQuIxdxoDBbEDFwe4acDMQf77nEJfrHA,12139
-jinja2/compiler.py,sha256=Ta9W1Lit542wItAHXlDcg0sEOsFDMirCdlFPHAurg4o,66284
-jinja2/constants.py,sha256=RR1sTzNzUmKco6aZicw4JpQpJGCuPuqm1h1YmCNUEFY,1458
-jinja2/debug.py,sha256=neR7GIGGjZH3_ILJGVUYy3eLQCCaWJMXOb7o0kGInWc,8529
-jinja2/defaults.py,sha256=85B6YUUCyWPSdrSeVhcqFVuu_bHUAQXeey--FIwSeVQ,1126
-jinja2/environment.py,sha256=XDSLKc4SqNLMOwTSq3TbWEyA5WyXfuLuVD0wAVjEFwM,50629
-jinja2/exceptions.py,sha256=VjNLawcmf2ODffqVMCQK1cRmvFaUfQWF4u8ouP3QPcE,5425
-jinja2/ext.py,sha256=AtwL5O5enT_L3HR9-oBvhGyUTdGoyaqG_ICtnR_EVd4,26441
-jinja2/filters.py,sha256=_RpPgAlgIj7ExvyDzcHAC3B36cocfWK-1TEketbNeM0,41415
-jinja2/idtracking.py,sha256=J3O4VHsrbf3wzwiBc7Cro26kHb6_5kbULeIOzocchIU,9211
-jinja2/lexer.py,sha256=nUFLRKhhKmmEWkLI65nQePgcQs7qsRdjVYZETMt_v0g,30331
-jinja2/loaders.py,sha256=C-fST_dmFjgWkp0ZuCkrgICAoOsoSIF28wfAFink0oU,17666
-jinja2/meta.py,sha256=QjyYhfNRD3QCXjBJpiPl9KgkEkGXJbAkCUq4-Ur10EQ,4131
-jinja2/nativetypes.py,sha256=Ul__gtVw4xH-0qvUvnCNHedQeNDwmEuyLJztzzSPeRg,2753
-jinja2/nodes.py,sha256=Mk1oJPVgIjnQw9WOqILvcu3rLepcFZ0ahxQm2mbwDwc,31095
-jinja2/optimizer.py,sha256=gQLlMYzvQhluhzmAIFA1tXS0cwgWYOjprN-gTRcHVsc,1457
-jinja2/parser.py,sha256=fcfdqePNTNyvosIvczbytVA332qpsURvYnCGcjDHSkA,35660
-jinja2/runtime.py,sha256=0y-BRyIEZ9ltByL2Id6GpHe1oDRQAwNeQvI0SKobNMw,30618
-jinja2/sandbox.py,sha256=knayyUvXsZ-F0mk15mO2-ehK9gsw04UhB8td-iUOtLc,17127
-jinja2/tests.py,sha256=iO_Y-9Vo60zrVe1lMpSl5sKHqAxe2leZHC08OoZ8K24,4799
-jinja2/utils.py,sha256=OoVMlQe9S2-lWT6jJbTu9tDuDvGNyWUhHDcE51i5_Do,22522
-jinja2/visitor.py,sha256=DUHupl0a4PGp7nxRtZFttUzAi1ccxzqc2hzetPYUz8U,3240
diff --git a/Flaskserver/venv/Lib/site-packages/Jinja2-2.11.2.dist-info/WHEEL b/Flaskserver/venv/Lib/site-packages/Jinja2-2.11.2.dist-info/WHEEL
deleted file mode 100644
index ef99c6cf3283b50a273ac4c6d009a0aa85597070..0000000000000000000000000000000000000000
--- a/Flaskserver/venv/Lib/site-packages/Jinja2-2.11.2.dist-info/WHEEL
+++ /dev/null
@@ -1,6 +0,0 @@
-Wheel-Version: 1.0
-Generator: bdist_wheel (0.34.2)
-Root-Is-Purelib: true
-Tag: py2-none-any
-Tag: py3-none-any
-
diff --git a/Flaskserver/venv/Lib/site-packages/Jinja2-2.11.2.dist-info/entry_points.txt b/Flaskserver/venv/Lib/site-packages/Jinja2-2.11.2.dist-info/entry_points.txt
deleted file mode 100644
index 3619483fd4fca7407f3bd462aefcd70d1de69737..0000000000000000000000000000000000000000
--- a/Flaskserver/venv/Lib/site-packages/Jinja2-2.11.2.dist-info/entry_points.txt
+++ /dev/null
@@ -1,3 +0,0 @@
-[babel.extractors]
-jinja2 = jinja2.ext:babel_extract [i18n]
-
diff --git a/Flaskserver/venv/Lib/site-packages/Jinja2-2.11.2.dist-info/top_level.txt b/Flaskserver/venv/Lib/site-packages/Jinja2-2.11.2.dist-info/top_level.txt
deleted file mode 100644
index 7f7afbf3bf54b346092be6a72070fcbd305ead1e..0000000000000000000000000000000000000000
--- a/Flaskserver/venv/Lib/site-packages/Jinja2-2.11.2.dist-info/top_level.txt
+++ /dev/null
@@ -1 +0,0 @@
-jinja2
diff --git a/Flaskserver/venv/Lib/site-packages/MarkupSafe-1.1.1.dist-info/INSTALLER b/Flaskserver/venv/Lib/site-packages/MarkupSafe-1.1.1.dist-info/INSTALLER
deleted file mode 100644
index a1b589e38a32041e49332e5e81c2d363dc418d68..0000000000000000000000000000000000000000
--- a/Flaskserver/venv/Lib/site-packages/MarkupSafe-1.1.1.dist-info/INSTALLER
+++ /dev/null
@@ -1 +0,0 @@
-pip
diff --git a/Flaskserver/venv/Lib/site-packages/MarkupSafe-1.1.1.dist-info/LICENSE.rst b/Flaskserver/venv/Lib/site-packages/MarkupSafe-1.1.1.dist-info/LICENSE.rst
deleted file mode 100644
index 9d227a0cc43c3268d15722b763bd94ad298645a1..0000000000000000000000000000000000000000
--- a/Flaskserver/venv/Lib/site-packages/MarkupSafe-1.1.1.dist-info/LICENSE.rst
+++ /dev/null
@@ -1,28 +0,0 @@
-Copyright 2010 Pallets
-
-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.
diff --git a/Flaskserver/venv/Lib/site-packages/MarkupSafe-1.1.1.dist-info/METADATA b/Flaskserver/venv/Lib/site-packages/MarkupSafe-1.1.1.dist-info/METADATA
deleted file mode 100644
index c50370d6e8457be099ff654efbacd8d89d1e9d45..0000000000000000000000000000000000000000
--- a/Flaskserver/venv/Lib/site-packages/MarkupSafe-1.1.1.dist-info/METADATA
+++ /dev/null
@@ -1,105 +0,0 @@
-Metadata-Version: 2.1
-Name: MarkupSafe
-Version: 1.1.1
-Summary: Safely add untrusted strings to HTML/XML markup.
-Home-page: https://palletsprojects.com/p/markupsafe/
-Author: Armin Ronacher
-Author-email: armin.ronacher@active-4.com
-Maintainer: The Pallets Team
-Maintainer-email: contact@palletsprojects.com
-License: BSD-3-Clause
-Project-URL: Documentation, https://markupsafe.palletsprojects.com/
-Project-URL: Code, https://github.com/pallets/markupsafe
-Project-URL: Issue tracker, https://github.com/pallets/markupsafe/issues
-Platform: UNKNOWN
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Environment :: Web Environment
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: BSD License
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 2
-Classifier: Programming Language :: Python :: 2.7
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.4
-Classifier: Programming Language :: Python :: 3.5
-Classifier: Programming Language :: Python :: 3.6
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Classifier: Topic :: Text Processing :: Markup :: HTML
-Requires-Python: >=2.7,!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*
-Description-Content-Type: text/x-rst
-
-MarkupSafe
-==========
-
-MarkupSafe implements a text object that escapes characters so it is
-safe to use in HTML and XML. Characters that have special meanings are
-replaced so that they display as the actual characters. This mitigates
-injection attacks, meaning untrusted user input can safely be displayed
-on a page.
-
-
-Installing
-----------
-
-Install and update using `pip`_:
-
-.. code-block:: text
-
-    pip install -U MarkupSafe
-
-.. _pip: https://pip.pypa.io/en/stable/quickstart/
-
-
-Examples
---------
-
-.. code-block:: pycon
-
-    >>> from markupsafe import Markup, escape
-    >>> # escape replaces special characters and wraps in Markup
-    >>> escape('<script>alert(document.cookie);</script>')
-    Markup(u'&lt;script&gt;alert(document.cookie);&lt;/script&gt;')
-    >>> # wrap in Markup to mark text "safe" and prevent escaping
-    >>> Markup('<strong>Hello</strong>')
-    Markup('<strong>hello</strong>')
-    >>> escape(Markup('<strong>Hello</strong>'))
-    Markup('<strong>hello</strong>')
-    >>> # Markup is a text subclass (str on Python 3, unicode on Python 2)
-    >>> # methods and operators escape their arguments
-    >>> template = Markup("Hello <em>%s</em>")
-    >>> template % '"World"'
-    Markup('Hello <em>&#34;World&#34;</em>')
-
-
-Donate
-------
-
-The Pallets organization develops and supports MarkupSafe and other
-libraries that use it. In order to grow the community of contributors
-and users, and allow the maintainers to devote more time to the
-projects, `please donate today`_.
-
-.. _please donate today: https://palletsprojects.com/donate
-
-
-Links
------
-
-*   Website: https://palletsprojects.com/p/markupsafe/
-*   Documentation: https://markupsafe.palletsprojects.com/
-*   License: `BSD-3-Clause <https://github.com/pallets/markupsafe/blob/master/LICENSE.rst>`_
-*   Releases: https://pypi.org/project/MarkupSafe/
-*   Code: https://github.com/pallets/markupsafe
-*   Issue tracker: https://github.com/pallets/markupsafe/issues
-*   Test status:
-
-    *   Linux, Mac: https://travis-ci.org/pallets/markupsafe
-    *   Windows: https://ci.appveyor.com/project/pallets/markupsafe
-
-*   Test coverage: https://codecov.io/gh/pallets/markupsafe
-*   Official chat: https://discord.gg/t6rrQZH
-
-
diff --git a/Flaskserver/venv/Lib/site-packages/MarkupSafe-1.1.1.dist-info/RECORD b/Flaskserver/venv/Lib/site-packages/MarkupSafe-1.1.1.dist-info/RECORD
deleted file mode 100644
index 892e3c59be97f7a84f81d132d3eebc1e6e60e0fb..0000000000000000000000000000000000000000
--- a/Flaskserver/venv/Lib/site-packages/MarkupSafe-1.1.1.dist-info/RECORD
+++ /dev/null
@@ -1,15 +0,0 @@
-MarkupSafe-1.1.1.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
-MarkupSafe-1.1.1.dist-info/LICENSE.rst,sha256=RjHsDbX9kKVH4zaBcmTGeYIUM4FG-KyUtKV_lu6MnsQ,1503
-MarkupSafe-1.1.1.dist-info/METADATA,sha256=IFCP4hCNGjXJgMoSvdjPiKDLAMUTTWoxKXQsQvmyMNU,3653
-MarkupSafe-1.1.1.dist-info/RECORD,,
-MarkupSafe-1.1.1.dist-info/WHEEL,sha256=z-ezgbNu1Y2ixypRrBmFDHP9mmiBhiGywozViqVfAIc,105
-MarkupSafe-1.1.1.dist-info/top_level.txt,sha256=qy0Plje5IJuvsCBjejJyhDCjEAdcDLK_2agVcex8Z6U,11
-markupsafe/__init__.py,sha256=UAy1UKlykemnSZWIVn8RDqY0wvjV6lkeRwYOMNhw4bA,10453
-markupsafe/__pycache__/__init__.cpython-38.pyc,,
-markupsafe/__pycache__/_compat.cpython-38.pyc,,
-markupsafe/__pycache__/_constants.cpython-38.pyc,,
-markupsafe/__pycache__/_native.cpython-38.pyc,,
-markupsafe/_compat.py,sha256=XweNhJEcyTP_wIBUaIO6nxzIb6XFwweriXyZfiTpkdw,591
-markupsafe/_constants.py,sha256=IXLUQkLM6CTustG5vEQTEy6pBB3z5pm84NkYU1aW9qI,4954
-markupsafe/_native.py,sha256=LwsYk-GHoPsPboRD_tNC6_jTmCj3MLtsnDFis7HjE50,1942
-markupsafe/_speedups.cp38-win_amd64.pyd,sha256=5dfKRjDzuEw9S4XjBgpxYSnBLLuHGj7pmC0-u3p_Qc4,14848
diff --git a/Flaskserver/venv/Lib/site-packages/MarkupSafe-1.1.1.dist-info/WHEEL b/Flaskserver/venv/Lib/site-packages/MarkupSafe-1.1.1.dist-info/WHEEL
deleted file mode 100644
index 1b5d689aec8ef45132bd1bf5a64a9ae4ecd3d0f8..0000000000000000000000000000000000000000
--- a/Flaskserver/venv/Lib/site-packages/MarkupSafe-1.1.1.dist-info/WHEEL
+++ /dev/null
@@ -1,5 +0,0 @@
-Wheel-Version: 1.0
-Generator: bdist_wheel (0.33.6)
-Root-Is-Purelib: false
-Tag: cp38-cp38-win_amd64
-
diff --git a/Flaskserver/venv/Lib/site-packages/MarkupSafe-1.1.1.dist-info/top_level.txt b/Flaskserver/venv/Lib/site-packages/MarkupSafe-1.1.1.dist-info/top_level.txt
deleted file mode 100644
index 75bf729258f9daef77370b6df1a57940f90fc23f..0000000000000000000000000000000000000000
--- a/Flaskserver/venv/Lib/site-packages/MarkupSafe-1.1.1.dist-info/top_level.txt
+++ /dev/null
@@ -1 +0,0 @@
-markupsafe
diff --git a/Flaskserver/venv/Lib/site-packages/PyYAML-5.3.1.dist-info/INSTALLER b/Flaskserver/venv/Lib/site-packages/PyYAML-5.3.1.dist-info/INSTALLER
deleted file mode 100644
index a1b589e38a32041e49332e5e81c2d363dc418d68..0000000000000000000000000000000000000000
--- a/Flaskserver/venv/Lib/site-packages/PyYAML-5.3.1.dist-info/INSTALLER
+++ /dev/null
@@ -1 +0,0 @@
-pip
diff --git a/Flaskserver/venv/Lib/site-packages/PyYAML-5.3.1.dist-info/LICENSE b/Flaskserver/venv/Lib/site-packages/PyYAML-5.3.1.dist-info/LICENSE
deleted file mode 100644
index 3d82c281ee8ceb45368153139f5935bd8d39c816..0000000000000000000000000000000000000000
--- a/Flaskserver/venv/Lib/site-packages/PyYAML-5.3.1.dist-info/LICENSE
+++ /dev/null
@@ -1,20 +0,0 @@
-Copyright (c) 2017-2020 Ingy döt Net
-Copyright (c) 2006-2016 Kirill Simonov
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of
-this software and associated documentation files (the "Software"), to deal in
-the Software without restriction, including without limitation the rights to
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
-of the Software, and to permit persons to whom the Software is furnished to do
-so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
diff --git a/Flaskserver/venv/Lib/site-packages/PyYAML-5.3.1.dist-info/METADATA b/Flaskserver/venv/Lib/site-packages/PyYAML-5.3.1.dist-info/METADATA
deleted file mode 100644
index 6cba5ce42253ea3189768462e2f743cfa436a0a5..0000000000000000000000000000000000000000
--- a/Flaskserver/venv/Lib/site-packages/PyYAML-5.3.1.dist-info/METADATA
+++ /dev/null
@@ -1,40 +0,0 @@
-Metadata-Version: 2.1
-Name: PyYAML
-Version: 5.3.1
-Summary: YAML parser and emitter for Python
-Home-page: https://github.com/yaml/pyyaml
-Author: Kirill Simonov
-Author-email: xi@resolvent.net
-License: MIT
-Download-URL: https://pypi.org/project/PyYAML/
-Platform: Any
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Cython
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 2
-Classifier: Programming Language :: Python :: 2.7
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.5
-Classifier: Programming Language :: Python :: 3.6
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: Implementation :: CPython
-Classifier: Programming Language :: Python :: Implementation :: PyPy
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Classifier: Topic :: Text Processing :: Markup
-
-YAML is a data serialization format designed for human readability
-and interaction with scripting languages.  PyYAML is a YAML parser
-and emitter for Python.
-
-PyYAML features a complete YAML 1.1 parser, Unicode support, pickle
-support, capable extension API, and sensible error messages.  PyYAML
-supports standard YAML tags and provides Python-specific tags that
-allow to represent an arbitrary Python object.
-
-PyYAML is applicable for a broad range of tasks from complex
-configuration files to object serialization and persistence.
-
diff --git a/Flaskserver/venv/Lib/site-packages/PyYAML-5.3.1.dist-info/RECORD b/Flaskserver/venv/Lib/site-packages/PyYAML-5.3.1.dist-info/RECORD
deleted file mode 100644
index 89ac3fafdc355e6395b3cdd3ff90d5a65eb4511c..0000000000000000000000000000000000000000
--- a/Flaskserver/venv/Lib/site-packages/PyYAML-5.3.1.dist-info/RECORD
+++ /dev/null
@@ -1,40 +0,0 @@
-PyYAML-5.3.1.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
-PyYAML-5.3.1.dist-info/LICENSE,sha256=xAESRJ8lS5dTBFklJIMT6ScO-jbSJrItgtTMbEPFfyk,1101
-PyYAML-5.3.1.dist-info/METADATA,sha256=JMHGIwZThSlNcmGxXTVZ-NFNK3KiEHBdfryJFfPG7Yk,1690
-PyYAML-5.3.1.dist-info/RECORD,,
-PyYAML-5.3.1.dist-info/WHEEL,sha256=-ODc2a2AO_YJ5T46NOquHfWjRM7bQvlt-f3zRaLBjL4,105
-_yaml.cp38-win_amd64.pyd,sha256=4GsUf9UXEtLFhk52pQCdWR15hJ4STDjUQth8KLldsQ8,284672
-yaml/__init__.py,sha256=XFUNbKTg4afAd0BETjGQ1mKQ97_g5jbE1C0WoKc74dc,13170
-yaml/__pycache__/__init__.cpython-38.pyc,sha256=VIr8pQ7J6C7GTdteeqhWWDKmp6o5b7KpXk9X9HEhXqM,11842
-yaml/__pycache__/composer.cpython-38.pyc,sha256=1QlHfIiSaExiYXxyPcOWx_K1v3OjqyW6QJQGeA5loDg,3560
-yaml/__pycache__/constructor.cpython-38.pyc,sha256=yj61plpCRp5H70DJ_Cakt-Avp_-0Wd0e3bRwLiNn5nQ,20819
-yaml/__pycache__/cyaml.cpython-38.pyc,sha256=VB_nI5aH0e7dPslaQTAx4m3BtdPpnmJw_yplqglilq8,3403
-yaml/__pycache__/dumper.cpython-38.pyc,sha256=6Hz-MxVnKWNrL9AF5bhrazSzRsLASWdbKYcVOXM7Qvw,1820
-yaml/__pycache__/emitter.cpython-38.pyc,sha256=UmRyfsvoEeb3aWG9DH5aY5Lrfmp7j3MZACiM90X-T7o,25350
-yaml/__pycache__/error.cpython-38.pyc,sha256=raWrNypX-e6i4s-SGToFOLg1mLSPs5c4ckc5iQXk20g,2297
-yaml/__pycache__/events.cpython-38.pyc,sha256=HBhv35Azy6dUDZSqCDPIsTzoyo-1y1kV3-z8M5AX-0I,3971
-yaml/__pycache__/loader.cpython-38.pyc,sha256=sQo_AFAhK20zN8w0s_dPtX88kg3M_a3C0bm8oZv4eIc,2161
-yaml/__pycache__/nodes.cpython-38.pyc,sha256=qGsbHemePSdhFJszDBi1uqjTtsO5F0c42Do-8EnEUeU,1722
-yaml/__pycache__/parser.cpython-38.pyc,sha256=c-zTpzjoNNwLnj-IiFxuy5F3P_Jo_0Tpm3hvAm2Jwno,11921
-yaml/__pycache__/reader.cpython-38.pyc,sha256=IvAiKEPwRjeoQjywtMZMcvNikFEdsbl1WkfqmJ5Orxc,4534
-yaml/__pycache__/representer.cpython-38.pyc,sha256=iArfEC3B4wSRK0Y04gr9l66nOdrRIcK1kK70YJnoSKk,10066
-yaml/__pycache__/resolver.cpython-38.pyc,sha256=tkBjJOtUkhyvchWgouur-mdhwi2uk9XkTak-f1ws9DY,5475
-yaml/__pycache__/scanner.cpython-38.pyc,sha256=2fxtpWWuiB3DGZajd8KsZaJ6Hugt5wtAdJbsY56nhYo,25266
-yaml/__pycache__/serializer.cpython-38.pyc,sha256=DUQCfMIgwmGaHM0nYsTk_R7qSBFOOMfnxbf0TZr_Vlc,3317
-yaml/__pycache__/tokens.cpython-38.pyc,sha256=hLLE8--b5O6JkJEOGPMxCyJDyz4IraBhAJapxxTvvPI,4932
-yaml/composer.py,sha256=_Ko30Wr6eDWUeUpauUGT3Lcg9QPBnOPVlTnIMRGJ9FM,4883
-yaml/constructor.py,sha256=O3Uaf0_J_5GQBoeI9ZNhpJAhtdagr_X2HzDgGbZOMnw,28627
-yaml/cyaml.py,sha256=LiMkvchNonfoy1F6ec9L2BiUz3r0bwF4hympASJX1Ic,3846
-yaml/dumper.py,sha256=PLctZlYwZLp7XmeUdwRuv4nYOZ2UBnDIUy8-lKfLF-o,2837
-yaml/emitter.py,sha256=jghtaU7eFwg31bG0B7RZea_29Adi9CKmXq_QjgQpCkQ,43006
-yaml/error.py,sha256=Ah9z-toHJUbE9j-M8YpxgSRM5CgLCcwVzJgLLRF2Fxo,2533
-yaml/events.py,sha256=50_TksgQiE4up-lKo_V-nBy-tAIxkIPQxY5qDhKCeHw,2445
-yaml/loader.py,sha256=UVa-zIqmkFSCIYq_PgSGm4NSJttHY2Rf_zQ4_b1fHN0,2061
-yaml/nodes.py,sha256=gPKNj8pKCdh2d4gr3gIYINnPOaOxGhJAUiYhGRnPE84,1440
-yaml/parser.py,sha256=ilWp5vvgoHFGzvOZDItFoGjD6D42nhlZrZyjAwa0oJo,25495
-yaml/reader.py,sha256=0dmzirOiDG4Xo41RnuQS7K9rkY3xjHiVasfDMNTqCNw,6794
-yaml/representer.py,sha256=82UM3ZxUQKqsKAF4ltWOxCS6jGPIFtXpGs7mvqyv4Xs,14184
-yaml/resolver.py,sha256=DJCjpQr8YQCEYYjKEYqTl0GrsZil2H4aFOI9b0Oe-U4,8970
-yaml/scanner.py,sha256=KeQIKGNlSyPE8QDwionHxy9CgbqE5teJEz05FR9-nAg,51277
-yaml/serializer.py,sha256=ChuFgmhU01hj4xgI8GaKv6vfM2Bujwa9i7d2FAHj7cA,4165
-yaml/tokens.py,sha256=lTQIzSVw8Mg9wv459-TjiOQe6wVziqaRlqX2_89rp54,2573
diff --git a/Flaskserver/venv/Lib/site-packages/PyYAML-5.3.1.dist-info/WHEEL b/Flaskserver/venv/Lib/site-packages/PyYAML-5.3.1.dist-info/WHEEL
deleted file mode 100644
index a5724305629dbcc76220ce1448625f0e9a2a4509..0000000000000000000000000000000000000000
--- a/Flaskserver/venv/Lib/site-packages/PyYAML-5.3.1.dist-info/WHEEL
+++ /dev/null
@@ -1,5 +0,0 @@
-Wheel-Version: 1.0
-Generator: bdist_wheel (0.34.2)
-Root-Is-Purelib: false
-Tag: cp38-cp38-win_amd64
-
diff --git a/Flaskserver/venv/Lib/site-packages/Werkzeug-1.0.1.dist-info/INSTALLER b/Flaskserver/venv/Lib/site-packages/Werkzeug-1.0.1.dist-info/INSTALLER
deleted file mode 100644
index a1b589e38a32041e49332e5e81c2d363dc418d68..0000000000000000000000000000000000000000
--- a/Flaskserver/venv/Lib/site-packages/Werkzeug-1.0.1.dist-info/INSTALLER
+++ /dev/null
@@ -1 +0,0 @@
-pip
diff --git a/Flaskserver/venv/Lib/site-packages/Werkzeug-1.0.1.dist-info/LICENSE.rst b/Flaskserver/venv/Lib/site-packages/Werkzeug-1.0.1.dist-info/LICENSE.rst
deleted file mode 100644
index c37cae49ec77ad6ebb25568c1605f1fee5313cfb..0000000000000000000000000000000000000000
--- a/Flaskserver/venv/Lib/site-packages/Werkzeug-1.0.1.dist-info/LICENSE.rst
+++ /dev/null
@@ -1,28 +0,0 @@
-Copyright 2007 Pallets
-
-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.
diff --git a/Flaskserver/venv/Lib/site-packages/Werkzeug-1.0.1.dist-info/METADATA b/Flaskserver/venv/Lib/site-packages/Werkzeug-1.0.1.dist-info/METADATA
deleted file mode 100644
index eb5f70917be514240bb54b29387fd593825cbd89..0000000000000000000000000000000000000000
--- a/Flaskserver/venv/Lib/site-packages/Werkzeug-1.0.1.dist-info/METADATA
+++ /dev/null
@@ -1,128 +0,0 @@
-Metadata-Version: 2.1
-Name: Werkzeug
-Version: 1.0.1
-Summary: The comprehensive WSGI web application library.
-Home-page: https://palletsprojects.com/p/werkzeug/
-Author: Armin Ronacher
-Author-email: armin.ronacher@active-4.com
-Maintainer: Pallets
-Maintainer-email: contact@palletsprojects.com
-License: BSD-3-Clause
-Project-URL: Documentation, https://werkzeug.palletsprojects.com/
-Project-URL: Code, https://github.com/pallets/werkzeug
-Project-URL: Issue tracker, https://github.com/pallets/werkzeug/issues
-Platform: UNKNOWN
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Environment :: Web Environment
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: BSD License
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 2
-Classifier: Programming Language :: Python :: 2.7
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.5
-Classifier: Programming Language :: Python :: 3.6
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: Implementation :: CPython
-Classifier: Programming Language :: Python :: Implementation :: PyPy
-Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
-Classifier: Topic :: Internet :: WWW/HTTP :: WSGI
-Classifier: Topic :: Internet :: WWW/HTTP :: WSGI :: Application
-Classifier: Topic :: Internet :: WWW/HTTP :: WSGI :: Middleware
-Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: >=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*
-Description-Content-Type: text/x-rst
-Provides-Extra: dev
-Requires-Dist: pytest ; extra == 'dev'
-Requires-Dist: pytest-timeout ; extra == 'dev'
-Requires-Dist: coverage ; extra == 'dev'
-Requires-Dist: tox ; extra == 'dev'
-Requires-Dist: sphinx ; extra == 'dev'
-Requires-Dist: pallets-sphinx-themes ; extra == 'dev'
-Requires-Dist: sphinx-issues ; extra == 'dev'
-Provides-Extra: watchdog
-Requires-Dist: watchdog ; extra == 'watchdog'
-
-Werkzeug
-========
-
-*werkzeug* German noun: "tool". Etymology: *werk* ("work"), *zeug* ("stuff")
-
-Werkzeug is a comprehensive `WSGI`_ web application library. It began as
-a simple collection of various utilities for WSGI applications and has
-become one of the most advanced WSGI utility libraries.
-
-It includes:
-
--   An interactive debugger that allows inspecting stack traces and
-    source code in the browser with an interactive interpreter for any
-    frame in the stack.
--   A full-featured request object with objects to interact with
-    headers, query args, form data, files, and cookies.
--   A response object that can wrap other WSGI applications and handle
-    streaming data.
--   A routing system for matching URLs to endpoints and generating URLs
-    for endpoints, with an extensible system for capturing variables
-    from URLs.
--   HTTP utilities to handle entity tags, cache control, dates, user
-    agents, cookies, files, and more.
--   A threaded WSGI server for use while developing applications
-    locally.
--   A test client for simulating HTTP requests during testing without
-    requiring running a server.
-
-Werkzeug is Unicode aware and doesn't enforce any dependencies. It is up
-to the developer to choose a template engine, database adapter, and even
-how to handle requests. It can be used to build all sorts of end user
-applications such as blogs, wikis, or bulletin boards.
-
-`Flask`_ wraps Werkzeug, using it to handle the details of WSGI while
-providing more structure and patterns for defining powerful
-applications.
-
-
-Installing
-----------
-
-Install and update using `pip`_:
-
-.. code-block:: text
-
-    pip install -U Werkzeug
-
-
-A Simple Example
-----------------
-
-.. code-block:: python
-
-    from werkzeug.wrappers import Request, Response
-
-    @Request.application
-    def application(request):
-        return Response('Hello, World!')
-
-    if __name__ == '__main__':
-        from werkzeug.serving import run_simple
-        run_simple('localhost', 4000, application)
-
-
-Links
------
-
--   Website: https://palletsprojects.com/p/werkzeug/
--   Documentation: https://werkzeug.palletsprojects.com/
--   Releases: https://pypi.org/project/Werkzeug/
--   Code: https://github.com/pallets/werkzeug
--   Issue tracker: https://github.com/pallets/werkzeug/issues
--   Test status: https://dev.azure.com/pallets/werkzeug/_build
--   Official chat: https://discord.gg/t6rrQZH
-
-.. _WSGI: https://wsgi.readthedocs.io/en/latest/
-.. _Flask: https://www.palletsprojects.com/p/flask/
-.. _pip: https://pip.pypa.io/en/stable/quickstart/
-
-
diff --git a/Flaskserver/venv/Lib/site-packages/Werkzeug-1.0.1.dist-info/RECORD b/Flaskserver/venv/Lib/site-packages/Werkzeug-1.0.1.dist-info/RECORD
deleted file mode 100644
index 9bc5975ef80ea54435e2533f09e734a1592a5a15..0000000000000000000000000000000000000000
--- a/Flaskserver/venv/Lib/site-packages/Werkzeug-1.0.1.dist-info/RECORD
+++ /dev/null
@@ -1,101 +0,0 @@
-Werkzeug-1.0.1.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
-Werkzeug-1.0.1.dist-info/LICENSE.rst,sha256=O0nc7kEF6ze6wQ-vG-JgQI_oXSUrjp3y4JefweCUQ3s,1475
-Werkzeug-1.0.1.dist-info/METADATA,sha256=d0zmVNa4UC2-nAo2A8_81oiy123D6JTGRSuY_Ymgyt4,4730
-Werkzeug-1.0.1.dist-info/RECORD,,
-Werkzeug-1.0.1.dist-info/WHEEL,sha256=kGT74LWyRUZrL4VgLh6_g12IeVl_9u9ZVhadrgXZUEY,110
-Werkzeug-1.0.1.dist-info/top_level.txt,sha256=QRyj2VjwJoQkrwjwFIOlB8Xg3r9un0NtqVHQF-15xaw,9
-werkzeug/__init__.py,sha256=rb-yPiXOjTLbtDOl5fQp5hN7oBdaoXAoQ-slAAvfZAo,502
-werkzeug/__pycache__/__init__.cpython-38.pyc,,
-werkzeug/__pycache__/_compat.cpython-38.pyc,,
-werkzeug/__pycache__/_internal.cpython-38.pyc,,
-werkzeug/__pycache__/_reloader.cpython-38.pyc,,
-werkzeug/__pycache__/datastructures.cpython-38.pyc,,
-werkzeug/__pycache__/exceptions.cpython-38.pyc,,
-werkzeug/__pycache__/filesystem.cpython-38.pyc,,
-werkzeug/__pycache__/formparser.cpython-38.pyc,,
-werkzeug/__pycache__/http.cpython-38.pyc,,
-werkzeug/__pycache__/local.cpython-38.pyc,,
-werkzeug/__pycache__/posixemulation.cpython-38.pyc,,
-werkzeug/__pycache__/routing.cpython-38.pyc,,
-werkzeug/__pycache__/security.cpython-38.pyc,,
-werkzeug/__pycache__/serving.cpython-38.pyc,,
-werkzeug/__pycache__/test.cpython-38.pyc,,
-werkzeug/__pycache__/testapp.cpython-38.pyc,,
-werkzeug/__pycache__/urls.cpython-38.pyc,,
-werkzeug/__pycache__/useragents.cpython-38.pyc,,
-werkzeug/__pycache__/utils.cpython-38.pyc,,
-werkzeug/__pycache__/wsgi.cpython-38.pyc,,
-werkzeug/_compat.py,sha256=zjufTNrhQ8BgYSGSh-sVu6iW3r3O9WzjE9j-qJobx-g,6671
-werkzeug/_internal.py,sha256=d_4AqheyS6dHMViwdc0drFrjs67ZzT6Ej2gWf-Z-Iys,14351
-werkzeug/_reloader.py,sha256=I3mg3oRQ0lLzl06oEoVopN3bN7CtINuuUQdqDcmTnEs,11531
-werkzeug/datastructures.py,sha256=AonxOcwU0TPMEzfKF1368ySULxHgxE-JE-DEAGdo2ts,100480
-werkzeug/debug/__init__.py,sha256=3RtUMc5Y9hYyK11ugHltgkQ9Dt-ViR945Vy_X5NV7zU,17289
-werkzeug/debug/__pycache__/__init__.cpython-38.pyc,,
-werkzeug/debug/__pycache__/console.cpython-38.pyc,,
-werkzeug/debug/__pycache__/repr.cpython-38.pyc,,
-werkzeug/debug/__pycache__/tbtools.cpython-38.pyc,,
-werkzeug/debug/console.py,sha256=OATaO7KHYMqpbzIFe1HeW9Mnl3wZgA3jMQoGDPn5URc,5488
-werkzeug/debug/repr.py,sha256=lIwuhbyrMwVe3P_cFqNyqzHL7P93TLKod7lw9clydEw,9621
-werkzeug/debug/shared/FONT_LICENSE,sha256=LwAVEI1oYnvXiNMT9SnCH_TaLCxCpeHziDrMg0gPkAI,4673
-werkzeug/debug/shared/console.png,sha256=bxax6RXXlvOij_KeqvSNX0ojJf83YbnZ7my-3Gx9w2A,507
-werkzeug/debug/shared/debugger.js,sha256=rOhqZMRfpZnnu6_XCGn6wMWPhtfwRAcyZKksdIxPJas,6400
-werkzeug/debug/shared/jquery.js,sha256=CSXorXvZcTkaix6Yvo6HppcZGetbYMGWSFlBw8HfCJo,88145
-werkzeug/debug/shared/less.png,sha256=-4-kNRaXJSONVLahrQKUxMwXGm9R4OnZ9SxDGpHlIR4,191
-werkzeug/debug/shared/more.png,sha256=GngN7CioHQoV58rH6ojnkYi8c_qED2Aka5FO5UXrReY,200
-werkzeug/debug/shared/source.png,sha256=RoGcBTE4CyCB85GBuDGTFlAnUqxwTBiIfDqW15EpnUQ,818
-werkzeug/debug/shared/style.css,sha256=gZ9uhmb5zj3XLuT9RvnMp6jMINgQ-VVBCp-2AZbG3YQ,6604
-werkzeug/debug/shared/ubuntu.ttf,sha256=1eaHFyepmy4FyDvjLVzpITrGEBu_CZYY94jE0nED1c0,70220
-werkzeug/debug/tbtools.py,sha256=2iJ8RURUZUSbopOIehy53LnVJWx47lsHN2V2l6hc7Wc,20363
-werkzeug/exceptions.py,sha256=UTYSDkmAsH-vt8VSidlEffwqBVNXuT7bRg-_NqgUe8A,25188
-werkzeug/filesystem.py,sha256=HzKl-j0Hd8Jl66j778UbPTAYNnY6vUZgYLlBZ0e7uw0,2101
-werkzeug/formparser.py,sha256=Sto0jZid9im9ZVIf56vilCdyX-arK33wSftkYsLCnzo,21788
-werkzeug/http.py,sha256=KVRV3yFK14PJeI56qClEq4qxFdvKUQVy4C_dwuWz9_Q,43107
-werkzeug/local.py,sha256=_Tk7gB238pPWUU7habxFkZF02fiCMRVW6d62YWL1Rh0,14371
-werkzeug/middleware/__init__.py,sha256=f1SFZo67IlW4k1uqKzNHxYQlsakUS-D6KK_j0e3jjwQ,549
-werkzeug/middleware/__pycache__/__init__.cpython-38.pyc,,
-werkzeug/middleware/__pycache__/dispatcher.cpython-38.pyc,,
-werkzeug/middleware/__pycache__/http_proxy.cpython-38.pyc,,
-werkzeug/middleware/__pycache__/lint.cpython-38.pyc,,
-werkzeug/middleware/__pycache__/profiler.cpython-38.pyc,,
-werkzeug/middleware/__pycache__/proxy_fix.cpython-38.pyc,,
-werkzeug/middleware/__pycache__/shared_data.cpython-38.pyc,,
-werkzeug/middleware/dispatcher.py,sha256=_-KoMzHtcISHS7ouWKAOraqlCLprdh83YOAn_8DjLp8,2240
-werkzeug/middleware/http_proxy.py,sha256=lRjTdMmghHiZuZrS7_UJ3gZc-vlFizhBbFZ-XZPLwIA,7117
-werkzeug/middleware/lint.py,sha256=ItTwuWJnflF8xMT1uqU_Ty1ryhux-CjeUfskqaUpxsw,12967
-werkzeug/middleware/profiler.py,sha256=8B_s23d6BGrU_q54gJsm6kcCbOJbTSqrXCsioHON0Xs,4471
-werkzeug/middleware/proxy_fix.py,sha256=K5oZ3DPXOzdZi0Xba5zW7ClPOxgUuqXHQHvY2-AWCGw,6431
-werkzeug/middleware/shared_data.py,sha256=sPSRTKqtKSVBUyN8fr6jOJbdq9cdOLu6pg3gz4Y_1Xo,9599
-werkzeug/posixemulation.py,sha256=gSSiv1SCmOyzOM_nq1ZaZCtxP__C5MeDJl_4yXJmi4Q,3541
-werkzeug/routing.py,sha256=6-iZ7CKeUILYAehoKXLbmi5E6LgLbwuzUh8TNplnf5Q,79019
-werkzeug/security.py,sha256=81149MplFq7-hD4RK4sKp9kzXXejjV9D4lWBzaRyeQ8,8106
-werkzeug/serving.py,sha256=YvTqvurA-Mnj8mkqRe2kBdVr2ap4ibCq1ByQjOA6g1w,38694
-werkzeug/test.py,sha256=GJ9kxTMSJ-nB7kfGtxuROr9JGmXxDRev-2U1SkeUJGE,39564
-werkzeug/testapp.py,sha256=bHekqMsqRfVxwgFbvOMem-DYa_sdB7R47yUXpt1RUTo,9329
-werkzeug/urls.py,sha256=T8-hV_1vwhu6xhX93FwsHteK-W-kIE2orj5WoMf-WFw,39322
-werkzeug/useragents.py,sha256=TSoGv5IOvP375eK5gLLpsLQCeUgTR6sO1WftmAP_YvM,5563
-werkzeug/utils.py,sha256=hrVK4u_wi8z9viBO9bgOLlm1aaIvCpn-p2d1FeZQDEo,25251
-werkzeug/wrappers/__init__.py,sha256=S4VioKAmF_av9Ec9zQvG71X1EOkYfPx1TYck9jyDiyY,1384
-werkzeug/wrappers/__pycache__/__init__.cpython-38.pyc,,
-werkzeug/wrappers/__pycache__/accept.cpython-38.pyc,,
-werkzeug/wrappers/__pycache__/auth.cpython-38.pyc,,
-werkzeug/wrappers/__pycache__/base_request.cpython-38.pyc,,
-werkzeug/wrappers/__pycache__/base_response.cpython-38.pyc,,
-werkzeug/wrappers/__pycache__/common_descriptors.cpython-38.pyc,,
-werkzeug/wrappers/__pycache__/cors.cpython-38.pyc,,
-werkzeug/wrappers/__pycache__/etag.cpython-38.pyc,,
-werkzeug/wrappers/__pycache__/json.cpython-38.pyc,,
-werkzeug/wrappers/__pycache__/request.cpython-38.pyc,,
-werkzeug/wrappers/__pycache__/response.cpython-38.pyc,,
-werkzeug/wrappers/__pycache__/user_agent.cpython-38.pyc,,
-werkzeug/wrappers/accept.py,sha256=TIvjUc0g73fhTWX54wg_D9NNzKvpnG1X8u1w26tK1o8,1760
-werkzeug/wrappers/auth.py,sha256=Pmn6iaGHBrUyHbJpW0lZhO_q9RVoAa5QalaTqcavdAI,1158
-werkzeug/wrappers/base_request.py,sha256=4TuGlKWeKQdlq4eU94hJYcXSfWo8Rk7CS1Ef5lJ3ZM0,26012
-werkzeug/wrappers/base_response.py,sha256=JTxJZ8o-IBetpoWJqt2HFwPaNWNDAlM3_GXJe1Whw80,27784
-werkzeug/wrappers/common_descriptors.py,sha256=X2Ktd5zUWsmcd4ciaF62Dd8Lru9pLGP_XDUNukc8cXs,12829
-werkzeug/wrappers/cors.py,sha256=XMbaCol4dWTGvb-dCJBoN0p3JX91v93AIAHd7tnB3L4,3466
-werkzeug/wrappers/etag.py,sha256=XMXtyfByBsOjxwaX8U7ZtUY7JXkbQLP45oXZ0qkyTNs,12217
-werkzeug/wrappers/json.py,sha256=HvK_A4NpO0sLqgb10sTJcoZydYOwyNiPCJPV7SVgcgE,4343
-werkzeug/wrappers/request.py,sha256=QbHGqDpGPN684pnOPEokwkPESfm-NnfYM7ydOMxW_NI,1514
-werkzeug/wrappers/response.py,sha256=Oqv8TMG_dnOKTq_V30ddgkO5B7IJhkVPODvm7cbhZ3c,2524
-werkzeug/wrappers/user_agent.py,sha256=YJb-vr12cujG7sQMG9V89VsJa-03SWSenhg1W4cT0EY,435
-werkzeug/wsgi.py,sha256=ZGk85NzRyQTzkYis-xl8V9ydJgfClBdStvhzDzER2mw,34367
diff --git a/Flaskserver/venv/Lib/site-packages/Werkzeug-1.0.1.dist-info/WHEEL b/Flaskserver/venv/Lib/site-packages/Werkzeug-1.0.1.dist-info/WHEEL
deleted file mode 100644
index ef99c6cf3283b50a273ac4c6d009a0aa85597070..0000000000000000000000000000000000000000
--- a/Flaskserver/venv/Lib/site-packages/Werkzeug-1.0.1.dist-info/WHEEL
+++ /dev/null
@@ -1,6 +0,0 @@
-Wheel-Version: 1.0
-Generator: bdist_wheel (0.34.2)
-Root-Is-Purelib: true
-Tag: py2-none-any
-Tag: py3-none-any
-
diff --git a/Flaskserver/venv/Lib/site-packages/Werkzeug-1.0.1.dist-info/top_level.txt b/Flaskserver/venv/Lib/site-packages/Werkzeug-1.0.1.dist-info/top_level.txt
deleted file mode 100644
index 6fe8da8499399d7c0484847967ad49e4b165589b..0000000000000000000000000000000000000000
--- a/Flaskserver/venv/Lib/site-packages/Werkzeug-1.0.1.dist-info/top_level.txt
+++ /dev/null
@@ -1 +0,0 @@
-werkzeug
diff --git a/Flaskserver/venv/Lib/site-packages/__pycache__/easy_install.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/__pycache__/easy_install.cpython-38.pyc
deleted file mode 100644
index efefa99751fc2f21d1ff2ca44ca90eedbfae7de9..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/__pycache__/easy_install.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/__pycache__/six.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/__pycache__/six.cpython-38.pyc
deleted file mode 100644
index b79edd7fccb2421ec14f571d6cd6b8ba88d03500..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/__pycache__/six.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/__pycache__/threadpoolctl.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/__pycache__/threadpoolctl.cpython-38.pyc
deleted file mode 100644
index adcd5b511aba9958388177a0c6c9edfa65f8dd44..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/__pycache__/threadpoolctl.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/_yaml.cp38-win_amd64.pyd b/Flaskserver/venv/Lib/site-packages/_yaml.cp38-win_amd64.pyd
deleted file mode 100644
index 4a031724756b5d283d445ec18fefa644c265580f..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/_yaml.cp38-win_amd64.pyd and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/click-7.1.2.dist-info/INSTALLER b/Flaskserver/venv/Lib/site-packages/click-7.1.2.dist-info/INSTALLER
deleted file mode 100644
index a1b589e38a32041e49332e5e81c2d363dc418d68..0000000000000000000000000000000000000000
--- a/Flaskserver/venv/Lib/site-packages/click-7.1.2.dist-info/INSTALLER
+++ /dev/null
@@ -1 +0,0 @@
-pip
diff --git a/Flaskserver/venv/Lib/site-packages/click-7.1.2.dist-info/LICENSE.rst b/Flaskserver/venv/Lib/site-packages/click-7.1.2.dist-info/LICENSE.rst
deleted file mode 100644
index d12a849186982399c537c5b9a8fd77bf2edd5eab..0000000000000000000000000000000000000000
--- a/Flaskserver/venv/Lib/site-packages/click-7.1.2.dist-info/LICENSE.rst
+++ /dev/null
@@ -1,28 +0,0 @@
-Copyright 2014 Pallets
-
-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.
diff --git a/Flaskserver/venv/Lib/site-packages/click-7.1.2.dist-info/METADATA b/Flaskserver/venv/Lib/site-packages/click-7.1.2.dist-info/METADATA
deleted file mode 100644
index 00d697493a2fa9ff774f5db7571477b2d616ae6d..0000000000000000000000000000000000000000
--- a/Flaskserver/venv/Lib/site-packages/click-7.1.2.dist-info/METADATA
+++ /dev/null
@@ -1,102 +0,0 @@
-Metadata-Version: 2.1
-Name: click
-Version: 7.1.2
-Summary: Composable command line interface toolkit
-Home-page: https://palletsprojects.com/p/click/
-Maintainer: Pallets
-Maintainer-email: contact@palletsprojects.com
-License: BSD-3-Clause
-Project-URL: Documentation, https://click.palletsprojects.com/
-Project-URL: Code, https://github.com/pallets/click
-Project-URL: Issue tracker, https://github.com/pallets/click/issues
-Platform: UNKNOWN
-Classifier: Development Status :: 5 - Production/Stable
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: BSD License
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 2
-Classifier: Programming Language :: Python :: 3
-Requires-Python: >=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*
-
-\$ click\_
-==========
-
-Click is a Python package for creating beautiful command line interfaces
-in a composable way with as little code as necessary. It's the "Command
-Line Interface Creation Kit". It's highly configurable but comes with
-sensible defaults out of the box.
-
-It aims to make the process of writing command line tools quick and fun
-while also preventing any frustration caused by the inability to
-implement an intended CLI API.
-
-Click in three points:
-
--   Arbitrary nesting of commands
--   Automatic help page generation
--   Supports lazy loading of subcommands at runtime
-
-
-Installing
-----------
-
-Install and update using `pip`_:
-
-.. code-block:: text
-
-    $ pip install -U click
-
-.. _pip: https://pip.pypa.io/en/stable/quickstart/
-
-
-A Simple Example
-----------------
-
-.. code-block:: python
-
-    import click
-
-    @click.command()
-    @click.option("--count", default=1, help="Number of greetings.")
-    @click.option("--name", prompt="Your name", help="The person to greet.")
-    def hello(count, name):
-        """Simple program that greets NAME for a total of COUNT times."""
-        for _ in range(count):
-            click.echo(f"Hello, {name}!")
-
-    if __name__ == '__main__':
-        hello()
-
-.. code-block:: text
-
-    $ python hello.py --count=3
-    Your name: Click
-    Hello, Click!
-    Hello, Click!
-    Hello, Click!
-
-
-Donate
-------
-
-The Pallets organization develops and supports Click and other popular
-packages. In order to grow the community of contributors and users, and
-allow the maintainers to devote more time to the projects, `please
-donate today`_.
-
-.. _please donate today: https://palletsprojects.com/donate
-
-
-Links
------
-
--   Website: https://palletsprojects.com/p/click/
--   Documentation: https://click.palletsprojects.com/
--   Releases: https://pypi.org/project/click/
--   Code: https://github.com/pallets/click
--   Issue tracker: https://github.com/pallets/click/issues
--   Test status: https://dev.azure.com/pallets/click/_build
--   Official chat: https://discord.gg/t6rrQZH
-
-
diff --git a/Flaskserver/venv/Lib/site-packages/click-7.1.2.dist-info/RECORD b/Flaskserver/venv/Lib/site-packages/click-7.1.2.dist-info/RECORD
deleted file mode 100644
index ad860aea0d852617883f850aaeae5cbfa63ace0e..0000000000000000000000000000000000000000
--- a/Flaskserver/venv/Lib/site-packages/click-7.1.2.dist-info/RECORD
+++ /dev/null
@@ -1,40 +0,0 @@
-click-7.1.2.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
-click-7.1.2.dist-info/LICENSE.rst,sha256=morRBqOU6FO_4h9C9OctWSgZoigF2ZG18ydQKSkrZY0,1475
-click-7.1.2.dist-info/METADATA,sha256=LrRgakZKV7Yg3qJqX_plu2WhFW81MzP3EqQmZhHIO8M,2868
-click-7.1.2.dist-info/RECORD,,
-click-7.1.2.dist-info/WHEEL,sha256=kGT74LWyRUZrL4VgLh6_g12IeVl_9u9ZVhadrgXZUEY,110
-click-7.1.2.dist-info/top_level.txt,sha256=J1ZQogalYS4pphY_lPECoNMfw0HzTSrZglC4Yfwo4xA,6
-click/__init__.py,sha256=FkyGDQ-cbiQxP_lxgUspyFYS48f2S_pTcfKPz-d_RMo,2463
-click/__pycache__/__init__.cpython-38.pyc,,
-click/__pycache__/_bashcomplete.cpython-38.pyc,,
-click/__pycache__/_compat.cpython-38.pyc,,
-click/__pycache__/_termui_impl.cpython-38.pyc,,
-click/__pycache__/_textwrap.cpython-38.pyc,,
-click/__pycache__/_unicodefun.cpython-38.pyc,,
-click/__pycache__/_winconsole.cpython-38.pyc,,
-click/__pycache__/core.cpython-38.pyc,,
-click/__pycache__/decorators.cpython-38.pyc,,
-click/__pycache__/exceptions.cpython-38.pyc,,
-click/__pycache__/formatting.cpython-38.pyc,,
-click/__pycache__/globals.cpython-38.pyc,,
-click/__pycache__/parser.cpython-38.pyc,,
-click/__pycache__/termui.cpython-38.pyc,,
-click/__pycache__/testing.cpython-38.pyc,,
-click/__pycache__/types.cpython-38.pyc,,
-click/__pycache__/utils.cpython-38.pyc,,
-click/_bashcomplete.py,sha256=9J98IHQYmCAr2Jup6TDshUr5FJEen-AoQCZR0K5nKxQ,12309
-click/_compat.py,sha256=AoMaYnZ-3pwtNXuHtlb6_UXsayoG0QZiHKIRy2VFezc,24169
-click/_termui_impl.py,sha256=yNktUMAdjYOU1HMkq915jR3zgAzUNtGSQqSTSSMn3eQ,20702
-click/_textwrap.py,sha256=ajCzkzFly5tjm9foQ5N9_MOeaYJMBjAltuFa69n4iXY,1197
-click/_unicodefun.py,sha256=apLSNEBZgUsQNPMUv072zJ1swqnm0dYVT5TqcIWTt6w,4201
-click/_winconsole.py,sha256=6YDu6Rq1Wxx4w9uinBMK2LHvP83aerZM9GQurlk3QDo,10010
-click/core.py,sha256=V6DJzastGhrC6WTDwV9MSLwcJUdX2Uf1ypmgkjBdn_Y,77650
-click/decorators.py,sha256=3TvEO_BkaHl7k6Eh1G5eC7JK4LKPdpFqH9JP0QDyTlM,11215
-click/exceptions.py,sha256=3pQAyyMFzx5A3eV0Y27WtDTyGogZRbrC6_o5DjjKBbw,8118
-click/formatting.py,sha256=Wb4gqFEpWaKPgAbOvnkCl8p-bEZx5KpM5ZSByhlnJNk,9281
-click/globals.py,sha256=ht7u2kUGI08pAarB4e4yC8Lkkxy6gJfRZyzxEj8EbWQ,1501
-click/parser.py,sha256=mFK-k58JtPpqO0AC36WAr0t5UfzEw1mvgVSyn7WCe9M,15691
-click/termui.py,sha256=G7QBEKIepRIGLvNdGwBTYiEtSImRxvTO_AglVpyHH2s,23998
-click/testing.py,sha256=EUEsDUqNXFgCLhZ0ZFOROpaVDA5I_rijwnNPE6qICgA,12854
-click/types.py,sha256=wuubik4VqgqAw5dvbYFkDt-zSAx97y9TQXuXcVaRyQA,25045
-click/utils.py,sha256=4VEcJ7iEHwjnFuzEuRtkT99o5VG3zqSD7Q2CVzv13WU,15940
diff --git a/Flaskserver/venv/Lib/site-packages/click-7.1.2.dist-info/WHEEL b/Flaskserver/venv/Lib/site-packages/click-7.1.2.dist-info/WHEEL
deleted file mode 100644
index ef99c6cf3283b50a273ac4c6d009a0aa85597070..0000000000000000000000000000000000000000
--- a/Flaskserver/venv/Lib/site-packages/click-7.1.2.dist-info/WHEEL
+++ /dev/null
@@ -1,6 +0,0 @@
-Wheel-Version: 1.0
-Generator: bdist_wheel (0.34.2)
-Root-Is-Purelib: true
-Tag: py2-none-any
-Tag: py3-none-any
-
diff --git a/Flaskserver/venv/Lib/site-packages/click-7.1.2.dist-info/top_level.txt b/Flaskserver/venv/Lib/site-packages/click-7.1.2.dist-info/top_level.txt
deleted file mode 100644
index dca9a909647e3b066931de2909c2d1e65c78c995..0000000000000000000000000000000000000000
--- a/Flaskserver/venv/Lib/site-packages/click-7.1.2.dist-info/top_level.txt
+++ /dev/null
@@ -1 +0,0 @@
-click
diff --git a/Flaskserver/venv/Lib/site-packages/click/__init__.py b/Flaskserver/venv/Lib/site-packages/click/__init__.py
deleted file mode 100644
index 2b6008f2dd4176d819f06e0d7e92e43b142d30b0..0000000000000000000000000000000000000000
--- a/Flaskserver/venv/Lib/site-packages/click/__init__.py
+++ /dev/null
@@ -1,79 +0,0 @@
-"""
-Click is a simple Python module inspired by the stdlib optparse to make
-writing command line scripts fun. Unlike other modules, it's based
-around a simple API that does not come with too much magic and is
-composable.
-"""
-from .core import Argument
-from .core import BaseCommand
-from .core import Command
-from .core import CommandCollection
-from .core import Context
-from .core import Group
-from .core import MultiCommand
-from .core import Option
-from .core import Parameter
-from .decorators import argument
-from .decorators import command
-from .decorators import confirmation_option
-from .decorators import group
-from .decorators import help_option
-from .decorators import make_pass_decorator
-from .decorators import option
-from .decorators import pass_context
-from .decorators import pass_obj
-from .decorators import password_option
-from .decorators import version_option
-from .exceptions import Abort
-from .exceptions import BadArgumentUsage
-from .exceptions import BadOptionUsage
-from .exceptions import BadParameter
-from .exceptions import ClickException
-from .exceptions import FileError
-from .exceptions import MissingParameter
-from .exceptions import NoSuchOption
-from .exceptions import UsageError
-from .formatting import HelpFormatter
-from .formatting import wrap_text
-from .globals import get_current_context
-from .parser import OptionParser
-from .termui import clear
-from .termui import confirm
-from .termui import echo_via_pager
-from .termui import edit
-from .termui import get_terminal_size
-from .termui import getchar
-from .termui import launch
-from .termui import pause
-from .termui import progressbar
-from .termui import prompt
-from .termui import secho
-from .termui import style
-from .termui import unstyle
-from .types import BOOL
-from .types import Choice
-from .types import DateTime
-from .types import File
-from .types import FLOAT
-from .types import FloatRange
-from .types import INT
-from .types import IntRange
-from .types import ParamType
-from .types import Path
-from .types import STRING
-from .types import Tuple
-from .types import UNPROCESSED
-from .types import UUID
-from .utils import echo
-from .utils import format_filename
-from .utils import get_app_dir
-from .utils import get_binary_stream
-from .utils import get_os_args
-from .utils import get_text_stream
-from .utils import open_file
-
-# Controls if click should emit the warning about the use of unicode
-# literals.
-disable_unicode_literals_warning = False
-
-__version__ = "7.1.2"
diff --git a/Flaskserver/venv/Lib/site-packages/click/__pycache__/__init__.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/click/__pycache__/__init__.cpython-38.pyc
deleted file mode 100644
index 5969832b3f8ef75fc54f9e23a3c8c4fdf1e7c4bb..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/click/__pycache__/__init__.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/click/__pycache__/_bashcomplete.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/click/__pycache__/_bashcomplete.cpython-38.pyc
deleted file mode 100644
index 9ec3f3c0885240f8edf7b52a91a42252f86fd7fd..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/click/__pycache__/_bashcomplete.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/click/__pycache__/_compat.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/click/__pycache__/_compat.cpython-38.pyc
deleted file mode 100644
index efebf6faa4b6b6bd81fff162907ff620699f57d6..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/click/__pycache__/_compat.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/click/__pycache__/_termui_impl.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/click/__pycache__/_termui_impl.cpython-38.pyc
deleted file mode 100644
index 8c0b7a34979bbec5228f1742c18a50dab29c164c..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/click/__pycache__/_termui_impl.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/click/__pycache__/_textwrap.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/click/__pycache__/_textwrap.cpython-38.pyc
deleted file mode 100644
index 570f1fab0a0cb7d26c85c4d74326c295f02047c5..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/click/__pycache__/_textwrap.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/click/__pycache__/_unicodefun.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/click/__pycache__/_unicodefun.cpython-38.pyc
deleted file mode 100644
index d89bb594dab06befce21f73c5bfe3f79e7ba958b..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/click/__pycache__/_unicodefun.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/click/__pycache__/_winconsole.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/click/__pycache__/_winconsole.cpython-38.pyc
deleted file mode 100644
index 625b04dbdb87c78b80fe48c77e16067616fc4a69..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/click/__pycache__/_winconsole.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/click/__pycache__/core.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/click/__pycache__/core.cpython-38.pyc
deleted file mode 100644
index 5ea9da96bf6d271c5f5a0ca775e44fe8a2e13835..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/click/__pycache__/core.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/click/__pycache__/decorators.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/click/__pycache__/decorators.cpython-38.pyc
deleted file mode 100644
index e554d66e3f6229ed134f367fad0ba7be05fcf5f0..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/click/__pycache__/decorators.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/click/__pycache__/exceptions.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/click/__pycache__/exceptions.cpython-38.pyc
deleted file mode 100644
index c399f105af3a91b46e9c2b990ce49034c39e06c1..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/click/__pycache__/exceptions.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/click/__pycache__/formatting.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/click/__pycache__/formatting.cpython-38.pyc
deleted file mode 100644
index 43e8ea4c79887cd3221c35b6685e63b2c8869219..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/click/__pycache__/formatting.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/click/__pycache__/globals.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/click/__pycache__/globals.cpython-38.pyc
deleted file mode 100644
index 63ecc38e10d2b1ab65bd173acc5d566843fe2816..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/click/__pycache__/globals.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/click/__pycache__/parser.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/click/__pycache__/parser.cpython-38.pyc
deleted file mode 100644
index bccf92e6b5cdca908b647298473ed293de37acd0..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/click/__pycache__/parser.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/click/__pycache__/termui.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/click/__pycache__/termui.cpython-38.pyc
deleted file mode 100644
index d82a90972c4ff7fa2b100f5f85b423a3b282c3ac..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/click/__pycache__/termui.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/click/__pycache__/testing.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/click/__pycache__/testing.cpython-38.pyc
deleted file mode 100644
index b72c802f1cb90caddb60b4556e3d945fc2c656d8..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/click/__pycache__/testing.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/click/__pycache__/types.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/click/__pycache__/types.cpython-38.pyc
deleted file mode 100644
index 6ad150c556ae921802497cdfc7e907fa5f10b5ce..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/click/__pycache__/types.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/click/__pycache__/utils.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/click/__pycache__/utils.cpython-38.pyc
deleted file mode 100644
index a558bc7103518358d2332342b286df980c267020..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/click/__pycache__/utils.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/click/_bashcomplete.py b/Flaskserver/venv/Lib/site-packages/click/_bashcomplete.py
deleted file mode 100644
index 8bca24480f751e0471a625bc36c05a61d49add87..0000000000000000000000000000000000000000
--- a/Flaskserver/venv/Lib/site-packages/click/_bashcomplete.py
+++ /dev/null
@@ -1,375 +0,0 @@
-import copy
-import os
-import re
-
-from .core import Argument
-from .core import MultiCommand
-from .core import Option
-from .parser import split_arg_string
-from .types import Choice
-from .utils import echo
-
-try:
-    from collections import abc
-except ImportError:
-    import collections as abc
-
-WORDBREAK = "="
-
-# Note, only BASH version 4.4 and later have the nosort option.
-COMPLETION_SCRIPT_BASH = """
-%(complete_func)s() {
-    local IFS=$'\n'
-    COMPREPLY=( $( env COMP_WORDS="${COMP_WORDS[*]}" \\
-                   COMP_CWORD=$COMP_CWORD \\
-                   %(autocomplete_var)s=complete $1 ) )
-    return 0
-}
-
-%(complete_func)setup() {
-    local COMPLETION_OPTIONS=""
-    local BASH_VERSION_ARR=(${BASH_VERSION//./ })
-    # Only BASH version 4.4 and later have the nosort option.
-    if [ ${BASH_VERSION_ARR[0]} -gt 4 ] || ([ ${BASH_VERSION_ARR[0]} -eq 4 ] \
-&& [ ${BASH_VERSION_ARR[1]} -ge 4 ]); then
-        COMPLETION_OPTIONS="-o nosort"
-    fi
-
-    complete $COMPLETION_OPTIONS -F %(complete_func)s %(script_names)s
-}
-
-%(complete_func)setup
-"""
-
-COMPLETION_SCRIPT_ZSH = """
-#compdef %(script_names)s
-
-%(complete_func)s() {
-    local -a completions
-    local -a completions_with_descriptions
-    local -a response
-    (( ! $+commands[%(script_names)s] )) && return 1
-
-    response=("${(@f)$( env COMP_WORDS=\"${words[*]}\" \\
-                        COMP_CWORD=$((CURRENT-1)) \\
-                        %(autocomplete_var)s=\"complete_zsh\" \\
-                        %(script_names)s )}")
-
-    for key descr in ${(kv)response}; do
-      if [[ "$descr" == "_" ]]; then
-          completions+=("$key")
-      else
-          completions_with_descriptions+=("$key":"$descr")
-      fi
-    done
-
-    if [ -n "$completions_with_descriptions" ]; then
-        _describe -V unsorted completions_with_descriptions -U
-    fi
-
-    if [ -n "$completions" ]; then
-        compadd -U -V unsorted -a completions
-    fi
-    compstate[insert]="automenu"
-}
-
-compdef %(complete_func)s %(script_names)s
-"""
-
-COMPLETION_SCRIPT_FISH = (
-    "complete --no-files --command %(script_names)s --arguments"
-    ' "(env %(autocomplete_var)s=complete_fish'
-    " COMP_WORDS=(commandline -cp) COMP_CWORD=(commandline -t)"
-    ' %(script_names)s)"'
-)
-
-_completion_scripts = {
-    "bash": COMPLETION_SCRIPT_BASH,
-    "zsh": COMPLETION_SCRIPT_ZSH,
-    "fish": COMPLETION_SCRIPT_FISH,
-}
-
-_invalid_ident_char_re = re.compile(r"[^a-zA-Z0-9_]")
-
-
-def get_completion_script(prog_name, complete_var, shell):
-    cf_name = _invalid_ident_char_re.sub("", prog_name.replace("-", "_"))
-    script = _completion_scripts.get(shell, COMPLETION_SCRIPT_BASH)
-    return (
-        script
-        % {
-            "complete_func": "_{}_completion".format(cf_name),
-            "script_names": prog_name,
-            "autocomplete_var": complete_var,
-        }
-    ).strip() + ";"
-
-
-def resolve_ctx(cli, prog_name, args):
-    """Parse into a hierarchy of contexts. Contexts are connected
-    through the parent variable.
-
-    :param cli: command definition
-    :param prog_name: the program that is running
-    :param args: full list of args
-    :return: the final context/command parsed
-    """
-    ctx = cli.make_context(prog_name, args, resilient_parsing=True)
-    args = ctx.protected_args + ctx.args
-    while args:
-        if isinstance(ctx.command, MultiCommand):
-            if not ctx.command.chain:
-                cmd_name, cmd, args = ctx.command.resolve_command(ctx, args)
-                if cmd is None:
-                    return ctx
-                ctx = cmd.make_context(
-                    cmd_name, args, parent=ctx, resilient_parsing=True
-                )
-                args = ctx.protected_args + ctx.args
-            else:
-                # Walk chained subcommand contexts saving the last one.
-                while args:
-                    cmd_name, cmd, args = ctx.command.resolve_command(ctx, args)
-                    if cmd is None:
-                        return ctx
-                    sub_ctx = cmd.make_context(
-                        cmd_name,
-                        args,
-                        parent=ctx,
-                        allow_extra_args=True,
-                        allow_interspersed_args=False,
-                        resilient_parsing=True,
-                    )
-                    args = sub_ctx.args
-                ctx = sub_ctx
-                args = sub_ctx.protected_args + sub_ctx.args
-        else:
-            break
-    return ctx
-
-
-def start_of_option(param_str):
-    """
-    :param param_str: param_str to check
-    :return: whether or not this is the start of an option declaration
-        (i.e. starts "-" or "--")
-    """
-    return param_str and param_str[:1] == "-"
-
-
-def is_incomplete_option(all_args, cmd_param):
-    """
-    :param all_args: the full original list of args supplied
-    :param cmd_param: the current command paramter
-    :return: whether or not the last option declaration (i.e. starts
-        "-" or "--") is incomplete and corresponds to this cmd_param. In
-        other words whether this cmd_param option can still accept
-        values
-    """
-    if not isinstance(cmd_param, Option):
-        return False
-    if cmd_param.is_flag:
-        return False
-    last_option = None
-    for index, arg_str in enumerate(
-        reversed([arg for arg in all_args if arg != WORDBREAK])
-    ):
-        if index + 1 > cmd_param.nargs:
-            break
-        if start_of_option(arg_str):
-            last_option = arg_str
-
-    return True if last_option and last_option in cmd_param.opts else False
-
-
-def is_incomplete_argument(current_params, cmd_param):
-    """
-    :param current_params: the current params and values for this
-        argument as already entered
-    :param cmd_param: the current command parameter
-    :return: whether or not the last argument is incomplete and
-        corresponds to this cmd_param. In other words whether or not the
-        this cmd_param argument can still accept values
-    """
-    if not isinstance(cmd_param, Argument):
-        return False
-    current_param_values = current_params[cmd_param.name]
-    if current_param_values is None:
-        return True
-    if cmd_param.nargs == -1:
-        return True
-    if (
-        isinstance(current_param_values, abc.Iterable)
-        and cmd_param.nargs > 1
-        and len(current_param_values) < cmd_param.nargs
-    ):
-        return True
-    return False
-
-
-def get_user_autocompletions(ctx, args, incomplete, cmd_param):
-    """
-    :param ctx: context associated with the parsed command
-    :param args: full list of args
-    :param incomplete: the incomplete text to autocomplete
-    :param cmd_param: command definition
-    :return: all the possible user-specified completions for the param
-    """
-    results = []
-    if isinstance(cmd_param.type, Choice):
-        # Choices don't support descriptions.
-        results = [
-            (c, None) for c in cmd_param.type.choices if str(c).startswith(incomplete)
-        ]
-    elif cmd_param.autocompletion is not None:
-        dynamic_completions = cmd_param.autocompletion(
-            ctx=ctx, args=args, incomplete=incomplete
-        )
-        results = [
-            c if isinstance(c, tuple) else (c, None) for c in dynamic_completions
-        ]
-    return results
-
-
-def get_visible_commands_starting_with(ctx, starts_with):
-    """
-    :param ctx: context associated with the parsed command
-    :starts_with: string that visible commands must start with.
-    :return: all visible (not hidden) commands that start with starts_with.
-    """
-    for c in ctx.command.list_commands(ctx):
-        if c.startswith(starts_with):
-            command = ctx.command.get_command(ctx, c)
-            if not command.hidden:
-                yield command
-
-
-def add_subcommand_completions(ctx, incomplete, completions_out):
-    # Add subcommand completions.
-    if isinstance(ctx.command, MultiCommand):
-        completions_out.extend(
-            [
-                (c.name, c.get_short_help_str())
-                for c in get_visible_commands_starting_with(ctx, incomplete)
-            ]
-        )
-
-    # Walk up the context list and add any other completion
-    # possibilities from chained commands
-    while ctx.parent is not None:
-        ctx = ctx.parent
-        if isinstance(ctx.command, MultiCommand) and ctx.command.chain:
-            remaining_commands = [
-                c
-                for c in get_visible_commands_starting_with(ctx, incomplete)
-                if c.name not in ctx.protected_args
-            ]
-            completions_out.extend(
-                [(c.name, c.get_short_help_str()) for c in remaining_commands]
-            )
-
-
-def get_choices(cli, prog_name, args, incomplete):
-    """
-    :param cli: command definition
-    :param prog_name: the program that is running
-    :param args: full list of args
-    :param incomplete: the incomplete text to autocomplete
-    :return: all the possible completions for the incomplete
-    """
-    all_args = copy.deepcopy(args)
-
-    ctx = resolve_ctx(cli, prog_name, args)
-    if ctx is None:
-        return []
-
-    has_double_dash = "--" in all_args
-
-    # In newer versions of bash long opts with '='s are partitioned, but
-    # it's easier to parse without the '='
-    if start_of_option(incomplete) and WORDBREAK in incomplete:
-        partition_incomplete = incomplete.partition(WORDBREAK)
-        all_args.append(partition_incomplete[0])
-        incomplete = partition_incomplete[2]
-    elif incomplete == WORDBREAK:
-        incomplete = ""
-
-    completions = []
-    if not has_double_dash and start_of_option(incomplete):
-        # completions for partial options
-        for param in ctx.command.params:
-            if isinstance(param, Option) and not param.hidden:
-                param_opts = [
-                    param_opt
-                    for param_opt in param.opts + param.secondary_opts
-                    if param_opt not in all_args or param.multiple
-                ]
-                completions.extend(
-                    [(o, param.help) for o in param_opts if o.startswith(incomplete)]
-                )
-        return completions
-    # completion for option values from user supplied values
-    for param in ctx.command.params:
-        if is_incomplete_option(all_args, param):
-            return get_user_autocompletions(ctx, all_args, incomplete, param)
-    # completion for argument values from user supplied values
-    for param in ctx.command.params:
-        if is_incomplete_argument(ctx.params, param):
-            return get_user_autocompletions(ctx, all_args, incomplete, param)
-
-    add_subcommand_completions(ctx, incomplete, completions)
-    # Sort before returning so that proper ordering can be enforced in custom types.
-    return sorted(completions)
-
-
-def do_complete(cli, prog_name, include_descriptions):
-    cwords = split_arg_string(os.environ["COMP_WORDS"])
-    cword = int(os.environ["COMP_CWORD"])
-    args = cwords[1:cword]
-    try:
-        incomplete = cwords[cword]
-    except IndexError:
-        incomplete = ""
-
-    for item in get_choices(cli, prog_name, args, incomplete):
-        echo(item[0])
-        if include_descriptions:
-            # ZSH has trouble dealing with empty array parameters when
-            # returned from commands, use '_' to indicate no description
-            # is present.
-            echo(item[1] if item[1] else "_")
-
-    return True
-
-
-def do_complete_fish(cli, prog_name):
-    cwords = split_arg_string(os.environ["COMP_WORDS"])
-    incomplete = os.environ["COMP_CWORD"]
-    args = cwords[1:]
-
-    for item in get_choices(cli, prog_name, args, incomplete):
-        if item[1]:
-            echo("{arg}\t{desc}".format(arg=item[0], desc=item[1]))
-        else:
-            echo(item[0])
-
-    return True
-
-
-def bashcomplete(cli, prog_name, complete_var, complete_instr):
-    if "_" in complete_instr:
-        command, shell = complete_instr.split("_", 1)
-    else:
-        command = complete_instr
-        shell = "bash"
-
-    if command == "source":
-        echo(get_completion_script(prog_name, complete_var, shell))
-        return True
-    elif command == "complete":
-        if shell == "fish":
-            return do_complete_fish(cli, prog_name)
-        elif shell in {"bash", "zsh"}:
-            return do_complete(cli, prog_name, shell == "zsh")
-
-    return False
diff --git a/Flaskserver/venv/Lib/site-packages/click/_compat.py b/Flaskserver/venv/Lib/site-packages/click/_compat.py
deleted file mode 100644
index 60cb115bc5091c408f68d2461115d2e35bd47799..0000000000000000000000000000000000000000
--- a/Flaskserver/venv/Lib/site-packages/click/_compat.py
+++ /dev/null
@@ -1,786 +0,0 @@
-# flake8: noqa
-import codecs
-import io
-import os
-import re
-import sys
-from weakref import WeakKeyDictionary
-
-PY2 = sys.version_info[0] == 2
-CYGWIN = sys.platform.startswith("cygwin")
-MSYS2 = sys.platform.startswith("win") and ("GCC" in sys.version)
-# Determine local App Engine environment, per Google's own suggestion
-APP_ENGINE = "APPENGINE_RUNTIME" in os.environ and "Development/" in os.environ.get(
-    "SERVER_SOFTWARE", ""
-)
-WIN = sys.platform.startswith("win") and not APP_ENGINE and not MSYS2
-DEFAULT_COLUMNS = 80
-
-
-_ansi_re = re.compile(r"\033\[[;?0-9]*[a-zA-Z]")
-
-
-def get_filesystem_encoding():
-    return sys.getfilesystemencoding() or sys.getdefaultencoding()
-
-
-def _make_text_stream(
-    stream, encoding, errors, force_readable=False, force_writable=False
-):
-    if encoding is None:
-        encoding = get_best_encoding(stream)
-    if errors is None:
-        errors = "replace"
-    return _NonClosingTextIOWrapper(
-        stream,
-        encoding,
-        errors,
-        line_buffering=True,
-        force_readable=force_readable,
-        force_writable=force_writable,
-    )
-
-
-def is_ascii_encoding(encoding):
-    """Checks if a given encoding is ascii."""
-    try:
-        return codecs.lookup(encoding).name == "ascii"
-    except LookupError:
-        return False
-
-
-def get_best_encoding(stream):
-    """Returns the default stream encoding if not found."""
-    rv = getattr(stream, "encoding", None) or sys.getdefaultencoding()
-    if is_ascii_encoding(rv):
-        return "utf-8"
-    return rv
-
-
-class _NonClosingTextIOWrapper(io.TextIOWrapper):
-    def __init__(
-        self,
-        stream,
-        encoding,
-        errors,
-        force_readable=False,
-        force_writable=False,
-        **extra
-    ):
-        self._stream = stream = _FixupStream(stream, force_readable, force_writable)
-        io.TextIOWrapper.__init__(self, stream, encoding, errors, **extra)
-
-    # The io module is a place where the Python 3 text behavior
-    # was forced upon Python 2, so we need to unbreak
-    # it to look like Python 2.
-    if PY2:
-
-        def write(self, x):
-            if isinstance(x, str) or is_bytes(x):
-                try:
-                    self.flush()
-                except Exception:
-                    pass
-                return self.buffer.write(str(x))
-            return io.TextIOWrapper.write(self, x)
-
-        def writelines(self, lines):
-            for line in lines:
-                self.write(line)
-
-    def __del__(self):
-        try:
-            self.detach()
-        except Exception:
-            pass
-
-    def isatty(self):
-        # https://bitbucket.org/pypy/pypy/issue/1803
-        return self._stream.isatty()
-
-
-class _FixupStream(object):
-    """The new io interface needs more from streams than streams
-    traditionally implement.  As such, this fix-up code is necessary in
-    some circumstances.
-
-    The forcing of readable and writable flags are there because some tools
-    put badly patched objects on sys (one such offender are certain version
-    of jupyter notebook).
-    """
-
-    def __init__(self, stream, force_readable=False, force_writable=False):
-        self._stream = stream
-        self._force_readable = force_readable
-        self._force_writable = force_writable
-
-    def __getattr__(self, name):
-        return getattr(self._stream, name)
-
-    def read1(self, size):
-        f = getattr(self._stream, "read1", None)
-        if f is not None:
-            return f(size)
-        # We only dispatch to readline instead of read in Python 2 as we
-        # do not want cause problems with the different implementation
-        # of line buffering.
-        if PY2:
-            return self._stream.readline(size)
-        return self._stream.read(size)
-
-    def readable(self):
-        if self._force_readable:
-            return True
-        x = getattr(self._stream, "readable", None)
-        if x is not None:
-            return x()
-        try:
-            self._stream.read(0)
-        except Exception:
-            return False
-        return True
-
-    def writable(self):
-        if self._force_writable:
-            return True
-        x = getattr(self._stream, "writable", None)
-        if x is not None:
-            return x()
-        try:
-            self._stream.write("")
-        except Exception:
-            try:
-                self._stream.write(b"")
-            except Exception:
-                return False
-        return True
-
-    def seekable(self):
-        x = getattr(self._stream, "seekable", None)
-        if x is not None:
-            return x()
-        try:
-            self._stream.seek(self._stream.tell())
-        except Exception:
-            return False
-        return True
-
-
-if PY2:
-    text_type = unicode
-    raw_input = raw_input
-    string_types = (str, unicode)
-    int_types = (int, long)
-    iteritems = lambda x: x.iteritems()
-    range_type = xrange
-
-    def is_bytes(x):
-        return isinstance(x, (buffer, bytearray))
-
-    _identifier_re = re.compile(r"^[a-zA-Z_][a-zA-Z0-9_]*$")
-
-    # For Windows, we need to force stdout/stdin/stderr to binary if it's
-    # fetched for that.  This obviously is not the most correct way to do
-    # it as it changes global state.  Unfortunately, there does not seem to
-    # be a clear better way to do it as just reopening the file in binary
-    # mode does not change anything.
-    #
-    # An option would be to do what Python 3 does and to open the file as
-    # binary only, patch it back to the system, and then use a wrapper
-    # stream that converts newlines.  It's not quite clear what's the
-    # correct option here.
-    #
-    # This code also lives in _winconsole for the fallback to the console
-    # emulation stream.
-    #
-    # There are also Windows environments where the `msvcrt` module is not
-    # available (which is why we use try-catch instead of the WIN variable
-    # here), such as the Google App Engine development server on Windows. In
-    # those cases there is just nothing we can do.
-    def set_binary_mode(f):
-        return f
-
-    try:
-        import msvcrt
-    except ImportError:
-        pass
-    else:
-
-        def set_binary_mode(f):
-            try:
-                fileno = f.fileno()
-            except Exception:
-                pass
-            else:
-                msvcrt.setmode(fileno, os.O_BINARY)
-            return f
-
-    try:
-        import fcntl
-    except ImportError:
-        pass
-    else:
-
-        def set_binary_mode(f):
-            try:
-                fileno = f.fileno()
-            except Exception:
-                pass
-            else:
-                flags = fcntl.fcntl(fileno, fcntl.F_GETFL)
-                fcntl.fcntl(fileno, fcntl.F_SETFL, flags & ~os.O_NONBLOCK)
-            return f
-
-    def isidentifier(x):
-        return _identifier_re.search(x) is not None
-
-    def get_binary_stdin():
-        return set_binary_mode(sys.stdin)
-
-    def get_binary_stdout():
-        _wrap_std_stream("stdout")
-        return set_binary_mode(sys.stdout)
-
-    def get_binary_stderr():
-        _wrap_std_stream("stderr")
-        return set_binary_mode(sys.stderr)
-
-    def get_text_stdin(encoding=None, errors=None):
-        rv = _get_windows_console_stream(sys.stdin, encoding, errors)
-        if rv is not None:
-            return rv
-        return _make_text_stream(sys.stdin, encoding, errors, force_readable=True)
-
-    def get_text_stdout(encoding=None, errors=None):
-        _wrap_std_stream("stdout")
-        rv = _get_windows_console_stream(sys.stdout, encoding, errors)
-        if rv is not None:
-            return rv
-        return _make_text_stream(sys.stdout, encoding, errors, force_writable=True)
-
-    def get_text_stderr(encoding=None, errors=None):
-        _wrap_std_stream("stderr")
-        rv = _get_windows_console_stream(sys.stderr, encoding, errors)
-        if rv is not None:
-            return rv
-        return _make_text_stream(sys.stderr, encoding, errors, force_writable=True)
-
-    def filename_to_ui(value):
-        if isinstance(value, bytes):
-            value = value.decode(get_filesystem_encoding(), "replace")
-        return value
-
-
-else:
-    import io
-
-    text_type = str
-    raw_input = input
-    string_types = (str,)
-    int_types = (int,)
-    range_type = range
-    isidentifier = lambda x: x.isidentifier()
-    iteritems = lambda x: iter(x.items())
-
-    def is_bytes(x):
-        return isinstance(x, (bytes, memoryview, bytearray))
-
-    def _is_binary_reader(stream, default=False):
-        try:
-            return isinstance(stream.read(0), bytes)
-        except Exception:
-            return default
-            # This happens in some cases where the stream was already
-            # closed.  In this case, we assume the default.
-
-    def _is_binary_writer(stream, default=False):
-        try:
-            stream.write(b"")
-        except Exception:
-            try:
-                stream.write("")
-                return False
-            except Exception:
-                pass
-            return default
-        return True
-
-    def _find_binary_reader(stream):
-        # We need to figure out if the given stream is already binary.
-        # This can happen because the official docs recommend detaching
-        # the streams to get binary streams.  Some code might do this, so
-        # we need to deal with this case explicitly.
-        if _is_binary_reader(stream, False):
-            return stream
-
-        buf = getattr(stream, "buffer", None)
-
-        # Same situation here; this time we assume that the buffer is
-        # actually binary in case it's closed.
-        if buf is not None and _is_binary_reader(buf, True):
-            return buf
-
-    def _find_binary_writer(stream):
-        # We need to figure out if the given stream is already binary.
-        # This can happen because the official docs recommend detatching
-        # the streams to get binary streams.  Some code might do this, so
-        # we need to deal with this case explicitly.
-        if _is_binary_writer(stream, False):
-            return stream
-
-        buf = getattr(stream, "buffer", None)
-
-        # Same situation here; this time we assume that the buffer is
-        # actually binary in case it's closed.
-        if buf is not None and _is_binary_writer(buf, True):
-            return buf
-
-    def _stream_is_misconfigured(stream):
-        """A stream is misconfigured if its encoding is ASCII."""
-        # If the stream does not have an encoding set, we assume it's set
-        # to ASCII.  This appears to happen in certain unittest
-        # environments.  It's not quite clear what the correct behavior is
-        # but this at least will force Click to recover somehow.
-        return is_ascii_encoding(getattr(stream, "encoding", None) or "ascii")
-
-    def _is_compat_stream_attr(stream, attr, value):
-        """A stream attribute is compatible if it is equal to the
-        desired value or the desired value is unset and the attribute
-        has a value.
-        """
-        stream_value = getattr(stream, attr, None)
-        return stream_value == value or (value is None and stream_value is not None)
-
-    def _is_compatible_text_stream(stream, encoding, errors):
-        """Check if a stream's encoding and errors attributes are
-        compatible with the desired values.
-        """
-        return _is_compat_stream_attr(
-            stream, "encoding", encoding
-        ) and _is_compat_stream_attr(stream, "errors", errors)
-
-    def _force_correct_text_stream(
-        text_stream,
-        encoding,
-        errors,
-        is_binary,
-        find_binary,
-        force_readable=False,
-        force_writable=False,
-    ):
-        if is_binary(text_stream, False):
-            binary_reader = text_stream
-        else:
-            # If the stream looks compatible, and won't default to a
-            # misconfigured ascii encoding, return it as-is.
-            if _is_compatible_text_stream(text_stream, encoding, errors) and not (
-                encoding is None and _stream_is_misconfigured(text_stream)
-            ):
-                return text_stream
-
-            # Otherwise, get the underlying binary reader.
-            binary_reader = find_binary(text_stream)
-
-            # If that's not possible, silently use the original reader
-            # and get mojibake instead of exceptions.
-            if binary_reader is None:
-                return text_stream
-
-        # Default errors to replace instead of strict in order to get
-        # something that works.
-        if errors is None:
-            errors = "replace"
-
-        # Wrap the binary stream in a text stream with the correct
-        # encoding parameters.
-        return _make_text_stream(
-            binary_reader,
-            encoding,
-            errors,
-            force_readable=force_readable,
-            force_writable=force_writable,
-        )
-
-    def _force_correct_text_reader(text_reader, encoding, errors, force_readable=False):
-        return _force_correct_text_stream(
-            text_reader,
-            encoding,
-            errors,
-            _is_binary_reader,
-            _find_binary_reader,
-            force_readable=force_readable,
-        )
-
-    def _force_correct_text_writer(text_writer, encoding, errors, force_writable=False):
-        return _force_correct_text_stream(
-            text_writer,
-            encoding,
-            errors,
-            _is_binary_writer,
-            _find_binary_writer,
-            force_writable=force_writable,
-        )
-
-    def get_binary_stdin():
-        reader = _find_binary_reader(sys.stdin)
-        if reader is None:
-            raise RuntimeError("Was not able to determine binary stream for sys.stdin.")
-        return reader
-
-    def get_binary_stdout():
-        writer = _find_binary_writer(sys.stdout)
-        if writer is None:
-            raise RuntimeError(
-                "Was not able to determine binary stream for sys.stdout."
-            )
-        return writer
-
-    def get_binary_stderr():
-        writer = _find_binary_writer(sys.stderr)
-        if writer is None:
-            raise RuntimeError(
-                "Was not able to determine binary stream for sys.stderr."
-            )
-        return writer
-
-    def get_text_stdin(encoding=None, errors=None):
-        rv = _get_windows_console_stream(sys.stdin, encoding, errors)
-        if rv is not None:
-            return rv
-        return _force_correct_text_reader(
-            sys.stdin, encoding, errors, force_readable=True
-        )
-
-    def get_text_stdout(encoding=None, errors=None):
-        rv = _get_windows_console_stream(sys.stdout, encoding, errors)
-        if rv is not None:
-            return rv
-        return _force_correct_text_writer(
-            sys.stdout, encoding, errors, force_writable=True
-        )
-
-    def get_text_stderr(encoding=None, errors=None):
-        rv = _get_windows_console_stream(sys.stderr, encoding, errors)
-        if rv is not None:
-            return rv
-        return _force_correct_text_writer(
-            sys.stderr, encoding, errors, force_writable=True
-        )
-
-    def filename_to_ui(value):
-        if isinstance(value, bytes):
-            value = value.decode(get_filesystem_encoding(), "replace")
-        else:
-            value = value.encode("utf-8", "surrogateescape").decode("utf-8", "replace")
-        return value
-
-
-def get_streerror(e, default=None):
-    if hasattr(e, "strerror"):
-        msg = e.strerror
-    else:
-        if default is not None:
-            msg = default
-        else:
-            msg = str(e)
-    if isinstance(msg, bytes):
-        msg = msg.decode("utf-8", "replace")
-    return msg
-
-
-def _wrap_io_open(file, mode, encoding, errors):
-    """On Python 2, :func:`io.open` returns a text file wrapper that
-    requires passing ``unicode`` to ``write``. Need to open the file in
-    binary mode then wrap it in a subclass that can write ``str`` and
-    ``unicode``.
-
-    Also handles not passing ``encoding`` and ``errors`` in binary mode.
-    """
-    binary = "b" in mode
-
-    if binary:
-        kwargs = {}
-    else:
-        kwargs = {"encoding": encoding, "errors": errors}
-
-    if not PY2 or binary:
-        return io.open(file, mode, **kwargs)
-
-    f = io.open(file, "{}b".format(mode.replace("t", "")))
-    return _make_text_stream(f, **kwargs)
-
-
-def open_stream(filename, mode="r", encoding=None, errors="strict", atomic=False):
-    binary = "b" in mode
-
-    # Standard streams first.  These are simple because they don't need
-    # special handling for the atomic flag.  It's entirely ignored.
-    if filename == "-":
-        if any(m in mode for m in ["w", "a", "x"]):
-            if binary:
-                return get_binary_stdout(), False
-            return get_text_stdout(encoding=encoding, errors=errors), False
-        if binary:
-            return get_binary_stdin(), False
-        return get_text_stdin(encoding=encoding, errors=errors), False
-
-    # Non-atomic writes directly go out through the regular open functions.
-    if not atomic:
-        return _wrap_io_open(filename, mode, encoding, errors), True
-
-    # Some usability stuff for atomic writes
-    if "a" in mode:
-        raise ValueError(
-            "Appending to an existing file is not supported, because that"
-            " would involve an expensive `copy`-operation to a temporary"
-            " file. Open the file in normal `w`-mode and copy explicitly"
-            " if that's what you're after."
-        )
-    if "x" in mode:
-        raise ValueError("Use the `overwrite`-parameter instead.")
-    if "w" not in mode:
-        raise ValueError("Atomic writes only make sense with `w`-mode.")
-
-    # Atomic writes are more complicated.  They work by opening a file
-    # as a proxy in the same folder and then using the fdopen
-    # functionality to wrap it in a Python file.  Then we wrap it in an
-    # atomic file that moves the file over on close.
-    import errno
-    import random
-
-    try:
-        perm = os.stat(filename).st_mode
-    except OSError:
-        perm = None
-
-    flags = os.O_RDWR | os.O_CREAT | os.O_EXCL
-
-    if binary:
-        flags |= getattr(os, "O_BINARY", 0)
-
-    while True:
-        tmp_filename = os.path.join(
-            os.path.dirname(filename),
-            ".__atomic-write{:08x}".format(random.randrange(1 << 32)),
-        )
-        try:
-            fd = os.open(tmp_filename, flags, 0o666 if perm is None else perm)
-            break
-        except OSError as e:
-            if e.errno == errno.EEXIST or (
-                os.name == "nt"
-                and e.errno == errno.EACCES
-                and os.path.isdir(e.filename)
-                and os.access(e.filename, os.W_OK)
-            ):
-                continue
-            raise
-
-    if perm is not None:
-        os.chmod(tmp_filename, perm)  # in case perm includes bits in umask
-
-    f = _wrap_io_open(fd, mode, encoding, errors)
-    return _AtomicFile(f, tmp_filename, os.path.realpath(filename)), True
-
-
-# Used in a destructor call, needs extra protection from interpreter cleanup.
-if hasattr(os, "replace"):
-    _replace = os.replace
-    _can_replace = True
-else:
-    _replace = os.rename
-    _can_replace = not WIN
-
-
-class _AtomicFile(object):
-    def __init__(self, f, tmp_filename, real_filename):
-        self._f = f
-        self._tmp_filename = tmp_filename
-        self._real_filename = real_filename
-        self.closed = False
-
-    @property
-    def name(self):
-        return self._real_filename
-
-    def close(self, delete=False):
-        if self.closed:
-            return
-        self._f.close()
-        if not _can_replace:
-            try:
-                os.remove(self._real_filename)
-            except OSError:
-                pass
-        _replace(self._tmp_filename, self._real_filename)
-        self.closed = True
-
-    def __getattr__(self, name):
-        return getattr(self._f, name)
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, exc_type, exc_value, tb):
-        self.close(delete=exc_type is not None)
-
-    def __repr__(self):
-        return repr(self._f)
-
-
-auto_wrap_for_ansi = None
-colorama = None
-get_winterm_size = None
-
-
-def strip_ansi(value):
-    return _ansi_re.sub("", value)
-
-
-def _is_jupyter_kernel_output(stream):
-    if WIN:
-        # TODO: Couldn't test on Windows, should't try to support until
-        # someone tests the details wrt colorama.
-        return
-
-    while isinstance(stream, (_FixupStream, _NonClosingTextIOWrapper)):
-        stream = stream._stream
-
-    return stream.__class__.__module__.startswith("ipykernel.")
-
-
-def should_strip_ansi(stream=None, color=None):
-    if color is None:
-        if stream is None:
-            stream = sys.stdin
-        return not isatty(stream) and not _is_jupyter_kernel_output(stream)
-    return not color
-
-
-# If we're on Windows, we provide transparent integration through
-# colorama.  This will make ANSI colors through the echo function
-# work automatically.
-if WIN:
-    # Windows has a smaller terminal
-    DEFAULT_COLUMNS = 79
-
-    from ._winconsole import _get_windows_console_stream, _wrap_std_stream
-
-    def _get_argv_encoding():
-        import locale
-
-        return locale.getpreferredencoding()
-
-    if PY2:
-
-        def raw_input(prompt=""):
-            sys.stderr.flush()
-            if prompt:
-                stdout = _default_text_stdout()
-                stdout.write(prompt)
-            stdin = _default_text_stdin()
-            return stdin.readline().rstrip("\r\n")
-
-    try:
-        import colorama
-    except ImportError:
-        pass
-    else:
-        _ansi_stream_wrappers = WeakKeyDictionary()
-
-        def auto_wrap_for_ansi(stream, color=None):
-            """This function wraps a stream so that calls through colorama
-            are issued to the win32 console API to recolor on demand.  It
-            also ensures to reset the colors if a write call is interrupted
-            to not destroy the console afterwards.
-            """
-            try:
-                cached = _ansi_stream_wrappers.get(stream)
-            except Exception:
-                cached = None
-            if cached is not None:
-                return cached
-            strip = should_strip_ansi(stream, color)
-            ansi_wrapper = colorama.AnsiToWin32(stream, strip=strip)
-            rv = ansi_wrapper.stream
-            _write = rv.write
-
-            def _safe_write(s):
-                try:
-                    return _write(s)
-                except:
-                    ansi_wrapper.reset_all()
-                    raise
-
-            rv.write = _safe_write
-            try:
-                _ansi_stream_wrappers[stream] = rv
-            except Exception:
-                pass
-            return rv
-
-        def get_winterm_size():
-            win = colorama.win32.GetConsoleScreenBufferInfo(
-                colorama.win32.STDOUT
-            ).srWindow
-            return win.Right - win.Left, win.Bottom - win.Top
-
-
-else:
-
-    def _get_argv_encoding():
-        return getattr(sys.stdin, "encoding", None) or get_filesystem_encoding()
-
-    _get_windows_console_stream = lambda *x: None
-    _wrap_std_stream = lambda *x: None
-
-
-def term_len(x):
-    return len(strip_ansi(x))
-
-
-def isatty(stream):
-    try:
-        return stream.isatty()
-    except Exception:
-        return False
-
-
-def _make_cached_stream_func(src_func, wrapper_func):
-    cache = WeakKeyDictionary()
-
-    def func():
-        stream = src_func()
-        try:
-            rv = cache.get(stream)
-        except Exception:
-            rv = None
-        if rv is not None:
-            return rv
-        rv = wrapper_func()
-        try:
-            stream = src_func()  # In case wrapper_func() modified the stream
-            cache[stream] = rv
-        except Exception:
-            pass
-        return rv
-
-    return func
-
-
-_default_text_stdin = _make_cached_stream_func(lambda: sys.stdin, get_text_stdin)
-_default_text_stdout = _make_cached_stream_func(lambda: sys.stdout, get_text_stdout)
-_default_text_stderr = _make_cached_stream_func(lambda: sys.stderr, get_text_stderr)
-
-
-binary_streams = {
-    "stdin": get_binary_stdin,
-    "stdout": get_binary_stdout,
-    "stderr": get_binary_stderr,
-}
-
-text_streams = {
-    "stdin": get_text_stdin,
-    "stdout": get_text_stdout,
-    "stderr": get_text_stderr,
-}
diff --git a/Flaskserver/venv/Lib/site-packages/click/_termui_impl.py b/Flaskserver/venv/Lib/site-packages/click/_termui_impl.py
deleted file mode 100644
index 88bec37701cf549a7b39c7667a6520930c141a73..0000000000000000000000000000000000000000
--- a/Flaskserver/venv/Lib/site-packages/click/_termui_impl.py
+++ /dev/null
@@ -1,657 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-This module contains implementations for the termui module. To keep the
-import time of Click down, some infrequently used functionality is
-placed in this module and only imported as needed.
-"""
-import contextlib
-import math
-import os
-import sys
-import time
-
-from ._compat import _default_text_stdout
-from ._compat import CYGWIN
-from ._compat import get_best_encoding
-from ._compat import int_types
-from ._compat import isatty
-from ._compat import open_stream
-from ._compat import range_type
-from ._compat import strip_ansi
-from ._compat import term_len
-from ._compat import WIN
-from .exceptions import ClickException
-from .utils import echo
-
-if os.name == "nt":
-    BEFORE_BAR = "\r"
-    AFTER_BAR = "\n"
-else:
-    BEFORE_BAR = "\r\033[?25l"
-    AFTER_BAR = "\033[?25h\n"
-
-
-def _length_hint(obj):
-    """Returns the length hint of an object."""
-    try:
-        return len(obj)
-    except (AttributeError, TypeError):
-        try:
-            get_hint = type(obj).__length_hint__
-        except AttributeError:
-            return None
-        try:
-            hint = get_hint(obj)
-        except TypeError:
-            return None
-        if hint is NotImplemented or not isinstance(hint, int_types) or hint < 0:
-            return None
-        return hint
-
-
-class ProgressBar(object):
-    def __init__(
-        self,
-        iterable,
-        length=None,
-        fill_char="#",
-        empty_char=" ",
-        bar_template="%(bar)s",
-        info_sep="  ",
-        show_eta=True,
-        show_percent=None,
-        show_pos=False,
-        item_show_func=None,
-        label=None,
-        file=None,
-        color=None,
-        width=30,
-    ):
-        self.fill_char = fill_char
-        self.empty_char = empty_char
-        self.bar_template = bar_template
-        self.info_sep = info_sep
-        self.show_eta = show_eta
-        self.show_percent = show_percent
-        self.show_pos = show_pos
-        self.item_show_func = item_show_func
-        self.label = label or ""
-        if file is None:
-            file = _default_text_stdout()
-        self.file = file
-        self.color = color
-        self.width = width
-        self.autowidth = width == 0
-
-        if length is None:
-            length = _length_hint(iterable)
-        if iterable is None:
-            if length is None:
-                raise TypeError("iterable or length is required")
-            iterable = range_type(length)
-        self.iter = iter(iterable)
-        self.length = length
-        self.length_known = length is not None
-        self.pos = 0
-        self.avg = []
-        self.start = self.last_eta = time.time()
-        self.eta_known = False
-        self.finished = False
-        self.max_width = None
-        self.entered = False
-        self.current_item = None
-        self.is_hidden = not isatty(self.file)
-        self._last_line = None
-        self.short_limit = 0.5
-
-    def __enter__(self):
-        self.entered = True
-        self.render_progress()
-        return self
-
-    def __exit__(self, exc_type, exc_value, tb):
-        self.render_finish()
-
-    def __iter__(self):
-        if not self.entered:
-            raise RuntimeError("You need to use progress bars in a with block.")
-        self.render_progress()
-        return self.generator()
-
-    def __next__(self):
-        # Iteration is defined in terms of a generator function,
-        # returned by iter(self); use that to define next(). This works
-        # because `self.iter` is an iterable consumed by that generator,
-        # so it is re-entry safe. Calling `next(self.generator())`
-        # twice works and does "what you want".
-        return next(iter(self))
-
-    # Python 2 compat
-    next = __next__
-
-    def is_fast(self):
-        return time.time() - self.start <= self.short_limit
-
-    def render_finish(self):
-        if self.is_hidden or self.is_fast():
-            return
-        self.file.write(AFTER_BAR)
-        self.file.flush()
-
-    @property
-    def pct(self):
-        if self.finished:
-            return 1.0
-        return min(self.pos / (float(self.length) or 1), 1.0)
-
-    @property
-    def time_per_iteration(self):
-        if not self.avg:
-            return 0.0
-        return sum(self.avg) / float(len(self.avg))
-
-    @property
-    def eta(self):
-        if self.length_known and not self.finished:
-            return self.time_per_iteration * (self.length - self.pos)
-        return 0.0
-
-    def format_eta(self):
-        if self.eta_known:
-            t = int(self.eta)
-            seconds = t % 60
-            t //= 60
-            minutes = t % 60
-            t //= 60
-            hours = t % 24
-            t //= 24
-            if t > 0:
-                return "{}d {:02}:{:02}:{:02}".format(t, hours, minutes, seconds)
-            else:
-                return "{:02}:{:02}:{:02}".format(hours, minutes, seconds)
-        return ""
-
-    def format_pos(self):
-        pos = str(self.pos)
-        if self.length_known:
-            pos += "/{}".format(self.length)
-        return pos
-
-    def format_pct(self):
-        return "{: 4}%".format(int(self.pct * 100))[1:]
-
-    def format_bar(self):
-        if self.length_known:
-            bar_length = int(self.pct * self.width)
-            bar = self.fill_char * bar_length
-            bar += self.empty_char * (self.width - bar_length)
-        elif self.finished:
-            bar = self.fill_char * self.width
-        else:
-            bar = list(self.empty_char * (self.width or 1))
-            if self.time_per_iteration != 0:
-                bar[
-                    int(
-                        (math.cos(self.pos * self.time_per_iteration) / 2.0 + 0.5)
-                        * self.width
-                    )
-                ] = self.fill_char
-            bar = "".join(bar)
-        return bar
-
-    def format_progress_line(self):
-        show_percent = self.show_percent
-
-        info_bits = []
-        if self.length_known and show_percent is None:
-            show_percent = not self.show_pos
-
-        if self.show_pos:
-            info_bits.append(self.format_pos())
-        if show_percent:
-            info_bits.append(self.format_pct())
-        if self.show_eta and self.eta_known and not self.finished:
-            info_bits.append(self.format_eta())
-        if self.item_show_func is not None:
-            item_info = self.item_show_func(self.current_item)
-            if item_info is not None:
-                info_bits.append(item_info)
-
-        return (
-            self.bar_template
-            % {
-                "label": self.label,
-                "bar": self.format_bar(),
-                "info": self.info_sep.join(info_bits),
-            }
-        ).rstrip()
-
-    def render_progress(self):
-        from .termui import get_terminal_size
-
-        if self.is_hidden:
-            return
-
-        buf = []
-        # Update width in case the terminal has been resized
-        if self.autowidth:
-            old_width = self.width
-            self.width = 0
-            clutter_length = term_len(self.format_progress_line())
-            new_width = max(0, get_terminal_size()[0] - clutter_length)
-            if new_width < old_width:
-                buf.append(BEFORE_BAR)
-                buf.append(" " * self.max_width)
-                self.max_width = new_width
-            self.width = new_width
-
-        clear_width = self.width
-        if self.max_width is not None:
-            clear_width = self.max_width
-
-        buf.append(BEFORE_BAR)
-        line = self.format_progress_line()
-        line_len = term_len(line)
-        if self.max_width is None or self.max_width < line_len:
-            self.max_width = line_len
-
-        buf.append(line)
-        buf.append(" " * (clear_width - line_len))
-        line = "".join(buf)
-        # Render the line only if it changed.
-
-        if line != self._last_line and not self.is_fast():
-            self._last_line = line
-            echo(line, file=self.file, color=self.color, nl=False)
-            self.file.flush()
-
-    def make_step(self, n_steps):
-        self.pos += n_steps
-        if self.length_known and self.pos >= self.length:
-            self.finished = True
-
-        if (time.time() - self.last_eta) < 1.0:
-            return
-
-        self.last_eta = time.time()
-
-        # self.avg is a rolling list of length <= 7 of steps where steps are
-        # defined as time elapsed divided by the total progress through
-        # self.length.
-        if self.pos:
-            step = (time.time() - self.start) / self.pos
-        else:
-            step = time.time() - self.start
-
-        self.avg = self.avg[-6:] + [step]
-
-        self.eta_known = self.length_known
-
-    def update(self, n_steps):
-        self.make_step(n_steps)
-        self.render_progress()
-
-    def finish(self):
-        self.eta_known = 0
-        self.current_item = None
-        self.finished = True
-
-    def generator(self):
-        """Return a generator which yields the items added to the bar
-        during construction, and updates the progress bar *after* the
-        yielded block returns.
-        """
-        # WARNING: the iterator interface for `ProgressBar` relies on
-        # this and only works because this is a simple generator which
-        # doesn't create or manage additional state. If this function
-        # changes, the impact should be evaluated both against
-        # `iter(bar)` and `next(bar)`. `next()` in particular may call
-        # `self.generator()` repeatedly, and this must remain safe in
-        # order for that interface to work.
-        if not self.entered:
-            raise RuntimeError("You need to use progress bars in a with block.")
-
-        if self.is_hidden:
-            for rv in self.iter:
-                yield rv
-        else:
-            for rv in self.iter:
-                self.current_item = rv
-                yield rv
-                self.update(1)
-            self.finish()
-            self.render_progress()
-
-
-def pager(generator, color=None):
-    """Decide what method to use for paging through text."""
-    stdout = _default_text_stdout()
-    if not isatty(sys.stdin) or not isatty(stdout):
-        return _nullpager(stdout, generator, color)
-    pager_cmd = (os.environ.get("PAGER", None) or "").strip()
-    if pager_cmd:
-        if WIN:
-            return _tempfilepager(generator, pager_cmd, color)
-        return _pipepager(generator, pager_cmd, color)
-    if os.environ.get("TERM") in ("dumb", "emacs"):
-        return _nullpager(stdout, generator, color)
-    if WIN or sys.platform.startswith("os2"):
-        return _tempfilepager(generator, "more <", color)
-    if hasattr(os, "system") and os.system("(less) 2>/dev/null") == 0:
-        return _pipepager(generator, "less", color)
-
-    import tempfile
-
-    fd, filename = tempfile.mkstemp()
-    os.close(fd)
-    try:
-        if hasattr(os, "system") and os.system('more "{}"'.format(filename)) == 0:
-            return _pipepager(generator, "more", color)
-        return _nullpager(stdout, generator, color)
-    finally:
-        os.unlink(filename)
-
-
-def _pipepager(generator, cmd, color):
-    """Page through text by feeding it to another program.  Invoking a
-    pager through this might support colors.
-    """
-    import subprocess
-
-    env = dict(os.environ)
-
-    # If we're piping to less we might support colors under the
-    # condition that
-    cmd_detail = cmd.rsplit("/", 1)[-1].split()
-    if color is None and cmd_detail[0] == "less":
-        less_flags = "{}{}".format(os.environ.get("LESS", ""), " ".join(cmd_detail[1:]))
-        if not less_flags:
-            env["LESS"] = "-R"
-            color = True
-        elif "r" in less_flags or "R" in less_flags:
-            color = True
-
-    c = subprocess.Popen(cmd, shell=True, stdin=subprocess.PIPE, env=env)
-    encoding = get_best_encoding(c.stdin)
-    try:
-        for text in generator:
-            if not color:
-                text = strip_ansi(text)
-
-            c.stdin.write(text.encode(encoding, "replace"))
-    except (IOError, KeyboardInterrupt):
-        pass
-    else:
-        c.stdin.close()
-
-    # Less doesn't respect ^C, but catches it for its own UI purposes (aborting
-    # search or other commands inside less).
-    #
-    # That means when the user hits ^C, the parent process (click) terminates,
-    # but less is still alive, paging the output and messing up the terminal.
-    #
-    # If the user wants to make the pager exit on ^C, they should set
-    # `LESS='-K'`. It's not our decision to make.
-    while True:
-        try:
-            c.wait()
-        except KeyboardInterrupt:
-            pass
-        else:
-            break
-
-
-def _tempfilepager(generator, cmd, color):
-    """Page through text by invoking a program on a temporary file."""
-    import tempfile
-
-    filename = tempfile.mktemp()
-    # TODO: This never terminates if the passed generator never terminates.
-    text = "".join(generator)
-    if not color:
-        text = strip_ansi(text)
-    encoding = get_best_encoding(sys.stdout)
-    with open_stream(filename, "wb")[0] as f:
-        f.write(text.encode(encoding))
-    try:
-        os.system('{} "{}"'.format(cmd, filename))
-    finally:
-        os.unlink(filename)
-
-
-def _nullpager(stream, generator, color):
-    """Simply print unformatted text.  This is the ultimate fallback."""
-    for text in generator:
-        if not color:
-            text = strip_ansi(text)
-        stream.write(text)
-
-
-class Editor(object):
-    def __init__(self, editor=None, env=None, require_save=True, extension=".txt"):
-        self.editor = editor
-        self.env = env
-        self.require_save = require_save
-        self.extension = extension
-
-    def get_editor(self):
-        if self.editor is not None:
-            return self.editor
-        for key in "VISUAL", "EDITOR":
-            rv = os.environ.get(key)
-            if rv:
-                return rv
-        if WIN:
-            return "notepad"
-        for editor in "sensible-editor", "vim", "nano":
-            if os.system("which {} >/dev/null 2>&1".format(editor)) == 0:
-                return editor
-        return "vi"
-
-    def edit_file(self, filename):
-        import subprocess
-
-        editor = self.get_editor()
-        if self.env:
-            environ = os.environ.copy()
-            environ.update(self.env)
-        else:
-            environ = None
-        try:
-            c = subprocess.Popen(
-                '{} "{}"'.format(editor, filename), env=environ, shell=True,
-            )
-            exit_code = c.wait()
-            if exit_code != 0:
-                raise ClickException("{}: Editing failed!".format(editor))
-        except OSError as e:
-            raise ClickException("{}: Editing failed: {}".format(editor, e))
-
-    def edit(self, text):
-        import tempfile
-
-        text = text or ""
-        if text and not text.endswith("\n"):
-            text += "\n"
-
-        fd, name = tempfile.mkstemp(prefix="editor-", suffix=self.extension)
-        try:
-            if WIN:
-                encoding = "utf-8-sig"
-                text = text.replace("\n", "\r\n")
-            else:
-                encoding = "utf-8"
-            text = text.encode(encoding)
-
-            f = os.fdopen(fd, "wb")
-            f.write(text)
-            f.close()
-            timestamp = os.path.getmtime(name)
-
-            self.edit_file(name)
-
-            if self.require_save and os.path.getmtime(name) == timestamp:
-                return None
-
-            f = open(name, "rb")
-            try:
-                rv = f.read()
-            finally:
-                f.close()
-            return rv.decode("utf-8-sig").replace("\r\n", "\n")
-        finally:
-            os.unlink(name)
-
-
-def open_url(url, wait=False, locate=False):
-    import subprocess
-
-    def _unquote_file(url):
-        try:
-            import urllib
-        except ImportError:
-            import urllib
-        if url.startswith("file://"):
-            url = urllib.unquote(url[7:])
-        return url
-
-    if sys.platform == "darwin":
-        args = ["open"]
-        if wait:
-            args.append("-W")
-        if locate:
-            args.append("-R")
-        args.append(_unquote_file(url))
-        null = open("/dev/null", "w")
-        try:
-            return subprocess.Popen(args, stderr=null).wait()
-        finally:
-            null.close()
-    elif WIN:
-        if locate:
-            url = _unquote_file(url)
-            args = 'explorer /select,"{}"'.format(_unquote_file(url.replace('"', "")))
-        else:
-            args = 'start {} "" "{}"'.format(
-                "/WAIT" if wait else "", url.replace('"', "")
-            )
-        return os.system(args)
-    elif CYGWIN:
-        if locate:
-            url = _unquote_file(url)
-            args = 'cygstart "{}"'.format(os.path.dirname(url).replace('"', ""))
-        else:
-            args = 'cygstart {} "{}"'.format("-w" if wait else "", url.replace('"', ""))
-        return os.system(args)
-
-    try:
-        if locate:
-            url = os.path.dirname(_unquote_file(url)) or "."
-        else:
-            url = _unquote_file(url)
-        c = subprocess.Popen(["xdg-open", url])
-        if wait:
-            return c.wait()
-        return 0
-    except OSError:
-        if url.startswith(("http://", "https://")) and not locate and not wait:
-            import webbrowser
-
-            webbrowser.open(url)
-            return 0
-        return 1
-
-
-def _translate_ch_to_exc(ch):
-    if ch == u"\x03":
-        raise KeyboardInterrupt()
-    if ch == u"\x04" and not WIN:  # Unix-like, Ctrl+D
-        raise EOFError()
-    if ch == u"\x1a" and WIN:  # Windows, Ctrl+Z
-        raise EOFError()
-
-
-if WIN:
-    import msvcrt
-
-    @contextlib.contextmanager
-    def raw_terminal():
-        yield
-
-    def getchar(echo):
-        # The function `getch` will return a bytes object corresponding to
-        # the pressed character. Since Windows 10 build 1803, it will also
-        # return \x00 when called a second time after pressing a regular key.
-        #
-        # `getwch` does not share this probably-bugged behavior. Moreover, it
-        # returns a Unicode object by default, which is what we want.
-        #
-        # Either of these functions will return \x00 or \xe0 to indicate
-        # a special key, and you need to call the same function again to get
-        # the "rest" of the code. The fun part is that \u00e0 is
-        # "latin small letter a with grave", so if you type that on a French
-        # keyboard, you _also_ get a \xe0.
-        # E.g., consider the Up arrow. This returns \xe0 and then \x48. The
-        # resulting Unicode string reads as "a with grave" + "capital H".
-        # This is indistinguishable from when the user actually types
-        # "a with grave" and then "capital H".
-        #
-        # When \xe0 is returned, we assume it's part of a special-key sequence
-        # and call `getwch` again, but that means that when the user types
-        # the \u00e0 character, `getchar` doesn't return until a second
-        # character is typed.
-        # The alternative is returning immediately, but that would mess up
-        # cross-platform handling of arrow keys and others that start with
-        # \xe0. Another option is using `getch`, but then we can't reliably
-        # read non-ASCII characters, because return values of `getch` are
-        # limited to the current 8-bit codepage.
-        #
-        # Anyway, Click doesn't claim to do this Right(tm), and using `getwch`
-        # is doing the right thing in more situations than with `getch`.
-        if echo:
-            func = msvcrt.getwche
-        else:
-            func = msvcrt.getwch
-
-        rv = func()
-        if rv in (u"\x00", u"\xe0"):
-            # \x00 and \xe0 are control characters that indicate special key,
-            # see above.
-            rv += func()
-        _translate_ch_to_exc(rv)
-        return rv
-
-
-else:
-    import tty
-    import termios
-
-    @contextlib.contextmanager
-    def raw_terminal():
-        if not isatty(sys.stdin):
-            f = open("/dev/tty")
-            fd = f.fileno()
-        else:
-            fd = sys.stdin.fileno()
-            f = None
-        try:
-            old_settings = termios.tcgetattr(fd)
-            try:
-                tty.setraw(fd)
-                yield fd
-            finally:
-                termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
-                sys.stdout.flush()
-                if f is not None:
-                    f.close()
-        except termios.error:
-            pass
-
-    def getchar(echo):
-        with raw_terminal() as fd:
-            ch = os.read(fd, 32)
-            ch = ch.decode(get_best_encoding(sys.stdin), "replace")
-            if echo and isatty(sys.stdout):
-                sys.stdout.write(ch)
-            _translate_ch_to_exc(ch)
-            return ch
diff --git a/Flaskserver/venv/Lib/site-packages/click/_textwrap.py b/Flaskserver/venv/Lib/site-packages/click/_textwrap.py
deleted file mode 100644
index 6959087b7f317841e16d0732b88d4240c364f24c..0000000000000000000000000000000000000000
--- a/Flaskserver/venv/Lib/site-packages/click/_textwrap.py
+++ /dev/null
@@ -1,37 +0,0 @@
-import textwrap
-from contextlib import contextmanager
-
-
-class TextWrapper(textwrap.TextWrapper):
-    def _handle_long_word(self, reversed_chunks, cur_line, cur_len, width):
-        space_left = max(width - cur_len, 1)
-
-        if self.break_long_words:
-            last = reversed_chunks[-1]
-            cut = last[:space_left]
-            res = last[space_left:]
-            cur_line.append(cut)
-            reversed_chunks[-1] = res
-        elif not cur_line:
-            cur_line.append(reversed_chunks.pop())
-
-    @contextmanager
-    def extra_indent(self, indent):
-        old_initial_indent = self.initial_indent
-        old_subsequent_indent = self.subsequent_indent
-        self.initial_indent += indent
-        self.subsequent_indent += indent
-        try:
-            yield
-        finally:
-            self.initial_indent = old_initial_indent
-            self.subsequent_indent = old_subsequent_indent
-
-    def indent_only(self, text):
-        rv = []
-        for idx, line in enumerate(text.splitlines()):
-            indent = self.initial_indent
-            if idx > 0:
-                indent = self.subsequent_indent
-            rv.append(indent + line)
-        return "\n".join(rv)
diff --git a/Flaskserver/venv/Lib/site-packages/click/_unicodefun.py b/Flaskserver/venv/Lib/site-packages/click/_unicodefun.py
deleted file mode 100644
index 781c3652272630609c14da72f88d62315b68798a..0000000000000000000000000000000000000000
--- a/Flaskserver/venv/Lib/site-packages/click/_unicodefun.py
+++ /dev/null
@@ -1,131 +0,0 @@
-import codecs
-import os
-import sys
-
-from ._compat import PY2
-
-
-def _find_unicode_literals_frame():
-    import __future__
-
-    if not hasattr(sys, "_getframe"):  # not all Python implementations have it
-        return 0
-    frm = sys._getframe(1)
-    idx = 1
-    while frm is not None:
-        if frm.f_globals.get("__name__", "").startswith("click."):
-            frm = frm.f_back
-            idx += 1
-        elif frm.f_code.co_flags & __future__.unicode_literals.compiler_flag:
-            return idx
-        else:
-            break
-    return 0
-
-
-def _check_for_unicode_literals():
-    if not __debug__:
-        return
-
-    from . import disable_unicode_literals_warning
-
-    if not PY2 or disable_unicode_literals_warning:
-        return
-    bad_frame = _find_unicode_literals_frame()
-    if bad_frame <= 0:
-        return
-    from warnings import warn
-
-    warn(
-        Warning(
-            "Click detected the use of the unicode_literals __future__"
-            " import. This is heavily discouraged because it can"
-            " introduce subtle bugs in your code. You should instead"
-            ' use explicit u"" literals for your unicode strings. For'
-            " more information see"
-            " https://click.palletsprojects.com/python3/"
-        ),
-        stacklevel=bad_frame,
-    )
-
-
-def _verify_python3_env():
-    """Ensures that the environment is good for unicode on Python 3."""
-    if PY2:
-        return
-    try:
-        import locale
-
-        fs_enc = codecs.lookup(locale.getpreferredencoding()).name
-    except Exception:
-        fs_enc = "ascii"
-    if fs_enc != "ascii":
-        return
-
-    extra = ""
-    if os.name == "posix":
-        import subprocess
-
-        try:
-            rv = subprocess.Popen(
-                ["locale", "-a"], stdout=subprocess.PIPE, stderr=subprocess.PIPE
-            ).communicate()[0]
-        except OSError:
-            rv = b""
-        good_locales = set()
-        has_c_utf8 = False
-
-        # Make sure we're operating on text here.
-        if isinstance(rv, bytes):
-            rv = rv.decode("ascii", "replace")
-
-        for line in rv.splitlines():
-            locale = line.strip()
-            if locale.lower().endswith((".utf-8", ".utf8")):
-                good_locales.add(locale)
-                if locale.lower() in ("c.utf8", "c.utf-8"):
-                    has_c_utf8 = True
-
-        extra += "\n\n"
-        if not good_locales:
-            extra += (
-                "Additional information: on this system no suitable"
-                " UTF-8 locales were discovered. This most likely"
-                " requires resolving by reconfiguring the locale"
-                " system."
-            )
-        elif has_c_utf8:
-            extra += (
-                "This system supports the C.UTF-8 locale which is"
-                " recommended. You might be able to resolve your issue"
-                " by exporting the following environment variables:\n\n"
-                "    export LC_ALL=C.UTF-8\n"
-                "    export LANG=C.UTF-8"
-            )
-        else:
-            extra += (
-                "This system lists a couple of UTF-8 supporting locales"
-                " that you can pick from. The following suitable"
-                " locales were discovered: {}".format(", ".join(sorted(good_locales)))
-            )
-
-        bad_locale = None
-        for locale in os.environ.get("LC_ALL"), os.environ.get("LANG"):
-            if locale and locale.lower().endswith((".utf-8", ".utf8")):
-                bad_locale = locale
-            if locale is not None:
-                break
-        if bad_locale is not None:
-            extra += (
-                "\n\nClick discovered that you exported a UTF-8 locale"
-                " but the locale system could not pick up from it"
-                " because it does not exist. The exported locale is"
-                " '{}' but it is not supported".format(bad_locale)
-            )
-
-    raise RuntimeError(
-        "Click will abort further execution because Python 3 was"
-        " configured to use ASCII as encoding for the environment."
-        " Consult https://click.palletsprojects.com/python3/ for"
-        " mitigation steps.{}".format(extra)
-    )
diff --git a/Flaskserver/venv/Lib/site-packages/click/_winconsole.py b/Flaskserver/venv/Lib/site-packages/click/_winconsole.py
deleted file mode 100644
index b6c4274af0e86151c60541dfefa85b955009205c..0000000000000000000000000000000000000000
--- a/Flaskserver/venv/Lib/site-packages/click/_winconsole.py
+++ /dev/null
@@ -1,370 +0,0 @@
-# -*- coding: utf-8 -*-
-# This module is based on the excellent work by Adam Bartoš who
-# provided a lot of what went into the implementation here in
-# the discussion to issue1602 in the Python bug tracker.
-#
-# There are some general differences in regards to how this works
-# compared to the original patches as we do not need to patch
-# the entire interpreter but just work in our little world of
-# echo and prmopt.
-import ctypes
-import io
-import os
-import sys
-import time
-import zlib
-from ctypes import byref
-from ctypes import c_char
-from ctypes import c_char_p
-from ctypes import c_int
-from ctypes import c_ssize_t
-from ctypes import c_ulong
-from ctypes import c_void_p
-from ctypes import POINTER
-from ctypes import py_object
-from ctypes import windll
-from ctypes import WinError
-from ctypes import WINFUNCTYPE
-from ctypes.wintypes import DWORD
-from ctypes.wintypes import HANDLE
-from ctypes.wintypes import LPCWSTR
-from ctypes.wintypes import LPWSTR
-
-import msvcrt
-
-from ._compat import _NonClosingTextIOWrapper
-from ._compat import PY2
-from ._compat import text_type
-
-try:
-    from ctypes import pythonapi
-
-    PyObject_GetBuffer = pythonapi.PyObject_GetBuffer
-    PyBuffer_Release = pythonapi.PyBuffer_Release
-except ImportError:
-    pythonapi = None
-
-
-c_ssize_p = POINTER(c_ssize_t)
-
-kernel32 = windll.kernel32
-GetStdHandle = kernel32.GetStdHandle
-ReadConsoleW = kernel32.ReadConsoleW
-WriteConsoleW = kernel32.WriteConsoleW
-GetConsoleMode = kernel32.GetConsoleMode
-GetLastError = kernel32.GetLastError
-GetCommandLineW = WINFUNCTYPE(LPWSTR)(("GetCommandLineW", windll.kernel32))
-CommandLineToArgvW = WINFUNCTYPE(POINTER(LPWSTR), LPCWSTR, POINTER(c_int))(
-    ("CommandLineToArgvW", windll.shell32)
-)
-LocalFree = WINFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p)(
-    ("LocalFree", windll.kernel32)
-)
-
-
-STDIN_HANDLE = GetStdHandle(-10)
-STDOUT_HANDLE = GetStdHandle(-11)
-STDERR_HANDLE = GetStdHandle(-12)
-
-
-PyBUF_SIMPLE = 0
-PyBUF_WRITABLE = 1
-
-ERROR_SUCCESS = 0
-ERROR_NOT_ENOUGH_MEMORY = 8
-ERROR_OPERATION_ABORTED = 995
-
-STDIN_FILENO = 0
-STDOUT_FILENO = 1
-STDERR_FILENO = 2
-
-EOF = b"\x1a"
-MAX_BYTES_WRITTEN = 32767
-
-
-class Py_buffer(ctypes.Structure):
-    _fields_ = [
-        ("buf", c_void_p),
-        ("obj", py_object),
-        ("len", c_ssize_t),
-        ("itemsize", c_ssize_t),
-        ("readonly", c_int),
-        ("ndim", c_int),
-        ("format", c_char_p),
-        ("shape", c_ssize_p),
-        ("strides", c_ssize_p),
-        ("suboffsets", c_ssize_p),
-        ("internal", c_void_p),
-    ]
-
-    if PY2:
-        _fields_.insert(-1, ("smalltable", c_ssize_t * 2))
-
-
-# On PyPy we cannot get buffers so our ability to operate here is
-# serverly limited.
-if pythonapi is None:
-    get_buffer = None
-else:
-
-    def get_buffer(obj, writable=False):
-        buf = Py_buffer()
-        flags = PyBUF_WRITABLE if writable else PyBUF_SIMPLE
-        PyObject_GetBuffer(py_object(obj), byref(buf), flags)
-        try:
-            buffer_type = c_char * buf.len
-            return buffer_type.from_address(buf.buf)
-        finally:
-            PyBuffer_Release(byref(buf))
-
-
-class _WindowsConsoleRawIOBase(io.RawIOBase):
-    def __init__(self, handle):
-        self.handle = handle
-
-    def isatty(self):
-        io.RawIOBase.isatty(self)
-        return True
-
-
-class _WindowsConsoleReader(_WindowsConsoleRawIOBase):
-    def readable(self):
-        return True
-
-    def readinto(self, b):
-        bytes_to_be_read = len(b)
-        if not bytes_to_be_read:
-            return 0
-        elif bytes_to_be_read % 2:
-            raise ValueError(
-                "cannot read odd number of bytes from UTF-16-LE encoded console"
-            )
-
-        buffer = get_buffer(b, writable=True)
-        code_units_to_be_read = bytes_to_be_read // 2
-        code_units_read = c_ulong()
-
-        rv = ReadConsoleW(
-            HANDLE(self.handle),
-            buffer,
-            code_units_to_be_read,
-            byref(code_units_read),
-            None,
-        )
-        if GetLastError() == ERROR_OPERATION_ABORTED:
-            # wait for KeyboardInterrupt
-            time.sleep(0.1)
-        if not rv:
-            raise OSError("Windows error: {}".format(GetLastError()))
-
-        if buffer[0] == EOF:
-            return 0
-        return 2 * code_units_read.value
-
-
-class _WindowsConsoleWriter(_WindowsConsoleRawIOBase):
-    def writable(self):
-        return True
-
-    @staticmethod
-    def _get_error_message(errno):
-        if errno == ERROR_SUCCESS:
-            return "ERROR_SUCCESS"
-        elif errno == ERROR_NOT_ENOUGH_MEMORY:
-            return "ERROR_NOT_ENOUGH_MEMORY"
-        return "Windows error {}".format(errno)
-
-    def write(self, b):
-        bytes_to_be_written = len(b)
-        buf = get_buffer(b)
-        code_units_to_be_written = min(bytes_to_be_written, MAX_BYTES_WRITTEN) // 2
-        code_units_written = c_ulong()
-
-        WriteConsoleW(
-            HANDLE(self.handle),
-            buf,
-            code_units_to_be_written,
-            byref(code_units_written),
-            None,
-        )
-        bytes_written = 2 * code_units_written.value
-
-        if bytes_written == 0 and bytes_to_be_written > 0:
-            raise OSError(self._get_error_message(GetLastError()))
-        return bytes_written
-
-
-class ConsoleStream(object):
-    def __init__(self, text_stream, byte_stream):
-        self._text_stream = text_stream
-        self.buffer = byte_stream
-
-    @property
-    def name(self):
-        return self.buffer.name
-
-    def write(self, x):
-        if isinstance(x, text_type):
-            return self._text_stream.write(x)
-        try:
-            self.flush()
-        except Exception:
-            pass
-        return self.buffer.write(x)
-
-    def writelines(self, lines):
-        for line in lines:
-            self.write(line)
-
-    def __getattr__(self, name):
-        return getattr(self._text_stream, name)
-
-    def isatty(self):
-        return self.buffer.isatty()
-
-    def __repr__(self):
-        return "<ConsoleStream name={!r} encoding={!r}>".format(
-            self.name, self.encoding
-        )
-
-
-class WindowsChunkedWriter(object):
-    """
-    Wraps a stream (such as stdout), acting as a transparent proxy for all
-    attribute access apart from method 'write()' which we wrap to write in
-    limited chunks due to a Windows limitation on binary console streams.
-    """
-
-    def __init__(self, wrapped):
-        # double-underscore everything to prevent clashes with names of
-        # attributes on the wrapped stream object.
-        self.__wrapped = wrapped
-
-    def __getattr__(self, name):
-        return getattr(self.__wrapped, name)
-
-    def write(self, text):
-        total_to_write = len(text)
-        written = 0
-
-        while written < total_to_write:
-            to_write = min(total_to_write - written, MAX_BYTES_WRITTEN)
-            self.__wrapped.write(text[written : written + to_write])
-            written += to_write
-
-
-_wrapped_std_streams = set()
-
-
-def _wrap_std_stream(name):
-    # Python 2 & Windows 7 and below
-    if (
-        PY2
-        and sys.getwindowsversion()[:2] <= (6, 1)
-        and name not in _wrapped_std_streams
-    ):
-        setattr(sys, name, WindowsChunkedWriter(getattr(sys, name)))
-        _wrapped_std_streams.add(name)
-
-
-def _get_text_stdin(buffer_stream):
-    text_stream = _NonClosingTextIOWrapper(
-        io.BufferedReader(_WindowsConsoleReader(STDIN_HANDLE)),
-        "utf-16-le",
-        "strict",
-        line_buffering=True,
-    )
-    return ConsoleStream(text_stream, buffer_stream)
-
-
-def _get_text_stdout(buffer_stream):
-    text_stream = _NonClosingTextIOWrapper(
-        io.BufferedWriter(_WindowsConsoleWriter(STDOUT_HANDLE)),
-        "utf-16-le",
-        "strict",
-        line_buffering=True,
-    )
-    return ConsoleStream(text_stream, buffer_stream)
-
-
-def _get_text_stderr(buffer_stream):
-    text_stream = _NonClosingTextIOWrapper(
-        io.BufferedWriter(_WindowsConsoleWriter(STDERR_HANDLE)),
-        "utf-16-le",
-        "strict",
-        line_buffering=True,
-    )
-    return ConsoleStream(text_stream, buffer_stream)
-
-
-if PY2:
-
-    def _hash_py_argv():
-        return zlib.crc32("\x00".join(sys.argv[1:]))
-
-    _initial_argv_hash = _hash_py_argv()
-
-    def _get_windows_argv():
-        argc = c_int(0)
-        argv_unicode = CommandLineToArgvW(GetCommandLineW(), byref(argc))
-        if not argv_unicode:
-            raise WinError()
-        try:
-            argv = [argv_unicode[i] for i in range(0, argc.value)]
-        finally:
-            LocalFree(argv_unicode)
-            del argv_unicode
-
-        if not hasattr(sys, "frozen"):
-            argv = argv[1:]
-            while len(argv) > 0:
-                arg = argv[0]
-                if not arg.startswith("-") or arg == "-":
-                    break
-                argv = argv[1:]
-                if arg.startswith(("-c", "-m")):
-                    break
-
-        return argv[1:]
-
-
-_stream_factories = {
-    0: _get_text_stdin,
-    1: _get_text_stdout,
-    2: _get_text_stderr,
-}
-
-
-def _is_console(f):
-    if not hasattr(f, "fileno"):
-        return False
-
-    try:
-        fileno = f.fileno()
-    except OSError:
-        return False
-
-    handle = msvcrt.get_osfhandle(fileno)
-    return bool(GetConsoleMode(handle, byref(DWORD())))
-
-
-def _get_windows_console_stream(f, encoding, errors):
-    if (
-        get_buffer is not None
-        and encoding in ("utf-16-le", None)
-        and errors in ("strict", None)
-        and _is_console(f)
-    ):
-        func = _stream_factories.get(f.fileno())
-        if func is not None:
-            if not PY2:
-                f = getattr(f, "buffer", None)
-                if f is None:
-                    return None
-            else:
-                # If we are on Python 2 we need to set the stream that we
-                # deal with to binary mode as otherwise the exercise if a
-                # bit moot.  The same problems apply as for
-                # get_binary_stdin and friends from _compat.
-                msvcrt.setmode(f.fileno(), os.O_BINARY)
-            return func(f)
diff --git a/Flaskserver/venv/Lib/site-packages/click/core.py b/Flaskserver/venv/Lib/site-packages/click/core.py
deleted file mode 100644
index f58bf26d2f988e5b02e060b21863874ac87e1529..0000000000000000000000000000000000000000
--- a/Flaskserver/venv/Lib/site-packages/click/core.py
+++ /dev/null
@@ -1,2030 +0,0 @@
-import errno
-import inspect
-import os
-import sys
-from contextlib import contextmanager
-from functools import update_wrapper
-from itertools import repeat
-
-from ._compat import isidentifier
-from ._compat import iteritems
-from ._compat import PY2
-from ._compat import string_types
-from ._unicodefun import _check_for_unicode_literals
-from ._unicodefun import _verify_python3_env
-from .exceptions import Abort
-from .exceptions import BadParameter
-from .exceptions import ClickException
-from .exceptions import Exit
-from .exceptions import MissingParameter
-from .exceptions import UsageError
-from .formatting import HelpFormatter
-from .formatting import join_options
-from .globals import pop_context
-from .globals import push_context
-from .parser import OptionParser
-from .parser import split_opt
-from .termui import confirm
-from .termui import prompt
-from .termui import style
-from .types import BOOL
-from .types import convert_type
-from .types import IntRange
-from .utils import echo
-from .utils import get_os_args
-from .utils import make_default_short_help
-from .utils import make_str
-from .utils import PacifyFlushWrapper
-
-_missing = object()
-
-SUBCOMMAND_METAVAR = "COMMAND [ARGS]..."
-SUBCOMMANDS_METAVAR = "COMMAND1 [ARGS]... [COMMAND2 [ARGS]...]..."
-
-DEPRECATED_HELP_NOTICE = " (DEPRECATED)"
-DEPRECATED_INVOKE_NOTICE = "DeprecationWarning: The command %(name)s is deprecated."
-
-
-def _maybe_show_deprecated_notice(cmd):
-    if cmd.deprecated:
-        echo(style(DEPRECATED_INVOKE_NOTICE % {"name": cmd.name}, fg="red"), err=True)
-
-
-def fast_exit(code):
-    """Exit without garbage collection, this speeds up exit by about 10ms for
-    things like bash completion.
-    """
-    sys.stdout.flush()
-    sys.stderr.flush()
-    os._exit(code)
-
-
-def _bashcomplete(cmd, prog_name, complete_var=None):
-    """Internal handler for the bash completion support."""
-    if complete_var is None:
-        complete_var = "_{}_COMPLETE".format(prog_name.replace("-", "_").upper())
-    complete_instr = os.environ.get(complete_var)
-    if not complete_instr:
-        return
-
-    from ._bashcomplete import bashcomplete
-
-    if bashcomplete(cmd, prog_name, complete_var, complete_instr):
-        fast_exit(1)
-
-
-def _check_multicommand(base_command, cmd_name, cmd, register=False):
-    if not base_command.chain or not isinstance(cmd, MultiCommand):
-        return
-    if register:
-        hint = (
-            "It is not possible to add multi commands as children to"
-            " another multi command that is in chain mode."
-        )
-    else:
-        hint = (
-            "Found a multi command as subcommand to a multi command"
-            " that is in chain mode. This is not supported."
-        )
-    raise RuntimeError(
-        "{}. Command '{}' is set to chain and '{}' was added as"
-        " subcommand but it in itself is a multi command. ('{}' is a {}"
-        " within a chained {} named '{}').".format(
-            hint,
-            base_command.name,
-            cmd_name,
-            cmd_name,
-            cmd.__class__.__name__,
-            base_command.__class__.__name__,
-            base_command.name,
-        )
-    )
-
-
-def batch(iterable, batch_size):
-    return list(zip(*repeat(iter(iterable), batch_size)))
-
-
-def invoke_param_callback(callback, ctx, param, value):
-    code = getattr(callback, "__code__", None)
-    args = getattr(code, "co_argcount", 3)
-
-    if args < 3:
-        from warnings import warn
-
-        warn(
-            "Parameter callbacks take 3 args, (ctx, param, value). The"
-            " 2-arg style is deprecated and will be removed in 8.0.".format(callback),
-            DeprecationWarning,
-            stacklevel=3,
-        )
-        return callback(ctx, value)
-
-    return callback(ctx, param, value)
-
-
-@contextmanager
-def augment_usage_errors(ctx, param=None):
-    """Context manager that attaches extra information to exceptions."""
-    try:
-        yield
-    except BadParameter as e:
-        if e.ctx is None:
-            e.ctx = ctx
-        if param is not None and e.param is None:
-            e.param = param
-        raise
-    except UsageError as e:
-        if e.ctx is None:
-            e.ctx = ctx
-        raise
-
-
-def iter_params_for_processing(invocation_order, declaration_order):
-    """Given a sequence of parameters in the order as should be considered
-    for processing and an iterable of parameters that exist, this returns
-    a list in the correct order as they should be processed.
-    """
-
-    def sort_key(item):
-        try:
-            idx = invocation_order.index(item)
-        except ValueError:
-            idx = float("inf")
-        return (not item.is_eager, idx)
-
-    return sorted(declaration_order, key=sort_key)
-
-
-class Context(object):
-    """The context is a special internal object that holds state relevant
-    for the script execution at every single level.  It's normally invisible
-    to commands unless they opt-in to getting access to it.
-
-    The context is useful as it can pass internal objects around and can
-    control special execution features such as reading data from
-    environment variables.
-
-    A context can be used as context manager in which case it will call
-    :meth:`close` on teardown.
-
-    .. versionadded:: 2.0
-       Added the `resilient_parsing`, `help_option_names`,
-       `token_normalize_func` parameters.
-
-    .. versionadded:: 3.0
-       Added the `allow_extra_args` and `allow_interspersed_args`
-       parameters.
-
-    .. versionadded:: 4.0
-       Added the `color`, `ignore_unknown_options`, and
-       `max_content_width` parameters.
-
-    .. versionadded:: 7.1
-       Added the `show_default` parameter.
-
-    :param command: the command class for this context.
-    :param parent: the parent context.
-    :param info_name: the info name for this invocation.  Generally this
-                      is the most descriptive name for the script or
-                      command.  For the toplevel script it is usually
-                      the name of the script, for commands below it it's
-                      the name of the script.
-    :param obj: an arbitrary object of user data.
-    :param auto_envvar_prefix: the prefix to use for automatic environment
-                               variables.  If this is `None` then reading
-                               from environment variables is disabled.  This
-                               does not affect manually set environment
-                               variables which are always read.
-    :param default_map: a dictionary (like object) with default values
-                        for parameters.
-    :param terminal_width: the width of the terminal.  The default is
-                           inherit from parent context.  If no context
-                           defines the terminal width then auto
-                           detection will be applied.
-    :param max_content_width: the maximum width for content rendered by
-                              Click (this currently only affects help
-                              pages).  This defaults to 80 characters if
-                              not overridden.  In other words: even if the
-                              terminal is larger than that, Click will not
-                              format things wider than 80 characters by
-                              default.  In addition to that, formatters might
-                              add some safety mapping on the right.
-    :param resilient_parsing: if this flag is enabled then Click will
-                              parse without any interactivity or callback
-                              invocation.  Default values will also be
-                              ignored.  This is useful for implementing
-                              things such as completion support.
-    :param allow_extra_args: if this is set to `True` then extra arguments
-                             at the end will not raise an error and will be
-                             kept on the context.  The default is to inherit
-                             from the command.
-    :param allow_interspersed_args: if this is set to `False` then options
-                                    and arguments cannot be mixed.  The
-                                    default is to inherit from the command.
-    :param ignore_unknown_options: instructs click to ignore options it does
-                                   not know and keeps them for later
-                                   processing.
-    :param help_option_names: optionally a list of strings that define how
-                              the default help parameter is named.  The
-                              default is ``['--help']``.
-    :param token_normalize_func: an optional function that is used to
-                                 normalize tokens (options, choices,
-                                 etc.).  This for instance can be used to
-                                 implement case insensitive behavior.
-    :param color: controls if the terminal supports ANSI colors or not.  The
-                  default is autodetection.  This is only needed if ANSI
-                  codes are used in texts that Click prints which is by
-                  default not the case.  This for instance would affect
-                  help output.
-    :param show_default: if True, shows defaults for all options.
-                    Even if an option is later created with show_default=False,
-                    this command-level setting overrides it.
-    """
-
-    def __init__(
-        self,
-        command,
-        parent=None,
-        info_name=None,
-        obj=None,
-        auto_envvar_prefix=None,
-        default_map=None,
-        terminal_width=None,
-        max_content_width=None,
-        resilient_parsing=False,
-        allow_extra_args=None,
-        allow_interspersed_args=None,
-        ignore_unknown_options=None,
-        help_option_names=None,
-        token_normalize_func=None,
-        color=None,
-        show_default=None,
-    ):
-        #: the parent context or `None` if none exists.
-        self.parent = parent
-        #: the :class:`Command` for this context.
-        self.command = command
-        #: the descriptive information name
-        self.info_name = info_name
-        #: the parsed parameters except if the value is hidden in which
-        #: case it's not remembered.
-        self.params = {}
-        #: the leftover arguments.
-        self.args = []
-        #: protected arguments.  These are arguments that are prepended
-        #: to `args` when certain parsing scenarios are encountered but
-        #: must be never propagated to another arguments.  This is used
-        #: to implement nested parsing.
-        self.protected_args = []
-        if obj is None and parent is not None:
-            obj = parent.obj
-        #: the user object stored.
-        self.obj = obj
-        self._meta = getattr(parent, "meta", {})
-
-        #: A dictionary (-like object) with defaults for parameters.
-        if (
-            default_map is None
-            and parent is not None
-            and parent.default_map is not None
-        ):
-            default_map = parent.default_map.get(info_name)
-        self.default_map = default_map
-
-        #: This flag indicates if a subcommand is going to be executed. A
-        #: group callback can use this information to figure out if it's
-        #: being executed directly or because the execution flow passes
-        #: onwards to a subcommand. By default it's None, but it can be
-        #: the name of the subcommand to execute.
-        #:
-        #: If chaining is enabled this will be set to ``'*'`` in case
-        #: any commands are executed.  It is however not possible to
-        #: figure out which ones.  If you require this knowledge you
-        #: should use a :func:`resultcallback`.
-        self.invoked_subcommand = None
-
-        if terminal_width is None and parent is not None:
-            terminal_width = parent.terminal_width
-        #: The width of the terminal (None is autodetection).
-        self.terminal_width = terminal_width
-
-        if max_content_width is None and parent is not None:
-            max_content_width = parent.max_content_width
-        #: The maximum width of formatted content (None implies a sensible
-        #: default which is 80 for most things).
-        self.max_content_width = max_content_width
-
-        if allow_extra_args is None:
-            allow_extra_args = command.allow_extra_args
-        #: Indicates if the context allows extra args or if it should
-        #: fail on parsing.
-        #:
-        #: .. versionadded:: 3.0
-        self.allow_extra_args = allow_extra_args
-
-        if allow_interspersed_args is None:
-            allow_interspersed_args = command.allow_interspersed_args
-        #: Indicates if the context allows mixing of arguments and
-        #: options or not.
-        #:
-        #: .. versionadded:: 3.0
-        self.allow_interspersed_args = allow_interspersed_args
-
-        if ignore_unknown_options is None:
-            ignore_unknown_options = command.ignore_unknown_options
-        #: Instructs click to ignore options that a command does not
-        #: understand and will store it on the context for later
-        #: processing.  This is primarily useful for situations where you
-        #: want to call into external programs.  Generally this pattern is
-        #: strongly discouraged because it's not possibly to losslessly
-        #: forward all arguments.
-        #:
-        #: .. versionadded:: 4.0
-        self.ignore_unknown_options = ignore_unknown_options
-
-        if help_option_names is None:
-            if parent is not None:
-                help_option_names = parent.help_option_names
-            else:
-                help_option_names = ["--help"]
-
-        #: The names for the help options.
-        self.help_option_names = help_option_names
-
-        if token_normalize_func is None and parent is not None:
-            token_normalize_func = parent.token_normalize_func
-
-        #: An optional normalization function for tokens.  This is
-        #: options, choices, commands etc.
-        self.token_normalize_func = token_normalize_func
-
-        #: Indicates if resilient parsing is enabled.  In that case Click
-        #: will do its best to not cause any failures and default values
-        #: will be ignored. Useful for completion.
-        self.resilient_parsing = resilient_parsing
-
-        # If there is no envvar prefix yet, but the parent has one and
-        # the command on this level has a name, we can expand the envvar
-        # prefix automatically.
-        if auto_envvar_prefix is None:
-            if (
-                parent is not None
-                and parent.auto_envvar_prefix is not None
-                and self.info_name is not None
-            ):
-                auto_envvar_prefix = "{}_{}".format(
-                    parent.auto_envvar_prefix, self.info_name.upper()
-                )
-        else:
-            auto_envvar_prefix = auto_envvar_prefix.upper()
-        if auto_envvar_prefix is not None:
-            auto_envvar_prefix = auto_envvar_prefix.replace("-", "_")
-        self.auto_envvar_prefix = auto_envvar_prefix
-
-        if color is None and parent is not None:
-            color = parent.color
-
-        #: Controls if styling output is wanted or not.
-        self.color = color
-
-        self.show_default = show_default
-
-        self._close_callbacks = []
-        self._depth = 0
-
-    def __enter__(self):
-        self._depth += 1
-        push_context(self)
-        return self
-
-    def __exit__(self, exc_type, exc_value, tb):
-        self._depth -= 1
-        if self._depth == 0:
-            self.close()
-        pop_context()
-
-    @contextmanager
-    def scope(self, cleanup=True):
-        """This helper method can be used with the context object to promote
-        it to the current thread local (see :func:`get_current_context`).
-        The default behavior of this is to invoke the cleanup functions which
-        can be disabled by setting `cleanup` to `False`.  The cleanup
-        functions are typically used for things such as closing file handles.
-
-        If the cleanup is intended the context object can also be directly
-        used as a context manager.
-
-        Example usage::
-
-            with ctx.scope():
-                assert get_current_context() is ctx
-
-        This is equivalent::
-
-            with ctx:
-                assert get_current_context() is ctx
-
-        .. versionadded:: 5.0
-
-        :param cleanup: controls if the cleanup functions should be run or
-                        not.  The default is to run these functions.  In
-                        some situations the context only wants to be
-                        temporarily pushed in which case this can be disabled.
-                        Nested pushes automatically defer the cleanup.
-        """
-        if not cleanup:
-            self._depth += 1
-        try:
-            with self as rv:
-                yield rv
-        finally:
-            if not cleanup:
-                self._depth -= 1
-
-    @property
-    def meta(self):
-        """This is a dictionary which is shared with all the contexts
-        that are nested.  It exists so that click utilities can store some
-        state here if they need to.  It is however the responsibility of
-        that code to manage this dictionary well.
-
-        The keys are supposed to be unique dotted strings.  For instance
-        module paths are a good choice for it.  What is stored in there is
-        irrelevant for the operation of click.  However what is important is
-        that code that places data here adheres to the general semantics of
-        the system.
-
-        Example usage::
-
-            LANG_KEY = f'{__name__}.lang'
-
-            def set_language(value):
-                ctx = get_current_context()
-                ctx.meta[LANG_KEY] = value
-
-            def get_language():
-                return get_current_context().meta.get(LANG_KEY, 'en_US')
-
-        .. versionadded:: 5.0
-        """
-        return self._meta
-
-    def make_formatter(self):
-        """Creates the formatter for the help and usage output."""
-        return HelpFormatter(
-            width=self.terminal_width, max_width=self.max_content_width
-        )
-
-    def call_on_close(self, f):
-        """This decorator remembers a function as callback that should be
-        executed when the context tears down.  This is most useful to bind
-        resource handling to the script execution.  For instance, file objects
-        opened by the :class:`File` type will register their close callbacks
-        here.
-
-        :param f: the function to execute on teardown.
-        """
-        self._close_callbacks.append(f)
-        return f
-
-    def close(self):
-        """Invokes all close callbacks."""
-        for cb in self._close_callbacks:
-            cb()
-        self._close_callbacks = []
-
-    @property
-    def command_path(self):
-        """The computed command path.  This is used for the ``usage``
-        information on the help page.  It's automatically created by
-        combining the info names of the chain of contexts to the root.
-        """
-        rv = ""
-        if self.info_name is not None:
-            rv = self.info_name
-        if self.parent is not None:
-            rv = "{} {}".format(self.parent.command_path, rv)
-        return rv.lstrip()
-
-    def find_root(self):
-        """Finds the outermost context."""
-        node = self
-        while node.parent is not None:
-            node = node.parent
-        return node
-
-    def find_object(self, object_type):
-        """Finds the closest object of a given type."""
-        node = self
-        while node is not None:
-            if isinstance(node.obj, object_type):
-                return node.obj
-            node = node.parent
-
-    def ensure_object(self, object_type):
-        """Like :meth:`find_object` but sets the innermost object to a
-        new instance of `object_type` if it does not exist.
-        """
-        rv = self.find_object(object_type)
-        if rv is None:
-            self.obj = rv = object_type()
-        return rv
-
-    def lookup_default(self, name):
-        """Looks up the default for a parameter name.  This by default
-        looks into the :attr:`default_map` if available.
-        """
-        if self.default_map is not None:
-            rv = self.default_map.get(name)
-            if callable(rv):
-                rv = rv()
-            return rv
-
-    def fail(self, message):
-        """Aborts the execution of the program with a specific error
-        message.
-
-        :param message: the error message to fail with.
-        """
-        raise UsageError(message, self)
-
-    def abort(self):
-        """Aborts the script."""
-        raise Abort()
-
-    def exit(self, code=0):
-        """Exits the application with a given exit code."""
-        raise Exit(code)
-
-    def get_usage(self):
-        """Helper method to get formatted usage string for the current
-        context and command.
-        """
-        return self.command.get_usage(self)
-
-    def get_help(self):
-        """Helper method to get formatted help page for the current
-        context and command.
-        """
-        return self.command.get_help(self)
-
-    def invoke(*args, **kwargs):  # noqa: B902
-        """Invokes a command callback in exactly the way it expects.  There
-        are two ways to invoke this method:
-
-        1.  the first argument can be a callback and all other arguments and
-            keyword arguments are forwarded directly to the function.
-        2.  the first argument is a click command object.  In that case all
-            arguments are forwarded as well but proper click parameters
-            (options and click arguments) must be keyword arguments and Click
-            will fill in defaults.
-
-        Note that before Click 3.2 keyword arguments were not properly filled
-        in against the intention of this code and no context was created.  For
-        more information about this change and why it was done in a bugfix
-        release see :ref:`upgrade-to-3.2`.
-        """
-        self, callback = args[:2]
-        ctx = self
-
-        # It's also possible to invoke another command which might or
-        # might not have a callback.  In that case we also fill
-        # in defaults and make a new context for this command.
-        if isinstance(callback, Command):
-            other_cmd = callback
-            callback = other_cmd.callback
-            ctx = Context(other_cmd, info_name=other_cmd.name, parent=self)
-            if callback is None:
-                raise TypeError(
-                    "The given command does not have a callback that can be invoked."
-                )
-
-            for param in other_cmd.params:
-                if param.name not in kwargs and param.expose_value:
-                    kwargs[param.name] = param.get_default(ctx)
-
-        args = args[2:]
-        with augment_usage_errors(self):
-            with ctx:
-                return callback(*args, **kwargs)
-
-    def forward(*args, **kwargs):  # noqa: B902
-        """Similar to :meth:`invoke` but fills in default keyword
-        arguments from the current context if the other command expects
-        it.  This cannot invoke callbacks directly, only other commands.
-        """
-        self, cmd = args[:2]
-
-        # It's also possible to invoke another command which might or
-        # might not have a callback.
-        if not isinstance(cmd, Command):
-            raise TypeError("Callback is not a command.")
-
-        for param in self.params:
-            if param not in kwargs:
-                kwargs[param] = self.params[param]
-
-        return self.invoke(cmd, **kwargs)
-
-
-class BaseCommand(object):
-    """The base command implements the minimal API contract of commands.
-    Most code will never use this as it does not implement a lot of useful
-    functionality but it can act as the direct subclass of alternative
-    parsing methods that do not depend on the Click parser.
-
-    For instance, this can be used to bridge Click and other systems like
-    argparse or docopt.
-
-    Because base commands do not implement a lot of the API that other
-    parts of Click take for granted, they are not supported for all
-    operations.  For instance, they cannot be used with the decorators
-    usually and they have no built-in callback system.
-
-    .. versionchanged:: 2.0
-       Added the `context_settings` parameter.
-
-    :param name: the name of the command to use unless a group overrides it.
-    :param context_settings: an optional dictionary with defaults that are
-                             passed to the context object.
-    """
-
-    #: the default for the :attr:`Context.allow_extra_args` flag.
-    allow_extra_args = False
-    #: the default for the :attr:`Context.allow_interspersed_args` flag.
-    allow_interspersed_args = True
-    #: the default for the :attr:`Context.ignore_unknown_options` flag.
-    ignore_unknown_options = False
-
-    def __init__(self, name, context_settings=None):
-        #: the name the command thinks it has.  Upon registering a command
-        #: on a :class:`Group` the group will default the command name
-        #: with this information.  You should instead use the
-        #: :class:`Context`\'s :attr:`~Context.info_name` attribute.
-        self.name = name
-        if context_settings is None:
-            context_settings = {}
-        #: an optional dictionary with defaults passed to the context.
-        self.context_settings = context_settings
-
-    def __repr__(self):
-        return "<{} {}>".format(self.__class__.__name__, self.name)
-
-    def get_usage(self, ctx):
-        raise NotImplementedError("Base commands cannot get usage")
-
-    def get_help(self, ctx):
-        raise NotImplementedError("Base commands cannot get help")
-
-    def make_context(self, info_name, args, parent=None, **extra):
-        """This function when given an info name and arguments will kick
-        off the parsing and create a new :class:`Context`.  It does not
-        invoke the actual command callback though.
-
-        :param info_name: the info name for this invokation.  Generally this
-                          is the most descriptive name for the script or
-                          command.  For the toplevel script it's usually
-                          the name of the script, for commands below it it's
-                          the name of the script.
-        :param args: the arguments to parse as list of strings.
-        :param parent: the parent context if available.
-        :param extra: extra keyword arguments forwarded to the context
-                      constructor.
-        """
-        for key, value in iteritems(self.context_settings):
-            if key not in extra:
-                extra[key] = value
-        ctx = Context(self, info_name=info_name, parent=parent, **extra)
-        with ctx.scope(cleanup=False):
-            self.parse_args(ctx, args)
-        return ctx
-
-    def parse_args(self, ctx, args):
-        """Given a context and a list of arguments this creates the parser
-        and parses the arguments, then modifies the context as necessary.
-        This is automatically invoked by :meth:`make_context`.
-        """
-        raise NotImplementedError("Base commands do not know how to parse arguments.")
-
-    def invoke(self, ctx):
-        """Given a context, this invokes the command.  The default
-        implementation is raising a not implemented error.
-        """
-        raise NotImplementedError("Base commands are not invokable by default")
-
-    def main(
-        self,
-        args=None,
-        prog_name=None,
-        complete_var=None,
-        standalone_mode=True,
-        **extra
-    ):
-        """This is the way to invoke a script with all the bells and
-        whistles as a command line application.  This will always terminate
-        the application after a call.  If this is not wanted, ``SystemExit``
-        needs to be caught.
-
-        This method is also available by directly calling the instance of
-        a :class:`Command`.
-
-        .. versionadded:: 3.0
-           Added the `standalone_mode` flag to control the standalone mode.
-
-        :param args: the arguments that should be used for parsing.  If not
-                     provided, ``sys.argv[1:]`` is used.
-        :param prog_name: the program name that should be used.  By default
-                          the program name is constructed by taking the file
-                          name from ``sys.argv[0]``.
-        :param complete_var: the environment variable that controls the
-                             bash completion support.  The default is
-                             ``"_<prog_name>_COMPLETE"`` with prog_name in
-                             uppercase.
-        :param standalone_mode: the default behavior is to invoke the script
-                                in standalone mode.  Click will then
-                                handle exceptions and convert them into
-                                error messages and the function will never
-                                return but shut down the interpreter.  If
-                                this is set to `False` they will be
-                                propagated to the caller and the return
-                                value of this function is the return value
-                                of :meth:`invoke`.
-        :param extra: extra keyword arguments are forwarded to the context
-                      constructor.  See :class:`Context` for more information.
-        """
-        # If we are in Python 3, we will verify that the environment is
-        # sane at this point or reject further execution to avoid a
-        # broken script.
-        if not PY2:
-            _verify_python3_env()
-        else:
-            _check_for_unicode_literals()
-
-        if args is None:
-            args = get_os_args()
-        else:
-            args = list(args)
-
-        if prog_name is None:
-            prog_name = make_str(
-                os.path.basename(sys.argv[0] if sys.argv else __file__)
-            )
-
-        # Hook for the Bash completion.  This only activates if the Bash
-        # completion is actually enabled, otherwise this is quite a fast
-        # noop.
-        _bashcomplete(self, prog_name, complete_var)
-
-        try:
-            try:
-                with self.make_context(prog_name, args, **extra) as ctx:
-                    rv = self.invoke(ctx)
-                    if not standalone_mode:
-                        return rv
-                    # it's not safe to `ctx.exit(rv)` here!
-                    # note that `rv` may actually contain data like "1" which
-                    # has obvious effects
-                    # more subtle case: `rv=[None, None]` can come out of
-                    # chained commands which all returned `None` -- so it's not
-                    # even always obvious that `rv` indicates success/failure
-                    # by its truthiness/falsiness
-                    ctx.exit()
-            except (EOFError, KeyboardInterrupt):
-                echo(file=sys.stderr)
-                raise Abort()
-            except ClickException as e:
-                if not standalone_mode:
-                    raise
-                e.show()
-                sys.exit(e.exit_code)
-            except IOError as e:
-                if e.errno == errno.EPIPE:
-                    sys.stdout = PacifyFlushWrapper(sys.stdout)
-                    sys.stderr = PacifyFlushWrapper(sys.stderr)
-                    sys.exit(1)
-                else:
-                    raise
-        except Exit as e:
-            if standalone_mode:
-                sys.exit(e.exit_code)
-            else:
-                # in non-standalone mode, return the exit code
-                # note that this is only reached if `self.invoke` above raises
-                # an Exit explicitly -- thus bypassing the check there which
-                # would return its result
-                # the results of non-standalone execution may therefore be
-                # somewhat ambiguous: if there are codepaths which lead to
-                # `ctx.exit(1)` and to `return 1`, the caller won't be able to
-                # tell the difference between the two
-                return e.exit_code
-        except Abort:
-            if not standalone_mode:
-                raise
-            echo("Aborted!", file=sys.stderr)
-            sys.exit(1)
-
-    def __call__(self, *args, **kwargs):
-        """Alias for :meth:`main`."""
-        return self.main(*args, **kwargs)
-
-
-class Command(BaseCommand):
-    """Commands are the basic building block of command line interfaces in
-    Click.  A basic command handles command line parsing and might dispatch
-    more parsing to commands nested below it.
-
-    .. versionchanged:: 2.0
-       Added the `context_settings` parameter.
-    .. versionchanged:: 7.1
-       Added the `no_args_is_help` parameter.
-
-    :param name: the name of the command to use unless a group overrides it.
-    :param context_settings: an optional dictionary with defaults that are
-                             passed to the context object.
-    :param callback: the callback to invoke.  This is optional.
-    :param params: the parameters to register with this command.  This can
-                   be either :class:`Option` or :class:`Argument` objects.
-    :param help: the help string to use for this command.
-    :param epilog: like the help string but it's printed at the end of the
-                   help page after everything else.
-    :param short_help: the short help to use for this command.  This is
-                       shown on the command listing of the parent command.
-    :param add_help_option: by default each command registers a ``--help``
-                            option.  This can be disabled by this parameter.
-    :param no_args_is_help: this controls what happens if no arguments are
-                            provided.  This option is disabled by default.
-                            If enabled this will add ``--help`` as argument
-                            if no arguments are passed
-    :param hidden: hide this command from help outputs.
-
-    :param deprecated: issues a message indicating that
-                             the command is deprecated.
-    """
-
-    def __init__(
-        self,
-        name,
-        context_settings=None,
-        callback=None,
-        params=None,
-        help=None,
-        epilog=None,
-        short_help=None,
-        options_metavar="[OPTIONS]",
-        add_help_option=True,
-        no_args_is_help=False,
-        hidden=False,
-        deprecated=False,
-    ):
-        BaseCommand.__init__(self, name, context_settings)
-        #: the callback to execute when the command fires.  This might be
-        #: `None` in which case nothing happens.
-        self.callback = callback
-        #: the list of parameters for this command in the order they
-        #: should show up in the help page and execute.  Eager parameters
-        #: will automatically be handled before non eager ones.
-        self.params = params or []
-        # if a form feed (page break) is found in the help text, truncate help
-        # text to the content preceding the first form feed
-        if help and "\f" in help:
-            help = help.split("\f", 1)[0]
-        self.help = help
-        self.epilog = epilog
-        self.options_metavar = options_metavar
-        self.short_help = short_help
-        self.add_help_option = add_help_option
-        self.no_args_is_help = no_args_is_help
-        self.hidden = hidden
-        self.deprecated = deprecated
-
-    def get_usage(self, ctx):
-        """Formats the usage line into a string and returns it.
-
-        Calls :meth:`format_usage` internally.
-        """
-        formatter = ctx.make_formatter()
-        self.format_usage(ctx, formatter)
-        return formatter.getvalue().rstrip("\n")
-
-    def get_params(self, ctx):
-        rv = self.params
-        help_option = self.get_help_option(ctx)
-        if help_option is not None:
-            rv = rv + [help_option]
-        return rv
-
-    def format_usage(self, ctx, formatter):
-        """Writes the usage line into the formatter.
-
-        This is a low-level method called by :meth:`get_usage`.
-        """
-        pieces = self.collect_usage_pieces(ctx)
-        formatter.write_usage(ctx.command_path, " ".join(pieces))
-
-    def collect_usage_pieces(self, ctx):
-        """Returns all the pieces that go into the usage line and returns
-        it as a list of strings.
-        """
-        rv = [self.options_metavar]
-        for param in self.get_params(ctx):
-            rv.extend(param.get_usage_pieces(ctx))
-        return rv
-
-    def get_help_option_names(self, ctx):
-        """Returns the names for the help option."""
-        all_names = set(ctx.help_option_names)
-        for param in self.params:
-            all_names.difference_update(param.opts)
-            all_names.difference_update(param.secondary_opts)
-        return all_names
-
-    def get_help_option(self, ctx):
-        """Returns the help option object."""
-        help_options = self.get_help_option_names(ctx)
-        if not help_options or not self.add_help_option:
-            return
-
-        def show_help(ctx, param, value):
-            if value and not ctx.resilient_parsing:
-                echo(ctx.get_help(), color=ctx.color)
-                ctx.exit()
-
-        return Option(
-            help_options,
-            is_flag=True,
-            is_eager=True,
-            expose_value=False,
-            callback=show_help,
-            help="Show this message and exit.",
-        )
-
-    def make_parser(self, ctx):
-        """Creates the underlying option parser for this command."""
-        parser = OptionParser(ctx)
-        for param in self.get_params(ctx):
-            param.add_to_parser(parser, ctx)
-        return parser
-
-    def get_help(self, ctx):
-        """Formats the help into a string and returns it.
-
-        Calls :meth:`format_help` internally.
-        """
-        formatter = ctx.make_formatter()
-        self.format_help(ctx, formatter)
-        return formatter.getvalue().rstrip("\n")
-
-    def get_short_help_str(self, limit=45):
-        """Gets short help for the command or makes it by shortening the
-        long help string.
-        """
-        return (
-            self.short_help
-            or self.help
-            and make_default_short_help(self.help, limit)
-            or ""
-        )
-
-    def format_help(self, ctx, formatter):
-        """Writes the help into the formatter if it exists.
-
-        This is a low-level method called by :meth:`get_help`.
-
-        This calls the following methods:
-
-        -   :meth:`format_usage`
-        -   :meth:`format_help_text`
-        -   :meth:`format_options`
-        -   :meth:`format_epilog`
-        """
-        self.format_usage(ctx, formatter)
-        self.format_help_text(ctx, formatter)
-        self.format_options(ctx, formatter)
-        self.format_epilog(ctx, formatter)
-
-    def format_help_text(self, ctx, formatter):
-        """Writes the help text to the formatter if it exists."""
-        if self.help:
-            formatter.write_paragraph()
-            with formatter.indentation():
-                help_text = self.help
-                if self.deprecated:
-                    help_text += DEPRECATED_HELP_NOTICE
-                formatter.write_text(help_text)
-        elif self.deprecated:
-            formatter.write_paragraph()
-            with formatter.indentation():
-                formatter.write_text(DEPRECATED_HELP_NOTICE)
-
-    def format_options(self, ctx, formatter):
-        """Writes all the options into the formatter if they exist."""
-        opts = []
-        for param in self.get_params(ctx):
-            rv = param.get_help_record(ctx)
-            if rv is not None:
-                opts.append(rv)
-
-        if opts:
-            with formatter.section("Options"):
-                formatter.write_dl(opts)
-
-    def format_epilog(self, ctx, formatter):
-        """Writes the epilog into the formatter if it exists."""
-        if self.epilog:
-            formatter.write_paragraph()
-            with formatter.indentation():
-                formatter.write_text(self.epilog)
-
-    def parse_args(self, ctx, args):
-        if not args and self.no_args_is_help and not ctx.resilient_parsing:
-            echo(ctx.get_help(), color=ctx.color)
-            ctx.exit()
-
-        parser = self.make_parser(ctx)
-        opts, args, param_order = parser.parse_args(args=args)
-
-        for param in iter_params_for_processing(param_order, self.get_params(ctx)):
-            value, args = param.handle_parse_result(ctx, opts, args)
-
-        if args and not ctx.allow_extra_args and not ctx.resilient_parsing:
-            ctx.fail(
-                "Got unexpected extra argument{} ({})".format(
-                    "s" if len(args) != 1 else "", " ".join(map(make_str, args))
-                )
-            )
-
-        ctx.args = args
-        return args
-
-    def invoke(self, ctx):
-        """Given a context, this invokes the attached callback (if it exists)
-        in the right way.
-        """
-        _maybe_show_deprecated_notice(self)
-        if self.callback is not None:
-            return ctx.invoke(self.callback, **ctx.params)
-
-
-class MultiCommand(Command):
-    """A multi command is the basic implementation of a command that
-    dispatches to subcommands.  The most common version is the
-    :class:`Group`.
-
-    :param invoke_without_command: this controls how the multi command itself
-                                   is invoked.  By default it's only invoked
-                                   if a subcommand is provided.
-    :param no_args_is_help: this controls what happens if no arguments are
-                            provided.  This option is enabled by default if
-                            `invoke_without_command` is disabled or disabled
-                            if it's enabled.  If enabled this will add
-                            ``--help`` as argument if no arguments are
-                            passed.
-    :param subcommand_metavar: the string that is used in the documentation
-                               to indicate the subcommand place.
-    :param chain: if this is set to `True` chaining of multiple subcommands
-                  is enabled.  This restricts the form of commands in that
-                  they cannot have optional arguments but it allows
-                  multiple commands to be chained together.
-    :param result_callback: the result callback to attach to this multi
-                            command.
-    """
-
-    allow_extra_args = True
-    allow_interspersed_args = False
-
-    def __init__(
-        self,
-        name=None,
-        invoke_without_command=False,
-        no_args_is_help=None,
-        subcommand_metavar=None,
-        chain=False,
-        result_callback=None,
-        **attrs
-    ):
-        Command.__init__(self, name, **attrs)
-        if no_args_is_help is None:
-            no_args_is_help = not invoke_without_command
-        self.no_args_is_help = no_args_is_help
-        self.invoke_without_command = invoke_without_command
-        if subcommand_metavar is None:
-            if chain:
-                subcommand_metavar = SUBCOMMANDS_METAVAR
-            else:
-                subcommand_metavar = SUBCOMMAND_METAVAR
-        self.subcommand_metavar = subcommand_metavar
-        self.chain = chain
-        #: The result callback that is stored.  This can be set or
-        #: overridden with the :func:`resultcallback` decorator.
-        self.result_callback = result_callback
-
-        if self.chain:
-            for param in self.params:
-                if isinstance(param, Argument) and not param.required:
-                    raise RuntimeError(
-                        "Multi commands in chain mode cannot have"
-                        " optional arguments."
-                    )
-
-    def collect_usage_pieces(self, ctx):
-        rv = Command.collect_usage_pieces(self, ctx)
-        rv.append(self.subcommand_metavar)
-        return rv
-
-    def format_options(self, ctx, formatter):
-        Command.format_options(self, ctx, formatter)
-        self.format_commands(ctx, formatter)
-
-    def resultcallback(self, replace=False):
-        """Adds a result callback to the chain command.  By default if a
-        result callback is already registered this will chain them but
-        this can be disabled with the `replace` parameter.  The result
-        callback is invoked with the return value of the subcommand
-        (or the list of return values from all subcommands if chaining
-        is enabled) as well as the parameters as they would be passed
-        to the main callback.
-
-        Example::
-
-            @click.group()
-            @click.option('-i', '--input', default=23)
-            def cli(input):
-                return 42
-
-            @cli.resultcallback()
-            def process_result(result, input):
-                return result + input
-
-        .. versionadded:: 3.0
-
-        :param replace: if set to `True` an already existing result
-                        callback will be removed.
-        """
-
-        def decorator(f):
-            old_callback = self.result_callback
-            if old_callback is None or replace:
-                self.result_callback = f
-                return f
-
-            def function(__value, *args, **kwargs):
-                return f(old_callback(__value, *args, **kwargs), *args, **kwargs)
-
-            self.result_callback = rv = update_wrapper(function, f)
-            return rv
-
-        return decorator
-
-    def format_commands(self, ctx, formatter):
-        """Extra format methods for multi methods that adds all the commands
-        after the options.
-        """
-        commands = []
-        for subcommand in self.list_commands(ctx):
-            cmd = self.get_command(ctx, subcommand)
-            # What is this, the tool lied about a command.  Ignore it
-            if cmd is None:
-                continue
-            if cmd.hidden:
-                continue
-
-            commands.append((subcommand, cmd))
-
-        # allow for 3 times the default spacing
-        if len(commands):
-            limit = formatter.width - 6 - max(len(cmd[0]) for cmd in commands)
-
-            rows = []
-            for subcommand, cmd in commands:
-                help = cmd.get_short_help_str(limit)
-                rows.append((subcommand, help))
-
-            if rows:
-                with formatter.section("Commands"):
-                    formatter.write_dl(rows)
-
-    def parse_args(self, ctx, args):
-        if not args and self.no_args_is_help and not ctx.resilient_parsing:
-            echo(ctx.get_help(), color=ctx.color)
-            ctx.exit()
-
-        rest = Command.parse_args(self, ctx, args)
-        if self.chain:
-            ctx.protected_args = rest
-            ctx.args = []
-        elif rest:
-            ctx.protected_args, ctx.args = rest[:1], rest[1:]
-
-        return ctx.args
-
-    def invoke(self, ctx):
-        def _process_result(value):
-            if self.result_callback is not None:
-                value = ctx.invoke(self.result_callback, value, **ctx.params)
-            return value
-
-        if not ctx.protected_args:
-            # If we are invoked without command the chain flag controls
-            # how this happens.  If we are not in chain mode, the return
-            # value here is the return value of the command.
-            # If however we are in chain mode, the return value is the
-            # return value of the result processor invoked with an empty
-            # list (which means that no subcommand actually was executed).
-            if self.invoke_without_command:
-                if not self.chain:
-                    return Command.invoke(self, ctx)
-                with ctx:
-                    Command.invoke(self, ctx)
-                    return _process_result([])
-            ctx.fail("Missing command.")
-
-        # Fetch args back out
-        args = ctx.protected_args + ctx.args
-        ctx.args = []
-        ctx.protected_args = []
-
-        # If we're not in chain mode, we only allow the invocation of a
-        # single command but we also inform the current context about the
-        # name of the command to invoke.
-        if not self.chain:
-            # Make sure the context is entered so we do not clean up
-            # resources until the result processor has worked.
-            with ctx:
-                cmd_name, cmd, args = self.resolve_command(ctx, args)
-                ctx.invoked_subcommand = cmd_name
-                Command.invoke(self, ctx)
-                sub_ctx = cmd.make_context(cmd_name, args, parent=ctx)
-                with sub_ctx:
-                    return _process_result(sub_ctx.command.invoke(sub_ctx))
-
-        # In chain mode we create the contexts step by step, but after the
-        # base command has been invoked.  Because at that point we do not
-        # know the subcommands yet, the invoked subcommand attribute is
-        # set to ``*`` to inform the command that subcommands are executed
-        # but nothing else.
-        with ctx:
-            ctx.invoked_subcommand = "*" if args else None
-            Command.invoke(self, ctx)
-
-            # Otherwise we make every single context and invoke them in a
-            # chain.  In that case the return value to the result processor
-            # is the list of all invoked subcommand's results.
-            contexts = []
-            while args:
-                cmd_name, cmd, args = self.resolve_command(ctx, args)
-                sub_ctx = cmd.make_context(
-                    cmd_name,
-                    args,
-                    parent=ctx,
-                    allow_extra_args=True,
-                    allow_interspersed_args=False,
-                )
-                contexts.append(sub_ctx)
-                args, sub_ctx.args = sub_ctx.args, []
-
-            rv = []
-            for sub_ctx in contexts:
-                with sub_ctx:
-                    rv.append(sub_ctx.command.invoke(sub_ctx))
-            return _process_result(rv)
-
-    def resolve_command(self, ctx, args):
-        cmd_name = make_str(args[0])
-        original_cmd_name = cmd_name
-
-        # Get the command
-        cmd = self.get_command(ctx, cmd_name)
-
-        # If we can't find the command but there is a normalization
-        # function available, we try with that one.
-        if cmd is None and ctx.token_normalize_func is not None:
-            cmd_name = ctx.token_normalize_func(cmd_name)
-            cmd = self.get_command(ctx, cmd_name)
-
-        # If we don't find the command we want to show an error message
-        # to the user that it was not provided.  However, there is
-        # something else we should do: if the first argument looks like
-        # an option we want to kick off parsing again for arguments to
-        # resolve things like --help which now should go to the main
-        # place.
-        if cmd is None and not ctx.resilient_parsing:
-            if split_opt(cmd_name)[0]:
-                self.parse_args(ctx, ctx.args)
-            ctx.fail("No such command '{}'.".format(original_cmd_name))
-
-        return cmd_name, cmd, args[1:]
-
-    def get_command(self, ctx, cmd_name):
-        """Given a context and a command name, this returns a
-        :class:`Command` object if it exists or returns `None`.
-        """
-        raise NotImplementedError()
-
-    def list_commands(self, ctx):
-        """Returns a list of subcommand names in the order they should
-        appear.
-        """
-        return []
-
-
-class Group(MultiCommand):
-    """A group allows a command to have subcommands attached.  This is the
-    most common way to implement nesting in Click.
-
-    :param commands: a dictionary of commands.
-    """
-
-    def __init__(self, name=None, commands=None, **attrs):
-        MultiCommand.__init__(self, name, **attrs)
-        #: the registered subcommands by their exported names.
-        self.commands = commands or {}
-
-    def add_command(self, cmd, name=None):
-        """Registers another :class:`Command` with this group.  If the name
-        is not provided, the name of the command is used.
-        """
-        name = name or cmd.name
-        if name is None:
-            raise TypeError("Command has no name.")
-        _check_multicommand(self, name, cmd, register=True)
-        self.commands[name] = cmd
-
-    def command(self, *args, **kwargs):
-        """A shortcut decorator for declaring and attaching a command to
-        the group.  This takes the same arguments as :func:`command` but
-        immediately registers the created command with this instance by
-        calling into :meth:`add_command`.
-        """
-        from .decorators import command
-
-        def decorator(f):
-            cmd = command(*args, **kwargs)(f)
-            self.add_command(cmd)
-            return cmd
-
-        return decorator
-
-    def group(self, *args, **kwargs):
-        """A shortcut decorator for declaring and attaching a group to
-        the group.  This takes the same arguments as :func:`group` but
-        immediately registers the created command with this instance by
-        calling into :meth:`add_command`.
-        """
-        from .decorators import group
-
-        def decorator(f):
-            cmd = group(*args, **kwargs)(f)
-            self.add_command(cmd)
-            return cmd
-
-        return decorator
-
-    def get_command(self, ctx, cmd_name):
-        return self.commands.get(cmd_name)
-
-    def list_commands(self, ctx):
-        return sorted(self.commands)
-
-
-class CommandCollection(MultiCommand):
-    """A command collection is a multi command that merges multiple multi
-    commands together into one.  This is a straightforward implementation
-    that accepts a list of different multi commands as sources and
-    provides all the commands for each of them.
-    """
-
-    def __init__(self, name=None, sources=None, **attrs):
-        MultiCommand.__init__(self, name, **attrs)
-        #: The list of registered multi commands.
-        self.sources = sources or []
-
-    def add_source(self, multi_cmd):
-        """Adds a new multi command to the chain dispatcher."""
-        self.sources.append(multi_cmd)
-
-    def get_command(self, ctx, cmd_name):
-        for source in self.sources:
-            rv = source.get_command(ctx, cmd_name)
-            if rv is not None:
-                if self.chain:
-                    _check_multicommand(self, cmd_name, rv)
-                return rv
-
-    def list_commands(self, ctx):
-        rv = set()
-        for source in self.sources:
-            rv.update(source.list_commands(ctx))
-        return sorted(rv)
-
-
-class Parameter(object):
-    r"""A parameter to a command comes in two versions: they are either
-    :class:`Option`\s or :class:`Argument`\s.  Other subclasses are currently
-    not supported by design as some of the internals for parsing are
-    intentionally not finalized.
-
-    Some settings are supported by both options and arguments.
-
-    :param param_decls: the parameter declarations for this option or
-                        argument.  This is a list of flags or argument
-                        names.
-    :param type: the type that should be used.  Either a :class:`ParamType`
-                 or a Python type.  The later is converted into the former
-                 automatically if supported.
-    :param required: controls if this is optional or not.
-    :param default: the default value if omitted.  This can also be a callable,
-                    in which case it's invoked when the default is needed
-                    without any arguments.
-    :param callback: a callback that should be executed after the parameter
-                     was matched.  This is called as ``fn(ctx, param,
-                     value)`` and needs to return the value.
-    :param nargs: the number of arguments to match.  If not ``1`` the return
-                  value is a tuple instead of single value.  The default for
-                  nargs is ``1`` (except if the type is a tuple, then it's
-                  the arity of the tuple).
-    :param metavar: how the value is represented in the help page.
-    :param expose_value: if this is `True` then the value is passed onwards
-                         to the command callback and stored on the context,
-                         otherwise it's skipped.
-    :param is_eager: eager values are processed before non eager ones.  This
-                     should not be set for arguments or it will inverse the
-                     order of processing.
-    :param envvar: a string or list of strings that are environment variables
-                   that should be checked.
-
-    .. versionchanged:: 7.1
-        Empty environment variables are ignored rather than taking the
-        empty string value. This makes it possible for scripts to clear
-        variables if they can't unset them.
-
-    .. versionchanged:: 2.0
-        Changed signature for parameter callback to also be passed the
-        parameter. The old callback format will still work, but it will
-        raise a warning to give you a chance to migrate the code easier.
-    """
-    param_type_name = "parameter"
-
-    def __init__(
-        self,
-        param_decls=None,
-        type=None,
-        required=False,
-        default=None,
-        callback=None,
-        nargs=None,
-        metavar=None,
-        expose_value=True,
-        is_eager=False,
-        envvar=None,
-        autocompletion=None,
-    ):
-        self.name, self.opts, self.secondary_opts = self._parse_decls(
-            param_decls or (), expose_value
-        )
-
-        self.type = convert_type(type, default)
-
-        # Default nargs to what the type tells us if we have that
-        # information available.
-        if nargs is None:
-            if self.type.is_composite:
-                nargs = self.type.arity
-            else:
-                nargs = 1
-
-        self.required = required
-        self.callback = callback
-        self.nargs = nargs
-        self.multiple = False
-        self.expose_value = expose_value
-        self.default = default
-        self.is_eager = is_eager
-        self.metavar = metavar
-        self.envvar = envvar
-        self.autocompletion = autocompletion
-
-    def __repr__(self):
-        return "<{} {}>".format(self.__class__.__name__, self.name)
-
-    @property
-    def human_readable_name(self):
-        """Returns the human readable name of this parameter.  This is the
-        same as the name for options, but the metavar for arguments.
-        """
-        return self.name
-
-    def make_metavar(self):
-        if self.metavar is not None:
-            return self.metavar
-        metavar = self.type.get_metavar(self)
-        if metavar is None:
-            metavar = self.type.name.upper()
-        if self.nargs != 1:
-            metavar += "..."
-        return metavar
-
-    def get_default(self, ctx):
-        """Given a context variable this calculates the default value."""
-        # Otherwise go with the regular default.
-        if callable(self.default):
-            rv = self.default()
-        else:
-            rv = self.default
-        return self.type_cast_value(ctx, rv)
-
-    def add_to_parser(self, parser, ctx):
-        pass
-
-    def consume_value(self, ctx, opts):
-        value = opts.get(self.name)
-        if value is None:
-            value = self.value_from_envvar(ctx)
-        if value is None:
-            value = ctx.lookup_default(self.name)
-        return value
-
-    def type_cast_value(self, ctx, value):
-        """Given a value this runs it properly through the type system.
-        This automatically handles things like `nargs` and `multiple` as
-        well as composite types.
-        """
-        if self.type.is_composite:
-            if self.nargs <= 1:
-                raise TypeError(
-                    "Attempted to invoke composite type but nargs has"
-                    " been set to {}. This is not supported; nargs"
-                    " needs to be set to a fixed value > 1.".format(self.nargs)
-                )
-            if self.multiple:
-                return tuple(self.type(x or (), self, ctx) for x in value or ())
-            return self.type(value or (), self, ctx)
-
-        def _convert(value, level):
-            if level == 0:
-                return self.type(value, self, ctx)
-            return tuple(_convert(x, level - 1) for x in value or ())
-
-        return _convert(value, (self.nargs != 1) + bool(self.multiple))
-
-    def process_value(self, ctx, value):
-        """Given a value and context this runs the logic to convert the
-        value as necessary.
-        """
-        # If the value we were given is None we do nothing.  This way
-        # code that calls this can easily figure out if something was
-        # not provided.  Otherwise it would be converted into an empty
-        # tuple for multiple invocations which is inconvenient.
-        if value is not None:
-            return self.type_cast_value(ctx, value)
-
-    def value_is_missing(self, value):
-        if value is None:
-            return True
-        if (self.nargs != 1 or self.multiple) and value == ():
-            return True
-        return False
-
-    def full_process_value(self, ctx, value):
-        value = self.process_value(ctx, value)
-
-        if value is None and not ctx.resilient_parsing:
-            value = self.get_default(ctx)
-
-        if self.required and self.value_is_missing(value):
-            raise MissingParameter(ctx=ctx, param=self)
-
-        return value
-
-    def resolve_envvar_value(self, ctx):
-        if self.envvar is None:
-            return
-        if isinstance(self.envvar, (tuple, list)):
-            for envvar in self.envvar:
-                rv = os.environ.get(envvar)
-                if rv is not None:
-                    return rv
-        else:
-            rv = os.environ.get(self.envvar)
-
-            if rv != "":
-                return rv
-
-    def value_from_envvar(self, ctx):
-        rv = self.resolve_envvar_value(ctx)
-        if rv is not None and self.nargs != 1:
-            rv = self.type.split_envvar_value(rv)
-        return rv
-
-    def handle_parse_result(self, ctx, opts, args):
-        with augment_usage_errors(ctx, param=self):
-            value = self.consume_value(ctx, opts)
-            try:
-                value = self.full_process_value(ctx, value)
-            except Exception:
-                if not ctx.resilient_parsing:
-                    raise
-                value = None
-            if self.callback is not None:
-                try:
-                    value = invoke_param_callback(self.callback, ctx, self, value)
-                except Exception:
-                    if not ctx.resilient_parsing:
-                        raise
-
-        if self.expose_value:
-            ctx.params[self.name] = value
-        return value, args
-
-    def get_help_record(self, ctx):
-        pass
-
-    def get_usage_pieces(self, ctx):
-        return []
-
-    def get_error_hint(self, ctx):
-        """Get a stringified version of the param for use in error messages to
-        indicate which param caused the error.
-        """
-        hint_list = self.opts or [self.human_readable_name]
-        return " / ".join(repr(x) for x in hint_list)
-
-
-class Option(Parameter):
-    """Options are usually optional values on the command line and
-    have some extra features that arguments don't have.
-
-    All other parameters are passed onwards to the parameter constructor.
-
-    :param show_default: controls if the default value should be shown on the
-                         help page. Normally, defaults are not shown. If this
-                         value is a string, it shows the string instead of the
-                         value. This is particularly useful for dynamic options.
-    :param show_envvar: controls if an environment variable should be shown on
-                        the help page.  Normally, environment variables
-                        are not shown.
-    :param prompt: if set to `True` or a non empty string then the user will be
-                   prompted for input.  If set to `True` the prompt will be the
-                   option name capitalized.
-    :param confirmation_prompt: if set then the value will need to be confirmed
-                                if it was prompted for.
-    :param hide_input: if this is `True` then the input on the prompt will be
-                       hidden from the user.  This is useful for password
-                       input.
-    :param is_flag: forces this option to act as a flag.  The default is
-                    auto detection.
-    :param flag_value: which value should be used for this flag if it's
-                       enabled.  This is set to a boolean automatically if
-                       the option string contains a slash to mark two options.
-    :param multiple: if this is set to `True` then the argument is accepted
-                     multiple times and recorded.  This is similar to ``nargs``
-                     in how it works but supports arbitrary number of
-                     arguments.
-    :param count: this flag makes an option increment an integer.
-    :param allow_from_autoenv: if this is enabled then the value of this
-                               parameter will be pulled from an environment
-                               variable in case a prefix is defined on the
-                               context.
-    :param help: the help string.
-    :param hidden: hide this option from help outputs.
-    """
-
-    param_type_name = "option"
-
-    def __init__(
-        self,
-        param_decls=None,
-        show_default=False,
-        prompt=False,
-        confirmation_prompt=False,
-        hide_input=False,
-        is_flag=None,
-        flag_value=None,
-        multiple=False,
-        count=False,
-        allow_from_autoenv=True,
-        type=None,
-        help=None,
-        hidden=False,
-        show_choices=True,
-        show_envvar=False,
-        **attrs
-    ):
-        default_is_missing = attrs.get("default", _missing) is _missing
-        Parameter.__init__(self, param_decls, type=type, **attrs)
-
-        if prompt is True:
-            prompt_text = self.name.replace("_", " ").capitalize()
-        elif prompt is False:
-            prompt_text = None
-        else:
-            prompt_text = prompt
-        self.prompt = prompt_text
-        self.confirmation_prompt = confirmation_prompt
-        self.hide_input = hide_input
-        self.hidden = hidden
-
-        # Flags
-        if is_flag is None:
-            if flag_value is not None:
-                is_flag = True
-            else:
-                is_flag = bool(self.secondary_opts)
-        if is_flag and default_is_missing:
-            self.default = False
-        if flag_value is None:
-            flag_value = not self.default
-        self.is_flag = is_flag
-        self.flag_value = flag_value
-        if self.is_flag and isinstance(self.flag_value, bool) and type in [None, bool]:
-            self.type = BOOL
-            self.is_bool_flag = True
-        else:
-            self.is_bool_flag = False
-
-        # Counting
-        self.count = count
-        if count:
-            if type is None:
-                self.type = IntRange(min=0)
-            if default_is_missing:
-                self.default = 0
-
-        self.multiple = multiple
-        self.allow_from_autoenv = allow_from_autoenv
-        self.help = help
-        self.show_default = show_default
-        self.show_choices = show_choices
-        self.show_envvar = show_envvar
-
-        # Sanity check for stuff we don't support
-        if __debug__:
-            if self.nargs < 0:
-                raise TypeError("Options cannot have nargs < 0")
-            if self.prompt and self.is_flag and not self.is_bool_flag:
-                raise TypeError("Cannot prompt for flags that are not bools.")
-            if not self.is_bool_flag and self.secondary_opts:
-                raise TypeError("Got secondary option for non boolean flag.")
-            if self.is_bool_flag and self.hide_input and self.prompt is not None:
-                raise TypeError("Hidden input does not work with boolean flag prompts.")
-            if self.count:
-                if self.multiple:
-                    raise TypeError(
-                        "Options cannot be multiple and count at the same time."
-                    )
-                elif self.is_flag:
-                    raise TypeError(
-                        "Options cannot be count and flags at the same time."
-                    )
-
-    def _parse_decls(self, decls, expose_value):
-        opts = []
-        secondary_opts = []
-        name = None
-        possible_names = []
-
-        for decl in decls:
-            if isidentifier(decl):
-                if name is not None:
-                    raise TypeError("Name defined twice")
-                name = decl
-            else:
-                split_char = ";" if decl[:1] == "/" else "/"
-                if split_char in decl:
-                    first, second = decl.split(split_char, 1)
-                    first = first.rstrip()
-                    if first:
-                        possible_names.append(split_opt(first))
-                        opts.append(first)
-                    second = second.lstrip()
-                    if second:
-                        secondary_opts.append(second.lstrip())
-                else:
-                    possible_names.append(split_opt(decl))
-                    opts.append(decl)
-
-        if name is None and possible_names:
-            possible_names.sort(key=lambda x: -len(x[0]))  # group long options first
-            name = possible_names[0][1].replace("-", "_").lower()
-            if not isidentifier(name):
-                name = None
-
-        if name is None:
-            if not expose_value:
-                return None, opts, secondary_opts
-            raise TypeError("Could not determine name for option")
-
-        if not opts and not secondary_opts:
-            raise TypeError(
-                "No options defined but a name was passed ({}). Did you"
-                " mean to declare an argument instead of an option?".format(name)
-            )
-
-        return name, opts, secondary_opts
-
-    def add_to_parser(self, parser, ctx):
-        kwargs = {
-            "dest": self.name,
-            "nargs": self.nargs,
-            "obj": self,
-        }
-
-        if self.multiple:
-            action = "append"
-        elif self.count:
-            action = "count"
-        else:
-            action = "store"
-
-        if self.is_flag:
-            kwargs.pop("nargs", None)
-            action_const = "{}_const".format(action)
-            if self.is_bool_flag and self.secondary_opts:
-                parser.add_option(self.opts, action=action_const, const=True, **kwargs)
-                parser.add_option(
-                    self.secondary_opts, action=action_const, const=False, **kwargs
-                )
-            else:
-                parser.add_option(
-                    self.opts, action=action_const, const=self.flag_value, **kwargs
-                )
-        else:
-            kwargs["action"] = action
-            parser.add_option(self.opts, **kwargs)
-
-    def get_help_record(self, ctx):
-        if self.hidden:
-            return
-        any_prefix_is_slash = []
-
-        def _write_opts(opts):
-            rv, any_slashes = join_options(opts)
-            if any_slashes:
-                any_prefix_is_slash[:] = [True]
-            if not self.is_flag and not self.count:
-                rv += " {}".format(self.make_metavar())
-            return rv
-
-        rv = [_write_opts(self.opts)]
-        if self.secondary_opts:
-            rv.append(_write_opts(self.secondary_opts))
-
-        help = self.help or ""
-        extra = []
-        if self.show_envvar:
-            envvar = self.envvar
-            if envvar is None:
-                if self.allow_from_autoenv and ctx.auto_envvar_prefix is not None:
-                    envvar = "{}_{}".format(ctx.auto_envvar_prefix, self.name.upper())
-            if envvar is not None:
-                extra.append(
-                    "env var: {}".format(
-                        ", ".join(str(d) for d in envvar)
-                        if isinstance(envvar, (list, tuple))
-                        else envvar
-                    )
-                )
-        if self.default is not None and (self.show_default or ctx.show_default):
-            if isinstance(self.show_default, string_types):
-                default_string = "({})".format(self.show_default)
-            elif isinstance(self.default, (list, tuple)):
-                default_string = ", ".join(str(d) for d in self.default)
-            elif inspect.isfunction(self.default):
-                default_string = "(dynamic)"
-            else:
-                default_string = self.default
-            extra.append("default: {}".format(default_string))
-
-        if self.required:
-            extra.append("required")
-        if extra:
-            help = "{}[{}]".format(
-                "{}  ".format(help) if help else "", "; ".join(extra)
-            )
-
-        return ("; " if any_prefix_is_slash else " / ").join(rv), help
-
-    def get_default(self, ctx):
-        # If we're a non boolean flag our default is more complex because
-        # we need to look at all flags in the same group to figure out
-        # if we're the the default one in which case we return the flag
-        # value as default.
-        if self.is_flag and not self.is_bool_flag:
-            for param in ctx.command.params:
-                if param.name == self.name and param.default:
-                    return param.flag_value
-            return None
-        return Parameter.get_default(self, ctx)
-
-    def prompt_for_value(self, ctx):
-        """This is an alternative flow that can be activated in the full
-        value processing if a value does not exist.  It will prompt the
-        user until a valid value exists and then returns the processed
-        value as result.
-        """
-        # Calculate the default before prompting anything to be stable.
-        default = self.get_default(ctx)
-
-        # If this is a prompt for a flag we need to handle this
-        # differently.
-        if self.is_bool_flag:
-            return confirm(self.prompt, default)
-
-        return prompt(
-            self.prompt,
-            default=default,
-            type=self.type,
-            hide_input=self.hide_input,
-            show_choices=self.show_choices,
-            confirmation_prompt=self.confirmation_prompt,
-            value_proc=lambda x: self.process_value(ctx, x),
-        )
-
-    def resolve_envvar_value(self, ctx):
-        rv = Parameter.resolve_envvar_value(self, ctx)
-        if rv is not None:
-            return rv
-        if self.allow_from_autoenv and ctx.auto_envvar_prefix is not None:
-            envvar = "{}_{}".format(ctx.auto_envvar_prefix, self.name.upper())
-            return os.environ.get(envvar)
-
-    def value_from_envvar(self, ctx):
-        rv = self.resolve_envvar_value(ctx)
-        if rv is None:
-            return None
-        value_depth = (self.nargs != 1) + bool(self.multiple)
-        if value_depth > 0 and rv is not None:
-            rv = self.type.split_envvar_value(rv)
-            if self.multiple and self.nargs != 1:
-                rv = batch(rv, self.nargs)
-        return rv
-
-    def full_process_value(self, ctx, value):
-        if value is None and self.prompt is not None and not ctx.resilient_parsing:
-            return self.prompt_for_value(ctx)
-        return Parameter.full_process_value(self, ctx, value)
-
-
-class Argument(Parameter):
-    """Arguments are positional parameters to a command.  They generally
-    provide fewer features than options but can have infinite ``nargs``
-    and are required by default.
-
-    All parameters are passed onwards to the parameter constructor.
-    """
-
-    param_type_name = "argument"
-
-    def __init__(self, param_decls, required=None, **attrs):
-        if required is None:
-            if attrs.get("default") is not None:
-                required = False
-            else:
-                required = attrs.get("nargs", 1) > 0
-        Parameter.__init__(self, param_decls, required=required, **attrs)
-        if self.default is not None and self.nargs < 0:
-            raise TypeError(
-                "nargs=-1 in combination with a default value is not supported."
-            )
-
-    @property
-    def human_readable_name(self):
-        if self.metavar is not None:
-            return self.metavar
-        return self.name.upper()
-
-    def make_metavar(self):
-        if self.metavar is not None:
-            return self.metavar
-        var = self.type.get_metavar(self)
-        if not var:
-            var = self.name.upper()
-        if not self.required:
-            var = "[{}]".format(var)
-        if self.nargs != 1:
-            var += "..."
-        return var
-
-    def _parse_decls(self, decls, expose_value):
-        if not decls:
-            if not expose_value:
-                return None, [], []
-            raise TypeError("Could not determine name for argument")
-        if len(decls) == 1:
-            name = arg = decls[0]
-            name = name.replace("-", "_").lower()
-        else:
-            raise TypeError(
-                "Arguments take exactly one parameter declaration, got"
-                " {}".format(len(decls))
-            )
-        return name, [arg], []
-
-    def get_usage_pieces(self, ctx):
-        return [self.make_metavar()]
-
-    def get_error_hint(self, ctx):
-        return repr(self.make_metavar())
-
-    def add_to_parser(self, parser, ctx):
-        parser.add_argument(dest=self.name, nargs=self.nargs, obj=self)
diff --git a/Flaskserver/venv/Lib/site-packages/click/decorators.py b/Flaskserver/venv/Lib/site-packages/click/decorators.py
deleted file mode 100644
index c7b5af6cc57fd7e120a1537fa4bf3906b16a24dd..0000000000000000000000000000000000000000
--- a/Flaskserver/venv/Lib/site-packages/click/decorators.py
+++ /dev/null
@@ -1,333 +0,0 @@
-import inspect
-import sys
-from functools import update_wrapper
-
-from ._compat import iteritems
-from ._unicodefun import _check_for_unicode_literals
-from .core import Argument
-from .core import Command
-from .core import Group
-from .core import Option
-from .globals import get_current_context
-from .utils import echo
-
-
-def pass_context(f):
-    """Marks a callback as wanting to receive the current context
-    object as first argument.
-    """
-
-    def new_func(*args, **kwargs):
-        return f(get_current_context(), *args, **kwargs)
-
-    return update_wrapper(new_func, f)
-
-
-def pass_obj(f):
-    """Similar to :func:`pass_context`, but only pass the object on the
-    context onwards (:attr:`Context.obj`).  This is useful if that object
-    represents the state of a nested system.
-    """
-
-    def new_func(*args, **kwargs):
-        return f(get_current_context().obj, *args, **kwargs)
-
-    return update_wrapper(new_func, f)
-
-
-def make_pass_decorator(object_type, ensure=False):
-    """Given an object type this creates a decorator that will work
-    similar to :func:`pass_obj` but instead of passing the object of the
-    current context, it will find the innermost context of type
-    :func:`object_type`.
-
-    This generates a decorator that works roughly like this::
-
-        from functools import update_wrapper
-
-        def decorator(f):
-            @pass_context
-            def new_func(ctx, *args, **kwargs):
-                obj = ctx.find_object(object_type)
-                return ctx.invoke(f, obj, *args, **kwargs)
-            return update_wrapper(new_func, f)
-        return decorator
-
-    :param object_type: the type of the object to pass.
-    :param ensure: if set to `True`, a new object will be created and
-                   remembered on the context if it's not there yet.
-    """
-
-    def decorator(f):
-        def new_func(*args, **kwargs):
-            ctx = get_current_context()
-            if ensure:
-                obj = ctx.ensure_object(object_type)
-            else:
-                obj = ctx.find_object(object_type)
-            if obj is None:
-                raise RuntimeError(
-                    "Managed to invoke callback without a context"
-                    " object of type '{}' existing".format(object_type.__name__)
-                )
-            return ctx.invoke(f, obj, *args, **kwargs)
-
-        return update_wrapper(new_func, f)
-
-    return decorator
-
-
-def _make_command(f, name, attrs, cls):
-    if isinstance(f, Command):
-        raise TypeError("Attempted to convert a callback into a command twice.")
-    try:
-        params = f.__click_params__
-        params.reverse()
-        del f.__click_params__
-    except AttributeError:
-        params = []
-    help = attrs.get("help")
-    if help is None:
-        help = inspect.getdoc(f)
-        if isinstance(help, bytes):
-            help = help.decode("utf-8")
-    else:
-        help = inspect.cleandoc(help)
-    attrs["help"] = help
-    _check_for_unicode_literals()
-    return cls(
-        name=name or f.__name__.lower().replace("_", "-"),
-        callback=f,
-        params=params,
-        **attrs
-    )
-
-
-def command(name=None, cls=None, **attrs):
-    r"""Creates a new :class:`Command` and uses the decorated function as
-    callback.  This will also automatically attach all decorated
-    :func:`option`\s and :func:`argument`\s as parameters to the command.
-
-    The name of the command defaults to the name of the function with
-    underscores replaced by dashes.  If you want to change that, you can
-    pass the intended name as the first argument.
-
-    All keyword arguments are forwarded to the underlying command class.
-
-    Once decorated the function turns into a :class:`Command` instance
-    that can be invoked as a command line utility or be attached to a
-    command :class:`Group`.
-
-    :param name: the name of the command.  This defaults to the function
-                 name with underscores replaced by dashes.
-    :param cls: the command class to instantiate.  This defaults to
-                :class:`Command`.
-    """
-    if cls is None:
-        cls = Command
-
-    def decorator(f):
-        cmd = _make_command(f, name, attrs, cls)
-        cmd.__doc__ = f.__doc__
-        return cmd
-
-    return decorator
-
-
-def group(name=None, **attrs):
-    """Creates a new :class:`Group` with a function as callback.  This
-    works otherwise the same as :func:`command` just that the `cls`
-    parameter is set to :class:`Group`.
-    """
-    attrs.setdefault("cls", Group)
-    return command(name, **attrs)
-
-
-def _param_memo(f, param):
-    if isinstance(f, Command):
-        f.params.append(param)
-    else:
-        if not hasattr(f, "__click_params__"):
-            f.__click_params__ = []
-        f.__click_params__.append(param)
-
-
-def argument(*param_decls, **attrs):
-    """Attaches an argument to the command.  All positional arguments are
-    passed as parameter declarations to :class:`Argument`; all keyword
-    arguments are forwarded unchanged (except ``cls``).
-    This is equivalent to creating an :class:`Argument` instance manually
-    and attaching it to the :attr:`Command.params` list.
-
-    :param cls: the argument class to instantiate.  This defaults to
-                :class:`Argument`.
-    """
-
-    def decorator(f):
-        ArgumentClass = attrs.pop("cls", Argument)
-        _param_memo(f, ArgumentClass(param_decls, **attrs))
-        return f
-
-    return decorator
-
-
-def option(*param_decls, **attrs):
-    """Attaches an option to the command.  All positional arguments are
-    passed as parameter declarations to :class:`Option`; all keyword
-    arguments are forwarded unchanged (except ``cls``).
-    This is equivalent to creating an :class:`Option` instance manually
-    and attaching it to the :attr:`Command.params` list.
-
-    :param cls: the option class to instantiate.  This defaults to
-                :class:`Option`.
-    """
-
-    def decorator(f):
-        # Issue 926, copy attrs, so pre-defined options can re-use the same cls=
-        option_attrs = attrs.copy()
-
-        if "help" in option_attrs:
-            option_attrs["help"] = inspect.cleandoc(option_attrs["help"])
-        OptionClass = option_attrs.pop("cls", Option)
-        _param_memo(f, OptionClass(param_decls, **option_attrs))
-        return f
-
-    return decorator
-
-
-def confirmation_option(*param_decls, **attrs):
-    """Shortcut for confirmation prompts that can be ignored by passing
-    ``--yes`` as parameter.
-
-    This is equivalent to decorating a function with :func:`option` with
-    the following parameters::
-
-        def callback(ctx, param, value):
-            if not value:
-                ctx.abort()
-
-        @click.command()
-        @click.option('--yes', is_flag=True, callback=callback,
-                      expose_value=False, prompt='Do you want to continue?')
-        def dropdb():
-            pass
-    """
-
-    def decorator(f):
-        def callback(ctx, param, value):
-            if not value:
-                ctx.abort()
-
-        attrs.setdefault("is_flag", True)
-        attrs.setdefault("callback", callback)
-        attrs.setdefault("expose_value", False)
-        attrs.setdefault("prompt", "Do you want to continue?")
-        attrs.setdefault("help", "Confirm the action without prompting.")
-        return option(*(param_decls or ("--yes",)), **attrs)(f)
-
-    return decorator
-
-
-def password_option(*param_decls, **attrs):
-    """Shortcut for password prompts.
-
-    This is equivalent to decorating a function with :func:`option` with
-    the following parameters::
-
-        @click.command()
-        @click.option('--password', prompt=True, confirmation_prompt=True,
-                      hide_input=True)
-        def changeadmin(password):
-            pass
-    """
-
-    def decorator(f):
-        attrs.setdefault("prompt", True)
-        attrs.setdefault("confirmation_prompt", True)
-        attrs.setdefault("hide_input", True)
-        return option(*(param_decls or ("--password",)), **attrs)(f)
-
-    return decorator
-
-
-def version_option(version=None, *param_decls, **attrs):
-    """Adds a ``--version`` option which immediately ends the program
-    printing out the version number.  This is implemented as an eager
-    option that prints the version and exits the program in the callback.
-
-    :param version: the version number to show.  If not provided Click
-                    attempts an auto discovery via setuptools.
-    :param prog_name: the name of the program (defaults to autodetection)
-    :param message: custom message to show instead of the default
-                    (``'%(prog)s, version %(version)s'``)
-    :param others: everything else is forwarded to :func:`option`.
-    """
-    if version is None:
-        if hasattr(sys, "_getframe"):
-            module = sys._getframe(1).f_globals.get("__name__")
-        else:
-            module = ""
-
-    def decorator(f):
-        prog_name = attrs.pop("prog_name", None)
-        message = attrs.pop("message", "%(prog)s, version %(version)s")
-
-        def callback(ctx, param, value):
-            if not value or ctx.resilient_parsing:
-                return
-            prog = prog_name
-            if prog is None:
-                prog = ctx.find_root().info_name
-            ver = version
-            if ver is None:
-                try:
-                    import pkg_resources
-                except ImportError:
-                    pass
-                else:
-                    for dist in pkg_resources.working_set:
-                        scripts = dist.get_entry_map().get("console_scripts") or {}
-                        for _, entry_point in iteritems(scripts):
-                            if entry_point.module_name == module:
-                                ver = dist.version
-                                break
-                if ver is None:
-                    raise RuntimeError("Could not determine version")
-            echo(message % {"prog": prog, "version": ver}, color=ctx.color)
-            ctx.exit()
-
-        attrs.setdefault("is_flag", True)
-        attrs.setdefault("expose_value", False)
-        attrs.setdefault("is_eager", True)
-        attrs.setdefault("help", "Show the version and exit.")
-        attrs["callback"] = callback
-        return option(*(param_decls or ("--version",)), **attrs)(f)
-
-    return decorator
-
-
-def help_option(*param_decls, **attrs):
-    """Adds a ``--help`` option which immediately ends the program
-    printing out the help page.  This is usually unnecessary to add as
-    this is added by default to all commands unless suppressed.
-
-    Like :func:`version_option`, this is implemented as eager option that
-    prints in the callback and exits.
-
-    All arguments are forwarded to :func:`option`.
-    """
-
-    def decorator(f):
-        def callback(ctx, param, value):
-            if value and not ctx.resilient_parsing:
-                echo(ctx.get_help(), color=ctx.color)
-                ctx.exit()
-
-        attrs.setdefault("is_flag", True)
-        attrs.setdefault("expose_value", False)
-        attrs.setdefault("help", "Show this message and exit.")
-        attrs.setdefault("is_eager", True)
-        attrs["callback"] = callback
-        return option(*(param_decls or ("--help",)), **attrs)(f)
-
-    return decorator
diff --git a/Flaskserver/venv/Lib/site-packages/click/exceptions.py b/Flaskserver/venv/Lib/site-packages/click/exceptions.py
deleted file mode 100644
index 592ee38f0dec509dceadded39aa7f1684d853ff4..0000000000000000000000000000000000000000
--- a/Flaskserver/venv/Lib/site-packages/click/exceptions.py
+++ /dev/null
@@ -1,253 +0,0 @@
-from ._compat import filename_to_ui
-from ._compat import get_text_stderr
-from ._compat import PY2
-from .utils import echo
-
-
-def _join_param_hints(param_hint):
-    if isinstance(param_hint, (tuple, list)):
-        return " / ".join(repr(x) for x in param_hint)
-    return param_hint
-
-
-class ClickException(Exception):
-    """An exception that Click can handle and show to the user."""
-
-    #: The exit code for this exception
-    exit_code = 1
-
-    def __init__(self, message):
-        ctor_msg = message
-        if PY2:
-            if ctor_msg is not None:
-                ctor_msg = ctor_msg.encode("utf-8")
-        Exception.__init__(self, ctor_msg)
-        self.message = message
-
-    def format_message(self):
-        return self.message
-
-    def __str__(self):
-        return self.message
-
-    if PY2:
-        __unicode__ = __str__
-
-        def __str__(self):
-            return self.message.encode("utf-8")
-
-    def show(self, file=None):
-        if file is None:
-            file = get_text_stderr()
-        echo("Error: {}".format(self.format_message()), file=file)
-
-
-class UsageError(ClickException):
-    """An internal exception that signals a usage error.  This typically
-    aborts any further handling.
-
-    :param message: the error message to display.
-    :param ctx: optionally the context that caused this error.  Click will
-                fill in the context automatically in some situations.
-    """
-
-    exit_code = 2
-
-    def __init__(self, message, ctx=None):
-        ClickException.__init__(self, message)
-        self.ctx = ctx
-        self.cmd = self.ctx.command if self.ctx else None
-
-    def show(self, file=None):
-        if file is None:
-            file = get_text_stderr()
-        color = None
-        hint = ""
-        if self.cmd is not None and self.cmd.get_help_option(self.ctx) is not None:
-            hint = "Try '{} {}' for help.\n".format(
-                self.ctx.command_path, self.ctx.help_option_names[0]
-            )
-        if self.ctx is not None:
-            color = self.ctx.color
-            echo("{}\n{}".format(self.ctx.get_usage(), hint), file=file, color=color)
-        echo("Error: {}".format(self.format_message()), file=file, color=color)
-
-
-class BadParameter(UsageError):
-    """An exception that formats out a standardized error message for a
-    bad parameter.  This is useful when thrown from a callback or type as
-    Click will attach contextual information to it (for instance, which
-    parameter it is).
-
-    .. versionadded:: 2.0
-
-    :param param: the parameter object that caused this error.  This can
-                  be left out, and Click will attach this info itself
-                  if possible.
-    :param param_hint: a string that shows up as parameter name.  This
-                       can be used as alternative to `param` in cases
-                       where custom validation should happen.  If it is
-                       a string it's used as such, if it's a list then
-                       each item is quoted and separated.
-    """
-
-    def __init__(self, message, ctx=None, param=None, param_hint=None):
-        UsageError.__init__(self, message, ctx)
-        self.param = param
-        self.param_hint = param_hint
-
-    def format_message(self):
-        if self.param_hint is not None:
-            param_hint = self.param_hint
-        elif self.param is not None:
-            param_hint = self.param.get_error_hint(self.ctx)
-        else:
-            return "Invalid value: {}".format(self.message)
-        param_hint = _join_param_hints(param_hint)
-
-        return "Invalid value for {}: {}".format(param_hint, self.message)
-
-
-class MissingParameter(BadParameter):
-    """Raised if click required an option or argument but it was not
-    provided when invoking the script.
-
-    .. versionadded:: 4.0
-
-    :param param_type: a string that indicates the type of the parameter.
-                       The default is to inherit the parameter type from
-                       the given `param`.  Valid values are ``'parameter'``,
-                       ``'option'`` or ``'argument'``.
-    """
-
-    def __init__(
-        self, message=None, ctx=None, param=None, param_hint=None, param_type=None
-    ):
-        BadParameter.__init__(self, message, ctx, param, param_hint)
-        self.param_type = param_type
-
-    def format_message(self):
-        if self.param_hint is not None:
-            param_hint = self.param_hint
-        elif self.param is not None:
-            param_hint = self.param.get_error_hint(self.ctx)
-        else:
-            param_hint = None
-        param_hint = _join_param_hints(param_hint)
-
-        param_type = self.param_type
-        if param_type is None and self.param is not None:
-            param_type = self.param.param_type_name
-
-        msg = self.message
-        if self.param is not None:
-            msg_extra = self.param.type.get_missing_message(self.param)
-            if msg_extra:
-                if msg:
-                    msg += ".  {}".format(msg_extra)
-                else:
-                    msg = msg_extra
-
-        return "Missing {}{}{}{}".format(
-            param_type,
-            " {}".format(param_hint) if param_hint else "",
-            ".  " if msg else ".",
-            msg or "",
-        )
-
-    def __str__(self):
-        if self.message is None:
-            param_name = self.param.name if self.param else None
-            return "missing parameter: {}".format(param_name)
-        else:
-            return self.message
-
-    if PY2:
-        __unicode__ = __str__
-
-        def __str__(self):
-            return self.__unicode__().encode("utf-8")
-
-
-class NoSuchOption(UsageError):
-    """Raised if click attempted to handle an option that does not
-    exist.
-
-    .. versionadded:: 4.0
-    """
-
-    def __init__(self, option_name, message=None, possibilities=None, ctx=None):
-        if message is None:
-            message = "no such option: {}".format(option_name)
-        UsageError.__init__(self, message, ctx)
-        self.option_name = option_name
-        self.possibilities = possibilities
-
-    def format_message(self):
-        bits = [self.message]
-        if self.possibilities:
-            if len(self.possibilities) == 1:
-                bits.append("Did you mean {}?".format(self.possibilities[0]))
-            else:
-                possibilities = sorted(self.possibilities)
-                bits.append("(Possible options: {})".format(", ".join(possibilities)))
-        return "  ".join(bits)
-
-
-class BadOptionUsage(UsageError):
-    """Raised if an option is generally supplied but the use of the option
-    was incorrect.  This is for instance raised if the number of arguments
-    for an option is not correct.
-
-    .. versionadded:: 4.0
-
-    :param option_name: the name of the option being used incorrectly.
-    """
-
-    def __init__(self, option_name, message, ctx=None):
-        UsageError.__init__(self, message, ctx)
-        self.option_name = option_name
-
-
-class BadArgumentUsage(UsageError):
-    """Raised if an argument is generally supplied but the use of the argument
-    was incorrect.  This is for instance raised if the number of values
-    for an argument is not correct.
-
-    .. versionadded:: 6.0
-    """
-
-    def __init__(self, message, ctx=None):
-        UsageError.__init__(self, message, ctx)
-
-
-class FileError(ClickException):
-    """Raised if a file cannot be opened."""
-
-    def __init__(self, filename, hint=None):
-        ui_filename = filename_to_ui(filename)
-        if hint is None:
-            hint = "unknown error"
-        ClickException.__init__(self, hint)
-        self.ui_filename = ui_filename
-        self.filename = filename
-
-    def format_message(self):
-        return "Could not open file {}: {}".format(self.ui_filename, self.message)
-
-
-class Abort(RuntimeError):
-    """An internal signalling exception that signals Click to abort."""
-
-
-class Exit(RuntimeError):
-    """An exception that indicates that the application should exit with some
-    status code.
-
-    :param code: the status code to exit with.
-    """
-
-    __slots__ = ("exit_code",)
-
-    def __init__(self, code=0):
-        self.exit_code = code
diff --git a/Flaskserver/venv/Lib/site-packages/click/formatting.py b/Flaskserver/venv/Lib/site-packages/click/formatting.py
deleted file mode 100644
index 319c7f6163e266de1abe6f96bd4290193184ec6c..0000000000000000000000000000000000000000
--- a/Flaskserver/venv/Lib/site-packages/click/formatting.py
+++ /dev/null
@@ -1,283 +0,0 @@
-from contextlib import contextmanager
-
-from ._compat import term_len
-from .parser import split_opt
-from .termui import get_terminal_size
-
-# Can force a width.  This is used by the test system
-FORCED_WIDTH = None
-
-
-def measure_table(rows):
-    widths = {}
-    for row in rows:
-        for idx, col in enumerate(row):
-            widths[idx] = max(widths.get(idx, 0), term_len(col))
-    return tuple(y for x, y in sorted(widths.items()))
-
-
-def iter_rows(rows, col_count):
-    for row in rows:
-        row = tuple(row)
-        yield row + ("",) * (col_count - len(row))
-
-
-def wrap_text(
-    text, width=78, initial_indent="", subsequent_indent="", preserve_paragraphs=False
-):
-    """A helper function that intelligently wraps text.  By default, it
-    assumes that it operates on a single paragraph of text but if the
-    `preserve_paragraphs` parameter is provided it will intelligently
-    handle paragraphs (defined by two empty lines).
-
-    If paragraphs are handled, a paragraph can be prefixed with an empty
-    line containing the ``\\b`` character (``\\x08``) to indicate that
-    no rewrapping should happen in that block.
-
-    :param text: the text that should be rewrapped.
-    :param width: the maximum width for the text.
-    :param initial_indent: the initial indent that should be placed on the
-                           first line as a string.
-    :param subsequent_indent: the indent string that should be placed on
-                              each consecutive line.
-    :param preserve_paragraphs: if this flag is set then the wrapping will
-                                intelligently handle paragraphs.
-    """
-    from ._textwrap import TextWrapper
-
-    text = text.expandtabs()
-    wrapper = TextWrapper(
-        width,
-        initial_indent=initial_indent,
-        subsequent_indent=subsequent_indent,
-        replace_whitespace=False,
-    )
-    if not preserve_paragraphs:
-        return wrapper.fill(text)
-
-    p = []
-    buf = []
-    indent = None
-
-    def _flush_par():
-        if not buf:
-            return
-        if buf[0].strip() == "\b":
-            p.append((indent or 0, True, "\n".join(buf[1:])))
-        else:
-            p.append((indent or 0, False, " ".join(buf)))
-        del buf[:]
-
-    for line in text.splitlines():
-        if not line:
-            _flush_par()
-            indent = None
-        else:
-            if indent is None:
-                orig_len = term_len(line)
-                line = line.lstrip()
-                indent = orig_len - term_len(line)
-            buf.append(line)
-    _flush_par()
-
-    rv = []
-    for indent, raw, text in p:
-        with wrapper.extra_indent(" " * indent):
-            if raw:
-                rv.append(wrapper.indent_only(text))
-            else:
-                rv.append(wrapper.fill(text))
-
-    return "\n\n".join(rv)
-
-
-class HelpFormatter(object):
-    """This class helps with formatting text-based help pages.  It's
-    usually just needed for very special internal cases, but it's also
-    exposed so that developers can write their own fancy outputs.
-
-    At present, it always writes into memory.
-
-    :param indent_increment: the additional increment for each level.
-    :param width: the width for the text.  This defaults to the terminal
-                  width clamped to a maximum of 78.
-    """
-
-    def __init__(self, indent_increment=2, width=None, max_width=None):
-        self.indent_increment = indent_increment
-        if max_width is None:
-            max_width = 80
-        if width is None:
-            width = FORCED_WIDTH
-            if width is None:
-                width = max(min(get_terminal_size()[0], max_width) - 2, 50)
-        self.width = width
-        self.current_indent = 0
-        self.buffer = []
-
-    def write(self, string):
-        """Writes a unicode string into the internal buffer."""
-        self.buffer.append(string)
-
-    def indent(self):
-        """Increases the indentation."""
-        self.current_indent += self.indent_increment
-
-    def dedent(self):
-        """Decreases the indentation."""
-        self.current_indent -= self.indent_increment
-
-    def write_usage(self, prog, args="", prefix="Usage: "):
-        """Writes a usage line into the buffer.
-
-        :param prog: the program name.
-        :param args: whitespace separated list of arguments.
-        :param prefix: the prefix for the first line.
-        """
-        usage_prefix = "{:>{w}}{} ".format(prefix, prog, w=self.current_indent)
-        text_width = self.width - self.current_indent
-
-        if text_width >= (term_len(usage_prefix) + 20):
-            # The arguments will fit to the right of the prefix.
-            indent = " " * term_len(usage_prefix)
-            self.write(
-                wrap_text(
-                    args,
-                    text_width,
-                    initial_indent=usage_prefix,
-                    subsequent_indent=indent,
-                )
-            )
-        else:
-            # The prefix is too long, put the arguments on the next line.
-            self.write(usage_prefix)
-            self.write("\n")
-            indent = " " * (max(self.current_indent, term_len(prefix)) + 4)
-            self.write(
-                wrap_text(
-                    args, text_width, initial_indent=indent, subsequent_indent=indent
-                )
-            )
-
-        self.write("\n")
-
-    def write_heading(self, heading):
-        """Writes a heading into the buffer."""
-        self.write("{:>{w}}{}:\n".format("", heading, w=self.current_indent))
-
-    def write_paragraph(self):
-        """Writes a paragraph into the buffer."""
-        if self.buffer:
-            self.write("\n")
-
-    def write_text(self, text):
-        """Writes re-indented text into the buffer.  This rewraps and
-        preserves paragraphs.
-        """
-        text_width = max(self.width - self.current_indent, 11)
-        indent = " " * self.current_indent
-        self.write(
-            wrap_text(
-                text,
-                text_width,
-                initial_indent=indent,
-                subsequent_indent=indent,
-                preserve_paragraphs=True,
-            )
-        )
-        self.write("\n")
-
-    def write_dl(self, rows, col_max=30, col_spacing=2):
-        """Writes a definition list into the buffer.  This is how options
-        and commands are usually formatted.
-
-        :param rows: a list of two item tuples for the terms and values.
-        :param col_max: the maximum width of the first column.
-        :param col_spacing: the number of spaces between the first and
-                            second column.
-        """
-        rows = list(rows)
-        widths = measure_table(rows)
-        if len(widths) != 2:
-            raise TypeError("Expected two columns for definition list")
-
-        first_col = min(widths[0], col_max) + col_spacing
-
-        for first, second in iter_rows(rows, len(widths)):
-            self.write("{:>{w}}{}".format("", first, w=self.current_indent))
-            if not second:
-                self.write("\n")
-                continue
-            if term_len(first) <= first_col - col_spacing:
-                self.write(" " * (first_col - term_len(first)))
-            else:
-                self.write("\n")
-                self.write(" " * (first_col + self.current_indent))
-
-            text_width = max(self.width - first_col - 2, 10)
-            wrapped_text = wrap_text(second, text_width, preserve_paragraphs=True)
-            lines = wrapped_text.splitlines()
-
-            if lines:
-                self.write("{}\n".format(lines[0]))
-
-                for line in lines[1:]:
-                    self.write(
-                        "{:>{w}}{}\n".format(
-                            "", line, w=first_col + self.current_indent
-                        )
-                    )
-
-                if len(lines) > 1:
-                    # separate long help from next option
-                    self.write("\n")
-            else:
-                self.write("\n")
-
-    @contextmanager
-    def section(self, name):
-        """Helpful context manager that writes a paragraph, a heading,
-        and the indents.
-
-        :param name: the section name that is written as heading.
-        """
-        self.write_paragraph()
-        self.write_heading(name)
-        self.indent()
-        try:
-            yield
-        finally:
-            self.dedent()
-
-    @contextmanager
-    def indentation(self):
-        """A context manager that increases the indentation."""
-        self.indent()
-        try:
-            yield
-        finally:
-            self.dedent()
-
-    def getvalue(self):
-        """Returns the buffer contents."""
-        return "".join(self.buffer)
-
-
-def join_options(options):
-    """Given a list of option strings this joins them in the most appropriate
-    way and returns them in the form ``(formatted_string,
-    any_prefix_is_slash)`` where the second item in the tuple is a flag that
-    indicates if any of the option prefixes was a slash.
-    """
-    rv = []
-    any_prefix_is_slash = False
-    for opt in options:
-        prefix = split_opt(opt)[0]
-        if prefix == "/":
-            any_prefix_is_slash = True
-        rv.append((len(prefix), opt))
-
-    rv.sort(key=lambda x: x[0])
-
-    rv = ", ".join(x[1] for x in rv)
-    return rv, any_prefix_is_slash
diff --git a/Flaskserver/venv/Lib/site-packages/click/globals.py b/Flaskserver/venv/Lib/site-packages/click/globals.py
deleted file mode 100644
index 1649f9a0bfbe60ba6c386d18634cdd77eb8df600..0000000000000000000000000000000000000000
--- a/Flaskserver/venv/Lib/site-packages/click/globals.py
+++ /dev/null
@@ -1,47 +0,0 @@
-from threading import local
-
-_local = local()
-
-
-def get_current_context(silent=False):
-    """Returns the current click context.  This can be used as a way to
-    access the current context object from anywhere.  This is a more implicit
-    alternative to the :func:`pass_context` decorator.  This function is
-    primarily useful for helpers such as :func:`echo` which might be
-    interested in changing its behavior based on the current context.
-
-    To push the current context, :meth:`Context.scope` can be used.
-
-    .. versionadded:: 5.0
-
-    :param silent: if set to `True` the return value is `None` if no context
-                   is available.  The default behavior is to raise a
-                   :exc:`RuntimeError`.
-    """
-    try:
-        return _local.stack[-1]
-    except (AttributeError, IndexError):
-        if not silent:
-            raise RuntimeError("There is no active click context.")
-
-
-def push_context(ctx):
-    """Pushes a new context to the current stack."""
-    _local.__dict__.setdefault("stack", []).append(ctx)
-
-
-def pop_context():
-    """Removes the top level from the stack."""
-    _local.stack.pop()
-
-
-def resolve_color_default(color=None):
-    """"Internal helper to get the default value of the color flag.  If a
-    value is passed it's returned unchanged, otherwise it's looked up from
-    the current context.
-    """
-    if color is not None:
-        return color
-    ctx = get_current_context(silent=True)
-    if ctx is not None:
-        return ctx.color
diff --git a/Flaskserver/venv/Lib/site-packages/click/parser.py b/Flaskserver/venv/Lib/site-packages/click/parser.py
deleted file mode 100644
index f43ebfe9fc095d168da5a5cc7d024cad7d6c274f..0000000000000000000000000000000000000000
--- a/Flaskserver/venv/Lib/site-packages/click/parser.py
+++ /dev/null
@@ -1,428 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-This module started out as largely a copy paste from the stdlib's
-optparse module with the features removed that we do not need from
-optparse because we implement them in Click on a higher level (for
-instance type handling, help formatting and a lot more).
-
-The plan is to remove more and more from here over time.
-
-The reason this is a different module and not optparse from the stdlib
-is that there are differences in 2.x and 3.x about the error messages
-generated and optparse in the stdlib uses gettext for no good reason
-and might cause us issues.
-
-Click uses parts of optparse written by Gregory P. Ward and maintained
-by the Python Software Foundation. This is limited to code in parser.py.
-
-Copyright 2001-2006 Gregory P. Ward. All rights reserved.
-Copyright 2002-2006 Python Software Foundation. All rights reserved.
-"""
-import re
-from collections import deque
-
-from .exceptions import BadArgumentUsage
-from .exceptions import BadOptionUsage
-from .exceptions import NoSuchOption
-from .exceptions import UsageError
-
-
-def _unpack_args(args, nargs_spec):
-    """Given an iterable of arguments and an iterable of nargs specifications,
-    it returns a tuple with all the unpacked arguments at the first index
-    and all remaining arguments as the second.
-
-    The nargs specification is the number of arguments that should be consumed
-    or `-1` to indicate that this position should eat up all the remainders.
-
-    Missing items are filled with `None`.
-    """
-    args = deque(args)
-    nargs_spec = deque(nargs_spec)
-    rv = []
-    spos = None
-
-    def _fetch(c):
-        try:
-            if spos is None:
-                return c.popleft()
-            else:
-                return c.pop()
-        except IndexError:
-            return None
-
-    while nargs_spec:
-        nargs = _fetch(nargs_spec)
-        if nargs == 1:
-            rv.append(_fetch(args))
-        elif nargs > 1:
-            x = [_fetch(args) for _ in range(nargs)]
-            # If we're reversed, we're pulling in the arguments in reverse,
-            # so we need to turn them around.
-            if spos is not None:
-                x.reverse()
-            rv.append(tuple(x))
-        elif nargs < 0:
-            if spos is not None:
-                raise TypeError("Cannot have two nargs < 0")
-            spos = len(rv)
-            rv.append(None)
-
-    # spos is the position of the wildcard (star).  If it's not `None`,
-    # we fill it with the remainder.
-    if spos is not None:
-        rv[spos] = tuple(args)
-        args = []
-        rv[spos + 1 :] = reversed(rv[spos + 1 :])
-
-    return tuple(rv), list(args)
-
-
-def _error_opt_args(nargs, opt):
-    if nargs == 1:
-        raise BadOptionUsage(opt, "{} option requires an argument".format(opt))
-    raise BadOptionUsage(opt, "{} option requires {} arguments".format(opt, nargs))
-
-
-def split_opt(opt):
-    first = opt[:1]
-    if first.isalnum():
-        return "", opt
-    if opt[1:2] == first:
-        return opt[:2], opt[2:]
-    return first, opt[1:]
-
-
-def normalize_opt(opt, ctx):
-    if ctx is None or ctx.token_normalize_func is None:
-        return opt
-    prefix, opt = split_opt(opt)
-    return prefix + ctx.token_normalize_func(opt)
-
-
-def split_arg_string(string):
-    """Given an argument string this attempts to split it into small parts."""
-    rv = []
-    for match in re.finditer(
-        r"('([^'\\]*(?:\\.[^'\\]*)*)'|\"([^\"\\]*(?:\\.[^\"\\]*)*)\"|\S+)\s*",
-        string,
-        re.S,
-    ):
-        arg = match.group().strip()
-        if arg[:1] == arg[-1:] and arg[:1] in "\"'":
-            arg = arg[1:-1].encode("ascii", "backslashreplace").decode("unicode-escape")
-        try:
-            arg = type(string)(arg)
-        except UnicodeError:
-            pass
-        rv.append(arg)
-    return rv
-
-
-class Option(object):
-    def __init__(self, opts, dest, action=None, nargs=1, const=None, obj=None):
-        self._short_opts = []
-        self._long_opts = []
-        self.prefixes = set()
-
-        for opt in opts:
-            prefix, value = split_opt(opt)
-            if not prefix:
-                raise ValueError("Invalid start character for option ({})".format(opt))
-            self.prefixes.add(prefix[0])
-            if len(prefix) == 1 and len(value) == 1:
-                self._short_opts.append(opt)
-            else:
-                self._long_opts.append(opt)
-                self.prefixes.add(prefix)
-
-        if action is None:
-            action = "store"
-
-        self.dest = dest
-        self.action = action
-        self.nargs = nargs
-        self.const = const
-        self.obj = obj
-
-    @property
-    def takes_value(self):
-        return self.action in ("store", "append")
-
-    def process(self, value, state):
-        if self.action == "store":
-            state.opts[self.dest] = value
-        elif self.action == "store_const":
-            state.opts[self.dest] = self.const
-        elif self.action == "append":
-            state.opts.setdefault(self.dest, []).append(value)
-        elif self.action == "append_const":
-            state.opts.setdefault(self.dest, []).append(self.const)
-        elif self.action == "count":
-            state.opts[self.dest] = state.opts.get(self.dest, 0) + 1
-        else:
-            raise ValueError("unknown action '{}'".format(self.action))
-        state.order.append(self.obj)
-
-
-class Argument(object):
-    def __init__(self, dest, nargs=1, obj=None):
-        self.dest = dest
-        self.nargs = nargs
-        self.obj = obj
-
-    def process(self, value, state):
-        if self.nargs > 1:
-            holes = sum(1 for x in value if x is None)
-            if holes == len(value):
-                value = None
-            elif holes != 0:
-                raise BadArgumentUsage(
-                    "argument {} takes {} values".format(self.dest, self.nargs)
-                )
-        state.opts[self.dest] = value
-        state.order.append(self.obj)
-
-
-class ParsingState(object):
-    def __init__(self, rargs):
-        self.opts = {}
-        self.largs = []
-        self.rargs = rargs
-        self.order = []
-
-
-class OptionParser(object):
-    """The option parser is an internal class that is ultimately used to
-    parse options and arguments.  It's modelled after optparse and brings
-    a similar but vastly simplified API.  It should generally not be used
-    directly as the high level Click classes wrap it for you.
-
-    It's not nearly as extensible as optparse or argparse as it does not
-    implement features that are implemented on a higher level (such as
-    types or defaults).
-
-    :param ctx: optionally the :class:`~click.Context` where this parser
-                should go with.
-    """
-
-    def __init__(self, ctx=None):
-        #: The :class:`~click.Context` for this parser.  This might be
-        #: `None` for some advanced use cases.
-        self.ctx = ctx
-        #: This controls how the parser deals with interspersed arguments.
-        #: If this is set to `False`, the parser will stop on the first
-        #: non-option.  Click uses this to implement nested subcommands
-        #: safely.
-        self.allow_interspersed_args = True
-        #: This tells the parser how to deal with unknown options.  By
-        #: default it will error out (which is sensible), but there is a
-        #: second mode where it will ignore it and continue processing
-        #: after shifting all the unknown options into the resulting args.
-        self.ignore_unknown_options = False
-        if ctx is not None:
-            self.allow_interspersed_args = ctx.allow_interspersed_args
-            self.ignore_unknown_options = ctx.ignore_unknown_options
-        self._short_opt = {}
-        self._long_opt = {}
-        self._opt_prefixes = {"-", "--"}
-        self._args = []
-
-    def add_option(self, opts, dest, action=None, nargs=1, const=None, obj=None):
-        """Adds a new option named `dest` to the parser.  The destination
-        is not inferred (unlike with optparse) and needs to be explicitly
-        provided.  Action can be any of ``store``, ``store_const``,
-        ``append``, ``appnd_const`` or ``count``.
-
-        The `obj` can be used to identify the option in the order list
-        that is returned from the parser.
-        """
-        if obj is None:
-            obj = dest
-        opts = [normalize_opt(opt, self.ctx) for opt in opts]
-        option = Option(opts, dest, action=action, nargs=nargs, const=const, obj=obj)
-        self._opt_prefixes.update(option.prefixes)
-        for opt in option._short_opts:
-            self._short_opt[opt] = option
-        for opt in option._long_opts:
-            self._long_opt[opt] = option
-
-    def add_argument(self, dest, nargs=1, obj=None):
-        """Adds a positional argument named `dest` to the parser.
-
-        The `obj` can be used to identify the option in the order list
-        that is returned from the parser.
-        """
-        if obj is None:
-            obj = dest
-        self._args.append(Argument(dest=dest, nargs=nargs, obj=obj))
-
-    def parse_args(self, args):
-        """Parses positional arguments and returns ``(values, args, order)``
-        for the parsed options and arguments as well as the leftover
-        arguments if there are any.  The order is a list of objects as they
-        appear on the command line.  If arguments appear multiple times they
-        will be memorized multiple times as well.
-        """
-        state = ParsingState(args)
-        try:
-            self._process_args_for_options(state)
-            self._process_args_for_args(state)
-        except UsageError:
-            if self.ctx is None or not self.ctx.resilient_parsing:
-                raise
-        return state.opts, state.largs, state.order
-
-    def _process_args_for_args(self, state):
-        pargs, args = _unpack_args(
-            state.largs + state.rargs, [x.nargs for x in self._args]
-        )
-
-        for idx, arg in enumerate(self._args):
-            arg.process(pargs[idx], state)
-
-        state.largs = args
-        state.rargs = []
-
-    def _process_args_for_options(self, state):
-        while state.rargs:
-            arg = state.rargs.pop(0)
-            arglen = len(arg)
-            # Double dashes always handled explicitly regardless of what
-            # prefixes are valid.
-            if arg == "--":
-                return
-            elif arg[:1] in self._opt_prefixes and arglen > 1:
-                self._process_opts(arg, state)
-            elif self.allow_interspersed_args:
-                state.largs.append(arg)
-            else:
-                state.rargs.insert(0, arg)
-                return
-
-        # Say this is the original argument list:
-        # [arg0, arg1, ..., arg(i-1), arg(i), arg(i+1), ..., arg(N-1)]
-        #                            ^
-        # (we are about to process arg(i)).
-        #
-        # Then rargs is [arg(i), ..., arg(N-1)] and largs is a *subset* of
-        # [arg0, ..., arg(i-1)] (any options and their arguments will have
-        # been removed from largs).
-        #
-        # The while loop will usually consume 1 or more arguments per pass.
-        # If it consumes 1 (eg. arg is an option that takes no arguments),
-        # then after _process_arg() is done the situation is:
-        #
-        #   largs = subset of [arg0, ..., arg(i)]
-        #   rargs = [arg(i+1), ..., arg(N-1)]
-        #
-        # If allow_interspersed_args is false, largs will always be
-        # *empty* -- still a subset of [arg0, ..., arg(i-1)], but
-        # not a very interesting subset!
-
-    def _match_long_opt(self, opt, explicit_value, state):
-        if opt not in self._long_opt:
-            possibilities = [word for word in self._long_opt if word.startswith(opt)]
-            raise NoSuchOption(opt, possibilities=possibilities, ctx=self.ctx)
-
-        option = self._long_opt[opt]
-        if option.takes_value:
-            # At this point it's safe to modify rargs by injecting the
-            # explicit value, because no exception is raised in this
-            # branch.  This means that the inserted value will be fully
-            # consumed.
-            if explicit_value is not None:
-                state.rargs.insert(0, explicit_value)
-
-            nargs = option.nargs
-            if len(state.rargs) < nargs:
-                _error_opt_args(nargs, opt)
-            elif nargs == 1:
-                value = state.rargs.pop(0)
-            else:
-                value = tuple(state.rargs[:nargs])
-                del state.rargs[:nargs]
-
-        elif explicit_value is not None:
-            raise BadOptionUsage(opt, "{} option does not take a value".format(opt))
-
-        else:
-            value = None
-
-        option.process(value, state)
-
-    def _match_short_opt(self, arg, state):
-        stop = False
-        i = 1
-        prefix = arg[0]
-        unknown_options = []
-
-        for ch in arg[1:]:
-            opt = normalize_opt(prefix + ch, self.ctx)
-            option = self._short_opt.get(opt)
-            i += 1
-
-            if not option:
-                if self.ignore_unknown_options:
-                    unknown_options.append(ch)
-                    continue
-                raise NoSuchOption(opt, ctx=self.ctx)
-            if option.takes_value:
-                # Any characters left in arg?  Pretend they're the
-                # next arg, and stop consuming characters of arg.
-                if i < len(arg):
-                    state.rargs.insert(0, arg[i:])
-                    stop = True
-
-                nargs = option.nargs
-                if len(state.rargs) < nargs:
-                    _error_opt_args(nargs, opt)
-                elif nargs == 1:
-                    value = state.rargs.pop(0)
-                else:
-                    value = tuple(state.rargs[:nargs])
-                    del state.rargs[:nargs]
-
-            else:
-                value = None
-
-            option.process(value, state)
-
-            if stop:
-                break
-
-        # If we got any unknown options we re-combinate the string of the
-        # remaining options and re-attach the prefix, then report that
-        # to the state as new larg.  This way there is basic combinatorics
-        # that can be achieved while still ignoring unknown arguments.
-        if self.ignore_unknown_options and unknown_options:
-            state.largs.append("{}{}".format(prefix, "".join(unknown_options)))
-
-    def _process_opts(self, arg, state):
-        explicit_value = None
-        # Long option handling happens in two parts.  The first part is
-        # supporting explicitly attached values.  In any case, we will try
-        # to long match the option first.
-        if "=" in arg:
-            long_opt, explicit_value = arg.split("=", 1)
-        else:
-            long_opt = arg
-        norm_long_opt = normalize_opt(long_opt, self.ctx)
-
-        # At this point we will match the (assumed) long option through
-        # the long option matching code.  Note that this allows options
-        # like "-foo" to be matched as long options.
-        try:
-            self._match_long_opt(norm_long_opt, explicit_value, state)
-        except NoSuchOption:
-            # At this point the long option matching failed, and we need
-            # to try with short options.  However there is a special rule
-            # which says, that if we have a two character options prefix
-            # (applies to "--foo" for instance), we do not dispatch to the
-            # short option code and will instead raise the no option
-            # error.
-            if arg[:2] not in self._opt_prefixes:
-                return self._match_short_opt(arg, state)
-            if not self.ignore_unknown_options:
-                raise
-            state.largs.append(arg)
diff --git a/Flaskserver/venv/Lib/site-packages/click/termui.py b/Flaskserver/venv/Lib/site-packages/click/termui.py
deleted file mode 100644
index 02ef9e9f045cd437ce043a72e29cbc1de732e962..0000000000000000000000000000000000000000
--- a/Flaskserver/venv/Lib/site-packages/click/termui.py
+++ /dev/null
@@ -1,681 +0,0 @@
-import inspect
-import io
-import itertools
-import os
-import struct
-import sys
-
-from ._compat import DEFAULT_COLUMNS
-from ._compat import get_winterm_size
-from ._compat import isatty
-from ._compat import raw_input
-from ._compat import string_types
-from ._compat import strip_ansi
-from ._compat import text_type
-from ._compat import WIN
-from .exceptions import Abort
-from .exceptions import UsageError
-from .globals import resolve_color_default
-from .types import Choice
-from .types import convert_type
-from .types import Path
-from .utils import echo
-from .utils import LazyFile
-
-# The prompt functions to use.  The doc tools currently override these
-# functions to customize how they work.
-visible_prompt_func = raw_input
-
-_ansi_colors = {
-    "black": 30,
-    "red": 31,
-    "green": 32,
-    "yellow": 33,
-    "blue": 34,
-    "magenta": 35,
-    "cyan": 36,
-    "white": 37,
-    "reset": 39,
-    "bright_black": 90,
-    "bright_red": 91,
-    "bright_green": 92,
-    "bright_yellow": 93,
-    "bright_blue": 94,
-    "bright_magenta": 95,
-    "bright_cyan": 96,
-    "bright_white": 97,
-}
-_ansi_reset_all = "\033[0m"
-
-
-def hidden_prompt_func(prompt):
-    import getpass
-
-    return getpass.getpass(prompt)
-
-
-def _build_prompt(
-    text, suffix, show_default=False, default=None, show_choices=True, type=None
-):
-    prompt = text
-    if type is not None and show_choices and isinstance(type, Choice):
-        prompt += " ({})".format(", ".join(map(str, type.choices)))
-    if default is not None and show_default:
-        prompt = "{} [{}]".format(prompt, _format_default(default))
-    return prompt + suffix
-
-
-def _format_default(default):
-    if isinstance(default, (io.IOBase, LazyFile)) and hasattr(default, "name"):
-        return default.name
-
-    return default
-
-
-def prompt(
-    text,
-    default=None,
-    hide_input=False,
-    confirmation_prompt=False,
-    type=None,
-    value_proc=None,
-    prompt_suffix=": ",
-    show_default=True,
-    err=False,
-    show_choices=True,
-):
-    """Prompts a user for input.  This is a convenience function that can
-    be used to prompt a user for input later.
-
-    If the user aborts the input by sending a interrupt signal, this
-    function will catch it and raise a :exc:`Abort` exception.
-
-    .. versionadded:: 7.0
-       Added the show_choices parameter.
-
-    .. versionadded:: 6.0
-       Added unicode support for cmd.exe on Windows.
-
-    .. versionadded:: 4.0
-       Added the `err` parameter.
-
-    :param text: the text to show for the prompt.
-    :param default: the default value to use if no input happens.  If this
-                    is not given it will prompt until it's aborted.
-    :param hide_input: if this is set to true then the input value will
-                       be hidden.
-    :param confirmation_prompt: asks for confirmation for the value.
-    :param type: the type to use to check the value against.
-    :param value_proc: if this parameter is provided it's a function that
-                       is invoked instead of the type conversion to
-                       convert a value.
-    :param prompt_suffix: a suffix that should be added to the prompt.
-    :param show_default: shows or hides the default value in the prompt.
-    :param err: if set to true the file defaults to ``stderr`` instead of
-                ``stdout``, the same as with echo.
-    :param show_choices: Show or hide choices if the passed type is a Choice.
-                         For example if type is a Choice of either day or week,
-                         show_choices is true and text is "Group by" then the
-                         prompt will be "Group by (day, week): ".
-    """
-    result = None
-
-    def prompt_func(text):
-        f = hidden_prompt_func if hide_input else visible_prompt_func
-        try:
-            # Write the prompt separately so that we get nice
-            # coloring through colorama on Windows
-            echo(text, nl=False, err=err)
-            return f("")
-        except (KeyboardInterrupt, EOFError):
-            # getpass doesn't print a newline if the user aborts input with ^C.
-            # Allegedly this behavior is inherited from getpass(3).
-            # A doc bug has been filed at https://bugs.python.org/issue24711
-            if hide_input:
-                echo(None, err=err)
-            raise Abort()
-
-    if value_proc is None:
-        value_proc = convert_type(type, default)
-
-    prompt = _build_prompt(
-        text, prompt_suffix, show_default, default, show_choices, type
-    )
-
-    while 1:
-        while 1:
-            value = prompt_func(prompt)
-            if value:
-                break
-            elif default is not None:
-                if isinstance(value_proc, Path):
-                    # validate Path default value(exists, dir_okay etc.)
-                    value = default
-                    break
-                return default
-        try:
-            result = value_proc(value)
-        except UsageError as e:
-            echo("Error: {}".format(e.message), err=err)  # noqa: B306
-            continue
-        if not confirmation_prompt:
-            return result
-        while 1:
-            value2 = prompt_func("Repeat for confirmation: ")
-            if value2:
-                break
-        if value == value2:
-            return result
-        echo("Error: the two entered values do not match", err=err)
-
-
-def confirm(
-    text, default=False, abort=False, prompt_suffix=": ", show_default=True, err=False
-):
-    """Prompts for confirmation (yes/no question).
-
-    If the user aborts the input by sending a interrupt signal this
-    function will catch it and raise a :exc:`Abort` exception.
-
-    .. versionadded:: 4.0
-       Added the `err` parameter.
-
-    :param text: the question to ask.
-    :param default: the default for the prompt.
-    :param abort: if this is set to `True` a negative answer aborts the
-                  exception by raising :exc:`Abort`.
-    :param prompt_suffix: a suffix that should be added to the prompt.
-    :param show_default: shows or hides the default value in the prompt.
-    :param err: if set to true the file defaults to ``stderr`` instead of
-                ``stdout``, the same as with echo.
-    """
-    prompt = _build_prompt(
-        text, prompt_suffix, show_default, "Y/n" if default else "y/N"
-    )
-    while 1:
-        try:
-            # Write the prompt separately so that we get nice
-            # coloring through colorama on Windows
-            echo(prompt, nl=False, err=err)
-            value = visible_prompt_func("").lower().strip()
-        except (KeyboardInterrupt, EOFError):
-            raise Abort()
-        if value in ("y", "yes"):
-            rv = True
-        elif value in ("n", "no"):
-            rv = False
-        elif value == "":
-            rv = default
-        else:
-            echo("Error: invalid input", err=err)
-            continue
-        break
-    if abort and not rv:
-        raise Abort()
-    return rv
-
-
-def get_terminal_size():
-    """Returns the current size of the terminal as tuple in the form
-    ``(width, height)`` in columns and rows.
-    """
-    # If shutil has get_terminal_size() (Python 3.3 and later) use that
-    if sys.version_info >= (3, 3):
-        import shutil
-
-        shutil_get_terminal_size = getattr(shutil, "get_terminal_size", None)
-        if shutil_get_terminal_size:
-            sz = shutil_get_terminal_size()
-            return sz.columns, sz.lines
-
-    # We provide a sensible default for get_winterm_size() when being invoked
-    # inside a subprocess. Without this, it would not provide a useful input.
-    if get_winterm_size is not None:
-        size = get_winterm_size()
-        if size == (0, 0):
-            return (79, 24)
-        else:
-            return size
-
-    def ioctl_gwinsz(fd):
-        try:
-            import fcntl
-            import termios
-
-            cr = struct.unpack("hh", fcntl.ioctl(fd, termios.TIOCGWINSZ, "1234"))
-        except Exception:
-            return
-        return cr
-
-    cr = ioctl_gwinsz(0) or ioctl_gwinsz(1) or ioctl_gwinsz(2)
-    if not cr:
-        try:
-            fd = os.open(os.ctermid(), os.O_RDONLY)
-            try:
-                cr = ioctl_gwinsz(fd)
-            finally:
-                os.close(fd)
-        except Exception:
-            pass
-    if not cr or not cr[0] or not cr[1]:
-        cr = (os.environ.get("LINES", 25), os.environ.get("COLUMNS", DEFAULT_COLUMNS))
-    return int(cr[1]), int(cr[0])
-
-
-def echo_via_pager(text_or_generator, color=None):
-    """This function takes a text and shows it via an environment specific
-    pager on stdout.
-
-    .. versionchanged:: 3.0
-       Added the `color` flag.
-
-    :param text_or_generator: the text to page, or alternatively, a
-                              generator emitting the text to page.
-    :param color: controls if the pager supports ANSI colors or not.  The
-                  default is autodetection.
-    """
-    color = resolve_color_default(color)
-
-    if inspect.isgeneratorfunction(text_or_generator):
-        i = text_or_generator()
-    elif isinstance(text_or_generator, string_types):
-        i = [text_or_generator]
-    else:
-        i = iter(text_or_generator)
-
-    # convert every element of i to a text type if necessary
-    text_generator = (el if isinstance(el, string_types) else text_type(el) for el in i)
-
-    from ._termui_impl import pager
-
-    return pager(itertools.chain(text_generator, "\n"), color)
-
-
-def progressbar(
-    iterable=None,
-    length=None,
-    label=None,
-    show_eta=True,
-    show_percent=None,
-    show_pos=False,
-    item_show_func=None,
-    fill_char="#",
-    empty_char="-",
-    bar_template="%(label)s  [%(bar)s]  %(info)s",
-    info_sep="  ",
-    width=36,
-    file=None,
-    color=None,
-):
-    """This function creates an iterable context manager that can be used
-    to iterate over something while showing a progress bar.  It will
-    either iterate over the `iterable` or `length` items (that are counted
-    up).  While iteration happens, this function will print a rendered
-    progress bar to the given `file` (defaults to stdout) and will attempt
-    to calculate remaining time and more.  By default, this progress bar
-    will not be rendered if the file is not a terminal.
-
-    The context manager creates the progress bar.  When the context
-    manager is entered the progress bar is already created.  With every
-    iteration over the progress bar, the iterable passed to the bar is
-    advanced and the bar is updated.  When the context manager exits,
-    a newline is printed and the progress bar is finalized on screen.
-
-    Note: The progress bar is currently designed for use cases where the
-    total progress can be expected to take at least several seconds.
-    Because of this, the ProgressBar class object won't display
-    progress that is considered too fast, and progress where the time
-    between steps is less than a second.
-
-    No printing must happen or the progress bar will be unintentionally
-    destroyed.
-
-    Example usage::
-
-        with progressbar(items) as bar:
-            for item in bar:
-                do_something_with(item)
-
-    Alternatively, if no iterable is specified, one can manually update the
-    progress bar through the `update()` method instead of directly
-    iterating over the progress bar.  The update method accepts the number
-    of steps to increment the bar with::
-
-        with progressbar(length=chunks.total_bytes) as bar:
-            for chunk in chunks:
-                process_chunk(chunk)
-                bar.update(chunks.bytes)
-
-    .. versionadded:: 2.0
-
-    .. versionadded:: 4.0
-       Added the `color` parameter.  Added a `update` method to the
-       progressbar object.
-
-    :param iterable: an iterable to iterate over.  If not provided the length
-                     is required.
-    :param length: the number of items to iterate over.  By default the
-                   progressbar will attempt to ask the iterator about its
-                   length, which might or might not work.  If an iterable is
-                   also provided this parameter can be used to override the
-                   length.  If an iterable is not provided the progress bar
-                   will iterate over a range of that length.
-    :param label: the label to show next to the progress bar.
-    :param show_eta: enables or disables the estimated time display.  This is
-                     automatically disabled if the length cannot be
-                     determined.
-    :param show_percent: enables or disables the percentage display.  The
-                         default is `True` if the iterable has a length or
-                         `False` if not.
-    :param show_pos: enables or disables the absolute position display.  The
-                     default is `False`.
-    :param item_show_func: a function called with the current item which
-                           can return a string to show the current item
-                           next to the progress bar.  Note that the current
-                           item can be `None`!
-    :param fill_char: the character to use to show the filled part of the
-                      progress bar.
-    :param empty_char: the character to use to show the non-filled part of
-                       the progress bar.
-    :param bar_template: the format string to use as template for the bar.
-                         The parameters in it are ``label`` for the label,
-                         ``bar`` for the progress bar and ``info`` for the
-                         info section.
-    :param info_sep: the separator between multiple info items (eta etc.)
-    :param width: the width of the progress bar in characters, 0 means full
-                  terminal width
-    :param file: the file to write to.  If this is not a terminal then
-                 only the label is printed.
-    :param color: controls if the terminal supports ANSI colors or not.  The
-                  default is autodetection.  This is only needed if ANSI
-                  codes are included anywhere in the progress bar output
-                  which is not the case by default.
-    """
-    from ._termui_impl import ProgressBar
-
-    color = resolve_color_default(color)
-    return ProgressBar(
-        iterable=iterable,
-        length=length,
-        show_eta=show_eta,
-        show_percent=show_percent,
-        show_pos=show_pos,
-        item_show_func=item_show_func,
-        fill_char=fill_char,
-        empty_char=empty_char,
-        bar_template=bar_template,
-        info_sep=info_sep,
-        file=file,
-        label=label,
-        width=width,
-        color=color,
-    )
-
-
-def clear():
-    """Clears the terminal screen.  This will have the effect of clearing
-    the whole visible space of the terminal and moving the cursor to the
-    top left.  This does not do anything if not connected to a terminal.
-
-    .. versionadded:: 2.0
-    """
-    if not isatty(sys.stdout):
-        return
-    # If we're on Windows and we don't have colorama available, then we
-    # clear the screen by shelling out.  Otherwise we can use an escape
-    # sequence.
-    if WIN:
-        os.system("cls")
-    else:
-        sys.stdout.write("\033[2J\033[1;1H")
-
-
-def style(
-    text,
-    fg=None,
-    bg=None,
-    bold=None,
-    dim=None,
-    underline=None,
-    blink=None,
-    reverse=None,
-    reset=True,
-):
-    """Styles a text with ANSI styles and returns the new string.  By
-    default the styling is self contained which means that at the end
-    of the string a reset code is issued.  This can be prevented by
-    passing ``reset=False``.
-
-    Examples::
-
-        click.echo(click.style('Hello World!', fg='green'))
-        click.echo(click.style('ATTENTION!', blink=True))
-        click.echo(click.style('Some things', reverse=True, fg='cyan'))
-
-    Supported color names:
-
-    * ``black`` (might be a gray)
-    * ``red``
-    * ``green``
-    * ``yellow`` (might be an orange)
-    * ``blue``
-    * ``magenta``
-    * ``cyan``
-    * ``white`` (might be light gray)
-    * ``bright_black``
-    * ``bright_red``
-    * ``bright_green``
-    * ``bright_yellow``
-    * ``bright_blue``
-    * ``bright_magenta``
-    * ``bright_cyan``
-    * ``bright_white``
-    * ``reset`` (reset the color code only)
-
-    .. versionadded:: 2.0
-
-    .. versionadded:: 7.0
-       Added support for bright colors.
-
-    :param text: the string to style with ansi codes.
-    :param fg: if provided this will become the foreground color.
-    :param bg: if provided this will become the background color.
-    :param bold: if provided this will enable or disable bold mode.
-    :param dim: if provided this will enable or disable dim mode.  This is
-                badly supported.
-    :param underline: if provided this will enable or disable underline.
-    :param blink: if provided this will enable or disable blinking.
-    :param reverse: if provided this will enable or disable inverse
-                    rendering (foreground becomes background and the
-                    other way round).
-    :param reset: by default a reset-all code is added at the end of the
-                  string which means that styles do not carry over.  This
-                  can be disabled to compose styles.
-    """
-    bits = []
-    if fg:
-        try:
-            bits.append("\033[{}m".format(_ansi_colors[fg]))
-        except KeyError:
-            raise TypeError("Unknown color '{}'".format(fg))
-    if bg:
-        try:
-            bits.append("\033[{}m".format(_ansi_colors[bg] + 10))
-        except KeyError:
-            raise TypeError("Unknown color '{}'".format(bg))
-    if bold is not None:
-        bits.append("\033[{}m".format(1 if bold else 22))
-    if dim is not None:
-        bits.append("\033[{}m".format(2 if dim else 22))
-    if underline is not None:
-        bits.append("\033[{}m".format(4 if underline else 24))
-    if blink is not None:
-        bits.append("\033[{}m".format(5 if blink else 25))
-    if reverse is not None:
-        bits.append("\033[{}m".format(7 if reverse else 27))
-    bits.append(text)
-    if reset:
-        bits.append(_ansi_reset_all)
-    return "".join(bits)
-
-
-def unstyle(text):
-    """Removes ANSI styling information from a string.  Usually it's not
-    necessary to use this function as Click's echo function will
-    automatically remove styling if necessary.
-
-    .. versionadded:: 2.0
-
-    :param text: the text to remove style information from.
-    """
-    return strip_ansi(text)
-
-
-def secho(message=None, file=None, nl=True, err=False, color=None, **styles):
-    """This function combines :func:`echo` and :func:`style` into one
-    call.  As such the following two calls are the same::
-
-        click.secho('Hello World!', fg='green')
-        click.echo(click.style('Hello World!', fg='green'))
-
-    All keyword arguments are forwarded to the underlying functions
-    depending on which one they go with.
-
-    .. versionadded:: 2.0
-    """
-    if message is not None:
-        message = style(message, **styles)
-    return echo(message, file=file, nl=nl, err=err, color=color)
-
-
-def edit(
-    text=None, editor=None, env=None, require_save=True, extension=".txt", filename=None
-):
-    r"""Edits the given text in the defined editor.  If an editor is given
-    (should be the full path to the executable but the regular operating
-    system search path is used for finding the executable) it overrides
-    the detected editor.  Optionally, some environment variables can be
-    used.  If the editor is closed without changes, `None` is returned.  In
-    case a file is edited directly the return value is always `None` and
-    `require_save` and `extension` are ignored.
-
-    If the editor cannot be opened a :exc:`UsageError` is raised.
-
-    Note for Windows: to simplify cross-platform usage, the newlines are
-    automatically converted from POSIX to Windows and vice versa.  As such,
-    the message here will have ``\n`` as newline markers.
-
-    :param text: the text to edit.
-    :param editor: optionally the editor to use.  Defaults to automatic
-                   detection.
-    :param env: environment variables to forward to the editor.
-    :param require_save: if this is true, then not saving in the editor
-                         will make the return value become `None`.
-    :param extension: the extension to tell the editor about.  This defaults
-                      to `.txt` but changing this might change syntax
-                      highlighting.
-    :param filename: if provided it will edit this file instead of the
-                     provided text contents.  It will not use a temporary
-                     file as an indirection in that case.
-    """
-    from ._termui_impl import Editor
-
-    editor = Editor(
-        editor=editor, env=env, require_save=require_save, extension=extension
-    )
-    if filename is None:
-        return editor.edit(text)
-    editor.edit_file(filename)
-
-
-def launch(url, wait=False, locate=False):
-    """This function launches the given URL (or filename) in the default
-    viewer application for this file type.  If this is an executable, it
-    might launch the executable in a new session.  The return value is
-    the exit code of the launched application.  Usually, ``0`` indicates
-    success.
-
-    Examples::
-
-        click.launch('https://click.palletsprojects.com/')
-        click.launch('/my/downloaded/file', locate=True)
-
-    .. versionadded:: 2.0
-
-    :param url: URL or filename of the thing to launch.
-    :param wait: waits for the program to stop.
-    :param locate: if this is set to `True` then instead of launching the
-                   application associated with the URL it will attempt to
-                   launch a file manager with the file located.  This
-                   might have weird effects if the URL does not point to
-                   the filesystem.
-    """
-    from ._termui_impl import open_url
-
-    return open_url(url, wait=wait, locate=locate)
-
-
-# If this is provided, getchar() calls into this instead.  This is used
-# for unittesting purposes.
-_getchar = None
-
-
-def getchar(echo=False):
-    """Fetches a single character from the terminal and returns it.  This
-    will always return a unicode character and under certain rare
-    circumstances this might return more than one character.  The
-    situations which more than one character is returned is when for
-    whatever reason multiple characters end up in the terminal buffer or
-    standard input was not actually a terminal.
-
-    Note that this will always read from the terminal, even if something
-    is piped into the standard input.
-
-    Note for Windows: in rare cases when typing non-ASCII characters, this
-    function might wait for a second character and then return both at once.
-    This is because certain Unicode characters look like special-key markers.
-
-    .. versionadded:: 2.0
-
-    :param echo: if set to `True`, the character read will also show up on
-                 the terminal.  The default is to not show it.
-    """
-    f = _getchar
-    if f is None:
-        from ._termui_impl import getchar as f
-    return f(echo)
-
-
-def raw_terminal():
-    from ._termui_impl import raw_terminal as f
-
-    return f()
-
-
-def pause(info="Press any key to continue ...", err=False):
-    """This command stops execution and waits for the user to press any
-    key to continue.  This is similar to the Windows batch "pause"
-    command.  If the program is not run through a terminal, this command
-    will instead do nothing.
-
-    .. versionadded:: 2.0
-
-    .. versionadded:: 4.0
-       Added the `err` parameter.
-
-    :param info: the info string to print before pausing.
-    :param err: if set to message goes to ``stderr`` instead of
-                ``stdout``, the same as with echo.
-    """
-    if not isatty(sys.stdin) or not isatty(sys.stdout):
-        return
-    try:
-        if info:
-            echo(info, nl=False, err=err)
-        try:
-            getchar()
-        except (KeyboardInterrupt, EOFError):
-            pass
-    finally:
-        if info:
-            echo(err=err)
diff --git a/Flaskserver/venv/Lib/site-packages/click/testing.py b/Flaskserver/venv/Lib/site-packages/click/testing.py
deleted file mode 100644
index a3dba3b3014b61ca507d191e1f83488eda85cfff..0000000000000000000000000000000000000000
--- a/Flaskserver/venv/Lib/site-packages/click/testing.py
+++ /dev/null
@@ -1,382 +0,0 @@
-import contextlib
-import os
-import shlex
-import shutil
-import sys
-import tempfile
-
-from . import formatting
-from . import termui
-from . import utils
-from ._compat import iteritems
-from ._compat import PY2
-from ._compat import string_types
-
-
-if PY2:
-    from cStringIO import StringIO
-else:
-    import io
-    from ._compat import _find_binary_reader
-
-
-class EchoingStdin(object):
-    def __init__(self, input, output):
-        self._input = input
-        self._output = output
-
-    def __getattr__(self, x):
-        return getattr(self._input, x)
-
-    def _echo(self, rv):
-        self._output.write(rv)
-        return rv
-
-    def read(self, n=-1):
-        return self._echo(self._input.read(n))
-
-    def readline(self, n=-1):
-        return self._echo(self._input.readline(n))
-
-    def readlines(self):
-        return [self._echo(x) for x in self._input.readlines()]
-
-    def __iter__(self):
-        return iter(self._echo(x) for x in self._input)
-
-    def __repr__(self):
-        return repr(self._input)
-
-
-def make_input_stream(input, charset):
-    # Is already an input stream.
-    if hasattr(input, "read"):
-        if PY2:
-            return input
-        rv = _find_binary_reader(input)
-        if rv is not None:
-            return rv
-        raise TypeError("Could not find binary reader for input stream.")
-
-    if input is None:
-        input = b""
-    elif not isinstance(input, bytes):
-        input = input.encode(charset)
-    if PY2:
-        return StringIO(input)
-    return io.BytesIO(input)
-
-
-class Result(object):
-    """Holds the captured result of an invoked CLI script."""
-
-    def __init__(
-        self, runner, stdout_bytes, stderr_bytes, exit_code, exception, exc_info=None
-    ):
-        #: The runner that created the result
-        self.runner = runner
-        #: The standard output as bytes.
-        self.stdout_bytes = stdout_bytes
-        #: The standard error as bytes, or None if not available
-        self.stderr_bytes = stderr_bytes
-        #: The exit code as integer.
-        self.exit_code = exit_code
-        #: The exception that happened if one did.
-        self.exception = exception
-        #: The traceback
-        self.exc_info = exc_info
-
-    @property
-    def output(self):
-        """The (standard) output as unicode string."""
-        return self.stdout
-
-    @property
-    def stdout(self):
-        """The standard output as unicode string."""
-        return self.stdout_bytes.decode(self.runner.charset, "replace").replace(
-            "\r\n", "\n"
-        )
-
-    @property
-    def stderr(self):
-        """The standard error as unicode string."""
-        if self.stderr_bytes is None:
-            raise ValueError("stderr not separately captured")
-        return self.stderr_bytes.decode(self.runner.charset, "replace").replace(
-            "\r\n", "\n"
-        )
-
-    def __repr__(self):
-        return "<{} {}>".format(
-            type(self).__name__, repr(self.exception) if self.exception else "okay"
-        )
-
-
-class CliRunner(object):
-    """The CLI runner provides functionality to invoke a Click command line
-    script for unittesting purposes in a isolated environment.  This only
-    works in single-threaded systems without any concurrency as it changes the
-    global interpreter state.
-
-    :param charset: the character set for the input and output data.  This is
-                    UTF-8 by default and should not be changed currently as
-                    the reporting to Click only works in Python 2 properly.
-    :param env: a dictionary with environment variables for overriding.
-    :param echo_stdin: if this is set to `True`, then reading from stdin writes
-                       to stdout.  This is useful for showing examples in
-                       some circumstances.  Note that regular prompts
-                       will automatically echo the input.
-    :param mix_stderr: if this is set to `False`, then stdout and stderr are
-                       preserved as independent streams.  This is useful for
-                       Unix-philosophy apps that have predictable stdout and
-                       noisy stderr, such that each may be measured
-                       independently
-    """
-
-    def __init__(self, charset=None, env=None, echo_stdin=False, mix_stderr=True):
-        if charset is None:
-            charset = "utf-8"
-        self.charset = charset
-        self.env = env or {}
-        self.echo_stdin = echo_stdin
-        self.mix_stderr = mix_stderr
-
-    def get_default_prog_name(self, cli):
-        """Given a command object it will return the default program name
-        for it.  The default is the `name` attribute or ``"root"`` if not
-        set.
-        """
-        return cli.name or "root"
-
-    def make_env(self, overrides=None):
-        """Returns the environment overrides for invoking a script."""
-        rv = dict(self.env)
-        if overrides:
-            rv.update(overrides)
-        return rv
-
-    @contextlib.contextmanager
-    def isolation(self, input=None, env=None, color=False):
-        """A context manager that sets up the isolation for invoking of a
-        command line tool.  This sets up stdin with the given input data
-        and `os.environ` with the overrides from the given dictionary.
-        This also rebinds some internals in Click to be mocked (like the
-        prompt functionality).
-
-        This is automatically done in the :meth:`invoke` method.
-
-        .. versionadded:: 4.0
-           The ``color`` parameter was added.
-
-        :param input: the input stream to put into sys.stdin.
-        :param env: the environment overrides as dictionary.
-        :param color: whether the output should contain color codes. The
-                      application can still override this explicitly.
-        """
-        input = make_input_stream(input, self.charset)
-
-        old_stdin = sys.stdin
-        old_stdout = sys.stdout
-        old_stderr = sys.stderr
-        old_forced_width = formatting.FORCED_WIDTH
-        formatting.FORCED_WIDTH = 80
-
-        env = self.make_env(env)
-
-        if PY2:
-            bytes_output = StringIO()
-            if self.echo_stdin:
-                input = EchoingStdin(input, bytes_output)
-            sys.stdout = bytes_output
-            if not self.mix_stderr:
-                bytes_error = StringIO()
-                sys.stderr = bytes_error
-        else:
-            bytes_output = io.BytesIO()
-            if self.echo_stdin:
-                input = EchoingStdin(input, bytes_output)
-            input = io.TextIOWrapper(input, encoding=self.charset)
-            sys.stdout = io.TextIOWrapper(bytes_output, encoding=self.charset)
-            if not self.mix_stderr:
-                bytes_error = io.BytesIO()
-                sys.stderr = io.TextIOWrapper(bytes_error, encoding=self.charset)
-
-        if self.mix_stderr:
-            sys.stderr = sys.stdout
-
-        sys.stdin = input
-
-        def visible_input(prompt=None):
-            sys.stdout.write(prompt or "")
-            val = input.readline().rstrip("\r\n")
-            sys.stdout.write("{}\n".format(val))
-            sys.stdout.flush()
-            return val
-
-        def hidden_input(prompt=None):
-            sys.stdout.write("{}\n".format(prompt or ""))
-            sys.stdout.flush()
-            return input.readline().rstrip("\r\n")
-
-        def _getchar(echo):
-            char = sys.stdin.read(1)
-            if echo:
-                sys.stdout.write(char)
-                sys.stdout.flush()
-            return char
-
-        default_color = color
-
-        def should_strip_ansi(stream=None, color=None):
-            if color is None:
-                return not default_color
-            return not color
-
-        old_visible_prompt_func = termui.visible_prompt_func
-        old_hidden_prompt_func = termui.hidden_prompt_func
-        old__getchar_func = termui._getchar
-        old_should_strip_ansi = utils.should_strip_ansi
-        termui.visible_prompt_func = visible_input
-        termui.hidden_prompt_func = hidden_input
-        termui._getchar = _getchar
-        utils.should_strip_ansi = should_strip_ansi
-
-        old_env = {}
-        try:
-            for key, value in iteritems(env):
-                old_env[key] = os.environ.get(key)
-                if value is None:
-                    try:
-                        del os.environ[key]
-                    except Exception:
-                        pass
-                else:
-                    os.environ[key] = value
-            yield (bytes_output, not self.mix_stderr and bytes_error)
-        finally:
-            for key, value in iteritems(old_env):
-                if value is None:
-                    try:
-                        del os.environ[key]
-                    except Exception:
-                        pass
-                else:
-                    os.environ[key] = value
-            sys.stdout = old_stdout
-            sys.stderr = old_stderr
-            sys.stdin = old_stdin
-            termui.visible_prompt_func = old_visible_prompt_func
-            termui.hidden_prompt_func = old_hidden_prompt_func
-            termui._getchar = old__getchar_func
-            utils.should_strip_ansi = old_should_strip_ansi
-            formatting.FORCED_WIDTH = old_forced_width
-
-    def invoke(
-        self,
-        cli,
-        args=None,
-        input=None,
-        env=None,
-        catch_exceptions=True,
-        color=False,
-        **extra
-    ):
-        """Invokes a command in an isolated environment.  The arguments are
-        forwarded directly to the command line script, the `extra` keyword
-        arguments are passed to the :meth:`~clickpkg.Command.main` function of
-        the command.
-
-        This returns a :class:`Result` object.
-
-        .. versionadded:: 3.0
-           The ``catch_exceptions`` parameter was added.
-
-        .. versionchanged:: 3.0
-           The result object now has an `exc_info` attribute with the
-           traceback if available.
-
-        .. versionadded:: 4.0
-           The ``color`` parameter was added.
-
-        :param cli: the command to invoke
-        :param args: the arguments to invoke. It may be given as an iterable
-                     or a string. When given as string it will be interpreted
-                     as a Unix shell command. More details at
-                     :func:`shlex.split`.
-        :param input: the input data for `sys.stdin`.
-        :param env: the environment overrides.
-        :param catch_exceptions: Whether to catch any other exceptions than
-                                 ``SystemExit``.
-        :param extra: the keyword arguments to pass to :meth:`main`.
-        :param color: whether the output should contain color codes. The
-                      application can still override this explicitly.
-        """
-        exc_info = None
-        with self.isolation(input=input, env=env, color=color) as outstreams:
-            exception = None
-            exit_code = 0
-
-            if isinstance(args, string_types):
-                args = shlex.split(args)
-
-            try:
-                prog_name = extra.pop("prog_name")
-            except KeyError:
-                prog_name = self.get_default_prog_name(cli)
-
-            try:
-                cli.main(args=args or (), prog_name=prog_name, **extra)
-            except SystemExit as e:
-                exc_info = sys.exc_info()
-                exit_code = e.code
-                if exit_code is None:
-                    exit_code = 0
-
-                if exit_code != 0:
-                    exception = e
-
-                if not isinstance(exit_code, int):
-                    sys.stdout.write(str(exit_code))
-                    sys.stdout.write("\n")
-                    exit_code = 1
-
-            except Exception as e:
-                if not catch_exceptions:
-                    raise
-                exception = e
-                exit_code = 1
-                exc_info = sys.exc_info()
-            finally:
-                sys.stdout.flush()
-                stdout = outstreams[0].getvalue()
-                if self.mix_stderr:
-                    stderr = None
-                else:
-                    stderr = outstreams[1].getvalue()
-
-        return Result(
-            runner=self,
-            stdout_bytes=stdout,
-            stderr_bytes=stderr,
-            exit_code=exit_code,
-            exception=exception,
-            exc_info=exc_info,
-        )
-
-    @contextlib.contextmanager
-    def isolated_filesystem(self):
-        """A context manager that creates a temporary folder and changes
-        the current working directory to it for isolated filesystem tests.
-        """
-        cwd = os.getcwd()
-        t = tempfile.mkdtemp()
-        os.chdir(t)
-        try:
-            yield t
-        finally:
-            os.chdir(cwd)
-            try:
-                shutil.rmtree(t)
-            except (OSError, IOError):  # noqa: B014
-                pass
diff --git a/Flaskserver/venv/Lib/site-packages/click/types.py b/Flaskserver/venv/Lib/site-packages/click/types.py
deleted file mode 100644
index 505c39f850922af375a12b130754e9ad6fb7fd02..0000000000000000000000000000000000000000
--- a/Flaskserver/venv/Lib/site-packages/click/types.py
+++ /dev/null
@@ -1,762 +0,0 @@
-import os
-import stat
-from datetime import datetime
-
-from ._compat import _get_argv_encoding
-from ._compat import filename_to_ui
-from ._compat import get_filesystem_encoding
-from ._compat import get_streerror
-from ._compat import open_stream
-from ._compat import PY2
-from ._compat import text_type
-from .exceptions import BadParameter
-from .utils import LazyFile
-from .utils import safecall
-
-
-class ParamType(object):
-    """Helper for converting values through types.  The following is
-    necessary for a valid type:
-
-    *   it needs a name
-    *   it needs to pass through None unchanged
-    *   it needs to convert from a string
-    *   it needs to convert its result type through unchanged
-        (eg: needs to be idempotent)
-    *   it needs to be able to deal with param and context being `None`.
-        This can be the case when the object is used with prompt
-        inputs.
-    """
-
-    is_composite = False
-
-    #: the descriptive name of this type
-    name = None
-
-    #: if a list of this type is expected and the value is pulled from a
-    #: string environment variable, this is what splits it up.  `None`
-    #: means any whitespace.  For all parameters the general rule is that
-    #: whitespace splits them up.  The exception are paths and files which
-    #: are split by ``os.path.pathsep`` by default (":" on Unix and ";" on
-    #: Windows).
-    envvar_list_splitter = None
-
-    def __call__(self, value, param=None, ctx=None):
-        if value is not None:
-            return self.convert(value, param, ctx)
-
-    def get_metavar(self, param):
-        """Returns the metavar default for this param if it provides one."""
-
-    def get_missing_message(self, param):
-        """Optionally might return extra information about a missing
-        parameter.
-
-        .. versionadded:: 2.0
-        """
-
-    def convert(self, value, param, ctx):
-        """Converts the value.  This is not invoked for values that are
-        `None` (the missing value).
-        """
-        return value
-
-    def split_envvar_value(self, rv):
-        """Given a value from an environment variable this splits it up
-        into small chunks depending on the defined envvar list splitter.
-
-        If the splitter is set to `None`, which means that whitespace splits,
-        then leading and trailing whitespace is ignored.  Otherwise, leading
-        and trailing splitters usually lead to empty items being included.
-        """
-        return (rv or "").split(self.envvar_list_splitter)
-
-    def fail(self, message, param=None, ctx=None):
-        """Helper method to fail with an invalid value message."""
-        raise BadParameter(message, ctx=ctx, param=param)
-
-
-class CompositeParamType(ParamType):
-    is_composite = True
-
-    @property
-    def arity(self):
-        raise NotImplementedError()
-
-
-class FuncParamType(ParamType):
-    def __init__(self, func):
-        self.name = func.__name__
-        self.func = func
-
-    def convert(self, value, param, ctx):
-        try:
-            return self.func(value)
-        except ValueError:
-            try:
-                value = text_type(value)
-            except UnicodeError:
-                value = str(value).decode("utf-8", "replace")
-            self.fail(value, param, ctx)
-
-
-class UnprocessedParamType(ParamType):
-    name = "text"
-
-    def convert(self, value, param, ctx):
-        return value
-
-    def __repr__(self):
-        return "UNPROCESSED"
-
-
-class StringParamType(ParamType):
-    name = "text"
-
-    def convert(self, value, param, ctx):
-        if isinstance(value, bytes):
-            enc = _get_argv_encoding()
-            try:
-                value = value.decode(enc)
-            except UnicodeError:
-                fs_enc = get_filesystem_encoding()
-                if fs_enc != enc:
-                    try:
-                        value = value.decode(fs_enc)
-                    except UnicodeError:
-                        value = value.decode("utf-8", "replace")
-                else:
-                    value = value.decode("utf-8", "replace")
-            return value
-        return value
-
-    def __repr__(self):
-        return "STRING"
-
-
-class Choice(ParamType):
-    """The choice type allows a value to be checked against a fixed set
-    of supported values. All of these values have to be strings.
-
-    You should only pass a list or tuple of choices. Other iterables
-    (like generators) may lead to surprising results.
-
-    The resulting value will always be one of the originally passed choices
-    regardless of ``case_sensitive`` or any ``ctx.token_normalize_func``
-    being specified.
-
-    See :ref:`choice-opts` for an example.
-
-    :param case_sensitive: Set to false to make choices case
-        insensitive. Defaults to true.
-    """
-
-    name = "choice"
-
-    def __init__(self, choices, case_sensitive=True):
-        self.choices = choices
-        self.case_sensitive = case_sensitive
-
-    def get_metavar(self, param):
-        return "[{}]".format("|".join(self.choices))
-
-    def get_missing_message(self, param):
-        return "Choose from:\n\t{}.".format(",\n\t".join(self.choices))
-
-    def convert(self, value, param, ctx):
-        # Match through normalization and case sensitivity
-        # first do token_normalize_func, then lowercase
-        # preserve original `value` to produce an accurate message in
-        # `self.fail`
-        normed_value = value
-        normed_choices = {choice: choice for choice in self.choices}
-
-        if ctx is not None and ctx.token_normalize_func is not None:
-            normed_value = ctx.token_normalize_func(value)
-            normed_choices = {
-                ctx.token_normalize_func(normed_choice): original
-                for normed_choice, original in normed_choices.items()
-            }
-
-        if not self.case_sensitive:
-            if PY2:
-                lower = str.lower
-            else:
-                lower = str.casefold
-
-            normed_value = lower(normed_value)
-            normed_choices = {
-                lower(normed_choice): original
-                for normed_choice, original in normed_choices.items()
-            }
-
-        if normed_value in normed_choices:
-            return normed_choices[normed_value]
-
-        self.fail(
-            "invalid choice: {}. (choose from {})".format(
-                value, ", ".join(self.choices)
-            ),
-            param,
-            ctx,
-        )
-
-    def __repr__(self):
-        return "Choice('{}')".format(list(self.choices))
-
-
-class DateTime(ParamType):
-    """The DateTime type converts date strings into `datetime` objects.
-
-    The format strings which are checked are configurable, but default to some
-    common (non-timezone aware) ISO 8601 formats.
-
-    When specifying *DateTime* formats, you should only pass a list or a tuple.
-    Other iterables, like generators, may lead to surprising results.
-
-    The format strings are processed using ``datetime.strptime``, and this
-    consequently defines the format strings which are allowed.
-
-    Parsing is tried using each format, in order, and the first format which
-    parses successfully is used.
-
-    :param formats: A list or tuple of date format strings, in the order in
-                    which they should be tried. Defaults to
-                    ``'%Y-%m-%d'``, ``'%Y-%m-%dT%H:%M:%S'``,
-                    ``'%Y-%m-%d %H:%M:%S'``.
-    """
-
-    name = "datetime"
-
-    def __init__(self, formats=None):
-        self.formats = formats or ["%Y-%m-%d", "%Y-%m-%dT%H:%M:%S", "%Y-%m-%d %H:%M:%S"]
-
-    def get_metavar(self, param):
-        return "[{}]".format("|".join(self.formats))
-
-    def _try_to_convert_date(self, value, format):
-        try:
-            return datetime.strptime(value, format)
-        except ValueError:
-            return None
-
-    def convert(self, value, param, ctx):
-        # Exact match
-        for format in self.formats:
-            dtime = self._try_to_convert_date(value, format)
-            if dtime:
-                return dtime
-
-        self.fail(
-            "invalid datetime format: {}. (choose from {})".format(
-                value, ", ".join(self.formats)
-            )
-        )
-
-    def __repr__(self):
-        return "DateTime"
-
-
-class IntParamType(ParamType):
-    name = "integer"
-
-    def convert(self, value, param, ctx):
-        try:
-            return int(value)
-        except ValueError:
-            self.fail("{} is not a valid integer".format(value), param, ctx)
-
-    def __repr__(self):
-        return "INT"
-
-
-class IntRange(IntParamType):
-    """A parameter that works similar to :data:`click.INT` but restricts
-    the value to fit into a range.  The default behavior is to fail if the
-    value falls outside the range, but it can also be silently clamped
-    between the two edges.
-
-    See :ref:`ranges` for an example.
-    """
-
-    name = "integer range"
-
-    def __init__(self, min=None, max=None, clamp=False):
-        self.min = min
-        self.max = max
-        self.clamp = clamp
-
-    def convert(self, value, param, ctx):
-        rv = IntParamType.convert(self, value, param, ctx)
-        if self.clamp:
-            if self.min is not None and rv < self.min:
-                return self.min
-            if self.max is not None and rv > self.max:
-                return self.max
-        if (
-            self.min is not None
-            and rv < self.min
-            or self.max is not None
-            and rv > self.max
-        ):
-            if self.min is None:
-                self.fail(
-                    "{} is bigger than the maximum valid value {}.".format(
-                        rv, self.max
-                    ),
-                    param,
-                    ctx,
-                )
-            elif self.max is None:
-                self.fail(
-                    "{} is smaller than the minimum valid value {}.".format(
-                        rv, self.min
-                    ),
-                    param,
-                    ctx,
-                )
-            else:
-                self.fail(
-                    "{} is not in the valid range of {} to {}.".format(
-                        rv, self.min, self.max
-                    ),
-                    param,
-                    ctx,
-                )
-        return rv
-
-    def __repr__(self):
-        return "IntRange({}, {})".format(self.min, self.max)
-
-
-class FloatParamType(ParamType):
-    name = "float"
-
-    def convert(self, value, param, ctx):
-        try:
-            return float(value)
-        except ValueError:
-            self.fail(
-                "{} is not a valid floating point value".format(value), param, ctx
-            )
-
-    def __repr__(self):
-        return "FLOAT"
-
-
-class FloatRange(FloatParamType):
-    """A parameter that works similar to :data:`click.FLOAT` but restricts
-    the value to fit into a range.  The default behavior is to fail if the
-    value falls outside the range, but it can also be silently clamped
-    between the two edges.
-
-    See :ref:`ranges` for an example.
-    """
-
-    name = "float range"
-
-    def __init__(self, min=None, max=None, clamp=False):
-        self.min = min
-        self.max = max
-        self.clamp = clamp
-
-    def convert(self, value, param, ctx):
-        rv = FloatParamType.convert(self, value, param, ctx)
-        if self.clamp:
-            if self.min is not None and rv < self.min:
-                return self.min
-            if self.max is not None and rv > self.max:
-                return self.max
-        if (
-            self.min is not None
-            and rv < self.min
-            or self.max is not None
-            and rv > self.max
-        ):
-            if self.min is None:
-                self.fail(
-                    "{} is bigger than the maximum valid value {}.".format(
-                        rv, self.max
-                    ),
-                    param,
-                    ctx,
-                )
-            elif self.max is None:
-                self.fail(
-                    "{} is smaller than the minimum valid value {}.".format(
-                        rv, self.min
-                    ),
-                    param,
-                    ctx,
-                )
-            else:
-                self.fail(
-                    "{} is not in the valid range of {} to {}.".format(
-                        rv, self.min, self.max
-                    ),
-                    param,
-                    ctx,
-                )
-        return rv
-
-    def __repr__(self):
-        return "FloatRange({}, {})".format(self.min, self.max)
-
-
-class BoolParamType(ParamType):
-    name = "boolean"
-
-    def convert(self, value, param, ctx):
-        if isinstance(value, bool):
-            return bool(value)
-        value = value.lower()
-        if value in ("true", "t", "1", "yes", "y"):
-            return True
-        elif value in ("false", "f", "0", "no", "n"):
-            return False
-        self.fail("{} is not a valid boolean".format(value), param, ctx)
-
-    def __repr__(self):
-        return "BOOL"
-
-
-class UUIDParameterType(ParamType):
-    name = "uuid"
-
-    def convert(self, value, param, ctx):
-        import uuid
-
-        try:
-            if PY2 and isinstance(value, text_type):
-                value = value.encode("ascii")
-            return uuid.UUID(value)
-        except ValueError:
-            self.fail("{} is not a valid UUID value".format(value), param, ctx)
-
-    def __repr__(self):
-        return "UUID"
-
-
-class File(ParamType):
-    """Declares a parameter to be a file for reading or writing.  The file
-    is automatically closed once the context tears down (after the command
-    finished working).
-
-    Files can be opened for reading or writing.  The special value ``-``
-    indicates stdin or stdout depending on the mode.
-
-    By default, the file is opened for reading text data, but it can also be
-    opened in binary mode or for writing.  The encoding parameter can be used
-    to force a specific encoding.
-
-    The `lazy` flag controls if the file should be opened immediately or upon
-    first IO. The default is to be non-lazy for standard input and output
-    streams as well as files opened for reading, `lazy` otherwise. When opening a
-    file lazily for reading, it is still opened temporarily for validation, but
-    will not be held open until first IO. lazy is mainly useful when opening
-    for writing to avoid creating the file until it is needed.
-
-    Starting with Click 2.0, files can also be opened atomically in which
-    case all writes go into a separate file in the same folder and upon
-    completion the file will be moved over to the original location.  This
-    is useful if a file regularly read by other users is modified.
-
-    See :ref:`file-args` for more information.
-    """
-
-    name = "filename"
-    envvar_list_splitter = os.path.pathsep
-
-    def __init__(
-        self, mode="r", encoding=None, errors="strict", lazy=None, atomic=False
-    ):
-        self.mode = mode
-        self.encoding = encoding
-        self.errors = errors
-        self.lazy = lazy
-        self.atomic = atomic
-
-    def resolve_lazy_flag(self, value):
-        if self.lazy is not None:
-            return self.lazy
-        if value == "-":
-            return False
-        elif "w" in self.mode:
-            return True
-        return False
-
-    def convert(self, value, param, ctx):
-        try:
-            if hasattr(value, "read") or hasattr(value, "write"):
-                return value
-
-            lazy = self.resolve_lazy_flag(value)
-
-            if lazy:
-                f = LazyFile(
-                    value, self.mode, self.encoding, self.errors, atomic=self.atomic
-                )
-                if ctx is not None:
-                    ctx.call_on_close(f.close_intelligently)
-                return f
-
-            f, should_close = open_stream(
-                value, self.mode, self.encoding, self.errors, atomic=self.atomic
-            )
-            # If a context is provided, we automatically close the file
-            # at the end of the context execution (or flush out).  If a
-            # context does not exist, it's the caller's responsibility to
-            # properly close the file.  This for instance happens when the
-            # type is used with prompts.
-            if ctx is not None:
-                if should_close:
-                    ctx.call_on_close(safecall(f.close))
-                else:
-                    ctx.call_on_close(safecall(f.flush))
-            return f
-        except (IOError, OSError) as e:  # noqa: B014
-            self.fail(
-                "Could not open file: {}: {}".format(
-                    filename_to_ui(value), get_streerror(e)
-                ),
-                param,
-                ctx,
-            )
-
-
-class Path(ParamType):
-    """The path type is similar to the :class:`File` type but it performs
-    different checks.  First of all, instead of returning an open file
-    handle it returns just the filename.  Secondly, it can perform various
-    basic checks about what the file or directory should be.
-
-    .. versionchanged:: 6.0
-       `allow_dash` was added.
-
-    :param exists: if set to true, the file or directory needs to exist for
-                   this value to be valid.  If this is not required and a
-                   file does indeed not exist, then all further checks are
-                   silently skipped.
-    :param file_okay: controls if a file is a possible value.
-    :param dir_okay: controls if a directory is a possible value.
-    :param writable: if true, a writable check is performed.
-    :param readable: if true, a readable check is performed.
-    :param resolve_path: if this is true, then the path is fully resolved
-                         before the value is passed onwards.  This means
-                         that it's absolute and symlinks are resolved.  It
-                         will not expand a tilde-prefix, as this is
-                         supposed to be done by the shell only.
-    :param allow_dash: If this is set to `True`, a single dash to indicate
-                       standard streams is permitted.
-    :param path_type: optionally a string type that should be used to
-                      represent the path.  The default is `None` which
-                      means the return value will be either bytes or
-                      unicode depending on what makes most sense given the
-                      input data Click deals with.
-    """
-
-    envvar_list_splitter = os.path.pathsep
-
-    def __init__(
-        self,
-        exists=False,
-        file_okay=True,
-        dir_okay=True,
-        writable=False,
-        readable=True,
-        resolve_path=False,
-        allow_dash=False,
-        path_type=None,
-    ):
-        self.exists = exists
-        self.file_okay = file_okay
-        self.dir_okay = dir_okay
-        self.writable = writable
-        self.readable = readable
-        self.resolve_path = resolve_path
-        self.allow_dash = allow_dash
-        self.type = path_type
-
-        if self.file_okay and not self.dir_okay:
-            self.name = "file"
-            self.path_type = "File"
-        elif self.dir_okay and not self.file_okay:
-            self.name = "directory"
-            self.path_type = "Directory"
-        else:
-            self.name = "path"
-            self.path_type = "Path"
-
-    def coerce_path_result(self, rv):
-        if self.type is not None and not isinstance(rv, self.type):
-            if self.type is text_type:
-                rv = rv.decode(get_filesystem_encoding())
-            else:
-                rv = rv.encode(get_filesystem_encoding())
-        return rv
-
-    def convert(self, value, param, ctx):
-        rv = value
-
-        is_dash = self.file_okay and self.allow_dash and rv in (b"-", "-")
-
-        if not is_dash:
-            if self.resolve_path:
-                rv = os.path.realpath(rv)
-
-            try:
-                st = os.stat(rv)
-            except OSError:
-                if not self.exists:
-                    return self.coerce_path_result(rv)
-                self.fail(
-                    "{} '{}' does not exist.".format(
-                        self.path_type, filename_to_ui(value)
-                    ),
-                    param,
-                    ctx,
-                )
-
-            if not self.file_okay and stat.S_ISREG(st.st_mode):
-                self.fail(
-                    "{} '{}' is a file.".format(self.path_type, filename_to_ui(value)),
-                    param,
-                    ctx,
-                )
-            if not self.dir_okay and stat.S_ISDIR(st.st_mode):
-                self.fail(
-                    "{} '{}' is a directory.".format(
-                        self.path_type, filename_to_ui(value)
-                    ),
-                    param,
-                    ctx,
-                )
-            if self.writable and not os.access(value, os.W_OK):
-                self.fail(
-                    "{} '{}' is not writable.".format(
-                        self.path_type, filename_to_ui(value)
-                    ),
-                    param,
-                    ctx,
-                )
-            if self.readable and not os.access(value, os.R_OK):
-                self.fail(
-                    "{} '{}' is not readable.".format(
-                        self.path_type, filename_to_ui(value)
-                    ),
-                    param,
-                    ctx,
-                )
-
-        return self.coerce_path_result(rv)
-
-
-class Tuple(CompositeParamType):
-    """The default behavior of Click is to apply a type on a value directly.
-    This works well in most cases, except for when `nargs` is set to a fixed
-    count and different types should be used for different items.  In this
-    case the :class:`Tuple` type can be used.  This type can only be used
-    if `nargs` is set to a fixed number.
-
-    For more information see :ref:`tuple-type`.
-
-    This can be selected by using a Python tuple literal as a type.
-
-    :param types: a list of types that should be used for the tuple items.
-    """
-
-    def __init__(self, types):
-        self.types = [convert_type(ty) for ty in types]
-
-    @property
-    def name(self):
-        return "<{}>".format(" ".join(ty.name for ty in self.types))
-
-    @property
-    def arity(self):
-        return len(self.types)
-
-    def convert(self, value, param, ctx):
-        if len(value) != len(self.types):
-            raise TypeError(
-                "It would appear that nargs is set to conflict with the"
-                " composite type arity."
-            )
-        return tuple(ty(x, param, ctx) for ty, x in zip(self.types, value))
-
-
-def convert_type(ty, default=None):
-    """Converts a callable or python type into the most appropriate
-    param type.
-    """
-    guessed_type = False
-    if ty is None and default is not None:
-        if isinstance(default, tuple):
-            ty = tuple(map(type, default))
-        else:
-            ty = type(default)
-        guessed_type = True
-
-    if isinstance(ty, tuple):
-        return Tuple(ty)
-    if isinstance(ty, ParamType):
-        return ty
-    if ty is text_type or ty is str or ty is None:
-        return STRING
-    if ty is int:
-        return INT
-    # Booleans are only okay if not guessed.  This is done because for
-    # flags the default value is actually a bit of a lie in that it
-    # indicates which of the flags is the one we want.  See get_default()
-    # for more information.
-    if ty is bool and not guessed_type:
-        return BOOL
-    if ty is float:
-        return FLOAT
-    if guessed_type:
-        return STRING
-
-    # Catch a common mistake
-    if __debug__:
-        try:
-            if issubclass(ty, ParamType):
-                raise AssertionError(
-                    "Attempted to use an uninstantiated parameter type ({}).".format(ty)
-                )
-        except TypeError:
-            pass
-    return FuncParamType(ty)
-
-
-#: A dummy parameter type that just does nothing.  From a user's
-#: perspective this appears to just be the same as `STRING` but internally
-#: no string conversion takes place.  This is necessary to achieve the
-#: same bytes/unicode behavior on Python 2/3 in situations where you want
-#: to not convert argument types.  This is usually useful when working
-#: with file paths as they can appear in bytes and unicode.
-#:
-#: For path related uses the :class:`Path` type is a better choice but
-#: there are situations where an unprocessed type is useful which is why
-#: it is is provided.
-#:
-#: .. versionadded:: 4.0
-UNPROCESSED = UnprocessedParamType()
-
-#: A unicode string parameter type which is the implicit default.  This
-#: can also be selected by using ``str`` as type.
-STRING = StringParamType()
-
-#: An integer parameter.  This can also be selected by using ``int`` as
-#: type.
-INT = IntParamType()
-
-#: A floating point value parameter.  This can also be selected by using
-#: ``float`` as type.
-FLOAT = FloatParamType()
-
-#: A boolean parameter.  This is the default for boolean flags.  This can
-#: also be selected by using ``bool`` as a type.
-BOOL = BoolParamType()
-
-#: A UUID parameter.
-UUID = UUIDParameterType()
diff --git a/Flaskserver/venv/Lib/site-packages/click/utils.py b/Flaskserver/venv/Lib/site-packages/click/utils.py
deleted file mode 100644
index 79265e732d49a4ea35198565a8d1bc401e07b7ea..0000000000000000000000000000000000000000
--- a/Flaskserver/venv/Lib/site-packages/click/utils.py
+++ /dev/null
@@ -1,455 +0,0 @@
-import os
-import sys
-
-from ._compat import _default_text_stderr
-from ._compat import _default_text_stdout
-from ._compat import auto_wrap_for_ansi
-from ._compat import binary_streams
-from ._compat import filename_to_ui
-from ._compat import get_filesystem_encoding
-from ._compat import get_streerror
-from ._compat import is_bytes
-from ._compat import open_stream
-from ._compat import PY2
-from ._compat import should_strip_ansi
-from ._compat import string_types
-from ._compat import strip_ansi
-from ._compat import text_streams
-from ._compat import text_type
-from ._compat import WIN
-from .globals import resolve_color_default
-
-if not PY2:
-    from ._compat import _find_binary_writer
-elif WIN:
-    from ._winconsole import _get_windows_argv
-    from ._winconsole import _hash_py_argv
-    from ._winconsole import _initial_argv_hash
-
-echo_native_types = string_types + (bytes, bytearray)
-
-
-def _posixify(name):
-    return "-".join(name.split()).lower()
-
-
-def safecall(func):
-    """Wraps a function so that it swallows exceptions."""
-
-    def wrapper(*args, **kwargs):
-        try:
-            return func(*args, **kwargs)
-        except Exception:
-            pass
-
-    return wrapper
-
-
-def make_str(value):
-    """Converts a value into a valid string."""
-    if isinstance(value, bytes):
-        try:
-            return value.decode(get_filesystem_encoding())
-        except UnicodeError:
-            return value.decode("utf-8", "replace")
-    return text_type(value)
-
-
-def make_default_short_help(help, max_length=45):
-    """Return a condensed version of help string."""
-    words = help.split()
-    total_length = 0
-    result = []
-    done = False
-
-    for word in words:
-        if word[-1:] == ".":
-            done = True
-        new_length = 1 + len(word) if result else len(word)
-        if total_length + new_length > max_length:
-            result.append("...")
-            done = True
-        else:
-            if result:
-                result.append(" ")
-            result.append(word)
-        if done:
-            break
-        total_length += new_length
-
-    return "".join(result)
-
-
-class LazyFile(object):
-    """A lazy file works like a regular file but it does not fully open
-    the file but it does perform some basic checks early to see if the
-    filename parameter does make sense.  This is useful for safely opening
-    files for writing.
-    """
-
-    def __init__(
-        self, filename, mode="r", encoding=None, errors="strict", atomic=False
-    ):
-        self.name = filename
-        self.mode = mode
-        self.encoding = encoding
-        self.errors = errors
-        self.atomic = atomic
-
-        if filename == "-":
-            self._f, self.should_close = open_stream(filename, mode, encoding, errors)
-        else:
-            if "r" in mode:
-                # Open and close the file in case we're opening it for
-                # reading so that we can catch at least some errors in
-                # some cases early.
-                open(filename, mode).close()
-            self._f = None
-            self.should_close = True
-
-    def __getattr__(self, name):
-        return getattr(self.open(), name)
-
-    def __repr__(self):
-        if self._f is not None:
-            return repr(self._f)
-        return "<unopened file '{}' {}>".format(self.name, self.mode)
-
-    def open(self):
-        """Opens the file if it's not yet open.  This call might fail with
-        a :exc:`FileError`.  Not handling this error will produce an error
-        that Click shows.
-        """
-        if self._f is not None:
-            return self._f
-        try:
-            rv, self.should_close = open_stream(
-                self.name, self.mode, self.encoding, self.errors, atomic=self.atomic
-            )
-        except (IOError, OSError) as e:  # noqa: E402
-            from .exceptions import FileError
-
-            raise FileError(self.name, hint=get_streerror(e))
-        self._f = rv
-        return rv
-
-    def close(self):
-        """Closes the underlying file, no matter what."""
-        if self._f is not None:
-            self._f.close()
-
-    def close_intelligently(self):
-        """This function only closes the file if it was opened by the lazy
-        file wrapper.  For instance this will never close stdin.
-        """
-        if self.should_close:
-            self.close()
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, exc_type, exc_value, tb):
-        self.close_intelligently()
-
-    def __iter__(self):
-        self.open()
-        return iter(self._f)
-
-
-class KeepOpenFile(object):
-    def __init__(self, file):
-        self._file = file
-
-    def __getattr__(self, name):
-        return getattr(self._file, name)
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, exc_type, exc_value, tb):
-        pass
-
-    def __repr__(self):
-        return repr(self._file)
-
-    def __iter__(self):
-        return iter(self._file)
-
-
-def echo(message=None, file=None, nl=True, err=False, color=None):
-    """Prints a message plus a newline to the given file or stdout.  On
-    first sight, this looks like the print function, but it has improved
-    support for handling Unicode and binary data that does not fail no
-    matter how badly configured the system is.
-
-    Primarily it means that you can print binary data as well as Unicode
-    data on both 2.x and 3.x to the given file in the most appropriate way
-    possible.  This is a very carefree function in that it will try its
-    best to not fail.  As of Click 6.0 this includes support for unicode
-    output on the Windows console.
-
-    In addition to that, if `colorama`_ is installed, the echo function will
-    also support clever handling of ANSI codes.  Essentially it will then
-    do the following:
-
-    -   add transparent handling of ANSI color codes on Windows.
-    -   hide ANSI codes automatically if the destination file is not a
-        terminal.
-
-    .. _colorama: https://pypi.org/project/colorama/
-
-    .. versionchanged:: 6.0
-       As of Click 6.0 the echo function will properly support unicode
-       output on the windows console.  Not that click does not modify
-       the interpreter in any way which means that `sys.stdout` or the
-       print statement or function will still not provide unicode support.
-
-    .. versionchanged:: 2.0
-       Starting with version 2.0 of Click, the echo function will work
-       with colorama if it's installed.
-
-    .. versionadded:: 3.0
-       The `err` parameter was added.
-
-    .. versionchanged:: 4.0
-       Added the `color` flag.
-
-    :param message: the message to print
-    :param file: the file to write to (defaults to ``stdout``)
-    :param err: if set to true the file defaults to ``stderr`` instead of
-                ``stdout``.  This is faster and easier than calling
-                :func:`get_text_stderr` yourself.
-    :param nl: if set to `True` (the default) a newline is printed afterwards.
-    :param color: controls if the terminal supports ANSI colors or not.  The
-                  default is autodetection.
-    """
-    if file is None:
-        if err:
-            file = _default_text_stderr()
-        else:
-            file = _default_text_stdout()
-
-    # Convert non bytes/text into the native string type.
-    if message is not None and not isinstance(message, echo_native_types):
-        message = text_type(message)
-
-    if nl:
-        message = message or u""
-        if isinstance(message, text_type):
-            message += u"\n"
-        else:
-            message += b"\n"
-
-    # If there is a message, and we're in Python 3, and the value looks
-    # like bytes, we manually need to find the binary stream and write the
-    # message in there.  This is done separately so that most stream
-    # types will work as you would expect.  Eg: you can write to StringIO
-    # for other cases.
-    if message and not PY2 and is_bytes(message):
-        binary_file = _find_binary_writer(file)
-        if binary_file is not None:
-            file.flush()
-            binary_file.write(message)
-            binary_file.flush()
-            return
-
-    # ANSI-style support.  If there is no message or we are dealing with
-    # bytes nothing is happening.  If we are connected to a file we want
-    # to strip colors.  If we are on windows we either wrap the stream
-    # to strip the color or we use the colorama support to translate the
-    # ansi codes to API calls.
-    if message and not is_bytes(message):
-        color = resolve_color_default(color)
-        if should_strip_ansi(file, color):
-            message = strip_ansi(message)
-        elif WIN:
-            if auto_wrap_for_ansi is not None:
-                file = auto_wrap_for_ansi(file)
-            elif not color:
-                message = strip_ansi(message)
-
-    if message:
-        file.write(message)
-    file.flush()
-
-
-def get_binary_stream(name):
-    """Returns a system stream for byte processing.  This essentially
-    returns the stream from the sys module with the given name but it
-    solves some compatibility issues between different Python versions.
-    Primarily this function is necessary for getting binary streams on
-    Python 3.
-
-    :param name: the name of the stream to open.  Valid names are ``'stdin'``,
-                 ``'stdout'`` and ``'stderr'``
-    """
-    opener = binary_streams.get(name)
-    if opener is None:
-        raise TypeError("Unknown standard stream '{}'".format(name))
-    return opener()
-
-
-def get_text_stream(name, encoding=None, errors="strict"):
-    """Returns a system stream for text processing.  This usually returns
-    a wrapped stream around a binary stream returned from
-    :func:`get_binary_stream` but it also can take shortcuts on Python 3
-    for already correctly configured streams.
-
-    :param name: the name of the stream to open.  Valid names are ``'stdin'``,
-                 ``'stdout'`` and ``'stderr'``
-    :param encoding: overrides the detected default encoding.
-    :param errors: overrides the default error mode.
-    """
-    opener = text_streams.get(name)
-    if opener is None:
-        raise TypeError("Unknown standard stream '{}'".format(name))
-    return opener(encoding, errors)
-
-
-def open_file(
-    filename, mode="r", encoding=None, errors="strict", lazy=False, atomic=False
-):
-    """This is similar to how the :class:`File` works but for manual
-    usage.  Files are opened non lazy by default.  This can open regular
-    files as well as stdin/stdout if ``'-'`` is passed.
-
-    If stdin/stdout is returned the stream is wrapped so that the context
-    manager will not close the stream accidentally.  This makes it possible
-    to always use the function like this without having to worry to
-    accidentally close a standard stream::
-
-        with open_file(filename) as f:
-            ...
-
-    .. versionadded:: 3.0
-
-    :param filename: the name of the file to open (or ``'-'`` for stdin/stdout).
-    :param mode: the mode in which to open the file.
-    :param encoding: the encoding to use.
-    :param errors: the error handling for this file.
-    :param lazy: can be flipped to true to open the file lazily.
-    :param atomic: in atomic mode writes go into a temporary file and it's
-                   moved on close.
-    """
-    if lazy:
-        return LazyFile(filename, mode, encoding, errors, atomic=atomic)
-    f, should_close = open_stream(filename, mode, encoding, errors, atomic=atomic)
-    if not should_close:
-        f = KeepOpenFile(f)
-    return f
-
-
-def get_os_args():
-    """This returns the argument part of sys.argv in the most appropriate
-    form for processing.  What this means is that this return value is in
-    a format that works for Click to process but does not necessarily
-    correspond well to what's actually standard for the interpreter.
-
-    On most environments the return value is ``sys.argv[:1]`` unchanged.
-    However if you are on Windows and running Python 2 the return value
-    will actually be a list of unicode strings instead because the
-    default behavior on that platform otherwise will not be able to
-    carry all possible values that sys.argv can have.
-
-    .. versionadded:: 6.0
-    """
-    # We can only extract the unicode argv if sys.argv has not been
-    # changed since the startup of the application.
-    if PY2 and WIN and _initial_argv_hash == _hash_py_argv():
-        return _get_windows_argv()
-    return sys.argv[1:]
-
-
-def format_filename(filename, shorten=False):
-    """Formats a filename for user display.  The main purpose of this
-    function is to ensure that the filename can be displayed at all.  This
-    will decode the filename to unicode if necessary in a way that it will
-    not fail.  Optionally, it can shorten the filename to not include the
-    full path to the filename.
-
-    :param filename: formats a filename for UI display.  This will also convert
-                     the filename into unicode without failing.
-    :param shorten: this optionally shortens the filename to strip of the
-                    path that leads up to it.
-    """
-    if shorten:
-        filename = os.path.basename(filename)
-    return filename_to_ui(filename)
-
-
-def get_app_dir(app_name, roaming=True, force_posix=False):
-    r"""Returns the config folder for the application.  The default behavior
-    is to return whatever is most appropriate for the operating system.
-
-    To give you an idea, for an app called ``"Foo Bar"``, something like
-    the following folders could be returned:
-
-    Mac OS X:
-      ``~/Library/Application Support/Foo Bar``
-    Mac OS X (POSIX):
-      ``~/.foo-bar``
-    Unix:
-      ``~/.config/foo-bar``
-    Unix (POSIX):
-      ``~/.foo-bar``
-    Win XP (roaming):
-      ``C:\Documents and Settings\<user>\Local Settings\Application Data\Foo Bar``
-    Win XP (not roaming):
-      ``C:\Documents and Settings\<user>\Application Data\Foo Bar``
-    Win 7 (roaming):
-      ``C:\Users\<user>\AppData\Roaming\Foo Bar``
-    Win 7 (not roaming):
-      ``C:\Users\<user>\AppData\Local\Foo Bar``
-
-    .. versionadded:: 2.0
-
-    :param app_name: the application name.  This should be properly capitalized
-                     and can contain whitespace.
-    :param roaming: controls if the folder should be roaming or not on Windows.
-                    Has no affect otherwise.
-    :param force_posix: if this is set to `True` then on any POSIX system the
-                        folder will be stored in the home folder with a leading
-                        dot instead of the XDG config home or darwin's
-                        application support folder.
-    """
-    if WIN:
-        key = "APPDATA" if roaming else "LOCALAPPDATA"
-        folder = os.environ.get(key)
-        if folder is None:
-            folder = os.path.expanduser("~")
-        return os.path.join(folder, app_name)
-    if force_posix:
-        return os.path.join(os.path.expanduser("~/.{}".format(_posixify(app_name))))
-    if sys.platform == "darwin":
-        return os.path.join(
-            os.path.expanduser("~/Library/Application Support"), app_name
-        )
-    return os.path.join(
-        os.environ.get("XDG_CONFIG_HOME", os.path.expanduser("~/.config")),
-        _posixify(app_name),
-    )
-
-
-class PacifyFlushWrapper(object):
-    """This wrapper is used to catch and suppress BrokenPipeErrors resulting
-    from ``.flush()`` being called on broken pipe during the shutdown/final-GC
-    of the Python interpreter. Notably ``.flush()`` is always called on
-    ``sys.stdout`` and ``sys.stderr``. So as to have minimal impact on any
-    other cleanup code, and the case where the underlying file is not a broken
-    pipe, all calls and attributes are proxied.
-    """
-
-    def __init__(self, wrapped):
-        self.wrapped = wrapped
-
-    def flush(self):
-        try:
-            self.wrapped.flush()
-        except IOError as e:
-            import errno
-
-            if e.errno != errno.EPIPE:
-                raise
-
-    def __getattr__(self, attr):
-        return getattr(self.wrapped, attr)
diff --git a/Flaskserver/venv/Lib/site-packages/dask/__init__.py b/Flaskserver/venv/Lib/site-packages/dask/__init__.py
deleted file mode 100644
index 41f65daa4159320974769f9af9e1e29f26f28ecd..0000000000000000000000000000000000000000
--- a/Flaskserver/venv/Lib/site-packages/dask/__init__.py
+++ /dev/null
@@ -1,19 +0,0 @@
-from . import config, datasets
-from .core import istask
-from .local import get_sync as get
-
-try:
-    from .delayed import delayed
-except ImportError:
-    pass
-try:
-    from .base import visualize, compute, persist, optimize, is_dask_collection
-except ImportError:
-    pass
-
-from ._version import get_versions
-
-versions = get_versions()
-__version__ = versions["version"]
-__git_revision__ = versions["full-revisionid"]
-del get_versions, versions
diff --git a/Flaskserver/venv/Lib/site-packages/dask/__pycache__/__init__.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/__pycache__/__init__.cpython-38.pyc
deleted file mode 100644
index 3b32679648e7aa183382cd95359d412ac52de9ef..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/__pycache__/__init__.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/__pycache__/_version.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/__pycache__/_version.cpython-38.pyc
deleted file mode 100644
index afd5b509a102bf790d594d538d89daed8b1b59e3..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/__pycache__/_version.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/__pycache__/base.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/__pycache__/base.cpython-38.pyc
deleted file mode 100644
index c7e1fb4b75d4e7b507a5de552915d1463fd1f691..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/__pycache__/base.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/__pycache__/blockwise.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/__pycache__/blockwise.cpython-38.pyc
deleted file mode 100644
index f77cf042d5473ea5a6af34a237b7011a86676327..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/__pycache__/blockwise.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/__pycache__/cache.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/__pycache__/cache.cpython-38.pyc
deleted file mode 100644
index dc4cce4e87f87fcbb729ad9629b68b16753eead3..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/__pycache__/cache.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/__pycache__/callbacks.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/__pycache__/callbacks.cpython-38.pyc
deleted file mode 100644
index ae73d8beeba7f0c0c1dc4c46f4b0ab29e20a214d..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/__pycache__/callbacks.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/__pycache__/compatibility.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/__pycache__/compatibility.cpython-38.pyc
deleted file mode 100644
index 8663242f85fd34d66a1e0f112bf99457e9c1b483..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/__pycache__/compatibility.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/__pycache__/config.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/__pycache__/config.cpython-38.pyc
deleted file mode 100644
index 2b470965e15912b7b2989b1f73b96e5df864600a..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/__pycache__/config.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/__pycache__/context.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/__pycache__/context.cpython-38.pyc
deleted file mode 100644
index 11136219b46e9def8a8b4df59bad7823237a3971..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/__pycache__/context.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/__pycache__/core.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/__pycache__/core.cpython-38.pyc
deleted file mode 100644
index ca038be50971993b0300a146aa3dfc6ba907f758..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/__pycache__/core.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/__pycache__/datasets.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/__pycache__/datasets.cpython-38.pyc
deleted file mode 100644
index e004f0142da15e467e9e454037a043977f01d773..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/__pycache__/datasets.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/__pycache__/delayed.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/__pycache__/delayed.cpython-38.pyc
deleted file mode 100644
index 07fd85fe4ef929243ba22eca0bb54648130de625..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/__pycache__/delayed.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/__pycache__/distributed.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/__pycache__/distributed.cpython-38.pyc
deleted file mode 100644
index d8d549d90399de8ea54cac17eaa3e0e6dbdba229..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/__pycache__/distributed.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/__pycache__/dot.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/__pycache__/dot.cpython-38.pyc
deleted file mode 100644
index 656039d2572603772694e31c73f6754f2372f7a4..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/__pycache__/dot.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/__pycache__/hashing.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/__pycache__/hashing.cpython-38.pyc
deleted file mode 100644
index 927d037621999759da0f6844aaa5274ae1b5a7d0..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/__pycache__/hashing.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/__pycache__/highlevelgraph.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/__pycache__/highlevelgraph.cpython-38.pyc
deleted file mode 100644
index e664298f4d7c79d0da332b622d2ac1ce0b5fe6f0..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/__pycache__/highlevelgraph.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/__pycache__/local.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/__pycache__/local.cpython-38.pyc
deleted file mode 100644
index ae41d3191e3e8a0e9a25e5766a084770465bc19c..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/__pycache__/local.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/__pycache__/multiprocessing.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/__pycache__/multiprocessing.cpython-38.pyc
deleted file mode 100644
index 0cd3549ed04a19b8d6627e31f872baf1820b8206..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/__pycache__/multiprocessing.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/__pycache__/optimization.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/__pycache__/optimization.cpython-38.pyc
deleted file mode 100644
index 7e8f75540d2c16bc3e37ad894afa5de9bcb0857e..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/__pycache__/optimization.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/__pycache__/order.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/__pycache__/order.cpython-38.pyc
deleted file mode 100644
index 0de7517075cded8a30ea930e3d57351a770d36b6..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/__pycache__/order.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/__pycache__/rewrite.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/__pycache__/rewrite.cpython-38.pyc
deleted file mode 100644
index 597e213ac5b7fe511565bd04ea800701735d3fd4..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/__pycache__/rewrite.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/__pycache__/sizeof.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/__pycache__/sizeof.cpython-38.pyc
deleted file mode 100644
index a9c28492825e1dc79efc7eb98db87804e6b77580..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/__pycache__/sizeof.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/__pycache__/system.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/__pycache__/system.cpython-38.pyc
deleted file mode 100644
index 58ed278aaf9386afc080f6ce1b2348086825019d..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/__pycache__/system.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/__pycache__/threaded.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/__pycache__/threaded.cpython-38.pyc
deleted file mode 100644
index d52049c9fcac6d9b814973a2dfb8509753b985ee..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/__pycache__/threaded.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/__pycache__/utils.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/__pycache__/utils.cpython-38.pyc
deleted file mode 100644
index acac3a389271663a1c07ef6e1200b843a72af4fe..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/__pycache__/utils.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/__pycache__/utils_test.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/__pycache__/utils_test.cpython-38.pyc
deleted file mode 100644
index e7a2e131f100198fe715b3d03b88dc161f29dd45..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/__pycache__/utils_test.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/_version.py b/Flaskserver/venv/Lib/site-packages/dask/_version.py
deleted file mode 100644
index edb88af35d76fd28564b3ea715f0b608092ca87e..0000000000000000000000000000000000000000
--- a/Flaskserver/venv/Lib/site-packages/dask/_version.py
+++ /dev/null
@@ -1,21 +0,0 @@
-
-# This file was generated by 'versioneer.py' (0.16) from
-# revision-control system data, or from the parent directory name of an
-# unpacked source archive. Distribution tarballs contain a pre-generated copy
-# of this file.
-
-import json
-import sys
-
-version_json = '''
-{
- "dirty": false,
- "error": null,
- "full-revisionid": "b8c30a081a6f2ada554d236a7a7d22bd7b2811a6",
- "version": "2.25.0"
-}
-'''  # END VERSION_JSON
-
-
-def get_versions():
-    return json.loads(version_json)
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/__init__.py b/Flaskserver/venv/Lib/site-packages/dask/array/__init__.py
deleted file mode 100644
index 16b43e94d569b4fb790a59b8c5c7289acda12c4c..0000000000000000000000000000000000000000
--- a/Flaskserver/venv/Lib/site-packages/dask/array/__init__.py
+++ /dev/null
@@ -1,250 +0,0 @@
-try:
-    from .blockwise import blockwise, atop
-    from .core import (
-        Array,
-        block,
-        concatenate,
-        stack,
-        from_array,
-        store,
-        map_blocks,
-        to_hdf5,
-        to_npy_stack,
-        from_npy_stack,
-        from_delayed,
-        asarray,
-        asanyarray,
-        PerformanceWarning,
-        broadcast_arrays,
-        broadcast_to,
-        from_zarr,
-        to_zarr,
-        unify_chunks,
-    )
-    from .tiledb_io import from_tiledb, to_tiledb
-    from .numpy_compat import rollaxis, moveaxis
-    from .routines import (
-        take,
-        choose,
-        argwhere,
-        where,
-        coarsen,
-        insert,
-        shape,
-        union1d,
-        ravel,
-        roll,
-        unique,
-        squeeze,
-        ptp,
-        diff,
-        ediff1d,
-        gradient,
-        bincount,
-        digitize,
-        histogram,
-        cov,
-        array,
-        dstack,
-        vstack,
-        hstack,
-        compress,
-        extract,
-        round,
-        count_nonzero,
-        flatnonzero,
-        nonzero,
-        unravel_index,
-        around,
-        isin,
-        isnull,
-        notnull,
-        isclose,
-        allclose,
-        corrcoef,
-        swapaxes,
-        tensordot,
-        transpose,
-        dot,
-        vdot,
-        matmul,
-        outer,
-        apply_along_axis,
-        apply_over_axes,
-        result_type,
-        atleast_1d,
-        atleast_2d,
-        atleast_3d,
-        piecewise,
-        flip,
-        flipud,
-        fliplr,
-        einsum,
-        average,
-    )
-    from .reshape import reshape
-    from .ufunc import (
-        add,
-        subtract,
-        multiply,
-        divide,
-        logaddexp,
-        logaddexp2,
-        true_divide,
-        floor_divide,
-        negative,
-        power,
-        remainder,
-        mod,
-        conj,
-        exp,
-        exp2,
-        log,
-        log2,
-        log10,
-        log1p,
-        expm1,
-        sqrt,
-        square,
-        cbrt,
-        reciprocal,
-        sin,
-        cos,
-        tan,
-        arcsin,
-        arccos,
-        arctan,
-        arctan2,
-        hypot,
-        sinh,
-        cosh,
-        tanh,
-        arcsinh,
-        arccosh,
-        arctanh,
-        deg2rad,
-        rad2deg,
-        greater,
-        greater_equal,
-        less,
-        less_equal,
-        not_equal,
-        equal,
-        maximum,
-        bitwise_and,
-        bitwise_or,
-        bitwise_xor,
-        bitwise_not,
-        invert,
-        minimum,
-        logical_and,
-        logical_or,
-        logical_xor,
-        logical_not,
-        fmax,
-        fmin,
-        isreal,
-        iscomplex,
-        isfinite,
-        isinf,
-        isneginf,
-        isposinf,
-        isnan,
-        signbit,
-        copysign,
-        nextafter,
-        spacing,
-        ldexp,
-        fmod,
-        floor,
-        ceil,
-        trunc,
-        degrees,
-        radians,
-        rint,
-        fix,
-        angle,
-        real,
-        imag,
-        clip,
-        fabs,
-        sign,
-        absolute,
-        i0,
-        sinc,
-        nan_to_num,
-        frexp,
-        modf,
-        divide,
-        frompyfunc,
-        float_power,
-        divmod,
-    )
-    from .reductions import (
-        sum,
-        prod,
-        mean,
-        std,
-        var,
-        any,
-        all,
-        min,
-        max,
-        median,
-        moment,
-        trace,
-        argmin,
-        argmax,
-        nansum,
-        nanmean,
-        nanmedian,
-        nanstd,
-        nanvar,
-        nanmin,
-        nanmax,
-        nanargmin,
-        nanargmax,
-        cumsum,
-        cumprod,
-        topk,
-        argtopk,
-        nanprod,
-        nancumprod,
-        nancumsum,
-        reduction,
-    )
-    from .percentile import percentile
-    from . import ma
-    from . import random, linalg, overlap, fft, backends
-    from .overlap import map_overlap
-    from .wrap import ones, zeros, empty, full
-    from .creation import ones_like, zeros_like, empty_like, full_like
-    from .rechunk import rechunk
-    from ..base import compute
-    from .optimization import optimize
-    from .creation import (
-        arange,
-        linspace,
-        meshgrid,
-        indices,
-        diag,
-        eye,
-        triu,
-        tril,
-        fromfunction,
-        tile,
-        repeat,
-        pad,
-        diagonal,
-    )
-    from .gufunc import apply_gufunc, gufunc, as_gufunc
-    from .utils import assert_eq
-
-except ImportError as e:
-    msg = (
-        "Dask array requirements are not installed.\n\n"
-        "Please either conda or pip install as follows:\n\n"
-        "  conda install dask                 # either conda install\n"
-        '  python -m pip install "dask[array]" --upgrade  # or python -m pip install'
-    )
-    raise ImportError(str(e) + "\n\n" + msg) from e
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/__init__.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/__init__.cpython-38.pyc
deleted file mode 100644
index 9338a80b9b613e8d892b3ab6a407ef8ecef66ccf..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/__init__.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/backends.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/backends.cpython-38.pyc
deleted file mode 100644
index 307d24dc2f83a180ace37f2a6a3f93202e88b271..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/backends.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/blockwise.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/blockwise.cpython-38.pyc
deleted file mode 100644
index 3b829ccdf54f2f2620d701d2904fa18b4261c390..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/blockwise.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/chunk.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/chunk.cpython-38.pyc
deleted file mode 100644
index cd077ac828ffcdb894c4251a24ac9e4ef4f38260..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/chunk.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/core.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/core.cpython-38.pyc
deleted file mode 100644
index df88030074cc7e0b9297e88f4497a2a420fe5905..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/core.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/creation.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/creation.cpython-38.pyc
deleted file mode 100644
index 9bea1b44c352717727748fee96ec506f0f1d91ad..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/creation.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/einsumfuncs.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/einsumfuncs.cpython-38.pyc
deleted file mode 100644
index b1a693ee0823f629c1aba0f5b8a5d9f509b1a7ef..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/einsumfuncs.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/fft.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/fft.cpython-38.pyc
deleted file mode 100644
index 2fb3b867aa8fb6988d8cce51f85c569f1214aa1a..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/fft.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/gufunc.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/gufunc.cpython-38.pyc
deleted file mode 100644
index 6f75ab2d978d82f6a5122853e8b9af78cb2f5f4a..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/gufunc.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/image.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/image.cpython-38.pyc
deleted file mode 100644
index dc6cbb6c012f1b70d6ae50a88e2b1b046c3ee717..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/image.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/linalg.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/linalg.cpython-38.pyc
deleted file mode 100644
index ccd7901706d8a2e7f1ab1351e4330d4b4bbae2f4..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/linalg.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/ma.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/ma.cpython-38.pyc
deleted file mode 100644
index f2af6cdf1cfbcb3ba2a63d66c1bee5bc9d81536c..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/ma.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/numpy_compat.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/numpy_compat.cpython-38.pyc
deleted file mode 100644
index 9a0ce134e0fadd5304c2484cd973f3473c885fe8..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/numpy_compat.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/optimization.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/optimization.cpython-38.pyc
deleted file mode 100644
index 7b03b74b4fe994a2a2e9366acb186f71e8d93023..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/optimization.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/overlap.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/overlap.cpython-38.pyc
deleted file mode 100644
index 4b69e1ccb50b548985c163132f4312f076140be7..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/overlap.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/percentile.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/percentile.cpython-38.pyc
deleted file mode 100644
index ca506bc1d0e79334f99855502454457b62f9e946..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/percentile.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/random.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/random.cpython-38.pyc
deleted file mode 100644
index 68843edc8f2415f1c324e7820d5aa7ffcd056b01..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/random.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/rechunk.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/rechunk.cpython-38.pyc
deleted file mode 100644
index 5ed8e3bfaf7acda7020821a8fe3a951a97ab53c6..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/rechunk.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/reductions.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/reductions.cpython-38.pyc
deleted file mode 100644
index a3fb70c69c5685bf4b527974a29cd2533f6e6bff..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/reductions.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/reshape.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/reshape.cpython-38.pyc
deleted file mode 100644
index 452083b551f863f52c904d37c0e103421f3a3a2d..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/reshape.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/routines.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/routines.cpython-38.pyc
deleted file mode 100644
index e9941790ccf8dd99ff50c3f0eb17b8555e6f2771..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/routines.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/slicing.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/slicing.cpython-38.pyc
deleted file mode 100644
index 917eb686ec92a6e88f1690f8404395697e60b97b..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/slicing.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/stats.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/stats.cpython-38.pyc
deleted file mode 100644
index 7a4e8446523b79ece8d385c0a1dbe9a456586e13..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/stats.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/svg.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/svg.cpython-38.pyc
deleted file mode 100644
index f1ca46447eb0a876b0b4094604a665de82012a8c..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/svg.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/tiledb_io.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/tiledb_io.cpython-38.pyc
deleted file mode 100644
index e9caadd363350b9263f1eba1016b4f76f1f69103..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/tiledb_io.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/ufunc.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/ufunc.cpython-38.pyc
deleted file mode 100644
index 2e76f9ea0c203be1c953cdd8f12ba750ce27ced5..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/ufunc.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/utils.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/utils.cpython-38.pyc
deleted file mode 100644
index bb7f727544886b0f3c083514d962e1a96f92cc9e..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/utils.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/wrap.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/wrap.cpython-38.pyc
deleted file mode 100644
index 9290f544bef5a820abd6e30423e1b67e4febfdd2..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/array/__pycache__/wrap.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/backends.py b/Flaskserver/venv/Lib/site-packages/dask/array/backends.py
deleted file mode 100644
index 19c99925d3b8d275af21bfd22766494debf94b00..0000000000000000000000000000000000000000
--- a/Flaskserver/venv/Lib/site-packages/dask/array/backends.py
+++ /dev/null
@@ -1,73 +0,0 @@
-from .core import tensordot_lookup, concatenate_lookup, einsum_lookup
-
-
-@tensordot_lookup.register_lazy("cupy")
-@concatenate_lookup.register_lazy("cupy")
-def register_cupy():
-    import cupy
-
-    concatenate_lookup.register(cupy.ndarray, cupy.concatenate)
-    tensordot_lookup.register(cupy.ndarray, cupy.tensordot)
-
-    @einsum_lookup.register(cupy.ndarray)
-    def _cupy_einsum(*args, **kwargs):
-        # NB: cupy does not accept `order` or `casting` kwargs - ignore
-        kwargs.pop("casting", None)
-        kwargs.pop("order", None)
-        return cupy.einsum(*args, **kwargs)
-
-
-@concatenate_lookup.register_lazy("cupyx")
-def register_cupyx():
-
-    from cupyx.scipy.sparse import spmatrix
-
-    try:
-        from cupyx.scipy.sparse import hstack
-        from cupyx.scipy.sparse import vstack
-    except ImportError as e:
-        raise ImportError(
-            "Stacking of sparse arrays requires at least CuPy version 8.0.0"
-        ) from e
-
-    def _concat_cupy_sparse(L, axis=0):
-        if axis == 0:
-            return vstack(L)
-        elif axis == 1:
-            return hstack(L)
-        else:
-            msg = (
-                "Can only concatenate cupy sparse matrices for axis in "
-                "{0, 1}.  Got %s" % axis
-            )
-            raise ValueError(msg)
-
-    concatenate_lookup.register(spmatrix, _concat_cupy_sparse)
-
-
-@tensordot_lookup.register_lazy("sparse")
-@concatenate_lookup.register_lazy("sparse")
-def register_sparse():
-    import sparse
-
-    concatenate_lookup.register(sparse.COO, sparse.concatenate)
-    tensordot_lookup.register(sparse.COO, sparse.tensordot)
-
-
-@concatenate_lookup.register_lazy("scipy")
-def register_scipy_sparse():
-    import scipy.sparse
-
-    def _concatenate(L, axis=0):
-        if axis == 0:
-            return scipy.sparse.vstack(L)
-        elif axis == 1:
-            return scipy.sparse.hstack(L)
-        else:
-            msg = (
-                "Can only concatenate scipy sparse matrices for axis in "
-                "{0, 1}.  Got %s" % axis
-            )
-            raise ValueError(msg)
-
-    concatenate_lookup.register(scipy.sparse.spmatrix, _concatenate)
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/blockwise.py b/Flaskserver/venv/Lib/site-packages/dask/array/blockwise.py
deleted file mode 100644
index 6b3bb925b8784a1f70dd3946b81e3ee2ec5c2fa0..0000000000000000000000000000000000000000
--- a/Flaskserver/venv/Lib/site-packages/dask/array/blockwise.py
+++ /dev/null
@@ -1,259 +0,0 @@
-import numbers
-import warnings
-
-import tlz as toolz
-
-from .. import base, utils
-from ..delayed import unpack_collections
-from ..highlevelgraph import HighLevelGraph
-from ..blockwise import blockwise as core_blockwise
-
-
-def blockwise(
-    func,
-    out_ind,
-    *args,
-    name=None,
-    token=None,
-    dtype=None,
-    adjust_chunks=None,
-    new_axes=None,
-    align_arrays=True,
-    concatenate=None,
-    meta=None,
-    **kwargs
-):
-    """Tensor operation: Generalized inner and outer products
-
-    A broad class of blocked algorithms and patterns can be specified with a
-    concise multi-index notation.  The ``blockwise`` function applies an in-memory
-    function across multiple blocks of multiple inputs in a variety of ways.
-    Many dask.array operations are special cases of blockwise including
-    elementwise, broadcasting, reductions, tensordot, and transpose.
-
-    Parameters
-    ----------
-    func : callable
-        Function to apply to individual tuples of blocks
-    out_ind : iterable
-        Block pattern of the output, something like 'ijk' or (1, 2, 3)
-    *args : sequence of Array, index pairs
-        Sequence like (x, 'ij', y, 'jk', z, 'i')
-    **kwargs : dict
-        Extra keyword arguments to pass to function
-    dtype : np.dtype
-        Datatype of resulting array.
-    concatenate : bool, keyword only
-        If true concatenate arrays along dummy indices, else provide lists
-    adjust_chunks : dict
-        Dictionary mapping index to function to be applied to chunk sizes
-    new_axes : dict, keyword only
-        New indexes and their dimension lengths
-
-    Examples
-    --------
-    2D embarrassingly parallel operation from two arrays, x, and y.
-
-    >>> z = blockwise(operator.add, 'ij', x, 'ij', y, 'ij', dtype='f8')  # z = x + y  # doctest: +SKIP
-
-    Outer product multiplying x by y, two 1-d vectors
-
-    >>> z = blockwise(operator.mul, 'ij', x, 'i', y, 'j', dtype='f8')  # doctest: +SKIP
-
-    z = x.T
-
-    >>> z = blockwise(np.transpose, 'ji', x, 'ij', dtype=x.dtype)  # doctest: +SKIP
-
-    The transpose case above is illustrative because it does same transposition
-    both on each in-memory block by calling ``np.transpose`` and on the order
-    of the blocks themselves, by switching the order of the index ``ij -> ji``.
-
-    We can compose these same patterns with more variables and more complex
-    in-memory functions
-
-    z = X + Y.T
-
-    >>> z = blockwise(lambda x, y: x + y.T, 'ij', x, 'ij', y, 'ji', dtype='f8')  # doctest: +SKIP
-
-    Any index, like ``i`` missing from the output index is interpreted as a
-    contraction (note that this differs from Einstein convention; repeated
-    indices do not imply contraction.)  In the case of a contraction the passed
-    function should expect an iterable of blocks on any array that holds that
-    index.  To receive arrays concatenated along contracted dimensions instead
-    pass ``concatenate=True``.
-
-    Inner product multiplying x by y, two 1-d vectors
-
-    >>> def sequence_dot(x_blocks, y_blocks):
-    ...     result = 0
-    ...     for x, y in zip(x_blocks, y_blocks):
-    ...         result += x.dot(y)
-    ...     return result
-
-    >>> z = blockwise(sequence_dot, '', x, 'i', y, 'i', dtype='f8')  # doctest: +SKIP
-
-    Add new single-chunk dimensions with the ``new_axes=`` keyword, including
-    the length of the new dimension.  New dimensions will always be in a single
-    chunk.
-
-    >>> def f(x):
-    ...     return x[:, None] * np.ones((1, 5))
-
-    >>> z = blockwise(f, 'az', x, 'a', new_axes={'z': 5}, dtype=x.dtype)  # doctest: +SKIP
-
-    New dimensions can also be multi-chunk by specifying a tuple of chunk
-    sizes.  This has limited utility as is (because the chunks are all the
-    same), but the resulting graph can be modified to achieve more useful
-    results (see ``da.map_blocks``).
-
-    >>> z = blockwise(f, 'az', x, 'a', new_axes={'z': (5, 5)}, dtype=x.dtype)  # doctest: +SKIP
-
-    If the applied function changes the size of each chunk you can specify this
-    with a ``adjust_chunks={...}`` dictionary holding a function for each index
-    that modifies the dimension size in that index.
-
-    >>> def double(x):
-    ...     return np.concatenate([x, x])
-
-    >>> y = blockwise(double, 'ij', x, 'ij',
-    ...               adjust_chunks={'i': lambda n: 2 * n}, dtype=x.dtype)  # doctest: +SKIP
-
-    Include literals by indexing with None
-
-    >>> y = blockwise(add, 'ij', x, 'ij', 1234, None, dtype=x.dtype)  # doctest: +SKIP
-    """
-    out = name
-    new_axes = new_axes or {}
-
-    # Input Validation
-    if len(set(out_ind)) != len(out_ind):
-        raise ValueError(
-            "Repeated elements not allowed in output index",
-            [k for k, v in toolz.frequencies(out_ind).items() if v > 1],
-        )
-    new = (
-        set(out_ind)
-        - {a for arg in args[1::2] if arg is not None for a in arg}
-        - set(new_axes or ())
-    )
-    if new:
-        raise ValueError("Unknown dimension", new)
-
-    from .core import Array, unify_chunks, normalize_arg
-
-    if align_arrays:
-        chunkss, arrays = unify_chunks(*args)
-    else:
-        arginds = [(a, i) for (a, i) in toolz.partition(2, args) if i is not None]
-        chunkss = {}
-        # For each dimension, use the input chunking that has the most blocks;
-        # this will ensure that broadcasting works as expected, and in
-        # particular the number of blocks should be correct if the inputs are
-        # consistent.
-        for arg, ind in arginds:
-            for c, i in zip(arg.chunks, ind):
-                if i not in chunkss or len(c) > len(chunkss[i]):
-                    chunkss[i] = c
-        arrays = args[::2]
-
-    for k, v in new_axes.items():
-        if not isinstance(v, tuple):
-            v = (v,)
-        chunkss[k] = v
-
-    arginds = zip(arrays, args[1::2])
-    numblocks = {}
-
-    dependencies = []
-    arrays = []
-
-    # Normalize arguments
-    argindsstr = []
-
-    for arg, ind in arginds:
-        if ind is None:
-            arg = normalize_arg(arg)
-            arg, collections = unpack_collections(arg)
-            dependencies.extend(collections)
-        else:
-            if (
-                hasattr(arg, "ndim")
-                and hasattr(ind, "__len__")
-                and arg.ndim != len(ind)
-            ):
-                raise ValueError(
-                    "Index string %s does not match array dimension %d"
-                    % (ind, arg.ndim)
-                )
-            numblocks[arg.name] = arg.numblocks
-            arrays.append(arg)
-            arg = arg.name
-        argindsstr.extend((arg, ind))
-
-    # Normalize keyword arguments
-    kwargs2 = {}
-    for k, v in kwargs.items():
-        v = normalize_arg(v)
-        v, collections = unpack_collections(v)
-        dependencies.extend(collections)
-        kwargs2[k] = v
-
-    # Finish up the name
-    if not out:
-        out = "%s-%s" % (
-            token or utils.funcname(func).strip("_"),
-            base.tokenize(func, out_ind, argindsstr, dtype, **kwargs),
-        )
-
-    graph = core_blockwise(
-        func,
-        out,
-        out_ind,
-        *argindsstr,
-        numblocks=numblocks,
-        dependencies=dependencies,
-        new_axes=new_axes,
-        concatenate=concatenate,
-        **kwargs2
-    )
-    graph = HighLevelGraph.from_collections(
-        out, graph, dependencies=arrays + dependencies
-    )
-
-    chunks = [chunkss[i] for i in out_ind]
-    if adjust_chunks:
-        for i, ind in enumerate(out_ind):
-            if ind in adjust_chunks:
-                if callable(adjust_chunks[ind]):
-                    chunks[i] = tuple(map(adjust_chunks[ind], chunks[i]))
-                elif isinstance(adjust_chunks[ind], numbers.Integral):
-                    chunks[i] = tuple(adjust_chunks[ind] for _ in chunks[i])
-                elif isinstance(adjust_chunks[ind], (tuple, list)):
-                    if len(adjust_chunks[ind]) != len(chunks[i]):
-                        raise ValueError(
-                            "Dimension {0} has {1} blocks, "
-                            "adjust_chunks specified with "
-                            "{2} blocks".format(
-                                i, len(chunks[i]), len(adjust_chunks[ind])
-                            )
-                        )
-                    chunks[i] = tuple(adjust_chunks[ind])
-                else:
-                    raise NotImplementedError(
-                        "adjust_chunks values must be callable, int, or tuple"
-                    )
-    chunks = tuple(chunks)
-
-    if meta is None:
-        from .utils import compute_meta
-
-        meta = compute_meta(func, dtype, *args[::2], **kwargs)
-    if meta is not None:
-        return Array(graph, out, chunks, meta=meta)
-    else:
-        return Array(graph, out, chunks, dtype=dtype)
-
-
-def atop(*args, **kwargs):
-    warnings.warn("The da.atop function has moved to da.blockwise")
-    return blockwise(*args, **kwargs)
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/chunk.py b/Flaskserver/venv/Lib/site-packages/dask/array/chunk.py
deleted file mode 100644
index b7b050351a6fda44e3519077ff94bfefde92bf0f..0000000000000000000000000000000000000000
--- a/Flaskserver/venv/Lib/site-packages/dask/array/chunk.py
+++ /dev/null
@@ -1,375 +0,0 @@
-""" A set of NumPy functions to apply per chunk """
-from collections.abc import Container, Iterable, Sequence
-from functools import wraps
-
-from tlz import concat
-import numpy as np
-from . import numpy_compat as npcompat
-
-from ..core import flatten
-from ..utils import ignoring
-
-from numbers import Integral
-
-try:
-    from numpy import take_along_axis
-except ImportError:  # pragma: no cover
-    take_along_axis = npcompat.take_along_axis
-
-
-def keepdims_wrapper(a_callable):
-    """
-    A wrapper for functions that don't provide keepdims to ensure that they do.
-    """
-
-    @wraps(a_callable)
-    def keepdims_wrapped_callable(x, axis=None, keepdims=None, *args, **kwargs):
-        r = a_callable(x, axis=axis, *args, **kwargs)
-
-        if not keepdims:
-            return r
-
-        axes = axis
-
-        if axes is None:
-            axes = range(x.ndim)
-
-        if not isinstance(axes, (Container, Iterable, Sequence)):
-            axes = [axes]
-
-        r_slice = tuple()
-        for each_axis in range(x.ndim):
-            if each_axis in axes:
-                r_slice += (None,)
-            else:
-                r_slice += (slice(None),)
-
-        r = r[r_slice]
-
-        return r
-
-    return keepdims_wrapped_callable
-
-
-# Wrap NumPy functions to ensure they provide keepdims.
-sum = np.sum
-prod = np.prod
-min = np.min
-max = np.max
-argmin = keepdims_wrapper(np.argmin)
-nanargmin = keepdims_wrapper(np.nanargmin)
-argmax = keepdims_wrapper(np.argmax)
-nanargmax = keepdims_wrapper(np.nanargmax)
-any = np.any
-all = np.all
-nansum = np.nansum
-nanprod = np.nanprod
-
-nancumprod = np.nancumprod
-nancumsum = np.nancumsum
-
-nanmin = np.nanmin
-nanmax = np.nanmax
-mean = np.mean
-
-with ignoring(AttributeError):
-    nanmean = np.nanmean
-
-var = np.var
-
-with ignoring(AttributeError):
-    nanvar = np.nanvar
-
-std = np.std
-
-with ignoring(AttributeError):
-    nanstd = np.nanstd
-
-
-def coarsen(reduction, x, axes, trim_excess=False, **kwargs):
-    """Coarsen array by applying reduction to fixed size neighborhoods
-
-    Parameters
-    ----------
-    reduction: function
-        Function like np.sum, np.mean, etc...
-    x: np.ndarray
-        Array to be coarsened
-    axes: dict
-        Mapping of axis to coarsening factor
-
-    Examples
-    --------
-    >>> x = np.array([1, 2, 3, 4, 5, 6])
-    >>> coarsen(np.sum, x, {0: 2})
-    array([ 3,  7, 11])
-    >>> coarsen(np.max, x, {0: 3})
-    array([3, 6])
-
-    Provide dictionary of scale per dimension
-
-    >>> x = np.arange(24).reshape((4, 6))
-    >>> x
-    array([[ 0,  1,  2,  3,  4,  5],
-           [ 6,  7,  8,  9, 10, 11],
-           [12, 13, 14, 15, 16, 17],
-           [18, 19, 20, 21, 22, 23]])
-
-    >>> coarsen(np.min, x, {0: 2, 1: 3})
-    array([[ 0,  3],
-           [12, 15]])
-
-    You must avoid excess elements explicitly
-
-    >>> x = np.array([1, 2, 3, 4, 5, 6, 7, 8])
-    >>> coarsen(np.min, x, {0: 3}, trim_excess=True)
-    array([1, 4])
-    """
-    # Insert singleton dimensions if they don't exist already
-    for i in range(x.ndim):
-        if i not in axes:
-            axes[i] = 1
-
-    if trim_excess:
-        ind = tuple(
-            slice(0, -(d % axes[i])) if d % axes[i] else slice(None, None)
-            for i, d in enumerate(x.shape)
-        )
-        x = x[ind]
-
-    # (10, 10) -> (5, 2, 5, 2)
-    newshape = tuple(concat([(x.shape[i] // axes[i], axes[i]) for i in range(x.ndim)]))
-
-    return reduction(x.reshape(newshape), axis=tuple(range(1, x.ndim * 2, 2)), **kwargs)
-
-
-def trim(x, axes=None):
-    """Trim boundaries off of array
-
-    >>> x = np.arange(24).reshape((4, 6))
-    >>> trim(x, axes={0: 0, 1: 1})
-    array([[ 1,  2,  3,  4],
-           [ 7,  8,  9, 10],
-           [13, 14, 15, 16],
-           [19, 20, 21, 22]])
-
-    >>> trim(x, axes={0: 1, 1: 1})
-    array([[ 7,  8,  9, 10],
-           [13, 14, 15, 16]])
-    """
-    if isinstance(axes, Integral):
-        axes = [axes] * x.ndim
-    if isinstance(axes, dict):
-        axes = [axes.get(i, 0) for i in range(x.ndim)]
-
-    return x[tuple(slice(ax, -ax if ax else None) for ax in axes)]
-
-
-def topk(a, k, axis, keepdims):
-    """Chunk and combine function of topk
-
-    Extract the k largest elements from a on the given axis.
-    If k is negative, extract the -k smallest elements instead.
-    Note that, unlike in the parent function, the returned elements
-    are not sorted internally.
-    """
-    assert keepdims is True
-    axis = axis[0]
-    if abs(k) >= a.shape[axis]:
-        return a
-
-    a = np.partition(a, -k, axis=axis)
-    k_slice = slice(-k, None) if k > 0 else slice(-k)
-    return a[tuple(k_slice if i == axis else slice(None) for i in range(a.ndim))]
-
-
-def topk_aggregate(a, k, axis, keepdims):
-    """Final aggregation function of topk
-
-    Invoke topk one final time and then sort the results internally.
-    """
-    assert keepdims is True
-    a = topk(a, k, axis, keepdims)
-    axis = axis[0]
-    a = np.sort(a, axis=axis)
-    if k < 0:
-        return a
-    return a[
-        tuple(
-            slice(None, None, -1) if i == axis else slice(None) for i in range(a.ndim)
-        )
-    ]
-
-
-def argtopk_preprocess(a, idx):
-    """Preparatory step for argtopk
-
-    Put data together with its original indices in a tuple.
-    """
-    return a, idx
-
-
-def argtopk(a_plus_idx, k, axis, keepdims):
-    """Chunk and combine function of argtopk
-
-    Extract the indices of the k largest elements from a on the given axis.
-    If k is negative, extract the indices of the -k smallest elements instead.
-    Note that, unlike in the parent function, the returned elements
-    are not sorted internally.
-    """
-    assert keepdims is True
-    axis = axis[0]
-
-    if isinstance(a_plus_idx, list):
-        a_plus_idx = list(flatten(a_plus_idx))
-        a = np.concatenate([ai for ai, _ in a_plus_idx], axis)
-        idx = np.concatenate(
-            [np.broadcast_to(idxi, ai.shape) for ai, idxi in a_plus_idx], axis
-        )
-    else:
-        a, idx = a_plus_idx
-
-    if abs(k) >= a.shape[axis]:
-        return a_plus_idx
-
-    idx2 = np.argpartition(a, -k, axis=axis)
-    k_slice = slice(-k, None) if k > 0 else slice(-k)
-    idx2 = idx2[tuple(k_slice if i == axis else slice(None) for i in range(a.ndim))]
-    return take_along_axis(a, idx2, axis), take_along_axis(idx, idx2, axis)
-
-
-def argtopk_aggregate(a_plus_idx, k, axis, keepdims):
-    """Final aggregation function of argtopk
-
-    Invoke argtopk one final time, sort the results internally, drop the data
-    and return the index only.
-    """
-    assert keepdims is True
-    a, idx = argtopk(a_plus_idx, k, axis, keepdims)
-    axis = axis[0]
-
-    idx2 = np.argsort(a, axis=axis)
-    idx = take_along_axis(idx, idx2, axis)
-    if k < 0:
-        return idx
-    return idx[
-        tuple(
-            slice(None, None, -1) if i == axis else slice(None) for i in range(idx.ndim)
-        )
-    ]
-
-
-def arange(start, stop, step, length, dtype):
-    res = np.arange(start, stop, step, dtype)
-    return res[:-1] if len(res) > length else res
-
-
-def astype(x, astype_dtype=None, **kwargs):
-    return x.astype(astype_dtype, **kwargs)
-
-
-def view(x, dtype, order="C"):
-    if order == "C":
-        x = np.ascontiguousarray(x)
-        return x.view(dtype)
-    else:
-        x = np.asfortranarray(x)
-        return x.T.view(dtype).T
-
-
-def slice_with_int_dask_array(x, idx, offset, x_size, axis):
-    """Chunk function of `slice_with_int_dask_array_on_axis`.
-    Slice one chunk of x by one chunk of idx.
-
-    Parameters
-    ----------
-    x: ndarray, any dtype, any shape
-        i-th chunk of x
-    idx: ndarray, ndim=1, dtype=any integer
-        j-th chunk of idx (cartesian product with the chunks of x)
-    offset: ndarray, shape=(1, ), dtype=int64
-        Index of the first element along axis of the current chunk of x
-    x_size: int
-        Total size of the x da.Array along axis
-    axis: int
-        normalized axis to take elements from (0 <= axis < x.ndim)
-
-    Returns
-    -------
-    x sliced along axis, using only the elements of idx that fall inside the
-    current chunk.
-    """
-    # Needed when idx is unsigned
-    idx = idx.astype(np.int64)
-
-    # Normalize negative indices
-    idx = np.where(idx < 0, idx + x_size, idx)
-
-    # A chunk of the offset dask Array is a numpy array with shape (1, ).
-    # It indicates the index of the first element along axis of the current
-    # chunk of x.
-    idx = idx - offset
-
-    # Drop elements of idx that do not fall inside the current chunk of x
-    idx_filter = (idx >= 0) & (idx < x.shape[axis])
-    idx = idx[idx_filter]
-
-    # np.take does not support slice indices
-    # return np.take(x, idx, axis)
-    return x[tuple(idx if i == axis else slice(None) for i in range(x.ndim))]
-
-
-def slice_with_int_dask_array_aggregate(idx, chunk_outputs, x_chunks, axis):
-    """Final aggregation function of `slice_with_int_dask_array_on_axis`.
-    Aggregate all chunks of x by one chunk of idx, reordering the output of
-    `slice_with_int_dask_array`.
-
-    Note that there is no combine function, as a recursive aggregation (e.g.
-    with split_every) would not give any benefit.
-
-    Parameters
-    ----------
-    idx: ndarray, ndim=1, dtype=any integer
-        j-th chunk of idx
-    chunk_outputs: ndarray
-        concatenation along axis of the outputs of `slice_with_int_dask_array`
-        for all chunks of x and the j-th chunk of idx
-    x_chunks: tuple
-        dask chunks of the x da.Array along axis, e.g. ``(3, 3, 2)``
-    axis: int
-        normalized axis to take elements from (0 <= axis < x.ndim)
-
-    Returns
-    -------
-    Selection from all chunks of x for the j-th chunk of idx, in the correct
-    order
-    """
-    # Needed when idx is unsigned
-    idx = idx.astype(np.int64)
-
-    # Normalize negative indices
-    idx = np.where(idx < 0, idx + sum(x_chunks), idx)
-
-    x_chunk_offset = 0
-    chunk_output_offset = 0
-
-    # Assemble the final index that picks from the output of the previous
-    # kernel by adding together one layer per chunk of x
-    # FIXME: this could probably be reimplemented with a faster search-based
-    # algorithm
-    idx_final = np.zeros_like(idx)
-    for x_chunk in x_chunks:
-        idx_filter = (idx >= x_chunk_offset) & (idx < x_chunk_offset + x_chunk)
-        idx_cum = np.cumsum(idx_filter)
-        idx_final += np.where(idx_filter, idx_cum - 1 + chunk_output_offset, 0)
-        x_chunk_offset += x_chunk
-        if idx_cum.size > 0:
-            chunk_output_offset += idx_cum[-1]
-
-    # np.take does not support slice indices
-    # return np.take(chunk_outputs, idx_final, axis)
-    return chunk_outputs[
-        tuple(
-            idx_final if i == axis else slice(None) for i in range(chunk_outputs.ndim)
-        )
-    ]
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/core.py b/Flaskserver/venv/Lib/site-packages/dask/array/core.py
deleted file mode 100644
index b2583bbae125a58f6264d2a23196384f8cc49314..0000000000000000000000000000000000000000
--- a/Flaskserver/venv/Lib/site-packages/dask/array/core.py
+++ /dev/null
@@ -1,4819 +0,0 @@
-import math
-import operator
-import os
-import pickle
-import re
-import sys
-import traceback
-import uuid
-import warnings
-from bisect import bisect
-from collections.abc import Iterable, Iterator, Mapping
-from functools import partial, wraps, reduce
-from itertools import product, zip_longest
-from numbers import Number, Integral
-from operator import add, getitem, mul
-from threading import Lock
-
-from tlz import partition, concat, first, groupby, accumulate, frequencies
-from tlz.curried import pluck
-import numpy as np
-
-from . import chunk
-from .. import config, compute
-from ..base import (
-    DaskMethodsMixin,
-    tokenize,
-    dont_optimize,
-    compute_as_if_collection,
-    persist,
-    is_dask_collection,
-)
-from ..blockwise import broadcast_dimensions
-from ..context import globalmethod
-from ..utils import (
-    ndeepmap,
-    ignoring,
-    concrete,
-    derived_from,
-    is_integer,
-    IndexCallable,
-    funcname,
-    SerializableLock,
-    Dispatch,
-    factors,
-    parse_bytes,
-    has_keyword,
-    M,
-    ndimlist,
-    format_bytes,
-    typename,
-)
-from ..core import quote
-from ..delayed import delayed, Delayed
-from .. import threaded, core
-from ..sizeof import sizeof
-from ..highlevelgraph import HighLevelGraph
-from .numpy_compat import _Recurser, _make_sliced_dtype
-from .slicing import slice_array, replace_ellipsis, cached_cumsum
-from .blockwise import blockwise
-
-config.update_defaults({"array": {"chunk-size": "128MiB", "rechunk-threshold": 4}})
-
-
-concatenate_lookup = Dispatch("concatenate")
-tensordot_lookup = Dispatch("tensordot")
-einsum_lookup = Dispatch("einsum")
-concatenate_lookup.register((object, np.ndarray), np.concatenate)
-tensordot_lookup.register((object, np.ndarray), np.tensordot)
-einsum_lookup.register((object, np.ndarray), np.einsum)
-
-unknown_chunk_message = (
-    "\n\n"
-    "A possible solution: "
-    "https://docs.dask.org/en/latest/array-chunks.html#unknown-chunks\n"
-    "Summary: to compute chunks sizes, use\n\n"
-    "   x.compute_chunk_sizes()  # for Dask Array `x`\n"
-    "   ddf.to_dask_array(lengths=True)  # for Dask DataFrame `ddf`"
-)
-
-
-class PerformanceWarning(Warning):
-    """ A warning given when bad chunking may cause poor performance """
-
-
-def getter(a, b, asarray=True, lock=None):
-    if isinstance(b, tuple) and any(x is None for x in b):
-        b2 = tuple(x for x in b if x is not None)
-        b3 = tuple(
-            None if x is None else slice(None, None)
-            for x in b
-            if not isinstance(x, Integral)
-        )
-        return getter(a, b2, asarray=asarray, lock=lock)[b3]
-
-    if lock:
-        lock.acquire()
-    try:
-        c = a[b]
-        if asarray:
-            c = np.asarray(c)
-    finally:
-        if lock:
-            lock.release()
-    return c
-
-
-def getter_nofancy(a, b, asarray=True, lock=None):
-    """A simple wrapper around ``getter``.
-
-    Used to indicate to the optimization passes that the backend doesn't
-    support fancy indexing.
-    """
-    return getter(a, b, asarray=asarray, lock=lock)
-
-
-def getter_inline(a, b, asarray=True, lock=None):
-    """A getter function that optimizations feel comfortable inlining
-
-    Slicing operations with this function may be inlined into a graph, such as
-    in the following rewrite
-
-    **Before**
-
-    >>> a = x[:10]  # doctest: +SKIP
-    >>> b = a + 1  # doctest: +SKIP
-    >>> c = a * 2  # doctest: +SKIP
-
-    **After**
-
-    >>> b = x[:10] + 1  # doctest: +SKIP
-    >>> c = x[:10] * 2  # doctest: +SKIP
-
-    This inlining can be relevant to operations when running off of disk.
-    """
-    return getter(a, b, asarray=asarray, lock=lock)
-
-
-from .optimization import optimize, fuse_slice
-
-
-# __array_function__ dict for mapping aliases and mismatching names
-_HANDLED_FUNCTIONS = {}
-
-
-def implements(*numpy_functions):
-    """Register an __array_function__ implementation for dask.array.Array
-
-    Register that a function implements the API of a NumPy function (or several
-    NumPy functions in case of aliases) which is handled with
-    ``__array_function__``.
-
-    Parameters
-    ----------
-    \\*numpy_functions : callables
-        One or more NumPy functions that are handled by ``__array_function__``
-        and will be mapped by `implements` to a `dask.array` function.
-    """
-
-    def decorator(dask_func):
-        for numpy_function in numpy_functions:
-            _HANDLED_FUNCTIONS[numpy_function] = dask_func
-
-        return dask_func
-
-    return decorator
-
-
-def slices_from_chunks(chunks):
-    """Translate chunks tuple to a set of slices in product order
-
-    >>> slices_from_chunks(((2, 2), (3, 3, 3)))  # doctest: +NORMALIZE_WHITESPACE
-     [(slice(0, 2, None), slice(0, 3, None)),
-      (slice(0, 2, None), slice(3, 6, None)),
-      (slice(0, 2, None), slice(6, 9, None)),
-      (slice(2, 4, None), slice(0, 3, None)),
-      (slice(2, 4, None), slice(3, 6, None)),
-      (slice(2, 4, None), slice(6, 9, None))]
-    """
-    cumdims = [cached_cumsum(bds, initial_zero=True) for bds in chunks]
-    slices = [
-        [slice(s, s + dim) for s, dim in zip(starts, shapes)]
-        for starts, shapes in zip(cumdims, chunks)
-    ]
-    return list(product(*slices))
-
-
-def getem(
-    arr,
-    chunks,
-    getitem=getter,
-    shape=None,
-    out_name=None,
-    lock=False,
-    asarray=True,
-    dtype=None,
-):
-    """Dask getting various chunks from an array-like
-
-    >>> getem('X', chunks=(2, 3), shape=(4, 6))  # doctest: +SKIP
-    {('X', 0, 0): (getter, 'X', (slice(0, 2), slice(0, 3))),
-     ('X', 1, 0): (getter, 'X', (slice(2, 4), slice(0, 3))),
-     ('X', 1, 1): (getter, 'X', (slice(2, 4), slice(3, 6))),
-     ('X', 0, 1): (getter, 'X', (slice(0, 2), slice(3, 6)))}
-
-    >>> getem('X', chunks=((2, 2), (3, 3)))  # doctest: +SKIP
-    {('X', 0, 0): (getter, 'X', (slice(0, 2), slice(0, 3))),
-     ('X', 1, 0): (getter, 'X', (slice(2, 4), slice(0, 3))),
-     ('X', 1, 1): (getter, 'X', (slice(2, 4), slice(3, 6))),
-     ('X', 0, 1): (getter, 'X', (slice(0, 2), slice(3, 6)))}
-    """
-    out_name = out_name or arr
-    chunks = normalize_chunks(chunks, shape, dtype=dtype)
-    keys = product([out_name], *(range(len(bds)) for bds in chunks))
-    slices = slices_from_chunks(chunks)
-
-    if (
-        has_keyword(getitem, "asarray")
-        and has_keyword(getitem, "lock")
-        and (not asarray or lock)
-    ):
-        values = [(getitem, arr, x, asarray, lock) for x in slices]
-    else:
-        # Common case, drop extra parameters
-        values = [(getitem, arr, x) for x in slices]
-
-    return dict(zip(keys, values))
-
-
-def dotmany(A, B, leftfunc=None, rightfunc=None, **kwargs):
-    """Dot product of many aligned chunks
-
-    >>> x = np.array([[1, 2], [1, 2]])
-    >>> y = np.array([[10, 20], [10, 20]])
-    >>> dotmany([x, x, x], [y, y, y])
-    array([[ 90, 180],
-           [ 90, 180]])
-
-    Optionally pass in functions to apply to the left and right chunks
-
-    >>> dotmany([x, x, x], [y, y, y], rightfunc=np.transpose)
-    array([[150, 150],
-           [150, 150]])
-    """
-    if leftfunc:
-        A = map(leftfunc, A)
-    if rightfunc:
-        B = map(rightfunc, B)
-    return sum(map(partial(np.dot, **kwargs), A, B))
-
-
-def _concatenate2(arrays, axes=[]):
-    """Recursively Concatenate nested lists of arrays along axes
-
-    Each entry in axes corresponds to each level of the nested list.  The
-    length of axes should correspond to the level of nesting of arrays.
-    If axes is an empty list or tuple, return arrays, or arrays[0] if
-    arrays is a list.
-
-    >>> x = np.array([[1, 2], [3, 4]])
-    >>> _concatenate2([x, x], axes=[0])
-    array([[1, 2],
-           [3, 4],
-           [1, 2],
-           [3, 4]])
-
-    >>> _concatenate2([x, x], axes=[1])
-    array([[1, 2, 1, 2],
-           [3, 4, 3, 4]])
-
-    >>> _concatenate2([[x, x], [x, x]], axes=[0, 1])
-    array([[1, 2, 1, 2],
-           [3, 4, 3, 4],
-           [1, 2, 1, 2],
-           [3, 4, 3, 4]])
-
-    Supports Iterators
-    >>> _concatenate2(iter([x, x]), axes=[1])
-    array([[1, 2, 1, 2],
-           [3, 4, 3, 4]])
-
-    Special Case
-    >>> _concatenate2([x, x], axes=())
-    array([[1, 2],
-           [3, 4]])
-    """
-    if axes == ():
-        if isinstance(arrays, list):
-            return arrays[0]
-        else:
-            return arrays
-
-    if isinstance(arrays, Iterator):
-        arrays = list(arrays)
-    if not isinstance(arrays, (list, tuple)):
-        return arrays
-    if len(axes) > 1:
-        arrays = [_concatenate2(a, axes=axes[1:]) for a in arrays]
-    concatenate = concatenate_lookup.dispatch(
-        type(max(arrays, key=lambda x: getattr(x, "__array_priority__", 0)))
-    )
-    return concatenate(arrays, axis=axes[0])
-
-
-def apply_infer_dtype(func, args, kwargs, funcname, suggest_dtype="dtype", nout=None):
-    """
-    Tries to infer output dtype of ``func`` for a small set of input arguments.
-
-    Parameters
-    ----------
-    func: Callable
-        Function for which output dtype is to be determined
-
-    args: List of array like
-        Arguments to the function, which would usually be used. Only attributes
-        ``ndim`` and ``dtype`` are used.
-
-    kwargs: dict
-        Additional ``kwargs`` to the ``func``
-
-    funcname: String
-        Name of calling function to improve potential error messages
-
-    suggest_dtype: None/False or String
-        If not ``None`` adds suggestion to potential error message to specify a dtype
-        via the specified kwarg. Defaults to ``'dtype'``.
-
-    nout: None or Int
-        ``None`` if function returns single output, integer if many.
-        Deafults to ``None``.
-
-    Returns
-    -------
-    : dtype or List of dtype
-        One or many dtypes (depending on ``nout``)
-    """
-    args = [
-        np.ones((1,) * x.ndim, dtype=x.dtype) if isinstance(x, Array) else x
-        for x in args
-    ]
-    try:
-        with np.errstate(all="ignore"):
-            o = func(*args, **kwargs)
-    except Exception as e:
-        exc_type, exc_value, exc_traceback = sys.exc_info()
-        tb = "".join(traceback.format_tb(exc_traceback))
-        suggest = (
-            (
-                "Please specify the dtype explicitly using the "
-                "`{dtype}` kwarg.\n\n".format(dtype=suggest_dtype)
-            )
-            if suggest_dtype
-            else ""
-        )
-        msg = (
-            "`dtype` inference failed in `{0}`.\n\n"
-            "{1}"
-            "Original error is below:\n"
-            "------------------------\n"
-            "{2}\n\n"
-            "Traceback:\n"
-            "---------\n"
-            "{3}"
-        ).format(funcname, suggest, repr(e), tb)
-    else:
-        msg = None
-    if msg is not None:
-        raise ValueError(msg)
-    return o.dtype if nout is None else tuple(e.dtype for e in o)
-
-
-def normalize_arg(x):
-    """Normalize user provided arguments to blockwise or map_blocks
-
-    We do a few things:
-
-    1.  If they are string literals that might collide with blockwise_token then we
-        quote them
-    2.  IF they are large (as defined by sizeof) then we put them into the
-        graph on their own by using dask.delayed
-    """
-    if is_dask_collection(x):
-        return x
-    elif isinstance(x, str) and re.match(r"_\d+", x):
-        return delayed(x)
-    elif isinstance(x, list) and len(x) >= 10:
-        return delayed(x)
-    elif sizeof(x) > 1e6:
-        return delayed(x)
-    else:
-        return x
-
-
-def _pass_extra_kwargs(func, keys, *args, **kwargs):
-    """Helper for :func:`map_blocks` to pass `block_info` or `block_id`.
-
-    For each element of `keys`, a corresponding element of args is changed
-    to a keyword argument with that key, before all arguments re passed on
-    to `func`.
-    """
-    kwargs.update(zip(keys, args))
-    return func(*args[len(keys) :], **kwargs)
-
-
-def map_blocks(
-    func,
-    *args,
-    name=None,
-    token=None,
-    dtype=None,
-    chunks=None,
-    drop_axis=[],
-    new_axis=None,
-    meta=None,
-    **kwargs,
-):
-    """Map a function across all blocks of a dask array.
-
-    Parameters
-    ----------
-    func : callable
-        Function to apply to every block in the array.
-    args : dask arrays or other objects
-    dtype : np.dtype, optional
-        The ``dtype`` of the output array. It is recommended to provide this.
-        If not provided, will be inferred by applying the function to a small
-        set of fake data.
-    chunks : tuple, optional
-        Chunk shape of resulting blocks if the function does not preserve
-        shape. If not provided, the resulting array is assumed to have the same
-        block structure as the first input array.
-    drop_axis : number or iterable, optional
-        Dimensions lost by the function.
-    new_axis : number or iterable, optional
-        New dimensions created by the function. Note that these are applied
-        after ``drop_axis`` (if present).
-    token : string, optional
-        The key prefix to use for the output array. If not provided, will be
-        determined from the function name.
-    name : string, optional
-        The key name to use for the output array. Note that this fully
-        specifies the output key name, and must be unique. If not provided,
-        will be determined by a hash of the arguments.
-    **kwargs :
-        Other keyword arguments to pass to function. Values must be constants
-        (not dask.arrays)
-
-    See Also
-    --------
-    dask.array.blockwise : Generalized operation with control over block alignment.
-
-    Examples
-    --------
-    >>> import dask.array as da
-    >>> x = da.arange(6, chunks=3)
-
-    >>> x.map_blocks(lambda x: x * 2).compute()
-    array([ 0,  2,  4,  6,  8, 10])
-
-    The ``da.map_blocks`` function can also accept multiple arrays.
-
-    >>> d = da.arange(5, chunks=2)
-    >>> e = da.arange(5, chunks=2)
-
-    >>> f = map_blocks(lambda a, b: a + b**2, d, e)
-    >>> f.compute()
-    array([ 0,  2,  6, 12, 20])
-
-    If the function changes shape of the blocks then you must provide chunks
-    explicitly.
-
-    >>> y = x.map_blocks(lambda x: x[::2], chunks=((2, 2),))
-
-    You have a bit of freedom in specifying chunks.  If all of the output chunk
-    sizes are the same, you can provide just that chunk size as a single tuple.
-
-    >>> a = da.arange(18, chunks=(6,))
-    >>> b = a.map_blocks(lambda x: x[:3], chunks=(3,))
-
-    If the function changes the dimension of the blocks you must specify the
-    created or destroyed dimensions.
-
-    >>> b = a.map_blocks(lambda x: x[None, :, None], chunks=(1, 6, 1),
-    ...                  new_axis=[0, 2])
-
-    If ``chunks`` is specified but ``new_axis`` is not, then it is inferred to
-    add the necessary number of axes on the left.
-
-    Map_blocks aligns blocks by block positions without regard to shape. In the
-    following example we have two arrays with the same number of blocks but
-    with different shape and chunk sizes.
-
-    >>> x = da.arange(1000, chunks=(100,))
-    >>> y = da.arange(100, chunks=(10,))
-
-    The relevant attribute to match is numblocks.
-
-    >>> x.numblocks
-    (10,)
-    >>> y.numblocks
-    (10,)
-
-    If these match (up to broadcasting rules) then we can map arbitrary
-    functions across blocks
-
-    >>> def func(a, b):
-    ...     return np.array([a.max(), b.max()])
-
-    >>> da.map_blocks(func, x, y, chunks=(2,), dtype='i8')
-    dask.array<func, shape=(20,), dtype=int64, chunksize=(2,), chunktype=numpy.ndarray>
-
-    >>> _.compute()
-    array([ 99,   9, 199,  19, 299,  29, 399,  39, 499,  49, 599,  59, 699,
-            69, 799,  79, 899,  89, 999,  99])
-
-    Your block function get information about where it is in the array by
-    accepting a special ``block_info`` keyword argument.
-
-    >>> def func(block, block_info=None):
-    ...     pass
-
-    This will receive the following information:
-
-    >>> block_info  # doctest: +SKIP
-    {0: {'shape': (1000,),
-         'num-chunks': (10,),
-         'chunk-location': (4,),
-         'array-location': [(400, 500)]},
-     None: {'shape': (1000,),
-            'num-chunks': (10,),
-            'chunk-location': (4,),
-            'array-location': [(400, 500)],
-            'chunk-shape': (100,),
-            'dtype': dtype('float64')}}
-
-    For each argument and keyword arguments that are dask arrays (the positions
-    of which are the first index), you will receive the shape of the full
-    array, the number of chunks of the full array in each dimension, the chunk
-    location (for example the fourth chunk over in the first dimension), and
-    the array location (for example the slice corresponding to ``40:50``). The
-    same information is provided for the output, with the key ``None``, plus
-    the shape and dtype that should be returned.
-
-    These features can be combined to synthesize an array from scratch, for
-    example:
-
-    >>> def func(block_info=None):
-    ...     loc = block_info[None]['array-location'][0]
-    ...     return np.arange(loc[0], loc[1])
-
-    >>> da.map_blocks(func, chunks=((4, 4),), dtype=np.float_)
-    dask.array<func, shape=(8,), dtype=float64, chunksize=(4,), chunktype=numpy.ndarray>
-
-    >>> _.compute()
-    array([0, 1, 2, 3, 4, 5, 6, 7])
-
-    You may specify the key name prefix of the resulting task in the graph with
-    the optional ``token`` keyword argument.
-
-    >>> x.map_blocks(lambda x: x + 1, name='increment')  # doctest: +SKIP
-    dask.array<increment, shape=(100,), dtype=int64, chunksize=(10,), chunktype=numpy.ndarray>
-    """
-    if not callable(func):
-        msg = (
-            "First argument must be callable function, not %s\n"
-            "Usage:   da.map_blocks(function, x)\n"
-            "   or:   da.map_blocks(function, x, y, z)"
-        )
-        raise TypeError(msg % type(func).__name__)
-    if token:
-        warnings.warn("The token= keyword to map_blocks has been moved to name=")
-        name = token
-
-    name = "%s-%s" % (name or funcname(func), tokenize(func, *args, **kwargs))
-    new_axes = {}
-
-    if isinstance(drop_axis, Number):
-        drop_axis = [drop_axis]
-    if isinstance(new_axis, Number):
-        new_axis = [new_axis]  # TODO: handle new_axis
-
-    arrs = [a for a in args if isinstance(a, Array)]
-
-    argpairs = [
-        (a, tuple(range(a.ndim))[::-1]) if isinstance(a, Array) else (a, None)
-        for a in args
-    ]
-    if arrs:
-        out_ind = tuple(range(max(a.ndim for a in arrs)))[::-1]
-    else:
-        out_ind = ()
-
-    original_kwargs = kwargs
-
-    if dtype is None and meta is None:
-        dtype = apply_infer_dtype(func, args, original_kwargs, "map_blocks")
-
-    if drop_axis:
-        out_ind = tuple(x for i, x in enumerate(out_ind) if i not in drop_axis)
-    if new_axis is None and chunks is not None and len(out_ind) < len(chunks):
-        new_axis = range(len(chunks) - len(out_ind))
-    if new_axis:
-        # new_axis = [x + len(drop_axis) for x in new_axis]
-        out_ind = list(out_ind)
-        for ax in sorted(new_axis):
-            n = len(out_ind) + len(drop_axis)
-            out_ind.insert(ax, n)
-            if chunks is not None:
-                new_axes[n] = chunks[ax]
-            else:
-                new_axes[n] = 1
-        out_ind = tuple(out_ind)
-        if max(new_axis) > max(out_ind):
-            raise ValueError("New_axis values do not fill in all dimensions")
-
-    if chunks is not None:
-        if len(chunks) != len(out_ind):
-            raise ValueError(
-                "Provided chunks have {0} dims, expected {1} "
-                "dims.".format(len(chunks), len(out_ind))
-            )
-        adjust_chunks = dict(zip(out_ind, chunks))
-    else:
-        adjust_chunks = None
-
-    out = blockwise(
-        func,
-        out_ind,
-        *concat(argpairs),
-        name=name,
-        new_axes=new_axes,
-        dtype=dtype,
-        concatenate=True,
-        align_arrays=False,
-        adjust_chunks=adjust_chunks,
-        meta=meta,
-        **kwargs,
-    )
-
-    extra_argpairs = []
-    extra_names = []
-    # If func has block_id as an argument, construct an array of block IDs and
-    # prepare to inject it.
-    if has_keyword(func, "block_id"):
-        block_id_name = "block-id-" + out.name
-        block_id_dsk = {
-            (block_id_name,) + block_id: block_id
-            for block_id in product(*(range(len(c)) for c in out.chunks))
-        }
-        block_id_array = Array(
-            block_id_dsk,
-            block_id_name,
-            chunks=tuple((1,) * len(c) for c in out.chunks),
-            dtype=np.object_,
-        )
-        extra_argpairs.append((block_id_array, out_ind))
-        extra_names.append("block_id")
-
-    # If func has block_info as an argument, construct an array of block info
-    # objects and prepare to inject it.
-    if has_keyword(func, "block_info"):
-        starts = {}
-        num_chunks = {}
-        shapes = {}
-
-        for i, (arg, in_ind) in enumerate(argpairs):
-            if in_ind is not None:
-                shapes[i] = arg.shape
-                if drop_axis:
-                    # We concatenate along dropped axes, so we need to treat them
-                    # as if there is only a single chunk.
-                    starts[i] = [
-                        (
-                            cached_cumsum(arg.chunks[j], initial_zero=True)
-                            if ind in out_ind
-                            else [0, arg.shape[j]]
-                        )
-                        for j, ind in enumerate(in_ind)
-                    ]
-                    num_chunks[i] = tuple(len(s) - 1 for s in starts[i])
-                else:
-                    starts[i] = [
-                        cached_cumsum(c, initial_zero=True) for c in arg.chunks
-                    ]
-                    num_chunks[i] = arg.numblocks
-        out_starts = [cached_cumsum(c, initial_zero=True) for c in out.chunks]
-
-        block_info_name = "block-info-" + out.name
-        block_info_dsk = {}
-        for block_id in product(*(range(len(c)) for c in out.chunks)):
-            # Get position of chunk, indexed by axis labels
-            location = {out_ind[i]: loc for i, loc in enumerate(block_id)}
-            info = {}
-            for i, shape in shapes.items():
-                # Compute chunk key in the array, taking broadcasting into
-                # account. We don't directly know which dimensions are
-                # broadcast, but any dimension with only one chunk can be
-                # treated as broadcast.
-                arr_k = tuple(
-                    location.get(ind, 0) if num_chunks[i][j] > 1 else 0
-                    for j, ind in enumerate(argpairs[i][1])
-                )
-                info[i] = {
-                    "shape": shape,
-                    "num-chunks": num_chunks[i],
-                    "array-location": [
-                        (starts[i][ij][j], starts[i][ij][j + 1])
-                        for ij, j in enumerate(arr_k)
-                    ],
-                    "chunk-location": arr_k,
-                }
-
-            info[None] = {
-                "shape": out.shape,
-                "num-chunks": out.numblocks,
-                "array-location": [
-                    (out_starts[ij][j], out_starts[ij][j + 1])
-                    for ij, j in enumerate(block_id)
-                ],
-                "chunk-location": block_id,
-                "chunk-shape": tuple(
-                    out.chunks[ij][j] for ij, j in enumerate(block_id)
-                ),
-                "dtype": dtype,
-            }
-            block_info_dsk[(block_info_name,) + block_id] = info
-
-        block_info = Array(
-            block_info_dsk,
-            block_info_name,
-            chunks=tuple((1,) * len(c) for c in out.chunks),
-            dtype=np.object_,
-        )
-        extra_argpairs.append((block_info, out_ind))
-        extra_names.append("block_info")
-
-    if extra_argpairs:
-        # Rewrite the Blockwise layer. It would be nice to find a way to
-        # avoid doing it twice, but it's currently needed to determine
-        # out.chunks from the first pass. Since it constructs a Blockwise
-        # rather than an expanded graph, it shouldn't be too expensive.
-        out = blockwise(
-            _pass_extra_kwargs,
-            out_ind,
-            func,
-            None,
-            tuple(extra_names),
-            None,
-            *concat(extra_argpairs),
-            *concat(argpairs),
-            name=out.name,
-            dtype=out.dtype,
-            concatenate=True,
-            align_arrays=False,
-            adjust_chunks=dict(zip(out_ind, out.chunks)),
-            meta=meta,
-            **kwargs,
-        )
-
-    return out
-
-
-def broadcast_chunks(*chunkss):
-    """Construct a chunks tuple that broadcasts many chunks tuples
-
-    >>> a = ((5, 5),)
-    >>> b = ((5, 5),)
-    >>> broadcast_chunks(a, b)
-    ((5, 5),)
-
-    >>> a = ((10, 10, 10), (5, 5),)
-    >>> b = ((5, 5),)
-    >>> broadcast_chunks(a, b)
-    ((10, 10, 10), (5, 5))
-
-    >>> a = ((10, 10, 10), (5, 5),)
-    >>> b = ((1,), (5, 5),)
-    >>> broadcast_chunks(a, b)
-    ((10, 10, 10), (5, 5))
-
-    >>> a = ((10, 10, 10), (5, 5),)
-    >>> b = ((3, 3,), (5, 5),)
-    >>> broadcast_chunks(a, b)
-    Traceback (most recent call last):
-        ...
-    ValueError: Chunks do not align: [(10, 10, 10), (3, 3)]
-    """
-    if not chunkss:
-        return ()
-    elif len(chunkss) == 1:
-        return chunkss[0]
-    n = max(map(len, chunkss))
-    chunkss2 = [((1,),) * (n - len(c)) + c for c in chunkss]
-    result = []
-    for i in range(n):
-        step1 = [c[i] for c in chunkss2]
-        if all(c == (1,) for c in step1):
-            step2 = step1
-        else:
-            step2 = [c for c in step1 if c != (1,)]
-        if len(set(step2)) != 1:
-            raise ValueError("Chunks do not align: %s" % str(step2))
-        result.append(step2[0])
-    return tuple(result)
-
-
-def store(
-    sources,
-    targets,
-    lock=True,
-    regions=None,
-    compute=True,
-    return_stored=False,
-    **kwargs,
-):
-    """Store dask arrays in array-like objects, overwrite data in target
-
-    This stores dask arrays into object that supports numpy-style setitem
-    indexing.  It stores values chunk by chunk so that it does not have to
-    fill up memory.  For best performance you can align the block size of
-    the storage target with the block size of your array.
-
-    If your data fits in memory then you may prefer calling
-    ``np.array(myarray)`` instead.
-
-    Parameters
-    ----------
-
-    sources: Array or iterable of Arrays
-    targets: array-like or Delayed or iterable of array-likes and/or Delayeds
-        These should support setitem syntax ``target[10:20] = ...``
-    lock: boolean or threading.Lock, optional
-        Whether or not to lock the data stores while storing.
-        Pass True (lock each file individually), False (don't lock) or a
-        particular ``threading.Lock`` object to be shared among all writes.
-    regions: tuple of slices or list of tuples of slices
-        Each ``region`` tuple in ``regions`` should be such that
-        ``target[region].shape = source.shape``
-        for the corresponding source and target in sources and targets,
-        respectively. If this is a tuple, the contents will be assumed to be
-        slices, so do not provide a tuple of tuples.
-    compute: boolean, optional
-        If true compute immediately, return ``dask.delayed.Delayed`` otherwise
-    return_stored: boolean, optional
-        Optionally return the stored result (default False).
-
-    Examples
-    --------
-    >>> x = ...  # doctest: +SKIP
-
-    >>> import h5py  # doctest: +SKIP
-    >>> f = h5py.File('myfile.hdf5', mode='a')  # doctest: +SKIP
-    >>> dset = f.create_dataset('/data', shape=x.shape,
-    ...                                  chunks=x.chunks,
-    ...                                  dtype='f8')  # doctest: +SKIP
-
-    >>> store(x, dset)  # doctest: +SKIP
-
-    Alternatively store many arrays at the same time
-
-    >>> store([x, y, z], [dset1, dset2, dset3])  # doctest: +SKIP
-    """
-
-    if isinstance(sources, Array):
-        sources = [sources]
-        targets = [targets]
-
-    if any(not isinstance(s, Array) for s in sources):
-        raise ValueError("All sources must be dask array objects")
-
-    if len(sources) != len(targets):
-        raise ValueError(
-            "Different number of sources [%d] and targets [%d]"
-            % (len(sources), len(targets))
-        )
-
-    if isinstance(regions, tuple) or regions is None:
-        regions = [regions]
-
-    if len(sources) > 1 and len(regions) == 1:
-        regions *= len(sources)
-
-    if len(sources) != len(regions):
-        raise ValueError(
-            "Different number of sources [%d] and targets [%d] than regions [%d]"
-            % (len(sources), len(targets), len(regions))
-        )
-
-    # Optimize all sources together
-    sources_dsk = HighLevelGraph.merge(*[e.__dask_graph__() for e in sources])
-    sources_dsk = Array.__dask_optimize__(
-        sources_dsk, list(core.flatten([e.__dask_keys__() for e in sources]))
-    )
-    sources2 = [Array(sources_dsk, e.name, e.chunks, meta=e) for e in sources]
-
-    # Optimize all targets together
-    targets2 = []
-    targets_keys = []
-    targets_dsk = []
-    for e in targets:
-        if isinstance(e, Delayed):
-            targets2.append(e.key)
-            targets_keys.extend(e.__dask_keys__())
-            targets_dsk.append(e.__dask_graph__())
-        elif is_dask_collection(e):
-            raise TypeError("Targets must be either Delayed objects or array-likes")
-        else:
-            targets2.append(e)
-
-    targets_dsk = HighLevelGraph.merge(*targets_dsk)
-    targets_dsk = Delayed.__dask_optimize__(targets_dsk, targets_keys)
-
-    load_stored = return_stored and not compute
-    toks = [str(uuid.uuid1()) for _ in range(len(sources))]
-    store_dsk = HighLevelGraph.merge(
-        *[
-            insert_to_ooc(s, t, lock, r, return_stored, load_stored, tok)
-            for s, t, r, tok in zip(sources2, targets2, regions, toks)
-        ]
-    )
-    store_keys = list(store_dsk.keys())
-
-    store_dsk = HighLevelGraph.merge(store_dsk, targets_dsk, sources_dsk)
-
-    if return_stored:
-        load_store_dsk = store_dsk
-        if compute:
-            store_dlyds = [Delayed(k, store_dsk) for k in store_keys]
-            store_dlyds = persist(*store_dlyds, **kwargs)
-            store_dsk_2 = HighLevelGraph.merge(*[e.dask for e in store_dlyds])
-
-            load_store_dsk = retrieve_from_ooc(store_keys, store_dsk, store_dsk_2)
-
-        result = tuple(
-            Array(load_store_dsk, "load-store-%s" % t, s.chunks, meta=s)
-            for s, t in zip(sources, toks)
-        )
-
-        return result
-    else:
-        name = "store-" + str(uuid.uuid1())
-        dsk = HighLevelGraph.merge({name: store_keys}, store_dsk)
-        result = Delayed(name, dsk)
-
-        if compute:
-            result.compute(**kwargs)
-            return None
-        else:
-            return result
-
-
-def blockdims_from_blockshape(shape, chunks):
-    """
-
-    >>> blockdims_from_blockshape((10, 10), (4, 3))
-    ((4, 4, 2), (3, 3, 3, 1))
-    >>> blockdims_from_blockshape((10, 0), (4, 0))
-    ((4, 4, 2), (0,))
-    """
-    if chunks is None:
-        raise TypeError("Must supply chunks= keyword argument")
-    if shape is None:
-        raise TypeError("Must supply shape= keyword argument")
-    if np.isnan(sum(shape)) or np.isnan(sum(chunks)):
-        raise ValueError(
-            "Array chunk sizes are unknown. shape: %s, chunks: %s%s"
-            % (shape, chunks, unknown_chunk_message)
-        )
-    if not all(map(is_integer, chunks)):
-        raise ValueError("chunks can only contain integers.")
-    if not all(map(is_integer, shape)):
-        raise ValueError("shape can only contain integers.")
-    shape = tuple(map(int, shape))
-    chunks = tuple(map(int, chunks))
-    return tuple(
-        ((bd,) * (d // bd) + ((d % bd,) if d % bd else ()) if d else (0,))
-        for d, bd in zip(shape, chunks)
-    )
-
-
-def finalize(results):
-    if not results:
-        return concatenate3(results)
-    results2 = results
-    while isinstance(results2, (tuple, list)):
-        if len(results2) > 1:
-            return concatenate3(results)
-        else:
-            results2 = results2[0]
-    return unpack_singleton(results)
-
-
-CHUNKS_NONE_ERROR_MESSAGE = """
-You must specify a chunks= keyword argument.
-This specifies the chunksize of your array blocks.
-
-See the following documentation page for details:
-  https://docs.dask.org/en/latest/array-creation.html#chunks
-""".strip()
-
-
-class Array(DaskMethodsMixin):
-    """Parallel Dask Array
-
-    A parallel nd-array comprised of many numpy arrays arranged in a grid.
-
-    This constructor is for advanced uses only.  For normal use see the
-    ``da.from_array`` function.
-
-    Parameters
-    ----------
-    dask : dict
-        Task dependency graph
-    name : string
-        Name of array in dask
-    shape : tuple of ints
-        Shape of the entire array
-    chunks: iterable of tuples
-        block sizes along each dimension
-    dtype : str or dtype
-        Typecode or data-type for the new Dask Array
-    meta : empty ndarray
-        empty ndarray created with same NumPy backend, ndim and dtype as the
-        Dask Array being created (overrides dtype)
-
-    See Also
-    --------
-    dask.array.from_array
-    """
-
-    __slots__ = "dask", "_name", "_cached_keys", "_chunks", "_meta"
-
-    def __new__(cls, dask, name, chunks, dtype=None, meta=None, shape=None):
-        self = super(Array, cls).__new__(cls)
-        assert isinstance(dask, Mapping)
-        if not isinstance(dask, HighLevelGraph):
-            dask = HighLevelGraph.from_collections(name, dask, dependencies=())
-        self.dask = dask
-        self.name = str(name)
-        meta = meta_from_array(meta, dtype=dtype)
-
-        if (
-            isinstance(chunks, str)
-            or isinstance(chunks, tuple)
-            and chunks
-            and any(isinstance(c, str) for c in chunks)
-        ):
-            dt = meta.dtype
-        else:
-            dt = None
-        self._chunks = normalize_chunks(chunks, shape, dtype=dt)
-        if self._chunks is None:
-            raise ValueError(CHUNKS_NONE_ERROR_MESSAGE)
-
-        self._meta = meta_from_array(meta, ndim=self.ndim, dtype=dtype)
-
-        for plugin in config.get("array_plugins", ()):
-            result = plugin(self)
-            if result is not None:
-                self = result
-
-        return self
-
-    def __reduce__(self):
-        return (Array, (self.dask, self.name, self.chunks, self.dtype))
-
-    def __dask_graph__(self):
-        return self.dask
-
-    def __dask_layers__(self):
-        return (self.name,)
-
-    def __dask_keys__(self):
-        if self._cached_keys is not None:
-            return self._cached_keys
-
-        name, chunks, numblocks = self.name, self.chunks, self.numblocks
-
-        def keys(*args):
-            if not chunks:
-                return [(name,)]
-            ind = len(args)
-            if ind + 1 == len(numblocks):
-                result = [(name,) + args + (i,) for i in range(numblocks[ind])]
-            else:
-                result = [keys(*(args + (i,))) for i in range(numblocks[ind])]
-            return result
-
-        self._cached_keys = result = keys()
-        return result
-
-    def __dask_tokenize__(self):
-        return self.name
-
-    __dask_optimize__ = globalmethod(
-        optimize, key="array_optimize", falsey=dont_optimize
-    )
-    __dask_scheduler__ = staticmethod(threaded.get)
-
-    def __dask_postcompute__(self):
-        return finalize, ()
-
-    def __dask_postpersist__(self):
-        return Array, (self.name, self.chunks, self.dtype, self._meta)
-
-    @property
-    def numblocks(self):
-        return tuple(map(len, self.chunks))
-
-    @property
-    def npartitions(self):
-        return reduce(mul, self.numblocks, 1)
-
-    def compute_chunk_sizes(self):
-        """
-        Compute the chunk sizes for a Dask array. This is especially useful
-        when the chunk sizes are unknown (e.g., when indexing one Dask array
-        with another).
-
-        Notes
-        -----
-        This function modifies the Dask array in-place.
-
-        Examples
-        --------
-        >>> import dask.array as da
-        >>> import numpy as np
-        >>> x = da.from_array([-2, -1, 0, 1, 2], chunks=2)
-        >>> x.chunks
-        ((2, 2, 1),)
-        >>> y = x[x <= 0]
-        >>> y.chunks
-        ((nan, nan, nan),)
-        >>> y.compute_chunk_sizes()  # in-place computation
-        dask.array<getitem, shape=(3,), dtype=int64, chunksize=(2,), chunktype=numpy.ndarray>
-        >>> y.chunks
-        ((2, 1, 0),)
-
-        """
-        x = self
-        chunk_shapes = x.map_blocks(
-            _get_chunk_shape,
-            dtype=int,
-            chunks=tuple(len(c) * (1,) for c in x.chunks) + ((x.ndim,),),
-            new_axis=x.ndim,
-        )
-
-        c = []
-        for i in range(x.ndim):
-            s = x.ndim * [0] + [i]
-            s[i] = slice(None)
-            s = tuple(s)
-
-            c.append(tuple(chunk_shapes[s]))
-
-        # `map_blocks` assigns numpy dtypes
-        # cast chunk dimensions back to python int before returning
-        x._chunks = tuple(
-            [tuple([int(chunk) for chunk in chunks]) for chunks in compute(tuple(c))[0]]
-        )
-        return x
-
-    @property
-    def shape(self):
-        return tuple(cached_cumsum(c, initial_zero=True)[-1] for c in self.chunks)
-
-    @property
-    def chunksize(self):
-        return tuple(max(c) for c in self.chunks)
-
-    @property
-    def dtype(self):
-        return self._meta.dtype
-
-    def _get_chunks(self):
-        return self._chunks
-
-    def _set_chunks(self, chunks):
-        msg = (
-            "Can not set chunks directly\n\n"
-            "Please use the rechunk method instead:\n"
-            "  x.rechunk({})\n\n"
-            "If trying to avoid unknown chunks, use\n"
-            "  x.compute_chunk_sizes()"
-        )
-        raise TypeError(msg.format(chunks))
-
-    chunks = property(_get_chunks, _set_chunks, "chunks property")
-
-    def __len__(self):
-        if not self.chunks:
-            raise TypeError("len() of unsized object")
-        return sum(self.chunks[0])
-
-    def __array_ufunc__(self, numpy_ufunc, method, *inputs, **kwargs):
-        out = kwargs.get("out", ())
-        for x in inputs + out:
-            if not isinstance(x, (np.ndarray, Number, Array)):
-                return NotImplemented
-
-        if method == "__call__":
-            if numpy_ufunc is np.matmul:
-                from .routines import matmul
-
-                # special case until apply_gufunc handles optional dimensions
-                return matmul(*inputs, **kwargs)
-            if numpy_ufunc.signature is not None:
-                from .gufunc import apply_gufunc
-
-                return apply_gufunc(
-                    numpy_ufunc, numpy_ufunc.signature, *inputs, **kwargs
-                )
-            if numpy_ufunc.nout > 1:
-                from . import ufunc
-
-                try:
-                    da_ufunc = getattr(ufunc, numpy_ufunc.__name__)
-                except AttributeError:
-                    return NotImplemented
-                return da_ufunc(*inputs, **kwargs)
-            else:
-                return elemwise(numpy_ufunc, *inputs, **kwargs)
-        elif method == "outer":
-            from . import ufunc
-
-            try:
-                da_ufunc = getattr(ufunc, numpy_ufunc.__name__)
-            except AttributeError:
-                return NotImplemented
-            return da_ufunc.outer(*inputs, **kwargs)
-        else:
-            return NotImplemented
-
-    def __repr__(self):
-        """
-
-        >>> import dask.array as da
-        >>> da.ones((10, 10), chunks=(5, 5), dtype='i4')
-        dask.array<..., shape=(10, 10), dtype=int32, chunksize=(5, 5), chunktype=numpy.ndarray>
-        """
-        chunksize = str(self.chunksize)
-        name = self.name.rsplit("-", 1)[0]
-        return "dask.array<%s, shape=%s, dtype=%s, chunksize=%s, chunktype=%s.%s>" % (
-            name,
-            self.shape,
-            self.dtype,
-            chunksize,
-            type(self._meta).__module__.split(".")[0],
-            type(self._meta).__name__,
-        )
-
-    def _repr_html_(self):
-        table = self._repr_html_table()
-        try:
-            grid = self.to_svg(size=config.get("array.svg.size", 120))
-        except NotImplementedError:
-            grid = ""
-
-        both = [
-            "<table>",
-            "<tr>",
-            "<td>",
-            table,
-            "</td>",
-            "<td>",
-            grid,
-            "</td>",
-            "</tr>",
-            "</table>",
-        ]
-        return "\n".join(both)
-
-    def _repr_html_table(self):
-        if "sparse" in typename(type(self._meta)):
-            nbytes = None
-            cbytes = None
-        elif not math.isnan(self.nbytes):
-            nbytes = format_bytes(self.nbytes)
-            cbytes = format_bytes(np.prod(self.chunksize) * self.dtype.itemsize)
-        else:
-            nbytes = "unknown"
-            cbytes = "unknown"
-
-        table = [
-            "<table>",
-            "  <thead>",
-            "    <tr><td> </td><th> Array </th><th> Chunk </th></tr>",
-            "  </thead>",
-            "  <tbody>",
-            "    <tr><th> Bytes </th><td> %s </td> <td> %s </td></tr>"
-            % (nbytes, cbytes)
-            if nbytes is not None
-            else "",
-            "    <tr><th> Shape </th><td> %s </td> <td> %s </td></tr>"
-            % (str(self.shape), str(self.chunksize)),
-            "    <tr><th> Count </th><td> %d Tasks </td><td> %d Chunks </td></tr>"
-            % (len(self.__dask_graph__()), self.npartitions),
-            "    <tr><th> Type </th><td> %s </td><td> %s.%s </td></tr>"
-            % (
-                self.dtype,
-                type(self._meta).__module__.split(".")[0],
-                type(self._meta).__name__,
-            ),
-            "  </tbody>",
-            "</table>",
-        ]
-        return "\n".join(table)
-
-    @property
-    def ndim(self):
-        return len(self.shape)
-
-    @property
-    def size(self):
-        """ Number of elements in array """
-        return reduce(mul, self.shape, 1)
-
-    @property
-    def nbytes(self):
-        """ Number of bytes in array """
-        return self.size * self.dtype.itemsize
-
-    @property
-    def itemsize(self):
-        """ Length of one array element in bytes """
-        return self.dtype.itemsize
-
-    @property
-    def name(self):
-        return self._name
-
-    @name.setter
-    def name(self, val):
-        self._name = val
-        # Clear the key cache when the name is reset
-        self._cached_keys = None
-
-    __array_priority__ = 11  # higher than numpy.ndarray and numpy.matrix
-
-    def __array__(self, dtype=None, **kwargs):
-        x = self.compute()
-        if dtype and x.dtype != dtype:
-            x = x.astype(dtype)
-        if not isinstance(x, np.ndarray):
-            x = np.array(x)
-        return x
-
-    def __array_function__(self, func, types, args, kwargs):
-        import dask.array as module
-
-        def handle_nonmatching_names(func, args, kwargs):
-            if func not in _HANDLED_FUNCTIONS:
-                warnings.warn(
-                    "The `{}` function is not implemented by Dask array. "
-                    "You may want to use the da.map_blocks function "
-                    "or something similar to silence this warning. "
-                    "Your code may stop working in a future release.".format(
-                        func.__module__ + "." + func.__name__
-                    ),
-                    FutureWarning,
-                )
-                # Need to convert to array object (e.g. numpy.ndarray or
-                # cupy.ndarray) as needed, so we can call the NumPy function
-                # again and it gets the chance to dispatch to the right
-                # implementation.
-                args, kwargs = compute(args, kwargs)
-                return func(*args, **kwargs)
-
-            return _HANDLED_FUNCTIONS[func](*args, **kwargs)
-
-        # First try to find a matching function name.  If that doesn't work, we may
-        # be dealing with an alias or a function that's simply not in the Dask API.
-        # Handle aliases via the _HANDLED_FUNCTIONS dict mapping, and warn otherwise.
-        for submodule in func.__module__.split(".")[1:]:
-            try:
-                module = getattr(module, submodule)
-            except AttributeError:
-                return handle_nonmatching_names(func, args, kwargs)
-
-        if not hasattr(module, func.__name__):
-            return handle_nonmatching_names(func, args, kwargs)
-
-        da_func = getattr(module, func.__name__)
-        if da_func is func:
-            return handle_nonmatching_names(func, args, kwargs)
-        return da_func(*args, **kwargs)
-
-    @property
-    def _elemwise(self):
-        return elemwise
-
-    @wraps(store)
-    def store(self, target, **kwargs):
-        r = store([self], [target], **kwargs)
-
-        if kwargs.get("return_stored", False):
-            r = r[0]
-
-        return r
-
-    def to_svg(self, size=500):
-        """Convert chunks from Dask Array into an SVG Image
-
-        Parameters
-        ----------
-        chunks: tuple
-        size: int
-            Rough size of the image
-
-        Examples
-        --------
-        >>> x.to_svg(size=500)  # doctest: +SKIP
-
-        Returns
-        -------
-        text: An svg string depicting the array as a grid of chunks
-        """
-        from .svg import svg
-
-        return svg(self.chunks, size=size)
-
-    def to_hdf5(self, filename, datapath, **kwargs):
-        """Store array in HDF5 file
-
-        >>> x.to_hdf5('myfile.hdf5', '/x')  # doctest: +SKIP
-
-        Optionally provide arguments as though to ``h5py.File.create_dataset``
-
-        >>> x.to_hdf5('myfile.hdf5', '/x', compression='lzf', shuffle=True)  # doctest: +SKIP
-
-        See Also
-        --------
-        da.store
-        h5py.File.create_dataset
-        """
-        return to_hdf5(filename, datapath, self, **kwargs)
-
-    def to_dask_dataframe(self, columns=None, index=None, meta=None):
-        """Convert dask Array to dask Dataframe
-
-        Parameters
-        ----------
-        columns: list or string
-            list of column names if DataFrame, single string if Series
-        index : dask.dataframe.Index, optional
-            An optional *dask* Index to use for the output Series or DataFrame.
-
-            The default output index depends on whether the array has any unknown
-            chunks. If there are any unknown chunks, the output has ``None``
-            for all the divisions (one per chunk). If all the chunks are known,
-            a default index with known divsions is created.
-
-            Specifying ``index`` can be useful if you're conforming a Dask Array
-            to an existing dask Series or DataFrame, and you would like the
-            indices to match.
-        meta : object, optional
-            An optional `meta` parameter can be passed for dask
-            to specify the concrete dataframe type to use for partitions of
-            the Dask dataframe. By default, pandas DataFrame is used.
-
-        See Also
-        --------
-        dask.dataframe.from_dask_array
-        """
-        from ..dataframe import from_dask_array
-
-        return from_dask_array(self, columns=columns, index=index, meta=meta)
-
-    def __bool__(self):
-        if self.size > 1:
-            raise ValueError(
-                "The truth value of a {0} is ambiguous. "
-                "Use a.any() or a.all().".format(self.__class__.__name__)
-            )
-        else:
-            return bool(self.compute())
-
-    __nonzero__ = __bool__  # python 2
-
-    def _scalarfunc(self, cast_type):
-        if self.size > 1:
-            raise TypeError("Only length-1 arrays can be converted to Python scalars")
-        else:
-            return cast_type(self.compute())
-
-    def __int__(self):
-        return self._scalarfunc(int)
-
-    __long__ = __int__  # python 2
-
-    def __float__(self):
-        return self._scalarfunc(float)
-
-    def __complex__(self):
-        return self._scalarfunc(complex)
-
-    def __setitem__(self, key, value):
-        from .routines import where
-
-        if isinstance(key, Array):
-            if isinstance(value, Array) and value.ndim > 1:
-                raise ValueError("boolean index array should have 1 dimension")
-            y = where(key, value, self)
-            self._meta = y._meta
-            self.dask = y.dask
-            self.name = y.name
-            self._chunks = y.chunks
-            return self
-        else:
-            raise NotImplementedError(
-                "Item assignment with %s not supported" % type(key)
-            )
-
-    def __getitem__(self, index):
-        # Field access, e.g. x['a'] or x[['a', 'b']]
-        if isinstance(index, str) or (
-            isinstance(index, list) and index and all(isinstance(i, str) for i in index)
-        ):
-            if isinstance(index, str):
-                dt = self.dtype[index]
-            else:
-                dt = _make_sliced_dtype(self.dtype, index)
-
-            if dt.shape:
-                new_axis = list(range(self.ndim, self.ndim + len(dt.shape)))
-                chunks = self.chunks + tuple((i,) for i in dt.shape)
-                return self.map_blocks(
-                    getitem, index, dtype=dt.base, chunks=chunks, new_axis=new_axis
-                )
-            else:
-                return self.map_blocks(getitem, index, dtype=dt)
-
-        if not isinstance(index, tuple):
-            index = (index,)
-
-        from .slicing import (
-            normalize_index,
-            slice_with_int_dask_array,
-            slice_with_bool_dask_array,
-        )
-
-        index2 = normalize_index(index, self.shape)
-
-        dependencies = {self.name}
-        for i in index2:
-            if isinstance(i, Array):
-                dependencies.add(i.name)
-
-        if any(isinstance(i, Array) and i.dtype.kind in "iu" for i in index2):
-            self, index2 = slice_with_int_dask_array(self, index2)
-        if any(isinstance(i, Array) and i.dtype == bool for i in index2):
-            self, index2 = slice_with_bool_dask_array(self, index2)
-
-        if all(isinstance(i, slice) and i == slice(None) for i in index2):
-            return self
-
-        out = "getitem-" + tokenize(self, index2)
-        dsk, chunks = slice_array(out, self.name, self.chunks, index2)
-
-        graph = HighLevelGraph.from_collections(out, dsk, dependencies=[self])
-
-        meta = meta_from_array(self._meta, ndim=len(chunks))
-        if np.isscalar(meta):
-            meta = np.array(meta)
-
-        return Array(graph, out, chunks, meta=meta)
-
-    def _vindex(self, key):
-        if not isinstance(key, tuple):
-            key = (key,)
-        if any(k is None for k in key):
-            raise IndexError(
-                "vindex does not support indexing with None (np.newaxis), "
-                "got {}".format(key)
-            )
-        if all(isinstance(k, slice) for k in key):
-            if all(
-                k.indices(d) == slice(0, d).indices(d) for k, d in zip(key, self.shape)
-            ):
-                return self
-            raise IndexError(
-                "vindex requires at least one non-slice to vectorize over "
-                "when the slices are not over the entire array (i.e, x[:]). "
-                "Use normal slicing instead when only using slices. Got: {}".format(key)
-            )
-        return _vindex(self, *key)
-
-    @property
-    def vindex(self):
-        """Vectorized indexing with broadcasting.
-
-        This is equivalent to numpy's advanced indexing, using arrays that are
-        broadcast against each other. This allows for pointwise indexing:
-
-        >>> x = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
-        >>> x = from_array(x, chunks=2)
-        >>> x.vindex[[0, 1, 2], [0, 1, 2]].compute()
-        array([1, 5, 9])
-
-        Mixed basic/advanced indexing with slices/arrays is also supported. The
-        order of dimensions in the result follows those proposed for
-        `ndarray.vindex <https://github.com/numpy/numpy/pull/6256>`_:
-        the subspace spanned by arrays is followed by all slices.
-
-        Note: ``vindex`` provides more general functionality than standard
-        indexing, but it also has fewer optimizations and can be significantly
-        slower.
-        """
-        return IndexCallable(self._vindex)
-
-    def _blocks(self, index):
-        from .slicing import normalize_index
-
-        if not isinstance(index, tuple):
-            index = (index,)
-        if sum(isinstance(ind, (np.ndarray, list)) for ind in index) > 1:
-            raise ValueError("Can only slice with a single list")
-        if any(ind is None for ind in index):
-            raise ValueError("Slicing with np.newaxis or None is not supported")
-        index = normalize_index(index, self.numblocks)
-        index = tuple(slice(k, k + 1) if isinstance(k, Number) else k for k in index)
-
-        name = "blocks-" + tokenize(self, index)
-
-        new_keys = np.array(self.__dask_keys__(), dtype=object)[index]
-
-        chunks = tuple(
-            tuple(np.array(c)[i].tolist()) for c, i in zip(self.chunks, index)
-        )
-
-        keys = product(*(range(len(c)) for c in chunks))
-
-        layer = {(name,) + key: tuple(new_keys[key].tolist()) for key in keys}
-
-        graph = HighLevelGraph.from_collections(name, layer, dependencies=[self])
-        return Array(graph, name, chunks, meta=self)
-
-    @property
-    def blocks(self):
-        """Slice an array by blocks
-
-        This allows blockwise slicing of a Dask array.  You can perform normal
-        Numpy-style slicing but now rather than slice elements of the array you
-        slice along blocks so, for example, ``x.blocks[0, ::2]`` produces a new
-        dask array with every other block in the first row of blocks.
-
-        You can index blocks in any way that could index a numpy array of shape
-        equal to the number of blocks in each dimension, (available as
-        array.numblocks).  The dimension of the output array will be the same
-        as the dimension of this array, even if integer indices are passed.
-        This does not support slicing with ``np.newaxis`` or multiple lists.
-
-        Examples
-        --------
-        >>> import dask.array as da
-        >>> x = da.arange(10, chunks=2)
-        >>> x.blocks[0].compute()
-        array([0, 1])
-        >>> x.blocks[:3].compute()
-        array([0, 1, 2, 3, 4, 5])
-        >>> x.blocks[::2].compute()
-        array([0, 1, 4, 5, 8, 9])
-        >>> x.blocks[[-1, 0]].compute()
-        array([8, 9, 0, 1])
-
-        Returns
-        -------
-        A Dask array
-        """
-        return IndexCallable(self._blocks)
-
-    @property
-    def partitions(self):
-        """Slice an array by partitions. Alias of dask array .blocks attribute.
-
-        This alias allows you to write agnostic code that works with both
-        dask arrays and dask dataframes.
-
-        This allows blockwise slicing of a Dask array.  You can perform normal
-        Numpy-style slicing but now rather than slice elements of the array you
-        slice along blocks so, for example, ``x.blocks[0, ::2]`` produces a new
-        dask array with every other block in the first row of blocks.
-
-        You can index blocks in any way that could index a numpy array of shape
-        equal to the number of blocks in each dimension, (available as
-        array.numblocks).  The dimension of the output array will be the same
-        as the dimension of this array, even if integer indices are passed.
-        This does not support slicing with ``np.newaxis`` or multiple lists.
-
-        Examples
-        --------
-        >>> import dask.array as da
-        >>> x = da.arange(10, chunks=2)
-        >>> x.partitions[0].compute()
-        array([0, 1])
-        >>> x.partitions[:3].compute()
-        array([0, 1, 2, 3, 4, 5])
-        >>> x.partitions[::2].compute()
-        array([0, 1, 4, 5, 8, 9])
-        >>> x.partitions[[-1, 0]].compute()
-        array([8, 9, 0, 1])
-        >>> all(x.partitions[:].compute() == x.blocks[:].compute())
-        True
-
-        Returns
-        -------
-        A Dask array
-        """
-        return self.blocks
-
-    @derived_from(np.ndarray)
-    def dot(self, other):
-        from .routines import tensordot
-
-        return tensordot(self, other, axes=((self.ndim - 1,), (other.ndim - 2,)))
-
-    @property
-    def A(self):
-        return self
-
-    @property
-    def T(self):
-        return self.transpose()
-
-    @derived_from(np.ndarray)
-    def transpose(self, *axes):
-        from .routines import transpose
-
-        if not axes:
-            axes = None
-        elif len(axes) == 1 and isinstance(axes[0], Iterable):
-            axes = axes[0]
-        if (axes == tuple(range(self.ndim))) or (axes == tuple(range(-self.ndim, 0))):
-            # no transpose necessary
-            return self
-        else:
-            return transpose(self, axes=axes)
-
-    @derived_from(np.ndarray)
-    def ravel(self):
-        from .routines import ravel
-
-        return ravel(self)
-
-    flatten = ravel
-
-    @derived_from(np.ndarray)
-    def choose(self, choices):
-        from .routines import choose
-
-        return choose(self, choices)
-
-    @derived_from(np.ndarray)
-    def reshape(self, *shape):
-        from .reshape import reshape
-
-        if len(shape) == 1 and not isinstance(shape[0], Number):
-            shape = shape[0]
-        return reshape(self, shape)
-
-    def topk(self, k, axis=-1, split_every=None):
-        """The top k elements of an array.
-
-        See ``da.topk`` for docstring"""
-        from .reductions import topk
-
-        return topk(self, k, axis=axis, split_every=split_every)
-
-    def argtopk(self, k, axis=-1, split_every=None):
-        """The indices of the top k elements of an array.
-
-        See ``da.argtopk`` for docstring"""
-        from .reductions import argtopk
-
-        return argtopk(self, k, axis=axis, split_every=split_every)
-
-    def astype(self, dtype, **kwargs):
-        """Copy of the array, cast to a specified type.
-
-        Parameters
-        ----------
-        dtype : str or dtype
-            Typecode or data-type to which the array is cast.
-        casting : {'no', 'equiv', 'safe', 'same_kind', 'unsafe'}, optional
-            Controls what kind of data casting may occur. Defaults to 'unsafe'
-            for backwards compatibility.
-
-            * 'no' means the data types should not be cast at all.
-            * 'equiv' means only byte-order changes are allowed.
-            * 'safe' means only casts which can preserve values are allowed.
-            * 'same_kind' means only safe casts or casts within a kind,
-                like float64 to float32, are allowed.
-            * 'unsafe' means any data conversions may be done.
-        copy : bool, optional
-            By default, astype always returns a newly allocated array. If this
-            is set to False and the `dtype` requirement is satisfied, the input
-            array is returned instead of a copy.
-        """
-        # Scalars don't take `casting` or `copy` kwargs - as such we only pass
-        # them to `map_blocks` if specified by user (different than defaults).
-        extra = set(kwargs) - {"casting", "copy"}
-        if extra:
-            raise TypeError(
-                "astype does not take the following keyword "
-                "arguments: {0!s}".format(list(extra))
-            )
-        casting = kwargs.get("casting", "unsafe")
-        dtype = np.dtype(dtype)
-        if self.dtype == dtype:
-            return self
-        elif not np.can_cast(self.dtype, dtype, casting=casting):
-            raise TypeError(
-                "Cannot cast array from {0!r} to {1!r}"
-                " according to the rule "
-                "{2!r}".format(self.dtype, dtype, casting)
-            )
-        return self.map_blocks(chunk.astype, dtype=dtype, astype_dtype=dtype, **kwargs)
-
-    def __abs__(self):
-        return elemwise(operator.abs, self)
-
-    def __add__(self, other):
-        return elemwise(operator.add, self, other)
-
-    def __radd__(self, other):
-        return elemwise(operator.add, other, self)
-
-    def __and__(self, other):
-        return elemwise(operator.and_, self, other)
-
-    def __rand__(self, other):
-        return elemwise(operator.and_, other, self)
-
-    def __div__(self, other):
-        return elemwise(operator.div, self, other)
-
-    def __rdiv__(self, other):
-        return elemwise(operator.div, other, self)
-
-    def __eq__(self, other):
-        return elemwise(operator.eq, self, other)
-
-    def __gt__(self, other):
-        return elemwise(operator.gt, self, other)
-
-    def __ge__(self, other):
-        return elemwise(operator.ge, self, other)
-
-    def __invert__(self):
-        return elemwise(operator.invert, self)
-
-    def __lshift__(self, other):
-        return elemwise(operator.lshift, self, other)
-
-    def __rlshift__(self, other):
-        return elemwise(operator.lshift, other, self)
-
-    def __lt__(self, other):
-        return elemwise(operator.lt, self, other)
-
-    def __le__(self, other):
-        return elemwise(operator.le, self, other)
-
-    def __mod__(self, other):
-        return elemwise(operator.mod, self, other)
-
-    def __rmod__(self, other):
-        return elemwise(operator.mod, other, self)
-
-    def __mul__(self, other):
-        return elemwise(operator.mul, self, other)
-
-    def __rmul__(self, other):
-        return elemwise(operator.mul, other, self)
-
-    def __ne__(self, other):
-        return elemwise(operator.ne, self, other)
-
-    def __neg__(self):
-        return elemwise(operator.neg, self)
-
-    def __or__(self, other):
-        return elemwise(operator.or_, self, other)
-
-    def __pos__(self):
-        return self
-
-    def __ror__(self, other):
-        return elemwise(operator.or_, other, self)
-
-    def __pow__(self, other):
-        return elemwise(operator.pow, self, other)
-
-    def __rpow__(self, other):
-        return elemwise(operator.pow, other, self)
-
-    def __rshift__(self, other):
-        return elemwise(operator.rshift, self, other)
-
-    def __rrshift__(self, other):
-        return elemwise(operator.rshift, other, self)
-
-    def __sub__(self, other):
-        return elemwise(operator.sub, self, other)
-
-    def __rsub__(self, other):
-        return elemwise(operator.sub, other, self)
-
-    def __truediv__(self, other):
-        return elemwise(operator.truediv, self, other)
-
-    def __rtruediv__(self, other):
-        return elemwise(operator.truediv, other, self)
-
-    def __floordiv__(self, other):
-        return elemwise(operator.floordiv, self, other)
-
-    def __rfloordiv__(self, other):
-        return elemwise(operator.floordiv, other, self)
-
-    def __xor__(self, other):
-        return elemwise(operator.xor, self, other)
-
-    def __rxor__(self, other):
-        return elemwise(operator.xor, other, self)
-
-    def __matmul__(self, other):
-        from .routines import matmul
-
-        return matmul(self, other)
-
-    def __rmatmul__(self, other):
-        from .routines import matmul
-
-        return matmul(other, self)
-
-    def __divmod__(self, other):
-        from .ufunc import divmod
-
-        return divmod(self, other)
-
-    def __rdivmod__(self, other):
-        from .ufunc import divmod
-
-        return divmod(other, self)
-
-    @derived_from(np.ndarray)
-    def any(self, axis=None, keepdims=False, split_every=None, out=None):
-        from .reductions import any
-
-        return any(self, axis=axis, keepdims=keepdims, split_every=split_every, out=out)
-
-    @derived_from(np.ndarray)
-    def all(self, axis=None, keepdims=False, split_every=None, out=None):
-        from .reductions import all
-
-        return all(self, axis=axis, keepdims=keepdims, split_every=split_every, out=out)
-
-    @derived_from(np.ndarray)
-    def min(self, axis=None, keepdims=False, split_every=None, out=None):
-        from .reductions import min
-
-        return min(self, axis=axis, keepdims=keepdims, split_every=split_every, out=out)
-
-    @derived_from(np.ndarray)
-    def max(self, axis=None, keepdims=False, split_every=None, out=None):
-        from .reductions import max
-
-        return max(self, axis=axis, keepdims=keepdims, split_every=split_every, out=out)
-
-    @derived_from(np.ndarray)
-    def argmin(self, axis=None, split_every=None, out=None):
-        from .reductions import argmin
-
-        return argmin(self, axis=axis, split_every=split_every, out=out)
-
-    @derived_from(np.ndarray)
-    def argmax(self, axis=None, split_every=None, out=None):
-        from .reductions import argmax
-
-        return argmax(self, axis=axis, split_every=split_every, out=out)
-
-    @derived_from(np.ndarray)
-    def sum(self, axis=None, dtype=None, keepdims=False, split_every=None, out=None):
-        from .reductions import sum
-
-        return sum(
-            self,
-            axis=axis,
-            dtype=dtype,
-            keepdims=keepdims,
-            split_every=split_every,
-            out=out,
-        )
-
-    @derived_from(np.ndarray)
-    def trace(self, offset=0, axis1=0, axis2=1, dtype=None):
-        from .reductions import trace
-
-        return trace(self, offset=offset, axis1=axis1, axis2=axis2, dtype=dtype)
-
-    @derived_from(np.ndarray)
-    def prod(self, axis=None, dtype=None, keepdims=False, split_every=None, out=None):
-        from .reductions import prod
-
-        return prod(
-            self,
-            axis=axis,
-            dtype=dtype,
-            keepdims=keepdims,
-            split_every=split_every,
-            out=out,
-        )
-
-    @derived_from(np.ndarray)
-    def mean(self, axis=None, dtype=None, keepdims=False, split_every=None, out=None):
-        from .reductions import mean
-
-        return mean(
-            self,
-            axis=axis,
-            dtype=dtype,
-            keepdims=keepdims,
-            split_every=split_every,
-            out=out,
-        )
-
-    @derived_from(np.ndarray)
-    def std(
-        self, axis=None, dtype=None, keepdims=False, ddof=0, split_every=None, out=None
-    ):
-        from .reductions import std
-
-        return std(
-            self,
-            axis=axis,
-            dtype=dtype,
-            keepdims=keepdims,
-            ddof=ddof,
-            split_every=split_every,
-            out=out,
-        )
-
-    @derived_from(np.ndarray)
-    def var(
-        self, axis=None, dtype=None, keepdims=False, ddof=0, split_every=None, out=None
-    ):
-        from .reductions import var
-
-        return var(
-            self,
-            axis=axis,
-            dtype=dtype,
-            keepdims=keepdims,
-            ddof=ddof,
-            split_every=split_every,
-            out=out,
-        )
-
-    def moment(
-        self,
-        order,
-        axis=None,
-        dtype=None,
-        keepdims=False,
-        ddof=0,
-        split_every=None,
-        out=None,
-    ):
-        """Calculate the nth centralized moment.
-
-        Parameters
-        ----------
-        order : int
-            Order of the moment that is returned, must be >= 2.
-        axis : int, optional
-            Axis along which the central moment is computed. The default is to
-            compute the moment of the flattened array.
-        dtype : data-type, optional
-            Type to use in computing the moment. For arrays of integer type the
-            default is float64; for arrays of float types it is the same as the
-            array type.
-        keepdims : bool, optional
-            If this is set to True, the axes which are reduced are left in the
-            result as dimensions with size one. With this option, the result
-            will broadcast correctly against the original array.
-        ddof : int, optional
-            "Delta Degrees of Freedom": the divisor used in the calculation is
-            N - ddof, where N represents the number of elements. By default
-            ddof is zero.
-
-        Returns
-        -------
-        moment : ndarray
-
-        References
-        ----------
-        .. [1] Pebay, Philippe (2008), "Formulas for Robust, One-Pass Parallel
-           Computation of Covariances and Arbitrary-Order Statistical Moments",
-           Technical Report SAND2008-6212, Sandia National Laboratories.
-
-        """
-
-        from .reductions import moment
-
-        return moment(
-            self,
-            order,
-            axis=axis,
-            dtype=dtype,
-            keepdims=keepdims,
-            ddof=ddof,
-            split_every=split_every,
-            out=out,
-        )
-
-    @wraps(map_blocks)
-    def map_blocks(self, func, *args, **kwargs):
-        return map_blocks(func, self, *args, **kwargs)
-
-    def map_overlap(self, func, depth, boundary=None, trim=True, **kwargs):
-        """Map a function over blocks of the array with some overlap
-
-        We share neighboring zones between blocks of the array, then map a
-        function, then trim away the neighboring strips.
-
-        Parameters
-        ----------
-        func: function
-            The function to apply to each extended block
-        depth: int, tuple, or dict
-            The number of elements that each block should share with its neighbors
-            If a tuple or dict then this can be different per axis
-        boundary: str, tuple, dict
-            How to handle the boundaries.
-            Values include 'reflect', 'periodic', 'nearest', 'none',
-            or any constant value like 0 or np.nan
-        trim: bool
-            Whether or not to trim ``depth`` elements from each block after
-            calling the map function.
-            Set this to False if your mapping function already does this for you
-        **kwargs:
-            Other keyword arguments valid in ``map_blocks``
-
-        Examples
-        --------
-        >>> x = np.array([1, 1, 2, 3, 3, 3, 2, 1, 1])
-        >>> x = from_array(x, chunks=5)
-        >>> def derivative(x):
-        ...     return x - np.roll(x, 1)
-
-        >>> y = x.map_overlap(derivative, depth=1, boundary=0)
-        >>> y.compute()
-        array([ 1,  0,  1,  1,  0,  0, -1, -1,  0])
-
-        >>> import dask.array as da
-        >>> x = np.arange(16).reshape((4, 4))
-        >>> d = da.from_array(x, chunks=(2, 2))
-        >>> d.map_overlap(lambda x: x + x.size, depth=1).compute()
-        array([[16, 17, 18, 19],
-               [20, 21, 22, 23],
-               [24, 25, 26, 27],
-               [28, 29, 30, 31]])
-
-        >>> func = lambda x: x + x.size
-        >>> depth = {0: 1, 1: 1}
-        >>> boundary = {0: 'reflect', 1: 'none'}
-        >>> d.map_overlap(func, depth, boundary).compute()  # doctest: +NORMALIZE_WHITESPACE
-        array([[12,  13,  14,  15],
-               [16,  17,  18,  19],
-               [20,  21,  22,  23],
-               [24,  25,  26,  27]])
-        """
-        from .overlap import map_overlap
-
-        return map_overlap(
-            func, self, depth=depth, boundary=boundary, trim=trim, **kwargs
-        )
-
-    @derived_from(np.ndarray)
-    def cumsum(self, axis, dtype=None, out=None):
-        from .reductions import cumsum
-
-        return cumsum(self, axis, dtype, out=out)
-
-    @derived_from(np.ndarray)
-    def cumprod(self, axis, dtype=None, out=None):
-        from .reductions import cumprod
-
-        return cumprod(self, axis, dtype, out=out)
-
-    @derived_from(np.ndarray)
-    def squeeze(self, axis=None):
-        from .routines import squeeze
-
-        return squeeze(self, axis)
-
-    def rechunk(self, chunks="auto", threshold=None, block_size_limit=None):
-        """ See da.rechunk for docstring """
-        from . import rechunk  # avoid circular import
-
-        return rechunk(self, chunks, threshold, block_size_limit)
-
-    @property
-    def real(self):
-        from .ufunc import real
-
-        return real(self)
-
-    @property
-    def imag(self):
-        from .ufunc import imag
-
-        return imag(self)
-
-    def conj(self):
-        from .ufunc import conj
-
-        return conj(self)
-
-    @derived_from(np.ndarray)
-    def clip(self, min=None, max=None):
-        from .ufunc import clip
-
-        return clip(self, min, max)
-
-    def view(self, dtype=None, order="C"):
-        """Get a view of the array as a new data type
-
-        Parameters
-        ----------
-        dtype:
-            The dtype by which to view the array.
-            The default, None, results in the view having the same data-type
-            as the original array.
-        order: string
-            'C' or 'F' (Fortran) ordering
-
-        This reinterprets the bytes of the array under a new dtype.  If that
-        dtype does not have the same size as the original array then the shape
-        will change.
-
-        Beware that both numpy and dask.array can behave oddly when taking
-        shape-changing views of arrays under Fortran ordering.  Under some
-        versions of NumPy this function will fail when taking shape-changing
-        views of Fortran ordered arrays if the first dimension has chunks of
-        size one.
-        """
-        if dtype is None:
-            dtype = self.dtype
-        else:
-            dtype = np.dtype(dtype)
-        mult = self.dtype.itemsize / dtype.itemsize
-
-        if order == "C":
-            chunks = self.chunks[:-1] + (
-                tuple(ensure_int(c * mult) for c in self.chunks[-1]),
-            )
-        elif order == "F":
-            chunks = (
-                tuple(ensure_int(c * mult) for c in self.chunks[0]),
-            ) + self.chunks[1:]
-        else:
-            raise ValueError("Order must be one of 'C' or 'F'")
-
-        return self.map_blocks(
-            chunk.view, dtype, order=order, dtype=dtype, chunks=chunks
-        )
-
-    @derived_from(np.ndarray)
-    def swapaxes(self, axis1, axis2):
-        from .routines import swapaxes
-
-        return swapaxes(self, axis1, axis2)
-
-    @derived_from(np.ndarray)
-    def round(self, decimals=0):
-        from .routines import round
-
-        return round(self, decimals=decimals)
-
-    def copy(self):
-        """
-        Copy array.  This is a no-op for dask.arrays, which are immutable
-        """
-        if self.npartitions == 1:
-            return self.map_blocks(M.copy)
-        else:
-            return Array(self.dask, self.name, self.chunks, meta=self)
-
-    def __deepcopy__(self, memo):
-        c = self.copy()
-        memo[id(self)] = c
-        return c
-
-    def to_delayed(self, optimize_graph=True):
-        """Convert into an array of ``dask.delayed`` objects, one per chunk.
-
-        Parameters
-        ----------
-        optimize_graph : bool, optional
-            If True [default], the graph is optimized before converting into
-            ``dask.delayed`` objects.
-
-        See Also
-        --------
-        dask.array.from_delayed
-        """
-        keys = self.__dask_keys__()
-        graph = self.__dask_graph__()
-        if optimize_graph:
-            graph = self.__dask_optimize__(graph, keys)  # TODO, don't collape graph
-            name = "delayed-" + self.name
-            graph = HighLevelGraph.from_collections(name, graph, dependencies=())
-        L = ndeepmap(self.ndim, lambda k: Delayed(k, graph), keys)
-        return np.array(L, dtype=object)
-
-    @derived_from(np.ndarray)
-    def repeat(self, repeats, axis=None):
-        from .creation import repeat
-
-        return repeat(self, repeats, axis=axis)
-
-    @derived_from(np.ndarray)
-    def nonzero(self):
-        from .routines import nonzero
-
-        return nonzero(self)
-
-    def to_zarr(self, *args, **kwargs):
-        """Save array to the zarr storage format
-
-        See https://zarr.readthedocs.io for details about the format.
-
-        See function ``to_zarr()`` for parameters.
-        """
-        return to_zarr(self, *args, **kwargs)
-
-    def to_tiledb(self, uri, *args, **kwargs):
-        """Save array to the TileDB storage manager
-
-        See function ``to_tiledb()`` for argument documentation.
-
-        See https://docs.tiledb.io for details about the format and engine.
-        """
-        from .tiledb_io import to_tiledb
-
-        return to_tiledb(self, uri, *args, **kwargs)
-
-
-def ensure_int(f):
-    i = int(f)
-    if i != f:
-        raise ValueError("Could not coerce %f to integer" % f)
-    return i
-
-
-def normalize_chunks(chunks, shape=None, limit=None, dtype=None, previous_chunks=None):
-    """Normalize chunks to tuple of tuples
-
-    This takes in a variety of input types and information and produces a full
-    tuple-of-tuples result for chunks, suitable to be passed to Array or
-    rechunk or any other operation that creates a Dask array.
-
-    Parameters
-    ----------
-    chunks: tuple, int, dict, or string
-        The chunks to be normalized.  See examples below for more details
-    shape: Tuple[int]
-        The shape of the array
-    limit: int (optional)
-        The maximum block size to target in bytes,
-        if freedom is given to choose
-    dtype: np.dtype
-    previous_chunks: Tuple[Tuple[int]] optional
-        Chunks from a previous array that we should use for inspiration when
-        rechunking auto dimensions.  If not provided but auto-chunking exists
-        then auto-dimensions will prefer square-like chunk shapes.
-
-    Examples
-    --------
-    Specify uniform chunk sizes
-
-    >>> normalize_chunks((2, 2), shape=(5, 6))
-    ((2, 2, 1), (2, 2, 2))
-
-    Also passes through fully explicit tuple-of-tuples
-
-    >>> normalize_chunks(((2, 2, 1), (2, 2, 2)), shape=(5, 6))
-    ((2, 2, 1), (2, 2, 2))
-
-    Cleans up lists to tuples
-
-    >>> normalize_chunks([[2, 2], [3, 3]])
-    ((2, 2), (3, 3))
-
-    Expands integer inputs 10 -> (10, 10)
-
-    >>> normalize_chunks(10, shape=(30, 5))
-    ((10, 10, 10), (5,))
-
-    Expands dict inputs
-
-    >>> normalize_chunks({0: 2, 1: 3}, shape=(6, 6))
-    ((2, 2, 2), (3, 3))
-
-    The values -1 and None get mapped to full size
-
-    >>> normalize_chunks((5, -1), shape=(10, 10))
-    ((5, 5), (10,))
-
-    Use the value "auto" to automatically determine chunk sizes along certain
-    dimensions.  This uses the ``limit=`` and ``dtype=`` keywords to
-    determine how large to make the chunks.  The term "auto" can be used
-    anywhere an integer can be used.  See array chunking documentation for more
-    information.
-
-    >>> normalize_chunks(("auto",), shape=(20,), limit=5, dtype='uint8')
-    ((5, 5, 5, 5),)
-
-    You can also use byte sizes (see ``dask.utils.parse_bytes``) in place of
-    "auto" to ask for a particular size
-
-    >>> normalize_chunks("1kiB", shape=(2000,), dtype='float32')
-    ((250, 250, 250, 250, 250, 250, 250, 250),)
-
-    Respects null dimensions
-
-    >>> normalize_chunks((), shape=(0, 0))
-    ((0,), (0,))
-    """
-    if dtype and not isinstance(dtype, np.dtype):
-        dtype = np.dtype(dtype)
-    if chunks is None:
-        raise ValueError(CHUNKS_NONE_ERROR_MESSAGE)
-    if isinstance(chunks, list):
-        chunks = tuple(chunks)
-    if isinstance(chunks, (Number, str)):
-        chunks = (chunks,) * len(shape)
-    if isinstance(chunks, dict):
-        chunks = tuple(chunks.get(i, None) for i in range(len(shape)))
-    if isinstance(chunks, np.ndarray):
-        chunks = chunks.tolist()
-    if not chunks and shape and all(s == 0 for s in shape):
-        chunks = ((0,),) * len(shape)
-
-    if (
-        shape
-        and len(shape) == 1
-        and len(chunks) > 1
-        and all(isinstance(c, (Number, str)) for c in chunks)
-    ):
-        chunks = (chunks,)
-
-    if shape and len(chunks) != len(shape):
-        raise ValueError(
-            "Chunks and shape must be of the same length/dimension. "
-            "Got chunks=%s, shape=%s" % (chunks, shape)
-        )
-    if -1 in chunks or None in chunks:
-        chunks = tuple(s if c == -1 or c is None else c for c, s in zip(chunks, shape))
-
-    # If specifying chunk size in bytes, use that value to set the limit.
-    # Verify there is only one consistent value of limit or chunk-bytes used.
-    for c in chunks:
-        if isinstance(c, str) and c != "auto":
-            parsed = parse_bytes(c)
-            if limit is None:
-                limit = parsed
-            elif parsed != limit:
-                raise ValueError(
-                    "Only one consistent value of limit or chunk is allowed."
-                    "Used %s != %s" % (parsed, limit)
-                )
-    # Substitute byte limits with 'auto' now that limit is set.
-    chunks = tuple("auto" if isinstance(c, str) and c != "auto" else c for c in chunks)
-
-    if any(c == "auto" for c in chunks):
-        chunks = auto_chunks(chunks, shape, limit, dtype, previous_chunks)
-
-    if shape is not None:
-        chunks = tuple(c if c not in {None, -1} else s for c, s in zip(chunks, shape))
-
-    if chunks and shape is not None:
-        chunks = sum(
-            (
-                blockdims_from_blockshape((s,), (c,))
-                if not isinstance(c, (tuple, list))
-                else (c,)
-                for s, c in zip(shape, chunks)
-            ),
-            (),
-        )
-    for c in chunks:
-        if not c:
-            raise ValueError(
-                "Empty tuples are not allowed in chunks. Express "
-                "zero length dimensions with 0(s) in chunks"
-            )
-
-    if shape is not None:
-        if len(chunks) != len(shape):
-            raise ValueError(
-                "Input array has %d dimensions but the supplied "
-                "chunks has only %d dimensions" % (len(shape), len(chunks))
-            )
-        if not all(
-            c == s or (math.isnan(c) or math.isnan(s))
-            for c, s in zip(map(sum, chunks), shape)
-        ):
-            raise ValueError(
-                "Chunks do not add up to shape. "
-                "Got chunks=%s, shape=%s" % (chunks, shape)
-            )
-
-    return tuple(tuple(int(x) if not math.isnan(x) else x for x in c) for c in chunks)
-
-
-def _compute_multiplier(limit: int, dtype, largest_block: int, result):
-    """
-    Utility function for auto_chunk, to fin how much larger or smaller the ideal
-    chunk size is relative to what we have now.
-    """
-    return (
-        limit
-        / dtype.itemsize
-        / largest_block
-        / np.prod(list(r if r != 0 else 1 for r in result.values()))
-    )
-
-
-def auto_chunks(chunks, shape, limit, dtype, previous_chunks=None):
-    """Determine automatic chunks
-
-    This takes in a chunks value that contains ``"auto"`` values in certain
-    dimensions and replaces those values with concrete dimension sizes that try
-    to get chunks to be of a certain size in bytes, provided by the ``limit=``
-    keyword.  If multiple dimensions are marked as ``"auto"`` then they will
-    all respond to meet the desired byte limit, trying to respect the aspect
-    ratio of their dimensions in ``previous_chunks=``, if given.
-
-    Parameters
-    ----------
-    chunks: Tuple
-        A tuple of either dimensions or tuples of explicit chunk dimensions
-        Some entries should be "auto"
-    shape: Tuple[int]
-    limit: int, str
-        The maximum allowable size of a chunk in bytes
-    previous_chunks: Tuple[Tuple[int]]
-
-    See also
-    --------
-    normalize_chunks: for full docstring and parameters
-    """
-    if previous_chunks is not None:
-        previous_chunks = tuple(
-            c if isinstance(c, tuple) else (c,) for c in previous_chunks
-        )
-    chunks = list(chunks)
-
-    autos = {i for i, c in enumerate(chunks) if c == "auto"}
-    if not autos:
-        return tuple(chunks)
-
-    if limit is None:
-        limit = config.get("array.chunk-size")
-    if isinstance(limit, str):
-        limit = parse_bytes(limit)
-
-    if dtype is None:
-        raise TypeError("DType must be known for auto-chunking")
-
-    if dtype.hasobject:
-        raise NotImplementedError(
-            "Can not use auto rechunking with object dtype. "
-            "We are unable to estimate the size in bytes of object data"
-        )
-
-    for x in tuple(chunks) + tuple(shape):
-        if (
-            isinstance(x, Number)
-            and np.isnan(x)
-            or isinstance(x, tuple)
-            and np.isnan(x).any()
-        ):
-            raise ValueError(
-                "Can not perform automatic rechunking with unknown "
-                "(nan) chunk sizes.%s" % unknown_chunk_message
-            )
-
-    limit = max(1, limit)
-
-    largest_block = np.prod(
-        [cs if isinstance(cs, Number) else max(cs) for cs in chunks if cs != "auto"]
-    )
-
-    if previous_chunks:
-        # Base ideal ratio on the median chunk size of the previous chunks
-        result = {a: np.median(previous_chunks[a]) for a in autos}
-
-        ideal_shape = []
-        for i, s in enumerate(shape):
-            chunk_frequencies = frequencies(previous_chunks[i])
-            mode, count = max(chunk_frequencies.items(), key=lambda kv: kv[1])
-            if mode > 1 and count >= len(previous_chunks[i]) / 2:
-                ideal_shape.append(mode)
-            else:
-                ideal_shape.append(s)
-
-        # How much larger or smaller the ideal chunk size is relative to what we have now
-        multiplier = _compute_multiplier(limit, dtype, largest_block, result)
-
-        last_multiplier = 0
-        last_autos = set()
-        while (
-            multiplier != last_multiplier or autos != last_autos
-        ):  # while things change
-            last_multiplier = multiplier  # record previous values
-            last_autos = set(autos)  # record previous values
-
-            # Expand or contract each of the dimensions appropriately
-            for a in sorted(autos):
-                if ideal_shape[a] == 0:
-                    result[a] = 0
-                    continue
-                proposed = result[a] * multiplier ** (1 / len(autos))
-                if proposed > shape[a]:  # we've hit the shape boundary
-                    autos.remove(a)
-                    largest_block *= shape[a]
-                    chunks[a] = shape[a]
-                    del result[a]
-                else:
-                    result[a] = round_to(proposed, ideal_shape[a])
-
-            # recompute how much multiplier we have left, repeat
-            multiplier = _compute_multiplier(limit, dtype, largest_block, result)
-
-        for k, v in result.items():
-            chunks[k] = v
-        return tuple(chunks)
-
-    else:
-        size = (limit / dtype.itemsize / largest_block) ** (1 / len(autos))
-        small = [i for i in autos if shape[i] < size]
-        if small:
-            for i in small:
-                chunks[i] = (shape[i],)
-            return auto_chunks(chunks, shape, limit, dtype)
-
-        for i in autos:
-            chunks[i] = round_to(size, shape[i])
-
-        return tuple(chunks)
-
-
-def round_to(c, s):
-    """Return a chunk dimension that is close to an even multiple or factor
-
-    We want values for c that are nicely aligned with s.
-
-    If c is smaller than s then we want the largest factor of s that is less than the
-    desired chunk size, but not less than half, which is too much.  If no such
-    factor exists then we just go with the original chunk size and accept an
-    uneven chunk at the end.
-
-    If c is larger than s then we want the largest multiple of s that is still
-    smaller than c.
-    """
-    if c <= s:
-        try:
-            return max(f for f in factors(s) if c / 2 <= f <= c)
-        except ValueError:  # no matching factors within factor of two
-            return max(1, int(c))
-    else:
-        return c // s * s
-
-
-def _get_chunk_shape(a):
-    s = np.asarray(a.shape, dtype=int)
-    return s[len(s) * (None,) + (slice(None),)]
-
-
-def from_array(
-    x,
-    chunks="auto",
-    name=None,
-    lock=False,
-    asarray=None,
-    fancy=True,
-    getitem=None,
-    meta=None,
-):
-    """Create dask array from something that looks like an array
-
-    Input must have a ``.shape``, ``.ndim``, ``.dtype`` and support numpy-style slicing.
-
-    Parameters
-    ----------
-    x : array_like
-    chunks : int, tuple
-        How to chunk the array. Must be one of the following forms:
-
-        - A blocksize like 1000.
-        - A blockshape like (1000, 1000).
-        - Explicit sizes of all blocks along all dimensions like
-          ((1000, 1000, 500), (400, 400)).
-        - A size in bytes, like "100 MiB" which will choose a uniform
-          block-like shape
-        - The word "auto" which acts like the above, but uses a configuration
-          value ``array.chunk-size`` for the chunk size
-
-        -1 or None as a blocksize indicate the size of the corresponding
-        dimension.
-    name : str, optional
-        The key name to use for the array. Defaults to a hash of ``x``.
-        By default, hash uses python's standard sha1. This behaviour can be
-        changed by installing cityhash, xxhash or murmurhash. If installed,
-        a large-factor speedup can be obtained in the tokenisation step.
-        Use ``name=False`` to generate a random name instead of hashing (fast)
-
-        .. note::
-
-           Because this ``name`` is used as the key in task graphs, you should
-           ensure that it uniquely identifies the data contained within. If
-           you'd like to provide a descriptive name that is still unique, combine
-           the descriptive name with :func:`dask.base.tokenize` of the
-           ``array_like``. See :ref:`graphs` for more.
-
-    lock : bool or Lock, optional
-        If ``x`` doesn't support concurrent reads then provide a lock here, or
-        pass in True to have dask.array create one for you.
-    asarray : bool, optional
-        If True then call np.asarray on chunks to convert them to numpy arrays.
-        If False then chunks are passed through unchanged.
-        If None (default) then we use True if the ``__array_function__`` method
-        is undefined.
-    fancy : bool, optional
-        If ``x`` doesn't support fancy indexing (e.g. indexing with lists or
-        arrays) then set to False. Default is True.
-    meta : Array-like, optional
-        The metadata for the resulting dask array.  This is the kind of array
-        that will result from slicing the input array.
-        Defaults to the input array.
-
-    Examples
-    --------
-
-    >>> x = h5py.File('...')['/data/path']  # doctest: +SKIP
-    >>> a = da.from_array(x, chunks=(1000, 1000))  # doctest: +SKIP
-
-    If your underlying datastore does not support concurrent reads then include
-    the ``lock=True`` keyword argument or ``lock=mylock`` if you want multiple
-    arrays to coordinate around the same lock.
-
-    >>> a = da.from_array(x, chunks=(1000, 1000), lock=True)  # doctest: +SKIP
-
-    If your underlying datastore has a ``.chunks`` attribute (as h5py and zarr
-    datasets do) then a multiple of that chunk shape will be used if you
-    do not provide a chunk shape.
-
-    >>> a = da.from_array(x, chunks='auto')  # doctest: +SKIP
-    >>> a = da.from_array(x, chunks='100 MiB')  # doctest: +SKIP
-    >>> a = da.from_array(x)  # doctest: +SKIP
-
-    If providing a name, ensure that it is unique
-
-    >>> import dask.base
-    >>> token = dask.base.tokenize(x)  # doctest: +SKIP
-    >>> a = da.from_array('myarray-' + token)  # doctest: +SKIP
-    """
-    if isinstance(x, Array):
-        raise ValueError(
-            "Array is already a dask array. Use 'asarray' or " "'rechunk' instead."
-        )
-    elif is_dask_collection(x):
-        warnings.warn(
-            "Passing an object to dask.array.from_array which is already a "
-            "Dask collection. This can lead to unexpected behavior."
-        )
-
-    if isinstance(x, (list, tuple, memoryview) + np.ScalarType):
-        x = np.array(x)
-
-    if asarray is None:
-        asarray = not hasattr(x, "__array_function__")
-
-    previous_chunks = getattr(x, "chunks", None)
-
-    chunks = normalize_chunks(
-        chunks, x.shape, dtype=x.dtype, previous_chunks=previous_chunks
-    )
-
-    if name in (None, True):
-        token = tokenize(x, chunks)
-        original_name = "array-original-" + token
-        name = name or "array-" + token
-    elif name is False:
-        original_name = name = "array-" + str(uuid.uuid1())
-    else:
-        original_name = name
-
-    if lock is True:
-        lock = SerializableLock()
-
-    # Always use the getter for h5py etc. Not using isinstance(x, np.ndarray)
-    # because np.matrix is a subclass of np.ndarray.
-    if type(x) is np.ndarray and all(len(c) == 1 for c in chunks):
-        # No slicing needed
-        dsk = {(name,) + (0,) * x.ndim: x}
-    else:
-        if getitem is None:
-            if type(x) is np.ndarray and not lock:
-                # simpler and cleaner, but missing all the nuances of getter
-                getitem = operator.getitem
-            elif fancy:
-                getitem = getter
-            else:
-                getitem = getter_nofancy
-
-        dsk = getem(
-            original_name,
-            chunks,
-            getitem=getitem,
-            shape=x.shape,
-            out_name=name,
-            lock=lock,
-            asarray=asarray,
-            dtype=x.dtype,
-        )
-        dsk[original_name] = x
-
-    # Workaround for TileDB, its indexing is 1-based,
-    # and doesn't seems to support 0-length slicing
-    if x.__class__.__module__.split(".")[0] == "tiledb" and hasattr(x, "_ctx_"):
-        return Array(dsk, name, chunks, dtype=x.dtype)
-
-    if meta is None:
-        meta = x
-
-    return Array(dsk, name, chunks, meta=meta, dtype=getattr(x, "dtype", None))
-
-
-def from_zarr(
-    url, component=None, storage_options=None, chunks=None, name=None, **kwargs
-):
-    """Load array from the zarr storage format
-
-    See https://zarr.readthedocs.io for details about the format.
-
-    Parameters
-    ----------
-    url: Zarr Array or str or MutableMapping
-        Location of the data. A URL can include a protocol specifier like s3://
-        for remote data. Can also be any MutableMapping instance, which should
-        be serializable if used in multiple processes.
-    component: str or None
-        If the location is a zarr group rather than an array, this is the
-        subcomponent that should be loaded, something like ``'foo/bar'``.
-    storage_options: dict
-        Any additional parameters for the storage backend (ignored for local
-        paths)
-    chunks: tuple of ints or tuples of ints
-        Passed to ``da.from_array``, allows setting the chunks on
-        initialisation, if the chunking scheme in the on-disc dataset is not
-        optimal for the calculations to follow.
-    name : str, optional
-         An optional keyname for the array.  Defaults to hashing the input
-    kwargs: passed to ``zarr.Array``.
-    """
-    import zarr
-
-    storage_options = storage_options or {}
-    if isinstance(url, zarr.Array):
-        z = url
-    elif isinstance(url, str):
-        from ..bytes.core import get_mapper
-
-        mapper = get_mapper(url, **storage_options)
-        z = zarr.Array(mapper, read_only=True, path=component, **kwargs)
-    else:
-        mapper = url
-        z = zarr.Array(mapper, read_only=True, path=component, **kwargs)
-    chunks = chunks if chunks is not None else z.chunks
-    if name is None:
-        name = "from-zarr-" + tokenize(z, component, storage_options, chunks, **kwargs)
-    return from_array(z, chunks, name=name)
-
-
-def to_zarr(
-    arr,
-    url,
-    component=None,
-    storage_options=None,
-    overwrite=False,
-    compute=True,
-    return_stored=False,
-    **kwargs,
-):
-    """Save array to the zarr storage format
-
-    See https://zarr.readthedocs.io for details about the format.
-
-    Parameters
-    ----------
-    arr: dask.array
-        Data to store
-    url: Zarr Array or str or MutableMapping
-        Location of the data. A URL can include a protocol specifier like s3://
-        for remote data. Can also be any MutableMapping instance, which should
-        be serializable if used in multiple processes.
-    component: str or None
-        If the location is a zarr group rather than an array, this is the
-        subcomponent that should be created/over-written.
-    storage_options: dict
-        Any additional parameters for the storage backend (ignored for local
-        paths)
-    overwrite: bool
-        If given array already exists, overwrite=False will cause an error,
-        where overwrite=True will replace the existing data.  Note that this
-        check is done at computation time, not during graph creation.
-    compute, return_stored: see ``store()``
-    kwargs: passed to the ``zarr.create()`` function, e.g., compression options
-
-    Raises
-    ------
-    ValueError
-        If ``arr`` has unknown chunk sizes, which is not supported by Zarr.
-
-    See Also
-    --------
-    dask.array.Array.compute_chunk_sizes
-
-    """
-    import zarr
-
-    if np.isnan(arr.shape).any():
-        raise ValueError(
-            "Saving a dask array with unknown chunk sizes is not "
-            "currently supported by Zarr.%s" % unknown_chunk_message
-        )
-
-    if isinstance(url, zarr.Array):
-        z = url
-        if isinstance(z.store, (dict, zarr.DictStore)) and "distributed" in config.get(
-            "scheduler", ""
-        ):
-            raise RuntimeError(
-                "Cannot store into in memory Zarr Array using "
-                "the Distributed Scheduler."
-            )
-        arr = arr.rechunk(z.chunks)
-        return arr.store(z, lock=False, compute=compute, return_stored=return_stored)
-
-    if not _check_regular_chunks(arr.chunks):
-        raise ValueError(
-            "Attempt to save array to zarr with irregular "
-            "chunking, please call `arr.rechunk(...)` first."
-        )
-
-    storage_options = storage_options or {}
-
-    if isinstance(url, str):
-        from ..bytes.core import get_mapper
-
-        mapper = get_mapper(url, **storage_options)
-    else:
-        # assume the object passed is already a mapper
-        mapper = url
-
-    chunks = [c[0] for c in arr.chunks]
-
-    # The zarr.create function has the side-effect of immediately
-    # creating metadata on disk.  This may not be desired,
-    # particularly if compute=False.  The caller may be creating many
-    # arrays on a slow filesystem, with the desire that any I/O be
-    # sharded across workers (not done serially on the originating
-    # machine).  Or the caller may decide later to not to do this
-    # computation, and so nothing should be written to disk.
-    z = delayed(zarr.create)(
-        shape=arr.shape,
-        chunks=chunks,
-        dtype=arr.dtype,
-        store=mapper,
-        path=component,
-        overwrite=overwrite,
-        **kwargs,
-    )
-    return arr.store(z, lock=False, compute=compute, return_stored=return_stored)
-
-
-def _check_regular_chunks(chunkset):
-    """Check if the chunks are regular
-
-    "Regular" in this context means that along every axis, the chunks all
-    have the same size, except the last one, which may be smaller
-
-    Parameters
-    ----------
-    chunkset: tuple of tuples of ints
-        From the ``.chunks`` attribute of an ``Array``
-
-    Returns
-    -------
-    True if chunkset passes, else False
-
-    Examples
-    --------
-    >>> import dask.array as da
-    >>> arr = da.zeros(10, chunks=(5, ))
-    >>> _check_regular_chunks(arr.chunks)
-    True
-
-    >>> arr = da.zeros(10, chunks=((3, 3, 3, 1), ))
-    >>> _check_regular_chunks(arr.chunks)
-    True
-
-    >>> arr = da.zeros(10, chunks=((3, 1, 3, 3), ))
-    >>> _check_regular_chunks(arr.chunks)
-    False
-    """
-    for chunks in chunkset:
-        if len(chunks) == 1:
-            continue
-        if len(set(chunks[:-1])) > 1:
-            return False
-        if chunks[-1] > chunks[0]:
-            return False
-    return True
-
-
-def from_delayed(value, shape, dtype=None, meta=None, name=None):
-    """Create a dask array from a dask delayed value
-
-    This routine is useful for constructing dask arrays in an ad-hoc fashion
-    using dask delayed, particularly when combined with stack and concatenate.
-
-    The dask array will consist of a single chunk.
-
-    Examples
-    --------
-    >>> import dask
-    >>> import dask.array as da
-    >>> value = dask.delayed(np.ones)(5)
-    >>> array = da.from_delayed(value, (5,), dtype=float)
-    >>> array
-    dask.array<from-value, shape=(5,), dtype=float64, chunksize=(5,), chunktype=numpy.ndarray>
-    >>> array.compute()
-    array([1., 1., 1., 1., 1.])
-    """
-    from ..delayed import delayed, Delayed
-
-    if not isinstance(value, Delayed) and hasattr(value, "key"):
-        value = delayed(value)
-
-    name = name or "from-value-" + tokenize(value, shape, dtype, meta)
-    dsk = {(name,) + (0,) * len(shape): value.key}
-    chunks = tuple((d,) for d in shape)
-    # TODO: value._key may not be the name of the layer in value.dask
-    # This should be fixed after we build full expression graphs
-    graph = HighLevelGraph.from_collections(name, dsk, dependencies=[value])
-    return Array(graph, name, chunks, dtype=dtype, meta=meta)
-
-
-def from_func(func, shape, dtype=None, name=None, args=(), kwargs={}):
-    """Create dask array in a single block by calling a function
-
-    Calling the provided function with func(*args, **kwargs) should return a
-    NumPy array of the indicated shape and dtype.
-
-    Examples
-    --------
-
-    >>> a = from_func(np.arange, (3,), dtype='i8', args=(3,))
-    >>> a.compute()
-    array([0, 1, 2])
-
-    This works particularly well when coupled with dask.array functions like
-    concatenate and stack:
-
-    >>> arrays = [from_func(np.array, (), dtype='i8', args=(n,)) for n in range(5)]
-    >>> stack(arrays).compute()
-    array([0, 1, 2, 3, 4])
-    """
-    name = name or "from_func-" + tokenize(func, shape, dtype, args, kwargs)
-    if args or kwargs:
-        func = partial(func, *args, **kwargs)
-    dsk = {(name,) + (0,) * len(shape): (func,)}
-    chunks = tuple((i,) for i in shape)
-    return Array(dsk, name, chunks, dtype)
-
-
-def common_blockdim(blockdims):
-    """Find the common block dimensions from the list of block dimensions
-
-    Currently only implements the simplest possible heuristic: the common
-    block-dimension is the only one that does not span fully span a dimension.
-    This is a conservative choice that allows us to avoid potentially very
-    expensive rechunking.
-
-    Assumes that each element of the input block dimensions has all the same
-    sum (i.e., that they correspond to dimensions of the same size).
-
-    Examples
-    --------
-    >>> common_blockdim([(3,), (2, 1)])
-    (2, 1)
-    >>> common_blockdim([(1, 2), (2, 1)])
-    (1, 1, 1)
-    >>> common_blockdim([(2, 2), (3, 1)])  # doctest: +SKIP
-    Traceback (most recent call last):
-        ...
-    ValueError: Chunks do not align
-    """
-    if not any(blockdims):
-        return ()
-    non_trivial_dims = set([d for d in blockdims if len(d) > 1])
-    if len(non_trivial_dims) == 1:
-        return first(non_trivial_dims)
-    if len(non_trivial_dims) == 0:
-        return max(blockdims, key=first)
-
-    if np.isnan(sum(map(sum, blockdims))):
-        raise ValueError(
-            "Arrays chunk sizes (%s) are unknown.\n\n"
-            "A possible solution:\n"
-            "  x.compute_chunk_sizes()" % blockdims
-        )
-
-    if len(set(map(sum, non_trivial_dims))) > 1:
-        raise ValueError("Chunks do not add up to same value", blockdims)
-
-    # We have multiple non-trivial chunks on this axis
-    # e.g. (5, 2) and (4, 3)
-
-    # We create a single chunk tuple with the same total length
-    # that evenly divides both, e.g. (4, 1, 2)
-
-    # To accomplish this we walk down all chunk tuples together, finding the
-    # smallest element, adding it to the output, and subtracting it from all
-    # other elements and remove the element itself.  We stop once we have
-    # burned through all of the chunk tuples.
-    # For efficiency's sake we reverse the lists so that we can pop off the end
-    rchunks = [list(ntd)[::-1] for ntd in non_trivial_dims]
-    total = sum(first(non_trivial_dims))
-    i = 0
-
-    out = []
-    while i < total:
-        m = min(c[-1] for c in rchunks)
-        out.append(m)
-        for c in rchunks:
-            c[-1] -= m
-            if c[-1] == 0:
-                c.pop()
-        i += m
-
-    return tuple(out)
-
-
-def unify_chunks(*args, **kwargs):
-    """
-    Unify chunks across a sequence of arrays
-
-    This utility function is used within other common operations like
-    ``map_blocks`` and ``blockwise``.  It is not commonly used by end-users
-    directly.
-
-    Parameters
-    ----------
-    *args: sequence of Array, index pairs
-        Sequence like (x, 'ij', y, 'jk', z, 'i')
-
-    Examples
-    --------
-    >>> import dask.array as da
-    >>> x = da.ones(10, chunks=((5, 2, 3),))
-    >>> y = da.ones(10, chunks=((2, 3, 5),))
-    >>> chunkss, arrays = unify_chunks(x, 'i', y, 'i')
-    >>> chunkss
-    {'i': (2, 3, 2, 3)}
-
-    >>> x = da.ones((100, 10), chunks=(20, 5))
-    >>> y = da.ones((10, 100), chunks=(4, 50))
-    >>> chunkss, arrays = unify_chunks(x, 'ij', y, 'jk', 'constant', None)
-    >>> chunkss  # doctest: +SKIP
-    {'k': (50, 50), 'i': (20, 20, 20, 20, 20), 'j': (4, 1, 3, 2)}
-
-    >>> unify_chunks(0, None)
-    ({}, [0])
-
-    Returns
-    -------
-    chunkss : dict
-        Map like {index: chunks}.
-    arrays : list
-        List of rechunked arrays.
-
-    See Also
-    --------
-    common_blockdim
-    """
-    if not args:
-        return {}, []
-
-    arginds = [
-        (asanyarray(a) if ind is not None else a, ind) for a, ind in partition(2, args)
-    ]  # [x, ij, y, jk]
-    args = list(concat(arginds))  # [(x, ij), (y, jk)]
-    warn = kwargs.get("warn", True)
-
-    arrays, inds = zip(*arginds)
-    if all(ind is None for ind in inds):
-        return {}, list(arrays)
-    if all(ind == inds[0] for ind in inds) and all(
-        a.chunks == arrays[0].chunks for a in arrays
-    ):
-        return dict(zip(inds[0], arrays[0].chunks)), arrays
-
-    nameinds = []
-    blockdim_dict = dict()
-    max_parts = 0
-    for a, ind in arginds:
-        if ind is not None:
-            nameinds.append((a.name, ind))
-            blockdim_dict[a.name] = a.chunks
-            max_parts = max(max_parts, a.npartitions)
-        else:
-            nameinds.append((a, ind))
-
-    chunkss = broadcast_dimensions(nameinds, blockdim_dict, consolidate=common_blockdim)
-    nparts = np.prod(list(map(len, chunkss.values())))
-
-    if warn and nparts and nparts >= max_parts * 10:
-        warnings.warn(
-            "Increasing number of chunks by factor of %d" % (nparts / max_parts),
-            PerformanceWarning,
-            stacklevel=3,
-        )
-
-    arrays = []
-    for a, i in arginds:
-        if i is None:
-            arrays.append(a)
-        else:
-            chunks = tuple(
-                chunkss[j]
-                if a.shape[n] > 1
-                else a.shape[n]
-                if not np.isnan(sum(chunkss[j]))
-                else None
-                for n, j in enumerate(i)
-            )
-            if chunks != a.chunks and all(a.chunks):
-                arrays.append(a.rechunk(chunks))
-            else:
-                arrays.append(a)
-    return chunkss, arrays
-
-
-def unpack_singleton(x):
-    """
-
-    >>> unpack_singleton([[[[1]]]])
-    1
-    >>> unpack_singleton(np.array(np.datetime64('2000-01-01')))
-    array('2000-01-01', dtype='datetime64[D]')
-    """
-    while isinstance(x, (list, tuple)):
-        try:
-            x = x[0]
-        except (IndexError, TypeError, KeyError):
-            break
-    return x
-
-
-def block(arrays, allow_unknown_chunksizes=False):
-    """
-    Assemble an nd-array from nested lists of blocks.
-
-    Blocks in the innermost lists are concatenated along the last
-    dimension (-1), then these are concatenated along the second-last
-    dimension (-2), and so on until the outermost list is reached
-
-    Blocks can be of any dimension, but will not be broadcasted using the normal
-    rules. Instead, leading axes of size 1 are inserted, to make ``block.ndim``
-    the same for all blocks. This is primarily useful for working with scalars,
-    and means that code like ``block([v, 1])`` is valid, where
-    ``v.ndim == 1``.
-
-    When the nested list is two levels deep, this allows block matrices to be
-    constructed from their components.
-
-    Parameters
-    ----------
-    arrays : nested list of array_like or scalars (but not tuples)
-        If passed a single ndarray or scalar (a nested list of depth 0), this
-        is returned unmodified (and not copied).
-
-        Elements shapes must match along the appropriate axes (without
-        broadcasting), but leading 1s will be prepended to the shape as
-        necessary to make the dimensions match.
-
-    allow_unknown_chunksizes: bool
-        Allow unknown chunksizes, such as come from converting from dask
-        dataframes.  Dask.array is unable to verify that chunks line up.  If
-        data comes from differently aligned sources then this can cause
-        unexpected results.
-
-    Returns
-    -------
-    block_array : ndarray
-        The array assembled from the given blocks.
-
-        The dimensionality of the output is equal to the greatest of:
-        * the dimensionality of all the inputs
-        * the depth to which the input list is nested
-
-    Raises
-    ------
-    ValueError
-        * If list depths are mismatched - for instance, ``[[a, b], c]`` is
-          illegal, and should be spelt ``[[a, b], [c]]``
-        * If lists are empty - for instance, ``[[a, b], []]``
-
-    See Also
-    --------
-    concatenate : Join a sequence of arrays together.
-    stack : Stack arrays in sequence along a new dimension.
-    hstack : Stack arrays in sequence horizontally (column wise).
-    vstack : Stack arrays in sequence vertically (row wise).
-    dstack : Stack arrays in sequence depth wise (along third dimension).
-    vsplit : Split array into a list of multiple sub-arrays vertically.
-
-    Notes
-    -----
-
-    When called with only scalars, ``block`` is equivalent to an ndarray
-    call. So ``block([[1, 2], [3, 4]])`` is equivalent to
-    ``array([[1, 2], [3, 4]])``.
-
-    This function does not enforce that the blocks lie on a fixed grid.
-    ``block([[a, b], [c, d]])`` is not restricted to arrays of the form::
-
-        AAAbb
-        AAAbb
-        cccDD
-
-    But is also allowed to produce, for some ``a, b, c, d``::
-
-        AAAbb
-        AAAbb
-        cDDDD
-
-    Since concatenation happens along the last axis first, `block` is _not_
-    capable of producing the following directly::
-
-        AAAbb
-        cccbb
-        cccDD
-
-    Matlab's "square bracket stacking", ``[A, B, ...; p, q, ...]``, is
-    equivalent to ``block([[A, B, ...], [p, q, ...]])``.
-    """
-
-    # This was copied almost verbatim from numpy.core.shape_base.block
-    # See numpy license at https://github.com/numpy/numpy/blob/master/LICENSE.txt
-    # or NUMPY_LICENSE.txt within this directory
-
-    def atleast_nd(x, ndim):
-        x = asanyarray(x)
-        diff = max(ndim - x.ndim, 0)
-        if diff == 0:
-            return x
-        else:
-            return x[(None,) * diff + (Ellipsis,)]
-
-    def format_index(index):
-        return "arrays" + "".join("[{}]".format(i) for i in index)
-
-    rec = _Recurser(recurse_if=lambda x: type(x) is list)
-
-    # ensure that the lists are all matched in depth
-    list_ndim = None
-    any_empty = False
-    for index, value, entering in rec.walk(arrays):
-        if type(value) is tuple:
-            # not strictly necessary, but saves us from:
-            #  - more than one way to do things - no point treating tuples like
-            #    lists
-            #  - horribly confusing behaviour that results when tuples are
-            #    treated like ndarray
-            raise TypeError(
-                "{} is a tuple. "
-                "Only lists can be used to arrange blocks, and np.block does "
-                "not allow implicit conversion from tuple to ndarray.".format(
-                    format_index(index)
-                )
-            )
-        if not entering:
-            curr_depth = len(index)
-        elif len(value) == 0:
-            curr_depth = len(index) + 1
-            any_empty = True
-        else:
-            continue
-
-        if list_ndim is not None and list_ndim != curr_depth:
-            raise ValueError(
-                "List depths are mismatched. First element was at depth {}, "
-                "but there is an element at depth {} ({})".format(
-                    list_ndim, curr_depth, format_index(index)
-                )
-            )
-        list_ndim = curr_depth
-
-    # do this here so we catch depth mismatches first
-    if any_empty:
-        raise ValueError("Lists cannot be empty")
-
-    # convert all the arrays to ndarrays
-    arrays = rec.map_reduce(arrays, f_map=asanyarray, f_reduce=list)
-
-    # determine the maximum dimension of the elements
-    elem_ndim = rec.map_reduce(arrays, f_map=lambda xi: xi.ndim, f_reduce=max)
-    ndim = max(list_ndim, elem_ndim)
-
-    # first axis to concatenate along
-    first_axis = ndim - list_ndim
-
-    # Make all the elements the same dimension
-    arrays = rec.map_reduce(
-        arrays, f_map=lambda xi: atleast_nd(xi, ndim), f_reduce=list
-    )
-
-    # concatenate innermost lists on the right, outermost on the left
-    return rec.map_reduce(
-        arrays,
-        f_reduce=lambda xs, axis: concatenate(
-            list(xs), axis=axis, allow_unknown_chunksizes=allow_unknown_chunksizes
-        ),
-        f_kwargs=lambda axis: dict(axis=(axis + 1)),
-        axis=first_axis,
-    )
-
-
-def concatenate(seq, axis=0, allow_unknown_chunksizes=False):
-    """
-    Concatenate arrays along an existing axis
-
-    Given a sequence of dask Arrays form a new dask Array by stacking them
-    along an existing dimension (axis=0 by default)
-
-    Parameters
-    ----------
-    seq: list of dask.arrays
-    axis: int
-        Dimension along which to align all of the arrays
-    allow_unknown_chunksizes: bool
-        Allow unknown chunksizes, such as come from converting from dask
-        dataframes.  Dask.array is unable to verify that chunks line up.  If
-        data comes from differently aligned sources then this can cause
-        unexpected results.
-
-    Examples
-    --------
-
-    Create slices
-
-    >>> import dask.array as da
-    >>> import numpy as np
-
-    >>> data = [from_array(np.ones((4, 4)), chunks=(2, 2))
-    ...          for i in range(3)]
-
-    >>> x = da.concatenate(data, axis=0)
-    >>> x.shape
-    (12, 4)
-
-    >>> da.concatenate(data, axis=1).shape
-    (4, 12)
-
-    Result is a new dask Array
-
-    See Also
-    --------
-    stack
-    """
-    from . import wrap
-
-    seq = [asarray(a) for a in seq]
-
-    if not seq:
-        raise ValueError("Need array(s) to concatenate")
-
-    seq_metas = [meta_from_array(s) for s in seq]
-    _concatenate = concatenate_lookup.dispatch(
-        type(max(seq_metas, key=lambda x: getattr(x, "__array_priority__", 0)))
-    )
-    meta = _concatenate(seq_metas, axis=axis)
-
-    # Promote types to match meta
-    seq = [a.astype(meta.dtype) for a in seq]
-
-    # Find output array shape
-    ndim = len(seq[0].shape)
-    shape = tuple(
-        sum((a.shape[i] for a in seq)) if i == axis else seq[0].shape[i]
-        for i in range(ndim)
-    )
-
-    # Drop empty arrays
-    seq2 = [a for a in seq if a.size]
-    if not seq2:
-        seq2 = seq
-
-    if axis < 0:
-        axis = ndim + axis
-    if axis >= ndim:
-        msg = (
-            "Axis must be less than than number of dimensions"
-            "\nData has %d dimensions, but got axis=%d"
-        )
-        raise ValueError(msg % (ndim, axis))
-
-    n = len(seq2)
-    if n == 0:
-        try:
-            return wrap.empty_like(meta, shape=shape, chunks=shape, dtype=meta.dtype)
-        except TypeError:
-            return wrap.empty(shape, chunks=shape, dtype=meta.dtype)
-    elif n == 1:
-        return seq2[0]
-
-    if not allow_unknown_chunksizes and not all(
-        i == axis or all(x.shape[i] == seq2[0].shape[i] for x in seq2)
-        for i in range(ndim)
-    ):
-        if any(map(np.isnan, seq2[0].shape)):
-            raise ValueError(
-                "Tried to concatenate arrays with unknown"
-                " shape %s.\n\nTwo solutions:\n"
-                "  1. Force concatenation pass"
-                " allow_unknown_chunksizes=True.\n"
-                "  2. Compute shapes with "
-                "[x.compute_chunk_sizes() for x in seq]" % str(seq2[0].shape)
-            )
-        raise ValueError("Shapes do not align: %s", [x.shape for x in seq2])
-
-    inds = [list(range(ndim)) for i in range(n)]
-    for i, ind in enumerate(inds):
-        ind[axis] = -(i + 1)
-
-    uc_args = list(concat(zip(seq2, inds)))
-    _, seq2 = unify_chunks(*uc_args, warn=False)
-
-    bds = [a.chunks for a in seq2]
-
-    chunks = (
-        seq2[0].chunks[:axis]
-        + (sum([bd[axis] for bd in bds], ()),)
-        + seq2[0].chunks[axis + 1 :]
-    )
-
-    cum_dims = [0] + list(accumulate(add, [len(a.chunks[axis]) for a in seq2]))
-
-    names = [a.name for a in seq2]
-
-    name = "concatenate-" + tokenize(names, axis)
-    keys = list(product([name], *[range(len(bd)) for bd in chunks]))
-
-    values = [
-        (names[bisect(cum_dims, key[axis + 1]) - 1],)
-        + key[1 : axis + 1]
-        + (key[axis + 1] - cum_dims[bisect(cum_dims, key[axis + 1]) - 1],)
-        + key[axis + 2 :]
-        for key in keys
-    ]
-
-    dsk = dict(zip(keys, values))
-    graph = HighLevelGraph.from_collections(name, dsk, dependencies=seq2)
-
-    return Array(graph, name, chunks, meta=meta)
-
-
-def load_store_chunk(x, out, index, lock, return_stored, load_stored):
-    """
-    A function inserted in a Dask graph for storing a chunk.
-
-    Parameters
-    ----------
-    x: array-like
-        An array (potentially a NumPy one)
-    out: array-like
-        Where to store results too.
-    index: slice-like
-        Where to store result from ``x`` in ``out``.
-    lock: Lock-like or False
-        Lock to use before writing to ``out``.
-    return_stored: bool
-        Whether to return ``out``.
-    load_stored: bool
-        Whether to return the array stored in ``out``.
-        Ignored if ``return_stored`` is not ``True``.
-
-    Examples
-    --------
-
-    >>> a = np.ones((5, 6))
-    >>> b = np.empty(a.shape)
-    >>> load_store_chunk(a, b, (slice(None), slice(None)), False, False, False)
-    """
-
-    result = None
-    if return_stored and not load_stored:
-        result = out
-
-    if lock:
-        lock.acquire()
-    try:
-        if x is not None:
-            out[index] = np.asanyarray(x)
-        if return_stored and load_stored:
-            result = out[index]
-    finally:
-        if lock:
-            lock.release()
-
-    return result
-
-
-def store_chunk(x, out, index, lock, return_stored):
-    return load_store_chunk(x, out, index, lock, return_stored, False)
-
-
-def load_chunk(out, index, lock):
-    return load_store_chunk(None, out, index, lock, True, True)
-
-
-def insert_to_ooc(
-    arr, out, lock=True, region=None, return_stored=False, load_stored=False, tok=None
-):
-    """
-    Creates a Dask graph for storing chunks from ``arr`` in ``out``.
-
-    Parameters
-    ----------
-    arr: da.Array
-        A dask array
-    out: array-like
-        Where to store results too.
-    lock: Lock-like or bool, optional
-        Whether to lock or with what (default is ``True``,
-        which means a ``threading.Lock`` instance).
-    region: slice-like, optional
-        Where in ``out`` to store ``arr``'s results
-        (default is ``None``, meaning all of ``out``).
-    return_stored: bool, optional
-        Whether to return ``out``
-        (default is ``False``, meaning ``None`` is returned).
-    load_stored: bool, optional
-        Whether to handling loading from ``out`` at the same time.
-        Ignored if ``return_stored`` is not ``True``.
-        (default is ``False``, meaning defer to ``return_stored``).
-    tok: str, optional
-        Token to use when naming keys
-
-    Examples
-    --------
-    >>> import dask.array as da
-    >>> d = da.ones((5, 6), chunks=(2, 3))
-    >>> a = np.empty(d.shape)
-    >>> insert_to_ooc(d, a)  # doctest: +SKIP
-    """
-
-    if lock is True:
-        lock = Lock()
-
-    slices = slices_from_chunks(arr.chunks)
-    if region:
-        slices = [fuse_slice(region, slc) for slc in slices]
-
-    name = "store-%s" % (tok or str(uuid.uuid1()))
-    func = store_chunk
-    args = ()
-    if return_stored and load_stored:
-        name = "load-%s" % name
-        func = load_store_chunk
-        args = args + (load_stored,)
-
-    dsk = {
-        (name,) + t[1:]: (func, t, out, slc, lock, return_stored) + args
-        for t, slc in zip(core.flatten(arr.__dask_keys__()), slices)
-    }
-
-    return dsk
-
-
-def retrieve_from_ooc(keys, dsk_pre, dsk_post=None):
-    """
-    Creates a Dask graph for loading stored ``keys`` from ``dsk``.
-
-    Parameters
-    ----------
-    keys: Sequence
-        A sequence containing Dask graph keys to load
-    dsk_pre: Mapping
-        A Dask graph corresponding to a Dask Array before computation
-    dsk_post: Mapping, optional
-        A Dask graph corresponding to a Dask Array after computation
-
-    Examples
-    --------
-    >>> import dask.array as da
-    >>> d = da.ones((5, 6), chunks=(2, 3))
-    >>> a = np.empty(d.shape)
-    >>> g = insert_to_ooc(d, a)
-    >>> retrieve_from_ooc(g.keys(), g)  # doctest: +SKIP
-    """
-
-    if not dsk_post:
-        dsk_post = {k: k for k in keys}
-
-    load_dsk = {
-        ("load-" + k[0],) + k[1:]: (load_chunk, dsk_post[k]) + dsk_pre[k][3:-1]
-        for k in keys
-    }
-
-    return load_dsk
-
-
-def asarray(a, **kwargs):
-    """Convert the input to a dask array.
-
-    Parameters
-    ----------
-    a : array-like
-        Input data, in any form that can be converted to a dask array.
-
-    Returns
-    -------
-    out : dask array
-        Dask array interpretation of a.
-
-    Examples
-    --------
-    >>> import dask.array as da
-    >>> import numpy as np
-    >>> x = np.arange(3)
-    >>> da.asarray(x)
-    dask.array<array, shape=(3,), dtype=int64, chunksize=(3,), chunktype=numpy.ndarray>
-
-    >>> y = [[1, 2, 3], [4, 5, 6]]
-    >>> da.asarray(y)
-    dask.array<array, shape=(2, 3), dtype=int64, chunksize=(2, 3), chunktype=numpy.ndarray>
-    """
-    if isinstance(a, Array):
-        return a
-    elif hasattr(a, "to_dask_array"):
-        return a.to_dask_array()
-    elif type(a).__module__.startswith("xarray.") and hasattr(a, "data"):
-        return asarray(a.data)
-    elif isinstance(a, (list, tuple)) and any(isinstance(i, Array) for i in a):
-        return stack(a)
-    elif not isinstance(getattr(a, "shape", None), Iterable):
-        a = np.asarray(a)
-    return from_array(a, getitem=getter_inline, **kwargs)
-
-
-def asanyarray(a):
-    """Convert the input to a dask array.
-
-    Subclasses of ``np.ndarray`` will be passed through as chunks unchanged.
-
-    Parameters
-    ----------
-    a : array-like
-        Input data, in any form that can be converted to a dask array.
-
-    Returns
-    -------
-    out : dask array
-        Dask array interpretation of a.
-
-    Examples
-    --------
-    >>> import dask.array as da
-    >>> import numpy as np
-    >>> x = np.arange(3)
-    >>> da.asanyarray(x)
-    dask.array<array, shape=(3,), dtype=int64, chunksize=(3,), chunktype=numpy.ndarray>
-
-    >>> y = [[1, 2, 3], [4, 5, 6]]
-    >>> da.asanyarray(y)
-    dask.array<array, shape=(2, 3), dtype=int64, chunksize=(2, 3), chunktype=numpy.ndarray>
-    """
-    if isinstance(a, Array):
-        return a
-    elif hasattr(a, "to_dask_array"):
-        return a.to_dask_array()
-    elif type(a).__module__.startswith("xarray.") and hasattr(a, "data"):
-        return asanyarray(a.data)
-    elif isinstance(a, (list, tuple)) and any(isinstance(i, Array) for i in a):
-        a = stack(a)
-    elif not isinstance(getattr(a, "shape", None), Iterable):
-        a = np.asanyarray(a)
-    return from_array(a, chunks=a.shape, getitem=getter_inline, asarray=False)
-
-
-def is_scalar_for_elemwise(arg):
-    """
-
-    >>> is_scalar_for_elemwise(42)
-    True
-    >>> is_scalar_for_elemwise('foo')
-    True
-    >>> is_scalar_for_elemwise(True)
-    True
-    >>> is_scalar_for_elemwise(np.array(42))
-    True
-    >>> is_scalar_for_elemwise([1, 2, 3])
-    True
-    >>> is_scalar_for_elemwise(np.array([1, 2, 3]))
-    False
-    >>> is_scalar_for_elemwise(from_array(np.array(0), chunks=()))
-    False
-    >>> is_scalar_for_elemwise(np.dtype('i4'))
-    True
-    """
-    # the second half of shape_condition is essentially just to ensure that
-    # dask series / frame are treated as scalars in elemwise.
-    maybe_shape = getattr(arg, "shape", None)
-    shape_condition = not isinstance(maybe_shape, Iterable) or any(
-        is_dask_collection(x) for x in maybe_shape
-    )
-
-    return (
-        np.isscalar(arg)
-        or shape_condition
-        or isinstance(arg, np.dtype)
-        or (isinstance(arg, np.ndarray) and arg.ndim == 0)
-    )
-
-
-def broadcast_shapes(*shapes):
-    """
-    Determines output shape from broadcasting arrays.
-
-    Parameters
-    ----------
-    shapes : tuples
-        The shapes of the arguments.
-
-    Returns
-    -------
-    output_shape : tuple
-
-    Raises
-    ------
-    ValueError
-        If the input shapes cannot be successfully broadcast together.
-    """
-    if len(shapes) == 1:
-        return shapes[0]
-    out = []
-    for sizes in zip_longest(*map(reversed, shapes), fillvalue=-1):
-        if np.isnan(sizes).any():
-            dim = np.nan
-        else:
-            dim = 0 if 0 in sizes else np.max(sizes)
-        if any(i not in [-1, 0, 1, dim] and not np.isnan(i) for i in sizes):
-            raise ValueError(
-                "operands could not be broadcast together with "
-                "shapes {0}".format(" ".join(map(str, shapes)))
-            )
-        out.append(dim)
-    return tuple(reversed(out))
-
-
-def elemwise(op, *args, **kwargs):
-    """Apply elementwise function across arguments
-
-    Respects broadcasting rules
-
-    Examples
-    --------
-    >>> elemwise(add, x, y)  # doctest: +SKIP
-    >>> elemwise(sin, x)  # doctest: +SKIP
-
-    See Also
-    --------
-    blockwise
-    """
-    out = kwargs.pop("out", None)
-    if not set(["name", "dtype"]).issuperset(kwargs):
-        msg = "%s does not take the following keyword arguments %s"
-        raise TypeError(
-            msg % (op.__name__, str(sorted(set(kwargs) - set(["name", "dtype"]))))
-        )
-
-    args = [np.asarray(a) if isinstance(a, (list, tuple)) else a for a in args]
-
-    shapes = []
-    for arg in args:
-        shape = getattr(arg, "shape", ())
-        if any(is_dask_collection(x) for x in shape):
-            # Want to excluded Delayed shapes and dd.Scalar
-            shape = ()
-        shapes.append(shape)
-
-    shapes = [s if isinstance(s, Iterable) else () for s in shapes]
-    out_ndim = len(
-        broadcast_shapes(*shapes)
-    )  # Raises ValueError if dimensions mismatch
-    expr_inds = tuple(range(out_ndim))[::-1]
-
-    need_enforce_dtype = False
-    if "dtype" in kwargs:
-        dt = kwargs["dtype"]
-    else:
-        # We follow NumPy's rules for dtype promotion, which special cases
-        # scalars and 0d ndarrays (which it considers equivalent) by using
-        # their values to compute the result dtype:
-        # https://github.com/numpy/numpy/issues/6240
-        # We don't inspect the values of 0d dask arrays, because these could
-        # hold potentially very expensive calculations. Instead, we treat
-        # them just like other arrays, and if necessary cast the result of op
-        # to match.
-        vals = [
-            np.empty((1,) * max(1, a.ndim), dtype=a.dtype)
-            if not is_scalar_for_elemwise(a)
-            else a
-            for a in args
-        ]
-        try:
-            dt = apply_infer_dtype(op, vals, {}, "elemwise", suggest_dtype=False)
-        except Exception:
-            return NotImplemented
-        need_enforce_dtype = any(
-            not is_scalar_for_elemwise(a) and a.ndim == 0 for a in args
-        )
-
-    name = kwargs.get("name", None) or "%s-%s" % (funcname(op), tokenize(op, dt, *args))
-
-    blockwise_kwargs = dict(dtype=dt, name=name, token=funcname(op).strip("_"))
-    if need_enforce_dtype:
-        blockwise_kwargs["enforce_dtype"] = dt
-        blockwise_kwargs["enforce_dtype_function"] = op
-        op = _enforce_dtype
-    result = blockwise(
-        op,
-        expr_inds,
-        *concat(
-            (a, tuple(range(a.ndim)[::-1]) if not is_scalar_for_elemwise(a) else None)
-            for a in args
-        ),
-        **blockwise_kwargs,
-    )
-
-    return handle_out(out, result)
-
-
-def handle_out(out, result):
-    """Handle out parameters
-
-    If out is a dask.array then this overwrites the contents of that array with
-    the result
-    """
-    if isinstance(out, tuple):
-        if len(out) == 1:
-            out = out[0]
-        elif len(out) > 1:
-            raise NotImplementedError("The out parameter is not fully supported")
-        else:
-            out = None
-    if isinstance(out, Array):
-        if out.shape != result.shape:
-            raise ValueError(
-                "Mismatched shapes between result and out parameter. "
-                "out=%s, result=%s" % (str(out.shape), str(result.shape))
-            )
-        out._chunks = result.chunks
-        out.dask = result.dask
-        out._meta = result._meta
-        out.name = result.name
-    elif out is not None:
-        msg = (
-            "The out parameter is not fully supported."
-            " Received type %s, expected Dask Array" % type(out).__name__
-        )
-        raise NotImplementedError(msg)
-    else:
-        return result
-
-
-def _enforce_dtype(*args, **kwargs):
-    """Calls a function and converts its result to the given dtype.
-
-    The parameters have deliberately been given unwieldy names to avoid
-    clashes with keyword arguments consumed by blockwise
-
-    A dtype of `object` is treated as a special case and not enforced,
-    because it is used as a dummy value in some places when the result will
-    not be a block in an Array.
-
-    Parameters
-    ----------
-    enforce_dtype : dtype
-        Result dtype
-    enforce_dtype_function : callable
-        The wrapped function, which will be passed the remaining arguments
-    """
-    dtype = kwargs.pop("enforce_dtype")
-    function = kwargs.pop("enforce_dtype_function")
-
-    result = function(*args, **kwargs)
-    if hasattr(result, "dtype") and dtype != result.dtype and dtype != object:
-        if not np.can_cast(result, dtype, casting="same_kind"):
-            raise ValueError(
-                "Inferred dtype from function %r was %r "
-                "but got %r, which can't be cast using "
-                "casting='same_kind'"
-                % (funcname(function), str(dtype), str(result.dtype))
-            )
-        if np.isscalar(result):
-            # scalar astype method doesn't take the keyword arguments, so
-            # have to convert via 0-dimensional array and back.
-            result = result.astype(dtype)
-        else:
-            try:
-                result = result.astype(dtype, copy=False)
-            except TypeError:
-                # Missing copy kwarg
-                result = result.astype(dtype)
-    return result
-
-
-def broadcast_to(x, shape, chunks=None):
-    """Broadcast an array to a new shape.
-
-    Parameters
-    ----------
-    x : array_like
-        The array to broadcast.
-    shape : tuple
-        The shape of the desired array.
-    chunks : tuple, optional
-        If provided, then the result will use these chunks instead of the same
-        chunks as the source array. Setting chunks explicitly as part of
-        broadcast_to is more efficient than rechunking afterwards. Chunks are
-        only allowed to differ from the original shape along dimensions that
-        are new on the result or have size 1 the input array.
-
-    Returns
-    -------
-    broadcast : dask array
-
-    See Also
-    --------
-    :func:`numpy.broadcast_to`
-    """
-    x = asarray(x)
-    shape = tuple(shape)
-
-    if x.shape == shape and (chunks is None or chunks == x.chunks):
-        return x
-
-    ndim_new = len(shape) - x.ndim
-    if ndim_new < 0 or any(
-        new != old for new, old in zip(shape[ndim_new:], x.shape) if old != 1
-    ):
-        raise ValueError("cannot broadcast shape %s to shape %s" % (x.shape, shape))
-
-    if chunks is None:
-        chunks = tuple((s,) for s in shape[:ndim_new]) + tuple(
-            bd if old > 1 else (new,)
-            for bd, old, new in zip(x.chunks, x.shape, shape[ndim_new:])
-        )
-    else:
-        chunks = normalize_chunks(
-            chunks, shape, dtype=x.dtype, previous_chunks=x.chunks
-        )
-        for old_bd, new_bd in zip(x.chunks, chunks[ndim_new:]):
-            if old_bd != new_bd and old_bd != (1,):
-                raise ValueError(
-                    "cannot broadcast chunks %s to chunks %s: "
-                    "new chunks must either be along a new "
-                    "dimension or a dimension of size 1" % (x.chunks, chunks)
-                )
-
-    name = "broadcast_to-" + tokenize(x, shape, chunks)
-    dsk = {}
-
-    enumerated_chunks = product(*(enumerate(bds) for bds in chunks))
-    for new_index, chunk_shape in (zip(*ec) for ec in enumerated_chunks):
-        old_index = tuple(
-            0 if bd == (1,) else i for bd, i in zip(x.chunks, new_index[ndim_new:])
-        )
-        old_key = (x.name,) + old_index
-        new_key = (name,) + new_index
-        dsk[new_key] = (np.broadcast_to, old_key, quote(chunk_shape))
-
-    graph = HighLevelGraph.from_collections(name, dsk, dependencies=[x])
-    return Array(graph, name, chunks, dtype=x.dtype)
-
-
-@derived_from(np)
-def broadcast_arrays(*args, **kwargs):
-    subok = bool(kwargs.pop("subok", False))
-
-    to_array = asanyarray if subok else asarray
-    args = tuple(to_array(e) for e in args)
-
-    if kwargs:
-        raise TypeError("unsupported keyword argument(s) provided")
-
-    # Unify uneven chunking
-    inds = [list(reversed(range(x.ndim))) for x in args]
-    uc_args = concat(zip(args, inds))
-    _, args = unify_chunks(*uc_args, warn=False)
-
-    shape = broadcast_shapes(*(e.shape for e in args))
-    chunks = broadcast_chunks(*(e.chunks for e in args))
-
-    result = [broadcast_to(e, shape=shape, chunks=chunks) for e in args]
-
-    return result
-
-
-def offset_func(func, offset, *args):
-    """Offsets inputs by offset
-
-    >>> double = lambda x: x * 2
-    >>> f = offset_func(double, (10,))
-    >>> f(1)
-    22
-    >>> f(300)
-    620
-    """
-
-    def _offset(*args):
-        args2 = list(map(add, args, offset))
-        return func(*args2)
-
-    with ignoring(Exception):
-        _offset.__name__ = "offset_" + func.__name__
-
-    return _offset
-
-
-def chunks_from_arrays(arrays):
-    """Chunks tuple from nested list of arrays
-
-    >>> x = np.array([1, 2])
-    >>> chunks_from_arrays([x, x])
-    ((2, 2),)
-
-    >>> x = np.array([[1, 2]])
-    >>> chunks_from_arrays([[x], [x]])
-    ((1, 1), (2,))
-
-    >>> x = np.array([[1, 2]])
-    >>> chunks_from_arrays([[x, x]])
-    ((1,), (2, 2))
-
-    >>> chunks_from_arrays([1, 1])
-    ((1, 1),)
-    """
-    if not arrays:
-        return ()
-    result = []
-    dim = 0
-
-    def shape(x):
-        try:
-            return x.shape
-        except AttributeError:
-            return (1,)
-
-    while isinstance(arrays, (list, tuple)):
-        result.append(tuple([shape(deepfirst(a))[dim] for a in arrays]))
-        arrays = arrays[0]
-        dim += 1
-    return tuple(result)
-
-
-def deepfirst(seq):
-    """First element in a nested list
-
-    >>> deepfirst([[[1, 2], [3, 4]], [5, 6], [7, 8]])
-    1
-    """
-    if not isinstance(seq, (list, tuple)):
-        return seq
-    else:
-        return deepfirst(seq[0])
-
-
-def shapelist(a):
-    """ Get the shape of nested list """
-    if type(a) is list:
-        return tuple([len(a)] + list(shapelist(a[0])))
-    else:
-        return ()
-
-
-def reshapelist(shape, seq):
-    """Reshape iterator to nested shape
-
-    >>> reshapelist((2, 3), range(6))
-    [[0, 1, 2], [3, 4, 5]]
-    """
-    if len(shape) == 1:
-        return list(seq)
-    else:
-        n = int(len(seq) / shape[0])
-        return [reshapelist(shape[1:], part) for part in partition(n, seq)]
-
-
-def transposelist(arrays, axes, extradims=0):
-    """Permute axes of nested list
-
-    >>> transposelist([[1,1,1],[1,1,1]], [2,1])
-    [[[1, 1], [1, 1], [1, 1]]]
-
-    >>> transposelist([[1,1,1],[1,1,1]], [2,1], extradims=1)
-    [[[[1], [1]], [[1], [1]], [[1], [1]]]]
-    """
-    if len(axes) != ndimlist(arrays):
-        raise ValueError("Length of axes should equal depth of nested arrays")
-    if extradims < 0:
-        raise ValueError("`newdims` should be positive")
-    if len(axes) > len(set(axes)):
-        raise ValueError("`axes` should be unique")
-
-    ndim = max(axes) + 1
-    shape = shapelist(arrays)
-    newshape = [
-        shape[axes.index(i)] if i in axes else 1 for i in range(ndim + extradims)
-    ]
-
-    result = list(core.flatten(arrays))
-    return reshapelist(newshape, result)
-
-
-def stack(seq, axis=0, allow_unknown_chunksizes=False):
-    """
-    Stack arrays along a new axis
-
-    Given a sequence of dask arrays, form a new dask array by stacking them
-    along a new dimension (axis=0 by default)
-
-    Parameters
-    ----------
-    seq: list of dask.arrays
-    axis: int
-        Dimension along which to align all of the arrays
-    allow_unknown_chunksizes: bool
-        Allow unknown chunksizes, such as come from converting from dask
-        dataframes.  Dask.array is unable to verify that chunks line up.  If
-        data comes from differently aligned sources then this can cause
-        unexpected results.
-
-    Examples
-    --------
-
-    Create slices
-
-    >>> import dask.array as da
-    >>> import numpy as np
-
-    >>> data = [from_array(np.ones((4, 4)), chunks=(2, 2))
-    ...          for i in range(3)]
-
-    >>> x = da.stack(data, axis=0)
-    >>> x.shape
-    (3, 4, 4)
-
-    >>> da.stack(data, axis=1).shape
-    (4, 3, 4)
-
-    >>> da.stack(data, axis=-1).shape
-    (4, 4, 3)
-
-    Result is a new dask Array
-
-    See Also
-    --------
-    concatenate
-    """
-    from . import wrap
-
-    seq = [asarray(a) for a in seq]
-
-    if not seq:
-        raise ValueError("Need array(s) to stack")
-    if not allow_unknown_chunksizes and not all(x.shape == seq[0].shape for x in seq):
-        idx = first(i for i in enumerate(seq) if i[1].shape != seq[0].shape)
-        raise ValueError(
-            "Stacked arrays must have the same shape. "
-            "The first array had shape {0}, while array "
-            "{1} has shape {2}.".format(seq[0].shape, idx[0] + 1, idx[1].shape)
-        )
-
-    meta = np.stack([meta_from_array(a) for a in seq], axis=axis)
-    seq = [x.astype(meta.dtype) for x in seq]
-
-    ndim = meta.ndim - 1
-    if axis < 0:
-        axis = ndim + axis + 1
-    shape = tuple(
-        len(seq)
-        if i == axis
-        else (seq[0].shape[i] if i < axis else seq[0].shape[i - 1])
-        for i in range(meta.ndim)
-    )
-
-    seq2 = [a for a in seq if a.size]
-    if not seq2:
-        seq2 = seq
-
-    n = len(seq2)
-    if n == 0:
-        try:
-            return wrap.empty_like(meta, shape=shape, chunks=shape, dtype=meta.dtype)
-        except TypeError:
-            return wrap.empty(shape, chunks=shape, dtype=meta.dtype)
-
-    ind = list(range(ndim))
-    uc_args = list(concat((x, ind) for x in seq2))
-    _, seq2 = unify_chunks(*uc_args)
-
-    assert len(set(a.chunks for a in seq2)) == 1  # same chunks
-    chunks = seq2[0].chunks[:axis] + ((1,) * n,) + seq2[0].chunks[axis:]
-
-    names = [a.name for a in seq2]
-    name = "stack-" + tokenize(names, axis)
-    keys = list(product([name], *[range(len(bd)) for bd in chunks]))
-
-    inputs = [
-        (names[key[axis + 1]],) + key[1 : axis + 1] + key[axis + 2 :] for key in keys
-    ]
-    values = [
-        (
-            getitem,
-            inp,
-            (slice(None, None, None),) * axis
-            + (None,)
-            + (slice(None, None, None),) * (ndim - axis),
-        )
-        for inp in inputs
-    ]
-
-    layer = dict(zip(keys, values))
-    graph = HighLevelGraph.from_collections(name, layer, dependencies=seq2)
-
-    return Array(graph, name, chunks, meta=meta)
-
-
-def concatenate3(arrays):
-    """Recursive np.concatenate
-
-    Input should be a nested list of numpy arrays arranged in the order they
-    should appear in the array itself.  Each array should have the same number
-    of dimensions as the desired output and the nesting of the lists.
-
-    >>> x = np.array([[1, 2]])
-    >>> concatenate3([[x, x, x], [x, x, x]])
-    array([[1, 2, 1, 2, 1, 2],
-           [1, 2, 1, 2, 1, 2]])
-
-    >>> concatenate3([[x, x], [x, x], [x, x]])
-    array([[1, 2, 1, 2],
-           [1, 2, 1, 2],
-           [1, 2, 1, 2]])
-    """
-    from .utils import IS_NEP18_ACTIVE
-
-    # We need this as __array_function__ may not exist on older NumPy versions.
-    # And to reduce verbosity.
-    NDARRAY_ARRAY_FUNCTION = getattr(np.ndarray, "__array_function__", None)
-
-    arrays = concrete(arrays)
-    if not arrays:
-        return np.empty(0)
-
-    advanced = max(
-        core.flatten(arrays, container=(list, tuple)),
-        key=lambda x: getattr(x, "__array_priority__", 0),
-    )
-
-    if IS_NEP18_ACTIVE and not all(
-        NDARRAY_ARRAY_FUNCTION
-        is getattr(arr, "__array_function__", NDARRAY_ARRAY_FUNCTION)
-        for arr in arrays
-    ):
-        try:
-            x = unpack_singleton(arrays)
-            return _concatenate2(arrays, axes=tuple(range(x.ndim)))
-        except TypeError:
-            pass
-
-    if concatenate_lookup.dispatch(type(advanced)) is not np.concatenate:
-        x = unpack_singleton(arrays)
-        return _concatenate2(arrays, axes=list(range(x.ndim)))
-
-    ndim = ndimlist(arrays)
-    if not ndim:
-        return arrays
-    chunks = chunks_from_arrays(arrays)
-    shape = tuple(map(sum, chunks))
-
-    def dtype(x):
-        try:
-            return x.dtype
-        except AttributeError:
-            return type(x)
-
-    result = np.empty(shape=shape, dtype=dtype(deepfirst(arrays)))
-
-    for (idx, arr) in zip(slices_from_chunks(chunks), core.flatten(arrays)):
-        if hasattr(arr, "ndim"):
-            while arr.ndim < ndim:
-                arr = arr[None, ...]
-        result[idx] = arr
-
-    return result
-
-
-def concatenate_axes(arrays, axes):
-    """ Recursively call np.concatenate along axes """
-    if len(axes) != ndimlist(arrays):
-        raise ValueError("Length of axes should equal depth of nested arrays")
-
-    extradims = max(0, deepfirst(arrays).ndim - (max(axes) + 1))
-    return concatenate3(transposelist(arrays, axes, extradims=extradims))
-
-
-def to_hdf5(filename, *args, **kwargs):
-    """Store arrays in HDF5 file
-
-    This saves several dask arrays into several datapaths in an HDF5 file.
-    It creates the necessary datasets and handles clean file opening/closing.
-
-    >>> da.to_hdf5('myfile.hdf5', '/x', x)  # doctest: +SKIP
-
-    or
-
-    >>> da.to_hdf5('myfile.hdf5', {'/x': x, '/y': y})  # doctest: +SKIP
-
-    Optionally provide arguments as though to ``h5py.File.create_dataset``
-
-    >>> da.to_hdf5('myfile.hdf5', '/x', x, compression='lzf', shuffle=True)  # doctest: +SKIP
-
-    This can also be used as a method on a single Array
-
-    >>> x.to_hdf5('myfile.hdf5', '/x')  # doctest: +SKIP
-
-    See Also
-    --------
-    da.store
-    h5py.File.create_dataset
-    """
-    if len(args) == 1 and isinstance(args[0], dict):
-        data = args[0]
-    elif len(args) == 2 and isinstance(args[0], str) and isinstance(args[1], Array):
-        data = {args[0]: args[1]}
-    else:
-        raise ValueError("Please provide {'/data/path': array} dictionary")
-
-    chunks = kwargs.pop("chunks", True)
-
-    import h5py
-
-    with h5py.File(filename, mode="a") as f:
-        dsets = [
-            f.require_dataset(
-                dp,
-                shape=x.shape,
-                dtype=x.dtype,
-                chunks=tuple([c[0] for c in x.chunks]) if chunks is True else chunks,
-                **kwargs,
-            )
-            for dp, x in data.items()
-        ]
-        store(list(data.values()), dsets)
-
-
-def interleave_none(a, b):
-    """
-
-    >>> interleave_none([0, None, 2, None], [1, 3])
-    (0, 1, 2, 3)
-    """
-    result = []
-    i = j = 0
-    n = len(a) + len(b)
-    while i + j < n:
-        if a[i] is not None:
-            result.append(a[i])
-            i += 1
-        else:
-            result.append(b[j])
-            i += 1
-            j += 1
-    return tuple(result)
-
-
-def keyname(name, i, okey):
-    """
-
-    >>> keyname('x', 3, [None, None, 0, 2])
-    ('x', 3, 0, 2)
-    """
-    return (name, i) + tuple(k for k in okey if k is not None)
-
-
-def _vindex(x, *indexes):
-    """Point wise indexing with broadcasting.
-
-    >>> x = np.arange(56).reshape((7, 8))
-    >>> x
-    array([[ 0,  1,  2,  3,  4,  5,  6,  7],
-           [ 8,  9, 10, 11, 12, 13, 14, 15],
-           [16, 17, 18, 19, 20, 21, 22, 23],
-           [24, 25, 26, 27, 28, 29, 30, 31],
-           [32, 33, 34, 35, 36, 37, 38, 39],
-           [40, 41, 42, 43, 44, 45, 46, 47],
-           [48, 49, 50, 51, 52, 53, 54, 55]])
-
-    >>> d = from_array(x, chunks=(3, 4))
-    >>> result = _vindex(d, [0, 1, 6, 0], [0, 1, 0, 7])
-    >>> result.compute()
-    array([ 0,  9, 48,  7])
-    """
-    indexes = replace_ellipsis(x.ndim, indexes)
-
-    nonfancy_indexes = []
-    reduced_indexes = []
-    for i, ind in enumerate(indexes):
-        if isinstance(ind, Number):
-            nonfancy_indexes.append(ind)
-        elif isinstance(ind, slice):
-            nonfancy_indexes.append(ind)
-            reduced_indexes.append(slice(None))
-        else:
-            nonfancy_indexes.append(slice(None))
-            reduced_indexes.append(ind)
-
-    nonfancy_indexes = tuple(nonfancy_indexes)
-    reduced_indexes = tuple(reduced_indexes)
-
-    x = x[nonfancy_indexes]
-
-    array_indexes = {}
-    for i, (ind, size) in enumerate(zip(reduced_indexes, x.shape)):
-        if not isinstance(ind, slice):
-            ind = np.array(ind, copy=True)
-            if ind.dtype.kind == "b":
-                raise IndexError("vindex does not support indexing with boolean arrays")
-            if ((ind >= size) | (ind < -size)).any():
-                raise IndexError(
-                    "vindex key has entries out of bounds for "
-                    "indexing along axis %s of size %s: %r" % (i, size, ind)
-                )
-            ind %= size
-            array_indexes[i] = ind
-
-    if array_indexes:
-        x = _vindex_array(x, array_indexes)
-
-    return x
-
-
-def _vindex_array(x, dict_indexes):
-    """Point wise indexing with only NumPy Arrays."""
-
-    try:
-        broadcast_indexes = np.broadcast_arrays(*dict_indexes.values())
-    except ValueError as e:
-        # note: error message exactly matches numpy
-        shapes_str = " ".join(str(a.shape) for a in dict_indexes.values())
-        raise IndexError(
-            "shape mismatch: indexing arrays could not be "
-            "broadcast together with shapes " + shapes_str
-        ) from e
-    broadcast_shape = broadcast_indexes[0].shape
-
-    lookup = dict(zip(dict_indexes, broadcast_indexes))
-    flat_indexes = [
-        lookup[i].ravel().tolist() if i in lookup else None for i in range(x.ndim)
-    ]
-    flat_indexes.extend([None] * (x.ndim - len(flat_indexes)))
-
-    flat_indexes = [
-        list(index) if index is not None else index for index in flat_indexes
-    ]
-    bounds = [list(accumulate(add, (0,) + c)) for c in x.chunks]
-    bounds2 = [b for i, b in zip(flat_indexes, bounds) if i is not None]
-    axis = _get_axis(flat_indexes)
-    token = tokenize(x, flat_indexes)
-    out_name = "vindex-merge-" + token
-
-    points = list()
-    for i, idx in enumerate(zip(*[i for i in flat_indexes if i is not None])):
-        block_idx = [
-            np.searchsorted(b, ind, "right") - 1 for b, ind in zip(bounds2, idx)
-        ]
-        inblock_idx = [
-            ind - bounds2[k][j] for k, (ind, j) in enumerate(zip(idx, block_idx))
-        ]
-        points.append((i, tuple(block_idx), tuple(inblock_idx)))
-
-    chunks = [c for i, c in zip(flat_indexes, x.chunks) if i is None]
-    chunks.insert(0, (len(points),) if points else (0,))
-    chunks = tuple(chunks)
-
-    if points:
-        per_block = groupby(1, points)
-        per_block = dict((k, v) for k, v in per_block.items() if v)
-
-        other_blocks = list(
-            product(
-                *[
-                    list(range(len(c))) if i is None else [None]
-                    for i, c in zip(flat_indexes, x.chunks)
-                ]
-            )
-        )
-
-        full_slices = [slice(None, None) if i is None else None for i in flat_indexes]
-
-        name = "vindex-slice-" + token
-        vindex_merge_name = "vindex-merge-" + token
-        dsk = {}
-        for okey in other_blocks:
-            for i, key in enumerate(per_block):
-                dsk[keyname(name, i, okey)] = (
-                    _vindex_transpose,
-                    (
-                        _vindex_slice,
-                        (x.name,) + interleave_none(okey, key),
-                        interleave_none(
-                            full_slices, list(zip(*pluck(2, per_block[key])))
-                        ),
-                    ),
-                    axis,
-                )
-            dsk[keyname(vindex_merge_name, 0, okey)] = (
-                _vindex_merge,
-                [list(pluck(0, per_block[key])) for key in per_block],
-                [keyname(name, i, okey) for i in range(len(per_block))],
-            )
-
-        result_1d = Array(
-            HighLevelGraph.from_collections(out_name, dsk, dependencies=[x]),
-            out_name,
-            chunks,
-            x.dtype,
-        )
-        return result_1d.reshape(broadcast_shape + result_1d.shape[1:])
-
-    # output has a zero dimension, just create a new zero-shape array with the
-    # same dtype
-    from .wrap import empty
-
-    result_1d = empty(
-        tuple(map(sum, chunks)), chunks=chunks, dtype=x.dtype, name=out_name
-    )
-    return result_1d.reshape(broadcast_shape + result_1d.shape[1:])
-
-
-def _get_axis(indexes):
-    """Get axis along which point-wise slicing results lie
-
-    This is mostly a hack because I can't figure out NumPy's rule on this and
-    can't be bothered to go reading.
-
-    >>> _get_axis([[1, 2], None, [1, 2], None])
-    0
-    >>> _get_axis([None, [1, 2], [1, 2], None])
-    1
-    >>> _get_axis([None, None, [1, 2], [1, 2]])
-    2
-    """
-    ndim = len(indexes)
-    indexes = [slice(None, None) if i is None else [0] for i in indexes]
-    x = np.empty((2,) * ndim)
-    x2 = x[tuple(indexes)]
-    return x2.shape.index(1)
-
-
-def _vindex_slice(block, points):
-    """ Pull out point-wise slices from block """
-    points = [p if isinstance(p, slice) else list(p) for p in points]
-    return block[tuple(points)]
-
-
-def _vindex_transpose(block, axis):
-    """ Rotate block so that points are on the first dimension """
-    axes = [axis] + list(range(axis)) + list(range(axis + 1, block.ndim))
-    return block.transpose(axes)
-
-
-def _vindex_merge(locations, values):
-    """
-
-    >>> locations = [0], [2, 1]
-    >>> values = [np.array([[1, 2, 3]]),
-    ...           np.array([[10, 20, 30], [40, 50, 60]])]
-
-    >>> _vindex_merge(locations, values)
-    array([[ 1,  2,  3],
-           [40, 50, 60],
-           [10, 20, 30]])
-    """
-    locations = list(map(list, locations))
-    values = list(values)
-
-    n = sum(map(len, locations))
-
-    shape = list(values[0].shape)
-    shape[0] = n
-    shape = tuple(shape)
-
-    dtype = values[0].dtype
-
-    x = np.empty(shape, dtype=dtype)
-
-    ind = [slice(None, None) for i in range(x.ndim)]
-    for loc, val in zip(locations, values):
-        ind[0] = loc
-        x[tuple(ind)] = val
-
-    return x
-
-
-def to_npy_stack(dirname, x, axis=0):
-    """Write dask array to a stack of .npy files
-
-    This partitions the dask.array along one axis and stores each block along
-    that axis as a single .npy file in the specified directory
-
-    Examples
-    --------
-    >>> x = da.ones((5, 10, 10), chunks=(2, 4, 4))  # doctest: +SKIP
-    >>> da.to_npy_stack('data/', x, axis=0)  # doctest: +SKIP
-
-    The ``.npy`` files store numpy arrays for ``x[0:2], x[2:4], and x[4:5]``
-    respectively, as is specified by the chunk size along the zeroth axis::
-
-        $ tree data/
-        data/
-        |-- 0.npy
-        |-- 1.npy
-        |-- 2.npy
-        |-- info
-
-    The ``info`` file stores the dtype, chunks, and axis information of the array.
-    You can load these stacks with the ``da.from_npy_stack`` function.
-
-    >>> y = da.from_npy_stack('data/')  # doctest: +SKIP
-
-    See Also
-    --------
-    from_npy_stack
-    """
-
-    chunks = tuple((c if i == axis else (sum(c),)) for i, c in enumerate(x.chunks))
-    xx = x.rechunk(chunks)
-
-    if not os.path.exists(dirname):
-        os.mkdir(dirname)
-
-    meta = {"chunks": chunks, "dtype": x.dtype, "axis": axis}
-
-    with open(os.path.join(dirname, "info"), "wb") as f:
-        pickle.dump(meta, f)
-
-    name = "to-npy-stack-" + str(uuid.uuid1())
-    dsk = {
-        (name, i): (np.save, os.path.join(dirname, "%d.npy" % i), key)
-        for i, key in enumerate(core.flatten(xx.__dask_keys__()))
-    }
-
-    graph = HighLevelGraph.from_collections(name, dsk, dependencies=[xx])
-    compute_as_if_collection(Array, graph, list(dsk))
-
-
-def from_npy_stack(dirname, mmap_mode="r"):
-    """Load dask array from stack of npy files
-
-    See ``da.to_npy_stack`` for docstring
-
-    Parameters
-    ----------
-    dirname: string
-        Directory of .npy files
-    mmap_mode: (None or 'r')
-        Read data in memory map mode
-    """
-    with open(os.path.join(dirname, "info"), "rb") as f:
-        info = pickle.load(f)
-
-    dtype = info["dtype"]
-    chunks = info["chunks"]
-    axis = info["axis"]
-
-    name = "from-npy-stack-%s" % dirname
-    keys = list(product([name], *[range(len(c)) for c in chunks]))
-    values = [
-        (np.load, os.path.join(dirname, "%d.npy" % i), mmap_mode)
-        for i in range(len(chunks[axis]))
-    ]
-    dsk = dict(zip(keys, values))
-
-    return Array(dsk, name, chunks, dtype)
-
-
-from .utils import meta_from_array
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/creation.py b/Flaskserver/venv/Lib/site-packages/dask/array/creation.py
deleted file mode 100644
index 8d4e1f4481ebbdcefc4e993e176498f99b9a07e5..0000000000000000000000000000000000000000
--- a/Flaskserver/venv/Lib/site-packages/dask/array/creation.py
+++ /dev/null
@@ -1,1228 +0,0 @@
-from collections.abc import Sequence
-from functools import partial, reduce
-from itertools import product
-from operator import add, getitem
-from numbers import Integral, Number
-
-import numpy as np
-from tlz import accumulate, sliding_window
-
-from ..highlevelgraph import HighLevelGraph
-from ..base import tokenize
-from ..utils import derived_from
-from . import chunk
-from .core import (
-    Array,
-    asarray,
-    normalize_chunks,
-    stack,
-    concatenate,
-    block,
-    broadcast_to,
-    broadcast_arrays,
-    cached_cumsum,
-)
-from .ufunc import rint
-from .wrap import empty, ones, zeros, full
-from .utils import AxisError, meta_from_array, zeros_like_safe
-
-
-def empty_like(a, dtype=None, order="C", chunks=None, name=None, shape=None):
-    """
-    Return a new array with the same shape and type as a given array.
-
-    Parameters
-    ----------
-    a : array_like
-        The shape and data-type of `a` define these same attributes of the
-        returned array.
-    dtype : data-type, optional
-        Overrides the data type of the result.
-    order : {'C', 'F'}, optional
-        Whether to store multidimensional data in C- or Fortran-contiguous
-        (row- or column-wise) order in memory.
-    chunks : sequence of ints
-        The number of samples on each block. Note that the last block will have
-        fewer samples if ``len(array) % chunks != 0``.
-    name : str, optional
-        An optional keyname for the array. Defaults to hashing the input
-        keyword arguments.
-    shape : int or sequence of ints, optional.
-        Overrides the shape of the result.
-
-    Returns
-    -------
-    out : ndarray
-        Array of uninitialized (arbitrary) data with the same
-        shape and type as `a`.
-
-    See Also
-    --------
-    ones_like : Return an array of ones with shape and type of input.
-    zeros_like : Return an array of zeros with shape and type of input.
-    empty : Return a new uninitialized array.
-    ones : Return a new array setting values to one.
-    zeros : Return a new array setting values to zero.
-
-    Notes
-    -----
-    This function does *not* initialize the returned array; to do that use
-    `zeros_like` or `ones_like` instead.  It may be marginally faster than
-    the functions that do set the array values.
-    """
-
-    a = asarray(a, name=False)
-    shape, chunks = _get_like_function_shapes_chunks(a, chunks, shape)
-    return empty(shape, dtype=(dtype or a.dtype), order=order, chunks=chunks, name=name)
-
-
-def ones_like(a, dtype=None, order="C", chunks=None, name=None, shape=None):
-    """
-    Return an array of ones with the same shape and type as a given array.
-
-    Parameters
-    ----------
-    a : array_like
-        The shape and data-type of `a` define these same attributes of
-        the returned array.
-    dtype : data-type, optional
-        Overrides the data type of the result.
-    order : {'C', 'F'}, optional
-        Whether to store multidimensional data in C- or Fortran-contiguous
-        (row- or column-wise) order in memory.
-    chunks : sequence of ints
-        The number of samples on each block. Note that the last block will have
-        fewer samples if ``len(array) % chunks != 0``.
-    name : str, optional
-        An optional keyname for the array. Defaults to hashing the input
-        keyword arguments.
-    shape : int or sequence of ints, optional.
-        Overrides the shape of the result.
-
-    Returns
-    -------
-    out : ndarray
-        Array of ones with the same shape and type as `a`.
-
-    See Also
-    --------
-    zeros_like : Return an array of zeros with shape and type of input.
-    empty_like : Return an empty array with shape and type of input.
-    zeros : Return a new array setting values to zero.
-    ones : Return a new array setting values to one.
-    empty : Return a new uninitialized array.
-    """
-
-    a = asarray(a, name=False)
-    shape, chunks = _get_like_function_shapes_chunks(a, chunks, shape)
-    return ones(shape, dtype=(dtype or a.dtype), order=order, chunks=chunks, name=name)
-
-
-def zeros_like(a, dtype=None, order="C", chunks=None, name=None, shape=None):
-    """
-    Return an array of zeros with the same shape and type as a given array.
-
-    Parameters
-    ----------
-    a : array_like
-        The shape and data-type of `a` define these same attributes of
-        the returned array.
-    dtype : data-type, optional
-        Overrides the data type of the result.
-    order : {'C', 'F'}, optional
-        Whether to store multidimensional data in C- or Fortran-contiguous
-        (row- or column-wise) order in memory.
-    chunks : sequence of ints
-        The number of samples on each block. Note that the last block will have
-        fewer samples if ``len(array) % chunks != 0``.
-    name : str, optional
-        An optional keyname for the array. Defaults to hashing the input
-        keyword arguments.
-    shape : int or sequence of ints, optional.
-        Overrides the shape of the result.
-
-    Returns
-    -------
-    out : ndarray
-        Array of zeros with the same shape and type as `a`.
-
-    See Also
-    --------
-    ones_like : Return an array of ones with shape and type of input.
-    empty_like : Return an empty array with shape and type of input.
-    zeros : Return a new array setting values to zero.
-    ones : Return a new array setting values to one.
-    empty : Return a new uninitialized array.
-    """
-
-    a = asarray(a, name=False)
-    shape, chunks = _get_like_function_shapes_chunks(a, chunks, shape)
-    return zeros(shape, dtype=(dtype or a.dtype), order=order, chunks=chunks, name=name)
-
-
-def full_like(a, fill_value, order="C", dtype=None, chunks=None, name=None, shape=None):
-    """
-    Return a full array with the same shape and type as a given array.
-
-    Parameters
-    ----------
-    a : array_like
-        The shape and data-type of `a` define these same attributes of
-        the returned array.
-    fill_value : scalar
-        Fill value.
-    dtype : data-type, optional
-        Overrides the data type of the result.
-    order : {'C', 'F'}, optional
-        Whether to store multidimensional data in C- or Fortran-contiguous
-        (row- or column-wise) order in memory.
-    chunks : sequence of ints
-        The number of samples on each block. Note that the last block will have
-        fewer samples if ``len(array) % chunks != 0``.
-    name : str, optional
-        An optional keyname for the array. Defaults to hashing the input
-        keyword arguments.
-    shape : int or sequence of ints, optional.
-        Overrides the shape of the result.
-
-    Returns
-    -------
-    out : ndarray
-        Array of `fill_value` with the same shape and type as `a`.
-
-    See Also
-    --------
-    zeros_like : Return an array of zeros with shape and type of input.
-    ones_like : Return an array of ones with shape and type of input.
-    empty_like : Return an empty array with shape and type of input.
-    zeros : Return a new array setting values to zero.
-    ones : Return a new array setting values to one.
-    empty : Return a new uninitialized array.
-    full : Fill a new array.
-    """
-
-    a = asarray(a, name=False)
-    shape, chunks = _get_like_function_shapes_chunks(a, chunks, shape)
-    return full(
-        shape,
-        fill_value,
-        dtype=(dtype or a.dtype),
-        order=order,
-        chunks=chunks,
-        name=name,
-    )
-
-
-def _get_like_function_shapes_chunks(a, chunks, shape):
-    """
-    Helper function for finding shapes and chunks for *_like()
-    array creation functions.
-    """
-    if shape is None:
-        shape = a.shape
-        if chunks is None:
-            chunks = a.chunks
-    elif chunks is None:
-        chunks = "auto"
-    return shape, chunks
-
-
-def linspace(
-    start, stop, num=50, endpoint=True, retstep=False, chunks="auto", dtype=None
-):
-    """
-    Return `num` evenly spaced values over the closed interval [`start`,
-    `stop`].
-
-    Parameters
-    ----------
-    start : scalar
-        The starting value of the sequence.
-    stop : scalar
-        The last value of the sequence.
-    num : int, optional
-        Number of samples to include in the returned dask array, including the
-        endpoints. Default is 50.
-    endpoint : bool, optional
-        If True, ``stop`` is the last sample. Otherwise, it is not included.
-        Default is True.
-    retstep : bool, optional
-        If True, return (samples, step), where step is the spacing between
-        samples. Default is False.
-    chunks :  int
-        The number of samples on each block. Note that the last block will have
-        fewer samples if `num % blocksize != 0`
-    dtype : dtype, optional
-        The type of the output array.
-
-    Returns
-    -------
-    samples : dask array
-    step : float, optional
-        Only returned if ``retstep`` is True. Size of spacing between samples.
-
-
-    See Also
-    --------
-    dask.array.arange
-    """
-    num = int(num)
-
-    if dtype is None:
-        dtype = np.linspace(0, 1, 1).dtype
-
-    chunks = normalize_chunks(chunks, (num,), dtype=dtype)
-
-    range_ = stop - start
-
-    div = (num - 1) if endpoint else num
-    step = float(range_) / div
-
-    name = "linspace-" + tokenize((start, stop, num, endpoint, chunks, dtype))
-
-    dsk = {}
-    blockstart = start
-
-    for i, bs in enumerate(chunks[0]):
-        bs_space = bs - 1 if endpoint else bs
-        blockstop = blockstart + (bs_space * step)
-        task = (
-            partial(np.linspace, endpoint=endpoint, dtype=dtype),
-            blockstart,
-            blockstop,
-            bs,
-        )
-        blockstart = blockstart + (step * bs)
-        dsk[(name, i)] = task
-
-    if retstep:
-        return Array(dsk, name, chunks, dtype=dtype), step
-    else:
-        return Array(dsk, name, chunks, dtype=dtype)
-
-
-def arange(*args, **kwargs):
-    """
-    Return evenly spaced values from `start` to `stop` with step size `step`.
-
-    The values are half-open [start, stop), so including start and excluding
-    stop. This is basically the same as python's range function but for dask
-    arrays.
-
-    When using a non-integer step, such as 0.1, the results will often not be
-    consistent. It is better to use linspace for these cases.
-
-    Parameters
-    ----------
-    start : int, optional
-        The starting value of the sequence. The default is 0.
-    stop : int
-        The end of the interval, this value is excluded from the interval.
-    step : int, optional
-        The spacing between the values. The default is 1 when not specified.
-        The last value of the sequence.
-    chunks :  int
-        The number of samples on each block. Note that the last block will have
-        fewer samples if ``len(array) % chunks != 0``.
-    dtype : numpy.dtype
-        Output dtype. Omit to infer it from start, stop, step
-
-    Returns
-    -------
-    samples : dask array
-
-    See Also
-    --------
-    dask.array.linspace
-    """
-    if len(args) == 1:
-        start = 0
-        stop = args[0]
-        step = 1
-    elif len(args) == 2:
-        start = args[0]
-        stop = args[1]
-        step = 1
-    elif len(args) == 3:
-        start, stop, step = args
-    else:
-        raise TypeError(
-            """
-        arange takes 3 positional arguments: arange([start], stop, [step])
-        """
-        )
-
-    chunks = kwargs.pop("chunks", "auto")
-
-    num = int(max(np.ceil((stop - start) / step), 0))
-
-    dtype = kwargs.pop("dtype", None)
-    if dtype is None:
-        dtype = np.arange(start, stop, step * num if num else step).dtype
-
-    chunks = normalize_chunks(chunks, (num,), dtype=dtype)
-
-    if kwargs:
-        raise TypeError("Unexpected keyword argument(s): %s" % ",".join(kwargs.keys()))
-
-    name = "arange-" + tokenize((start, stop, step, chunks, dtype))
-    dsk = {}
-    elem_count = 0
-
-    for i, bs in enumerate(chunks[0]):
-        blockstart = start + (elem_count * step)
-        blockstop = start + ((elem_count + bs) * step)
-        task = (chunk.arange, blockstart, blockstop, step, bs, dtype)
-        dsk[(name, i)] = task
-        elem_count += bs
-
-    return Array(dsk, name, chunks, dtype=dtype)
-
-
-@derived_from(np)
-def meshgrid(*xi, **kwargs):
-    indexing = kwargs.pop("indexing", "xy")
-    sparse = bool(kwargs.pop("sparse", False))
-
-    if "copy" in kwargs:
-        raise NotImplementedError("`copy` not supported")
-
-    if kwargs:
-        raise TypeError("unsupported keyword argument(s) provided")
-
-    if indexing not in ("ij", "xy"):
-        raise ValueError("`indexing` must be `'ij'` or `'xy'`")
-
-    xi = [asarray(e) for e in xi]
-    xi = [e.flatten() for e in xi]
-
-    if indexing == "xy" and len(xi) > 1:
-        xi[0], xi[1] = xi[1], xi[0]
-
-    grid = []
-    for i in range(len(xi)):
-        s = len(xi) * [None]
-        s[i] = slice(None)
-        s = tuple(s)
-
-        r = xi[i][s]
-
-        grid.append(r)
-
-    if not sparse:
-        grid = broadcast_arrays(*grid)
-
-    if indexing == "xy" and len(xi) > 1:
-        grid[0], grid[1] = grid[1], grid[0]
-
-    return grid
-
-
-def indices(dimensions, dtype=int, chunks="auto"):
-    """
-    Implements NumPy's ``indices`` for Dask Arrays.
-
-    Generates a grid of indices covering the dimensions provided.
-
-    The final array has the shape ``(len(dimensions), *dimensions)``. The
-    chunks are used to specify the chunking for axis 1 up to
-    ``len(dimensions)``. The 0th axis always has chunks of length 1.
-
-    Parameters
-    ----------
-    dimensions : sequence of ints
-        The shape of the index grid.
-    dtype : dtype, optional
-        Type to use for the array. Default is ``int``.
-    chunks : sequence of ints, str
-        The size of each block.  Must be one of the following forms:
-
-        - A blocksize like (500, 1000)
-        - A size in bytes, like "100 MiB" which will choose a uniform
-          block-like shape
-        - The word "auto" which acts like the above, but uses a configuration
-          value ``array.chunk-size`` for the chunk size
-
-        Note that the last block will have fewer samples if ``len(array) % chunks != 0``.
-
-    Returns
-    -------
-    grid : dask array
-    """
-    dimensions = tuple(dimensions)
-    dtype = np.dtype(dtype)
-    chunks = normalize_chunks(chunks, shape=dimensions, dtype=dtype)
-
-    if len(dimensions) != len(chunks):
-        raise ValueError("Need same number of chunks as dimensions.")
-
-    xi = []
-    for i in range(len(dimensions)):
-        xi.append(arange(dimensions[i], dtype=dtype, chunks=(chunks[i],)))
-
-    grid = []
-    if np.prod(dimensions):
-        grid = meshgrid(*xi, indexing="ij")
-
-    if grid:
-        grid = stack(grid)
-    else:
-        grid = empty((len(dimensions),) + dimensions, dtype=dtype, chunks=(1,) + chunks)
-
-    return grid
-
-
-def eye(N, chunks="auto", M=None, k=0, dtype=float):
-    """
-    Return a 2-D Array with ones on the diagonal and zeros elsewhere.
-
-    Parameters
-    ----------
-    N : int
-      Number of rows in the output.
-    chunks : int, str
-        How to chunk the array. Must be one of the following forms:
-
-        -   A blocksize like 1000.
-        -   A size in bytes, like "100 MiB" which will choose a uniform
-            block-like shape
-        -   The word "auto" which acts like the above, but uses a configuration
-            value ``array.chunk-size`` for the chunk size
-    M : int, optional
-      Number of columns in the output. If None, defaults to `N`.
-    k : int, optional
-      Index of the diagonal: 0 (the default) refers to the main diagonal,
-      a positive value refers to an upper diagonal, and a negative value
-      to a lower diagonal.
-    dtype : data-type, optional
-      Data-type of the returned array.
-
-    Returns
-    -------
-    I : Array of shape (N,M)
-      An array where all elements are equal to zero, except for the `k`-th
-      diagonal, whose values are equal to one.
-    """
-    eye = {}
-    if M is None:
-        M = N
-
-    if not isinstance(chunks, (int, str)):
-        raise ValueError("chunks must be an int or string")
-    elif isinstance(chunks, str):
-        chunks = normalize_chunks(chunks, shape=(N, M), dtype=dtype)
-        chunks = chunks[0][0]
-    token = tokenize(N, chunks, M, k, dtype)
-    name_eye = "eye-" + token
-
-    vchunks = [chunks] * (N // chunks)
-    if N % chunks != 0:
-        vchunks.append(N % chunks)
-    hchunks = [chunks] * (M // chunks)
-    if M % chunks != 0:
-        hchunks.append(M % chunks)
-
-    for i, vchunk in enumerate(vchunks):
-        for j, hchunk in enumerate(hchunks):
-            if (j - i - 1) * chunks <= k <= (j - i + 1) * chunks:
-                eye[name_eye, i, j] = (
-                    np.eye,
-                    vchunk,
-                    hchunk,
-                    k - (j - i) * chunks,
-                    dtype,
-                )
-            else:
-                eye[name_eye, i, j] = (np.zeros, (vchunk, hchunk), dtype)
-    return Array(eye, name_eye, shape=(N, M), chunks=(chunks, chunks), dtype=dtype)
-
-
-@derived_from(np)
-def diag(v):
-    name = "diag-" + tokenize(v)
-
-    meta = meta_from_array(v, 2 if v.ndim == 1 else 1)
-
-    if isinstance(v, np.ndarray) or (
-        hasattr(v, "__array_function__") and not isinstance(v, Array)
-    ):
-        if v.ndim == 1:
-            chunks = ((v.shape[0],), (v.shape[0],))
-            dsk = {(name, 0, 0): (np.diag, v)}
-        elif v.ndim == 2:
-            chunks = ((min(v.shape),),)
-            dsk = {(name, 0): (np.diag, v)}
-        else:
-            raise ValueError("Array must be 1d or 2d only")
-        return Array(dsk, name, chunks, meta=meta)
-    if not isinstance(v, Array):
-        raise TypeError(
-            "v must be a dask array or numpy array, got {0}".format(type(v))
-        )
-    if v.ndim != 1:
-        if v.chunks[0] == v.chunks[1]:
-            dsk = {
-                (name, i): (np.diag, row[i]) for i, row in enumerate(v.__dask_keys__())
-            }
-            graph = HighLevelGraph.from_collections(name, dsk, dependencies=[v])
-            return Array(graph, name, (v.chunks[0],), meta=meta)
-        else:
-            raise NotImplementedError(
-                "Extracting diagonals from non-square chunked arrays"
-            )
-    chunks_1d = v.chunks[0]
-    blocks = v.__dask_keys__()
-    dsk = {}
-    for i, m in enumerate(chunks_1d):
-        for j, n in enumerate(chunks_1d):
-            key = (name, i, j)
-            if i == j:
-                dsk[key] = (np.diag, blocks[i])
-            else:
-                dsk[key] = (np.zeros, (m, n))
-                dsk[key] = (partial(zeros_like_safe, shape=(m, n)), meta)
-
-    graph = HighLevelGraph.from_collections(name, dsk, dependencies=[v])
-    return Array(graph, name, (chunks_1d, chunks_1d), meta=meta)
-
-
-@derived_from(np)
-def diagonal(a, offset=0, axis1=0, axis2=1):
-    name = "diagonal-" + tokenize(a, offset, axis1, axis2)
-
-    if a.ndim < 2:
-        # NumPy uses `diag` as we do here.
-        raise ValueError("diag requires an array of at least two dimensions")
-
-    def _axis_fmt(axis, name, ndim):
-        if axis < 0:
-            t = ndim + axis
-            if t < 0:
-                msg = "{}: axis {} is out of bounds for array of dimension {}"
-                raise AxisError(msg.format(name, axis, ndim))
-            axis = t
-        return axis
-
-    axis1 = _axis_fmt(axis1, "axis1", a.ndim)
-    axis2 = _axis_fmt(axis2, "axis2", a.ndim)
-
-    if axis1 == axis2:
-        raise ValueError("axis1 and axis2 cannot be the same")
-
-    a = asarray(a)
-
-    if axis1 > axis2:
-        axis1, axis2 = axis2, axis1
-        offset = -offset
-
-    def _diag_len(dim1, dim2, offset):
-        return max(0, min(min(dim1, dim2), dim1 + offset, dim2 - offset))
-
-    diag_chunks = []
-    chunk_offsets = []
-    cum1 = cached_cumsum(a.chunks[axis1], initial_zero=True)[:-1]
-    cum2 = cached_cumsum(a.chunks[axis2], initial_zero=True)[:-1]
-    for co1, c1 in zip(cum1, a.chunks[axis1]):
-        chunk_offsets.append([])
-        for co2, c2 in zip(cum2, a.chunks[axis2]):
-            k = offset + co1 - co2
-            diag_chunks.append(_diag_len(c1, c2, k))
-            chunk_offsets[-1].append(k)
-
-    dsk = {}
-    idx_set = set(range(a.ndim)) - set([axis1, axis2])
-    n1 = len(a.chunks[axis1])
-    n2 = len(a.chunks[axis2])
-    for idx in product(*(range(len(a.chunks[i])) for i in idx_set)):
-        for i, (i1, i2) in enumerate(product(range(n1), range(n2))):
-            tsk = reduce(getitem, idx[:axis1], a.__dask_keys__())[i1]
-            tsk = reduce(getitem, idx[axis1 : axis2 - 1], tsk)[i2]
-            tsk = reduce(getitem, idx[axis2 - 1 :], tsk)
-            k = chunk_offsets[i1][i2]
-            dsk[(name,) + idx + (i,)] = (np.diagonal, tsk, k, axis1, axis2)
-
-    left_shape = tuple(a.shape[i] for i in idx_set)
-    right_shape = (_diag_len(a.shape[axis1], a.shape[axis2], offset),)
-    shape = left_shape + right_shape
-
-    left_chunks = tuple(a.chunks[i] for i in idx_set)
-    right_shape = (tuple(diag_chunks),)
-    chunks = left_chunks + right_shape
-
-    graph = HighLevelGraph.from_collections(name, dsk, dependencies=[a])
-    meta = meta_from_array(a, len(shape))
-    return Array(graph, name, shape=shape, chunks=chunks, meta=meta)
-
-
-def triu(m, k=0):
-    """
-    Upper triangle of an array with elements below the `k`-th diagonal zeroed.
-
-    Parameters
-    ----------
-    m : array_like, shape (M, N)
-        Input array.
-    k : int, optional
-        Diagonal below which to zero elements.  `k = 0` (the default) is the
-        main diagonal, `k < 0` is below it and `k > 0` is above.
-
-    Returns
-    -------
-    triu : ndarray, shape (M, N)
-        Upper triangle of `m`, of same shape and data-type as `m`.
-
-    See Also
-    --------
-    tril : lower triangle of an array
-    """
-    if m.ndim != 2:
-        raise ValueError("input must be 2 dimensional")
-    if m.chunks[0][0] != m.chunks[1][0]:
-        msg = (
-            "chunks must be a square. "
-            "Use .rechunk method to change the size of chunks."
-        )
-        raise NotImplementedError(msg)
-
-    rdim = len(m.chunks[0])
-    hdim = len(m.chunks[1])
-    chunk = m.chunks[0][0]
-
-    token = tokenize(m, k)
-    name = "triu-" + token
-
-    dsk = {}
-    for i in range(rdim):
-        for j in range(hdim):
-            if chunk * (j - i + 1) < k:
-                dsk[(name, i, j)] = (
-                    partial(zeros_like_safe, shape=(m.chunks[0][i], m.chunks[1][j])),
-                    m._meta,
-                )
-            elif chunk * (j - i - 1) < k <= chunk * (j - i + 1):
-                dsk[(name, i, j)] = (np.triu, (m.name, i, j), k - (chunk * (j - i)))
-            else:
-                dsk[(name, i, j)] = (m.name, i, j)
-    graph = HighLevelGraph.from_collections(name, dsk, dependencies=[m])
-    return Array(graph, name, shape=m.shape, chunks=m.chunks, meta=m)
-
-
-def tril(m, k=0):
-    """
-    Lower triangle of an array with elements above the `k`-th diagonal zeroed.
-
-    Parameters
-    ----------
-    m : array_like, shape (M, M)
-        Input array.
-    k : int, optional
-        Diagonal above which to zero elements.  `k = 0` (the default) is the
-        main diagonal, `k < 0` is below it and `k > 0` is above.
-
-    Returns
-    -------
-    tril : ndarray, shape (M, M)
-        Lower triangle of `m`, of same shape and data-type as `m`.
-
-    See Also
-    --------
-    triu : upper triangle of an array
-    """
-    if m.ndim != 2:
-        raise ValueError("input must be 2 dimensional")
-    if not len(set(m.chunks[0] + m.chunks[1])) == 1:
-        msg = (
-            "All chunks must be a square matrix to perform lu decomposition. "
-            "Use .rechunk method to change the size of chunks."
-        )
-        raise ValueError(msg)
-
-    rdim = len(m.chunks[0])
-    hdim = len(m.chunks[1])
-    chunk = m.chunks[0][0]
-
-    token = tokenize(m, k)
-    name = "tril-" + token
-
-    dsk = {}
-    for i in range(rdim):
-        for j in range(hdim):
-            if chunk * (j - i + 1) < k:
-                dsk[(name, i, j)] = (m.name, i, j)
-            elif chunk * (j - i - 1) < k <= chunk * (j - i + 1):
-                dsk[(name, i, j)] = (np.tril, (m.name, i, j), k - (chunk * (j - i)))
-            else:
-                dsk[(name, i, j)] = (
-                    partial(zeros_like_safe, shape=(m.chunks[0][i], m.chunks[1][j])),
-                    m._meta,
-                )
-    graph = HighLevelGraph.from_collections(name, dsk, dependencies=[m])
-    return Array(graph, name, shape=m.shape, chunks=m.chunks, meta=m)
-
-
-def _np_fromfunction(func, shape, dtype, offset, func_kwargs):
-    def offset_func(*args, **kwargs):
-        args2 = list(map(add, args, offset))
-        return func(*args2, **kwargs)
-
-    return np.fromfunction(offset_func, shape, dtype=dtype, **func_kwargs)
-
-
-@derived_from(np)
-def fromfunction(func, chunks="auto", shape=None, dtype=None, **kwargs):
-    chunks = normalize_chunks(chunks, shape, dtype=dtype)
-    name = "fromfunction-" + tokenize(func, chunks, shape, dtype, kwargs)
-    keys = product([name], *(range(len(bd)) for bd in chunks))
-
-    def accumulate_gen(chunks):
-        for bd in chunks:
-            yield accumulate(add, (0,) + bd[:-1])
-
-    aggdims = accumulate_gen(chunks)
-    offsets = product(*aggdims)
-    shapes = product(*chunks)
-    dtype = dtype or float
-
-    values = [
-        (_np_fromfunction, func, shp, dtype, offset, kwargs)
-        for offset, shp in zip(offsets, shapes)
-    ]
-
-    dsk = dict(zip(keys, values))
-
-    return Array(dsk, name, chunks, dtype=dtype)
-
-
-@derived_from(np)
-def repeat(a, repeats, axis=None):
-    if axis is None:
-        if a.ndim == 1:
-            axis = 0
-        else:
-            raise NotImplementedError("Must supply an integer axis value")
-
-    if not isinstance(repeats, Integral):
-        raise NotImplementedError("Only integer valued repeats supported")
-
-    if -a.ndim <= axis < 0:
-        axis += a.ndim
-    elif not 0 <= axis <= a.ndim - 1:
-        raise ValueError("axis(=%d) out of bounds" % axis)
-
-    if repeats == 0:
-        return a[tuple(slice(None) if d != axis else slice(0) for d in range(a.ndim))]
-    elif repeats == 1:
-        return a
-
-    cchunks = cached_cumsum(a.chunks[axis], initial_zero=True)
-    slices = []
-    for c_start, c_stop in sliding_window(2, cchunks):
-        ls = np.linspace(c_start, c_stop, repeats).round(0)
-        for ls_start, ls_stop in sliding_window(2, ls):
-            if ls_start != ls_stop:
-                slices.append(slice(ls_start, ls_stop))
-
-    all_slice = slice(None, None, None)
-    slices = [
-        (all_slice,) * axis + (s,) + (all_slice,) * (a.ndim - axis - 1) for s in slices
-    ]
-
-    slabs = [a[slc] for slc in slices]
-
-    out = []
-    for slab in slabs:
-        chunks = list(slab.chunks)
-        assert len(chunks[axis]) == 1
-        chunks[axis] = (chunks[axis][0] * repeats,)
-        chunks = tuple(chunks)
-        result = slab.map_blocks(
-            np.repeat, repeats, axis=axis, chunks=chunks, dtype=slab.dtype
-        )
-        out.append(result)
-
-    return concatenate(out, axis=axis)
-
-
-@derived_from(np)
-def tile(A, reps):
-    try:
-        tup = tuple(reps)
-    except TypeError:
-        tup = (reps,)
-    if any(i < 0 for i in tup):
-        raise ValueError("Negative `reps` are not allowed.")
-    c = asarray(A)
-
-    if all(tup):
-        for nrep in tup[::-1]:
-            c = nrep * [c]
-        return block(c)
-
-    d = len(tup)
-    if d < c.ndim:
-        tup = (1,) * (c.ndim - d) + tup
-    if c.ndim < d:
-        shape = (1,) * (d - c.ndim) + c.shape
-    else:
-        shape = c.shape
-    shape_out = tuple(s * t for s, t in zip(shape, tup))
-    return empty(shape=shape_out, dtype=c.dtype)
-
-
-def expand_pad_value(array, pad_value):
-    if isinstance(pad_value, Number):
-        pad_value = array.ndim * ((pad_value, pad_value),)
-    elif (
-        isinstance(pad_value, Sequence)
-        and all(isinstance(pw, Number) for pw in pad_value)
-        and len(pad_value) == 1
-    ):
-        pad_value = array.ndim * ((pad_value[0], pad_value[0]),)
-    elif (
-        isinstance(pad_value, Sequence)
-        and len(pad_value) == 2
-        and all(isinstance(pw, Number) for pw in pad_value)
-    ):
-        pad_value = array.ndim * (tuple(pad_value),)
-    elif (
-        isinstance(pad_value, Sequence)
-        and len(pad_value) == array.ndim
-        and all(isinstance(pw, Sequence) for pw in pad_value)
-        and all((len(pw) == 2) for pw in pad_value)
-        and all(all(isinstance(w, Number) for w in pw) for pw in pad_value)
-    ):
-        pad_value = tuple(tuple(pw) for pw in pad_value)
-    elif (
-        isinstance(pad_value, Sequence)
-        and len(pad_value) == 1
-        and isinstance(pad_value[0], Sequence)
-        and len(pad_value[0]) == 2
-        and all(isinstance(pw, Number) for pw in pad_value[0])
-    ):
-        pad_value = array.ndim * (tuple(pad_value[0]),)
-    else:
-        raise TypeError("`pad_value` must be composed of integral typed values.")
-
-    return pad_value
-
-
-def get_pad_shapes_chunks(array, pad_width, axes):
-    """
-    Helper function for finding shapes and chunks of end pads.
-    """
-
-    pad_shapes = [list(array.shape), list(array.shape)]
-    pad_chunks = [list(array.chunks), list(array.chunks)]
-
-    for d in axes:
-        for i in range(2):
-            pad_shapes[i][d] = pad_width[d][i]
-            pad_chunks[i][d] = (pad_width[d][i],)
-
-    pad_shapes = [tuple(s) for s in pad_shapes]
-    pad_chunks = [tuple(c) for c in pad_chunks]
-
-    return pad_shapes, pad_chunks
-
-
-def linear_ramp_chunk(start, stop, num, dim, step):
-    """
-    Helper function to find the linear ramp for a chunk.
-    """
-
-    num1 = num + 1
-
-    shape = list(start.shape)
-    shape[dim] = num
-    shape = tuple(shape)
-
-    dtype = np.dtype(start.dtype)
-
-    result = np.empty(shape, dtype=dtype)
-    for i in np.ndindex(start.shape):
-        j = list(i)
-        j[dim] = slice(None)
-        j = tuple(j)
-
-        result[j] = np.linspace(start[i], stop, num1, dtype=dtype)[1:][::step]
-
-    return result
-
-
-def pad_edge(array, pad_width, mode, **kwargs):
-    """
-    Helper function for padding edges.
-
-    Handles the cases where the only the values on the edge are needed.
-    """
-
-    kwargs = {k: expand_pad_value(array, v) for k, v in kwargs.items()}
-
-    result = array
-    for d in range(array.ndim):
-        pad_shapes, pad_chunks = get_pad_shapes_chunks(result, pad_width, (d,))
-        pad_arrays = [result, result]
-
-        if mode == "constant":
-            constant_values = kwargs["constant_values"][d]
-            constant_values = [asarray(c).astype(result.dtype) for c in constant_values]
-
-            pad_arrays = [
-                broadcast_to(v, s, c)
-                for v, s, c in zip(constant_values, pad_shapes, pad_chunks)
-            ]
-        elif mode in ["edge", "linear_ramp"]:
-            pad_slices = [result.ndim * [slice(None)], result.ndim * [slice(None)]]
-            pad_slices[0][d] = slice(None, 1, None)
-            pad_slices[1][d] = slice(-1, None, None)
-            pad_slices = [tuple(sl) for sl in pad_slices]
-
-            pad_arrays = [result[sl] for sl in pad_slices]
-
-            if mode == "edge":
-                pad_arrays = [
-                    broadcast_to(a, s, c)
-                    for a, s, c in zip(pad_arrays, pad_shapes, pad_chunks)
-                ]
-            elif mode == "linear_ramp":
-                end_values = kwargs["end_values"][d]
-
-                pad_arrays = [
-                    a.map_blocks(
-                        linear_ramp_chunk,
-                        ev,
-                        pw,
-                        chunks=c,
-                        dtype=result.dtype,
-                        dim=d,
-                        step=(2 * i - 1),
-                    )
-                    for i, (a, ev, pw, c) in enumerate(
-                        zip(pad_arrays, end_values, pad_width[d], pad_chunks)
-                    )
-                ]
-        elif mode == "empty":
-            pad_arrays = [
-                empty(s, dtype=array.dtype, chunks=c)
-                for s, c in zip(pad_shapes, pad_chunks)
-            ]
-
-        result = concatenate([pad_arrays[0], result, pad_arrays[1]], axis=d)
-
-    return result
-
-
-def pad_reuse(array, pad_width, mode, **kwargs):
-    """
-    Helper function for padding boundaries with values in the array.
-
-    Handles the cases where the padding is constructed from values in
-    the array. Namely by reflecting them or tiling them to create periodic
-    boundary constraints.
-    """
-
-    if mode in {"reflect", "symmetric"}:
-        reflect_type = kwargs.get("reflect", "even")
-        if reflect_type == "odd":
-            raise NotImplementedError("`pad` does not support `reflect_type` of `odd`.")
-        if reflect_type != "even":
-            raise ValueError(
-                "unsupported value for reflect_type, must be one of (`even`, `odd`)"
-            )
-
-    result = np.empty(array.ndim * (3,), dtype=object)
-    for idx in np.ndindex(result.shape):
-        select = []
-        orient = []
-        for i, s, pw in zip(idx, array.shape, pad_width):
-            if mode == "wrap":
-                pw = pw[::-1]
-
-            if i < 1:
-                if mode == "reflect":
-                    select.append(slice(1, pw[0] + 1, None))
-                else:
-                    select.append(slice(None, pw[0], None))
-            elif i > 1:
-                if mode == "reflect":
-                    select.append(slice(s - pw[1] - 1, s - 1, None))
-                else:
-                    select.append(slice(s - pw[1], None, None))
-            else:
-                select.append(slice(None))
-
-            if i != 1 and mode in ["reflect", "symmetric"]:
-                orient.append(slice(None, None, -1))
-            else:
-                orient.append(slice(None))
-
-        select = tuple(select)
-        orient = tuple(orient)
-
-        if mode == "wrap":
-            idx = tuple(2 - i for i in idx)
-
-        result[idx] = array[select][orient]
-
-    result = block(result.tolist())
-
-    return result
-
-
-def pad_stats(array, pad_width, mode, stat_length):
-    """
-    Helper function for padding boundaries with statistics from the array.
-
-    In cases where the padding requires computations of statistics from part
-    or all of the array, this function helps compute those statistics as
-    requested and then adds those statistics onto the boundaries of the array.
-    """
-
-    if mode == "median":
-        raise NotImplementedError("`pad` does not support `mode` of `median`.")
-
-    stat_length = expand_pad_value(array, stat_length)
-
-    result = np.empty(array.ndim * (3,), dtype=object)
-    for idx in np.ndindex(result.shape):
-        axes = []
-        select = []
-        pad_shape = []
-        pad_chunks = []
-        for d, (i, s, c, w, l) in enumerate(
-            zip(idx, array.shape, array.chunks, pad_width, stat_length)
-        ):
-            if i < 1:
-                axes.append(d)
-                select.append(slice(None, l[0], None))
-                pad_shape.append(w[0])
-                pad_chunks.append(w[0])
-            elif i > 1:
-                axes.append(d)
-                select.append(slice(s - l[1], None, None))
-                pad_shape.append(w[1])
-                pad_chunks.append(w[1])
-            else:
-                select.append(slice(None))
-                pad_shape.append(s)
-                pad_chunks.append(c)
-
-        axes = tuple(axes)
-        select = tuple(select)
-        pad_shape = tuple(pad_shape)
-        pad_chunks = tuple(pad_chunks)
-
-        result_idx = array[select]
-        if axes:
-            if mode == "maximum":
-                result_idx = result_idx.max(axis=axes, keepdims=True)
-            elif mode == "mean":
-                result_idx = result_idx.mean(axis=axes, keepdims=True)
-            elif mode == "minimum":
-                result_idx = result_idx.min(axis=axes, keepdims=True)
-
-            result_idx = broadcast_to(result_idx, pad_shape, chunks=pad_chunks)
-
-            if mode == "mean":
-                if np.issubdtype(array.dtype, np.integer):
-                    result_idx = rint(result_idx)
-                result_idx = result_idx.astype(array.dtype)
-
-        result[idx] = result_idx
-
-    result = block(result.tolist())
-
-    return result
-
-
-def wrapped_pad_func(array, pad_func, iaxis_pad_width, iaxis, pad_func_kwargs):
-    result = np.empty_like(array)
-    for i in np.ndindex(array.shape[:iaxis] + array.shape[iaxis + 1 :]):
-        i = i[:iaxis] + (slice(None),) + i[iaxis:]
-        result[i] = pad_func(array[i], iaxis_pad_width, iaxis, pad_func_kwargs)
-
-    return result
-
-
-def pad_udf(array, pad_width, mode, **kwargs):
-    """
-    Helper function for padding boundaries with a user defined function.
-
-    In cases where the padding requires a custom user defined function be
-    applied to the array, this function assists in the prepping and
-    application of this function to the Dask Array to construct the desired
-    boundaries.
-    """
-
-    result = pad_edge(array, pad_width, "constant", constant_values=0)
-
-    chunks = result.chunks
-    for d in range(result.ndim):
-        result = result.rechunk(
-            chunks[:d] + (result.shape[d : d + 1],) + chunks[d + 1 :]
-        )
-
-        result = result.map_blocks(
-            wrapped_pad_func,
-            name="pad",
-            dtype=result.dtype,
-            pad_func=mode,
-            iaxis_pad_width=pad_width[d],
-            iaxis=d,
-            pad_func_kwargs=kwargs,
-        )
-
-        result = result.rechunk(chunks)
-
-    return result
-
-
-@derived_from(np)
-def pad(array, pad_width, mode="constant", **kwargs):
-    array = asarray(array)
-
-    pad_width = expand_pad_value(array, pad_width)
-
-    if callable(mode):
-        return pad_udf(array, pad_width, mode, **kwargs)
-
-    # Make sure that no unsupported keywords were passed for the current mode
-    allowed_kwargs = {
-        "empty": [],
-        "edge": [],
-        "wrap": [],
-        "constant": ["constant_values"],
-        "linear_ramp": ["end_values"],
-        "maximum": ["stat_length"],
-        "mean": ["stat_length"],
-        "median": ["stat_length"],
-        "minimum": ["stat_length"],
-        "reflect": ["reflect_type"],
-        "symmetric": ["reflect_type"],
-    }
-    try:
-        unsupported_kwargs = set(kwargs) - set(allowed_kwargs[mode])
-    except KeyError as e:
-        raise ValueError("mode '{}' is not supported".format(mode)) from e
-    if unsupported_kwargs:
-        raise ValueError(
-            "unsupported keyword arguments for mode '{}': {}".format(
-                mode, unsupported_kwargs
-            )
-        )
-
-    if mode in {"maximum", "mean", "median", "minimum"}:
-        stat_length = kwargs.get("stat_length", tuple((n, n) for n in array.shape))
-        return pad_stats(array, pad_width, mode, stat_length)
-    elif mode == "constant":
-        kwargs.setdefault("constant_values", 0)
-        return pad_edge(array, pad_width, mode, **kwargs)
-    elif mode == "linear_ramp":
-        kwargs.setdefault("end_values", 0)
-        return pad_edge(array, pad_width, mode, **kwargs)
-    elif mode in {"edge", "empty"}:
-        return pad_edge(array, pad_width, mode)
-    elif mode in ["reflect", "symmetric", "wrap"]:
-        return pad_reuse(array, pad_width, mode, **kwargs)
-
-    assert False, "unreachable"
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/einsumfuncs.py b/Flaskserver/venv/Lib/site-packages/dask/array/einsumfuncs.py
deleted file mode 100644
index f4f21cb2fad01be12a05315c58ae6ab9135aed0c..0000000000000000000000000000000000000000
--- a/Flaskserver/venv/Lib/site-packages/dask/array/einsumfuncs.py
+++ /dev/null
@@ -1,251 +0,0 @@
-import numpy as np
-from numpy.compat import basestring
-
-from .core import blockwise, asarray, einsum_lookup
-from ..utils import derived_from
-
-einsum_symbols = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
-einsum_symbols_set = set(einsum_symbols)
-
-
-def chunk_einsum(*operands, **kwargs):
-    subscripts = kwargs.pop("subscripts")
-    ncontract_inds = kwargs.pop("ncontract_inds")
-    dtype = kwargs.pop("kernel_dtype")
-    einsum = einsum_lookup.dispatch(type(operands[0]))
-    chunk = einsum(subscripts, *operands, dtype=dtype, **kwargs)
-
-    # Avoid concatenate=True in blockwise by adding 1's
-    # for the contracted dimensions
-    return chunk.reshape(chunk.shape + (1,) * ncontract_inds)
-
-
-# This function duplicates numpy's _parse_einsum_input() function
-# See https://github.com/numpy/numpy/blob/master/LICENSE.txt
-# or NUMPY_LICENSE.txt within this directory
-def parse_einsum_input(operands):
-    """
-    A reproduction of numpy's _parse_einsum_input()
-    which in itself is a reproduction of
-    c side einsum parsing in python.
-
-    Returns
-    -------
-    input_strings : str
-        Parsed input strings
-    output_string : str
-        Parsed output string
-    operands : list of array_like
-        The operands to use in the numpy contraction
-    Examples
-    --------
-    The operand list is simplified to reduce printing:
-    >> a = np.random.rand(4, 4)
-    >> b = np.random.rand(4, 4, 4)
-    >> __parse_einsum_input(('...a,...a->...', a, b))
-    ('za,xza', 'xz', [a, b])
-    >> __parse_einsum_input((a, [Ellipsis, 0], b, [Ellipsis, 0]))
-    ('za,xza', 'xz', [a, b])
-    """
-
-    if len(operands) == 0:
-        raise ValueError("No input operands")
-
-    if isinstance(operands[0], basestring):
-        subscripts = operands[0].replace(" ", "")
-        operands = [asarray(o) for o in operands[1:]]
-
-        # Ensure all characters are valid
-        for s in subscripts:
-            if s in ".,->":
-                continue
-            if s not in einsum_symbols_set:
-                raise ValueError("Character %s is not a valid symbol." % s)
-
-    else:
-        tmp_operands = list(operands)
-        operand_list = []
-        subscript_list = []
-        for p in range(len(operands) // 2):
-            operand_list.append(tmp_operands.pop(0))
-            subscript_list.append(tmp_operands.pop(0))
-
-        output_list = tmp_operands[-1] if len(tmp_operands) else None
-        operands = [asarray(v) for v in operand_list]
-        subscripts = ""
-        last = len(subscript_list) - 1
-        for num, sub in enumerate(subscript_list):
-            for s in sub:
-                if s is Ellipsis:
-                    subscripts += "..."
-                elif isinstance(s, int):
-                    subscripts += einsum_symbols[s]
-                else:
-                    raise TypeError(
-                        "For this input type lists must contain "
-                        "either int or Ellipsis"
-                    )
-            if num != last:
-                subscripts += ","
-
-        if output_list is not None:
-            subscripts += "->"
-            for s in output_list:
-                if s is Ellipsis:
-                    subscripts += "..."
-                elif isinstance(s, int):
-                    subscripts += einsum_symbols[s]
-                else:
-                    raise TypeError(
-                        "For this input type lists must contain "
-                        "either int or Ellipsis"
-                    )
-    # Check for proper "->"
-    if ("-" in subscripts) or (">" in subscripts):
-        invalid = (subscripts.count("-") > 1) or (subscripts.count(">") > 1)
-        if invalid or (subscripts.count("->") != 1):
-            raise ValueError("Subscripts can only contain one '->'.")
-
-    # Parse ellipses
-    if "." in subscripts:
-        used = subscripts.replace(".", "").replace(",", "").replace("->", "")
-        unused = list(einsum_symbols_set - set(used))
-        ellipse_inds = "".join(unused)
-        longest = 0
-
-        if "->" in subscripts:
-            input_tmp, output_sub = subscripts.split("->")
-            split_subscripts = input_tmp.split(",")
-            out_sub = True
-        else:
-            split_subscripts = subscripts.split(",")
-            out_sub = False
-
-        for num, sub in enumerate(split_subscripts):
-            if "." in sub:
-                if (sub.count(".") != 3) or (sub.count("...") != 1):
-                    raise ValueError("Invalid Ellipses.")
-
-                # Take into account numerical values
-                if operands[num].shape == ():
-                    ellipse_count = 0
-                else:
-                    ellipse_count = max(operands[num].ndim, 1)
-                    ellipse_count -= len(sub) - 3
-
-                if ellipse_count > longest:
-                    longest = ellipse_count
-
-                if ellipse_count < 0:
-                    raise ValueError("Ellipses lengths do not match.")
-                elif ellipse_count == 0:
-                    split_subscripts[num] = sub.replace("...", "")
-                else:
-                    rep_inds = ellipse_inds[-ellipse_count:]
-                    split_subscripts[num] = sub.replace("...", rep_inds)
-
-        subscripts = ",".join(split_subscripts)
-        if longest == 0:
-            out_ellipse = ""
-        else:
-            out_ellipse = ellipse_inds[-longest:]
-
-        if out_sub:
-            subscripts += "->" + output_sub.replace("...", out_ellipse)
-        else:
-            # Special care for outputless ellipses
-            output_subscript = ""
-            tmp_subscripts = subscripts.replace(",", "")
-            for s in sorted(set(tmp_subscripts)):
-                if s not in einsum_symbols_set:
-                    raise ValueError("Character %s is not a valid symbol." % s)
-                if tmp_subscripts.count(s) == 1:
-                    output_subscript += s
-            normal_inds = "".join(sorted(set(output_subscript) - set(out_ellipse)))
-
-            subscripts += "->" + out_ellipse + normal_inds
-
-    # Build output string if does not exist
-    if "->" in subscripts:
-        input_subscripts, output_subscript = subscripts.split("->")
-    else:
-        input_subscripts = subscripts
-        # Build output subscripts
-        tmp_subscripts = subscripts.replace(",", "")
-        output_subscript = ""
-        for s in sorted(set(tmp_subscripts)):
-            if s not in einsum_symbols_set:
-                raise ValueError("Character %s is not a valid symbol." % s)
-            if tmp_subscripts.count(s) == 1:
-                output_subscript += s
-
-    # Make sure output subscripts are in the input
-    for char in output_subscript:
-        if char not in input_subscripts:
-            raise ValueError("Output character %s did not appear in the input" % char)
-
-    # Make sure number operands is equivalent to the number of terms
-    if len(input_subscripts.split(",")) != len(operands):
-        raise ValueError(
-            "Number of einsum subscripts must be equal to the number of operands."
-        )
-
-    return (input_subscripts, output_subscript, operands)
-
-
-@derived_from(np)
-def einsum(*operands, **kwargs):
-    dtype = kwargs.pop("dtype", None)
-    optimize = kwargs.pop("optimize", False)
-    split_every = kwargs.pop("split_every", None)
-
-    einsum_dtype = dtype
-
-    inputs, outputs, ops = parse_einsum_input(operands)
-    subscripts = "->".join((inputs, outputs))
-
-    # Infer the output dtype from operands
-    if dtype is None:
-        dtype = np.result_type(*[o.dtype for o in ops])
-
-    if optimize is not False:
-        # Avoid computation of dask arrays within np.einsum_path
-        # by passing in small numpy arrays broadcasted
-        # up to the right shape
-        fake_ops = [np.broadcast_to(o.dtype.type(0), shape=o.shape) for o in ops]
-        optimize, _ = np.einsum_path(subscripts, *fake_ops, optimize=optimize)
-
-    inputs = [tuple(i) for i in inputs.split(",")]
-
-    # Set of all indices
-    all_inds = set(a for i in inputs for a in i)
-
-    # Which indices are contracted?
-    contract_inds = all_inds - set(outputs)
-    ncontract_inds = len(contract_inds)
-
-    # Introduce the contracted indices into the blockwise product
-    # so that we get numpy arrays, not lists
-    result = blockwise(
-        chunk_einsum,
-        tuple(outputs) + tuple(contract_inds),
-        *(a for ap in zip(ops, inputs) for a in ap),
-        # blockwise parameters
-        adjust_chunks={ind: 1 for ind in contract_inds},
-        dtype=dtype,
-        # np.einsum parameters
-        subscripts=subscripts,
-        kernel_dtype=einsum_dtype,
-        ncontract_inds=ncontract_inds,
-        optimize=optimize,
-        **kwargs
-    )
-
-    # Now reduce over any extra contraction dimensions
-    if ncontract_inds > 0:
-        size = len(outputs)
-        return result.sum(
-            axis=list(range(size, size + ncontract_inds)), split_every=split_every
-        )
-
-    return result
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/fft.py b/Flaskserver/venv/Lib/site-packages/dask/array/fft.py
deleted file mode 100644
index 824e4a7b729054d3bccb8e774485ee1f1cfb2fb4..0000000000000000000000000000000000000000
--- a/Flaskserver/venv/Lib/site-packages/dask/array/fft.py
+++ /dev/null
@@ -1,295 +0,0 @@
-import inspect
-from collections.abc import Sequence
-
-import numpy as np
-
-try:
-    import scipy
-    import scipy.fftpack
-except ImportError:
-    scipy = None
-
-from .core import concatenate as _concatenate
-from .creation import arange as _arange
-from ..utils import derived_from
-
-
-chunk_error = (
-    "Dask array only supports taking an FFT along an axis that \n"
-    "has a single chunk. An FFT operation was tried on axis %s \n"
-    "which has chunks %s. To change the array's chunks use "
-    "dask.Array.rechunk."
-)
-
-fft_preamble = """
-    Wrapping of %s
-
-    The axis along which the FFT is applied must have only one chunk. To change
-    the array's chunking use dask.Array.rechunk.
-
-    The %s docstring follows below:
-
-    """
-
-
-def _fft_out_chunks(a, s, axes):
-    """ For computing the output chunks of [i]fft*"""
-    if s is None:
-        return a.chunks
-    chunks = list(a.chunks)
-    for i, axis in enumerate(axes):
-        chunks[axis] = (s[i],)
-    return chunks
-
-
-def _rfft_out_chunks(a, s, axes):
-    """ For computing the output chunks of rfft*"""
-    if s is None:
-        s = [a.chunks[axis][0] for axis in axes]
-    s = list(s)
-    s[-1] = s[-1] // 2 + 1
-    chunks = list(a.chunks)
-    for i, axis in enumerate(axes):
-        chunks[axis] = (s[i],)
-    return chunks
-
-
-def _irfft_out_chunks(a, s, axes):
-    """ For computing the output chunks of irfft*"""
-    if s is None:
-        s = [a.chunks[axis][0] for axis in axes]
-        s[-1] = 2 * (s[-1] - 1)
-    chunks = list(a.chunks)
-    for i, axis in enumerate(axes):
-        chunks[axis] = (s[i],)
-    return chunks
-
-
-def _hfft_out_chunks(a, s, axes):
-    assert len(axes) == 1
-
-    axis = axes[0]
-
-    if s is None:
-        s = [2 * (a.chunks[axis][0] - 1)]
-
-    n = s[0]
-
-    chunks = list(a.chunks)
-    chunks[axis] = (n,)
-    return chunks
-
-
-def _ihfft_out_chunks(a, s, axes):
-    assert len(axes) == 1
-
-    axis = axes[0]
-
-    if s is None:
-        s = [a.chunks[axis][0]]
-    else:
-        assert len(s) == 1
-
-    n = s[0]
-
-    chunks = list(a.chunks)
-    if n % 2 == 0:
-        m = (n // 2) + 1
-    else:
-        m = (n + 1) // 2
-    chunks[axis] = (m,)
-    return chunks
-
-
-_out_chunk_fns = {
-    "fft": _fft_out_chunks,
-    "ifft": _fft_out_chunks,
-    "rfft": _rfft_out_chunks,
-    "irfft": _irfft_out_chunks,
-    "hfft": _hfft_out_chunks,
-    "ihfft": _ihfft_out_chunks,
-}
-
-
-def fft_wrap(fft_func, kind=None, dtype=None):
-    """Wrap 1D, 2D, and ND real and complex FFT functions
-
-    Takes a function that behaves like ``numpy.fft`` functions and
-    a specified kind to match it to that are named after the functions
-    in the ``numpy.fft`` API.
-
-    Supported kinds include:
-
-        * fft
-        * fft2
-        * fftn
-        * ifft
-        * ifft2
-        * ifftn
-        * rfft
-        * rfft2
-        * rfftn
-        * irfft
-        * irfft2
-        * irfftn
-        * hfft
-        * ihfft
-
-    Examples
-    --------
-    >>> parallel_fft = fft_wrap(np.fft.fft)
-    >>> parallel_ifft = fft_wrap(np.fft.ifft)
-    """
-    if scipy is not None:
-        if fft_func is scipy.fftpack.rfft:
-            raise ValueError("SciPy's `rfft` doesn't match the NumPy API.")
-        elif fft_func is scipy.fftpack.irfft:
-            raise ValueError("SciPy's `irfft` doesn't match the NumPy API.")
-
-    if kind is None:
-        kind = fft_func.__name__
-    try:
-        out_chunk_fn = _out_chunk_fns[kind.rstrip("2n")]
-    except KeyError:
-        raise ValueError("Given unknown `kind` %s." % kind)
-
-    def func(a, s=None, axes=None):
-        if axes is None:
-            if kind.endswith("2"):
-                axes = (-2, -1)
-            elif kind.endswith("n"):
-                if s is None:
-                    axes = tuple(range(a.ndim))
-                else:
-                    axes = tuple(range(len(s)))
-            else:
-                axes = (-1,)
-        else:
-            if len(set(axes)) < len(axes):
-                raise ValueError("Duplicate axes not allowed.")
-
-        _dtype = dtype
-        if _dtype is None:
-            sample = np.ones(a.ndim * (8,), dtype=a.dtype)
-            try:
-                _dtype = fft_func(sample, axes=axes).dtype
-            except TypeError:
-                _dtype = fft_func(sample).dtype
-
-        for each_axis in axes:
-            if len(a.chunks[each_axis]) != 1:
-                raise ValueError(chunk_error % (each_axis, a.chunks[each_axis]))
-
-        chunks = out_chunk_fn(a, s, axes)
-
-        args = (s, axes)
-        if kind.endswith("fft"):
-            axis = None if axes is None else axes[0]
-            n = None if s is None else s[0]
-            args = (n, axis)
-
-        return a.map_blocks(fft_func, *args, dtype=_dtype, chunks=chunks)
-
-    if kind.endswith("fft"):
-        _func = func
-
-        def func(a, n=None, axis=None):
-            s = None
-            if n is not None:
-                s = (n,)
-
-            axes = None
-            if axis is not None:
-                axes = (axis,)
-
-            return _func(a, s, axes)
-
-    func_mod = inspect.getmodule(fft_func)
-    func_name = fft_func.__name__
-    func_fullname = func_mod.__name__ + "." + func_name
-    if fft_func.__doc__ is not None:
-        func.__doc__ = fft_preamble % (2 * (func_fullname,))
-        func.__doc__ += fft_func.__doc__
-    func.__name__ = func_name
-    return func
-
-
-fft = fft_wrap(np.fft.fft)
-fft2 = fft_wrap(np.fft.fft2)
-fftn = fft_wrap(np.fft.fftn)
-ifft = fft_wrap(np.fft.ifft)
-ifft2 = fft_wrap(np.fft.ifft2)
-ifftn = fft_wrap(np.fft.ifftn)
-rfft = fft_wrap(np.fft.rfft)
-rfft2 = fft_wrap(np.fft.rfft2)
-rfftn = fft_wrap(np.fft.rfftn)
-irfft = fft_wrap(np.fft.irfft)
-irfft2 = fft_wrap(np.fft.irfft2)
-irfftn = fft_wrap(np.fft.irfftn)
-hfft = fft_wrap(np.fft.hfft)
-ihfft = fft_wrap(np.fft.ihfft)
-
-
-def _fftfreq_block(i, n, d):
-    r = i.copy()
-    r[i >= (n + 1) // 2] -= n
-    r /= n * d
-    return r
-
-
-@derived_from(np.fft)
-def fftfreq(n, d=1.0, chunks="auto"):
-    n = int(n)
-    d = float(d)
-
-    r = _arange(n, dtype=float, chunks=chunks)
-
-    return r.map_blocks(_fftfreq_block, dtype=float, n=n, d=d)
-
-
-@derived_from(np.fft)
-def rfftfreq(n, d=1.0, chunks="auto"):
-    n = int(n)
-    d = float(d)
-
-    r = _arange(n // 2 + 1, dtype=float, chunks=chunks)
-    r /= n * d
-
-    return r
-
-
-def _fftshift_helper(x, axes=None, inverse=False):
-    if axes is None:
-        axes = list(range(x.ndim))
-    elif not isinstance(axes, Sequence):
-        axes = (axes,)
-
-    y = x
-    for i in axes:
-        n = y.shape[i]
-        n_2 = (n + int(inverse is False)) // 2
-
-        l = y.ndim * [slice(None)]
-        l[i] = slice(None, n_2)
-        l = tuple(l)
-
-        r = y.ndim * [slice(None)]
-        r[i] = slice(n_2, None)
-        r = tuple(r)
-
-        y = _concatenate([y[r], y[l]], axis=i)
-
-        if len(x.chunks[i]) == 1:
-            y = y.rechunk({i: x.chunks[i]})
-
-    return y
-
-
-@derived_from(np.fft)
-def fftshift(x, axes=None):
-    return _fftshift_helper(x, axes=axes, inverse=False)
-
-
-@derived_from(np.fft)
-def ifftshift(x, axes=None):
-    return _fftshift_helper(x, axes=axes, inverse=True)
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/gufunc.py b/Flaskserver/venv/Lib/site-packages/dask/array/gufunc.py
deleted file mode 100644
index 9b9557c34579fef4e07ccbc35f36e7270271337e..0000000000000000000000000000000000000000
--- a/Flaskserver/venv/Lib/site-packages/dask/array/gufunc.py
+++ /dev/null
@@ -1,758 +0,0 @@
-import numpy as np
-import re
-
-from tlz import concat, merge, unique
-
-from .core import Array, asarray, blockwise, getitem, apply_infer_dtype
-from .utils import meta_from_array
-from ..highlevelgraph import HighLevelGraph
-from ..core import flatten
-
-
-# Modified version of `numpy.lib.function_base._parse_gufunc_signature`
-# Modifications:
-#   - Allow for zero input arguments
-# See https://docs.scipy.org/doc/numpy/reference/c-api/generalized-ufuncs.html
-_DIMENSION_NAME = r"\w+"
-_CORE_DIMENSION_LIST = "(?:{0:}(?:,{0:})*,?)?".format(_DIMENSION_NAME)
-_ARGUMENT = r"\({}\)".format(_CORE_DIMENSION_LIST)
-_INPUT_ARGUMENTS = "(?:{0:}(?:,{0:})*,?)?".format(_ARGUMENT)
-_OUTPUT_ARGUMENTS = "{0:}(?:,{0:})*".format(
-    _ARGUMENT
-)  # Use `'{0:}(?:,{0:})*,?'` if gufunc-
-# signature should be allowed for length 1 tuple returns
-_SIGNATURE = "^{0:}->{1:}$".format(_INPUT_ARGUMENTS, _OUTPUT_ARGUMENTS)
-
-
-def _parse_gufunc_signature(signature):
-    """
-    Parse string signatures for a generalized universal function.
-
-    Arguments
-    ---------
-    signature : string
-        Generalized universal function signature, e.g., ``(m,n),(n,p)->(m,p)``
-        for ``np.matmul``.
-
-    Returns
-    -------
-    Tuple of input and output core dimensions parsed from the signature, each
-    of the form List[Tuple[str, ...]], except for one output. For one output
-    core dimension is not a list, but of the form Tuple[str, ...]
-    """
-    signature = signature.replace(" ", "")
-    if not re.match(_SIGNATURE, signature):
-        raise ValueError("Not a valid gufunc signature: {}".format(signature))
-    in_txt, out_txt = signature.split("->")
-    ins = [
-        tuple(re.findall(_DIMENSION_NAME, arg)) for arg in re.findall(_ARGUMENT, in_txt)
-    ]
-    outs = [
-        tuple(re.findall(_DIMENSION_NAME, arg))
-        for arg in re.findall(_ARGUMENT, out_txt)
-    ]
-    outs = outs[0] if ((len(outs) == 1) and (out_txt[-1] != ",")) else outs
-    return ins, outs
-
-
-def _validate_normalize_axes(axes, axis, keepdims, input_coredimss, output_coredimss):
-    """
-    Validates logic of `axes`/`axis`/`keepdims` arguments and normalize them.
-    Refer to [1]_ for details
-
-    Arguments
-    ---------
-    axes: List of tuples
-    axis: int
-    keepdims: bool
-    input_coredimss: List of Tuple of dims
-    output_coredimss: List of Tuple of dims
-
-    Returns
-    -------
-    input_axes: List of tuple of int
-    output_axes: List of tuple of int
-
-    References
-    ----------
-    .. [1] https://docs.scipy.org/doc/numpy/reference/ufuncs.html#optional-keyword-arguments
-    """
-    nin = len(input_coredimss)
-    nout = 1 if not isinstance(output_coredimss, list) else len(output_coredimss)
-
-    if axes is not None and axis is not None:
-        raise ValueError(
-            "Only one of `axis` or `axes` keyword arguments should be given"
-        )
-    if axes and not isinstance(axes, list):
-        raise ValueError("`axes` has to be of type list")
-
-    output_coredimss = output_coredimss if nout > 1 else [output_coredimss]
-    filtered_core_dims = list(filter(len, input_coredimss))
-    nr_outputs_with_coredims = len([True for x in output_coredimss if len(x) > 0])
-
-    if keepdims:
-        if nr_outputs_with_coredims > 0:
-            raise ValueError("`keepdims` can only be used for scalar outputs")
-        output_coredimss = len(output_coredimss) * [filtered_core_dims[0]]
-
-    core_dims = input_coredimss + output_coredimss
-    if axis is not None:
-        if not isinstance(axis, int):
-            raise ValueError("`axis` argument has to be an integer value")
-        if filtered_core_dims:
-            cd0 = filtered_core_dims[0]
-            if len(cd0) != 1:
-                raise ValueError(
-                    "`axis` can be used only, if one core dimension is present"
-                )
-            for cd in filtered_core_dims:
-                if cd0 != cd:
-                    raise ValueError(
-                        "To use `axis`, all core dimensions have to be equal"
-                    )
-
-    # Expand dafaults or axis
-    if axes is None:
-        if axis is not None:
-            axes = [(axis,) if cd else tuple() for cd in core_dims]
-        else:
-            axes = [tuple(range(-len(icd), 0)) for icd in core_dims]
-    elif not isinstance(axes, list):
-        raise ValueError("`axes` argument has to be a list")
-    axes = [(a,) if isinstance(a, int) else a for a in axes]
-
-    if (
-        (nr_outputs_with_coredims == 0)
-        and (nin != len(axes))
-        and (nin + nout != len(axes))
-    ) or ((nr_outputs_with_coredims > 0) and (nin + nout != len(axes))):
-        raise ValueError(
-            "The number of `axes` entries is not equal the number of input and output arguments"
-        )
-
-    # Treat outputs
-    output_axes = axes[nin:]
-    output_axes = (
-        output_axes
-        if output_axes
-        else [tuple(range(-len(ocd), 0)) for ocd in output_coredimss]
-    )
-    input_axes = axes[:nin]
-
-    # Assert we have as many axes as output core dimensions
-    for idx, (iax, icd) in enumerate(zip(input_axes, input_coredimss)):
-        if len(iax) != len(icd):
-            raise ValueError(
-                "The number of `axes` entries for argument #{} is not equal "
-                "the number of respective input core dimensions in signature".format(
-                    idx
-                )
-            )
-    if not keepdims:
-        for idx, (oax, ocd) in enumerate(zip(output_axes, output_coredimss)):
-            if len(oax) != len(ocd):
-                raise ValueError(
-                    "The number of `axes` entries for argument #{} is not equal "
-                    "the number of respective output core dimensions in signature".format(
-                        idx
-                    )
-                )
-    else:
-        if input_coredimss:
-            icd0 = input_coredimss[0]
-            for icd in input_coredimss:
-                if icd0 != icd:
-                    raise ValueError(
-                        "To use `keepdims`, all core dimensions have to be equal"
-                    )
-            iax0 = input_axes[0]
-            output_axes = [iax0 for _ in output_coredimss]
-
-    return input_axes, output_axes
-
-
-def apply_gufunc(func, signature, *args, **kwargs):
-    """
-    Apply a generalized ufunc or similar python function to arrays.
-
-    ``signature`` determines if the function consumes or produces core
-    dimensions. The remaining dimensions in given input arrays (``*args``)
-    are considered loop dimensions and are required to broadcast
-    naturally against each other.
-
-    In other terms, this function is like ``np.vectorize``, but for
-    the blocks of dask arrays. If the function itself shall also
-    be vectorized use ``vectorize=True`` for convenience.
-
-    Parameters
-    ----------
-    func : callable
-        Function to call like ``func(*args, **kwargs)`` on input arrays
-        (``*args``) that returns an array or tuple of arrays. If multiple
-        arguments with non-matching dimensions are supplied, this function is
-        expected to vectorize (broadcast) over axes of positional arguments in
-        the style of NumPy universal functions [1]_ (if this is not the case,
-        set ``vectorize=True``). If this function returns multiple outputs,
-        ``output_core_dims`` has to be set as well.
-    signature: string
-        Specifies what core dimensions are consumed and produced by ``func``.
-        According to the specification of numpy.gufunc signature [2]_
-    *args : numeric
-        Input arrays or scalars to the callable function.
-    axes: List of tuples, optional, keyword only
-        A list of tuples with indices of axes a generalized ufunc should operate on.
-        For instance, for a signature of ``"(i,j),(j,k)->(i,k)"`` appropriate for
-        matrix multiplication, the base elements are two-dimensional matrices
-        and these are taken to be stored in the two last axes of each argument. The
-        corresponding axes keyword would be ``[(-2, -1), (-2, -1), (-2, -1)]``.
-        For simplicity, for generalized ufuncs that operate on 1-dimensional arrays
-        (vectors), a single integer is accepted instead of a single-element tuple,
-        and for generalized ufuncs for which all outputs are scalars, the output
-        tuples can be omitted.
-    axis: int, optional, keyword only
-        A single axis over which a generalized ufunc should operate. This is a short-cut
-        for ufuncs that operate over a single, shared core dimension, equivalent to passing
-        in axes with entries of (axis,) for each single-core-dimension argument and ``()`` for
-        all others. For instance, for a signature ``"(i),(i)->()"``, it is equivalent to passing
-        in ``axes=[(axis,), (axis,), ()]``.
-    keepdims: bool, optional, keyword only
-        If this is set to True, axes which are reduced over will be left in the result as
-        a dimension with size one, so that the result will broadcast correctly against the
-        inputs. This option can only be used for generalized ufuncs that operate on inputs
-        that all have the same number of core dimensions and with outputs that have no core
-        dimensions , i.e., with signatures like ``"(i),(i)->()"`` or ``"(m,m)->()"``.
-        If used, the location of the dimensions in the output can be controlled with axes
-        and axis.
-    output_dtypes : Optional, dtype or list of dtypes, keyword only
-        Valid numpy dtype specification or list thereof.
-        If not given, a call of ``func`` with a small set of data
-        is performed in order to try to automatically determine the
-        output dtypes.
-    output_sizes : dict, optional, keyword only
-        Optional mapping from dimension names to sizes for outputs. Only used if
-        new core dimensions (not found on inputs) appear on outputs.
-    vectorize: bool, keyword only
-        If set to ``True``, ``np.vectorize`` is applied to ``func`` for
-        convenience. Defaults to ``False``.
-    allow_rechunk: Optional, bool, keyword only
-        Allows rechunking, otherwise chunk sizes need to match and core
-        dimensions are to consist only of one chunk.
-        Warning: enabling this can increase memory usage significantly.
-        Defaults to ``False``.
-    meta: Optional, tuple, keyword only
-        tuple of empty ndarrays describing the shape and dtype of the output of the gufunc.
-        Defaults to ``None``.
-    **kwargs : dict
-        Extra keyword arguments to pass to `func`
-
-    Returns
-    -------
-    Single dask.array.Array or tuple of dask.array.Array
-
-    Examples
-    --------
-    >>> import dask.array as da
-    >>> import numpy as np
-    >>> def stats(x):
-    ...     return np.mean(x, axis=-1), np.std(x, axis=-1)
-    >>> a = da.random.normal(size=(10,20,30), chunks=(5, 10, 30))
-    >>> mean, std = da.apply_gufunc(stats, "(i)->(),()", a)
-    >>> mean.compute().shape
-    (10, 20)
-
-
-    >>> def outer_product(x, y):
-    ...     return np.einsum("i,j->ij", x, y)
-    >>> a = da.random.normal(size=(   20,30), chunks=(10, 30))
-    >>> b = da.random.normal(size=(10, 1,40), chunks=(5, 1, 40))
-    >>> c = da.apply_gufunc(outer_product, "(i),(j)->(i,j)", a, b, vectorize=True)
-    >>> c.compute().shape
-    (10, 20, 30, 40)
-
-    References
-    ----------
-    .. [1] https://docs.scipy.org/doc/numpy/reference/ufuncs.html
-    .. [2] https://docs.scipy.org/doc/numpy/reference/c-api/generalized-ufuncs.html
-    """
-    axes = kwargs.pop("axes", None)
-    axis = kwargs.pop("axis", None)
-    keepdims = kwargs.pop("keepdims", False)
-    output_dtypes = kwargs.pop("output_dtypes", None)
-    output_sizes = kwargs.pop("output_sizes", None)
-    vectorize = kwargs.pop("vectorize", None)
-    allow_rechunk = kwargs.pop("allow_rechunk", False)
-    meta = kwargs.pop("meta", None)
-
-    # Input processing:
-    ## Signature
-    if not isinstance(signature, str):
-        raise TypeError("`signature` has to be of type string")
-    input_coredimss, output_coredimss = _parse_gufunc_signature(signature)
-
-    ## Determine nout: nout = None for functions of one direct return; nout = int for return tuples
-    nout = None if not isinstance(output_coredimss, list) else len(output_coredimss)
-
-    ## Determine and handle output_dtypes
-    if output_dtypes is None:
-        if vectorize:
-            tempfunc = np.vectorize(func, signature=signature)
-        else:
-            tempfunc = func
-        output_dtypes = apply_infer_dtype(
-            tempfunc, args, kwargs, "apply_gufunc", "output_dtypes", nout
-        )
-
-    if isinstance(output_dtypes, (tuple, list)):
-        if nout is None:
-            if len(output_dtypes) > 1:
-                raise ValueError(
-                    (
-                        "Must specify single dtype or list of one dtype "
-                        "for `output_dtypes` for function with one output"
-                    )
-                )
-            otypes = output_dtypes
-            output_dtypes = output_dtypes[0]
-        else:
-            otypes = output_dtypes
-    else:
-        if nout is not None:
-            raise ValueError(
-                "Must specify tuple of dtypes for `output_dtypes` for function with multiple outputs"
-            )
-        otypes = [output_dtypes]
-
-    ## Vectorize function, if required
-    if vectorize:
-        func = np.vectorize(func, signature=signature, otypes=otypes)
-
-    ## Miscellaneous
-    if output_sizes is None:
-        output_sizes = {}
-
-    ## Axes
-    input_axes, output_axes = _validate_normalize_axes(
-        axes, axis, keepdims, input_coredimss, output_coredimss
-    )
-
-    # Main code:
-    ## Cast all input arrays to dask
-    args = [asarray(a) for a in args]
-
-    if len(input_coredimss) != len(args):
-        ValueError(
-            "According to `signature`, `func` requires %d arguments, but %s given"
-            % (len(input_coredimss), len(args))
-        )
-
-    ## Axes: transpose input arguments
-    transposed_args = []
-    for arg, iax, input_coredims in zip(args, input_axes, input_coredimss):
-        shape = arg.shape
-        iax = tuple(a if a < 0 else a - len(shape) for a in iax)
-        tidc = tuple(i for i in range(-len(shape) + 0, 0) if i not in iax) + iax
-        transposed_arg = arg.transpose(tidc)
-        transposed_args.append(transposed_arg)
-    args = transposed_args
-
-    ## Assess input args for loop dims
-    input_shapes = [a.shape for a in args]
-    input_chunkss = [a.chunks for a in args]
-    num_loopdims = [len(s) - len(cd) for s, cd in zip(input_shapes, input_coredimss)]
-    max_loopdims = max(num_loopdims) if num_loopdims else None
-    core_input_shapes = [
-        dict(zip(icd, s[n:]))
-        for s, n, icd in zip(input_shapes, num_loopdims, input_coredimss)
-    ]
-    core_shapes = merge(*core_input_shapes)
-    core_shapes.update(output_sizes)
-
-    loop_input_dimss = [
-        tuple("__loopdim%d__" % d for d in range(max_loopdims - n, max_loopdims))
-        for n in num_loopdims
-    ]
-    input_dimss = [l + c for l, c in zip(loop_input_dimss, input_coredimss)]
-
-    loop_output_dims = max(loop_input_dimss, key=len) if loop_input_dimss else tuple()
-
-    ## Assess input args for same size and chunk sizes
-    ### Collect sizes and chunksizes of all dims in all arrays
-    dimsizess = {}
-    chunksizess = {}
-    for dims, shape, chunksizes in zip(input_dimss, input_shapes, input_chunkss):
-        for dim, size, chunksize in zip(dims, shape, chunksizes):
-            dimsizes = dimsizess.get(dim, [])
-            dimsizes.append(size)
-            dimsizess[dim] = dimsizes
-            chunksizes_ = chunksizess.get(dim, [])
-            chunksizes_.append(chunksize)
-            chunksizess[dim] = chunksizes_
-    ### Assert correct partitioning, for case:
-    for dim, sizes in dimsizess.items():
-        #### Check that the arrays have same length for same dimensions or dimension `1`
-        if set(sizes).union({1}) != {1, max(sizes)}:
-            raise ValueError(
-                "Dimension `'{}'` with different lengths in arrays".format(dim)
-            )
-        if not allow_rechunk:
-            chunksizes = chunksizess[dim]
-            #### Check if core dimensions consist of only one chunk
-            if (dim in core_shapes) and (chunksizes[0][0] < core_shapes[dim]):
-                raise ValueError(
-                    "Core dimension `'{}'` consists of multiple chunks. To fix, rechunk into a single \
-chunk along this dimension or set `allow_rechunk=True`, but beware that this may increase memory usage \
-significantly.".format(
-                        dim
-                    )
-                )
-            #### Check if loop dimensions consist of same chunksizes, when they have sizes > 1
-            relevant_chunksizes = list(
-                unique(c for s, c in zip(sizes, chunksizes) if s > 1)
-            )
-            if len(relevant_chunksizes) > 1:
-                raise ValueError(
-                    "Dimension `'{}'` with different chunksize present".format(dim)
-                )
-
-    ## Apply function - use blockwise here
-    arginds = list(concat(zip(args, input_dimss)))
-
-    ### Use existing `blockwise` but only with loopdims to enforce
-    ### concatenation for coredims that appear also at the output
-    ### Modifying `blockwise` could improve things here.
-    if meta is not None:
-        tmp = blockwise(
-            func, loop_output_dims, *arginds, concatenate=True, meta=meta, **kwargs
-        )
-    else:
-        try:
-            tmp = blockwise(  # First try to compute meta
-                func, loop_output_dims, *arginds, concatenate=True, **kwargs
-            )
-        except ValueError:
-            # If computing meta doesn't work, provide it explicitly based on
-            # provided dtypes
-            sample = arginds[0]._meta
-            if isinstance(output_dtypes, tuple):
-                meta = tuple(
-                    meta_from_array(sample, dtype=odt)
-                    for ocd, odt in zip(output_coredimss, output_dtypes)
-                )
-            else:
-                meta = tuple(
-                    meta_from_array(sample, dtype=odt)
-                    for ocd, odt in zip((output_coredimss,), (output_dtypes,))
-                )
-            tmp = blockwise(
-                func, loop_output_dims, *arginds, concatenate=True, meta=meta, **kwargs
-            )
-
-    if isinstance(tmp._meta, tuple):
-        metas = tmp._meta
-    else:
-        metas = (tmp._meta,)
-
-    ## Prepare output shapes
-    loop_output_shape = tmp.shape
-    loop_output_chunks = tmp.chunks
-    keys = list(flatten(tmp.__dask_keys__()))
-    name, token = keys[0][0].split("-")
-
-    ### *) Treat direct output
-    if nout is None:
-        output_coredimss = [output_coredimss]
-        output_dtypes = [output_dtypes]
-
-    ## Split output
-    leaf_arrs = []
-    for i, (ocd, oax, meta) in enumerate(zip(output_coredimss, output_axes, metas)):
-        core_output_shape = tuple(core_shapes[d] for d in ocd)
-        core_chunkinds = len(ocd) * (0,)
-        output_shape = loop_output_shape + core_output_shape
-        output_chunks = loop_output_chunks + core_output_shape
-        leaf_name = "%s_%d-%s" % (name, i, token)
-        leaf_dsk = {
-            (leaf_name,)
-            + key[1:]
-            + core_chunkinds: ((getitem, key, i) if nout else key)
-            for key in keys
-        }
-        graph = HighLevelGraph.from_collections(leaf_name, leaf_dsk, dependencies=[tmp])
-        meta = meta_from_array(meta, len(output_shape))
-        leaf_arr = Array(
-            graph, leaf_name, chunks=output_chunks, shape=output_shape, meta=meta
-        )
-
-        ### Axes:
-        if keepdims:
-            slices = len(leaf_arr.shape) * (slice(None),) + len(oax) * (np.newaxis,)
-            leaf_arr = leaf_arr[slices]
-
-        tidcs = [None] * len(leaf_arr.shape)
-        for i, oa in zip(range(-len(oax), 0), oax):
-            tidcs[oa] = i
-        j = 0
-        for i in range(len(tidcs)):
-            if tidcs[i] is None:
-                tidcs[i] = j
-                j += 1
-        leaf_arr = leaf_arr.transpose(tidcs)
-        leaf_arrs.append(leaf_arr)
-
-    return (*leaf_arrs,) if nout else leaf_arrs[0]  # Undo *) from above
-
-
-class gufunc(object):
-    """
-    Binds `pyfunc` into ``dask.array.apply_gufunc`` when called.
-
-    Parameters
-    ----------
-    pyfunc : callable
-        Function to call like ``func(*args, **kwargs)`` on input arrays
-        (``*args``) that returns an array or tuple of arrays. If multiple
-        arguments with non-matching dimensions are supplied, this function is
-        expected to vectorize (broadcast) over axes of positional arguments in
-        the style of NumPy universal functions [1]_ (if this is not the case,
-        set ``vectorize=True``). If this function returns multiple outputs,
-        ``output_core_dims`` has to be set as well.
-    signature : String, keyword only
-        Specifies what core dimensions are consumed and produced by ``func``.
-        According to the specification of numpy.gufunc signature [2]_
-    axes: List of tuples, optional, keyword only
-        A list of tuples with indices of axes a generalized ufunc should operate on.
-        For instance, for a signature of ``"(i,j),(j,k)->(i,k)"`` appropriate for
-        matrix multiplication, the base elements are two-dimensional matrices
-        and these are taken to be stored in the two last axes of each argument. The
-        corresponding axes keyword would be ``[(-2, -1), (-2, -1), (-2, -1)]``.
-        For simplicity, for generalized ufuncs that operate on 1-dimensional arrays
-        (vectors), a single integer is accepted instead of a single-element tuple,
-        and for generalized ufuncs for which all outputs are scalars, the output
-        tuples can be omitted.
-    axis: int, optional, keyword only
-        A single axis over which a generalized ufunc should operate. This is a short-cut
-        for ufuncs that operate over a single, shared core dimension, equivalent to passing
-        in axes with entries of (axis,) for each single-core-dimension argument and ``()`` for
-        all others. For instance, for a signature ``"(i),(i)->()"``, it is equivalent to passing
-        in ``axes=[(axis,), (axis,), ()]``.
-    keepdims: bool, optional, keyword only
-        If this is set to True, axes which are reduced over will be left in the result as
-        a dimension with size one, so that the result will broadcast correctly against the
-        inputs. This option can only be used for generalized ufuncs that operate on inputs
-        that all have the same number of core dimensions and with outputs that have no core
-        dimensions , i.e., with signatures like ``"(i),(i)->()"`` or ``"(m,m)->()"``.
-        If used, the location of the dimensions in the output can be controlled with axes
-        and axis.
-    output_dtypes : Optional, dtype or list of dtypes, keyword only
-        Valid numpy dtype specification or list thereof.
-        If not given, a call of ``func`` with a small set of data
-        is performed in order to try to automatically determine the
-        output dtypes.
-    output_sizes : dict, optional, keyword only
-        Optional mapping from dimension names to sizes for outputs. Only used if
-        new core dimensions (not found on inputs) appear on outputs.
-    vectorize: bool, keyword only
-        If set to ``True``, ``np.vectorize`` is applied to ``func`` for
-        convenience. Defaults to ``False``.
-    allow_rechunk: Optional, bool, keyword only
-        Allows rechunking, otherwise chunk sizes need to match and core
-        dimensions are to consist only of one chunk.
-        Warning: enabling this can increase memory usage significantly.
-        Defaults to ``False``.
-
-    Returns
-    -------
-    Wrapped function
-
-    Examples
-    --------
-    >>> import dask.array as da
-    >>> import numpy as np
-    >>> a = da.random.normal(size=(10,20,30), chunks=(5, 10, 30))
-    >>> def stats(x):
-    ...     return np.mean(x, axis=-1), np.std(x, axis=-1)
-    >>> gustats = da.gufunc(stats, signature="(i)->(),()", output_dtypes=(float, float))
-    >>> mean, std = gustats(a)
-    >>> mean.compute().shape
-    (10, 20)
-
-    >>> a = da.random.normal(size=(   20,30), chunks=(10, 30))
-    >>> b = da.random.normal(size=(10, 1,40), chunks=(5, 1, 40))
-    >>> def outer_product(x, y):
-    ...     return np.einsum("i,j->ij", x, y)
-    >>> guouter_product = da.gufunc(outer_product, signature="(i),(j)->(i,j)", output_dtypes=float, vectorize=True)
-    >>> c = guouter_product(a, b)
-    >>> c.compute().shape
-    (10, 20, 30, 40)
-
-    References
-    ----------
-    .. [1] https://docs.scipy.org/doc/numpy/reference/ufuncs.html
-    .. [2] https://docs.scipy.org/doc/numpy/reference/c-api/generalized-ufuncs.html
-    """
-
-    def __init__(self, pyfunc, **kwargs):
-        self.pyfunc = pyfunc
-        self.signature = kwargs.pop("signature", None)
-        self.vectorize = kwargs.pop("vectorize", False)
-        self.axes = kwargs.pop("axes", None)
-        self.axis = kwargs.pop("axis", None)
-        self.keepdims = kwargs.pop("keepdims", False)
-        self.output_sizes = kwargs.pop("output_sizes", None)
-        self.output_dtypes = kwargs.pop("output_dtypes", None)
-        self.allow_rechunk = kwargs.pop("allow_rechunk", False)
-        if kwargs:
-            raise TypeError("Unsupported keyword argument(s) provided")
-
-        self.__doc__ = """
-        Bound ``dask.array.gufunc``
-        func: ``{func}``
-        signature: ``'{signature}'``
-
-        Parameters
-        ----------
-        *args : numpy/dask arrays or scalars
-            Arrays to which to apply to ``func``. Core dimensions as specified in
-            ``signature`` need to come last.
-        **kwargs : dict
-            Extra keyword arguments to pass to ``func``
-
-        Returns
-        -------
-        Single dask.array.Array or tuple of dask.array.Array
-        """.format(
-            func=str(self.pyfunc), signature=self.signature
-        )
-
-    def __call__(self, *args, **kwargs):
-        return apply_gufunc(
-            self.pyfunc,
-            self.signature,
-            *args,
-            vectorize=self.vectorize,
-            axes=self.axes,
-            axis=self.axis,
-            keepdims=self.keepdims,
-            output_sizes=self.output_sizes,
-            output_dtypes=self.output_dtypes,
-            allow_rechunk=self.allow_rechunk or kwargs.pop("allow_rechunk", False),
-            **kwargs,
-        )
-
-
-def as_gufunc(signature=None, **kwargs):
-    """
-    Decorator for ``dask.array.gufunc``.
-
-    Parameters
-    ----------
-    signature : String
-        Specifies what core dimensions are consumed and produced by ``func``.
-        According to the specification of numpy.gufunc signature [2]_
-    axes: List of tuples, optional, keyword only
-        A list of tuples with indices of axes a generalized ufunc should operate on.
-        For instance, for a signature of ``"(i,j),(j,k)->(i,k)"`` appropriate for
-        matrix multiplication, the base elements are two-dimensional matrices
-        and these are taken to be stored in the two last axes of each argument. The
-        corresponding axes keyword would be ``[(-2, -1), (-2, -1), (-2, -1)]``.
-        For simplicity, for generalized ufuncs that operate on 1-dimensional arrays
-        (vectors), a single integer is accepted instead of a single-element tuple,
-        and for generalized ufuncs for which all outputs are scalars, the output
-        tuples can be omitted.
-    axis: int, optional, keyword only
-        A single axis over which a generalized ufunc should operate. This is a short-cut
-        for ufuncs that operate over a single, shared core dimension, equivalent to passing
-        in axes with entries of (axis,) for each single-core-dimension argument and ``()`` for
-        all others. For instance, for a signature ``"(i),(i)->()"``, it is equivalent to passing
-        in ``axes=[(axis,), (axis,), ()]``.
-    keepdims: bool, optional, keyword only
-        If this is set to True, axes which are reduced over will be left in the result as
-        a dimension with size one, so that the result will broadcast correctly against the
-        inputs. This option can only be used for generalized ufuncs that operate on inputs
-        that all have the same number of core dimensions and with outputs that have no core
-        dimensions , i.e., with signatures like ``"(i),(i)->()"`` or ``"(m,m)->()"``.
-        If used, the location of the dimensions in the output can be controlled with axes
-        and axis.
-    output_dtypes : Optional, dtype or list of dtypes, keyword only
-        Valid numpy dtype specification or list thereof.
-        If not given, a call of ``func`` with a small set of data
-        is performed in order to try to automatically determine the
-        output dtypes.
-    output_sizes : dict, optional, keyword only
-        Optional mapping from dimension names to sizes for outputs. Only used if
-        new core dimensions (not found on inputs) appear on outputs.
-    vectorize: bool, keyword only
-        If set to ``True``, ``np.vectorize`` is applied to ``func`` for
-        convenience. Defaults to ``False``.
-    allow_rechunk: Optional, bool, keyword only
-        Allows rechunking, otherwise chunk sizes need to match and core
-        dimensions are to consist only of one chunk.
-        Warning: enabling this can increase memory usage significantly.
-        Defaults to ``False``.
-    meta: Optional, tuple, keyword only
-        tuple of empty ndarrays describing the shape and dtype of the output of the gufunc.
-        Defaults to ``None``.
-
-    Returns
-    -------
-    Decorator for `pyfunc` that itself returns a `gufunc`.
-
-    Examples
-    --------
-    >>> import dask.array as da
-    >>> import numpy as np
-    >>> a = da.random.normal(size=(10,20,30), chunks=(5, 10, 30))
-    >>> @da.as_gufunc("(i)->(),()", output_dtypes=(float, float))
-    ... def stats(x):
-    ...     return np.mean(x, axis=-1), np.std(x, axis=-1)
-    >>> mean, std = stats(a)
-    >>> mean.compute().shape
-    (10, 20)
-
-    >>> a = da.random.normal(size=(   20,30), chunks=(10, 30))
-    >>> b = da.random.normal(size=(10, 1,40), chunks=(5, 1, 40))
-    >>> @da.as_gufunc("(i),(j)->(i,j)", output_dtypes=float, vectorize=True)
-    ... def outer_product(x, y):
-    ...     return np.einsum("i,j->ij", x, y)
-    >>> c = outer_product(a, b)
-    >>> c.compute().shape
-    (10, 20, 30, 40)
-
-    References
-    ----------
-    .. [1] https://docs.scipy.org/doc/numpy/reference/ufuncs.html
-    .. [2] https://docs.scipy.org/doc/numpy/reference/c-api/generalized-ufuncs.html
-    """
-    _allowedkeys = {
-        "vectorize",
-        "axes",
-        "axis",
-        "keepdims",
-        "output_sizes",
-        "output_dtypes",
-        "allow_rechunk",
-        "meta",
-    }
-    if set(_allowedkeys).issubset(kwargs.keys()):
-        raise TypeError("Unsupported keyword argument(s) provided")
-
-    def _as_gufunc(pyfunc):
-        return gufunc(pyfunc, signature=signature, **kwargs)
-
-    _as_gufunc.__doc__ = """
-        Decorator to make ``dask.array.gufunc``
-        signature: ``'{signature}'``
-
-        Parameters
-        ----------
-        pyfunc : callable
-            Function matching signature ``'{signature}'``.
-
-        Returns
-        -------
-        ``dask.array.gufunc``
-        """.format(
-        signature=signature
-    )
-    return _as_gufunc
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/image.py b/Flaskserver/venv/Lib/site-packages/dask/array/image.py
deleted file mode 100644
index 8c2341f09326e80b557a176f956d5c6b8d34a7b1..0000000000000000000000000000000000000000
--- a/Flaskserver/venv/Lib/site-packages/dask/array/image.py
+++ /dev/null
@@ -1,69 +0,0 @@
-from glob import glob
-import os
-
-try:
-    from skimage.io import imread as sk_imread
-except (AttributeError, ImportError):
-    pass
-
-from .core import Array
-from ..base import tokenize
-
-
-def add_leading_dimension(x):
-    return x[None, ...]
-
-
-def imread(filename, imread=None, preprocess=None):
-    """Read a stack of images into a dask array
-
-    Parameters
-    ----------
-
-    filename: string
-        A globstring like 'myfile.*.png'
-    imread: function (optional)
-        Optionally provide custom imread function.
-        Function should expect a filename and produce a numpy array.
-        Defaults to ``skimage.io.imread``.
-    preprocess: function (optional)
-        Optionally provide custom function to preprocess the image.
-        Function should expect a numpy array for a single image.
-
-    Examples
-    --------
-
-    >>> from dask.array.image import imread
-    >>> im = imread('2015-*-*.png')  # doctest: +SKIP
-    >>> im.shape  # doctest: +SKIP
-    (365, 1000, 1000, 3)
-
-    Returns
-    -------
-
-    Dask array of all images stacked along the first dimension.  All images
-    will be treated as individual chunks
-    """
-    imread = imread or sk_imread
-    filenames = sorted(glob(filename))
-    if not filenames:
-        raise ValueError("No files found under name %s" % filename)
-
-    name = "imread-%s" % tokenize(filenames, map(os.path.getmtime, filenames))
-
-    sample = imread(filenames[0])
-    if preprocess:
-        sample = preprocess(sample)
-
-    keys = [(name, i) + (0,) * len(sample.shape) for i in range(len(filenames))]
-    if preprocess:
-        values = [
-            (add_leading_dimension, (preprocess, (imread, fn))) for fn in filenames
-        ]
-    else:
-        values = [(add_leading_dimension, (imread, fn)) for fn in filenames]
-    dsk = dict(zip(keys, values))
-
-    chunks = ((1,) * len(filenames),) + tuple((d,) for d in sample.shape)
-
-    return Array(dsk, name, chunks, sample.dtype)
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/linalg.py b/Flaskserver/venv/Lib/site-packages/dask/array/linalg.py
deleted file mode 100644
index 4fea40cf5bc854eb11c92bbec62cb2c009566302..0000000000000000000000000000000000000000
--- a/Flaskserver/venv/Lib/site-packages/dask/array/linalg.py
+++ /dev/null
@@ -1,1359 +0,0 @@
-import operator
-from numbers import Number
-
-import numpy as np
-import tlz as toolz
-
-from ..base import tokenize, wait
-from ..blockwise import blockwise
-from ..highlevelgraph import HighLevelGraph
-from ..utils import derived_from, apply
-from .core import dotmany, Array, concatenate
-from .creation import eye
-from .random import RandomState
-from .utils import meta_from_array
-
-
-def _cumsum_blocks(it):
-    total = 0
-    for x in it:
-        total_previous = total
-        total += x
-        yield (total_previous, total)
-
-
-def _cumsum_part(last, new):
-    return (last[1], last[1] + new)
-
-
-def _nanmin(m, n):
-    k_0 = min([m, n])
-    k_1 = m if np.isnan(n) else n
-    return k_1 if np.isnan(k_0) else k_0
-
-
-def _wrapped_qr(a):
-    """
-    A wrapper for np.linalg.qr that handles arrays with 0 rows
-
-    Notes: Created for tsqr so as to manage cases with uncertain
-    array dimensions. In particular, the case where arrays have
-    (uncertain) chunks with 0 rows.
-    """
-    # workaround may be removed when numpy stops rejecting edge cases
-    if a.shape[0] == 0:
-        return np.zeros((0, 0)), np.zeros((0, a.shape[1]))
-    else:
-        return np.linalg.qr(a)
-
-
-def tsqr(data, compute_svd=False, _max_vchunk_size=None):
-    """Direct Tall-and-Skinny QR algorithm
-
-    As presented in:
-
-        A. Benson, D. Gleich, and J. Demmel.
-        Direct QR factorizations for tall-and-skinny matrices in
-        MapReduce architectures.
-        IEEE International Conference on Big Data, 2013.
-        https://arxiv.org/abs/1301.1071
-
-    This algorithm is used to compute both the QR decomposition and the
-    Singular Value Decomposition.  It requires that the input array have a
-    single column of blocks, each of which fit in memory.
-
-    Parameters
-    ----------
-    data: Array
-    compute_svd: bool
-        Whether to compute the SVD rather than the QR decomposition
-    _max_vchunk_size: Integer
-        Used internally in recursion to set the maximum row dimension
-        of chunks in subsequent recursive calls.
-
-    Notes
-    -----
-    With ``k`` blocks of size ``(m, n)``, this algorithm has memory use that
-    scales as ``k * n * n``.
-
-    The implementation here is the recursive variant due to the ultimate
-    need for one "single core" QR decomposition. In the non-recursive version
-    of the algorithm, given ``k`` blocks, after ``k`` ``m * n`` QR
-    decompositions, there will be a "single core" QR decomposition that will
-    have to work with a ``(k * n, n)`` matrix.
-
-    Here, recursion is applied as necessary to ensure that ``k * n`` is not
-    larger than ``m`` (if ``m / n >= 2``). In particular, this is done
-    to ensure that single core computations do not have to work on blocks
-    larger than ``(m, n)``.
-
-    Where blocks are irregular, the above logic is applied with the "height" of
-    the "tallest" block used in place of ``m``.
-
-    Consider use of the ``rechunk`` method to control this behavior.
-    Taller blocks will reduce overall memory use (assuming that many of them
-    still fit in memory at once).
-
-    See Also
-    --------
-    dask.array.linalg.qr
-        Powered by this algorithm
-    dask.array.linalg.svd
-        Powered by this algorithm
-    dask.array.linalg.sfqr
-        Variant for short-and-fat arrays
-    """
-    nr, nc = len(data.chunks[0]), len(data.chunks[1])
-    cr_max, cc = max(data.chunks[0]), data.chunks[1][0]
-
-    if not (data.ndim == 2 and nc == 1):  # Is a matrix  # Only one column block
-        raise ValueError(
-            "Input must have the following properties:\n"
-            "  1. Have two dimensions\n"
-            "  2. Have only one column of blocks\n\n"
-            "Note: This function (tsqr) supports QR decomposition in the case of\n"
-            "tall-and-skinny matrices (single column chunk/block; see qr)"
-            "Current shape: {},\nCurrent chunksize: {}".format(
-                data.shape, data.chunksize
-            )
-        )
-
-    token = "-" + tokenize(data, compute_svd)
-
-    m, n = data.shape
-    numblocks = (nr, 1)
-
-    qq, rr = np.linalg.qr(np.ones(shape=(1, 1), dtype=data.dtype))
-
-    layers = data.__dask_graph__().layers.copy()
-    dependencies = data.__dask_graph__().dependencies.copy()
-
-    # Block qr
-    name_qr_st1 = "qr" + token
-    dsk_qr_st1 = blockwise(
-        _wrapped_qr,
-        name_qr_st1,
-        "ij",
-        data.name,
-        "ij",
-        numblocks={data.name: numblocks},
-    )
-    layers[name_qr_st1] = dsk_qr_st1
-    dependencies[name_qr_st1] = data.__dask_layers__()
-
-    # Block qr[0]
-    name_q_st1 = "getitem" + token + "-q1"
-    dsk_q_st1 = dict(
-        ((name_q_st1, i, 0), (operator.getitem, (name_qr_st1, i, 0), 0))
-        for i in range(numblocks[0])
-    )
-    layers[name_q_st1] = dsk_q_st1
-    dependencies[name_q_st1] = {name_qr_st1}
-
-    # Block qr[1]
-    name_r_st1 = "getitem" + token + "-r1"
-    dsk_r_st1 = dict(
-        ((name_r_st1, i, 0), (operator.getitem, (name_qr_st1, i, 0), 1))
-        for i in range(numblocks[0])
-    )
-    layers[name_r_st1] = dsk_r_st1
-    dependencies[name_r_st1] = {name_qr_st1}
-
-    # Next step is to obtain a QR decomposition for the stacked R factors, so either:
-    # - gather R factors into a single core and do a QR decomposition
-    # - recurse with tsqr (if single core computation too large and a-priori "meaningful
-    #   reduction" possible, meaning that chunks have to be well defined)
-
-    single_core_compute_m = nr * cc
-    chunks_well_defined = not any(np.isnan(c) for cs in data.chunks for c in cs)
-    prospective_blocks = np.ceil(single_core_compute_m / cr_max)
-    meaningful_reduction_possible = (
-        cr_max if _max_vchunk_size is None else _max_vchunk_size
-    ) >= 2 * cc
-    can_distribute = chunks_well_defined and int(prospective_blocks) > 1
-
-    if chunks_well_defined and meaningful_reduction_possible and can_distribute:
-        # stack chunks into blocks and recurse using tsqr
-
-        # Prepare to stack chunks into blocks (from block qr[1])
-        all_blocks = []
-        curr_block = []
-        curr_block_sz = 0
-        for idx, a_m in enumerate(data.chunks[0]):
-            m_q = a_m
-            n_q = min(m_q, cc)
-            m_r = n_q
-            # n_r = cc
-            if curr_block_sz + m_r > cr_max:
-                all_blocks.append(curr_block)
-                curr_block = []
-                curr_block_sz = 0
-            curr_block.append((idx, m_r))
-            curr_block_sz += m_r
-        if len(curr_block) > 0:
-            all_blocks.append(curr_block)
-
-        # R_stacked
-        name_r_stacked = "stack" + token + "-r1"
-        dsk_r_stacked = dict(
-            (
-                (name_r_stacked, i, 0),
-                (
-                    np.vstack,
-                    (tuple, [(name_r_st1, idx, 0) for idx, _ in sub_block_info]),
-                ),
-            )
-            for i, sub_block_info in enumerate(all_blocks)
-        )
-        layers[name_r_stacked] = dsk_r_stacked
-        dependencies[name_r_stacked] = {name_r_st1}
-
-        # retrieve R_stacked for recursion with tsqr
-        vchunks_rstacked = tuple(
-            [sum(map(lambda x: x[1], sub_block_info)) for sub_block_info in all_blocks]
-        )
-        graph = HighLevelGraph(layers, dependencies)
-        # dsk.dependencies[name_r_stacked] = {data.name}
-        r_stacked_meta = meta_from_array(
-            data, len((sum(vchunks_rstacked), n)), dtype=rr.dtype
-        )
-        r_stacked = Array(
-            graph,
-            name_r_stacked,
-            shape=(sum(vchunks_rstacked), n),
-            chunks=(vchunks_rstacked, n),
-            meta=r_stacked_meta,
-        )
-
-        # recurse
-        q_inner, r_inner = tsqr(r_stacked, _max_vchunk_size=cr_max)
-        layers = toolz.merge(q_inner.dask.layers, r_inner.dask.layers)
-        dependencies = toolz.merge(q_inner.dask.dependencies, r_inner.dask.dependencies)
-
-        # Q_inner: "unstack"
-        name_q_st2 = "getitem" + token + "-q2"
-        dsk_q_st2 = dict(
-            (
-                (name_q_st2, j, 0),
-                (
-                    operator.getitem,
-                    (q_inner.name, i, 0),
-                    ((slice(e[0], e[1])), (slice(0, n))),
-                ),
-            )
-            for i, sub_block_info in enumerate(all_blocks)
-            for j, e in zip(
-                [x[0] for x in sub_block_info],
-                _cumsum_blocks([x[1] for x in sub_block_info]),
-            )
-        )
-        layers[name_q_st2] = dsk_q_st2
-        dependencies[name_q_st2] = q_inner.__dask_layers__()
-
-        # R: R_inner
-        name_r_st2 = "r-inner" + token
-        dsk_r_st2 = {(name_r_st2, 0, 0): (r_inner.name, 0, 0)}
-        layers[name_r_st2] = dsk_r_st2
-        dependencies[name_r_st2] = r_inner.__dask_layers__()
-
-        # Q: Block qr[0] (*) Q_inner
-        name_q_st3 = "dot" + token + "-q3"
-        dsk_q_st3 = blockwise(
-            np.dot,
-            name_q_st3,
-            "ij",
-            name_q_st1,
-            "ij",
-            name_q_st2,
-            "ij",
-            numblocks={name_q_st1: numblocks, name_q_st2: numblocks},
-        )
-        layers[name_q_st3] = dsk_q_st3
-        dependencies[name_q_st3] = {name_q_st1, name_q_st2}
-    else:
-        # Do single core computation
-
-        # Stacking for in-core QR computation
-        to_stack = [(name_r_st1, i, 0) for i in range(numblocks[0])]
-        name_r_st1_stacked = "stack" + token + "-r1"
-        dsk_r_st1_stacked = {(name_r_st1_stacked, 0, 0): (np.vstack, (tuple, to_stack))}
-        layers[name_r_st1_stacked] = dsk_r_st1_stacked
-        dependencies[name_r_st1_stacked] = {name_r_st1}
-
-        # In-core QR computation
-        name_qr_st2 = "qr" + token + "-qr2"
-        dsk_qr_st2 = blockwise(
-            np.linalg.qr,
-            name_qr_st2,
-            "ij",
-            name_r_st1_stacked,
-            "ij",
-            numblocks={name_r_st1_stacked: (1, 1)},
-        )
-        layers[name_qr_st2] = dsk_qr_st2
-        dependencies[name_qr_st2] = {name_r_st1_stacked}
-
-        # In-core qr[0]
-        name_q_st2_aux = "getitem" + token + "-q2-aux"
-        dsk_q_st2_aux = {
-            (name_q_st2_aux, 0, 0): (operator.getitem, (name_qr_st2, 0, 0), 0)
-        }
-        layers[name_q_st2_aux] = dsk_q_st2_aux
-        dependencies[name_q_st2_aux] = {name_qr_st2}
-
-        if not any(np.isnan(c) for cs in data.chunks for c in cs):
-            # when chunks are all known...
-            # obtain slices on q from in-core compute (e.g.: (slice(10, 20), slice(0, 5)))
-            q2_block_sizes = [min(e, n) for e in data.chunks[0]]
-            block_slices = [
-                (slice(e[0], e[1]), slice(0, n)) for e in _cumsum_blocks(q2_block_sizes)
-            ]
-            dsk_q_blockslices = {}
-            deps = set()
-        else:
-            # when chunks are not already known...
-
-            # request shape information: vertical chunk sizes & column dimension (n)
-            name_q2bs = "shape" + token + "-q2"
-            dsk_q2_shapes = {
-                (name_q2bs, i): (min, (getattr, (data.name, i, 0), "shape"))
-                for i in range(numblocks[0])
-            }
-            name_n = "getitem" + token + "-n"
-            dsk_n = {
-                name_n: (operator.getitem, (getattr, (data.name, 0, 0), "shape"), 1)
-            }
-
-            # cumulative sums (start, end)
-            name_q2cs = "cumsum" + token + "-q2"
-            dsk_q2_cumsum = {(name_q2cs, 0): [0, (name_q2bs, 0)]}
-
-            for i in range(1, numblocks[0]):
-                dsk_q2_cumsum[(name_q2cs, i)] = (
-                    _cumsum_part,
-                    (name_q2cs, i - 1),
-                    (name_q2bs, i),
-                )
-
-            # obtain slices on q from in-core compute (e.g.: (slice(10, 20), slice(0, 5)))
-            name_blockslice = "slice" + token + "-q"
-            dsk_block_slices = {
-                (name_blockslice, i): (
-                    tuple,
-                    [(apply, slice, (name_q2cs, i)), (slice, 0, name_n)],
-                )
-                for i in range(numblocks[0])
-            }
-
-            dsk_q_blockslices = toolz.merge(
-                dsk_n, dsk_q2_shapes, dsk_q2_cumsum, dsk_block_slices
-            )
-
-            deps = {data.name, name_q2bs, name_q2cs}
-            block_slices = [(name_blockslice, i) for i in range(numblocks[0])]
-
-        layers["q-blocksizes" + token] = dsk_q_blockslices
-        dependencies["q-blocksizes" + token] = deps
-
-        # In-core qr[0] unstacking
-        name_q_st2 = "getitem" + token + "-q2"
-        dsk_q_st2 = dict(
-            ((name_q_st2, i, 0), (operator.getitem, (name_q_st2_aux, 0, 0), b))
-            for i, b in enumerate(block_slices)
-        )
-        layers[name_q_st2] = dsk_q_st2
-        dependencies[name_q_st2] = {name_q_st2_aux, "q-blocksizes" + token}
-
-        # Q: Block qr[0] (*) In-core qr[0]
-        name_q_st3 = "dot" + token + "-q3"
-        dsk_q_st3 = blockwise(
-            np.dot,
-            name_q_st3,
-            "ij",
-            name_q_st1,
-            "ij",
-            name_q_st2,
-            "ij",
-            numblocks={name_q_st1: numblocks, name_q_st2: numblocks},
-        )
-        layers[name_q_st3] = dsk_q_st3
-        dependencies[name_q_st3] = {name_q_st1, name_q_st2}
-
-        # R: In-core qr[1]
-        name_r_st2 = "getitem" + token + "-r2"
-        dsk_r_st2 = {(name_r_st2, 0, 0): (operator.getitem, (name_qr_st2, 0, 0), 1)}
-        layers[name_r_st2] = dsk_r_st2
-        dependencies[name_r_st2] = {name_qr_st2}
-
-    if not compute_svd:
-        is_unknown_m = np.isnan(data.shape[0]) or any(
-            np.isnan(c) for c in data.chunks[0]
-        )
-        is_unknown_n = np.isnan(data.shape[1]) or any(
-            np.isnan(c) for c in data.chunks[1]
-        )
-
-        if is_unknown_m and is_unknown_n:
-            # assumption: m >= n
-            q_shape = data.shape
-            q_chunks = (data.chunks[0], (np.nan,))
-            r_shape = (np.nan, np.nan)
-            r_chunks = ((np.nan,), (np.nan,))
-        elif is_unknown_m and not is_unknown_n:
-            # assumption: m >= n
-            q_shape = data.shape
-            q_chunks = (data.chunks[0], (n,))
-            r_shape = (n, n)
-            r_chunks = (n, n)
-        elif not is_unknown_m and is_unknown_n:
-            # assumption: m >= n
-            q_shape = data.shape
-            q_chunks = (data.chunks[0], (np.nan,))
-            r_shape = (np.nan, np.nan)
-            r_chunks = ((np.nan,), (np.nan,))
-        else:
-            q_shape = (
-                data.shape
-                if data.shape[0] >= data.shape[1]
-                else (data.shape[0], data.shape[0])
-            )
-            q_chunks = (
-                data.chunks
-                if data.shape[0] >= data.shape[1]
-                else (data.chunks[0], data.chunks[0])
-            )
-            r_shape = (n, n) if data.shape[0] >= data.shape[1] else data.shape
-            r_chunks = r_shape
-
-        # dsk.dependencies[name_q_st3] = {data.name}
-        # dsk.dependencies[name_r_st2] = {data.name}
-        graph = HighLevelGraph(layers, dependencies)
-        q_meta = meta_from_array(data, len(q_shape), qq.dtype)
-        r_meta = meta_from_array(data, len(r_shape), rr.dtype)
-        q = Array(graph, name_q_st3, shape=q_shape, chunks=q_chunks, meta=q_meta)
-        r = Array(graph, name_r_st2, shape=r_shape, chunks=r_chunks, meta=r_meta)
-        return q, r
-    else:
-        # In-core SVD computation
-        name_svd_st2 = "svd" + token + "-2"
-        dsk_svd_st2 = blockwise(
-            np.linalg.svd,
-            name_svd_st2,
-            "ij",
-            name_r_st2,
-            "ij",
-            numblocks={name_r_st2: (1, 1)},
-        )
-        # svd[0]
-        name_u_st2 = "getitem" + token + "-u2"
-        dsk_u_st2 = {(name_u_st2, 0, 0): (operator.getitem, (name_svd_st2, 0, 0), 0)}
-        # svd[1]
-        name_s_st2 = "getitem" + token + "-s2"
-        dsk_s_st2 = {(name_s_st2, 0): (operator.getitem, (name_svd_st2, 0, 0), 1)}
-        # svd[2]
-        name_v_st2 = "getitem" + token + "-v2"
-        dsk_v_st2 = {(name_v_st2, 0, 0): (operator.getitem, (name_svd_st2, 0, 0), 2)}
-        # Q * U
-        name_u_st4 = "getitem" + token + "-u4"
-        dsk_u_st4 = blockwise(
-            dotmany,
-            name_u_st4,
-            "ij",
-            name_q_st3,
-            "ik",
-            name_u_st2,
-            "kj",
-            numblocks={name_q_st3: numblocks, name_u_st2: (1, 1)},
-        )
-
-        layers[name_svd_st2] = dsk_svd_st2
-        dependencies[name_svd_st2] = {name_r_st2}
-        layers[name_u_st2] = dsk_u_st2
-        dependencies[name_u_st2] = {name_svd_st2}
-        layers[name_u_st4] = dsk_u_st4
-        dependencies[name_u_st4] = {name_q_st3, name_u_st2}
-        layers[name_s_st2] = dsk_s_st2
-        dependencies[name_s_st2] = {name_svd_st2}
-        layers[name_v_st2] = dsk_v_st2
-        dependencies[name_v_st2] = {name_svd_st2}
-
-        uu, ss, vvh = np.linalg.svd(np.ones(shape=(1, 1), dtype=data.dtype))
-
-        k = _nanmin(m, n)  # avoid RuntimeWarning with np.nanmin([m, n])
-
-        m_u = m
-        n_u = int(k) if not np.isnan(k) else k
-        n_s = n_u
-        m_vh = n_u
-        n_vh = n
-        d_vh = max(m_vh, n_vh)  # full matrix returned: but basically n
-        graph = HighLevelGraph(layers, dependencies)
-        u_meta = meta_from_array(data, len((m_u, n_u)), uu.dtype)
-        s_meta = meta_from_array(data, len((n_s,)), ss.dtype)
-        vh_meta = meta_from_array(data, len((d_vh, d_vh)), vvh.dtype)
-        u = Array(
-            graph,
-            name_u_st4,
-            shape=(m_u, n_u),
-            chunks=(data.chunks[0], (n_u,)),
-            meta=u_meta,
-        )
-        s = Array(graph, name_s_st2, shape=(n_s,), chunks=((n_s,),), meta=s_meta)
-        vh = Array(
-            graph, name_v_st2, shape=(d_vh, d_vh), chunks=((n,), (n,)), meta=vh_meta
-        )
-        return u, s, vh
-
-
-def sfqr(data, name=None):
-    """Direct Short-and-Fat QR
-
-    Currently, this is a quick hack for non-tall-and-skinny matrices which
-    are one chunk tall and (unless they are one chunk wide) have chunks
-    that are wider than they are tall
-
-    Q [R_1 R_2 ...] = [A_1 A_2 ...]
-
-    it computes the factorization Q R_1 = A_1, then computes the other
-    R_k's in parallel.
-
-    Parameters
-    ----------
-    data: Array
-
-    See Also
-    --------
-    dask.array.linalg.qr
-        Main user API that uses this function
-    dask.array.linalg.tsqr
-        Variant for tall-and-skinny case
-    """
-    nr, nc = len(data.chunks[0]), len(data.chunks[1])
-    cr, cc = data.chunks[0][0], data.chunks[1][0]
-
-    if not (
-        (data.ndim == 2)
-        and (nr == 1)  # Is a matrix
-        and (  # Has exactly one block row
-            (cr <= cc)
-            or (nc == 1)  # Chunking dimension on rows is at least that on cols or...
-        )
-    ):  # ... only one block col
-        raise ValueError(
-            "Input must have the following properties:\n"
-            "  1. Have two dimensions\n"
-            "  2. Have only one row of blocks\n"
-            "  3. Either one column of blocks or (first) chunk size on cols\n"
-            "     is at most that on rows (e.g.: for a 5x20 matrix,\n"
-            "     chunks=((5), (8,4,8)) is fine, but chunks=((5), (4,8,8)) is not;\n"
-            "     still, prefer something simple like chunks=(5,10) or chunks=5)\n\n"
-            "Note: This function (sfqr) supports QR decomposition in the case\n"
-            "of short-and-fat matrices (single row chunk/block; see qr)"
-        )
-
-    prefix = name or "sfqr-" + tokenize(data)
-    prefix += "_"
-
-    m, n = data.shape
-
-    qq, rr = np.linalg.qr(np.ones(shape=(1, 1), dtype=data.dtype))
-
-    layers = data.__dask_graph__().layers.copy()
-    dependencies = data.__dask_graph__().dependencies.copy()
-
-    # data = A = [A_1 A_rest]
-    name_A_1 = prefix + "A_1"
-    name_A_rest = prefix + "A_rest"
-    layers[name_A_1] = {(name_A_1, 0, 0): (data.name, 0, 0)}
-    dependencies[name_A_1] = data.__dask_layers__()
-    layers[name_A_rest] = {
-        (name_A_rest, 0, idx): (data.name, 0, 1 + idx) for idx in range(nc - 1)
-    }
-    dependencies[name_A_rest] = data.__dask_layers__()
-
-    # Q R_1 = A_1
-    name_Q_R1 = prefix + "Q_R_1"
-    name_Q = prefix + "Q"
-    name_R_1 = prefix + "R_1"
-    layers[name_Q_R1] = {(name_Q_R1, 0, 0): (np.linalg.qr, (name_A_1, 0, 0))}
-    dependencies[name_Q_R1] = {name_A_1}
-
-    layers[name_Q] = {(name_Q, 0, 0): (operator.getitem, (name_Q_R1, 0, 0), 0)}
-    dependencies[name_Q] = {name_Q_R1}
-
-    layers[name_R_1] = {(name_R_1, 0, 0): (operator.getitem, (name_Q_R1, 0, 0), 1)}
-    dependencies[name_R_1] = {name_Q_R1}
-
-    graph = HighLevelGraph(layers, dependencies)
-
-    Q_meta = meta_from_array(data, len((m, min(m, n))), dtype=qq.dtype)
-    R_1_meta = meta_from_array(data, len((min(m, n), cc)), dtype=rr.dtype)
-    Q = Array(graph, name_Q, shape=(m, min(m, n)), chunks=(m, min(m, n)), meta=Q_meta)
-    R_1 = Array(graph, name_R_1, shape=(min(m, n), cc), chunks=(cr, cc), meta=R_1_meta)
-
-    # R = [R_1 Q'A_rest]
-    Rs = [R_1]
-
-    if nc > 1:
-        A_rest_meta = meta_from_array(data, len((min(m, n), n - cc)), dtype=rr.dtype)
-        A_rest = Array(
-            graph,
-            name_A_rest,
-            shape=(min(m, n), n - cc),
-            chunks=(cr, data.chunks[1][1:]),
-            meta=A_rest_meta,
-        )
-        Rs.append(Q.T.dot(A_rest))
-
-    R = concatenate(Rs, axis=1)
-
-    return Q, R
-
-
-def compression_level(n, q, oversampling=10, min_subspace_size=20):
-    """Compression level to use in svd_compressed
-
-    Given the size ``n`` of a space, compress that that to one of size
-    ``q`` plus oversampling.
-
-    The oversampling allows for greater flexibility in finding an
-    appropriate subspace, a low value is often enough (10 is already a
-    very conservative choice, it can be further reduced).
-    ``q + oversampling`` should not be larger than ``n``.  In this
-    specific implementation, ``q + oversampling`` is at least
-    ``min_subspace_size``.
-
-    >>> compression_level(100, 10)
-    20
-    """
-    return min(max(min_subspace_size, q + oversampling), n)
-
-
-def compression_matrix(data, q, n_power_iter=0, seed=None, compute=False):
-    """Randomly sample matrix to find most active subspace
-
-    This compression matrix returned by this algorithm can be used to
-    compute both the QR decomposition and the Singular Value
-    Decomposition.
-
-    Parameters
-    ----------
-    data: Array
-    q: int
-        Size of the desired subspace (the actual size will be bigger,
-        because of oversampling, see ``da.linalg.compression_level``)
-    n_power_iter: int
-        number of power iterations, useful when the singular values of
-        the input matrix decay very slowly.
-    compute : bool
-        Whether or not to compute data at each use.
-        Recomputing the input while performing several passes reduces memory
-        pressure, but means that we have to compute the input multiple times.
-        This is a good choice if the data is larger than memory and cheap to
-        recreate.
-
-    References
-    ----------
-    N. Halko, P. G. Martinsson, and J. A. Tropp.
-    Finding structure with randomness: Probabilistic algorithms for
-    constructing approximate matrix decompositions.
-    SIAM Rev., Survey and Review section, Vol. 53, num. 2,
-    pp. 217-288, June 2011
-    https://arxiv.org/abs/0909.4061
-    """
-    n = data.shape[1]
-    comp_level = compression_level(n, q)
-    if isinstance(seed, RandomState):
-        state = seed
-    else:
-        state = RandomState(seed)
-    omega = state.standard_normal(
-        size=(n, comp_level), chunks=(data.chunks[1], (comp_level,))
-    )
-    mat_h = data.dot(omega)
-    for j in range(n_power_iter):
-        if compute:
-            mat_h = mat_h.persist()
-            wait(mat_h)
-        tmp = data.T.dot(mat_h)
-        if compute:
-            tmp = tmp.persist()
-            wait(tmp)
-        mat_h = data.dot(tmp)
-    q, _ = tsqr(mat_h)
-    return q.T
-
-
-def svd_compressed(a, k, n_power_iter=0, seed=None, compute=False):
-    """Randomly compressed rank-k thin Singular Value Decomposition.
-
-    This computes the approximate singular value decomposition of a large
-    array.  This algorithm is generally faster than the normal algorithm
-    but does not provide exact results.  One can balance between
-    performance and accuracy with input parameters (see below).
-
-    Parameters
-    ----------
-    a: Array
-        Input array
-    k: int
-        Rank of the desired thin SVD decomposition.
-    n_power_iter: int
-        Number of power iterations, useful when the singular values
-        decay slowly. Error decreases exponentially as n_power_iter
-        increases. In practice, set n_power_iter <= 4.
-    compute : bool
-        Whether or not to compute data at each use.
-        Recomputing the input while performing several passes reduces memory
-        pressure, but means that we have to compute the input multiple times.
-        This is a good choice if the data is larger than memory and cheap to
-        recreate.
-
-    Examples
-    --------
-    >>> u, s, vt = svd_compressed(x, 20)  # doctest: +SKIP
-
-    Returns
-    -------
-    u:  Array, unitary / orthogonal
-    s:  Array, singular values in decreasing order (largest first)
-    v:  Array, unitary / orthogonal
-
-    References
-    ----------
-    N. Halko, P. G. Martinsson, and J. A. Tropp.
-    Finding structure with randomness: Probabilistic algorithms for
-    constructing approximate matrix decompositions.
-    SIAM Rev., Survey and Review section, Vol. 53, num. 2,
-    pp. 217-288, June 2011
-    https://arxiv.org/abs/0909.4061
-    """
-    comp = compression_matrix(
-        a, k, n_power_iter=n_power_iter, seed=seed, compute=compute
-    )
-    if compute:
-        comp = comp.persist()
-        wait(comp)
-    a_compressed = comp.dot(a)
-    v, s, u = tsqr(a_compressed.T, compute_svd=True)
-    u = comp.T.dot(u)
-    v = v.T
-    u = u[:, :k]
-    s = s[:k]
-    v = v[:k, :]
-    return u, s, v
-
-
-def qr(a):
-    """
-    Compute the qr factorization of a matrix.
-
-    Parameters
-    ----------
-    a : Array
-
-    Returns
-    -------
-    q:  Array, orthonormal
-    r:  Array, upper-triangular
-
-    Examples
-    --------
-    >>> q, r = da.linalg.qr(x)  # doctest: +SKIP
-
-    See Also
-    --------
-    numpy.linalg.qr: Equivalent NumPy Operation
-    dask.array.linalg.tsqr: Implementation for tall-and-skinny arrays
-    dask.array.linalg.sfqr: Implementation for short-and-fat arrays
-    """
-
-    if len(a.chunks[1]) == 1 and len(a.chunks[0]) > 1:
-        return tsqr(a)
-    elif len(a.chunks[0]) == 1:
-        return sfqr(a)
-    else:
-        raise NotImplementedError(
-            "qr currently supports only tall-and-skinny (single column chunk/block; see tsqr)\n"
-            "and short-and-fat (single row chunk/block; see sfqr) matrices\n\n"
-            "Consider use of the rechunk method. For example,\n\n"
-            "x.rechunk({0: -1, 1: 'auto'}) or x.rechunk({0: 'auto', 1: -1})\n\n"
-            "which rechunk one shorter axis to a single chunk, while allowing\n"
-            "the other axis to automatically grow/shrink appropriately."
-        )
-
-
-def svd(a):
-    """
-    Compute the singular value decomposition of a matrix.
-
-    Examples
-    --------
-
-    >>> u, s, v = da.linalg.svd(x)  # doctest: +SKIP
-
-    Returns
-    -------
-
-    u:  Array, unitary / orthogonal
-    s:  Array, singular values in decreasing order (largest first)
-    v:  Array, unitary / orthogonal
-
-    See Also
-    --------
-
-    np.linalg.svd : Equivalent NumPy Operation
-    dask.array.linalg.tsqr: Implementation for tall-and-skinny arrays
-    """
-    return tsqr(a, compute_svd=True)
-
-
-def _solve_triangular_lower(a, b):
-    import scipy.linalg
-
-    return scipy.linalg.solve_triangular(a, b, lower=True)
-
-
-def lu(a):
-    """
-    Compute the lu decomposition of a matrix.
-
-    Examples
-    --------
-
-    >>> p, l, u = da.linalg.lu(x)  # doctest: +SKIP
-
-    Returns
-    -------
-
-    p:  Array, permutation matrix
-    l:  Array, lower triangular matrix with unit diagonal.
-    u:  Array, upper triangular matrix
-    """
-
-    import scipy.linalg
-
-    if a.ndim != 2:
-        raise ValueError("Dimension must be 2 to perform lu decomposition")
-
-    xdim, ydim = a.shape
-    if xdim != ydim:
-        raise ValueError("Input must be a square matrix to perform lu decomposition")
-    if not len(set(a.chunks[0] + a.chunks[1])) == 1:
-        msg = (
-            "All chunks must be a square matrix to perform lu decomposition. "
-            "Use .rechunk method to change the size of chunks."
-        )
-        raise ValueError(msg)
-
-    vdim = len(a.chunks[0])
-    hdim = len(a.chunks[1])
-
-    token = tokenize(a)
-    name_lu = "lu-lu-" + token
-
-    name_p = "lu-p-" + token
-    name_l = "lu-l-" + token
-    name_u = "lu-u-" + token
-
-    # for internal calculation
-    name_p_inv = "lu-p-inv-" + token
-    name_l_permuted = "lu-l-permute-" + token
-    name_u_transposed = "lu-u-transpose-" + token
-    name_plu_dot = "lu-plu-dot-" + token
-    name_lu_dot = "lu-lu-dot-" + token
-
-    dsk = {}
-    for i in range(min(vdim, hdim)):
-        target = (a.name, i, i)
-        if i > 0:
-            prevs = []
-            for p in range(i):
-                prev = name_plu_dot, i, p, p, i
-                dsk[prev] = (np.dot, (name_l_permuted, i, p), (name_u, p, i))
-                prevs.append(prev)
-            target = (operator.sub, target, (sum, prevs))
-        # diagonal block
-        dsk[name_lu, i, i] = (scipy.linalg.lu, target)
-
-        # sweep to horizontal
-        for j in range(i + 1, hdim):
-            target = (np.dot, (name_p_inv, i, i), (a.name, i, j))
-            if i > 0:
-                prevs = []
-                for p in range(i):
-                    prev = name_lu_dot, i, p, p, j
-                    dsk[prev] = (np.dot, (name_l, i, p), (name_u, p, j))
-                    prevs.append(prev)
-                target = (operator.sub, target, (sum, prevs))
-            dsk[name_lu, i, j] = (_solve_triangular_lower, (name_l, i, i), target)
-
-        # sweep to vertical
-        for k in range(i + 1, vdim):
-            target = (a.name, k, i)
-            if i > 0:
-                prevs = []
-                for p in range(i):
-                    prev = name_plu_dot, k, p, p, i
-                    dsk[prev] = (np.dot, (name_l_permuted, k, p), (name_u, p, i))
-                    prevs.append(prev)
-                target = (operator.sub, target, (sum, prevs))
-            # solving x.dot(u) = target is equal to u.T.dot(x.T) = target.T
-            dsk[name_lu, k, i] = (
-                np.transpose,
-                (
-                    _solve_triangular_lower,
-                    (name_u_transposed, i, i),
-                    (np.transpose, target),
-                ),
-            )
-
-    for i in range(min(vdim, hdim)):
-        for j in range(min(vdim, hdim)):
-            if i == j:
-                dsk[name_p, i, j] = (operator.getitem, (name_lu, i, j), 0)
-                dsk[name_l, i, j] = (operator.getitem, (name_lu, i, j), 1)
-                dsk[name_u, i, j] = (operator.getitem, (name_lu, i, j), 2)
-
-                # permuted l is required to be propagated to i > j blocks
-                dsk[name_l_permuted, i, j] = (np.dot, (name_p, i, j), (name_l, i, j))
-                dsk[name_u_transposed, i, j] = (np.transpose, (name_u, i, j))
-                # transposed permutation matrix is equal to its inverse
-                dsk[name_p_inv, i, j] = (np.transpose, (name_p, i, j))
-            elif i > j:
-                dsk[name_p, i, j] = (np.zeros, (a.chunks[0][i], a.chunks[1][j]))
-                # calculations are performed using permuted l,
-                # thus the result should be reverted by inverted (=transposed) p
-                # to have the same row order as diagonal blocks
-                dsk[name_l, i, j] = (np.dot, (name_p_inv, i, i), (name_lu, i, j))
-                dsk[name_u, i, j] = (np.zeros, (a.chunks[0][i], a.chunks[1][j]))
-                dsk[name_l_permuted, i, j] = (name_lu, i, j)
-            else:
-                dsk[name_p, i, j] = (np.zeros, (a.chunks[0][i], a.chunks[1][j]))
-                dsk[name_l, i, j] = (np.zeros, (a.chunks[0][i], a.chunks[1][j]))
-                dsk[name_u, i, j] = (name_lu, i, j)
-                # l_permuted is not referred in upper triangulars
-
-    pp, ll, uu = scipy.linalg.lu(np.ones(shape=(1, 1), dtype=a.dtype))
-    pp_meta = meta_from_array(a, dtype=pp.dtype)
-    ll_meta = meta_from_array(a, dtype=ll.dtype)
-    uu_meta = meta_from_array(a, dtype=uu.dtype)
-
-    graph = HighLevelGraph.from_collections(name_p, dsk, dependencies=[a])
-    p = Array(graph, name_p, shape=a.shape, chunks=a.chunks, meta=pp_meta)
-
-    graph = HighLevelGraph.from_collections(name_l, dsk, dependencies=[a])
-    l = Array(graph, name_l, shape=a.shape, chunks=a.chunks, meta=ll_meta)
-
-    graph = HighLevelGraph.from_collections(name_u, dsk, dependencies=[a])
-    u = Array(graph, name_u, shape=a.shape, chunks=a.chunks, meta=uu_meta)
-
-    return p, l, u
-
-
-def solve_triangular(a, b, lower=False):
-    """
-    Solve the equation `a x = b` for `x`, assuming a is a triangular matrix.
-
-    Parameters
-    ----------
-    a : (M, M) array_like
-        A triangular matrix
-    b : (M,) or (M, N) array_like
-        Right-hand side matrix in `a x = b`
-    lower : bool, optional
-        Use only data contained in the lower triangle of `a`.
-        Default is to use upper triangle.
-
-    Returns
-    -------
-    x : (M,) or (M, N) array
-        Solution to the system `a x = b`. Shape of return matches `b`.
-    """
-
-    import scipy.linalg
-
-    if a.ndim != 2:
-        raise ValueError("a must be 2 dimensional")
-    if b.ndim <= 2:
-        if a.shape[1] != b.shape[0]:
-            raise ValueError("a.shape[1] and b.shape[0] must be equal")
-        if a.chunks[1] != b.chunks[0]:
-            msg = (
-                "a.chunks[1] and b.chunks[0] must be equal. "
-                "Use .rechunk method to change the size of chunks."
-            )
-            raise ValueError(msg)
-    else:
-        raise ValueError("b must be 1 or 2 dimensional")
-
-    vchunks = len(a.chunks[1])
-    hchunks = 1 if b.ndim == 1 else len(b.chunks[1])
-    token = tokenize(a, b, lower)
-    name = "solve-triangular-" + token
-
-    # for internal calculation
-    # (name, i, j, k, l) corresponds to a_ij.dot(b_kl)
-    name_mdot = "solve-tri-dot-" + token
-
-    def _b_init(i, j):
-        if b.ndim == 1:
-            return b.name, i
-        else:
-            return b.name, i, j
-
-    def _key(i, j):
-        if b.ndim == 1:
-            return name, i
-        else:
-            return name, i, j
-
-    dsk = {}
-    if lower:
-        for i in range(vchunks):
-            for j in range(hchunks):
-                target = _b_init(i, j)
-                if i > 0:
-                    prevs = []
-                    for k in range(i):
-                        prev = name_mdot, i, k, k, j
-                        dsk[prev] = (np.dot, (a.name, i, k), _key(k, j))
-                        prevs.append(prev)
-                    target = (operator.sub, target, (sum, prevs))
-                dsk[_key(i, j)] = (_solve_triangular_lower, (a.name, i, i), target)
-    else:
-        for i in range(vchunks):
-            for j in range(hchunks):
-                target = _b_init(i, j)
-                if i < vchunks - 1:
-                    prevs = []
-                    for k in range(i + 1, vchunks):
-                        prev = name_mdot, i, k, k, j
-                        dsk[prev] = (np.dot, (a.name, i, k), _key(k, j))
-                        prevs.append(prev)
-                    target = (operator.sub, target, (sum, prevs))
-                dsk[_key(i, j)] = (
-                    scipy.linalg.solve_triangular,
-                    (a.name, i, i),
-                    target,
-                )
-
-    graph = HighLevelGraph.from_collections(name, dsk, dependencies=[a, b])
-    res = _solve_triangular_lower(
-        np.array([[1, 0], [1, 2]], dtype=a.dtype), np.array([0, 1], dtype=b.dtype)
-    )
-    meta = meta_from_array(a, b.ndim, dtype=res.dtype)
-    return Array(graph, name, shape=b.shape, chunks=b.chunks, meta=meta)
-
-
-def solve(a, b, sym_pos=False):
-    """
-    Solve the equation ``a x = b`` for ``x``. By default, use LU
-    decomposition and forward / backward substitutions. When ``sym_pos`` is
-    ``True``, use Cholesky decomposition.
-
-    Parameters
-    ----------
-    a : (M, M) array_like
-        A square matrix.
-    b : (M,) or (M, N) array_like
-        Right-hand side matrix in ``a x = b``.
-    sym_pos : bool
-        Assume a is symmetric and positive definite. If ``True``, use Cholesky
-        decomposition.
-
-    Returns
-    -------
-    x : (M,) or (M, N) Array
-        Solution to the system ``a x = b``.  Shape of the return matches the
-        shape of `b`.
-    """
-    if sym_pos:
-        l, u = _cholesky(a)
-    else:
-        p, l, u = lu(a)
-        b = p.T.dot(b)
-    uy = solve_triangular(l, b, lower=True)
-    return solve_triangular(u, uy)
-
-
-def inv(a):
-    """
-    Compute the inverse of a matrix with LU decomposition and
-    forward / backward substitutions.
-
-    Parameters
-    ----------
-    a : array_like
-        Square matrix to be inverted.
-
-    Returns
-    -------
-    ainv : Array
-        Inverse of the matrix `a`.
-    """
-    return solve(a, eye(a.shape[0], chunks=a.chunks[0][0]))
-
-
-def _cholesky_lower(a):
-    import scipy.linalg
-
-    return scipy.linalg.cholesky(a, lower=True)
-
-
-def cholesky(a, lower=False):
-    """
-    Returns the Cholesky decomposition, :math:`A = L L^*` or
-    :math:`A = U^* U` of a Hermitian positive-definite matrix A.
-
-    Parameters
-    ----------
-    a : (M, M) array_like
-        Matrix to be decomposed
-    lower : bool, optional
-        Whether to compute the upper or lower triangular Cholesky
-        factorization.  Default is upper-triangular.
-
-    Returns
-    -------
-    c : (M, M) Array
-        Upper- or lower-triangular Cholesky factor of `a`.
-    """
-
-    l, u = _cholesky(a)
-    if lower:
-        return l
-    else:
-        return u
-
-
-def _cholesky(a):
-    """
-    Private function to perform Cholesky decomposition, which returns both
-    lower and upper triangulars.
-    """
-    import scipy.linalg
-
-    if a.ndim != 2:
-        raise ValueError("Dimension must be 2 to perform cholesky decomposition")
-
-    xdim, ydim = a.shape
-    if xdim != ydim:
-        raise ValueError(
-            "Input must be a square matrix to perform cholesky decomposition"
-        )
-    if not len(set(a.chunks[0] + a.chunks[1])) == 1:
-        msg = (
-            "All chunks must be a square matrix to perform cholesky decomposition. "
-            "Use .rechunk method to change the size of chunks."
-        )
-        raise ValueError(msg)
-
-    vdim = len(a.chunks[0])
-    hdim = len(a.chunks[1])
-
-    token = tokenize(a)
-    name = "cholesky-" + token
-
-    # (name_lt_dot, i, j, k, l) corresponds to l_ij.dot(l_kl.T)
-    name_lt_dot = "cholesky-lt-dot-" + token
-    # because transposed results are needed for calculation,
-    # we can build graph for upper triangular simultaneously
-    name_upper = "cholesky-upper-" + token
-
-    # calculates lower triangulars because subscriptions get simpler
-    dsk = {}
-    for i in range(vdim):
-        for j in range(hdim):
-            if i < j:
-                dsk[name, i, j] = (np.zeros, (a.chunks[0][i], a.chunks[1][j]))
-                dsk[name_upper, j, i] = (name, i, j)
-            elif i == j:
-                target = (a.name, i, j)
-                if i > 0:
-                    prevs = []
-                    for p in range(i):
-                        prev = name_lt_dot, i, p, i, p
-                        dsk[prev] = (np.dot, (name, i, p), (name_upper, p, i))
-                        prevs.append(prev)
-                    target = (operator.sub, target, (sum, prevs))
-                dsk[name, i, i] = (_cholesky_lower, target)
-                dsk[name_upper, i, i] = (np.transpose, (name, i, i))
-            else:
-                # solving x.dot(L11.T) = (A21 - L20.dot(L10.T)) is equal to
-                # L11.dot(x.T) = A21.T - L10.dot(L20.T)
-                # L11.dot(x.T) = A12 - L10.dot(L02)
-                target = (a.name, j, i)
-                if j > 0:
-                    prevs = []
-                    for p in range(j):
-                        prev = name_lt_dot, j, p, i, p
-                        dsk[prev] = (np.dot, (name, j, p), (name_upper, p, i))
-                        prevs.append(prev)
-                    target = (operator.sub, target, (sum, prevs))
-                dsk[name_upper, j, i] = (_solve_triangular_lower, (name, j, j), target)
-                dsk[name, i, j] = (np.transpose, (name_upper, j, i))
-
-    graph_upper = HighLevelGraph.from_collections(name_upper, dsk, dependencies=[a])
-    graph_lower = HighLevelGraph.from_collections(name, dsk, dependencies=[a])
-    cho = scipy.linalg.cholesky(np.array([[1, 2], [2, 5]], dtype=a.dtype))
-    meta = meta_from_array(a, dtype=cho.dtype)
-
-    lower = Array(graph_lower, name, shape=a.shape, chunks=a.chunks, meta=meta)
-    # do not use .T, because part of transposed blocks are already calculated
-    upper = Array(graph_upper, name_upper, shape=a.shape, chunks=a.chunks, meta=meta)
-    return lower, upper
-
-
-def _sort_decreasing(x):
-    x[::-1].sort()
-    return x
-
-
-def lstsq(a, b):
-    """
-    Return the least-squares solution to a linear matrix equation using
-    QR decomposition.
-
-    Solves the equation `a x = b` by computing a vector `x` that
-    minimizes the Euclidean 2-norm `|| b - a x ||^2`.  The equation may
-    be under-, well-, or over- determined (i.e., the number of
-    linearly independent rows of `a` can be less than, equal to, or
-    greater than its number of linearly independent columns).  If `a`
-    is square and of full rank, then `x` (but for round-off error) is
-    the "exact" solution of the equation.
-
-    Parameters
-    ----------
-    a : (M, N) array_like
-        "Coefficient" matrix.
-    b : (M,) array_like
-        Ordinate or "dependent variable" values.
-
-    Returns
-    -------
-    x : (N,) Array
-        Least-squares solution. If `b` is two-dimensional,
-        the solutions are in the `K` columns of `x`.
-    residuals : (1,) Array
-        Sums of residuals; squared Euclidean 2-norm for each column in
-        ``b - a*x``.
-    rank : Array
-        Rank of matrix `a`.
-    s : (min(M, N),) Array
-        Singular values of `a`.
-    """
-    q, r = qr(a)
-    x = solve_triangular(r, q.T.dot(b))
-    residuals = b - a.dot(x)
-    residuals = (residuals ** 2).sum(keepdims=True)
-
-    token = tokenize(a, b)
-
-    # r must be a triangular with single block
-
-    # rank
-    rname = "lstsq-rank-" + token
-    rdsk = {(rname,): (np.linalg.matrix_rank, (r.name, 0, 0))}
-    graph = HighLevelGraph.from_collections(rname, rdsk, dependencies=[r])
-    # rank must be an integer
-    rank = Array(graph, rname, shape=(), chunks=(), dtype=int)
-
-    # singular
-    sname = "lstsq-singular-" + token
-    rt = r.T
-    sdsk = {
-        (sname, 0): (
-            _sort_decreasing,
-            (np.sqrt, (np.linalg.eigvals, (np.dot, (rt.name, 0, 0), (r.name, 0, 0)))),
-        )
-    }
-    graph = HighLevelGraph.from_collections(sname, sdsk, dependencies=[rt])
-    _, _, _, ss = np.linalg.lstsq(
-        np.array([[1, 0], [1, 2]], dtype=a.dtype),
-        np.array([0, 1], dtype=b.dtype),
-        rcond=-1,
-    )
-    meta = meta_from_array(r, 1, dtype=ss.dtype)
-    s = Array(graph, sname, shape=(r.shape[0],), chunks=r.shape[0], meta=meta)
-
-    return x, residuals, rank, s
-
-
-@derived_from(np.linalg)
-def norm(x, ord=None, axis=None, keepdims=False):
-    if axis is None:
-        axis = tuple(range(x.ndim))
-    elif isinstance(axis, Number):
-        axis = (int(axis),)
-    else:
-        axis = tuple(axis)
-
-    if len(axis) > 2:
-        raise ValueError("Improper number of dimensions to norm.")
-
-    if ord == "fro":
-        ord = None
-        if len(axis) == 1:
-            raise ValueError("Invalid norm order for vectors.")
-
-    # Coerce to double precision.
-    r = x.astype(np.promote_types(x.dtype, float))
-
-    if ord is None:
-        r = (abs(r) ** 2).sum(axis=axis, keepdims=keepdims) ** 0.5
-    elif ord == "nuc":
-        if len(axis) == 1:
-            raise ValueError("Invalid norm order for vectors.")
-        if x.ndim > 2:
-            raise NotImplementedError("SVD based norm not implemented for ndim > 2")
-
-        r = svd(x)[1][None].sum(keepdims=keepdims)
-    elif ord == np.inf:
-        r = abs(r)
-        if len(axis) == 1:
-            r = r.max(axis=axis, keepdims=keepdims)
-        else:
-            r = r.sum(axis=axis[1], keepdims=True).max(axis=axis[0], keepdims=True)
-            if keepdims is False:
-                r = r.squeeze(axis=axis)
-    elif ord == -np.inf:
-        r = abs(r)
-        if len(axis) == 1:
-            r = r.min(axis=axis, keepdims=keepdims)
-        else:
-            r = r.sum(axis=axis[1], keepdims=True).min(axis=axis[0], keepdims=True)
-            if keepdims is False:
-                r = r.squeeze(axis=axis)
-    elif ord == 0:
-        if len(axis) == 2:
-            raise ValueError("Invalid norm order for matrices.")
-
-        r = (r != 0).astype(r.dtype).sum(axis=axis, keepdims=keepdims)
-    elif ord == 1:
-        r = abs(r)
-        if len(axis) == 1:
-            r = r.sum(axis=axis, keepdims=keepdims)
-        else:
-            r = r.sum(axis=axis[0], keepdims=True).max(axis=axis[1], keepdims=True)
-            if keepdims is False:
-                r = r.squeeze(axis=axis)
-    elif len(axis) == 2 and ord == -1:
-        r = abs(r).sum(axis=axis[0], keepdims=True).min(axis=axis[1], keepdims=True)
-        if keepdims is False:
-            r = r.squeeze(axis=axis)
-    elif len(axis) == 2 and ord == 2:
-        if x.ndim > 2:
-            raise NotImplementedError("SVD based norm not implemented for ndim > 2")
-        r = svd(x)[1][None].max(keepdims=keepdims)
-    elif len(axis) == 2 and ord == -2:
-        if x.ndim > 2:
-            raise NotImplementedError("SVD based norm not implemented for ndim > 2")
-        r = svd(x)[1][None].min(keepdims=keepdims)
-    else:
-        if len(axis) == 2:
-            raise ValueError("Invalid norm order for matrices.")
-
-        r = (abs(r) ** ord).sum(axis=axis, keepdims=keepdims) ** (1.0 / ord)
-
-    return r
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/ma.py b/Flaskserver/venv/Lib/site-packages/dask/array/ma.py
deleted file mode 100644
index 38b971e3e8ab5a99325c4a895e7525a6b501a47f..0000000000000000000000000000000000000000
--- a/Flaskserver/venv/Lib/site-packages/dask/array/ma.py
+++ /dev/null
@@ -1,261 +0,0 @@
-from functools import wraps
-
-import numpy as np
-
-from ..base import normalize_token
-from .core import (
-    concatenate_lookup,
-    tensordot_lookup,
-    map_blocks,
-    asanyarray,
-    blockwise,
-)
-from .routines import _average
-from ..utils import derived_from
-
-
-@normalize_token.register(np.ma.masked_array)
-def normalize_masked_array(x):
-    data = normalize_token(x.data)
-    mask = normalize_token(x.mask)
-    fill_value = normalize_token(x.fill_value)
-    return (data, mask, fill_value)
-
-
-@concatenate_lookup.register(np.ma.masked_array)
-def _concatenate(arrays, axis=0):
-    out = np.ma.concatenate(arrays, axis=axis)
-    fill_values = [i.fill_value for i in arrays if hasattr(i, "fill_value")]
-    if any(isinstance(f, np.ndarray) for f in fill_values):
-        raise ValueError(
-            "Dask doesn't support masked array's with non-scalar `fill_value`s"
-        )
-    if fill_values:
-        # If all the fill_values are the same copy over the fill value
-        fill_values = np.unique(fill_values)
-        if len(fill_values) == 1:
-            out.fill_value = fill_values[0]
-    return out
-
-
-@tensordot_lookup.register(np.ma.masked_array)
-def _tensordot(a, b, axes=2):
-    # Much of this is stolen from numpy/core/numeric.py::tensordot
-    # Please see license at https://github.com/numpy/numpy/blob/master/LICENSE.txt
-    try:
-        iter(axes)
-    except TypeError:
-        axes_a = list(range(-axes, 0))
-        axes_b = list(range(0, axes))
-    else:
-        axes_a, axes_b = axes
-    try:
-        na = len(axes_a)
-        axes_a = list(axes_a)
-    except TypeError:
-        axes_a = [axes_a]
-        na = 1
-    try:
-        nb = len(axes_b)
-        axes_b = list(axes_b)
-    except TypeError:
-        axes_b = [axes_b]
-        nb = 1
-
-    # a, b = asarray(a), asarray(b)  # <--- modified
-    as_ = a.shape
-    nda = a.ndim
-    bs = b.shape
-    ndb = b.ndim
-    equal = True
-    if na != nb:
-        equal = False
-    else:
-        for k in range(na):
-            if as_[axes_a[k]] != bs[axes_b[k]]:
-                equal = False
-                break
-            if axes_a[k] < 0:
-                axes_a[k] += nda
-            if axes_b[k] < 0:
-                axes_b[k] += ndb
-    if not equal:
-        raise ValueError("shape-mismatch for sum")
-
-    # Move the axes to sum over to the end of "a"
-    # and to the front of "b"
-    notin = [k for k in range(nda) if k not in axes_a]
-    newaxes_a = notin + axes_a
-    N2 = 1
-    for axis in axes_a:
-        N2 *= as_[axis]
-    newshape_a = (-1, N2)
-    olda = [as_[axis] for axis in notin]
-
-    notin = [k for k in range(ndb) if k not in axes_b]
-    newaxes_b = axes_b + notin
-    N2 = 1
-    for axis in axes_b:
-        N2 *= bs[axis]
-    newshape_b = (N2, -1)
-    oldb = [bs[axis] for axis in notin]
-
-    at = a.transpose(newaxes_a).reshape(newshape_a)
-    bt = b.transpose(newaxes_b).reshape(newshape_b)
-    res = np.ma.dot(at, bt)
-    return res.reshape(olda + oldb)
-
-
-@derived_from(np.ma)
-def filled(a, fill_value=None):
-    a = asanyarray(a)
-    return a.map_blocks(np.ma.filled, fill_value=fill_value)
-
-
-def _wrap_masked(f):
-    @wraps(f)
-    def _(a, value):
-        a = asanyarray(a)
-        value = asanyarray(value)
-        ainds = tuple(range(a.ndim))[::-1]
-        vinds = tuple(range(value.ndim))[::-1]
-        oinds = max(ainds, vinds, key=len)
-        return blockwise(f, oinds, a, ainds, value, vinds, dtype=a.dtype)
-
-    return _
-
-
-masked_greater = _wrap_masked(np.ma.masked_greater)
-masked_greater_equal = _wrap_masked(np.ma.masked_greater_equal)
-masked_less = _wrap_masked(np.ma.masked_less)
-masked_less_equal = _wrap_masked(np.ma.masked_less_equal)
-masked_not_equal = _wrap_masked(np.ma.masked_not_equal)
-
-
-@derived_from(np.ma)
-def masked_equal(a, value):
-    a = asanyarray(a)
-    if getattr(value, "shape", ()):
-        raise ValueError("da.ma.masked_equal doesn't support array `value`s")
-    inds = tuple(range(a.ndim))
-    return blockwise(np.ma.masked_equal, inds, a, inds, value, (), dtype=a.dtype)
-
-
-@derived_from(np.ma)
-def masked_invalid(a):
-    return asanyarray(a).map_blocks(np.ma.masked_invalid)
-
-
-@derived_from(np.ma)
-def masked_inside(x, v1, v2):
-    x = asanyarray(x)
-    return x.map_blocks(np.ma.masked_inside, v1, v2)
-
-
-@derived_from(np.ma)
-def masked_outside(x, v1, v2):
-    x = asanyarray(x)
-    return x.map_blocks(np.ma.masked_outside, v1, v2)
-
-
-@derived_from(np.ma)
-def masked_where(condition, a):
-    cshape = getattr(condition, "shape", ())
-    if cshape and cshape != a.shape:
-        raise IndexError(
-            "Inconsistant shape between the condition and the "
-            "input (got %s and %s)" % (cshape, a.shape)
-        )
-    condition = asanyarray(condition)
-    a = asanyarray(a)
-    ainds = tuple(range(a.ndim))
-    cinds = tuple(range(condition.ndim))
-    return blockwise(
-        np.ma.masked_where, ainds, condition, cinds, a, ainds, dtype=a.dtype
-    )
-
-
-@derived_from(np.ma)
-def masked_values(x, value, rtol=1e-05, atol=1e-08, shrink=True):
-    x = asanyarray(x)
-    if getattr(value, "shape", ()):
-        raise ValueError("da.ma.masked_values doesn't support array `value`s")
-    return map_blocks(
-        np.ma.masked_values, x, value, rtol=rtol, atol=atol, shrink=shrink
-    )
-
-
-@derived_from(np.ma)
-def fix_invalid(a, fill_value=None):
-    a = asanyarray(a)
-    return a.map_blocks(np.ma.fix_invalid, fill_value=fill_value)
-
-
-@derived_from(np.ma)
-def getdata(a):
-    a = asanyarray(a)
-    return a.map_blocks(np.ma.getdata)
-
-
-@derived_from(np.ma)
-def getmaskarray(a):
-    a = asanyarray(a)
-    return a.map_blocks(np.ma.getmaskarray)
-
-
-def _masked_array(data, mask=np.ma.nomask, **kwargs):
-    dtype = kwargs.pop("masked_dtype", None)
-    return np.ma.masked_array(data, mask=mask, dtype=dtype, **kwargs)
-
-
-@derived_from(np.ma)
-def masked_array(data, mask=np.ma.nomask, fill_value=None, **kwargs):
-    data = asanyarray(data)
-    inds = tuple(range(data.ndim))
-    arginds = [inds, data, inds]
-
-    if getattr(fill_value, "shape", ()):
-        raise ValueError("non-scalar fill_value not supported")
-    kwargs["fill_value"] = fill_value
-
-    if mask is not np.ma.nomask:
-        mask = asanyarray(mask)
-        if mask.size == 1:
-            mask = mask.reshape((1,) * data.ndim)
-        elif data.shape != mask.shape:
-            raise np.ma.MaskError(
-                "Mask and data not compatible: data shape "
-                "is %s, and mask shape is "
-                "%s." % (repr(data.shape), repr(mask.shape))
-            )
-        arginds.extend([mask, inds])
-
-    if "dtype" in kwargs:
-        kwargs["masked_dtype"] = kwargs["dtype"]
-    else:
-        kwargs["dtype"] = data.dtype
-
-    return blockwise(_masked_array, *arginds, **kwargs)
-
-
-def _set_fill_value(x, fill_value):
-    if isinstance(x, np.ma.masked_array):
-        x = x.copy()
-        np.ma.set_fill_value(x, fill_value=fill_value)
-    return x
-
-
-@derived_from(np.ma)
-def set_fill_value(a, fill_value):
-    a = asanyarray(a)
-    if getattr(fill_value, "shape", ()):
-        raise ValueError("da.ma.set_fill_value doesn't support array `value`s")
-    fill_value = np.ma.core._check_fill_value(fill_value, a.dtype)
-    res = a.map_blocks(_set_fill_value, fill_value)
-    a.dask = res.dask
-    a.name = res.name
-
-
-@derived_from(np.ma)
-def average(a, axis=None, weights=None, returned=False):
-    return _average(a, axis, weights, returned, is_masked=True)
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/numpy_compat.py b/Flaskserver/venv/Lib/site-packages/dask/array/numpy_compat.py
deleted file mode 100644
index ed132e7f53dd43b59d6a53e0ac330660723e0ac3..0000000000000000000000000000000000000000
--- a/Flaskserver/venv/Lib/site-packages/dask/array/numpy_compat.py
+++ /dev/null
@@ -1,338 +0,0 @@
-from distutils.version import LooseVersion
-
-import numpy as np
-import warnings
-
-from ..utils import derived_from
-
-_numpy_115 = LooseVersion(np.__version__) >= "1.15.0"
-_numpy_116 = LooseVersion(np.__version__) >= "1.16.0"
-_numpy_117 = LooseVersion(np.__version__) >= "1.17.0"
-_numpy_118 = LooseVersion(np.__version__) >= "1.18.0"
-_numpy_120 = LooseVersion(np.__version__) >= "1.20.0"
-
-
-# Taken from scikit-learn:
-# https://github.com/scikit-learn/scikit-learn/blob/master/sklearn/utils/fixes.py#L84
-try:
-    with warnings.catch_warnings():
-        if (
-            not np.allclose(
-                np.divide(0.4, 1, casting="unsafe"),
-                np.divide(0.4, 1, casting="unsafe", dtype=float),
-            )
-            or not np.allclose(np.divide(1, 0.5, dtype="i8"), 2)
-            or not np.allclose(np.divide(0.4, 1), 0.4)
-        ):
-            raise TypeError(
-                "Divide not working with dtype: "
-                "https://github.com/numpy/numpy/issues/3484"
-            )
-        divide = np.divide
-        ma_divide = np.ma.divide
-
-except TypeError:
-    # Divide with dtype doesn't work on Python 3
-    def divide(x1, x2, out=None, dtype=None):
-        """Implementation of numpy.divide that works with dtype kwarg.
-
-        Temporary compatibility fix for a bug in numpy's version. See
-        https://github.com/numpy/numpy/issues/3484 for the relevant issue."""
-        x = np.divide(x1, x2, out)
-        if dtype is not None:
-            x = x.astype(dtype)
-        return x
-
-    ma_divide = np.ma.core._DomainedBinaryOperation(
-        divide, np.ma.core._DomainSafeDivide(), 0, 1
-    )
-
-
-if LooseVersion(np.__version__) < "1.15.0":
-    # These functions were added in numpy 1.15.0. For previous versions they
-    # are duplicated here
-
-    def _make_along_axis_idx(arr_shape, indices, axis):
-        # compute dimensions to iterate over
-        if not np.issubdtype(indices.dtype, np.integer):
-            raise IndexError("`indices` must be an integer array")
-        if len(arr_shape) != indices.ndim:
-            raise ValueError(
-                "`indices` and `arr` must have the same number of dimensions"
-            )
-        shape_ones = (1,) * indices.ndim
-        dest_dims = list(range(axis)) + [None] + list(range(axis + 1, indices.ndim))
-
-        # build a fancy index, consisting of orthogonal aranges, with the
-        # requested index inserted at the right location
-        fancy_index = []
-        for dim, n in zip(dest_dims, arr_shape):
-            if dim is None:
-                fancy_index.append(indices)
-            else:
-                ind_shape = shape_ones[:dim] + (-1,) + shape_ones[dim + 1 :]
-                fancy_index.append(np.arange(n).reshape(ind_shape))
-
-        return tuple(fancy_index)
-
-    def take_along_axis(arr, indices, axis):
-        """
-        Take values from the input array by matching 1d index and data slices.
-        This iterates over matching 1d slices oriented along the specified axis in
-        the index and data arrays, and uses the former to look up values in the
-        latter. These slices can be different lengths.
-        Functions returning an index along an axis, like `argsort` and
-        `argpartition`, produce suitable indices for this function.
-        .. versionadded:: 1.15.0
-        Parameters
-        ----------
-        arr: ndarray (Ni..., M, Nk...)
-            Source array
-        indices: ndarray (Ni..., J, Nk...)
-            Indices to take along each 1d slice of `arr`. This must match the
-            dimension of arr, but dimensions Ni and Nj only need to broadcast
-            against `arr`.
-        axis: int
-            The axis to take 1d slices along. If axis is None, the input array is
-            treated as if it had first been flattened to 1d, for consistency with
-            `sort` and `argsort`.
-        Returns
-        -------
-        out: ndarray (Ni..., J, Nk...)
-            The indexed result.
-        Notes
-        -----
-        This is equivalent to (but faster than) the following use of `ndindex` and
-        `s_`, which sets each of ``ii`` and ``kk`` to a tuple of indices::
-            Ni, M, Nk = a.shape[:axis], a.shape[axis], a.shape[axis+1:]
-            J = indices.shape[axis]  # Need not equal M
-            out = np.empty(Nk + (J,) + Nk)
-            for ii in ndindex(Ni):
-                for kk in ndindex(Nk):
-                    a_1d       = a      [ii + s_[:,] + kk]
-                    indices_1d = indices[ii + s_[:,] + kk]
-                    out_1d     = out    [ii + s_[:,] + kk]
-                    for j in range(J):
-                        out_1d[j] = a_1d[indices_1d[j]]
-        Equivalently, eliminating the inner loop, the last two lines would be::
-                    out_1d[:] = a_1d[indices_1d]
-        See Also
-        --------
-        take : Take along an axis, using the same indices for every 1d slice
-        put_along_axis :
-            Put values into the destination array by matching 1d index and data slices
-        Examples
-        --------
-        For this sample array
-        >>> a = np.array([[10, 30, 20], [60, 40, 50]])
-
-        We can sort either by using sort directly, or argsort and this function
-        >>> np.sort(a, axis=1)
-        array([[10, 20, 30],
-               [40, 50, 60]])
-        >>> ai = np.argsort(a, axis=1); ai
-        array([[0, 2, 1],
-               [1, 2, 0]])
-        >>> take_along_axis(a, ai, axis=1)
-        array([[10, 20, 30],
-               [40, 50, 60]])
-
-        The same works for max and min, if you expand the dimensions:
-        >>> np.expand_dims(np.max(a, axis=1), axis=1)
-        array([[30],
-               [60]])
-        >>> ai = np.expand_dims(np.argmax(a, axis=1), axis=1)
-        >>> ai
-        array([[1],
-               [0]])
-        >>> take_along_axis(a, ai, axis=1)
-        array([[30],
-               [60]])
-
-        If we want to get the max and min at the same time,
-        we can stack the indices first:
-        >>> ai_min = np.expand_dims(np.argmin(a, axis=1), axis=1)
-        >>> ai_max = np.expand_dims(np.argmax(a, axis=1), axis=1)
-        >>> ai = np.concatenate([ai_min, ai_max], axis=1)
-        >>> ai
-        array([[0, 1],
-               [1, 0]])
-        >>> take_along_axis(a, ai, axis=1)
-        array([[10, 30],
-               [40, 60]])
-        """
-        # normalize inputs
-        if axis is None:
-            arr = arr.flat
-            arr_shape = (len(arr),)  # flatiter has no .shape
-            axis = 0
-        else:
-            if axis < 0:
-                axis = arr.ndim + axis
-            arr_shape = arr.shape
-
-        # use the fancy index
-        return arr[_make_along_axis_idx(arr_shape, indices, axis)]
-
-
-def _make_sliced_dtype_np_ge_16(dtype, index):
-    # This was briefly added in 1.14.0
-    # https://github.com/numpy/numpy/pull/6053, NumPy >= 1.14
-    # which was then reverted in 1.14.1 with
-    # https://github.com/numpy/numpy/pull/10411
-    # And then was finally released with
-    # https://github.com/numpy/numpy/pull/12447
-    # in version 1.16.0
-    new = {
-        "names": index,
-        "formats": [dtype.fields[name][0] for name in index],
-        "offsets": [dtype.fields[name][1] for name in index],
-        "itemsize": dtype.itemsize,
-    }
-    return np.dtype(new)
-
-
-def _make_sliced_dtype_np_lt_14(dtype, index):
-    # For numpy < 1.14
-    dt = np.dtype([(name, dtype[name]) for name in index])
-    return dt
-
-
-if LooseVersion(np.__version__) >= LooseVersion("1.16.0") or LooseVersion(
-    np.__version__
-) == LooseVersion("1.14.0"):
-    _make_sliced_dtype = _make_sliced_dtype_np_ge_16
-else:
-    _make_sliced_dtype = _make_sliced_dtype_np_lt_14
-
-
-class _Recurser(object):
-    """
-    Utility class for recursing over nested iterables
-    """
-
-    # This was copied almost verbatim from numpy.core.shape_base._Recurser
-    # See numpy license at https://github.com/numpy/numpy/blob/master/LICENSE.txt
-    # or NUMPY_LICENSE.txt within this directory
-
-    def __init__(self, recurse_if):
-        self.recurse_if = recurse_if
-
-    def map_reduce(
-        self,
-        x,
-        f_map=lambda x, **kwargs: x,
-        f_reduce=lambda x, **kwargs: x,
-        f_kwargs=lambda **kwargs: kwargs,
-        **kwargs
-    ):
-        """
-        Iterate over the nested list, applying:
-        * ``f_map`` (T -> U) to items
-        * ``f_reduce`` (Iterable[U] -> U) to mapped items
-
-        For instance, ``map_reduce([[1, 2], 3, 4])`` is::
-
-            f_reduce([
-              f_reduce([
-                f_map(1),
-                f_map(2)
-              ]),
-              f_map(3),
-              f_map(4)
-            ]])
-
-
-        State can be passed down through the calls with `f_kwargs`,
-        to iterables of mapped items. When kwargs are passed, as in
-        ``map_reduce([[1, 2], 3, 4], **kw)``, this becomes::
-
-            kw1 = f_kwargs(**kw)
-            kw2 = f_kwargs(**kw1)
-            f_reduce([
-              f_reduce([
-                f_map(1), **kw2)
-                f_map(2,  **kw2)
-              ],      **kw1),
-              f_map(3, **kw1),
-              f_map(4, **kw1)
-            ]],     **kw)
-        """
-
-        def f(x, **kwargs):
-            if not self.recurse_if(x):
-                return f_map(x, **kwargs)
-            else:
-                next_kwargs = f_kwargs(**kwargs)
-                return f_reduce((f(xi, **next_kwargs) for xi in x), **kwargs)
-
-        return f(x, **kwargs)
-
-    def walk(self, x, index=()):
-        """
-        Iterate over x, yielding (index, value, entering), where
-
-        * ``index``: a tuple of indices up to this point
-        * ``value``: equal to ``x[index[0]][...][index[-1]]``. On the first iteration, is
-                     ``x`` itself
-        * ``entering``: bool. The result of ``recurse_if(value)``
-        """
-        do_recurse = self.recurse_if(x)
-        yield index, x, do_recurse
-
-        if not do_recurse:
-            return
-        for i, xi in enumerate(x):
-            # yield from ...
-            for v in self.walk(xi, index + (i,)):
-                yield v
-
-
-if _numpy_116:
-    _unravel_index_keyword = "shape"
-else:
-    _unravel_index_keyword = "dims"
-
-
-# Implementation taken directly from numpy:
-# https://github.com/numpy/numpy/blob/d9b1e32cb8ef90d6b4a47853241db2a28146a57d/numpy/core/numeric.py#L1336-L1405
-@derived_from(np)
-def moveaxis(a, source, destination):
-    source = np.core.numeric.normalize_axis_tuple(source, a.ndim, "source")
-    destination = np.core.numeric.normalize_axis_tuple(
-        destination, a.ndim, "destination"
-    )
-    if len(source) != len(destination):
-        raise ValueError(
-            "`source` and `destination` arguments must have "
-            "the same number of elements"
-        )
-
-    order = [n for n in range(a.ndim) if n not in source]
-
-    for dest, src in sorted(zip(destination, source)):
-        order.insert(dest, src)
-
-    result = a.transpose(order)
-    return result
-
-
-# Implementation adapted directly from numpy:
-# https://github.com/numpy/numpy/blob/v1.17.0/numpy/core/numeric.py#L1107-L1204
-def rollaxis(a, axis, start=0):
-    n = a.ndim
-    axis = np.core.numeric.normalize_axis_index(axis, n)
-    if start < 0:
-        start += n
-    msg = "'%s' arg requires %d <= %s < %d, but %d was passed in"
-    if not (0 <= start < n + 1):
-        raise ValueError(msg % ("start", -n, "start", n + 1, start))
-    if axis < start:
-        # it's been removed
-        start -= 1
-    if axis == start:
-        return a[...]
-    axes = list(range(0, n))
-    axes.remove(axis)
-    axes.insert(start, axis)
-    return a.transpose(axes)
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/optimization.py b/Flaskserver/venv/Lib/site-packages/dask/array/optimization.py
deleted file mode 100644
index a6ae0b985fe0653d1f9e267cc3ef9e06a804da2b..0000000000000000000000000000000000000000
--- a/Flaskserver/venv/Lib/site-packages/dask/array/optimization.py
+++ /dev/null
@@ -1,327 +0,0 @@
-from itertools import zip_longest
-from operator import getitem
-
-import numpy as np
-
-from .core import getter, getter_nofancy, getter_inline
-from ..blockwise import optimize_blockwise, fuse_roots
-from ..core import flatten, reverse_dict
-from ..optimization import cull, fuse, inline_functions
-from ..utils import ensure_dict
-from ..highlevelgraph import HighLevelGraph
-
-from numbers import Integral
-
-# All get* functions the optimizations know about
-GETTERS = (getter, getter_nofancy, getter_inline, getitem)
-# These get* functions aren't ever completely removed from the graph,
-# even if the index should be a no-op by numpy semantics. Some array-like's
-# don't completely follow semantics, making indexing always necessary.
-GETNOREMOVE = (getter, getter_nofancy)
-
-
-def optimize(
-    dsk,
-    keys,
-    fuse_keys=None,
-    fast_functions=None,
-    inline_functions_fast_functions=(getter_inline,),
-    rename_fused_keys=True,
-    **kwargs
-):
-    """Optimize dask for array computation
-
-    1.  Cull tasks not necessary to evaluate keys
-    2.  Remove full slicing, e.g. x[:]
-    3.  Inline fast functions like getitem and np.transpose
-    """
-    keys = list(flatten(keys))
-
-    # High level stage optimization
-    if isinstance(dsk, HighLevelGraph):
-        dsk = optimize_blockwise(dsk, keys=keys)
-        dsk = fuse_roots(dsk, keys=keys)
-
-    # Low level task optimizations
-    dsk = ensure_dict(dsk)
-    if fast_functions is not None:
-        inline_functions_fast_functions = fast_functions
-
-    dsk2, dependencies = cull(dsk, keys)
-    hold = hold_keys(dsk2, dependencies)
-
-    dsk3, dependencies = fuse(
-        dsk2,
-        hold + keys + (fuse_keys or []),
-        dependencies,
-        rename_keys=rename_fused_keys,
-    )
-    if inline_functions_fast_functions:
-        dsk4 = inline_functions(
-            dsk3,
-            keys,
-            dependencies=dependencies,
-            fast_functions=inline_functions_fast_functions,
-        )
-    else:
-        dsk4 = dsk3
-    dsk5 = optimize_slices(dsk4)
-
-    return dsk5
-
-
-def hold_keys(dsk, dependencies):
-    """Find keys to avoid fusion
-
-    We don't want to fuse data present in the graph because it is easier to
-    serialize as a raw value.
-
-    We don't want to fuse chains after getitem/GETTERS because we want to
-    move around only small pieces of data, rather than the underlying arrays.
-    """
-    dependents = reverse_dict(dependencies)
-    data = {k for k, v in dsk.items() if type(v) not in (tuple, str)}
-
-    hold_keys = list(data)
-    for dat in data:
-        deps = dependents[dat]
-        for dep in deps:
-            task = dsk[dep]
-            # If the task is a get* function, we walk up the chain, and stop
-            # when there's either more than one dependent, or the dependent is
-            # no longer a get* function or an alias. We then add the final
-            # key to the list of keys not to fuse.
-            if type(task) is tuple and task and task[0] in GETTERS:
-                try:
-                    while len(dependents[dep]) == 1:
-                        new_dep = next(iter(dependents[dep]))
-                        new_task = dsk[new_dep]
-                        # If the task is a get* or an alias, continue up the
-                        # linear chain
-                        if new_task[0] in GETTERS or new_task in dsk:
-                            dep = new_dep
-                        else:
-                            break
-                except (IndexError, TypeError):
-                    pass
-                hold_keys.append(dep)
-    return hold_keys
-
-
-def optimize_slices(dsk):
-    """Optimize slices
-
-    1.  Fuse repeated slices, like x[5:][2:6] -> x[7:11]
-    2.  Remove full slices, like         x[:] -> x
-
-    See also:
-        fuse_slice_dict
-    """
-    fancy_ind_types = (list, np.ndarray)
-    dsk = dsk.copy()
-    for k, v in dsk.items():
-        if type(v) is tuple and v[0] in GETTERS and len(v) in (3, 5):
-            if len(v) == 3:
-                get, a, a_index = v
-                # getter defaults to asarray=True, getitem is semantically False
-                a_asarray = get is not getitem
-                a_lock = None
-            else:
-                get, a, a_index, a_asarray, a_lock = v
-            while type(a) is tuple and a[0] in GETTERS and len(a) in (3, 5):
-                if len(a) == 3:
-                    f2, b, b_index = a
-                    b_asarray = f2 is not getitem
-                    b_lock = None
-                else:
-                    f2, b, b_index, b_asarray, b_lock = a
-
-                if a_lock and a_lock is not b_lock:
-                    break
-                if (type(a_index) is tuple) != (type(b_index) is tuple):
-                    break
-                if type(a_index) is tuple:
-                    indices = b_index + a_index
-                    if len(a_index) != len(b_index) and any(i is None for i in indices):
-                        break
-                    if f2 is getter_nofancy and any(
-                        isinstance(i, fancy_ind_types) for i in indices
-                    ):
-                        break
-                elif f2 is getter_nofancy and (
-                    type(a_index) in fancy_ind_types or type(b_index) in fancy_ind_types
-                ):
-                    break
-                try:
-                    c_index = fuse_slice(b_index, a_index)
-                    # rely on fact that nested gets never decrease in
-                    # strictness e.g. `(getter_nofancy, (getter, ...))` never
-                    # happens
-                    get = getter if f2 is getter_inline else f2
-                except NotImplementedError:
-                    break
-                a, a_index, a_lock = b, c_index, b_lock
-                a_asarray |= b_asarray
-
-            # Skip the get call if not from from_array and nothing to do
-            if get not in GETNOREMOVE and (
-                (
-                    type(a_index) is slice
-                    and not a_index.start
-                    and a_index.stop is None
-                    and a_index.step is None
-                )
-                or (
-                    type(a_index) is tuple
-                    and all(
-                        type(s) is slice
-                        and not s.start
-                        and s.stop is None
-                        and s.step is None
-                        for s in a_index
-                    )
-                )
-            ):
-                dsk[k] = a
-            elif get is getitem or (a_asarray and not a_lock):
-                # default settings are fine, drop the extra parameters Since we
-                # always fallback to inner `get` functions, `get is getitem`
-                # can only occur if all gets are getitem, meaning all
-                # parameters must be getitem defaults.
-                dsk[k] = (get, a, a_index)
-            else:
-                dsk[k] = (get, a, a_index, a_asarray, a_lock)
-
-    return dsk
-
-
-def normalize_slice(s):
-    """Replace Nones in slices with integers
-
-    >>> normalize_slice(slice(None, None, None))
-    slice(0, None, 1)
-    """
-    start, stop, step = s.start, s.stop, s.step
-    if start is None:
-        start = 0
-    if step is None:
-        step = 1
-    if start < 0 or step < 0 or stop is not None and stop < 0:
-        raise NotImplementedError()
-    return slice(start, stop, step)
-
-
-def check_for_nonfusible_fancy_indexing(fancy, normal):
-    # Check for fancy indexing and normal indexing, where the fancy
-    # indexed dimensions != normal indexed dimensions with integers. E.g.:
-    # disallow things like:
-    # x[:, [1, 2], :][0, :, :] -> x[0, [1, 2], :] or
-    # x[0, :, :][:, [1, 2], :] -> x[0, [1, 2], :]
-    for f, n in zip_longest(fancy, normal, fillvalue=slice(None)):
-        if type(f) is not list and isinstance(n, Integral):
-            raise NotImplementedError(
-                "Can't handle normal indexing with "
-                "integers and fancy indexing if the "
-                "integers and fancy indices don't "
-                "align with the same dimensions."
-            )
-
-
-def fuse_slice(a, b):
-    """Fuse stacked slices together
-
-    Fuse a pair of repeated slices into a single slice:
-
-    >>> fuse_slice(slice(1000, 2000), slice(10, 15))
-    slice(1010, 1015, None)
-
-    This also works for tuples of slices
-
-    >>> fuse_slice((slice(100, 200), slice(100, 200, 10)),
-    ...            (slice(10, 15), [5, 2]))
-    (slice(110, 115, None), [150, 120])
-
-    And a variety of other interesting cases
-
-    >>> fuse_slice(slice(1000, 2000), 10)  # integers
-    1010
-
-    >>> fuse_slice(slice(1000, 2000, 5), slice(10, 20, 2))
-    slice(1050, 1100, 10)
-
-    >>> fuse_slice(slice(1000, 2000, 5), [1, 2, 3])  # lists
-    [1005, 1010, 1015]
-
-    >>> fuse_slice(None, slice(None, None))  # doctest: +SKIP
-    None
-    """
-    # None only works if the second side is a full slice
-    if a is None and isinstance(b, slice) and b == slice(None, None):
-        return None
-
-    # Replace None with 0 and one in start and step
-    if isinstance(a, slice):
-        a = normalize_slice(a)
-    if isinstance(b, slice):
-        b = normalize_slice(b)
-
-    if isinstance(a, slice) and isinstance(b, Integral):
-        if b < 0:
-            raise NotImplementedError()
-        return a.start + b * a.step
-
-    if isinstance(a, slice) and isinstance(b, slice):
-        start = a.start + a.step * b.start
-        if b.stop is not None:
-            stop = a.start + a.step * b.stop
-        else:
-            stop = None
-        if a.stop is not None:
-            if stop is not None:
-                stop = min(a.stop, stop)
-            else:
-                stop = a.stop
-        step = a.step * b.step
-        if step == 1:
-            step = None
-        return slice(start, stop, step)
-
-    if isinstance(b, list):
-        return [fuse_slice(a, bb) for bb in b]
-    if isinstance(a, list) and isinstance(b, (Integral, slice)):
-        return a[b]
-
-    if isinstance(a, tuple) and not isinstance(b, tuple):
-        b = (b,)
-
-    # If given two tuples walk through both, being mindful of uneven sizes
-    # and newaxes
-    if isinstance(a, tuple) and isinstance(b, tuple):
-
-        # Check for non-fusible cases with fancy-indexing
-        a_has_lists = any(isinstance(item, list) for item in a)
-        b_has_lists = any(isinstance(item, list) for item in b)
-        if a_has_lists and b_has_lists:
-            raise NotImplementedError("Can't handle multiple list indexing")
-        elif a_has_lists:
-            check_for_nonfusible_fancy_indexing(a, b)
-        elif b_has_lists:
-            check_for_nonfusible_fancy_indexing(b, a)
-
-        j = 0
-        result = list()
-        for i in range(len(a)):
-            #  axis ceased to exist  or we're out of b
-            if isinstance(a[i], Integral) or j == len(b):
-                result.append(a[i])
-                continue
-            while b[j] is None:  # insert any Nones on the rhs
-                result.append(None)
-                j += 1
-            result.append(fuse_slice(a[i], b[j]))  # Common case
-            j += 1
-        while j < len(b):  # anything leftover on the right?
-            result.append(b[j])
-            j += 1
-        return tuple(result)
-    raise NotImplementedError()
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/overlap.py b/Flaskserver/venv/Lib/site-packages/dask/array/overlap.py
deleted file mode 100644
index 7ba5f99ef703e94b940a7d34ccea169bd7999812..0000000000000000000000000000000000000000
--- a/Flaskserver/venv/Lib/site-packages/dask/array/overlap.py
+++ /dev/null
@@ -1,756 +0,0 @@
-import warnings
-from operator import getitem
-from itertools import product
-from numbers import Integral
-from tlz import merge, pipe, concat, partial, get
-from tlz.curried import map
-
-from . import chunk, wrap
-from .core import (
-    Array,
-    map_blocks,
-    concatenate,
-    concatenate3,
-    reshapelist,
-    unify_chunks,
-)
-from ..highlevelgraph import HighLevelGraph
-from ..base import tokenize
-from ..core import flatten
-from ..utils import concrete
-
-
-def fractional_slice(task, axes):
-    """
-
-    >>> fractional_slice(('x', 5.1), {0: 2})  # doctest: +SKIP
-    (getitem, ('x', 6), (slice(0, 2),))
-
-    >>> fractional_slice(('x', 3, 5.1), {0: 2, 1: 3})  # doctest: +SKIP
-    (getitem, ('x', 3, 5), (slice(None, None, None), slice(-3, None)))
-
-    >>> fractional_slice(('x', 2.9, 5.1), {0: 2, 1: 3})  # doctest: +SKIP
-    (getitem, ('x', 3, 5), (slice(0, 2), slice(-3, None)))
-    """
-    rounded = (task[0],) + tuple(int(round(i)) for i in task[1:])
-
-    index = []
-    for i, (t, r) in enumerate(zip(task[1:], rounded[1:])):
-        depth = axes.get(i, 0)
-        if isinstance(depth, tuple):
-            left_depth = depth[0]
-            right_depth = depth[1]
-        else:
-            left_depth = depth
-            right_depth = depth
-
-        if t == r:
-            index.append(slice(None, None, None))
-        elif t < r and right_depth:
-            index.append(slice(0, right_depth))
-        elif t > r and left_depth:
-            index.append(slice(-left_depth, None))
-        else:
-            index.append(slice(0, 0))
-    index = tuple(index)
-
-    if all(ind == slice(None, None, None) for ind in index):
-        return task
-    else:
-        return (getitem, rounded, index)
-
-
-def expand_key(k, dims, name=None, axes=None):
-    """Get all neighboring keys around center
-
-    Parameters
-    ----------
-    k: tuple
-        They key around which to generate new keys
-    dims: Sequence[int]
-        The number of chunks in each dimension
-    name: Option[str]
-        The name to include in the output keys, or none to include no name
-    axes: Dict[int, int]
-        The axes active in the expansion.  We don't expand on non-active axes
-
-    Examples
-    --------
-    >>> expand_key(('x', 2, 3), dims=[5, 5], name='y', axes={0: 1, 1: 1})  # doctest: +NORMALIZE_WHITESPACE
-    [[('y', 1.1, 2.1), ('y', 1.1, 3), ('y', 1.1, 3.9)],
-     [('y',   2, 2.1), ('y',   2, 3), ('y',   2, 3.9)],
-     [('y', 2.9, 2.1), ('y', 2.9, 3), ('y', 2.9, 3.9)]]
-
-    >>> expand_key(('x', 0, 4), dims=[5, 5], name='y', axes={0: 1, 1: 1})  # doctest: +NORMALIZE_WHITESPACE
-    [[('y',   0, 3.1), ('y',   0,   4)],
-     [('y', 0.9, 3.1), ('y', 0.9,   4)]]
-    """
-
-    def inds(i, ind):
-        rv = []
-        if ind - 0.9 > 0:
-            rv.append(ind - 0.9)
-        rv.append(ind)
-        if ind + 0.9 < dims[i] - 1:
-            rv.append(ind + 0.9)
-        return rv
-
-    shape = []
-    for i, ind in enumerate(k[1:]):
-        num = 1
-        if ind > 0:
-            num += 1
-        if ind < dims[i] - 1:
-            num += 1
-        shape.append(num)
-
-    args = [
-        inds(i, ind) if any((axes.get(i, 0),)) else [ind] for i, ind in enumerate(k[1:])
-    ]
-    if name is not None:
-        args = [[name]] + args
-    seq = list(product(*args))
-    shape2 = [d if any((axes.get(i, 0),)) else 1 for i, d in enumerate(shape)]
-    result = reshapelist(shape2, seq)
-    return result
-
-
-def overlap_internal(x, axes):
-    """Share boundaries between neighboring blocks
-
-    Parameters
-    ----------
-
-    x: da.Array
-        A dask array
-    axes: dict
-        The size of the shared boundary per axis
-
-    The axes input informs how many cells to overlap between neighboring blocks
-    {0: 2, 2: 5} means share two cells in 0 axis, 5 cells in 2 axis
-    """
-    dims = list(map(len, x.chunks))
-    expand_key2 = partial(expand_key, dims=dims, axes=axes)
-
-    # Make keys for each of the surrounding sub-arrays
-    interior_keys = pipe(
-        x.__dask_keys__(), flatten, map(expand_key2), map(flatten), concat, list
-    )
-
-    name = "overlap-" + tokenize(x, axes)
-    getitem_name = "getitem-" + tokenize(x, axes)
-    interior_slices = {}
-    overlap_blocks = {}
-    for k in interior_keys:
-        frac_slice = fractional_slice((x.name,) + k, axes)
-        if (x.name,) + k != frac_slice:
-            interior_slices[(getitem_name,) + k] = frac_slice
-        else:
-            interior_slices[(getitem_name,) + k] = (x.name,) + k
-            overlap_blocks[(name,) + k] = (
-                concatenate3,
-                (concrete, expand_key2((None,) + k, name=getitem_name)),
-            )
-
-    chunks = []
-    for i, bds in enumerate(x.chunks):
-        depth = axes.get(i, 0)
-        if isinstance(depth, tuple):
-            left_depth = depth[0]
-            right_depth = depth[1]
-        else:
-            left_depth = depth
-            right_depth = depth
-
-        if len(bds) == 1:
-            chunks.append(bds)
-        else:
-            left = [bds[0] + right_depth]
-            right = [bds[-1] + left_depth]
-            mid = []
-            for bd in bds[1:-1]:
-                mid.append(bd + left_depth + right_depth)
-            chunks.append(left + mid + right)
-
-    dsk = merge(interior_slices, overlap_blocks)
-    graph = HighLevelGraph.from_collections(name, dsk, dependencies=[x])
-
-    return Array(graph, name, chunks, meta=x)
-
-
-def trim_overlap(x, depth, boundary=None):
-    """Trim sides from each block.
-
-    This couples well with the ``map_overlap`` operation which may leave
-    excess data on each block.
-
-    See also
-    --------
-    dask.array.overlap.map_overlap
-
-    """
-
-    # parameter to be passed to trim_internal
-    axes = coerce_depth(x.ndim, depth)
-    boundary2 = coerce_boundary(x.ndim, boundary)
-    return trim_internal(x, axes=axes, boundary=boundary2)
-
-
-def trim_internal(x, axes, boundary=None):
-    """Trim sides from each block
-
-    This couples well with the overlap operation, which may leave excess data on
-    each block
-
-    See also
-    --------
-    dask.array.chunk.trim
-    dask.array.map_blocks
-    """
-    boundary = coerce_boundary(x.ndim, boundary)
-
-    olist = []
-    for i, bd in enumerate(x.chunks):
-        bdy = boundary.get(i, "none")
-        overlap = axes.get(i, 0)
-        ilist = []
-        for j, d in enumerate(bd):
-            if bdy != "none":
-                if isinstance(overlap, tuple):
-                    d = d - sum(overlap)
-                else:
-                    d = d - overlap * 2
-
-            else:
-                if isinstance(overlap, tuple):
-                    d = d - overlap[0] if j != 0 else d
-                    d = d - overlap[1] if j != len(bd) - 1 else d
-                else:
-                    d = d - overlap if j != 0 else d
-                    d = d - overlap if j != len(bd) - 1 else d
-
-            ilist.append(d)
-        olist.append(tuple(ilist))
-    chunks = tuple(olist)
-
-    return map_blocks(
-        partial(_trim, axes=axes, boundary=boundary),
-        x,
-        chunks=chunks,
-        dtype=x.dtype,
-        meta=x._meta,
-    )
-
-
-def _trim(x, axes, boundary, block_info):
-    """Similar to dask.array.chunk.trim but requires one to specificy the
-    boundary condition.
-
-    ``axes``, and ``boundary`` are assumed to have been coerced.
-
-    """
-    axes = [axes.get(i, 0) for i in range(x.ndim)]
-    axes_front = (ax[0] if isinstance(ax, tuple) else ax for ax in axes)
-    axes_back = (
-        -ax[1]
-        if isinstance(ax, tuple) and ax[1]
-        else -ax
-        if isinstance(ax, Integral) and ax
-        else None
-        for ax in axes
-    )
-
-    trim_front = (
-        0 if (chunk_location == 0 and boundary.get(i, "none") == "none") else ax
-        for i, (chunk_location, ax) in enumerate(
-            zip(block_info[0]["chunk-location"], axes_front)
-        )
-    )
-    trim_back = (
-        None
-        if (chunk_location == chunks - 1 and boundary.get(i, "none") == "none")
-        else ax
-        for i, (chunks, chunk_location, ax) in enumerate(
-            zip(block_info[0]["num-chunks"], block_info[0]["chunk-location"], axes_back)
-        )
-    )
-    ind = tuple(slice(front, back) for front, back in zip(trim_front, trim_back))
-    return x[ind]
-
-
-def periodic(x, axis, depth):
-    """Copy a slice of an array around to its other side
-
-    Useful to create periodic boundary conditions for overlap
-    """
-
-    left = (
-        (slice(None, None, None),) * axis
-        + (slice(0, depth),)
-        + (slice(None, None, None),) * (x.ndim - axis - 1)
-    )
-    right = (
-        (slice(None, None, None),) * axis
-        + (slice(-depth, None),)
-        + (slice(None, None, None),) * (x.ndim - axis - 1)
-    )
-    l = x[left]
-    r = x[right]
-
-    l, r = _remove_overlap_boundaries(l, r, axis, depth)
-
-    return concatenate([r, x, l], axis=axis)
-
-
-def reflect(x, axis, depth):
-    """Reflect boundaries of array on the same side
-
-    This is the converse of ``periodic``
-    """
-    if depth == 1:
-        left = (
-            (slice(None, None, None),) * axis
-            + (slice(0, 1),)
-            + (slice(None, None, None),) * (x.ndim - axis - 1)
-        )
-    else:
-        left = (
-            (slice(None, None, None),) * axis
-            + (slice(depth - 1, None, -1),)
-            + (slice(None, None, None),) * (x.ndim - axis - 1)
-        )
-    right = (
-        (slice(None, None, None),) * axis
-        + (slice(-1, -depth - 1, -1),)
-        + (slice(None, None, None),) * (x.ndim - axis - 1)
-    )
-    l = x[left]
-    r = x[right]
-
-    l, r = _remove_overlap_boundaries(l, r, axis, depth)
-
-    return concatenate([l, x, r], axis=axis)
-
-
-def nearest(x, axis, depth):
-    """Each reflect each boundary value outwards
-
-    This mimics what the skimage.filters.gaussian_filter(... mode="nearest")
-    does.
-    """
-    left = (
-        (slice(None, None, None),) * axis
-        + (slice(0, 1),)
-        + (slice(None, None, None),) * (x.ndim - axis - 1)
-    )
-    right = (
-        (slice(None, None, None),) * axis
-        + (slice(-1, -2, -1),)
-        + (slice(None, None, None),) * (x.ndim - axis - 1)
-    )
-
-    l = concatenate([x[left]] * depth, axis=axis)
-    r = concatenate([x[right]] * depth, axis=axis)
-
-    l, r = _remove_overlap_boundaries(l, r, axis, depth)
-
-    return concatenate([l, x, r], axis=axis)
-
-
-def constant(x, axis, depth, value):
-    """ Add constant slice to either side of array """
-    chunks = list(x.chunks)
-    chunks[axis] = (depth,)
-
-    try:
-        c = wrap.full_like(
-            getattr(x, "_meta", x),
-            value,
-            shape=tuple(map(sum, chunks)),
-            chunks=tuple(chunks),
-            dtype=x.dtype,
-        )
-    except TypeError:
-        c = wrap.full(
-            tuple(map(sum, chunks)), value, chunks=tuple(chunks), dtype=x.dtype
-        )
-
-    return concatenate([c, x, c], axis=axis)
-
-
-def _remove_overlap_boundaries(l, r, axis, depth):
-    lchunks = list(l.chunks)
-    lchunks[axis] = (depth,)
-    rchunks = list(r.chunks)
-    rchunks[axis] = (depth,)
-
-    l = l.rechunk(tuple(lchunks))
-    r = r.rechunk(tuple(rchunks))
-    return l, r
-
-
-def boundaries(x, depth=None, kind=None):
-    """Add boundary conditions to an array before overlaping
-
-    See Also
-    --------
-    periodic
-    constant
-    """
-    if not isinstance(kind, dict):
-        kind = dict((i, kind) for i in range(x.ndim))
-    if not isinstance(depth, dict):
-        depth = dict((i, depth) for i in range(x.ndim))
-
-    for i in range(x.ndim):
-        d = depth.get(i, 0)
-        if d == 0:
-            continue
-
-        this_kind = kind.get(i, "none")
-        if this_kind == "none":
-            continue
-        elif this_kind == "periodic":
-            x = periodic(x, i, d)
-        elif this_kind == "reflect":
-            x = reflect(x, i, d)
-        elif this_kind == "nearest":
-            x = nearest(x, i, d)
-        elif i in kind:
-            x = constant(x, i, d, kind[i])
-
-    return x
-
-
-def overlap(x, depth, boundary):
-    """Share boundaries between neighboring blocks
-
-    Parameters
-    ----------
-
-    x: da.Array
-        A dask array
-    depth: dict
-        The size of the shared boundary per axis
-    boundary: dict
-        The boundary condition on each axis. Options are 'reflect', 'periodic',
-        'nearest', 'none', or an array value.  Such a value will fill the
-        boundary with that value.
-
-    The depth input informs how many cells to overlap between neighboring
-    blocks ``{0: 2, 2: 5}`` means share two cells in 0 axis, 5 cells in 2 axis.
-    Axes missing from this input will not be overlapped.
-
-    Examples
-    --------
-    >>> import numpy as np
-    >>> import dask.array as da
-
-    >>> x = np.arange(64).reshape((8, 8))
-    >>> d = da.from_array(x, chunks=(4, 4))
-    >>> d.chunks
-    ((4, 4), (4, 4))
-
-    >>> g = da.overlap.overlap(d, depth={0: 2, 1: 1},
-    ...                       boundary={0: 100, 1: 'reflect'})
-    >>> g.chunks
-    ((8, 8), (6, 6))
-
-    >>> np.array(g)
-    array([[100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100],
-           [100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100],
-           [  0,   0,   1,   2,   3,   4,   3,   4,   5,   6,   7,   7],
-           [  8,   8,   9,  10,  11,  12,  11,  12,  13,  14,  15,  15],
-           [ 16,  16,  17,  18,  19,  20,  19,  20,  21,  22,  23,  23],
-           [ 24,  24,  25,  26,  27,  28,  27,  28,  29,  30,  31,  31],
-           [ 32,  32,  33,  34,  35,  36,  35,  36,  37,  38,  39,  39],
-           [ 40,  40,  41,  42,  43,  44,  43,  44,  45,  46,  47,  47],
-           [ 16,  16,  17,  18,  19,  20,  19,  20,  21,  22,  23,  23],
-           [ 24,  24,  25,  26,  27,  28,  27,  28,  29,  30,  31,  31],
-           [ 32,  32,  33,  34,  35,  36,  35,  36,  37,  38,  39,  39],
-           [ 40,  40,  41,  42,  43,  44,  43,  44,  45,  46,  47,  47],
-           [ 48,  48,  49,  50,  51,  52,  51,  52,  53,  54,  55,  55],
-           [ 56,  56,  57,  58,  59,  60,  59,  60,  61,  62,  63,  63],
-           [100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100],
-           [100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100, 100]])
-    """
-    depth2 = coerce_depth(x.ndim, depth)
-    boundary2 = coerce_boundary(x.ndim, boundary)
-
-    # is depth larger than chunk size?
-    depth_values = [depth2.get(i, 0) for i in range(x.ndim)]
-    for d, c in zip(depth_values, x.chunks):
-        maxd = max(d) if isinstance(d, tuple) else d
-        if maxd > min(c):
-            raise ValueError(
-                "The overlapping depth %d is larger than your\n"
-                "smallest chunk size %d. Rechunk your array\n"
-                "with a larger chunk size or a chunk size that\n"
-                "more evenly divides the shape of your array." % (d, min(c))
-            )
-    x2 = boundaries(x, depth2, boundary2)
-    x3 = overlap_internal(x2, depth2)
-    trim = dict(
-        (k, v * 2 if boundary2.get(k, "none") != "none" else 0)
-        for k, v in depth2.items()
-    )
-    x4 = chunk.trim(x3, trim)
-    return x4
-
-
-def add_dummy_padding(x, depth, boundary):
-    """
-    Pads an array which has 'none' as the boundary type.
-    Used to simplify trimming arrays which use 'none'.
-
-    >>> import dask.array as da
-    >>> x = da.arange(6, chunks=3)
-    >>> add_dummy_padding(x, {0: 1}, {0: 'none'}).compute()  # doctest: +NORMALIZE_WHITESPACE
-    array([..., 0, 1, 2, 3, 4, 5, ...])
-    """
-    for k, v in boundary.items():
-        d = depth.get(k, 0)
-        if v == "none" and d > 0:
-            empty_shape = list(x.shape)
-            empty_shape[k] = d
-
-            empty_chunks = list(x.chunks)
-            empty_chunks[k] = (d,)
-
-            try:
-                empty = wrap.empty_like(
-                    getattr(x, "_meta", x),
-                    shape=empty_shape,
-                    chunks=empty_chunks,
-                    dtype=x.dtype,
-                )
-            except TypeError:
-                empty = wrap.empty(empty_shape, chunks=empty_chunks, dtype=x.dtype)
-
-            out_chunks = list(x.chunks)
-            ax_chunks = list(out_chunks[k])
-            ax_chunks[0] += d
-            ax_chunks[-1] += d
-            out_chunks[k] = tuple(ax_chunks)
-
-            x = concatenate([empty, x, empty], axis=k)
-            x = x.rechunk(out_chunks)
-    return x
-
-
-def map_overlap(
-    func, *args, depth=None, boundary=None, trim=True, align_arrays=True, **kwargs
-):
-    """Map a function over blocks of arrays with some overlap
-
-    We share neighboring zones between blocks of the array, map a
-    function, and then trim away the neighboring strips.
-
-    Parameters
-    ----------
-    func: function
-        The function to apply to each extended block.
-        If multiple arrays are provided, then the function should expect to
-        receive chunks of each array in the same order.
-    args : dask arrays
-    depth: int, tuple, dict or list
-        The number of elements that each block should share with its neighbors
-        If a tuple or dict then this can be different per axis.
-        If a list then each element of that list must be an int, tuple or dict
-        defining depth for the corresponding array in `args`.
-        Asymmetric depths may be specified using a dict value of (-/+) tuples.
-        Note that asymmetric depths are currently only supported when
-        ``boundary`` is 'none'.
-        The default value is 0.
-    boundary: str, tuple, dict or list
-        How to handle the boundaries.
-        Values include 'reflect', 'periodic', 'nearest', 'none',
-        or any constant value like 0 or np.nan.
-        If a list then each element must be a str, tuple or dict defining the
-        boundary for the corresponding array in `args`.
-        The default value is 'reflect'.
-    trim: bool
-        Whether or not to trim ``depth`` elements from each block after
-        calling the map function.
-        Set this to False if your mapping function already does this for you
-    align_arrays: bool
-        Whether or not to align chunks along equally sized dimensions when
-        multiple arrays are provided.  This allows for larger chunks in some
-        arrays to be broken into smaller ones that match chunk sizes in other
-        arrays such that they are compatible for block function mapping. If
-        this is false, then an error will be thrown if arrays do not already
-        have the same number of blocks in each dimension.
-    **kwargs:
-        Other keyword arguments valid in ``map_blocks``
-
-    Examples
-    --------
-    >>> import numpy as np
-    >>> import dask.array as da
-
-    >>> x = np.array([1, 1, 2, 3, 3, 3, 2, 1, 1])
-    >>> x = da.from_array(x, chunks=5)
-    >>> def derivative(x):
-    ...     return x - np.roll(x, 1)
-
-    >>> y = x.map_overlap(derivative, depth=1, boundary=0)
-    >>> y.compute()
-    array([ 1,  0,  1,  1,  0,  0, -1, -1,  0])
-
-    >>> x = np.arange(16).reshape((4, 4))
-    >>> d = da.from_array(x, chunks=(2, 2))
-    >>> d.map_overlap(lambda x: x + x.size, depth=1).compute()
-    array([[16, 17, 18, 19],
-           [20, 21, 22, 23],
-           [24, 25, 26, 27],
-           [28, 29, 30, 31]])
-
-    >>> func = lambda x: x + x.size
-    >>> depth = {0: 1, 1: 1}
-    >>> boundary = {0: 'reflect', 1: 'none'}
-    >>> d.map_overlap(func, depth, boundary).compute()  # doctest: +NORMALIZE_WHITESPACE
-    array([[12,  13,  14,  15],
-           [16,  17,  18,  19],
-           [20,  21,  22,  23],
-           [24,  25,  26,  27]])
-
-    The ``da.map_overlap`` function can also accept multiple arrays.
-
-    >>> func = lambda x, y: x + y
-    >>> x = da.arange(8).reshape(2, 4).rechunk((1, 2))
-    >>> y = da.arange(4).rechunk(2)
-    >>> da.map_overlap(func, x, y, depth=1).compute() # doctest: +NORMALIZE_WHITESPACE
-    array([[ 0,  2,  4,  6],
-           [ 4,  6,  8,  10]])
-
-    When multiple arrays are given, they do not need to have the
-    same number of dimensions but they must broadcast together.
-    Arrays are aligned block by block (just as in ``da.map_blocks``)
-    so the blocks must have a common chunk size.  This common chunking
-    is determined automatically as long as ``align_arrays`` is True.
-
-    >>> x = da.arange(8, chunks=4)
-    >>> y = da.arange(8, chunks=2)
-    >>> r = da.map_overlap(func, x, y, depth=1, align_arrays=True)
-    >>> len(r.to_delayed())
-    4
-
-    >>> da.map_overlap(func, x, y, depth=1, align_arrays=False).compute()
-    Traceback (most recent call last):
-        ...
-    ValueError: Shapes do not align {'.0': {2, 4}}
-
-    Note also that this function is equivalent to ``map_blocks``
-    by default.  A non-zero ``depth`` must be defined for any
-    overlap to appear in the arrays provided to ``func``.
-
-    >>> func = lambda x: x.sum()
-    >>> x = da.ones(10, dtype='int')
-    >>> block_args = dict(chunks=(), drop_axis=0)
-    >>> da.map_blocks(func, x, **block_args).compute()
-    10
-    >>> da.map_overlap(func, x, **block_args).compute()
-    10
-    >>> da.map_overlap(func, x, **block_args, depth=1).compute()
-    12
-    """
-    # Look for invocation using deprecated single-array signature
-    # map_overlap(x, func, depth, boundary=None, trim=True, **kwargs)
-    if isinstance(func, Array) and callable(args[0]):
-        warnings.warn(
-            "The use of map_overlap(array, func, **kwargs) is deprecated since dask 2.17.0 "
-            "and will be an error in a future release. To silence this warning, use the syntax "
-            "map_overlap(func, array0,[ array1, ...,] **kwargs) instead.",
-            FutureWarning,
-        )
-        sig = ["func", "depth", "boundary", "trim"]
-        depth = get(sig.index("depth"), args, depth)
-        boundary = get(sig.index("boundary"), args, boundary)
-        trim = get(sig.index("trim"), args, trim)
-        func, args = args[0], [func]
-
-    if not callable(func):
-        raise TypeError(
-            "First argument must be callable function, not {}\n"
-            "Usage:   da.map_overlap(function, x)\n"
-            "   or:   da.map_overlap(function, x, y, z)".format(type(func).__name__)
-        )
-    if not all(isinstance(x, Array) for x in args):
-        raise TypeError(
-            "All variadic arguments must be arrays, not {}\n"
-            "Usage:   da.map_overlap(function, x)\n"
-            "   or:   da.map_overlap(function, x, y, z)".format(
-                [type(x).__name__ for x in args]
-            )
-        )
-
-    # Coerce depth and boundary arguments to lists of individual
-    # specifications for each array argument
-    def coerce(xs, arg, fn):
-        if not isinstance(arg, list):
-            arg = [arg] * len(xs)
-        return [fn(x.ndim, a) for x, a in zip(xs, arg)]
-
-    depth = coerce(args, depth, coerce_depth)
-    boundary = coerce(args, boundary, coerce_boundary)
-
-    # Align chunks in each array to a common size
-    if align_arrays:
-        # Reverse unification order to allow block broadcasting
-        inds = [list(reversed(range(x.ndim))) for x in args]
-        _, args = unify_chunks(*list(concat(zip(args, inds))), warn=False)
-
-    for i, x in enumerate(args):
-        for j in range(x.ndim):
-            if isinstance(depth[i][j], tuple) and boundary[i][j] != "none":
-                raise NotImplementedError(
-                    "Asymmetric overlap is currently only implemented "
-                    "for boundary='none', however boundary for dimension "
-                    "{} in array argument {} is {}".format(j, i, boundary[i][j])
-                )
-
-    def assert_int_chunksize(xs):
-        assert all(type(c) is int for x in xs for cc in x.chunks for c in cc)
-
-    assert_int_chunksize(args)
-    args = [overlap(x, depth=d, boundary=b) for x, d, b in zip(args, depth, boundary)]
-    assert_int_chunksize(args)
-    x = map_blocks(func, *args, **kwargs)
-    assert_int_chunksize([x])
-    if trim:
-        # Find index of array argument with maximum rank and break ties by choosing first provided
-        i = sorted(enumerate(args), key=lambda v: (v[1].ndim, -v[0]))[-1][0]
-        # Trim using depth/boundary setting for array of highest rank
-        return trim_internal(x, depth[i], boundary[i])
-    else:
-        return x
-
-
-def coerce_depth(ndim, depth):
-    default = 0
-    if depth is None:
-        depth = default
-    if isinstance(depth, Integral):
-        depth = (depth,) * ndim
-    if isinstance(depth, tuple):
-        depth = dict(zip(range(ndim), depth))
-    if isinstance(depth, dict):
-        for i in range(ndim):
-            if i not in depth:
-                depth[i] = 0
-    return depth
-
-
-def coerce_boundary(ndim, boundary):
-    default = "reflect"
-    if boundary is None:
-        boundary = default
-    if not isinstance(boundary, (tuple, dict)):
-        boundary = (boundary,) * ndim
-    if isinstance(boundary, tuple):
-        boundary = dict(zip(range(ndim), boundary))
-    if isinstance(boundary, dict):
-        for i in range(ndim):
-            if i not in boundary:
-                boundary[i] = default
-    return boundary
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/percentile.py b/Flaskserver/venv/Lib/site-packages/dask/array/percentile.py
deleted file mode 100644
index ef4e9c09f3bc604ad1db06773fb88968e3f1d82a..0000000000000000000000000000000000000000
--- a/Flaskserver/venv/Lib/site-packages/dask/array/percentile.py
+++ /dev/null
@@ -1,267 +0,0 @@
-from collections.abc import Iterator
-from functools import wraps
-from numbers import Number
-
-import numpy as np
-from tlz import merge, merge_sorted
-
-from .core import Array
-from ..base import tokenize
-from ..highlevelgraph import HighLevelGraph
-
-
-@wraps(np.percentile)
-def _percentile(a, q, interpolation="linear"):
-    n = len(a)
-    if not len(a):
-        return None, n
-    if isinstance(q, Iterator):
-        q = list(q)
-    if a.dtype.name == "category":
-        result = np.percentile(a.codes, q, interpolation=interpolation)
-        import pandas as pd
-
-        return pd.Categorical.from_codes(result, a.categories, a.ordered), n
-    if np.issubdtype(a.dtype, np.datetime64):
-        a2 = a.astype("i8")
-        result = np.percentile(a2, q, interpolation=interpolation)
-        return result.astype(a.dtype), n
-    if not np.issubdtype(a.dtype, np.number):
-        interpolation = "nearest"
-    return np.percentile(a, q, interpolation=interpolation), n
-
-
-def _tdigest_chunk(a):
-
-    from crick import TDigest
-
-    t = TDigest()
-    t.update(a)
-
-    return t
-
-
-def _percentiles_from_tdigest(qs, digests):
-
-    from crick import TDigest
-
-    t = TDigest()
-    t.merge(*digests)
-
-    return np.array(t.quantile(qs / 100.0))
-
-
-def percentile(a, q, interpolation="linear", method="default"):
-    """Approximate percentile of 1-D array
-
-    Parameters
-    ----------
-    a : Array
-    q : array_like of float
-        Percentile or sequence of percentiles to compute, which must be between
-        0 and 100 inclusive.
-    interpolation : {'linear', 'lower', 'higher', 'midpoint', 'nearest'}, optional
-        The interpolation method to use when the desired percentile lies
-        between two data points ``i < j``. Only valid for ``method='dask'``.
-
-        - 'linear': ``i + (j - i) * fraction``, where ``fraction``
-          is the fractional part of the index surrounded by ``i``
-          and ``j``.
-        - 'lower': ``i``.
-        - 'higher': ``j``.
-        - 'nearest': ``i`` or ``j``, whichever is nearest.
-        - 'midpoint': ``(i + j) / 2``.
-
-    method : {'default', 'dask', 'tdigest'}, optional
-        What method to use. By default will use dask's internal custom
-        algorithm (``'dask'``).  If set to ``'tdigest'`` will use tdigest for
-        floats and ints and fallback to the ``'dask'`` otherwise.
-
-    See Also
-    --------
-    numpy.percentile : Numpy's equivalent Percentile function
-    """
-    if not a.ndim == 1:
-        raise NotImplementedError("Percentiles only implemented for 1-d arrays")
-    if isinstance(q, Number):
-        q = [q]
-    q = np.array(q)
-    token = tokenize(a, q, interpolation)
-
-    dtype = a.dtype
-    if np.issubdtype(dtype, np.integer):
-        dtype = (np.array([], dtype=dtype) / 0.5).dtype
-
-    allowed_methods = ["default", "dask", "tdigest"]
-    if method not in allowed_methods:
-        raise ValueError("method can only be 'default', 'dask' or 'tdigest'")
-
-    if method == "default":
-        internal_method = "dask"
-    else:
-        internal_method = method
-
-    # Allow using t-digest if interpolation is allowed and dtype is of floating or integer type
-    if (
-        internal_method == "tdigest"
-        and interpolation == "linear"
-        and (np.issubdtype(dtype, np.floating) or np.issubdtype(dtype, np.integer))
-    ):
-
-        from dask.utils import import_required
-
-        import_required(
-            "crick", "crick is a required dependency for using the t-digest method."
-        )
-
-        name = "percentile_tdigest_chunk-" + token
-        dsk = dict(
-            ((name, i), (_tdigest_chunk, key))
-            for i, key in enumerate(a.__dask_keys__())
-        )
-
-        name2 = "percentile_tdigest-" + token
-
-        dsk2 = {(name2, 0): (_percentiles_from_tdigest, q, sorted(dsk))}
-
-    # Otherwise use the custom percentile algorithm
-    else:
-
-        name = "percentile_chunk-" + token
-        dsk = dict(
-            ((name, i), (_percentile, key, q, interpolation))
-            for i, key in enumerate(a.__dask_keys__())
-        )
-
-        name2 = "percentile-" + token
-        dsk2 = {
-            (name2, 0): (
-                merge_percentiles,
-                q,
-                [q] * len(a.chunks[0]),
-                sorted(dsk),
-                interpolation,
-            )
-        }
-
-    dsk = merge(dsk, dsk2)
-    graph = HighLevelGraph.from_collections(name2, dsk, dependencies=[a])
-    return Array(graph, name2, chunks=((len(q),),), dtype=dtype)
-
-
-def merge_percentiles(finalq, qs, vals, interpolation="lower", Ns=None):
-    """Combine several percentile calculations of different data.
-
-    Parameters
-    ----------
-
-    finalq : numpy.array
-        Percentiles to compute (must use same scale as ``qs``).
-    qs : sequence of :class:`numpy.array`s
-        Percentiles calculated on different sets of data.
-    vals : sequence of :class:`numpy.array`s
-        Resulting values associated with percentiles ``qs``.
-    Ns : sequence of integers
-        The number of data elements associated with each data set.
-    interpolation : {'linear', 'lower', 'higher', 'midpoint', 'nearest'}
-        Specify the type of interpolation to use to calculate final
-        percentiles.  For more information, see :func:`numpy.percentile`.
-
-    Examples
-    --------
-
-    >>> finalq = [10, 20, 30, 40, 50, 60, 70, 80]
-    >>> qs = [[20, 40, 60, 80], [20, 40, 60, 80]]
-    >>> vals = [np.array([1, 2, 3, 4]), np.array([10, 11, 12, 13])]
-    >>> Ns = [100, 100]  # Both original arrays had 100 elements
-
-    >>> merge_percentiles(finalq, qs, vals, Ns=Ns)
-    array([ 1,  2,  3,  4, 10, 11, 12, 13])
-    """
-    if isinstance(finalq, Iterator):
-        finalq = list(finalq)
-    finalq = np.array(finalq)
-    qs = list(map(list, qs))
-    vals = list(vals)
-    if Ns is None:
-        vals, Ns = zip(*vals)
-    Ns = list(Ns)
-
-    L = list(zip(*[(q, val, N) for q, val, N in zip(qs, vals, Ns) if N]))
-    if not L:
-        raise ValueError("No non-trivial arrays found")
-    qs, vals, Ns = L
-
-    # TODO: Perform this check above in percentile once dtype checking is easy
-    #       Here we silently change meaning
-    if vals[0].dtype.name == "category":
-        result = merge_percentiles(
-            finalq, qs, [v.codes for v in vals], interpolation, Ns
-        )
-        import pandas as pd
-
-        return pd.Categorical.from_codes(result, vals[0].categories, vals[0].ordered)
-    if not np.issubdtype(vals[0].dtype, np.number):
-        interpolation = "nearest"
-
-    if len(vals) != len(qs) or len(Ns) != len(qs):
-        raise ValueError("qs, vals, and Ns parameters must be the same length")
-
-    # transform qs and Ns into number of observations between percentiles
-    counts = []
-    for q, N in zip(qs, Ns):
-        count = np.empty(len(q))
-        count[1:] = np.diff(q)
-        count[0] = q[0]
-        count *= N
-        counts.append(count)
-
-    # Sort by calculated percentile values, then number of observations.
-    # >95% of the time in this function is spent in `merge_sorted` below.
-    # An alternative that uses numpy sort is shown.  It is sometimes
-    # comparable to, but typically slower than, `merge_sorted`.
-    #
-    # >>> A = np.concatenate(map(np.array, map(zip, vals, counts)))
-    # >>> A.sort(0, kind='mergesort')
-
-    combined_vals_counts = merge_sorted(*map(zip, vals, counts))
-    combined_vals, combined_counts = zip(*combined_vals_counts)
-
-    combined_vals = np.array(combined_vals)
-    combined_counts = np.array(combined_counts)
-
-    # percentile-like, but scaled by total number of observations
-    combined_q = np.cumsum(combined_counts)
-
-    # rescale finalq percentiles to match combined_q
-    desired_q = finalq * sum(Ns)
-
-    # the behavior of different interpolation methods should be
-    # investigated further.
-    if interpolation == "linear":
-        rv = np.interp(desired_q, combined_q, combined_vals)
-    else:
-        left = np.searchsorted(combined_q, desired_q, side="left")
-        right = np.searchsorted(combined_q, desired_q, side="right") - 1
-        np.minimum(left, len(combined_vals) - 1, left)  # don't exceed max index
-        lower = np.minimum(left, right)
-        upper = np.maximum(left, right)
-        if interpolation == "lower":
-            rv = combined_vals[lower]
-        elif interpolation == "higher":
-            rv = combined_vals[upper]
-        elif interpolation == "midpoint":
-            rv = 0.5 * (combined_vals[lower] + combined_vals[upper])
-        elif interpolation == "nearest":
-            lower_residual = np.abs(combined_q[lower] - desired_q)
-            upper_residual = np.abs(combined_q[upper] - desired_q)
-            mask = lower_residual > upper_residual
-            index = lower  # alias; we no longer need lower
-            index[mask] = upper[mask]
-            rv = combined_vals[index]
-        else:
-            raise ValueError(
-                "interpolation can only be 'linear', 'lower', "
-                "'higher', 'midpoint', or 'nearest'"
-            )
-    return rv
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/random.py b/Flaskserver/venv/Lib/site-packages/dask/array/random.py
deleted file mode 100644
index 4d2070d3adca80bf65c885dc12c4984b6cc0c66b..0000000000000000000000000000000000000000
--- a/Flaskserver/venv/Lib/site-packages/dask/array/random.py
+++ /dev/null
@@ -1,521 +0,0 @@
-import numbers
-import warnings
-from itertools import product
-from numbers import Integral
-from operator import getitem
-
-import numpy as np
-
-from .core import (
-    normalize_chunks,
-    Array,
-    slices_from_chunks,
-    asarray,
-    broadcast_shapes,
-    broadcast_to,
-)
-from .creation import arange
-from ..base import tokenize
-from ..highlevelgraph import HighLevelGraph
-from ..utils import ignoring, random_state_data, derived_from, skip_doctest
-
-
-def doc_wraps(func):
-    """ Copy docstring from one function to another """
-    warnings.warn(
-        "dask.array.random.doc_wraps is deprecated and will be removed in a future version",
-        FutureWarning,
-    )
-
-    def _(func2):
-        if func.__doc__ is not None:
-            func2.__doc__ = skip_doctest(func.__doc__)
-        return func2
-
-    return _
-
-
-class RandomState(object):
-    """
-    Mersenne Twister pseudo-random number generator
-
-    This object contains state to deterministically generate pseudo-random
-    numbers from a variety of probability distributions.  It is identical to
-    ``np.random.RandomState`` except that all functions also take a ``chunks=``
-    keyword argument.
-
-    Parameters
-    ----------
-    seed: Number
-        Object to pass to RandomState to serve as deterministic seed
-    RandomState: Callable[seed] -> RandomState
-        A callable that, when provided with a ``seed`` keyword provides an
-        object that operates identically to ``np.random.RandomState`` (the
-        default).  This might also be a function that returns a
-        ``randomgen.RandomState``, ``mkl_random``, or
-        ``cupy.random.RandomState`` object.
-
-    Examples
-    --------
-    >>> import dask.array as da
-    >>> state = da.random.RandomState(1234)  # a seed
-    >>> x = state.normal(10, 0.1, size=3, chunks=(2,))
-    >>> x.compute()
-    array([10.01867852, 10.04812289,  9.89649746])
-
-    See Also
-    --------
-    np.random.RandomState
-    """
-
-    def __init__(self, seed=None, RandomState=None):
-        self._numpy_state = np.random.RandomState(seed)
-        self._RandomState = RandomState
-
-    def seed(self, seed=None):
-        self._numpy_state.seed(seed)
-
-    def _wrap(
-        self, funcname, *args, size=None, chunks="auto", extra_chunks=(), **kwargs
-    ):
-        """Wrap numpy random function to produce dask.array random function
-
-        extra_chunks should be a chunks tuple to append to the end of chunks
-        """
-        if size is not None and not isinstance(size, (tuple, list)):
-            size = (size,)
-
-        args_shapes = {ar.shape for ar in args if isinstance(ar, (Array, np.ndarray))}
-        args_shapes.union(
-            {ar.shape for ar in kwargs.values() if isinstance(ar, (Array, np.ndarray))}
-        )
-
-        shapes = list(args_shapes)
-        if size is not None:
-            shapes.extend([size])
-        # broadcast to the final size(shape)
-        size = broadcast_shapes(*shapes)
-        chunks = normalize_chunks(
-            chunks,
-            size,  # ideally would use dtype here
-            dtype=kwargs.get("dtype", np.float64),
-        )
-        slices = slices_from_chunks(chunks)
-
-        def _broadcast_any(ar, shape, chunks):
-            if isinstance(ar, Array):
-                return broadcast_to(ar, shape).rechunk(chunks)
-            if isinstance(ar, np.ndarray):
-                return np.ascontiguousarray(np.broadcast_to(ar, shape))
-
-        # Broadcast all arguments, get tiny versions as well
-        # Start adding the relevant bits to the graph
-        dsk = {}
-        dsks = []
-        lookup = {}
-        small_args = []
-        dependencies = []
-        for i, ar in enumerate(args):
-            if isinstance(ar, (np.ndarray, Array)):
-                res = _broadcast_any(ar, size, chunks)
-                if isinstance(res, Array):
-                    dependencies.append(res)
-                    dsks.append(res.dask)
-                    lookup[i] = res.name
-                elif isinstance(res, np.ndarray):
-                    name = "array-{}".format(tokenize(res))
-                    lookup[i] = name
-                    dsk[name] = res
-                small_args.append(ar[tuple(0 for _ in ar.shape)])
-            else:
-                small_args.append(ar)
-
-        small_kwargs = {}
-        for key, ar in kwargs.items():
-            if isinstance(ar, (np.ndarray, Array)):
-                res = _broadcast_any(ar, size, chunks)
-                if isinstance(res, Array):
-                    dependencies.append(res)
-                    dsks.append(res.dask)
-                    lookup[key] = res.name
-                elif isinstance(res, np.ndarray):
-                    name = "array-{}".format(tokenize(res))
-                    lookup[key] = name
-                    dsk[name] = res
-                small_kwargs[key] = ar[tuple(0 for _ in ar.shape)]
-            else:
-                small_kwargs[key] = ar
-
-        sizes = list(product(*chunks))
-        seeds = random_state_data(len(sizes), self._numpy_state)
-        token = tokenize(seeds, size, chunks, args, kwargs)
-        name = "{0}-{1}".format(funcname, token)
-
-        keys = product(
-            [name], *([range(len(bd)) for bd in chunks] + [[0]] * len(extra_chunks))
-        )
-        blocks = product(*[range(len(bd)) for bd in chunks])
-
-        vals = []
-        for seed, size, slc, block in zip(seeds, sizes, slices, blocks):
-            arg = []
-            for i, ar in enumerate(args):
-                if i not in lookup:
-                    arg.append(ar)
-                else:
-                    if isinstance(ar, Array):
-                        dependencies.append(ar)
-                        arg.append((lookup[i],) + block)
-                    else:  # np.ndarray
-                        arg.append((getitem, lookup[i], slc))
-            kwrg = {}
-            for k, ar in kwargs.items():
-                if k not in lookup:
-                    kwrg[k] = ar
-                else:
-                    if isinstance(ar, Array):
-                        dependencies.append(ar)
-                        kwrg[k] = (lookup[k],) + block
-                    else:  # np.ndarray
-                        kwrg[k] = (getitem, lookup[k], slc)
-            vals.append(
-                (_apply_random, self._RandomState, funcname, seed, size, arg, kwrg)
-            )
-
-        meta = _apply_random(
-            self._RandomState,
-            funcname,
-            seed,
-            (0,) * len(size),
-            small_args,
-            small_kwargs,
-        )
-
-        dsk.update(dict(zip(keys, vals)))
-
-        graph = HighLevelGraph.from_collections(name, dsk, dependencies=dependencies)
-        return Array(graph, name, chunks + extra_chunks, meta=meta)
-
-    @derived_from(np.random.RandomState, skipblocks=1)
-    def beta(self, a, b, size=None, chunks="auto", **kwargs):
-        return self._wrap("beta", a, b, size=size, chunks=chunks, **kwargs)
-
-    @derived_from(np.random.RandomState, skipblocks=1)
-    def binomial(self, n, p, size=None, chunks="auto", **kwargs):
-        return self._wrap("binomial", n, p, size=size, chunks=chunks, **kwargs)
-
-    @derived_from(np.random.RandomState, skipblocks=1)
-    def chisquare(self, df, size=None, chunks="auto", **kwargs):
-        return self._wrap("chisquare", df, size=size, chunks=chunks, **kwargs)
-
-    with ignoring(AttributeError):
-
-        @derived_from(np.random.RandomState, skipblocks=1)
-        def choice(self, a, size=None, replace=True, p=None, chunks="auto"):
-            dependencies = []
-            # Normalize and validate `a`
-            if isinstance(a, Integral):
-                # On windows the output dtype differs if p is provided or
-                # absent, see https://github.com/numpy/numpy/issues/9867
-                dummy_p = np.array([1]) if p is not None else p
-                dtype = np.random.choice(1, size=(), p=dummy_p).dtype
-                len_a = a
-                if a < 0:
-                    raise ValueError("a must be greater than 0")
-            else:
-                a = asarray(a)
-                a = a.rechunk(a.shape)
-                dtype = a.dtype
-                if a.ndim != 1:
-                    raise ValueError("a must be one dimensional")
-                len_a = len(a)
-                dependencies.append(a)
-                a = a.__dask_keys__()[0]
-
-            # Normalize and validate `p`
-            if p is not None:
-                if not isinstance(p, Array):
-                    # If p is not a dask array, first check the sum is close
-                    # to 1 before converting.
-                    p = np.asarray(p)
-                    if not np.isclose(p.sum(), 1, rtol=1e-7, atol=0):
-                        raise ValueError("probabilities do not sum to 1")
-                    p = asarray(p)
-                else:
-                    p = p.rechunk(p.shape)
-
-                if p.ndim != 1:
-                    raise ValueError("p must be one dimensional")
-                if len(p) != len_a:
-                    raise ValueError("a and p must have the same size")
-
-                dependencies.append(p)
-                p = p.__dask_keys__()[0]
-
-            if size is None:
-                size = ()
-            elif not isinstance(size, (tuple, list)):
-                size = (size,)
-
-            chunks = normalize_chunks(chunks, size, dtype=np.float64)
-            if not replace and len(chunks[0]) > 1:
-                err_msg = (
-                    "replace=False is not currently supported for "
-                    "dask.array.choice with multi-chunk output "
-                    "arrays"
-                )
-                raise NotImplementedError(err_msg)
-            sizes = list(product(*chunks))
-            state_data = random_state_data(len(sizes), self._numpy_state)
-
-            name = "da.random.choice-%s" % tokenize(
-                state_data, size, chunks, a, replace, p
-            )
-            keys = product([name], *(range(len(bd)) for bd in chunks))
-            dsk = {
-                k: (_choice, state, a, size, replace, p)
-                for k, state, size in zip(keys, state_data, sizes)
-            }
-
-            graph = HighLevelGraph.from_collections(
-                name, dsk, dependencies=dependencies
-            )
-            return Array(graph, name, chunks, dtype=dtype)
-
-    # @derived_from(np.random.RandomState, skipblocks=1)
-    # def dirichlet(self, alpha, size=None, chunks="auto"):
-
-    @derived_from(np.random.RandomState, skipblocks=1)
-    def exponential(self, scale=1.0, size=None, chunks="auto", **kwargs):
-        return self._wrap("exponential", scale, size=size, chunks=chunks, **kwargs)
-
-    @derived_from(np.random.RandomState, skipblocks=1)
-    def f(self, dfnum, dfden, size=None, chunks="auto", **kwargs):
-        return self._wrap("f", dfnum, dfden, size=size, chunks=chunks, **kwargs)
-
-    @derived_from(np.random.RandomState, skipblocks=1)
-    def gamma(self, shape, scale=1.0, size=None, chunks="auto", **kwargs):
-        return self._wrap("gamma", shape, scale, size=size, chunks=chunks, **kwargs)
-
-    @derived_from(np.random.RandomState, skipblocks=1)
-    def geometric(self, p, size=None, chunks="auto", **kwargs):
-        return self._wrap("geometric", p, size=size, chunks=chunks, **kwargs)
-
-    @derived_from(np.random.RandomState, skipblocks=1)
-    def gumbel(self, loc=0.0, scale=1.0, size=None, chunks="auto", **kwargs):
-        return self._wrap("gumbel", loc, scale, size=size, chunks=chunks, **kwargs)
-
-    @derived_from(np.random.RandomState, skipblocks=1)
-    def hypergeometric(self, ngood, nbad, nsample, size=None, chunks="auto", **kwargs):
-        return self._wrap(
-            "hypergeometric", ngood, nbad, nsample, size=size, chunks=chunks, **kwargs
-        )
-
-    @derived_from(np.random.RandomState, skipblocks=1)
-    def laplace(self, loc=0.0, scale=1.0, size=None, chunks="auto", **kwargs):
-        return self._wrap("laplace", loc, scale, size=size, chunks=chunks, **kwargs)
-
-    @derived_from(np.random.RandomState, skipblocks=1)
-    def logistic(self, loc=0.0, scale=1.0, size=None, chunks="auto", **kwargs):
-        return self._wrap("logistic", loc, scale, size=size, chunks=chunks, **kwargs)
-
-    @derived_from(np.random.RandomState, skipblocks=1)
-    def lognormal(self, mean=0.0, sigma=1.0, size=None, chunks="auto", **kwargs):
-        return self._wrap("lognormal", mean, sigma, size=size, chunks=chunks, **kwargs)
-
-    @derived_from(np.random.RandomState, skipblocks=1)
-    def logseries(self, p, size=None, chunks="auto", **kwargs):
-        return self._wrap("logseries", p, size=size, chunks=chunks, **kwargs)
-
-    @derived_from(np.random.RandomState, skipblocks=1)
-    def multinomial(self, n, pvals, size=None, chunks="auto", **kwargs):
-        return self._wrap(
-            "multinomial",
-            n,
-            pvals,
-            size=size,
-            chunks=chunks,
-            extra_chunks=((len(pvals),),),
-        )
-
-    @derived_from(np.random.RandomState, skipblocks=1)
-    def negative_binomial(self, n, p, size=None, chunks="auto", **kwargs):
-        return self._wrap("negative_binomial", n, p, size=size, chunks=chunks, **kwargs)
-
-    @derived_from(np.random.RandomState, skipblocks=1)
-    def noncentral_chisquare(self, df, nonc, size=None, chunks="auto", **kwargs):
-        return self._wrap(
-            "noncentral_chisquare", df, nonc, size=size, chunks=chunks, **kwargs
-        )
-
-    @derived_from(np.random.RandomState, skipblocks=1)
-    def noncentral_f(self, dfnum, dfden, nonc, size=None, chunks="auto", **kwargs):
-        return self._wrap(
-            "noncentral_f", dfnum, dfden, nonc, size=size, chunks=chunks, **kwargs
-        )
-
-    @derived_from(np.random.RandomState, skipblocks=1)
-    def normal(self, loc=0.0, scale=1.0, size=None, chunks="auto", **kwargs):
-        return self._wrap("normal", loc, scale, size=size, chunks=chunks, **kwargs)
-
-    @derived_from(np.random.RandomState, skipblocks=1)
-    def pareto(self, a, size=None, chunks="auto", **kwargs):
-        return self._wrap("pareto", a, size=size, chunks=chunks, **kwargs)
-
-    @derived_from(np.random.RandomState, skipblocks=1)
-    def permutation(self, x):
-        from .slicing import shuffle_slice
-
-        if isinstance(x, numbers.Number):
-            x = arange(x, chunks="auto")
-
-        index = np.arange(len(x))
-        self._numpy_state.shuffle(index)
-        return shuffle_slice(x, index)
-
-    @derived_from(np.random.RandomState, skipblocks=1)
-    def poisson(self, lam=1.0, size=None, chunks="auto", **kwargs):
-        return self._wrap("poisson", lam, size=size, chunks=chunks, **kwargs)
-
-    @derived_from(np.random.RandomState, skipblocks=1)
-    def power(self, a, size=None, chunks="auto", **kwargs):
-        return self._wrap("power", a, size=size, chunks=chunks, **kwargs)
-
-    @derived_from(np.random.RandomState, skipblocks=1)
-    def randint(self, low, high=None, size=None, chunks="auto", dtype="l", **kwargs):
-        return self._wrap(
-            "randint", low, high, size=size, chunks=chunks, dtype=dtype, **kwargs
-        )
-
-    @derived_from(np.random.RandomState, skipblocks=1)
-    def random_integers(self, low, high=None, size=None, chunks="auto", **kwargs):
-        return self._wrap(
-            "random_integers", low, high, size=size, chunks=chunks, **kwargs
-        )
-
-    @derived_from(np.random.RandomState, skipblocks=1)
-    def random_sample(self, size=None, chunks="auto", **kwargs):
-        return self._wrap("random_sample", size=size, chunks=chunks, **kwargs)
-
-    random = random_sample
-
-    @derived_from(np.random.RandomState, skipblocks=1)
-    def rayleigh(self, scale=1.0, size=None, chunks="auto", **kwargs):
-        return self._wrap("rayleigh", scale, size=size, chunks=chunks, **kwargs)
-
-    @derived_from(np.random.RandomState, skipblocks=1)
-    def standard_cauchy(self, size=None, chunks="auto", **kwargs):
-        return self._wrap("standard_cauchy", size=size, chunks=chunks, **kwargs)
-
-    @derived_from(np.random.RandomState, skipblocks=1)
-    def standard_exponential(self, size=None, chunks="auto", **kwargs):
-        return self._wrap("standard_exponential", size=size, chunks=chunks, **kwargs)
-
-    @derived_from(np.random.RandomState, skipblocks=1)
-    def standard_gamma(self, shape, size=None, chunks="auto", **kwargs):
-        return self._wrap("standard_gamma", shape, size=size, chunks=chunks, **kwargs)
-
-    @derived_from(np.random.RandomState, skipblocks=1)
-    def standard_normal(self, size=None, chunks="auto", **kwargs):
-        return self._wrap("standard_normal", size=size, chunks=chunks, **kwargs)
-
-    @derived_from(np.random.RandomState, skipblocks=1)
-    def standard_t(self, df, size=None, chunks="auto", **kwargs):
-        return self._wrap("standard_t", df, size=size, chunks=chunks, **kwargs)
-
-    @derived_from(np.random.RandomState, skipblocks=1)
-    def tomaxint(self, size=None, chunks="auto", **kwargs):
-        return self._wrap("tomaxint", size=size, chunks=chunks, **kwargs)
-
-    @derived_from(np.random.RandomState, skipblocks=1)
-    def triangular(self, left, mode, right, size=None, chunks="auto", **kwargs):
-        return self._wrap(
-            "triangular", left, mode, right, size=size, chunks=chunks, **kwargs
-        )
-
-    @derived_from(np.random.RandomState, skipblocks=1)
-    def uniform(self, low=0.0, high=1.0, size=None, chunks="auto", **kwargs):
-        return self._wrap("uniform", low, high, size=size, chunks=chunks, **kwargs)
-
-    @derived_from(np.random.RandomState, skipblocks=1)
-    def vonmises(self, mu, kappa, size=None, chunks="auto", **kwargs):
-        return self._wrap("vonmises", mu, kappa, size=size, chunks=chunks, **kwargs)
-
-    @derived_from(np.random.RandomState, skipblocks=1)
-    def wald(self, mean, scale, size=None, chunks="auto", **kwargs):
-        return self._wrap("wald", mean, scale, size=size, chunks=chunks, **kwargs)
-
-    @derived_from(np.random.RandomState, skipblocks=1)
-    def weibull(self, a, size=None, chunks="auto", **kwargs):
-        return self._wrap("weibull", a, size=size, chunks=chunks, **kwargs)
-
-    @derived_from(np.random.RandomState, skipblocks=1)
-    def zipf(self, a, size=None, chunks="auto", **kwargs):
-        return self._wrap("zipf", a, size=size, chunks=chunks, **kwargs)
-
-
-def _choice(state_data, a, size, replace, p):
-    state = np.random.RandomState(state_data)
-    return state.choice(a, size=size, replace=replace, p=p)
-
-
-def _apply_random(RandomState, funcname, state_data, size, args, kwargs):
-    """Apply RandomState method with seed"""
-    if RandomState is None:
-        RandomState = np.random.RandomState
-    state = RandomState(state_data)
-    func = getattr(state, funcname)
-    return func(*args, size=size, **kwargs)
-
-
-_state = RandomState()
-
-
-seed = _state.seed
-
-
-beta = _state.beta
-binomial = _state.binomial
-chisquare = _state.chisquare
-if hasattr(_state, "choice"):
-    choice = _state.choice
-exponential = _state.exponential
-f = _state.f
-gamma = _state.gamma
-geometric = _state.geometric
-gumbel = _state.gumbel
-hypergeometric = _state.hypergeometric
-laplace = _state.laplace
-logistic = _state.logistic
-lognormal = _state.lognormal
-logseries = _state.logseries
-multinomial = _state.multinomial
-negative_binomial = _state.negative_binomial
-noncentral_chisquare = _state.noncentral_chisquare
-noncentral_f = _state.noncentral_f
-normal = _state.normal
-pareto = _state.pareto
-permutation = _state.permutation
-poisson = _state.poisson
-power = _state.power
-rayleigh = _state.rayleigh
-random_sample = _state.random_sample
-random = random_sample
-randint = _state.randint
-random_integers = _state.random_integers
-triangular = _state.triangular
-uniform = _state.uniform
-vonmises = _state.vonmises
-wald = _state.wald
-weibull = _state.weibull
-zipf = _state.zipf
-
-"""
-Standard distributions
-"""
-
-standard_cauchy = _state.standard_cauchy
-standard_exponential = _state.standard_exponential
-standard_gamma = _state.standard_gamma
-standard_normal = _state.standard_normal
-standard_t = _state.standard_t
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/rechunk.py b/Flaskserver/venv/Lib/site-packages/dask/array/rechunk.py
deleted file mode 100644
index e1da675649b5cb4abc0de497d774282ef30b9495..0000000000000000000000000000000000000000
--- a/Flaskserver/venv/Lib/site-packages/dask/array/rechunk.py
+++ /dev/null
@@ -1,662 +0,0 @@
-"""
-The rechunk module defines:
-    intersect_chunks: a function for
-        converting chunks to new dimensions
-    rechunk: a function to convert the blocks
-        of an existing dask array to new chunks or blockshape
-"""
-import math
-import heapq
-from functools import reduce
-
-from itertools import product, chain, count
-from operator import getitem, add, mul, itemgetter
-
-import numpy as np
-import tlz as toolz
-from tlz import accumulate
-
-from ..base import tokenize
-from ..highlevelgraph import HighLevelGraph
-from ..utils import parse_bytes
-from .core import concatenate3, Array, normalize_chunks
-from .utils import validate_axis
-from .wrap import empty
-from .. import config
-
-
-def cumdims_label(chunks, const):
-    """Internal utility for cumulative sum with label.
-
-    >>> cumdims_label(((5, 3, 3), (2, 2, 1)), 'n')  # doctest: +NORMALIZE_WHITESPACE
-    [(('n', 0), ('n', 5), ('n', 8), ('n', 11)),
-     (('n', 0), ('n', 2), ('n', 4), ('n', 5))]
-    """
-    return [
-        tuple(zip((const,) * (1 + len(bds)), accumulate(add, (0,) + bds)))
-        for bds in chunks
-    ]
-
-
-def _breakpoints(cumold, cumnew):
-    """
-
-    >>> new = cumdims_label(((2, 3), (2, 2, 1)), 'n')
-    >>> old = cumdims_label(((2, 2, 1), (5,)), 'o')
-
-    >>> _breakpoints(new[0], old[0])
-    (('n', 0), ('o', 0), ('n', 2), ('o', 2), ('o', 4), ('n', 5), ('o', 5))
-    >>> _breakpoints(new[1], old[1])
-    (('n', 0), ('o', 0), ('n', 2), ('n', 4), ('n', 5), ('o', 5))
-    """
-    return tuple(sorted(cumold + cumnew, key=itemgetter(1)))
-
-
-def _intersect_1d(breaks):
-    """
-    Internal utility to intersect chunks for 1d after preprocessing.
-
-    >>> new = cumdims_label(((2, 3), (2, 2, 1)), 'n')
-    >>> old = cumdims_label(((2, 2, 1), (5,)), 'o')
-
-    >>> _intersect_1d(_breakpoints(old[0], new[0]))  # doctest: +NORMALIZE_WHITESPACE
-    [[(0, slice(0, 2, None))],
-     [(1, slice(0, 2, None)), (2, slice(0, 1, None))]]
-    >>> _intersect_1d(_breakpoints(old[1], new[1]))  # doctest: +NORMALIZE_WHITESPACE
-    [[(0, slice(0, 2, None))],
-     [(0, slice(2, 4, None))],
-     [(0, slice(4, 5, None))]]
-
-    Parameters
-    ----------
-
-    breaks: list of tuples
-        Each tuple is ('o', 8) or ('n', 8)
-        These are pairs of 'o' old or new 'n'
-        indicator with a corresponding cumulative sum.
-
-    Uses 'o' and 'n' to make new tuples of slices for
-    the new block crosswalk to old blocks.
-    """
-    start = 0
-    last_end = 0
-    old_idx = 0
-    ret = []
-    ret_next = []
-    for idx in range(1, len(breaks)):
-        label, br = breaks[idx]
-        last_label, last_br = breaks[idx - 1]
-        if last_label == "n":
-            if ret_next:
-                ret.append(ret_next)
-                ret_next = []
-        if last_label == "o":
-            start = 0
-        else:
-            start = last_end
-        end = br - last_br + start
-        last_end = end
-        if br == last_br:
-            if label == "o":
-                old_idx += 1
-            continue
-        ret_next.append((old_idx, slice(start, end)))
-        if label == "o":
-            old_idx += 1
-            start = 0
-
-    if ret_next:
-        ret.append(ret_next)
-
-    return ret
-
-
-def _old_to_new(old_chunks, new_chunks):
-    """Helper to build old_chunks to new_chunks.
-
-    Handles missing values, as long as the missing dimension
-    is unchanged.
-
-    Examples
-    --------
-    >>> old = ((10, 10, 10, 10, 10), )
-    >>> new = ((25, 5, 20), )
-    >>> _old_to_new(old, new)  # doctest: +NORMALIZE_WHITESPACE
-    [[[(0, slice(0, 10, None)), (1, slice(0, 10, None)), (2, slice(0, 5, None))],
-      [(2, slice(5, 10, None))],
-      [(3, slice(0, 10, None)), (4, slice(0, 10, None))]]]
-    """
-    old_known = [x for x in old_chunks if not any(math.isnan(y) for y in x)]
-    new_known = [x for x in new_chunks if not any(math.isnan(y) for y in x)]
-
-    n_missing = [sum(math.isnan(y) for y in x) for x in old_chunks]
-    n_missing2 = [sum(math.isnan(y) for y in x) for x in new_chunks]
-
-    cmo = cumdims_label(old_known, "o")
-    cmn = cumdims_label(new_known, "n")
-
-    sums = [sum(o) for o in old_known]
-    sums2 = [sum(n) for n in new_known]
-
-    if not sums == sums2:
-        raise ValueError("Cannot change dimensions from %r to %r" % (sums, sums2))
-    if not n_missing == n_missing2:
-        raise ValueError(
-            "Chunks must be unchanging along unknown dimensions.\n\n"
-            "A possible solution:\n  x.compute_chunk_sizes()"
-        )
-
-    old_to_new = [_intersect_1d(_breakpoints(cm[0], cm[1])) for cm in zip(cmo, cmn)]
-    for idx, missing in enumerate(n_missing):
-        if missing:
-            # Missing dimensions are always unchanged, so old -> new is everything
-            extra = [[(i, slice(0, None))] for i in range(missing)]
-            old_to_new.insert(idx, extra)
-    return old_to_new
-
-
-def intersect_chunks(old_chunks, new_chunks):
-    """
-    Make dask.array slices as intersection of old and new chunks.
-
-    >>> intersections = intersect_chunks(((4, 4), (2,)),
-    ...                                  ((8,), (1, 1)))
-    >>> list(intersections)  # doctest: +NORMALIZE_WHITESPACE
-    [(((0, slice(0, 4, None)), (0, slice(0, 1, None))),
-      ((1, slice(0, 4, None)), (0, slice(0, 1, None)))),
-     (((0, slice(0, 4, None)), (0, slice(1, 2, None))),
-      ((1, slice(0, 4, None)), (0, slice(1, 2, None))))]
-
-    Parameters
-    ----------
-
-    old_chunks : iterable of tuples
-        block sizes along each dimension (convert from old_chunks)
-    new_chunks: iterable of tuples
-        block sizes along each dimension (converts to new_chunks)
-    """
-    old_to_new = _old_to_new(old_chunks, new_chunks)
-
-    cross1 = product(*old_to_new)
-    cross = chain(tuple(product(*cr)) for cr in cross1)
-    return cross
-
-
-def rechunk(x, chunks="auto", threshold=None, block_size_limit=None):
-    """
-    Convert blocks in dask array x for new chunks.
-
-    Parameters
-    ----------
-    x: dask array
-        Array to be rechunked.
-    chunks:  int, tuple, dict or str, optional
-        The new block dimensions to create. -1 indicates the full size of the
-        corresponding dimension. Default is "auto" which automatically
-        determines chunk sizes.
-    threshold: int, optional
-        The graph growth factor under which we don't bother introducing an
-        intermediate step.
-    block_size_limit: int, optional
-        The maximum block size (in bytes) we want to produce
-        Defaults to the configuration value ``array.chunk-size``
-
-    Examples
-    --------
-    >>> import dask.array as da
-    >>> x = da.ones((1000, 1000), chunks=(100, 100))
-
-    Specify uniform chunk sizes with a tuple
-
-    >>> y = x.rechunk((1000, 10))
-
-    Or chunk only specific dimensions with a dictionary
-
-    >>> y = x.rechunk({0: 1000})
-
-    Use the value ``-1`` to specify that you want a single chunk along a
-    dimension or the value ``"auto"`` to specify that dask can freely rechunk a
-    dimension to attain blocks of a uniform block size
-
-    >>> y = x.rechunk({0: -1, 1: 'auto'}, block_size_limit=1e8)
-    """
-    # don't rechunk if array is empty
-    if x.ndim > 0 and all(s == 0 for s in x.shape):
-        return x
-    if isinstance(chunks, dict):
-        chunks = {validate_axis(c, x.ndim): v for c, v in chunks.items()}
-        for i in range(x.ndim):
-            if i not in chunks:
-                chunks[i] = x.chunks[i]
-    if isinstance(chunks, (tuple, list)):
-        chunks = tuple(lc if lc is not None else rc for lc, rc in zip(chunks, x.chunks))
-    chunks = normalize_chunks(
-        chunks, x.shape, limit=block_size_limit, dtype=x.dtype, previous_chunks=x.chunks
-    )
-
-    if chunks == x.chunks:
-        return x
-    ndim = x.ndim
-    if not len(chunks) == ndim:
-        raise ValueError("Provided chunks are not consistent with shape")
-    new_shapes = tuple(map(sum, chunks))
-
-    for new, old in zip(new_shapes, x.shape):
-        if new != old and not math.isnan(old) and not math.isnan(new):
-            raise ValueError("Provided chunks are not consistent with shape")
-
-    steps = plan_rechunk(
-        x.chunks, chunks, x.dtype.itemsize, threshold, block_size_limit
-    )
-    for c in steps:
-        x = _compute_rechunk(x, c)
-
-    return x
-
-
-def _number_of_blocks(chunks):
-    return reduce(mul, map(len, chunks))
-
-
-def _largest_block_size(chunks):
-    return reduce(mul, map(max, chunks))
-
-
-def estimate_graph_size(old_chunks, new_chunks):
-    """Estimate the graph size during a rechunk computation."""
-    # Estimate the number of intermediate blocks that will be produced
-    # (we don't use intersect_chunks() which is much more expensive)
-    crossed_size = reduce(
-        mul,
-        (
-            (len(oc) + len(nc) - 1 if oc != nc else len(oc))
-            for oc, nc in zip(old_chunks, new_chunks)
-        ),
-    )
-    return crossed_size
-
-
-def divide_to_width(desired_chunks, max_width):
-    """Minimally divide the given chunks so as to make the largest chunk
-    width less or equal than *max_width*.
-    """
-    chunks = []
-    for c in desired_chunks:
-        nb_divides = int(np.ceil(c / max_width))
-        for i in range(nb_divides):
-            n = c // (nb_divides - i)
-            chunks.append(n)
-            c -= n
-        assert c == 0
-    return tuple(chunks)
-
-
-def merge_to_number(desired_chunks, max_number):
-    """Minimally merge the given chunks so as to drop the number of
-    chunks below *max_number*, while minimizing the largest width.
-    """
-    if len(desired_chunks) <= max_number:
-        return desired_chunks
-
-    distinct = set(desired_chunks)
-    if len(distinct) == 1:
-        # Fast path for homogeneous target, also ensuring a regular result
-        w = distinct.pop()
-        n = len(desired_chunks)
-        total = n * w
-
-        desired_width = total // max_number
-        width = w * (desired_width // w)
-        adjust = (total - max_number * width) // w
-
-        return (width + w,) * adjust + (width,) * (max_number - adjust)
-
-    desired_width = sum(desired_chunks) // max_number
-    nmerges = len(desired_chunks) - max_number
-
-    heap = [
-        (desired_chunks[i] + desired_chunks[i + 1], i, i + 1)
-        for i in range(len(desired_chunks) - 1)
-    ]
-    heapq.heapify(heap)
-
-    chunks = list(desired_chunks)
-
-    while nmerges > 0:
-        # Find smallest interval to merge
-        width, i, j = heapq.heappop(heap)
-        # If interval was made invalid by another merge, recompute
-        # it, re-insert it and retry.
-        if chunks[j] == 0:
-            j += 1
-            while chunks[j] == 0:
-                j += 1
-            heapq.heappush(heap, (chunks[i] + chunks[j], i, j))
-            continue
-        elif chunks[i] + chunks[j] != width:
-            heapq.heappush(heap, (chunks[i] + chunks[j], i, j))
-            continue
-        # Merge
-        assert chunks[i] != 0
-        chunks[i] = 0  # mark deleted
-        chunks[j] = width
-        nmerges -= 1
-
-    return tuple(filter(None, chunks))
-
-
-def find_merge_rechunk(old_chunks, new_chunks, block_size_limit):
-    """
-    Find an intermediate rechunk that would merge some adjacent blocks
-    together in order to get us nearer the *new_chunks* target, without
-    violating the *block_size_limit* (in number of elements).
-    """
-    ndim = len(old_chunks)
-
-    old_largest_width = [max(c) for c in old_chunks]
-    new_largest_width = [max(c) for c in new_chunks]
-
-    graph_size_effect = {
-        dim: len(nc) / len(oc)
-        for dim, (oc, nc) in enumerate(zip(old_chunks, new_chunks))
-    }
-
-    block_size_effect = {
-        dim: new_largest_width[dim] / (old_largest_width[dim] or 1)
-        for dim in range(ndim)
-    }
-
-    # Our goal is to reduce the number of nodes in the rechunk graph
-    # by merging some adjacent chunks, so consider dimensions where we can
-    # reduce the # of chunks
-    merge_candidates = [dim for dim in range(ndim) if graph_size_effect[dim] <= 1.0]
-
-    # Merging along each dimension reduces the graph size by a certain factor
-    # and increases memory largest block size by a certain factor.
-    # We want to optimize the graph size while staying below the given
-    # block_size_limit.  This is in effect a knapsack problem, except with
-    # multiplicative values and weights.  Just use a greedy algorithm
-    # by trying dimensions in decreasing value / weight order.
-    def key(k):
-        gse = graph_size_effect[k]
-        bse = block_size_effect[k]
-        if bse == 1:
-            bse = 1 + 1e-9
-        return (np.log(gse) / np.log(bse)) if bse > 0 else 0
-
-    sorted_candidates = sorted(merge_candidates, key=key)
-
-    largest_block_size = reduce(mul, old_largest_width)
-
-    chunks = list(old_chunks)
-    memory_limit_hit = False
-
-    for dim in sorted_candidates:
-        # Examine this dimension for possible graph reduction
-        new_largest_block_size = (
-            largest_block_size * new_largest_width[dim] // (old_largest_width[dim] or 1)
-        )
-        if new_largest_block_size <= block_size_limit:
-            # Full replacement by new chunks is possible
-            chunks[dim] = new_chunks[dim]
-            largest_block_size = new_largest_block_size
-        else:
-            # Try a partial rechunk, dividing the new chunks into
-            # smaller pieces
-            largest_width = old_largest_width[dim]
-            chunk_limit = int(block_size_limit * largest_width / largest_block_size)
-            c = divide_to_width(new_chunks[dim], chunk_limit)
-            if len(c) <= len(old_chunks[dim]):
-                # We manage to reduce the number of blocks, so do it
-                chunks[dim] = c
-                largest_block_size = largest_block_size * max(c) // largest_width
-
-            memory_limit_hit = True
-
-    assert largest_block_size == _largest_block_size(chunks)
-    assert largest_block_size <= block_size_limit
-    return tuple(chunks), memory_limit_hit
-
-
-def find_split_rechunk(old_chunks, new_chunks, graph_size_limit):
-    """
-    Find an intermediate rechunk that would split some chunks to
-    get us nearer *new_chunks*, without violating the *graph_size_limit*.
-    """
-    ndim = len(old_chunks)
-
-    chunks = list(old_chunks)
-
-    for dim in range(ndim):
-        graph_size = estimate_graph_size(chunks, new_chunks)
-        if graph_size > graph_size_limit:
-            break
-        if len(old_chunks[dim]) > len(new_chunks[dim]):
-            # It's not interesting to split
-            continue
-        # Merge the new chunks so as to stay within the graph size budget
-        max_number = int(len(old_chunks[dim]) * graph_size_limit / graph_size)
-        c = merge_to_number(new_chunks[dim], max_number)
-        assert len(c) <= max_number
-        # Consider the merge successful if its result has a greater length
-        # and smaller max width than the old chunks
-        if len(c) >= len(old_chunks[dim]) and max(c) <= max(old_chunks[dim]):
-            chunks[dim] = c
-
-    return tuple(chunks)
-
-
-def plan_rechunk(
-    old_chunks, new_chunks, itemsize, threshold=None, block_size_limit=None
-):
-    """Plan an iterative rechunking from *old_chunks* to *new_chunks*.
-    The plan aims to minimize the rechunk graph size.
-
-    Parameters
-    ----------
-    itemsize: int
-        The item size of the array
-    threshold: int
-        The graph growth factor under which we don't bother
-        introducing an intermediate step
-    block_size_limit: int
-        The maximum block size (in bytes) we want to produce during an
-        intermediate step
-
-    Notes
-    -----
-    No intermediate steps will be planned if any dimension of ``old_chunks``
-    is unknown.
-    """
-    threshold = threshold or config.get("array.rechunk-threshold")
-    block_size_limit = block_size_limit or config.get("array.chunk-size")
-    if isinstance(block_size_limit, str):
-        block_size_limit = parse_bytes(block_size_limit)
-
-    ndim = len(new_chunks)
-    steps = []
-    has_nans = [any(math.isnan(y) for y in x) for x in old_chunks]
-
-    if ndim <= 1 or not all(new_chunks) or any(has_nans):
-        # Trivial array / unknown dim => no need / ability for an intermediate
-        return steps + [new_chunks]
-
-    # Make it a number ef elements
-    block_size_limit /= itemsize
-
-    # Fix block_size_limit if too small for either old_chunks or new_chunks
-    largest_old_block = _largest_block_size(old_chunks)
-    largest_new_block = _largest_block_size(new_chunks)
-    block_size_limit = max([block_size_limit, largest_old_block, largest_new_block])
-
-    # The graph size above which to optimize
-    graph_size_threshold = threshold * (
-        _number_of_blocks(old_chunks) + _number_of_blocks(new_chunks)
-    )
-
-    current_chunks = old_chunks
-    first_pass = True
-
-    while True:
-        graph_size = estimate_graph_size(current_chunks, new_chunks)
-        if graph_size < graph_size_threshold:
-            break
-
-        if first_pass:
-            chunks = current_chunks
-        else:
-            # We hit the block_size_limit in a previous merge pass =>
-            # accept a significant increase in graph size in exchange for
-            # 1) getting nearer the goal 2) reducing the largest block size
-            # to make place for the following merge.
-            # To see this pass in action, make the block_size_limit very small.
-            chunks = find_split_rechunk(
-                current_chunks, new_chunks, graph_size * threshold
-            )
-        chunks, memory_limit_hit = find_merge_rechunk(
-            chunks, new_chunks, block_size_limit
-        )
-        if (chunks == current_chunks and not first_pass) or chunks == new_chunks:
-            break
-        if chunks != current_chunks:
-            steps.append(chunks)
-        current_chunks = chunks
-        if not memory_limit_hit:
-            break
-        first_pass = False
-
-    return steps + [new_chunks]
-
-
-def _compute_rechunk(x, chunks):
-    """Compute the rechunk of *x* to the given *chunks*."""
-    if x.size == 0:
-        # Special case for empty array, as the algorithm below does not behave correctly
-        return empty(x.shape, chunks=chunks, dtype=x.dtype)
-
-    ndim = x.ndim
-    crossed = intersect_chunks(x.chunks, chunks)
-    x2 = dict()
-    intermediates = dict()
-    token = tokenize(x, chunks)
-    merge_name = "rechunk-merge-" + token
-    split_name = "rechunk-split-" + token
-    split_name_suffixes = count()
-
-    # Pre-allocate old block references, to allow re-use and reduce the
-    # graph's memory footprint a bit.
-    old_blocks = np.empty([len(c) for c in x.chunks], dtype="O")
-    for index in np.ndindex(old_blocks.shape):
-        old_blocks[index] = (x.name,) + index
-
-    # Iterate over all new blocks
-    new_index = product(*(range(len(c)) for c in chunks))
-
-    for new_idx, cross1 in zip(new_index, crossed):
-        key = (merge_name,) + new_idx
-        old_block_indices = [[cr[i][0] for cr in cross1] for i in range(ndim)]
-        subdims1 = [len(set(old_block_indices[i])) for i in range(ndim)]
-
-        rec_cat_arg = np.empty(subdims1, dtype="O")
-        rec_cat_arg_flat = rec_cat_arg.flat
-
-        # Iterate over the old blocks required to build the new block
-        for rec_cat_index, ind_slices in enumerate(cross1):
-            old_block_index, slices = zip(*ind_slices)
-            name = (split_name, next(split_name_suffixes))
-            old_index = old_blocks[old_block_index][1:]
-            if all(
-                slc.start == 0 and slc.stop == x.chunks[i][ind]
-                for i, (slc, ind) in enumerate(zip(slices, old_index))
-            ):
-                rec_cat_arg_flat[rec_cat_index] = old_blocks[old_block_index]
-            else:
-                intermediates[name] = (getitem, old_blocks[old_block_index], slices)
-                rec_cat_arg_flat[rec_cat_index] = name
-
-        assert rec_cat_index == rec_cat_arg.size - 1
-
-        # New block is formed by concatenation of sliced old blocks
-        if all(d == 1 for d in rec_cat_arg.shape):
-            x2[key] = rec_cat_arg.flat[0]
-        else:
-            x2[key] = (concatenate3, rec_cat_arg.tolist())
-
-    del old_blocks, new_index
-
-    layer = toolz.merge(x2, intermediates)
-    graph = HighLevelGraph.from_collections(merge_name, layer, dependencies=[x])
-    return Array(graph, merge_name, chunks, meta=x)
-
-
-class _PrettyBlocks(object):
-    def __init__(self, blocks):
-        self.blocks = blocks
-
-    def __str__(self):
-        runs = []
-        run = []
-        repeats = 0
-        for c in self.blocks:
-            if run and run[-1] == c:
-                if repeats == 0 and len(run) > 1:
-                    runs.append((None, run[:-1]))
-                    run = run[-1:]
-                repeats += 1
-            else:
-                if repeats > 0:
-                    assert len(run) == 1
-                    runs.append((repeats + 1, run[-1]))
-                    run = []
-                    repeats = 0
-                run.append(c)
-        if run:
-            if repeats == 0:
-                runs.append((None, run))
-            else:
-                assert len(run) == 1
-                runs.append((repeats + 1, run[-1]))
-
-        parts = []
-        for repeats, run in runs:
-            if repeats is None:
-                parts.append(str(run))
-            else:
-                parts.append("%d*[%s]" % (repeats, run))
-        return " | ".join(parts)
-
-    __repr__ = __str__
-
-
-def format_blocks(blocks):
-    """
-    Pretty-format *blocks*.
-
-    >>> format_blocks((10, 10, 10))
-    3*[10]
-    >>> format_blocks((2, 3, 4))
-    [2, 3, 4]
-    >>> format_blocks((10, 10, 5, 6, 2, 2, 2, 7))
-    2*[10] | [5, 6] | 3*[2] | [7]
-    """
-    assert isinstance(blocks, tuple) and all(
-        isinstance(x, int) or math.isnan(x) for x in blocks
-    )
-    return _PrettyBlocks(blocks)
-
-
-def format_chunks(chunks):
-    """
-    >>> format_chunks((10 * (3,), 3 * (10,)))
-    (10*[3], 3*[10])
-    """
-    assert isinstance(chunks, tuple)
-    return tuple(format_blocks(c) for c in chunks)
-
-
-def format_plan(plan):
-    """
-    >>> format_plan([((10, 10, 10), (15, 15)), ((30,), (10, 10, 10))])
-    [(3*[10], 2*[15]), ([30], 3*[10])]
-    """
-    return [format_chunks(c) for c in plan]
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/reductions.py b/Flaskserver/venv/Lib/site-packages/dask/array/reductions.py
deleted file mode 100644
index 5138702f499be2f6e06736ccb1ddd75b7295c108..0000000000000000000000000000000000000000
--- a/Flaskserver/venv/Lib/site-packages/dask/array/reductions.py
+++ /dev/null
@@ -1,1345 +0,0 @@
-import builtins
-from collections.abc import Iterable
-import operator
-from functools import partial
-from itertools import product, repeat
-from math import factorial, log, ceil
-
-import numpy as np
-from numbers import Integral, Number
-
-from tlz import compose, partition_all, get, accumulate, pluck
-
-from . import chunk
-from .core import _concatenate2, Array, handle_out, implements
-from .blockwise import blockwise
-from ..blockwise import lol_tuples
-from .creation import arange, diagonal
-from .utils import full_like_safe, validate_axis, compute_meta, is_arraylike
-from .wrap import zeros, ones
-from .numpy_compat import ma_divide, divide as np_divide
-from ..base import tokenize
-from ..highlevelgraph import HighLevelGraph
-from ..utils import ignoring, funcname, Dispatch, deepmap, getargspec, derived_from
-from .. import config
-
-# Generic functions to support chunks of different types
-empty_lookup = Dispatch("empty")
-empty_lookup.register((object, np.ndarray), np.empty)
-empty_lookup.register(np.ma.masked_array, np.ma.empty)
-divide_lookup = Dispatch("divide")
-divide_lookup.register((object, np.ndarray), np_divide)
-divide_lookup.register(np.ma.masked_array, ma_divide)
-
-
-def divide(a, b, dtype=None):
-    key = lambda x: getattr(x, "__array_priority__", float("-inf"))
-    f = divide_lookup.dispatch(type(builtins.max(a, b, key=key)))
-    return f(a, b, dtype=dtype)
-
-
-def reduction(
-    x,
-    chunk,
-    aggregate,
-    axis=None,
-    keepdims=False,
-    dtype=None,
-    split_every=None,
-    combine=None,
-    name=None,
-    out=None,
-    concatenate=True,
-    output_size=1,
-    meta=None,
-):
-    """General version of reductions
-
-    Parameters
-    ----------
-    x: Array
-        Data being reduced along one or more axes
-    chunk: callable(x_chunk, axis, keepdims)
-        First function to be executed when resolving the dask graph.
-        This function is applied in parallel to all original chunks of x.
-        See below for function parameters.
-    combine: callable(x_chunk, axis, keepdims), optional
-        Function used for intermediate recursive aggregation (see
-        split_every below). If omitted, it defaults to aggregate.
-        If the reduction can be performed in less than 3 steps, it will not
-        be invoked at all.
-    aggregate: callable(x_chunk, axis, keepdims)
-        Last function to be executed when resolving the dask graph,
-        producing the final output. It is always invoked, even when the reduced
-        Array counts a single chunk along the reduced axes.
-    axis: int or sequence of ints, optional
-        Axis or axes to aggregate upon. If omitted, aggregate along all axes.
-    keepdims: boolean, optional
-        Whether the reduction function should preserve the reduced axes,
-        leaving them at size ``output_size``, or remove them.
-    dtype: np.dtype, optional
-        Force output dtype. Defaults to x.dtype if omitted.
-    split_every: int >= 2 or dict(axis: int), optional
-        Determines the depth of the recursive aggregation. If set to or more
-        than the number of input chunks, the aggregation will be performed in
-        two steps, one ``chunk`` function per input chunk and a single
-        ``aggregate`` function at the end. If set to less than that, an
-        intermediate ``combine`` function will be used, so that any one
-        ``combine`` or ``aggregate`` function has no more than ``split_every``
-        inputs. The depth of the aggregation graph will be
-        :math:`log_{split_every}(input chunks along reduced axes)`. Setting to
-        a low value can reduce cache size and network transfers, at the cost of
-        more CPU and a larger dask graph.
-
-        Omit to let dask heuristically decide a good default. A default can
-        also be set globally with the ``split_every`` key in
-        :mod:`dask.config`.
-    name: str, optional
-        Prefix of the keys of the intermediate and output nodes. If omitted it
-        defaults to the function names.
-    out: Array, optional
-        Another dask array whose contents will be replaced. Omit to create a
-        new one. Note that, unlike in numpy, this setting gives no performance
-        benefits whatsoever, but can still be useful  if one needs to preserve
-        the references to a previously existing Array.
-    concatenate: bool, optional
-        If True (the default), the outputs of the ``chunk``/``combine``
-        functions are concatenated into a single np.array before being passed
-        to the ``combine``/``aggregate`` functions. If False, the input of
-        ``combine`` and ``aggregate`` will be either a list of the raw outputs
-        of the previous step or a single output, and the function will have to
-        concatenate it itself. It can be useful to set this to False if the
-        chunk and/or combine steps do not produce np.arrays.
-    output_size: int >= 1, optional
-        Size of the output of the ``aggregate`` function along the reduced
-        axes. Ignored if keepdims is False.
-
-    Returns
-    -------
-    dask array
-
-    **Function Parameters**
-
-    x_chunk: numpy.ndarray
-        Individual input chunk. For ``chunk`` functions, it is one of the
-        original chunks of x. For ``combine`` and ``aggregate`` functions, it's
-        the concatenation of the outputs produced by the previous ``chunk`` or
-        ``combine`` functions. If concatenate=False, it's a list of the raw
-        outputs from the previous functions.
-    axis: tuple
-        Normalized list of axes to reduce upon, e.g. ``(0, )``
-        Scalar, negative, and None axes have been normalized away.
-        Note that some numpy reduction functions cannot reduce along multiple
-        axes at once and strictly require an int in input. Such functions have
-        to be wrapped to cope.
-    keepdims: bool
-        Whether the reduction function should preserve the reduced axes or
-        remove them.
-    """
-    if axis is None:
-        axis = tuple(range(x.ndim))
-    if isinstance(axis, Integral):
-        axis = (axis,)
-    axis = validate_axis(axis, x.ndim)
-
-    if dtype is None:
-        raise ValueError("Must specify dtype")
-    if "dtype" in getargspec(chunk).args:
-        chunk = partial(chunk, dtype=dtype)
-    if "dtype" in getargspec(aggregate).args:
-        aggregate = partial(aggregate, dtype=dtype)
-
-    # Map chunk across all blocks
-    inds = tuple(range(x.ndim))
-    # The dtype of `tmp` doesn't actually matter, and may be incorrect.
-    tmp = blockwise(
-        chunk, inds, x, inds, axis=axis, keepdims=True, token=name, dtype=dtype or float
-    )
-    tmp._chunks = tuple(
-        (output_size,) * len(c) if i in axis else c for i, c in enumerate(tmp.chunks)
-    )
-
-    if meta is None and hasattr(x, "_meta"):
-        try:
-            reduced_meta = compute_meta(
-                chunk, x.dtype, x._meta, axis=axis, keepdims=True, computing_meta=True
-            )
-        except TypeError:
-            reduced_meta = compute_meta(
-                chunk, x.dtype, x._meta, axis=axis, keepdims=True
-            )
-        except ValueError:
-            pass
-    else:
-        reduced_meta = None
-
-    result = _tree_reduce(
-        tmp,
-        aggregate,
-        axis,
-        keepdims,
-        dtype,
-        split_every,
-        combine,
-        name=name,
-        concatenate=concatenate,
-        reduced_meta=reduced_meta,
-    )
-    if keepdims and output_size != 1:
-        result._chunks = tuple(
-            (output_size,) if i in axis else c for i, c in enumerate(tmp.chunks)
-        )
-    if meta is not None:
-        result._meta = meta
-    return handle_out(out, result)
-
-
-def _tree_reduce(
-    x,
-    aggregate,
-    axis,
-    keepdims,
-    dtype,
-    split_every=None,
-    combine=None,
-    name=None,
-    concatenate=True,
-    reduced_meta=None,
-):
-    """Perform the tree reduction step of a reduction.
-
-    Lower level, users should use ``reduction`` or ``arg_reduction`` directly.
-    """
-    # Normalize split_every
-    split_every = split_every or config.get("split_every", 4)
-    if isinstance(split_every, dict):
-        split_every = dict((k, split_every.get(k, 2)) for k in axis)
-    elif isinstance(split_every, Integral):
-        n = builtins.max(int(split_every ** (1 / (len(axis) or 1))), 2)
-        split_every = dict.fromkeys(axis, n)
-    else:
-        raise ValueError("split_every must be a int or a dict")
-
-    # Reduce across intermediates
-    depth = 1
-    for i, n in enumerate(x.numblocks):
-        if i in split_every and split_every[i] != 1:
-            depth = int(builtins.max(depth, ceil(log(n, split_every[i]))))
-    func = partial(combine or aggregate, axis=axis, keepdims=True)
-    if concatenate:
-        func = compose(func, partial(_concatenate2, axes=axis))
-    for i in range(depth - 1):
-        x = partial_reduce(
-            func,
-            x,
-            split_every,
-            True,
-            dtype=dtype,
-            name=(name or funcname(combine or aggregate)) + "-partial",
-            reduced_meta=reduced_meta,
-        )
-    func = partial(aggregate, axis=axis, keepdims=keepdims)
-    if concatenate:
-        func = compose(func, partial(_concatenate2, axes=axis))
-    return partial_reduce(
-        func,
-        x,
-        split_every,
-        keepdims=keepdims,
-        dtype=dtype,
-        name=(name or funcname(aggregate)) + "-aggregate",
-        reduced_meta=reduced_meta,
-    )
-
-
-def partial_reduce(
-    func, x, split_every, keepdims=False, dtype=None, name=None, reduced_meta=None
-):
-    """Partial reduction across multiple axes.
-
-    Parameters
-    ----------
-    func : function
-    x : Array
-    split_every : dict
-        Maximum reduction block sizes in each dimension.
-
-    Examples
-    --------
-    Reduce across axis 0 and 2, merging a maximum of 1 block in the 0th
-    dimension, and 3 blocks in the 2nd dimension:
-
-    >>> partial_reduce(np.min, x, {0: 1, 2: 3})    # doctest: +SKIP
-    """
-    name = (
-        (name or funcname(func)) + "-" + tokenize(func, x, split_every, keepdims, dtype)
-    )
-    parts = [
-        list(partition_all(split_every.get(i, 1), range(n)))
-        for (i, n) in enumerate(x.numblocks)
-    ]
-    keys = product(*map(range, map(len, parts)))
-    out_chunks = [
-        tuple(1 for p in partition_all(split_every[i], c)) if i in split_every else c
-        for (i, c) in enumerate(x.chunks)
-    ]
-    if not keepdims:
-        out_axis = [i for i in range(x.ndim) if i not in split_every]
-        getter = lambda k: get(out_axis, k)
-        keys = map(getter, keys)
-        out_chunks = list(getter(out_chunks))
-    dsk = {}
-    for k, p in zip(keys, product(*parts)):
-        decided = dict((i, j[0]) for (i, j) in enumerate(p) if len(j) == 1)
-        dummy = dict(i for i in enumerate(p) if i[0] not in decided)
-        g = lol_tuples((x.name,), range(x.ndim), decided, dummy)
-        dsk[(name,) + k] = (func, g)
-    graph = HighLevelGraph.from_collections(name, dsk, dependencies=[x])
-
-    meta = x._meta
-    if reduced_meta is not None:
-        try:
-            meta = func(reduced_meta, computing_meta=True)
-        # no meta keyword argument exists for func, and it isn't required
-        except TypeError:
-            meta = func(reduced_meta)
-        # when no work can be computed on the empty array (e.g., func is a ufunc)
-        except ValueError:
-            pass
-
-    # some functions can't compute empty arrays (those for which reduced_meta
-    # fall into the ValueError exception) and we have to rely on reshaping
-    # the array according to len(out_chunks)
-    if is_arraylike(meta) and meta.ndim != len(out_chunks):
-        if len(out_chunks) == 0:
-            meta = meta.sum()
-        else:
-            meta = meta.reshape((0,) * len(out_chunks))
-
-    if np.isscalar(meta):
-        return Array(graph, name, out_chunks, dtype=dtype)
-    else:
-        with ignoring(AttributeError):
-            meta = meta.astype(dtype)
-        return Array(graph, name, out_chunks, meta=meta)
-
-
-@derived_from(np)
-def sum(a, axis=None, dtype=None, keepdims=False, split_every=None, out=None):
-    if dtype is None:
-        dtype = getattr(np.zeros(1, dtype=a.dtype).sum(), "dtype", object)
-    result = reduction(
-        a,
-        chunk.sum,
-        chunk.sum,
-        axis=axis,
-        keepdims=keepdims,
-        dtype=dtype,
-        split_every=split_every,
-        out=out,
-    )
-    return result
-
-
-@derived_from(np)
-def prod(a, axis=None, dtype=None, keepdims=False, split_every=None, out=None):
-    if dtype is not None:
-        dt = dtype
-    else:
-        dt = getattr(np.empty((1,), dtype=a.dtype).prod(), "dtype", object)
-    return reduction(
-        a,
-        chunk.prod,
-        chunk.prod,
-        axis=axis,
-        keepdims=keepdims,
-        dtype=dt,
-        split_every=split_every,
-        out=out,
-    )
-
-
-@implements(np.min, np.amin)
-@derived_from(np)
-def min(a, axis=None, keepdims=False, split_every=None, out=None):
-    return reduction(
-        a,
-        chunk.min,
-        chunk.min,
-        axis=axis,
-        keepdims=keepdims,
-        dtype=a.dtype,
-        split_every=split_every,
-        out=out,
-    )
-
-
-@implements(np.max, np.amax)
-@derived_from(np)
-def max(a, axis=None, keepdims=False, split_every=None, out=None):
-    return reduction(
-        a,
-        chunk.max,
-        chunk.max,
-        axis=axis,
-        keepdims=keepdims,
-        dtype=a.dtype,
-        split_every=split_every,
-        out=out,
-    )
-
-
-@derived_from(np)
-def any(a, axis=None, keepdims=False, split_every=None, out=None):
-    return reduction(
-        a,
-        chunk.any,
-        chunk.any,
-        axis=axis,
-        keepdims=keepdims,
-        dtype="bool",
-        split_every=split_every,
-        out=out,
-    )
-
-
-@derived_from(np)
-def all(a, axis=None, keepdims=False, split_every=None, out=None):
-    return reduction(
-        a,
-        chunk.all,
-        chunk.all,
-        axis=axis,
-        keepdims=keepdims,
-        dtype="bool",
-        split_every=split_every,
-        out=out,
-    )
-
-
-@derived_from(np)
-def nansum(a, axis=None, dtype=None, keepdims=False, split_every=None, out=None):
-    if dtype is not None:
-        dt = dtype
-    else:
-        dt = getattr(chunk.nansum(np.empty((1,), dtype=a.dtype)), "dtype", object)
-    return reduction(
-        a,
-        chunk.nansum,
-        chunk.sum,
-        axis=axis,
-        keepdims=keepdims,
-        dtype=dt,
-        split_every=split_every,
-        out=out,
-    )
-
-
-with ignoring(AttributeError):
-
-    @derived_from(np)
-    def nanprod(a, axis=None, dtype=None, keepdims=False, split_every=None, out=None):
-        if dtype is not None:
-            dt = dtype
-        else:
-            dt = getattr(chunk.nansum(np.empty((1,), dtype=a.dtype)), "dtype", object)
-        return reduction(
-            a,
-            chunk.nanprod,
-            chunk.prod,
-            axis=axis,
-            keepdims=keepdims,
-            dtype=dt,
-            split_every=split_every,
-            out=out,
-        )
-
-    @derived_from(np)
-    def nancumsum(x, axis, dtype=None, out=None):
-        return cumreduction(chunk.nancumsum, operator.add, 0, x, axis, dtype, out=out)
-
-    @derived_from(np)
-    def nancumprod(x, axis, dtype=None, out=None):
-        return cumreduction(chunk.nancumprod, operator.mul, 1, x, axis, dtype, out=out)
-
-
-@derived_from(np)
-def nanmin(a, axis=None, keepdims=False, split_every=None, out=None):
-    return reduction(
-        a,
-        chunk.nanmin,
-        chunk.nanmin,
-        axis=axis,
-        keepdims=keepdims,
-        dtype=a.dtype,
-        split_every=split_every,
-        out=out,
-    )
-
-
-@derived_from(np)
-def nanmax(a, axis=None, keepdims=False, split_every=None, out=None):
-    return reduction(
-        a,
-        chunk.nanmax,
-        chunk.nanmax,
-        axis=axis,
-        keepdims=keepdims,
-        dtype=a.dtype,
-        split_every=split_every,
-        out=out,
-    )
-
-
-def numel(x, **kwargs):
-    """ A reduction to count the number of elements """
-
-    if hasattr(x, "mask"):
-        return chunk.sum(np.ones_like(x), **kwargs)
-
-    shape = x.shape
-    keepdims = kwargs.get("keepdims", False)
-    axis = kwargs.get("axis", None)
-    dtype = kwargs.get("dtype", np.float64)
-
-    if axis is None:
-        prod = np.prod(shape, dtype=dtype)
-        return (
-            full_like_safe(x, prod, shape=(1,) * len(shape), dtype=dtype)
-            if keepdims is True
-            else prod
-        )
-
-    if not isinstance(axis, tuple or list):
-        axis = [axis]
-
-    prod = np.prod([shape[dim] for dim in axis])
-    if keepdims is True:
-        new_shape = tuple(
-            shape[dim] if dim not in axis else 1 for dim in range(len(shape))
-        )
-    else:
-        new_shape = tuple(shape[dim] for dim in range(len(shape)) if dim not in axis)
-    return full_like_safe(x, prod, shape=new_shape, dtype=dtype)
-
-
-def nannumel(x, **kwargs):
-    """ A reduction to count the number of elements """
-    return chunk.sum(~(np.isnan(x)), **kwargs)
-
-
-def mean_chunk(
-    x, sum=chunk.sum, numel=numel, dtype="f8", computing_meta=False, **kwargs
-):
-    if computing_meta:
-        return x
-    n = numel(x, dtype=dtype, **kwargs)
-
-    total = sum(x, dtype=dtype, **kwargs)
-
-    return {"n": n, "total": total}
-
-
-def mean_combine(
-    pairs,
-    sum=chunk.sum,
-    numel=numel,
-    dtype="f8",
-    axis=None,
-    computing_meta=False,
-    **kwargs
-):
-    if not isinstance(pairs, list):
-        pairs = [pairs]
-
-    ns = deepmap(lambda pair: pair["n"], pairs) if not computing_meta else pairs
-    n = _concatenate2(ns, axes=axis).sum(axis=axis, **kwargs)
-
-    if computing_meta:
-        return n
-
-    totals = deepmap(lambda pair: pair["total"], pairs)
-    total = _concatenate2(totals, axes=axis).sum(axis=axis, **kwargs)
-
-    return {"n": n, "total": total}
-
-
-def mean_agg(pairs, dtype="f8", axis=None, computing_meta=False, **kwargs):
-    ns = deepmap(lambda pair: pair["n"], pairs) if not computing_meta else pairs
-    n = _concatenate2(ns, axes=axis)
-    n = np.sum(n, axis=axis, dtype=dtype, **kwargs)
-
-    if computing_meta:
-        return n
-
-    totals = deepmap(lambda pair: pair["total"], pairs)
-    total = _concatenate2(totals, axes=axis).sum(axis=axis, dtype=dtype, **kwargs)
-
-    return divide(total, n, dtype=dtype)
-
-
-@derived_from(np)
-def mean(a, axis=None, dtype=None, keepdims=False, split_every=None, out=None):
-    if dtype is not None:
-        dt = dtype
-    else:
-        dt = getattr(np.mean(np.empty(shape=(1,), dtype=a.dtype)), "dtype", object)
-    return reduction(
-        a,
-        mean_chunk,
-        mean_agg,
-        axis=axis,
-        keepdims=keepdims,
-        dtype=dt,
-        split_every=split_every,
-        combine=mean_combine,
-        out=out,
-        concatenate=False,
-    )
-
-
-@derived_from(np)
-def nanmean(a, axis=None, dtype=None, keepdims=False, split_every=None, out=None):
-    if dtype is not None:
-        dt = dtype
-    else:
-        dt = getattr(np.mean(np.empty(shape=(1,), dtype=a.dtype)), "dtype", object)
-    return reduction(
-        a,
-        partial(mean_chunk, sum=chunk.nansum, numel=nannumel),
-        mean_agg,
-        axis=axis,
-        keepdims=keepdims,
-        dtype=dt,
-        split_every=split_every,
-        out=out,
-        concatenate=False,
-        combine=partial(mean_combine, sum=chunk.nansum, numel=nannumel),
-    )
-
-
-with ignoring(AttributeError):
-    nanmean = derived_from(np)(nanmean)
-
-
-def moment_chunk(
-    A, order=2, sum=chunk.sum, numel=numel, dtype="f8", computing_meta=False, **kwargs
-):
-    if computing_meta:
-        return A
-    n = numel(A, **kwargs)
-
-    n = n.astype(np.int64)
-    total = sum(A, dtype=dtype, **kwargs)
-    with np.errstate(divide="ignore", invalid="ignore"):
-        u = total / n
-    xs = [sum((A - u) ** i, dtype=dtype, **kwargs) for i in range(2, order + 1)]
-    M = np.stack(xs, axis=-1)
-    return {"total": total, "n": n, "M": M}
-
-
-def _moment_helper(Ms, ns, inner_term, order, sum, axis, kwargs):
-    M = Ms[..., order - 2].sum(axis=axis, **kwargs) + sum(
-        ns * inner_term ** order, axis=axis, **kwargs
-    )
-    for k in range(1, order - 1):
-        coeff = factorial(order) / (factorial(k) * factorial(order - k))
-        M += coeff * sum(Ms[..., order - k - 2] * inner_term ** k, axis=axis, **kwargs)
-    return M
-
-
-def moment_combine(
-    pairs,
-    order=2,
-    ddof=0,
-    dtype="f8",
-    sum=np.sum,
-    axis=None,
-    computing_meta=False,
-    **kwargs
-):
-    if not isinstance(pairs, list):
-        pairs = [pairs]
-
-    kwargs["dtype"] = dtype
-    kwargs["keepdims"] = True
-
-    ns = deepmap(lambda pair: pair["n"], pairs) if not computing_meta else pairs
-    ns = _concatenate2(ns, axes=axis)
-    n = ns.sum(axis=axis, **kwargs)
-
-    if computing_meta:
-        return n
-
-    totals = _concatenate2(deepmap(lambda pair: pair["total"], pairs), axes=axis)
-    Ms = _concatenate2(deepmap(lambda pair: pair["M"], pairs), axes=axis)
-
-    total = totals.sum(axis=axis, **kwargs)
-    mu = divide(total, n, dtype=dtype)
-    inner_term = divide(totals, ns, dtype=dtype) - mu
-
-    xs = [
-        _moment_helper(Ms, ns, inner_term, o, sum, axis, kwargs)
-        for o in range(2, order + 1)
-    ]
-    M = np.stack(xs, axis=-1)
-    return {"total": total, "n": n, "M": M}
-
-
-def moment_agg(
-    pairs,
-    order=2,
-    ddof=0,
-    dtype="f8",
-    sum=np.sum,
-    axis=None,
-    computing_meta=False,
-    **kwargs
-):
-    if not isinstance(pairs, list):
-        pairs = [pairs]
-
-    kwargs["dtype"] = dtype
-    # To properly handle ndarrays, the original dimensions need to be kept for
-    # part of the calculation.
-    keepdim_kw = kwargs.copy()
-    keepdim_kw["keepdims"] = True
-
-    ns = deepmap(lambda pair: pair["n"], pairs) if not computing_meta else pairs
-    ns = _concatenate2(ns, axes=axis)
-    n = ns.sum(axis=axis, **keepdim_kw)
-
-    if computing_meta:
-        return n
-
-    totals = _concatenate2(deepmap(lambda pair: pair["total"], pairs), axes=axis)
-    Ms = _concatenate2(deepmap(lambda pair: pair["M"], pairs), axes=axis)
-
-    mu = divide(totals.sum(axis=axis, **keepdim_kw), n, dtype=dtype)
-    inner_term = divide(totals, ns, dtype=dtype) - mu
-
-    M = _moment_helper(Ms, ns, inner_term, order, sum, axis, kwargs)
-
-    denominator = n.sum(axis=axis, **kwargs) - ddof
-
-    # taking care of the edge case with empty or all-nans array with ddof > 0
-    if isinstance(denominator, Number):
-        if denominator < 0:
-            denominator = np.nan
-    elif denominator is not np.ma.masked:
-        denominator[denominator < 0] = np.nan
-
-    return divide(M, denominator, dtype=dtype)
-
-
-def moment(
-    a, order, axis=None, dtype=None, keepdims=False, ddof=0, split_every=None, out=None
-):
-    if not isinstance(order, Integral) or order < 0:
-        raise ValueError("Order must be an integer >= 0")
-
-    if order < 2:
-        reduced = a.sum(axis=axis)  # get reduced shape and chunks
-        if order == 0:
-            # When order equals 0, the result is 1, by definition.
-            return ones(reduced.shape, chunks=reduced.chunks, dtype="f8")
-        # By definition the first order about the mean is 0.
-        return zeros(reduced.shape, chunks=reduced.chunks, dtype="f8")
-
-    if dtype is not None:
-        dt = dtype
-    else:
-        dt = getattr(np.var(np.ones(shape=(1,), dtype=a.dtype)), "dtype", object)
-    return reduction(
-        a,
-        partial(moment_chunk, order=order),
-        partial(moment_agg, order=order, ddof=ddof),
-        axis=axis,
-        keepdims=keepdims,
-        dtype=dt,
-        split_every=split_every,
-        out=out,
-        concatenate=False,
-        combine=partial(moment_combine, order=order),
-    )
-
-
-@derived_from(np)
-def var(a, axis=None, dtype=None, keepdims=False, ddof=0, split_every=None, out=None):
-    if dtype is not None:
-        dt = dtype
-    else:
-        dt = getattr(np.var(np.ones(shape=(1,), dtype=a.dtype)), "dtype", object)
-    return reduction(
-        a,
-        moment_chunk,
-        partial(moment_agg, ddof=ddof),
-        axis=axis,
-        keepdims=keepdims,
-        dtype=dt,
-        split_every=split_every,
-        combine=moment_combine,
-        name="var",
-        out=out,
-        concatenate=False,
-    )
-
-
-@derived_from(np)
-def nanvar(
-    a, axis=None, dtype=None, keepdims=False, ddof=0, split_every=None, out=None
-):
-    if dtype is not None:
-        dt = dtype
-    else:
-        dt = getattr(np.var(np.ones(shape=(1,), dtype=a.dtype)), "dtype", object)
-    return reduction(
-        a,
-        partial(moment_chunk, sum=chunk.nansum, numel=nannumel),
-        partial(moment_agg, sum=np.nansum, ddof=ddof),
-        axis=axis,
-        keepdims=keepdims,
-        dtype=dt,
-        split_every=split_every,
-        combine=partial(moment_combine, sum=np.nansum),
-        out=out,
-        concatenate=False,
-    )
-
-
-with ignoring(AttributeError):
-    nanvar = derived_from(np)(nanvar)
-
-
-def _sqrt(a):
-    o = np.sqrt(a)
-    if isinstance(o, np.ma.masked_array) and not o.shape and o.mask.all():
-        return np.ma.masked
-    return o
-
-
-def safe_sqrt(a):
-    """A version of sqrt that properly handles scalar masked arrays.
-
-    To mimic ``np.ma`` reductions, we need to convert scalar masked arrays that
-    have an active mask to the ``np.ma.masked`` singleton. This is properly
-    handled automatically for reduction code, but not for ufuncs. We implement
-    a simple version here, since calling `np.ma.sqrt` everywhere is
-    significantly more expensive.
-    """
-    if hasattr(a, "_elemwise"):
-        return a._elemwise(_sqrt, a)
-    return _sqrt(a)
-
-
-@derived_from(np)
-def std(a, axis=None, dtype=None, keepdims=False, ddof=0, split_every=None, out=None):
-    result = safe_sqrt(
-        var(
-            a,
-            axis=axis,
-            dtype=dtype,
-            keepdims=keepdims,
-            ddof=ddof,
-            split_every=split_every,
-            out=out,
-        )
-    )
-    if dtype and dtype != result.dtype:
-        result = result.astype(dtype)
-    return result
-
-
-@derived_from(np)
-def nanstd(
-    a, axis=None, dtype=None, keepdims=False, ddof=0, split_every=None, out=None
-):
-    result = safe_sqrt(
-        nanvar(
-            a,
-            axis=axis,
-            dtype=dtype,
-            keepdims=keepdims,
-            ddof=ddof,
-            split_every=split_every,
-            out=out,
-        )
-    )
-    if dtype and dtype != result.dtype:
-        result = result.astype(dtype)
-    return result
-
-
-with ignoring(AttributeError):
-    nanstd = derived_from(np)(nanstd)
-
-
-def _arg_combine(data, axis, argfunc, keepdims=False):
-    """ Merge intermediate results from ``arg_*`` functions"""
-    axis = None if len(axis) == data.ndim or data.ndim == 1 else axis[0]
-    vals = data["vals"]
-    arg = data["arg"]
-    if axis is None:
-        local_args = argfunc(vals, axis=axis, keepdims=keepdims)
-        vals = vals.ravel()[local_args]
-        arg = arg.ravel()[local_args]
-    else:
-        local_args = argfunc(vals, axis=axis)
-        inds = np.ogrid[tuple(map(slice, local_args.shape))]
-        inds.insert(axis, local_args)
-        inds = tuple(inds)
-        vals = vals[inds]
-        arg = arg[inds]
-        if keepdims:
-            vals = np.expand_dims(vals, axis)
-            arg = np.expand_dims(arg, axis)
-    return arg, vals
-
-
-def arg_chunk(func, argfunc, x, axis, offset_info):
-    arg_axis = None if len(axis) == x.ndim or x.ndim == 1 else axis[0]
-    vals = func(x, axis=arg_axis, keepdims=True)
-    arg = argfunc(x, axis=arg_axis, keepdims=True)
-    if arg_axis is None:
-        offset, total_shape = offset_info
-        ind = np.unravel_index(arg.ravel()[0], x.shape)
-        total_ind = tuple(o + i for (o, i) in zip(offset, ind))
-        arg[:] = np.ravel_multi_index(total_ind, total_shape)
-    else:
-        arg += offset_info
-
-    if isinstance(vals, np.ma.masked_array):
-        if "min" in argfunc.__name__:
-            fill_value = np.ma.minimum_fill_value(vals)
-        else:
-            fill_value = np.ma.maximum_fill_value(vals)
-        vals = np.ma.filled(vals, fill_value)
-
-    result = np.empty(
-        shape=vals.shape, dtype=[("vals", vals.dtype), ("arg", arg.dtype)]
-    )
-    result["vals"] = vals
-    result["arg"] = arg
-    return result
-
-
-def arg_combine(func, argfunc, data, axis=None, **kwargs):
-    arg, vals = _arg_combine(data, axis, argfunc, keepdims=True)
-    result = np.empty(
-        shape=vals.shape, dtype=[("vals", vals.dtype), ("arg", arg.dtype)]
-    )
-    result["vals"] = vals
-    result["arg"] = arg
-    return result
-
-
-def arg_agg(func, argfunc, data, axis=None, **kwargs):
-    return _arg_combine(data, axis, argfunc, keepdims=False)[0]
-
-
-def nanarg_agg(func, argfunc, data, axis=None, **kwargs):
-    arg, vals = _arg_combine(data, axis, argfunc, keepdims=False)
-    if np.any(np.isnan(vals)):
-        raise ValueError("All NaN slice encountered")
-    return arg
-
-
-def arg_reduction(x, chunk, combine, agg, axis=None, split_every=None, out=None):
-    """Generic function for argreduction.
-
-    Parameters
-    ----------
-    x : Array
-    chunk : callable
-        Partialed ``arg_chunk``.
-    combine : callable
-        Partialed ``arg_combine``.
-    agg : callable
-        Partialed ``arg_agg``.
-    axis : int, optional
-    split_every : int or dict, optional
-    """
-    if axis is None:
-        axis = tuple(range(x.ndim))
-        ravel = True
-    elif isinstance(axis, Integral):
-        axis = validate_axis(axis, x.ndim)
-        axis = (axis,)
-        ravel = x.ndim == 1
-    else:
-        raise TypeError("axis must be either `None` or int, got '{0}'".format(axis))
-
-    for ax in axis:
-        chunks = x.chunks[ax]
-        if len(chunks) > 1 and np.isnan(chunks).any():
-            raise ValueError(
-                "Arg-reductions do not work with arrays that have "
-                "unknown chunksizes. At some point in your computation "
-                "this array lost chunking information.\n\n"
-                "A possible solution is with \n"
-                "  x.compute_chunk_sizes()"
-            )
-
-    # Map chunk across all blocks
-    name = "arg-reduce-{0}".format(tokenize(axis, x, chunk, combine, split_every))
-    old = x.name
-    keys = list(product(*map(range, x.numblocks)))
-    offsets = list(product(*(accumulate(operator.add, bd[:-1], 0) for bd in x.chunks)))
-    if ravel:
-        offset_info = zip(offsets, repeat(x.shape))
-    else:
-        offset_info = pluck(axis[0], offsets)
-
-    chunks = tuple((1,) * len(c) if i in axis else c for (i, c) in enumerate(x.chunks))
-    dsk = dict(
-        ((name,) + k, (chunk, (old,) + k, axis, off))
-        for (k, off) in zip(keys, offset_info)
-    )
-    # The dtype of `tmp` doesn't actually matter, just need to provide something
-    graph = HighLevelGraph.from_collections(name, dsk, dependencies=[x])
-    tmp = Array(graph, name, chunks, dtype=x.dtype)
-    dtype = np.argmin([1]).dtype
-    result = _tree_reduce(tmp, agg, axis, False, dtype, split_every, combine)
-    return handle_out(out, result)
-
-
-def make_arg_reduction(func, argfunc, is_nan_func=False):
-    """Create an argreduction callable
-
-    Parameters
-    ----------
-    func : callable
-        The reduction (e.g. ``min``)
-    argfunc : callable
-        The argreduction (e.g. ``argmin``)
-    """
-    chunk = partial(arg_chunk, func, argfunc)
-    combine = partial(arg_combine, func, argfunc)
-    if is_nan_func:
-        agg = partial(nanarg_agg, func, argfunc)
-    else:
-        agg = partial(arg_agg, func, argfunc)
-
-    def wrapped(x, axis=None, split_every=None, out=None):
-        return arg_reduction(
-            x, chunk, combine, agg, axis, split_every=split_every, out=out
-        )
-
-    wrapped.__name__ = func.__name__
-
-    return derived_from(np)(wrapped)
-
-
-def _nanargmin(x, axis, **kwargs):
-    try:
-        return chunk.nanargmin(x, axis, **kwargs)
-    except ValueError:
-        return chunk.nanargmin(np.where(np.isnan(x), np.inf, x), axis, **kwargs)
-
-
-def _nanargmax(x, axis, **kwargs):
-    try:
-        return chunk.nanargmax(x, axis, **kwargs)
-    except ValueError:
-        return chunk.nanargmax(np.where(np.isnan(x), -np.inf, x), axis, **kwargs)
-
-
-argmin = make_arg_reduction(chunk.min, chunk.argmin)
-argmax = make_arg_reduction(chunk.max, chunk.argmax)
-nanargmin = make_arg_reduction(chunk.nanmin, _nanargmin, True)
-nanargmax = make_arg_reduction(chunk.nanmax, _nanargmax, True)
-
-
-def cumreduction(func, binop, ident, x, axis=None, dtype=None, out=None):
-    """Generic function for cumulative reduction
-
-    Parameters
-    ----------
-    func: callable
-        Cumulative function like np.cumsum or np.cumprod
-    binop: callable
-        Associated binary operator like ``np.cumsum->add`` or ``np.cumprod->mul``
-    ident: Number
-        Associated identity like ``np.cumsum->0`` or ``np.cumprod->1``
-    x: dask Array
-    axis: int
-    dtype: dtype
-
-    Returns
-    -------
-    dask array
-
-    See also
-    --------
-    cumsum
-    cumprod
-    """
-    if axis is None:
-        x = x.flatten()
-        axis = 0
-    if dtype is None:
-        dtype = getattr(func(np.empty((0,), dtype=x.dtype)), "dtype", object)
-    assert isinstance(axis, Integral)
-    axis = validate_axis(axis, x.ndim)
-
-    m = x.map_blocks(func, axis=axis, dtype=dtype)
-
-    name = "{0}-{1}".format(func.__name__, tokenize(func, axis, binop, ident, x, dtype))
-    n = x.numblocks[axis]
-    full = slice(None, None, None)
-    slc = (full,) * axis + (slice(-1, None),) + (full,) * (x.ndim - axis - 1)
-
-    indices = list(
-        product(*[range(nb) if i != axis else [0] for i, nb in enumerate(x.numblocks)])
-    )
-    dsk = dict()
-    for ind in indices:
-        shape = tuple(x.chunks[i][ii] if i != axis else 1 for i, ii in enumerate(ind))
-        dsk[(name, "extra") + ind] = (np.full, shape, ident, m.dtype)
-        dsk[(name,) + ind] = (m.name,) + ind
-
-    for i in range(1, n):
-        last_indices = indices
-        indices = list(
-            product(
-                *[range(nb) if ii != axis else [i] for ii, nb in enumerate(x.numblocks)]
-            )
-        )
-        for old, ind in zip(last_indices, indices):
-            this_slice = (name, "extra") + ind
-            dsk[this_slice] = (
-                binop,
-                (name, "extra") + old,
-                (operator.getitem, (m.name,) + old, slc),
-            )
-            dsk[(name,) + ind] = (binop, this_slice, (m.name,) + ind)
-
-    graph = HighLevelGraph.from_collections(name, dsk, dependencies=[m])
-    result = Array(graph, name, x.chunks, m.dtype)
-    return handle_out(out, result)
-
-
-def _cumsum_merge(a, b):
-    if isinstance(a, np.ma.masked_array) or isinstance(b, np.ma.masked_array):
-        values = np.ma.getdata(a) + np.ma.getdata(b)
-        return np.ma.masked_array(values, mask=np.ma.getmaskarray(b))
-    return a + b
-
-
-def _cumprod_merge(a, b):
-    if isinstance(a, np.ma.masked_array) or isinstance(b, np.ma.masked_array):
-        values = np.ma.getdata(a) * np.ma.getdata(b)
-        return np.ma.masked_array(values, mask=np.ma.getmaskarray(b))
-    return a * b
-
-
-@derived_from(np)
-def cumsum(x, axis=None, dtype=None, out=None):
-    return cumreduction(np.cumsum, _cumsum_merge, 0, x, axis, dtype, out=out)
-
-
-@derived_from(np)
-def cumprod(x, axis=None, dtype=None, out=None):
-    return cumreduction(np.cumprod, _cumprod_merge, 1, x, axis, dtype, out=out)
-
-
-def topk(a, k, axis=-1, split_every=None):
-    """Extract the k largest elements from a on the given axis,
-    and return them sorted from largest to smallest.
-    If k is negative, extract the -k smallest elements instead,
-    and return them sorted from smallest to largest.
-
-    This performs best when ``k`` is much smaller than the chunk size. All
-    results will be returned in a single chunk along the given axis.
-
-    Parameters
-    ----------
-    x: Array
-        Data being sorted
-    k: int
-    axis: int, optional
-    split_every: int >=2, optional
-        See :func:`reduce`. This parameter becomes very important when k is
-        on the same order of magnitude of the chunk size or more, as it
-        prevents getting the whole or a significant portion of the input array
-        in memory all at once, with a negative impact on network transfer
-        too when running on distributed.
-
-    Returns
-    -------
-    Selection of x with size abs(k) along the given axis.
-
-    Examples
-    --------
-    >>> import dask.array as da
-    >>> x = np.array([5, 1, 3, 6])
-    >>> d = da.from_array(x, chunks=2)
-    >>> d.topk(2).compute()
-    array([6, 5])
-    >>> d.topk(-2).compute()
-    array([1, 3])
-    """
-    axis = validate_axis(axis, a.ndim)
-
-    # chunk and combine steps of the reduction, which recursively invoke
-    # np.partition to pick the top/bottom k elements from the previous step.
-    # The selection is not sorted internally.
-    chunk_combine = partial(chunk.topk, k=k)
-    # aggregate step of the reduction. Internally invokes the chunk/combine
-    # function, then sorts the results internally.
-    aggregate = partial(chunk.topk_aggregate, k=k)
-
-    return reduction(
-        a,
-        chunk=chunk_combine,
-        combine=chunk_combine,
-        aggregate=aggregate,
-        axis=axis,
-        keepdims=True,
-        dtype=a.dtype,
-        split_every=split_every,
-        output_size=abs(k),
-    )
-
-
-def argtopk(a, k, axis=-1, split_every=None):
-    """Extract the indices of the k largest elements from a on the given axis,
-    and return them sorted from largest to smallest. If k is negative, extract
-    the indices of the -k smallest elements instead, and return them sorted
-    from smallest to largest.
-
-    This performs best when ``k`` is much smaller than the chunk size. All
-    results will be returned in a single chunk along the given axis.
-
-    Parameters
-    ----------
-    x: Array
-        Data being sorted
-    k: int
-    axis: int, optional
-    split_every: int >=2, optional
-        See :func:`topk`. The performance considerations for topk also apply
-        here.
-
-    Returns
-    -------
-    Selection of np.intp indices of x with size abs(k) along the given axis.
-
-    Examples
-    --------
-    >>> import dask.array as da
-    >>> x = np.array([5, 1, 3, 6])
-    >>> d = da.from_array(x, chunks=2)
-    >>> d.argtopk(2).compute()
-    array([3, 0])
-    >>> d.argtopk(-2).compute()
-    array([1, 2])
-    """
-    axis = validate_axis(axis, a.ndim)
-
-    # Generate nodes where every chunk is a tuple of (a, original index of a)
-    idx = arange(a.shape[axis], chunks=(a.chunks[axis],), dtype=np.intp)
-    idx = idx[tuple(slice(None) if i == axis else np.newaxis for i in range(a.ndim))]
-    a_plus_idx = a.map_blocks(chunk.argtopk_preprocess, idx, dtype=object)
-
-    # chunk and combine steps of the reduction. They acquire in input a tuple
-    # of (a, original indices of a) and return another tuple containing the top
-    # k elements of a and the matching original indices. The selection is not
-    # sorted internally, as in np.argpartition.
-    chunk_combine = partial(chunk.argtopk, k=k)
-    # aggregate step of the reduction. Internally invokes the chunk/combine
-    # function, then sorts the results internally, drops a and returns the
-    # index only.
-    aggregate = partial(chunk.argtopk_aggregate, k=k)
-
-    if isinstance(axis, Number):
-        naxis = 1
-    else:
-        naxis = len(axis)
-
-    meta = a._meta.astype(np.intp).reshape((0,) * (a.ndim - naxis + 1))
-
-    return reduction(
-        a_plus_idx,
-        chunk=chunk_combine,
-        combine=chunk_combine,
-        aggregate=aggregate,
-        axis=axis,
-        keepdims=True,
-        dtype=np.intp,
-        split_every=split_every,
-        concatenate=False,
-        output_size=abs(k),
-        meta=meta,
-    )
-
-
-@derived_from(np)
-def trace(a, offset=0, axis1=0, axis2=1, dtype=None):
-    return diagonal(a, offset=offset, axis1=axis1, axis2=axis2).sum(-1, dtype=dtype)
-
-
-@derived_from(np)
-def median(a, axis=None, keepdims=False, out=None):
-    """
-    This works by automatically chunking the reduced axes to a single chunk
-    and then calling ``numpy.median`` function across the remaining dimensions
-    """
-    if axis is None:
-        raise NotImplementedError(
-            "The da.median function only works along an axis.  "
-            "The full algorithm is difficult to do in parallel"
-        )
-
-    if not isinstance(axis, Iterable):
-        axis = (axis,)
-
-    axis = [ax + a.ndim if ax < 0 else ax for ax in axis]
-
-    a = a.rechunk({ax: -1 if ax in axis else "auto" for ax in range(a.ndim)})
-
-    result = a.map_blocks(
-        np.median,
-        axis=axis,
-        keepdims=keepdims,
-        drop_axis=axis if not keepdims else None,
-        chunks=[1 if ax in axis else c for ax, c in enumerate(a.chunks)]
-        if keepdims
-        else None,
-    )
-
-    result = handle_out(out, result)
-    return result
-
-
-@derived_from(np)
-def nanmedian(a, axis=None, keepdims=False, out=None):
-    """
-    This works by automatically chunking the reduced axes to a single chunk
-    and then calling ``numpy.nanmedian`` function across the remaining dimensions
-    """
-    if axis is None:
-        raise NotImplementedError(
-            "The da.nanmedian function only works along an axis or a subset of axes.  "
-            "The full algorithm is difficult to do in parallel"
-        )
-
-    if not isinstance(axis, Iterable):
-        axis = (axis,)
-
-    axis = [ax + a.ndim if ax < 0 else ax for ax in axis]
-
-    a = a.rechunk({ax: -1 if ax in axis else "auto" for ax in range(a.ndim)})
-
-    result = a.map_blocks(
-        np.nanmedian,
-        axis=axis,
-        keepdims=keepdims,
-        drop_axis=axis if not keepdims else None,
-        chunks=[1 if ax in axis else c for ax, c in enumerate(a.chunks)]
-        if keepdims
-        else None,
-    )
-
-    result = handle_out(out, result)
-    return result
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/reshape.py b/Flaskserver/venv/Lib/site-packages/dask/array/reshape.py
deleted file mode 100644
index 18cef220e36a5a57f8d51b08cd8d661f89928a0f..0000000000000000000000000000000000000000
--- a/Flaskserver/venv/Lib/site-packages/dask/array/reshape.py
+++ /dev/null
@@ -1,205 +0,0 @@
-from functools import reduce
-from itertools import product
-from operator import mul
-
-import numpy as np
-
-from .core import Array
-from .utils import meta_from_array
-from ..base import tokenize
-from ..core import flatten
-from ..highlevelgraph import HighLevelGraph
-from ..utils import M
-
-
-def reshape_rechunk(inshape, outshape, inchunks):
-    assert all(isinstance(c, tuple) for c in inchunks)
-    ii = len(inshape) - 1
-    oi = len(outshape) - 1
-    result_inchunks = [None for i in range(len(inshape))]
-    result_outchunks = [None for i in range(len(outshape))]
-
-    while ii >= 0 or oi >= 0:
-        if inshape[ii] == outshape[oi]:
-            result_inchunks[ii] = inchunks[ii]
-            result_outchunks[oi] = inchunks[ii]
-            ii -= 1
-            oi -= 1
-            continue
-        din = inshape[ii]
-        dout = outshape[oi]
-        if din == 1:
-            result_inchunks[ii] = (1,)
-            ii -= 1
-        elif dout == 1:
-            result_outchunks[oi] = (1,)
-            oi -= 1
-        elif din < dout:  # (4, 4, 4) -> (64,)
-            ileft = ii - 1
-            while (
-                ileft >= 0 and reduce(mul, inshape[ileft : ii + 1]) < dout
-            ):  # 4 < 64, 4*4 < 64, 4*4*4 == 64
-                ileft -= 1
-            if reduce(mul, inshape[ileft : ii + 1]) != dout:
-                raise ValueError("Shapes not compatible")
-
-            for i in range(ileft + 1, ii + 1):  # need single-shape dimensions
-                result_inchunks[i] = (inshape[i],)  # chunks[i] = (4,)
-
-            chunk_reduction = reduce(mul, map(len, inchunks[ileft + 1 : ii + 1]))
-            result_inchunks[ileft] = expand_tuple(inchunks[ileft], chunk_reduction)
-
-            prod = reduce(mul, inshape[ileft + 1 : ii + 1])  # 16
-            result_outchunks[oi] = tuple(
-                prod * c for c in result_inchunks[ileft]
-            )  # (1, 1, 1, 1) .* 16
-
-            oi -= 1
-            ii = ileft - 1
-        elif din > dout:  # (64,) -> (4, 4, 4)
-            oleft = oi - 1
-            while oleft >= 0 and reduce(mul, outshape[oleft : oi + 1]) < din:
-                oleft -= 1
-            if reduce(mul, outshape[oleft : oi + 1]) != din:
-                raise ValueError("Shapes not compatible")
-
-            # TODO: don't coalesce shapes unnecessarily
-            cs = reduce(mul, outshape[oleft + 1 : oi + 1])
-
-            result_inchunks[ii] = contract_tuple(inchunks[ii], cs)  # (16, 16, 16, 16)
-
-            for i in range(oleft + 1, oi + 1):
-                result_outchunks[i] = (outshape[i],)
-
-            result_outchunks[oleft] = tuple(c // cs for c in result_inchunks[ii])
-
-            oi = oleft - 1
-            ii -= 1
-
-    return tuple(result_inchunks), tuple(result_outchunks)
-
-
-def expand_tuple(chunks, factor):
-    """
-
-    >>> expand_tuple((2, 4), 2)
-    (1, 1, 2, 2)
-
-    >>> expand_tuple((2, 4), 3)
-    (1, 1, 1, 1, 2)
-
-    >>> expand_tuple((3, 4), 2)
-    (1, 2, 2, 2)
-
-    >>> expand_tuple((7, 4), 3)
-    (2, 2, 3, 1, 1, 2)
-    """
-    if factor == 1:
-        return chunks
-
-    out = []
-    for c in chunks:
-        x = c
-        part = max(x / factor, 1)
-        while x >= 2 * part:
-            out.append(int(part))
-            x -= int(part)
-        if x:
-            out.append(x)
-    assert sum(chunks) == sum(out)
-    return tuple(out)
-
-
-def contract_tuple(chunks, factor):
-    """Return simple chunks tuple such that factor divides all elements
-
-    Examples
-    --------
-
-    >>> contract_tuple((2, 2, 8, 4), 4)
-    (4, 8, 4)
-    """
-    assert sum(chunks) % factor == 0
-
-    out = []
-    residual = 0
-    for chunk in chunks:
-        chunk += residual
-        div = chunk // factor
-        residual = chunk % factor
-        good = factor * div
-        if good:
-            out.append(good)
-    return tuple(out)
-
-
-def reshape(x, shape):
-    """Reshape array to new shape
-
-    This is a parallelized version of the ``np.reshape`` function with the
-    following limitations:
-
-    1.  It assumes that the array is stored in `row-major order`_
-    2.  It only allows for reshapings that collapse or merge dimensions like
-        ``(1, 2, 3, 4) -> (1, 6, 4)`` or ``(64,) -> (4, 4, 4)``
-
-    .. _`row-major order`: https://en.wikipedia.org/wiki/Row-_and_column-major_order
-
-    When communication is necessary this algorithm depends on the logic within
-    rechunk.  It endeavors to keep chunk sizes roughly the same when possible.
-
-    See Also
-    --------
-    dask.array.rechunk
-    numpy.reshape
-    """
-    # Sanitize inputs, look for -1 in shape
-    from .slicing import sanitize_index
-
-    shape = tuple(map(sanitize_index, shape))
-    known_sizes = [s for s in shape if s != -1]
-    if len(known_sizes) < len(shape):
-        if len(known_sizes) - len(shape) > 1:
-            raise ValueError("can only specify one unknown dimension")
-        # Fastpath for x.reshape(-1) on 1D arrays, allows unknown shape in x
-        # for this case only.
-        if len(shape) == 1 and x.ndim == 1:
-            return x
-        missing_size = sanitize_index(x.size / reduce(mul, known_sizes, 1))
-        shape = tuple(missing_size if s == -1 else s for s in shape)
-
-    if np.isnan(sum(x.shape)):
-        raise ValueError(
-            "Array chunk size or shape is unknown. shape: %s\n\n"
-            "Possible solution with x.compute_chunk_sizes()" % x.shape
-        )
-
-    if reduce(mul, shape, 1) != x.size:
-        raise ValueError("total size of new array must be unchanged")
-
-    if x.shape == shape:
-        return x
-
-    meta = meta_from_array(x, len(shape))
-
-    name = "reshape-" + tokenize(x, shape)
-
-    if x.npartitions == 1:
-        key = next(flatten(x.__dask_keys__()))
-        dsk = {(name,) + (0,) * len(shape): (M.reshape, key, shape)}
-        chunks = tuple((d,) for d in shape)
-        graph = HighLevelGraph.from_collections(name, dsk, dependencies=[x])
-        return Array(graph, name, chunks, meta=meta)
-
-    # Logic for how to rechunk
-    inchunks, outchunks = reshape_rechunk(x.shape, shape, x.chunks)
-    x2 = x.rechunk(inchunks)
-
-    # Construct graph
-    in_keys = list(product([x2.name], *[range(len(c)) for c in inchunks]))
-    out_keys = list(product([name], *[range(len(c)) for c in outchunks]))
-    shapes = list(product(*outchunks))
-    dsk = {a: (M.reshape, b, shape) for a, b, shape in zip(out_keys, in_keys, shapes)}
-
-    graph = HighLevelGraph.from_collections(name, dsk, dependencies=[x2])
-    return Array(graph, name, outchunks, meta=meta)
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/routines.py b/Flaskserver/venv/Lib/site-packages/dask/array/routines.py
deleted file mode 100644
index 8c3ebce2de5c0cce721eccdeaeb81564819d5f80..0000000000000000000000000000000000000000
--- a/Flaskserver/venv/Lib/site-packages/dask/array/routines.py
+++ /dev/null
@@ -1,1547 +0,0 @@
-import inspect
-import math
-import warnings
-from collections.abc import Iterable
-from functools import wraps, partial
-from numbers import Real, Integral
-from distutils.version import LooseVersion
-
-import numpy as np
-from tlz import concat, sliding_window, interleave
-
-from ..compatibility import apply
-from ..core import flatten
-from ..base import tokenize, is_dask_collection
-from ..delayed import unpack_collections, Delayed
-from ..highlevelgraph import HighLevelGraph
-from ..utils import funcname, derived_from, is_arraylike
-from . import chunk
-from .creation import arange, diag, empty, indices
-from .utils import safe_wraps, validate_axis, meta_from_array, zeros_like_safe
-from .wrap import ones
-from .ufunc import multiply, sqrt
-
-from .core import (
-    Array,
-    map_blocks,
-    elemwise,
-    asarray,
-    asanyarray,
-    concatenate,
-    stack,
-    blockwise,
-    broadcast_shapes,
-    is_scalar_for_elemwise,
-    broadcast_to,
-    tensordot_lookup,
-    implements,
-)
-
-from .einsumfuncs import einsum  # noqa
-from .numpy_compat import _unravel_index_keyword
-
-
-@derived_from(np)
-def array(x, dtype=None, ndmin=None):
-    x = asarray(x)
-    while ndmin is not None and x.ndim < ndmin:
-        x = x[None, :]
-    if dtype is not None and x.dtype != dtype:
-        x = x.astype(dtype)
-    return x
-
-
-@derived_from(np)
-def result_type(*args):
-    args = [a if is_scalar_for_elemwise(a) else a.dtype for a in args]
-    return np.result_type(*args)
-
-
-@derived_from(np)
-def atleast_3d(*arys):
-    new_arys = []
-    for x in arys:
-        x = asanyarray(x)
-        if x.ndim == 0:
-            x = x[None, None, None]
-        elif x.ndim == 1:
-            x = x[None, :, None]
-        elif x.ndim == 2:
-            x = x[:, :, None]
-
-        new_arys.append(x)
-
-    if len(new_arys) == 1:
-        return new_arys[0]
-    else:
-        return new_arys
-
-
-@derived_from(np)
-def atleast_2d(*arys):
-    new_arys = []
-    for x in arys:
-        x = asanyarray(x)
-        if x.ndim == 0:
-            x = x[None, None]
-        elif x.ndim == 1:
-            x = x[None, :]
-
-        new_arys.append(x)
-
-    if len(new_arys) == 1:
-        return new_arys[0]
-    else:
-        return new_arys
-
-
-@derived_from(np)
-def atleast_1d(*arys):
-    new_arys = []
-    for x in arys:
-        x = asanyarray(x)
-        if x.ndim == 0:
-            x = x[None]
-
-        new_arys.append(x)
-
-    if len(new_arys) == 1:
-        return new_arys[0]
-    else:
-        return new_arys
-
-
-@derived_from(np)
-def vstack(tup, allow_unknown_chunksizes=False):
-    tup = tuple(atleast_2d(x) for x in tup)
-    return concatenate(tup, axis=0, allow_unknown_chunksizes=allow_unknown_chunksizes)
-
-
-@derived_from(np)
-def hstack(tup, allow_unknown_chunksizes=False):
-    if all(x.ndim == 1 for x in tup):
-        return concatenate(
-            tup, axis=0, allow_unknown_chunksizes=allow_unknown_chunksizes
-        )
-    else:
-        return concatenate(
-            tup, axis=1, allow_unknown_chunksizes=allow_unknown_chunksizes
-        )
-
-
-@derived_from(np)
-def dstack(tup, allow_unknown_chunksizes=False):
-    tup = tuple(atleast_3d(x) for x in tup)
-    return concatenate(tup, axis=2, allow_unknown_chunksizes=allow_unknown_chunksizes)
-
-
-@derived_from(np)
-def swapaxes(a, axis1, axis2):
-    if axis1 == axis2:
-        return a
-    if axis1 < 0:
-        axis1 = axis1 + a.ndim
-    if axis2 < 0:
-        axis2 = axis2 + a.ndim
-    ind = list(range(a.ndim))
-    out = list(ind)
-    out[axis1], out[axis2] = axis2, axis1
-
-    return blockwise(np.swapaxes, out, a, ind, axis1=axis1, axis2=axis2, dtype=a.dtype)
-
-
-@derived_from(np)
-def transpose(a, axes=None):
-    if axes:
-        if len(axes) != a.ndim:
-            raise ValueError("axes don't match array")
-    else:
-        axes = tuple(range(a.ndim))[::-1]
-    axes = tuple(d + a.ndim if d < 0 else d for d in axes)
-    return blockwise(
-        np.transpose, axes, a, tuple(range(a.ndim)), dtype=a.dtype, axes=axes
-    )
-
-
-def flip(m, axis):
-    """
-    Reverse element order along axis.
-
-    Parameters
-    ----------
-    axis : int
-        Axis to reverse element order of.
-
-    Returns
-    -------
-    reversed array : ndarray
-    """
-
-    m = asanyarray(m)
-
-    sl = m.ndim * [slice(None)]
-    try:
-        sl[axis] = slice(None, None, -1)
-    except IndexError as e:
-        raise ValueError(
-            "`axis` of %s invalid for %s-D array" % (str(axis), str(m.ndim))
-        ) from e
-    sl = tuple(sl)
-
-    return m[sl]
-
-
-@derived_from(np)
-def flipud(m):
-    return flip(m, 0)
-
-
-@derived_from(np)
-def fliplr(m):
-    return flip(m, 1)
-
-
-alphabet = "abcdefghijklmnopqrstuvwxyz"
-ALPHABET = alphabet.upper()
-
-
-def _tensordot(a, b, axes):
-    x = max([a, b], key=lambda x: x.__array_priority__)
-    tensordot = tensordot_lookup.dispatch(type(x))
-
-    # workaround may be removed when numpy version (currently 1.13.0) is bumped
-    a_dims = np.array([a.shape[i] for i in axes[0]])
-    b_dims = np.array([b.shape[i] for i in axes[1]])
-    if (
-        len(a_dims) > 0
-        and (a_dims == b_dims).all()
-        and a_dims.min() == 0
-        and LooseVersion(np.__version__) < LooseVersion("1.14")
-    ):
-        x = np.zeros(
-            tuple(
-                [s for i, s in enumerate(a.shape) if i not in axes[0]]
-                + [s for i, s in enumerate(b.shape) if i not in axes[1]]
-            )
-        )
-    else:
-        x = tensordot(a, b, axes=axes)
-
-    ind = [slice(None, None)] * x.ndim
-    for a in sorted(axes[0]):
-        ind.insert(a, None)
-    x = x[tuple(ind)]
-    return x
-
-
-@derived_from(np)
-def tensordot(lhs, rhs, axes=2):
-    if isinstance(axes, Iterable):
-        left_axes, right_axes = axes
-    else:
-        left_axes = tuple(range(lhs.ndim - axes, lhs.ndim))
-        right_axes = tuple(range(0, axes))
-
-    if isinstance(left_axes, Integral):
-        left_axes = (left_axes,)
-    if isinstance(right_axes, Integral):
-        right_axes = (right_axes,)
-    if isinstance(left_axes, list):
-        left_axes = tuple(left_axes)
-    if isinstance(right_axes, list):
-        right_axes = tuple(right_axes)
-
-    dt = np.promote_types(lhs.dtype, rhs.dtype)
-
-    left_index = list(range(lhs.ndim))
-    right_index = list(range(lhs.ndim, lhs.ndim + rhs.ndim))
-    out_index = left_index + right_index
-
-    for l, r in zip(left_axes, right_axes):
-        out_index.remove(right_index[r])
-        right_index[r] = left_index[l]
-
-    intermediate = blockwise(
-        _tensordot,
-        out_index,
-        lhs,
-        left_index,
-        rhs,
-        right_index,
-        dtype=dt,
-        axes=(left_axes, right_axes),
-    )
-
-    result = intermediate.sum(axis=left_axes)
-    return result
-
-
-@derived_from(np)
-def dot(a, b):
-    return tensordot(a, b, axes=((a.ndim - 1,), (b.ndim - 2,)))
-
-
-@derived_from(np)
-def vdot(a, b):
-    return dot(a.conj().ravel(), b.ravel())
-
-
-@derived_from(np)
-def matmul(a, b):
-    a = asanyarray(a)
-    b = asanyarray(b)
-
-    if a.ndim == 0 or b.ndim == 0:
-        raise ValueError("`matmul` does not support scalars.")
-
-    a_is_1d = False
-    if a.ndim == 1:
-        a_is_1d = True
-        a = a[np.newaxis, :]
-
-    b_is_1d = False
-    if b.ndim == 1:
-        b_is_1d = True
-        b = b[:, np.newaxis]
-
-    if a.ndim < b.ndim:
-        a = a[(b.ndim - a.ndim) * (np.newaxis,)]
-    elif a.ndim > b.ndim:
-        b = b[(a.ndim - b.ndim) * (np.newaxis,)]
-
-    out = blockwise(
-        np.matmul,
-        tuple(range(1, a.ndim + 1)),
-        a,
-        tuple(range(1, a.ndim - 1)) + (a.ndim - 1, 0),
-        b,
-        tuple(range(1, a.ndim - 1)) + (0, a.ndim),
-        dtype=result_type(a, b),
-        concatenate=True,
-    )
-
-    if a_is_1d:
-        out = out[..., 0, :]
-    if b_is_1d:
-        out = out[..., 0]
-
-    return out
-
-
-@derived_from(np)
-def outer(a, b):
-    a = a.flatten()
-    b = b.flatten()
-
-    dtype = np.outer(a.dtype.type(), b.dtype.type()).dtype
-
-    return blockwise(np.outer, "ij", a, "i", b, "j", dtype=dtype)
-
-
-def _inner_apply_along_axis(arr, func1d, func1d_axis, func1d_args, func1d_kwargs):
-    return np.apply_along_axis(func1d, func1d_axis, arr, *func1d_args, **func1d_kwargs)
-
-
-@derived_from(np)
-def apply_along_axis(func1d, axis, arr, *args, dtype=None, shape=None, **kwargs):
-    """
-    Apply a function to 1-D slices along the given axis. This is
-    a blocked variant of :func:`numpy.apply_along_axis` implemented via
-    :func:`dask.array.map_blocks`
-
-    Parameters
-    ----------
-    func1d : callable
-        Function to apply to 1-D slices of the array along the given axis
-    axis : int
-        Axis along which func1d will be applied
-    arr : dask array
-        Dask array to which ``func1d`` will be applied
-    args : any
-        Additional arguments to ``func1d``.
-    dtype : str or dtype, optional
-        The dtype of the output of ``func1d``.
-    shape : tuple, optional
-        The shape of the output of ``func1d``.
-    kwargs : any
-        Additional keyword arguments for ``func1d``.
-
-    Notes
-    -----
-    If either of `dtype` or `shape` are not provided, Dask attempts to
-    determine them by calling `func1d` on a dummy array. This may produce
-    incorrect values for `dtype` or `shape`, so we recommend providing them.
-    """
-    arr = asarray(arr)
-
-    # Verify that axis is valid and throw an error otherwise
-    axis = len(arr.shape[:axis])
-
-    # If necessary, infer dtype and shape of the output of func1d by calling it on test data.
-    if shape is None or dtype is None:
-        test_data = np.ones((1,), dtype=arr.dtype)
-        test_result = np.array(func1d(test_data, *args, **kwargs))
-        if shape is None:
-            shape = test_result.shape
-        if dtype is None:
-            dtype = test_result.dtype
-
-    # Rechunk so that func1d is applied over the full axis.
-    arr = arr.rechunk(
-        arr.chunks[:axis] + (arr.shape[axis : axis + 1],) + arr.chunks[axis + 1 :]
-    )
-
-    # Map func1d over the data to get the result
-    # Adds other axes as needed.
-    result = arr.map_blocks(
-        _inner_apply_along_axis,
-        name=funcname(func1d) + "-along-axis",
-        dtype=dtype,
-        chunks=(arr.chunks[:axis] + shape + arr.chunks[axis + 1 :]),
-        drop_axis=axis,
-        new_axis=list(range(axis, axis + len(shape), 1)),
-        func1d=func1d,
-        func1d_axis=axis,
-        func1d_args=args,
-        func1d_kwargs=kwargs,
-    )
-
-    return result
-
-
-@derived_from(np)
-def apply_over_axes(func, a, axes):
-    # Validate arguments
-    a = asarray(a)
-    try:
-        axes = tuple(axes)
-    except TypeError:
-        axes = (axes,)
-
-    sl = a.ndim * (slice(None),)
-
-    # Compute using `apply_along_axis`.
-    result = a
-    for i in axes:
-        result = apply_along_axis(func, i, result, 0)
-
-        # Restore original dimensionality or error.
-        if result.ndim == (a.ndim - 1):
-            result = result[sl[:i] + (None,)]
-        elif result.ndim != a.ndim:
-            raise ValueError(
-                "func must either preserve dimensionality of the input"
-                " or reduce it by one."
-            )
-
-    return result
-
-
-@derived_from(np)
-def ptp(a, axis=None):
-    return a.max(axis=axis) - a.min(axis=axis)
-
-
-@derived_from(np)
-def diff(a, n=1, axis=-1):
-    a = asarray(a)
-    n = int(n)
-    axis = int(axis)
-
-    sl_1 = a.ndim * [slice(None)]
-    sl_2 = a.ndim * [slice(None)]
-
-    sl_1[axis] = slice(1, None)
-    sl_2[axis] = slice(None, -1)
-
-    sl_1 = tuple(sl_1)
-    sl_2 = tuple(sl_2)
-
-    r = a
-    for i in range(n):
-        r = r[sl_1] - r[sl_2]
-
-    return r
-
-
-@derived_from(np)
-def ediff1d(ary, to_end=None, to_begin=None):
-    ary = asarray(ary)
-
-    aryf = ary.flatten()
-    r = aryf[1:] - aryf[:-1]
-
-    r = [r]
-    if to_begin is not None:
-        r = [asarray(to_begin).flatten()] + r
-    if to_end is not None:
-        r = r + [asarray(to_end).flatten()]
-    r = concatenate(r)
-
-    return r
-
-
-def _gradient_kernel(x, block_id, coord, axis, array_locs, grad_kwargs):
-    """
-    x: nd-array
-        array of one block
-    coord: 1d-array or scalar
-        coordinate along which the gradient is computed.
-    axis: int
-        axis along which the gradient is computed
-    array_locs:
-        actual location along axis. None if coordinate is scalar
-    grad_kwargs:
-        keyword to be passed to np.gradient
-    """
-    block_loc = block_id[axis]
-    if array_locs is not None:
-        coord = coord[array_locs[0][block_loc] : array_locs[1][block_loc]]
-    grad = np.gradient(x, coord, axis=axis, **grad_kwargs)
-    return grad
-
-
-@derived_from(np)
-def gradient(f, *varargs, **kwargs):
-    f = asarray(f)
-
-    kwargs["edge_order"] = math.ceil(kwargs.get("edge_order", 1))
-    if kwargs["edge_order"] > 2:
-        raise ValueError("edge_order must be less than or equal to 2.")
-
-    drop_result_list = False
-    axis = kwargs.pop("axis", None)
-    if axis is None:
-        axis = tuple(range(f.ndim))
-    elif isinstance(axis, Integral):
-        drop_result_list = True
-        axis = (axis,)
-
-    axis = validate_axis(axis, f.ndim)
-
-    if len(axis) != len(set(axis)):
-        raise ValueError("duplicate axes not allowed")
-
-    axis = tuple(ax % f.ndim for ax in axis)
-
-    if varargs == ():
-        varargs = (1,)
-    if len(varargs) == 1:
-        varargs = len(axis) * varargs
-    if len(varargs) != len(axis):
-        raise TypeError(
-            "Spacing must either be a single scalar, or a scalar / 1d-array per axis"
-        )
-
-    if issubclass(f.dtype.type, (np.bool8, Integral)):
-        f = f.astype(float)
-    elif issubclass(f.dtype.type, Real) and f.dtype.itemsize < 4:
-        f = f.astype(float)
-
-    results = []
-    for i, ax in enumerate(axis):
-        for c in f.chunks[ax]:
-            if np.min(c) < kwargs["edge_order"] + 1:
-                raise ValueError(
-                    "Chunk size must be larger than edge_order + 1. "
-                    "Minimum chunk for axis {} is {}. Rechunk to "
-                    "proceed.".format(ax, np.min(c))
-                )
-
-        if np.isscalar(varargs[i]):
-            array_locs = None
-        else:
-            if isinstance(varargs[i], Array):
-                raise NotImplementedError("dask array coordinated is not supported.")
-            # coordinate position for each block taking overlap into account
-            chunk = np.array(f.chunks[ax])
-            array_loc_stop = np.cumsum(chunk) + 1
-            array_loc_start = array_loc_stop - chunk - 2
-            array_loc_stop[-1] -= 1
-            array_loc_start[0] = 0
-            array_locs = (array_loc_start, array_loc_stop)
-
-        results.append(
-            f.map_overlap(
-                _gradient_kernel,
-                dtype=f.dtype,
-                depth={j: 1 if j == ax else 0 for j in range(f.ndim)},
-                boundary="none",
-                coord=varargs[i],
-                axis=ax,
-                array_locs=array_locs,
-                grad_kwargs=kwargs,
-            )
-        )
-
-    if drop_result_list:
-        results = results[0]
-
-    return results
-
-
-def _bincount_sum(bincounts, dtype=int):
-    n = max(map(len, bincounts))
-    out = zeros_like_safe(bincounts[0], shape=n, dtype=dtype)
-    for b in bincounts:
-        out[: len(b)] += b
-    return out
-
-
-@derived_from(np)
-def bincount(x, weights=None, minlength=0):
-    if x.ndim != 1:
-        raise ValueError("Input array must be one dimensional. Try using x.ravel()")
-    if weights is not None:
-        if weights.chunks != x.chunks:
-            raise ValueError("Chunks of input array x and weights must match.")
-
-    token = tokenize(x, weights, minlength)
-    name = "bincount-" + token
-    final_name = "bincount-sum" + token
-    # Call np.bincount on each block, possibly with weights
-    if weights is not None:
-        dsk = {
-            (name, i): (np.bincount, (x.name, i), (weights.name, i), minlength)
-            for i, _ in enumerate(x.__dask_keys__())
-        }
-        dtype = np.bincount([1], weights=[1]).dtype
-    else:
-        dsk = {
-            (name, i): (np.bincount, (x.name, i), None, minlength)
-            for i, _ in enumerate(x.__dask_keys__())
-        }
-        dtype = np.bincount([]).dtype
-
-    dsk[(final_name, 0)] = (_bincount_sum, list(dsk), dtype)
-    graph = HighLevelGraph.from_collections(
-        final_name, dsk, dependencies=[x] if weights is None else [x, weights]
-    )
-
-    if minlength == 0:
-        chunks = ((np.nan,),)
-    else:
-        chunks = ((minlength,),)
-
-    meta = meta_from_array(x, 1, dtype=dtype)
-
-    return Array(graph, final_name, chunks, meta=meta)
-
-
-@derived_from(np)
-def digitize(a, bins, right=False):
-    bins = np.asarray(bins)
-    dtype = np.digitize([0], bins, right=False).dtype
-    return a.map_blocks(np.digitize, dtype=dtype, bins=bins, right=right)
-
-
-# TODO: dask linspace doesn't support delayed values
-def _linspace_from_delayed(start, stop, num=50):
-    linspace_name = "linspace-" + tokenize(start, stop, num)
-    (start_ref, stop_ref, num_ref), deps = unpack_collections([start, stop, num])
-    if len(deps) == 0:
-        return np.linspace(start, stop, num=num)
-
-    linspace_dsk = {(linspace_name, 0): (np.linspace, start_ref, stop_ref, num_ref)}
-    linspace_graph = HighLevelGraph.from_collections(
-        linspace_name, linspace_dsk, dependencies=deps
-    )
-
-    chunks = ((np.nan,),) if is_dask_collection(num) else ((num,),)
-    return Array(linspace_graph, linspace_name, chunks, dtype=float)
-
-
-def _block_hist(x, bins, range=None, weights=None):
-    return np.histogram(x, bins, range=range, weights=weights)[0][np.newaxis]
-
-
-def histogram(a, bins=None, range=None, normed=False, weights=None, density=None):
-    """
-    Blocked variant of :func:`numpy.histogram`.
-
-    Parameters
-    ----------
-    a : array_like
-        Input data. The histogram is computed over the flattened array.
-    bins : int or sequence of scalars, optional
-        Either an iterable specifying the ``bins`` or the number of ``bins``
-        and a ``range`` argument is required as computing ``min`` and ``max``
-        over blocked arrays is an expensive operation that must be performed
-        explicitly.
-        If `bins` is an int, it defines the number of equal-width
-        bins in the given range (10, by default). If `bins` is a
-        sequence, it defines a monotonically increasing array of bin edges,
-        including the rightmost edge, allowing for non-uniform bin widths.
-    range : (float, float), optional
-        The lower and upper range of the bins.  If not provided, range
-        is simply ``(a.min(), a.max())``.  Values outside the range are
-        ignored. The first element of the range must be less than or
-        equal to the second. `range` affects the automatic bin
-        computation as well. While bin width is computed to be optimal
-        based on the actual data within `range`, the bin count will fill
-        the entire range including portions containing no data.
-    normed : bool, optional
-        This is equivalent to the ``density`` argument, but produces incorrect
-        results for unequal bin widths. It should not be used.
-    weights : array_like, optional
-        A dask.array.Array of weights, of the same block structure as ``a``.  Each value in
-        ``a`` only contributes its associated weight towards the bin count
-        (instead of 1). If ``density`` is True, the weights are
-        normalized, so that the integral of the density over the range
-        remains 1.
-    density : bool, optional
-        If ``False``, the result will contain the number of samples in
-        each bin. If ``True``, the result is the value of the
-        probability *density* function at the bin, normalized such that
-        the *integral* over the range is 1. Note that the sum of the
-        histogram values will not be equal to 1 unless bins of unity
-        width are chosen; it is not a probability *mass* function.
-        Overrides the ``normed`` keyword if given.
-        If ``density`` is True, ``bins`` cannot be a single-number delayed
-        value. It must be a concrete number, or a (possibly-delayed)
-        array/sequence of the bin edges.
-    Returns
-    -------
-    hist : dask Array
-        The values of the histogram. See `density` and `weights` for a
-        description of the possible semantics.
-    bin_edges : dask Array of dtype float
-        Return the bin edges ``(length(hist)+1)``.
-
-
-    Examples
-    --------
-    Using number of bins and range:
-
-    >>> import dask.array as da
-    >>> import numpy as np
-    >>> x = da.from_array(np.arange(10000), chunks=10)
-    >>> h, bins = da.histogram(x, bins=10, range=[0, 10000])
-    >>> bins
-    array([    0.,  1000.,  2000.,  3000.,  4000.,  5000.,  6000.,  7000.,
-            8000.,  9000., 10000.])
-    >>> h.compute()
-    array([1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000, 1000])
-
-    Explicitly specifying the bins:
-
-    >>> h, bins = da.histogram(x, bins=np.array([0, 5000, 10000]))
-    >>> bins
-    array([    0,  5000, 10000])
-    >>> h.compute()
-    array([5000, 5000])
-    """
-    if isinstance(bins, Array):
-        scalar_bins = bins.ndim == 0
-        # ^ `np.ndim` is not implemented by Dask array.
-    elif isinstance(bins, Delayed):
-        scalar_bins = bins._length is None or bins._length == 1
-    else:
-        scalar_bins = np.ndim(bins) == 0
-
-    if bins is None or (scalar_bins and range is None):
-        raise ValueError(
-            "dask.array.histogram requires either specifying "
-            "bins as an iterable or specifying both a range and "
-            "the number of bins"
-        )
-
-    if weights is not None and weights.chunks != a.chunks:
-        raise ValueError("Input array and weights must have the same chunked structure")
-
-    if normed is not False:
-        raise ValueError(
-            "The normed= keyword argument has been deprecated. "
-            "Please use density instead. "
-            "See the numpy.histogram docstring for more information."
-        )
-
-    if density and scalar_bins and isinstance(bins, (Array, Delayed)):
-        raise NotImplementedError(
-            "When `density` is True, `bins` cannot be a scalar Dask object. "
-            "It must be a concrete number or a (possibly-delayed) array/sequence of bin edges."
-        )
-
-    for argname, val in [("bins", bins), ("range", range), ("weights", weights)]:
-        if not isinstance(bins, (Array, Delayed)) and is_dask_collection(bins):
-            raise TypeError(
-                "Dask types besides Array and Delayed are not supported "
-                "for `histogram`. For argument `{}`, got: {!r}".format(argname, val)
-            )
-
-    if range is not None:
-        try:
-            if len(range) != 2:
-                raise ValueError(
-                    f"range must be a sequence or array of length 2, but got {len(range)} items"
-                )
-            if isinstance(range, (Array, np.ndarray)) and range.shape != (2,):
-                raise ValueError(
-                    f"range must be a 1-dimensional array of two items, but got an array of shape {range.shape}"
-                )
-        except TypeError:
-            raise TypeError(
-                f"Expected a sequence or array for range, not {range}"
-            ) from None
-
-    token = tokenize(a, bins, range, weights, density)
-    name = "histogram-sum-" + token
-
-    if scalar_bins:
-        bins = _linspace_from_delayed(range[0], range[1], bins + 1)
-        # ^ NOTE `range[1]` is safe because of the above check, and the initial check
-        # that range must not be None if `scalar_bins`
-    else:
-        if not isinstance(bins, (Array, np.ndarray)):
-            bins = asarray(bins)
-        if bins.ndim != 1:
-            raise ValueError(
-                f"bins must be a 1-dimensional array or sequence, got shape {bins.shape}"
-            )
-
-    (bins_ref, range_ref), deps = unpack_collections([bins, range])
-
-    # Map the histogram to all bins, forming a 2D array of histograms, stacked for each chunk
-    if weights is None:
-        dsk = {
-            (name, i, 0): (_block_hist, k, bins_ref, range_ref)
-            for i, k in enumerate(flatten(a.__dask_keys__()))
-        }
-        dtype = np.histogram([])[0].dtype
-    else:
-        a_keys = flatten(a.__dask_keys__())
-        w_keys = flatten(weights.__dask_keys__())
-        dsk = {
-            (name, i, 0): (_block_hist, k, bins_ref, range_ref, w)
-            for i, (k, w) in enumerate(zip(a_keys, w_keys))
-        }
-        dtype = weights.dtype
-
-    deps = (a,) + deps
-    if weights is not None:
-        deps += (weights,)
-    graph = HighLevelGraph.from_collections(name, dsk, dependencies=deps)
-
-    # Turn graph into a 2D Array of shape (nchunks, nbins)
-    nchunks = len(list(flatten(a.__dask_keys__())))
-    nbins = bins.size - 1  # since `bins` is 1D
-    chunks = ((1,) * nchunks, (nbins,))
-    mapped = Array(graph, name, chunks, dtype=dtype)
-
-    # Sum over chunks to get the final histogram
-    n = mapped.sum(axis=0)
-
-    # We need to replicate normed and density options from numpy
-    if density is not None:
-        if density:
-            db = asarray(np.diff(bins).astype(float), chunks=n.chunks)
-            return n / db / n.sum(), bins
-        else:
-            return n, bins
-    else:
-        return n, bins
-
-
-@derived_from(np)
-def cov(m, y=None, rowvar=1, bias=0, ddof=None):
-    # This was copied almost verbatim from np.cov
-    # See numpy license at https://github.com/numpy/numpy/blob/master/LICENSE.txt
-    # or NUMPY_LICENSE.txt within this directory
-    if ddof is not None and ddof != int(ddof):
-        raise ValueError("ddof must be integer")
-
-    # Handles complex arrays too
-    m = asarray(m)
-    if y is None:
-        dtype = np.result_type(m, np.float64)
-    else:
-        y = asarray(y)
-        dtype = np.result_type(m, y, np.float64)
-    X = array(m, ndmin=2, dtype=dtype)
-
-    if X.shape[0] == 1:
-        rowvar = 1
-    if rowvar:
-        N = X.shape[1]
-        axis = 0
-    else:
-        N = X.shape[0]
-        axis = 1
-
-    # check ddof
-    if ddof is None:
-        if bias == 0:
-            ddof = 1
-        else:
-            ddof = 0
-    fact = float(N - ddof)
-    if fact <= 0:
-        warnings.warn("Degrees of freedom <= 0 for slice", RuntimeWarning)
-        fact = 0.0
-
-    if y is not None:
-        y = array(y, ndmin=2, dtype=dtype)
-        X = concatenate((X, y), axis)
-
-    X = X - X.mean(axis=1 - axis, keepdims=True)
-    if not rowvar:
-        return (dot(X.T, X.conj()) / fact).squeeze()
-    else:
-        return (dot(X, X.T.conj()) / fact).squeeze()
-
-
-@derived_from(np)
-def corrcoef(x, y=None, rowvar=1):
-    c = cov(x, y, rowvar)
-    if c.shape == ():
-        return c / c
-    d = diag(c)
-    d = d.reshape((d.shape[0], 1))
-    sqr_d = sqrt(d)
-    return (c / sqr_d) / sqr_d.T
-
-
-@implements(np.round, np.round_)
-@derived_from(np)
-def round(a, decimals=0):
-    return a.map_blocks(np.round, decimals=decimals, dtype=a.dtype)
-
-
-@implements(np.iscomplexobj)
-@derived_from(np)
-def iscomplexobj(x):
-    return issubclass(x.dtype.type, np.complexfloating)
-
-
-def _unique_internal(ar, indices, counts, return_inverse=False):
-    """
-    Helper/wrapper function for :func:`numpy.unique`.
-
-    Uses :func:`numpy.unique` to find the unique values for the array chunk.
-    Given this chunk may not represent the whole array, also take the
-    ``indices`` and ``counts`` that are in 1-to-1 correspondence to ``ar``
-    and reduce them in the same fashion as ``ar`` is reduced. Namely sum
-    any counts that correspond to the same value and take the smallest
-    index that corresponds to the same value.
-
-    To handle the inverse mapping from the unique values to the original
-    array, simply return a NumPy array created with ``arange`` with enough
-    values to correspond 1-to-1 to the unique values. While there is more
-    work needed to be done to create the full inverse mapping for the
-    original array, this provides enough information to generate the
-    inverse mapping in Dask.
-
-    Given Dask likes to have one array returned from functions like
-    ``blockwise``, some formatting is done to stuff all of the resulting arrays
-    into one big NumPy structured array. Dask is then able to handle this
-    object and can split it apart into the separate results on the Dask side,
-    which then can be passed back to this function in concatenated chunks for
-    further reduction or can be return to the user to perform other forms of
-    analysis.
-
-    By handling the problem in this way, it does not matter where a chunk
-    is in a larger array or how big it is. The chunk can still be computed
-    on the same way. Also it does not matter if the chunk is the result of
-    other chunks being run through this function multiple times. The end
-    result will still be just as accurate using this strategy.
-    """
-
-    return_index = indices is not None
-    return_counts = counts is not None
-
-    u = np.unique(ar)
-
-    dt = [("values", u.dtype)]
-    if return_index:
-        dt.append(("indices", np.intp))
-    if return_inverse:
-        dt.append(("inverse", np.intp))
-    if return_counts:
-        dt.append(("counts", np.intp))
-
-    r = np.empty(u.shape, dtype=dt)
-    r["values"] = u
-    if return_inverse:
-        r["inverse"] = np.arange(len(r), dtype=np.intp)
-    if return_index or return_counts:
-        for i, v in enumerate(r["values"]):
-            m = ar == v
-            if return_index:
-                indices[m].min(keepdims=True, out=r["indices"][i : i + 1])
-            if return_counts:
-                counts[m].sum(keepdims=True, out=r["counts"][i : i + 1])
-
-    return r
-
-
-@derived_from(np)
-def unique(ar, return_index=False, return_inverse=False, return_counts=False):
-    ar = ar.ravel()
-
-    # Run unique on each chunk and collect results in a Dask Array of
-    # unknown size.
-
-    args = [ar, "i"]
-    out_dtype = [("values", ar.dtype)]
-    if return_index:
-        args.extend([arange(ar.shape[0], dtype=np.intp, chunks=ar.chunks[0]), "i"])
-        out_dtype.append(("indices", np.intp))
-    else:
-        args.extend([None, None])
-    if return_counts:
-        args.extend([ones((ar.shape[0],), dtype=np.intp, chunks=ar.chunks[0]), "i"])
-        out_dtype.append(("counts", np.intp))
-    else:
-        args.extend([None, None])
-
-    out = blockwise(_unique_internal, "i", *args, dtype=out_dtype, return_inverse=False)
-    out._chunks = tuple((np.nan,) * len(c) for c in out.chunks)
-
-    # Take the results from the unique chunks and do the following.
-    #
-    # 1. Collect all results as arguments.
-    # 2. Concatenate each result into one big array.
-    # 3. Pass all results as arguments to the internal unique again.
-    #
-    # TODO: This should be replaced with a tree reduction using this strategy.
-    # xref: https://github.com/dask/dask/issues/2851
-
-    out_parts = [out["values"]]
-    if return_index:
-        out_parts.append(out["indices"])
-    else:
-        out_parts.append(None)
-    if return_counts:
-        out_parts.append(out["counts"])
-    else:
-        out_parts.append(None)
-
-    name = "unique-aggregate-" + out.name
-    dsk = {
-        (name, 0): (
-            (_unique_internal,)
-            + tuple(
-                (np.concatenate, o.__dask_keys__())
-                if hasattr(o, "__dask_keys__")
-                else o
-                for o in out_parts
-            )
-            + (return_inverse,)
-        )
-    }
-    out_dtype = [("values", ar.dtype)]
-    if return_index:
-        out_dtype.append(("indices", np.intp))
-    if return_inverse:
-        out_dtype.append(("inverse", np.intp))
-    if return_counts:
-        out_dtype.append(("counts", np.intp))
-
-    dependencies = [o for o in out_parts if hasattr(o, "__dask_keys__")]
-    graph = HighLevelGraph.from_collections(name, dsk, dependencies=dependencies)
-    chunks = ((np.nan,),)
-    out = Array(graph, name, chunks, out_dtype)
-
-    # Split out all results to return to the user.
-
-    result = [out["values"]]
-    if return_index:
-        result.append(out["indices"])
-    if return_inverse:
-        # Using the returned unique values and arange of unknown length, find
-        # each value matching a unique value and replace it with its
-        # corresponding index or `0`. There should be only one entry for this
-        # index in axis `1` (the one of unknown length). Reduce axis `1`
-        # through summing to get an array with known dimensionality and the
-        # mapping of the original values.
-        mtches = (ar[:, None] == out["values"][None, :]).astype(np.intp)
-        result.append((mtches * out["inverse"]).sum(axis=1))
-    if return_counts:
-        result.append(out["counts"])
-
-    if len(result) == 1:
-        result = result[0]
-    else:
-        result = tuple(result)
-
-    return result
-
-
-def _isin_kernel(element, test_elements, assume_unique=False):
-    values = np.in1d(element.ravel(), test_elements, assume_unique=assume_unique)
-    return values.reshape(element.shape + (1,) * test_elements.ndim)
-
-
-@safe_wraps(getattr(np, "isin", None))
-def isin(element, test_elements, assume_unique=False, invert=False):
-    element = asarray(element)
-    test_elements = asarray(test_elements)
-    element_axes = tuple(range(element.ndim))
-    test_axes = tuple(i + element.ndim for i in range(test_elements.ndim))
-    mapped = blockwise(
-        _isin_kernel,
-        element_axes + test_axes,
-        element,
-        element_axes,
-        test_elements,
-        test_axes,
-        adjust_chunks={axis: lambda _: 1 for axis in test_axes},
-        dtype=bool,
-        assume_unique=assume_unique,
-    )
-
-    result = mapped.any(axis=test_axes)
-    if invert:
-        result = ~result
-    return result
-
-
-@derived_from(np)
-def roll(array, shift, axis=None):
-    result = array
-
-    if axis is None:
-        result = ravel(result)
-
-        if not isinstance(shift, Integral):
-            raise TypeError(
-                "Expect `shift` to be an instance of Integral when `axis` is None."
-            )
-
-        shift = (shift,)
-        axis = (0,)
-    else:
-        try:
-            len(shift)
-        except TypeError:
-            shift = (shift,)
-        try:
-            len(axis)
-        except TypeError:
-            axis = (axis,)
-
-    if len(shift) != len(axis):
-        raise ValueError("Must have the same number of shifts as axes.")
-
-    for i, s in zip(axis, shift):
-        s = -s
-        s %= result.shape[i]
-
-        sl1 = result.ndim * [slice(None)]
-        sl2 = result.ndim * [slice(None)]
-
-        sl1[i] = slice(s, None)
-        sl2[i] = slice(None, s)
-
-        sl1 = tuple(sl1)
-        sl2 = tuple(sl2)
-
-        result = concatenate([result[sl1], result[sl2]], axis=i)
-
-    result = result.reshape(array.shape)
-
-    return result
-
-
-@derived_from(np)
-def shape(array):
-    return array.shape
-
-
-@derived_from(np)
-def union1d(ar1, ar2):
-    return unique(concatenate((ar1.ravel(), ar2.ravel())))
-
-
-@derived_from(np)
-def ravel(array):
-    return array.reshape((-1,))
-
-
-@derived_from(np)
-def squeeze(a, axis=None):
-    if axis is None:
-        axis = tuple(i for i, d in enumerate(a.shape) if d == 1)
-    elif not isinstance(axis, tuple):
-        axis = (axis,)
-
-    if any(a.shape[i] != 1 for i in axis):
-        raise ValueError("cannot squeeze axis with size other than one")
-
-    axis = validate_axis(axis, a.ndim)
-
-    sl = tuple(0 if i in axis else slice(None) for i, s in enumerate(a.shape))
-
-    a = a[sl]
-
-    return a
-
-
-@derived_from(np)
-def compress(condition, a, axis=None):
-
-    if not is_arraylike(condition):
-        # Allow `condition` to be anything array-like, otherwise ensure `condition`
-        # is a numpy array.
-        condition = np.asarray(condition)
-    condition = condition.astype(bool)
-    a = asarray(a)
-
-    if condition.ndim != 1:
-        raise ValueError("Condition must be one dimensional")
-
-    if axis is None:
-        a = a.ravel()
-        axis = 0
-    axis = validate_axis(axis, a.ndim)
-
-    # Treat `condition` as filled with `False` (if it is too short)
-    a = a[
-        tuple(
-            slice(None, len(condition)) if i == axis else slice(None)
-            for i in range(a.ndim)
-        )
-    ]
-
-    # Use `condition` to select along 1 dimension
-    a = a[tuple(condition if i == axis else slice(None) for i in range(a.ndim))]
-
-    return a
-
-
-@derived_from(np)
-def extract(condition, arr):
-    condition = asarray(condition).astype(bool)
-    arr = asarray(arr)
-    return compress(condition.ravel(), arr.ravel())
-
-
-@derived_from(np)
-def take(a, indices, axis=0):
-    axis = validate_axis(axis, a.ndim)
-
-    if isinstance(a, np.ndarray) and isinstance(indices, Array):
-        return _take_dask_array_from_numpy(a, indices, axis)
-    else:
-        return a[(slice(None),) * axis + (indices,)]
-
-
-def _take_dask_array_from_numpy(a, indices, axis):
-    assert isinstance(a, np.ndarray)
-    assert isinstance(indices, Array)
-
-    return indices.map_blocks(
-        lambda block: np.take(a, block, axis), chunks=indices.chunks, dtype=a.dtype
-    )
-
-
-@derived_from(np)
-def around(x, decimals=0):
-    return map_blocks(partial(np.around, decimals=decimals), x, dtype=x.dtype)
-
-
-def _asarray_isnull(values):
-    import pandas as pd
-
-    return np.asarray(pd.isnull(values))
-
-
-def isnull(values):
-    """ pandas.isnull for dask arrays """
-    # eagerly raise ImportError, if pandas isn't available
-    import pandas as pd  # noqa
-
-    return elemwise(_asarray_isnull, values, dtype="bool")
-
-
-def notnull(values):
-    """ pandas.notnull for dask arrays """
-    return ~isnull(values)
-
-
-@derived_from(np)
-def isclose(arr1, arr2, rtol=1e-5, atol=1e-8, equal_nan=False):
-    func = partial(np.isclose, rtol=rtol, atol=atol, equal_nan=equal_nan)
-    return elemwise(func, arr1, arr2, dtype="bool")
-
-
-@derived_from(np)
-def allclose(arr1, arr2, rtol=1e-5, atol=1e-8, equal_nan=False):
-    return isclose(arr1, arr2, rtol=rtol, atol=atol, equal_nan=equal_nan).all()
-
-
-def variadic_choose(a, *choices):
-    return np.choose(a, choices)
-
-
-@derived_from(np)
-def choose(a, choices):
-    return elemwise(variadic_choose, a, *choices)
-
-
-def _isnonzero_vec(v):
-    return bool(np.count_nonzero(v))
-
-
-_isnonzero_vec = np.vectorize(_isnonzero_vec, otypes=[bool])
-
-
-def isnonzero(a):
-    if a.dtype.kind in {"U", "S"}:
-        # NumPy treats all-whitespace strings as falsy (like in `np.nonzero`).
-        # but not in `.astype(bool)`. To match the behavior of numpy at least until
-        # 1.19, we use `_isnonzero_vec`. When NumPy changes behavior, we should just
-        # use the try block below.
-        # https://github.com/numpy/numpy/issues/9875
-        return a.map_blocks(_isnonzero_vec, dtype=bool)
-    try:
-        np.zeros(tuple(), dtype=a.dtype).astype(bool)
-    except ValueError:
-        ######################################################
-        # Handle special cases where conversion to bool does #
-        # not work correctly.                                #
-        #                                                    #
-        # xref: https://github.com/numpy/numpy/issues/9479   #
-        ######################################################
-        return a.map_blocks(_isnonzero_vec, dtype=bool)
-    else:
-        return a.astype(bool)
-
-
-@derived_from(np)
-def argwhere(a):
-    a = asarray(a)
-
-    nz = isnonzero(a).flatten()
-
-    ind = indices(a.shape, dtype=np.intp, chunks=a.chunks)
-    if ind.ndim > 1:
-        ind = stack([ind[i].ravel() for i in range(len(ind))], axis=1)
-    ind = compress(nz, ind, axis=0)
-
-    return ind
-
-
-@derived_from(np)
-def where(condition, x=None, y=None):
-    if (x is None) != (y is None):
-        raise ValueError("either both or neither of x and y should be given")
-    if (x is None) and (y is None):
-        return nonzero(condition)
-
-    if np.isscalar(condition):
-        dtype = result_type(x, y)
-        x = asarray(x)
-        y = asarray(y)
-
-        shape = broadcast_shapes(x.shape, y.shape)
-        out = x if condition else y
-
-        return broadcast_to(out, shape).astype(dtype)
-    else:
-        return elemwise(np.where, condition, x, y)
-
-
-@derived_from(np)
-def count_nonzero(a, axis=None):
-    return isnonzero(asarray(a)).astype(np.intp).sum(axis=axis)
-
-
-@derived_from(np)
-def flatnonzero(a):
-    return argwhere(asarray(a).ravel())[:, 0]
-
-
-@derived_from(np)
-def nonzero(a):
-    ind = argwhere(a)
-    if ind.ndim > 1:
-        return tuple(ind[:, i] for i in range(ind.shape[1]))
-    else:
-        return (ind,)
-
-
-def _int_piecewise(x, *condlist, **kwargs):
-    return np.piecewise(
-        x, list(condlist), kwargs["funclist"], *kwargs["func_args"], **kwargs["func_kw"]
-    )
-
-
-def _unravel_index_kernel(indices, func_kwargs):
-    return np.stack(np.unravel_index(indices, **func_kwargs))
-
-
-@derived_from(np)
-def unravel_index(indices, shape, order="C"):
-    if shape and indices.size:
-        unraveled_indices = tuple(
-            indices.map_blocks(
-                _unravel_index_kernel,
-                dtype=np.intp,
-                chunks=(((len(shape),),) + indices.chunks),
-                new_axis=0,
-                func_kwargs={_unravel_index_keyword: shape, "order": order},
-            )
-        )
-    else:
-        unraveled_indices = tuple(empty((0,), dtype=np.intp, chunks=1) for i in shape)
-
-    return unraveled_indices
-
-
-@derived_from(np)
-def piecewise(x, condlist, funclist, *args, **kw):
-    return map_blocks(
-        _int_piecewise,
-        x,
-        *condlist,
-        dtype=x.dtype,
-        name="piecewise",
-        funclist=funclist,
-        func_args=args,
-        func_kw=kw,
-    )
-
-
-@wraps(chunk.coarsen)
-def coarsen(reduction, x, axes, trim_excess=False, **kwargs):
-    if not trim_excess and not all(
-        bd % div == 0 for i, div in axes.items() for bd in x.chunks[i]
-    ):
-        msg = "Coarsening factor does not align with block dimensions"
-        raise ValueError(msg)
-
-    if "dask" in inspect.getfile(reduction):
-        reduction = getattr(np, reduction.__name__)
-
-    name = "coarsen-" + tokenize(reduction, x, axes, trim_excess)
-    dsk = {
-        (name,)
-        + key[1:]: (apply, chunk.coarsen, [reduction, key, axes, trim_excess], kwargs)
-        for key in flatten(x.__dask_keys__())
-    }
-    chunks = tuple(
-        tuple(int(bd // axes.get(i, 1)) for bd in bds) for i, bds in enumerate(x.chunks)
-    )
-
-    meta = reduction(np.empty((1,) * x.ndim, dtype=x.dtype), **kwargs)
-    graph = HighLevelGraph.from_collections(name, dsk, dependencies=[x])
-    return Array(graph, name, chunks, meta=meta)
-
-
-def split_at_breaks(array, breaks, axis=0):
-    """Split an array into a list of arrays (using slices) at the given breaks
-
-    >>> split_at_breaks(np.arange(6), [3, 5])
-    [array([0, 1, 2]), array([3, 4]), array([5])]
-    """
-    padded_breaks = concat([[None], breaks, [None]])
-    slices = [slice(i, j) for i, j in sliding_window(2, padded_breaks)]
-    preslice = (slice(None),) * axis
-    split_array = [array[preslice + (s,)] for s in slices]
-    return split_array
-
-
-@derived_from(np)
-def insert(arr, obj, values, axis):
-    # axis is a required argument here to avoid needing to deal with the numpy
-    # default case (which reshapes the array to make it flat)
-    axis = validate_axis(axis, arr.ndim)
-
-    if isinstance(obj, slice):
-        obj = np.arange(*obj.indices(arr.shape[axis]))
-    obj = np.asarray(obj)
-    scalar_obj = obj.ndim == 0
-    if scalar_obj:
-        obj = np.atleast_1d(obj)
-
-    obj = np.where(obj < 0, obj + arr.shape[axis], obj)
-    if (np.diff(obj) < 0).any():
-        raise NotImplementedError(
-            "da.insert only implemented for monotonic ``obj`` argument"
-        )
-
-    split_arr = split_at_breaks(arr, np.unique(obj), axis)
-
-    if getattr(values, "ndim", 0) == 0:
-        # we need to turn values into a dask array
-        name = "values-" + tokenize(values)
-        dtype = getattr(values, "dtype", type(values))
-        values = Array({(name,): values}, name, chunks=(), dtype=dtype)
-
-        values_shape = tuple(
-            len(obj) if axis == n else s for n, s in enumerate(arr.shape)
-        )
-        values = broadcast_to(values, values_shape)
-    elif scalar_obj:
-        values = values[(slice(None),) * axis + (None,)]
-
-    values_chunks = tuple(
-        values_bd if axis == n else arr_bd
-        for n, (arr_bd, values_bd) in enumerate(zip(arr.chunks, values.chunks))
-    )
-    values = values.rechunk(values_chunks)
-
-    counts = np.bincount(obj)[:-1]
-    values_breaks = np.cumsum(counts[counts > 0])
-    split_values = split_at_breaks(values, values_breaks, axis)
-
-    interleaved = list(interleave([split_arr, split_values]))
-    interleaved = [i for i in interleaved if i.nbytes]
-    return concatenate(interleaved, axis=axis)
-
-
-def _average(a, axis=None, weights=None, returned=False, is_masked=False):
-    # This was minimally modified from numpy.average
-    # See numpy license at https://github.com/numpy/numpy/blob/master/LICENSE.txt
-    # or NUMPY_LICENSE.txt within this directory
-    # Wrapper used by da.average or da.ma.average.
-    a = asanyarray(a)
-
-    if weights is None:
-        avg = a.mean(axis)
-        scl = avg.dtype.type(a.size / avg.size)
-    else:
-        wgt = asanyarray(weights)
-
-        if issubclass(a.dtype.type, (np.integer, np.bool_)):
-            result_dtype = result_type(a.dtype, wgt.dtype, "f8")
-        else:
-            result_dtype = result_type(a.dtype, wgt.dtype)
-
-        # Sanity checks
-        if a.shape != wgt.shape:
-            if axis is None:
-                raise TypeError(
-                    "Axis must be specified when shapes of a and weights differ."
-                )
-            if wgt.ndim != 1:
-                raise TypeError(
-                    "1D weights expected when shapes of a and weights differ."
-                )
-            if wgt.shape[0] != a.shape[axis]:
-                raise ValueError(
-                    "Length of weights not compatible with specified axis."
-                )
-
-            # setup wgt to broadcast along axis
-            wgt = broadcast_to(wgt, (a.ndim - 1) * (1,) + wgt.shape)
-            wgt = wgt.swapaxes(-1, axis)
-        if is_masked:
-            from .ma import getmaskarray
-
-            wgt = wgt * (~getmaskarray(a))
-        scl = wgt.sum(axis=axis, dtype=result_dtype)
-        avg = multiply(a, wgt, dtype=result_dtype).sum(axis) / scl
-
-    if returned:
-        if scl.shape != avg.shape:
-            scl = broadcast_to(scl, avg.shape).copy()
-        return avg, scl
-    else:
-        return avg
-
-
-@derived_from(np)
-def average(a, axis=None, weights=None, returned=False):
-    return _average(a, axis, weights, returned, is_masked=False)
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/slicing.py b/Flaskserver/venv/Lib/site-packages/dask/array/slicing.py
deleted file mode 100644
index d44147bb47514372ef0b566827e4545e557abeaa..0000000000000000000000000000000000000000
--- a/Flaskserver/venv/Lib/site-packages/dask/array/slicing.py
+++ /dev/null
@@ -1,1252 +0,0 @@
-from itertools import product
-import math
-from numbers import Integral, Number
-from operator import add, getitem, itemgetter
-import warnings
-import functools
-import bisect
-
-import numpy as np
-from tlz import memoize, merge, pluck, concat, accumulate
-
-from .. import core
-from ..highlevelgraph import HighLevelGraph
-from ..base import tokenize, is_dask_collection
-
-colon = slice(None, None, None)
-
-
-def _sanitize_index_element(ind):
-    """Sanitize a one-element index."""
-    if isinstance(ind, Number):
-        ind2 = int(ind)
-        if ind2 != ind:
-            raise IndexError("Bad index.  Must be integer-like: %s" % ind)
-        else:
-            return ind2
-    elif ind is None:
-        return None
-    else:
-        raise TypeError("Invalid index type", type(ind), ind)
-
-
-def sanitize_index(ind):
-    """Sanitize the elements for indexing along one axis
-
-    >>> sanitize_index([2, 3, 5])
-    array([2, 3, 5])
-    >>> sanitize_index([True, False, True, False])
-    array([0, 2])
-    >>> sanitize_index(np.array([1, 2, 3]))
-    array([1, 2, 3])
-    >>> sanitize_index(np.array([False, True, True]))
-    array([1, 2])
-    >>> type(sanitize_index(np.int32(0)))
-    <class 'int'>
-    >>> sanitize_index(1.0)
-    1
-    >>> sanitize_index(0.5)
-    Traceback (most recent call last):
-    ...
-    IndexError: Bad index.  Must be integer-like: 0.5
-    """
-    if ind is None:
-        return None
-    elif isinstance(ind, slice):
-        return slice(
-            _sanitize_index_element(ind.start),
-            _sanitize_index_element(ind.stop),
-            _sanitize_index_element(ind.step),
-        )
-    elif isinstance(ind, Number):
-        return _sanitize_index_element(ind)
-    elif is_dask_collection(ind):
-        return ind
-    index_array = np.asanyarray(ind)
-    if index_array.dtype == bool:
-        nonzero = np.nonzero(index_array)
-        if len(nonzero) == 1:
-            # If a 1-element tuple, unwrap the element
-            nonzero = nonzero[0]
-        return np.asanyarray(nonzero)
-    elif np.issubdtype(index_array.dtype, np.integer):
-        return index_array
-    elif np.issubdtype(index_array.dtype, np.floating):
-        int_index = index_array.astype(np.intp)
-        if np.allclose(index_array, int_index):
-            return int_index
-        else:
-            check_int = np.isclose(index_array, int_index)
-            first_err = index_array.ravel()[np.flatnonzero(~check_int)[0]]
-            raise IndexError("Bad index.  Must be integer-like: %s" % first_err)
-    else:
-        raise TypeError("Invalid index type", type(ind), ind)
-
-
-def slice_array(out_name, in_name, blockdims, index):
-    """
-    Master function for array slicing
-
-    This function makes a new dask that slices blocks along every
-    dimension and aggregates (via cartesian product) each dimension's
-    slices so that the resulting block slices give the same results
-    as the original slice on the original structure
-
-    Index must be a tuple.  It may contain the following types
-
-        int, slice, list (at most one list), None
-
-    Parameters
-    ----------
-    in_name - string
-      This is the dask variable name that will be used as input
-    out_name - string
-      This is the dask variable output name
-    blockshape - iterable of integers
-    index - iterable of integers, slices, lists, or None
-
-    Returns
-    -------
-    Dict where the keys are tuples of
-
-        (out_name, dim_index[, dim_index[, ...]])
-
-    and the values are
-
-        (function, (in_name, dim_index, dim_index, ...),
-                   (slice(...), [slice()[,...]])
-
-    Also new blockdims with shapes of each block
-
-        ((10, 10, 10, 10), (20, 20))
-
-    Examples
-    --------
-    >>> dsk, blockdims = slice_array('y', 'x', [(20, 20, 20, 20, 20)],
-    ...                              (slice(10, 35),))  #  doctest: +SKIP
-    >>> dsk  # doctest: +SKIP
-    {('y', 0): (getitem, ('x', 0), (slice(10, 20),)),
-     ('y', 1): (getitem, ('x', 1), (slice(0, 15),))}
-    >>> blockdims  # doctest: +SKIP
-    ((10, 15),)
-
-    See Also
-    --------
-    This function works by successively unwrapping cases and passing down
-    through a sequence of functions.
-
-    slice_with_newaxis : handle None/newaxis case
-    slice_wrap_lists : handle fancy indexing with lists
-    slice_slices_and_integers : handle everything else
-    """
-    blockdims = tuple(map(tuple, blockdims))
-
-    # x[:, :, :] - Punt and return old value
-    if all(
-        isinstance(index, slice) and index == slice(None, None, None) for index in index
-    ):
-        suffixes = product(*[range(len(bd)) for bd in blockdims])
-        dsk = dict(((out_name,) + s, (in_name,) + s) for s in suffixes)
-        return dsk, blockdims
-
-    # Add in missing colons at the end as needed.  x[5] -> x[5, :, :]
-    not_none_count = sum(i is not None for i in index)
-    missing = len(blockdims) - not_none_count
-    index += (slice(None, None, None),) * missing
-
-    # Pass down to next function
-    dsk_out, bd_out = slice_with_newaxes(out_name, in_name, blockdims, index)
-
-    bd_out = tuple(map(tuple, bd_out))
-    return dsk_out, bd_out
-
-
-def slice_with_newaxes(out_name, in_name, blockdims, index):
-    """
-    Handle indexing with Nones
-
-    Strips out Nones then hands off to slice_wrap_lists
-    """
-    # Strip Nones from index
-    index2 = tuple([ind for ind in index if ind is not None])
-    where_none = [i for i, ind in enumerate(index) if ind is None]
-    where_none_orig = list(where_none)
-    for i, x in enumerate(where_none):
-        n = sum(isinstance(ind, Integral) for ind in index[:x])
-        if n:
-            where_none[i] -= n
-
-    # Pass down and do work
-    dsk, blockdims2 = slice_wrap_lists(out_name, in_name, blockdims, index2)
-
-    if where_none:
-        expand = expander(where_none)
-        expand_orig = expander(where_none_orig)
-
-        # Insert ",0" into the key:  ('x', 2, 3) -> ('x', 0, 2, 0, 3)
-        dsk2 = {
-            (out_name,) + expand(k[1:], 0): (v[:2] + (expand_orig(v[2], None),))
-            for k, v in dsk.items()
-            if k[0] == out_name
-        }
-
-        # Add back intermediate parts of the dask that weren't the output
-        dsk3 = merge(dsk2, {k: v for k, v in dsk.items() if k[0] != out_name})
-
-        # Insert (1,) into blockdims:  ((2, 2), (3, 3)) -> ((2, 2), (1,), (3, 3))
-        blockdims3 = expand(blockdims2, (1,))
-
-        return dsk3, blockdims3
-
-    else:
-        return dsk, blockdims2
-
-
-def slice_wrap_lists(out_name, in_name, blockdims, index):
-    """
-    Fancy indexing along blocked array dasks
-
-    Handles index of type list.  Calls slice_slices_and_integers for the rest
-
-    See Also
-    --------
-
-    take : handle slicing with lists ("fancy" indexing)
-    slice_slices_and_integers : handle slicing with slices and integers
-    """
-    assert all(isinstance(i, (slice, list, Integral, np.ndarray)) for i in index)
-    if not len(blockdims) == len(index):
-        raise IndexError("Too many indices for array")
-
-    # Do we have more than one list in the index?
-    where_list = [
-        i for i, ind in enumerate(index) if isinstance(ind, np.ndarray) and ind.ndim > 0
-    ]
-    if len(where_list) > 1:
-        raise NotImplementedError("Don't yet support nd fancy indexing")
-    # Is the single list an empty list? In this case just treat it as a zero
-    # length slice
-    if where_list and not index[where_list[0]].size:
-        index = list(index)
-        index[where_list.pop()] = slice(0, 0, 1)
-        index = tuple(index)
-
-    # No lists, hooray! just use slice_slices_and_integers
-    if not where_list:
-        return slice_slices_and_integers(out_name, in_name, blockdims, index)
-
-    # Replace all lists with full slices  [3, 1, 0] -> slice(None, None, None)
-    index_without_list = tuple(
-        slice(None, None, None) if isinstance(i, np.ndarray) else i for i in index
-    )
-
-    # lists and full slices.  Just use take
-    if all(isinstance(i, np.ndarray) or i == slice(None, None, None) for i in index):
-        axis = where_list[0]
-        blockdims2, dsk3 = take(
-            out_name, in_name, blockdims, index[where_list[0]], axis=axis
-        )
-    # Mixed case. Both slices/integers and lists. slice/integer then take
-    else:
-        # Do first pass without lists
-        tmp = "slice-" + tokenize((out_name, in_name, blockdims, index))
-        dsk, blockdims2 = slice_slices_and_integers(
-            tmp, in_name, blockdims, index_without_list
-        )
-
-        # After collapsing some axes due to int indices, adjust axis parameter
-        axis = where_list[0]
-        axis2 = axis - sum(
-            1 for i, ind in enumerate(index) if i < axis and isinstance(ind, Integral)
-        )
-
-        # Do work
-        blockdims2, dsk2 = take(out_name, tmp, blockdims2, index[axis], axis=axis2)
-        dsk3 = merge(dsk, dsk2)
-
-    return dsk3, blockdims2
-
-
-def slice_slices_and_integers(out_name, in_name, blockdims, index):
-    """
-    Dask array indexing with slices and integers
-
-    See Also
-    --------
-
-    _slice_1d
-    """
-    from .core import unknown_chunk_message
-
-    shape = tuple(cached_cumsum(dim, initial_zero=True)[-1] for dim in blockdims)
-
-    for dim, ind in zip(shape, index):
-        if np.isnan(dim) and ind != slice(None, None, None):
-            raise ValueError(
-                "Arrays chunk sizes are unknown: %s%s" % (shape, unknown_chunk_message)
-            )
-
-    assert all(isinstance(ind, (slice, Integral)) for ind in index)
-    assert len(index) == len(blockdims)
-
-    # Get a list (for each dimension) of dicts{blocknum: slice()}
-    block_slices = list(map(_slice_1d, shape, blockdims, index))
-    sorted_block_slices = [sorted(i.items()) for i in block_slices]
-
-    # (in_name, 1, 1, 2), (in_name, 1, 1, 4), (in_name, 2, 1, 2), ...
-    in_names = list(product([in_name], *[pluck(0, s) for s in sorted_block_slices]))
-
-    # (out_name, 0, 0, 0), (out_name, 0, 0, 1), (out_name, 0, 1, 0), ...
-    out_names = list(
-        product(
-            [out_name],
-            *[
-                range(len(d))[::-1] if i.step and i.step < 0 else range(len(d))
-                for d, i in zip(block_slices, index)
-                if not isinstance(i, Integral)
-            ]
-        )
-    )
-
-    all_slices = list(product(*[pluck(1, s) for s in sorted_block_slices]))
-
-    dsk_out = {
-        out_name: (getitem, in_name, slices)
-        for out_name, in_name, slices in zip(out_names, in_names, all_slices)
-    }
-
-    new_blockdims = [
-        new_blockdim(d, db, i)
-        for d, i, db in zip(shape, index, blockdims)
-        if not isinstance(i, Integral)
-    ]
-
-    return dsk_out, new_blockdims
-
-
-def _slice_1d(dim_shape, lengths, index):
-    """Returns a dict of {blocknum: slice}
-
-    This function figures out where each slice should start in each
-    block for a single dimension. If the slice won't return any elements
-    in the block, that block will not be in the output.
-
-    Parameters
-    ----------
-
-    dim_shape - the number of elements in this dimension.
-      This should be a positive, non-zero integer
-    blocksize - the number of elements per block in this dimension
-      This should be a positive, non-zero integer
-    index - a description of the elements in this dimension that we want
-      This might be an integer, a slice(), or an Ellipsis
-
-    Returns
-    -------
-
-    dictionary where the keys are the integer index of the blocks that
-      should be sliced and the values are the slices
-
-    Examples
-    --------
-
-    Trivial slicing
-
-    >>> _slice_1d(100, [60, 40], slice(None, None, None))
-    {0: slice(None, None, None), 1: slice(None, None, None)}
-
-    100 length array cut into length 20 pieces, slice 0:35
-
-    >>> _slice_1d(100, [20, 20, 20, 20, 20], slice(0, 35))
-    {0: slice(None, None, None), 1: slice(0, 15, 1)}
-
-    Support irregular blocks and various slices
-
-    >>> _slice_1d(100, [20, 10, 10, 10, 25, 25], slice(10, 35))
-    {0: slice(10, 20, 1), 1: slice(None, None, None), 2: slice(0, 5, 1)}
-
-    Support step sizes
-
-    >>> _slice_1d(100, [15, 14, 13], slice(10, 41, 3))
-    {0: slice(10, 15, 3), 1: slice(1, 14, 3), 2: slice(2, 12, 3)}
-
-    >>> _slice_1d(100, [20, 20, 20, 20, 20], slice(0, 100, 40))  # step > blocksize
-    {0: slice(0, 20, 40), 2: slice(0, 20, 40), 4: slice(0, 20, 40)}
-
-    Also support indexing single elements
-
-    >>> _slice_1d(100, [20, 20, 20, 20, 20], 25)
-    {1: 5}
-
-    And negative slicing
-
-    >>> _slice_1d(100, [20, 20, 20, 20, 20], slice(100, 0, -3)) # doctest: +NORMALIZE_WHITESPACE
-    {4: slice(-1, -21, -3),
-     3: slice(-2, -21, -3),
-     2: slice(-3, -21, -3),
-     1: slice(-1, -21, -3),
-     0: slice(-2, -20, -3)}
-
-    >>> _slice_1d(100, [20, 20, 20, 20, 20], slice(100, 12, -3)) # doctest: +NORMALIZE_WHITESPACE
-    {4: slice(-1, -21, -3),
-     3: slice(-2, -21, -3),
-     2: slice(-3, -21, -3),
-     1: slice(-1, -21, -3),
-     0: slice(-2, -8, -3)}
-
-    >>> _slice_1d(100, [20, 20, 20, 20, 20], slice(100, -12, -3))
-    {4: slice(-1, -12, -3)}
-    """
-    chunk_boundaries = cached_cumsum(lengths)
-
-    if isinstance(index, Integral):
-        # use right-side search to be consistent with previous result
-        i = bisect.bisect_right(chunk_boundaries, index)
-        if i > 0:
-            # the very first chunk has no relative shift
-            ind = index - chunk_boundaries[i - 1]
-        else:
-            ind = index
-        return {int(i): int(ind)}
-
-    assert isinstance(index, slice)
-
-    if index == colon:
-        return {k: colon for k in range(len(lengths))}
-
-    step = index.step or 1
-    if step > 0:
-        start = index.start or 0
-        stop = index.stop if index.stop is not None else dim_shape
-    else:
-        start = index.start if index.start is not None else dim_shape - 1
-        start = dim_shape - 1 if start >= dim_shape else start
-        stop = -(dim_shape + 1) if index.stop is None else index.stop
-
-    # posify start and stop
-    if start < 0:
-        start += dim_shape
-    if stop < 0:
-        stop += dim_shape
-
-    d = dict()
-    if step > 0:
-        istart = bisect.bisect_right(chunk_boundaries, start)
-        istop = bisect.bisect_left(chunk_boundaries, stop)
-
-        # the bound is not exactly tight; make it tighter?
-        istop = min(istop + 1, len(lengths))
-
-        # jump directly to istart
-        if istart > 0:
-            start = start - chunk_boundaries[istart - 1]
-            stop = stop - chunk_boundaries[istart - 1]
-
-        for i in range(istart, istop):
-            length = lengths[i]
-            if start < length and stop > 0:
-                d[i] = slice(start, min(stop, length), step)
-                start = (start - length) % step
-            else:
-                start = start - length
-            stop -= length
-    else:
-        rstart = start  # running start
-
-        istart = bisect.bisect_left(chunk_boundaries, start)
-        istop = bisect.bisect_right(chunk_boundaries, stop)
-
-        # the bound is not exactly tight; make it tighter?
-        istart = min(istart + 1, len(chunk_boundaries) - 1)
-        istop = max(istop - 1, -1)
-
-        for i in range(istart, istop, -1):
-            chunk_stop = chunk_boundaries[i]
-            # create a chunk start and stop
-            if i == 0:
-                chunk_start = 0
-            else:
-                chunk_start = chunk_boundaries[i - 1]
-
-            # if our slice is in this chunk
-            if (chunk_start <= rstart < chunk_stop) and (rstart > stop):
-                d[i] = slice(
-                    rstart - chunk_stop,
-                    max(chunk_start - chunk_stop - 1, stop - chunk_stop),
-                    step,
-                )
-
-                # compute the next running start point,
-                offset = (rstart - (chunk_start - 1)) % step
-                rstart = chunk_start + offset - 1
-
-    # replace 0:20:1 with : if appropriate
-    for k, v in d.items():
-        if v == slice(0, lengths[k], 1):
-            d[k] = slice(None, None, None)
-
-    if not d:  # special case x[:0]
-        d[0] = slice(0, 0, 1)
-
-    return d
-
-
-def partition_by_size(sizes, seq):
-    """
-
-    >>> partition_by_size([10, 20, 10], [1, 5, 9, 12, 29, 35])
-    [array([1, 5, 9]), array([ 2, 19]), array([5])]
-    """
-    seq = np.asanyarray(seq)
-    left = np.empty(len(sizes) + 1, dtype=int)
-    left[0] = 0
-
-    right = np.cumsum(sizes, out=left[1:])
-    locations = np.empty(len(sizes) + 1, dtype=int)
-    locations[0] = 0
-    locations[1:] = np.searchsorted(seq, right)
-    return [(seq[j:k] - l) for j, k, l in zip(locations[:-1], locations[1:], left)]
-
-
-def issorted(seq):
-    """Is sequence sorted?
-
-    >>> issorted([1, 2, 3])
-    True
-    >>> issorted([3, 1, 2])
-    False
-    """
-    if len(seq) == 0:
-        return True
-    return np.all(seq[:-1] <= seq[1:])
-
-
-def slicing_plan(chunks, index):
-    """Construct a plan to slice chunks with the given index
-
-    Parameters
-    ----------
-    chunks : Tuple[int]
-        One dimensions worth of chunking information
-    index : np.ndarray[int]
-        The index passed to slice on that dimension
-
-    Returns
-    -------
-    out : List[Tuple[int, np.ndarray]]
-        A list of chunk/sub-index pairs corresponding to each output chunk
-    """
-    index = np.asanyarray(index)
-    cum_chunks = cached_cumsum(chunks)
-
-    chunk_locations = np.searchsorted(cum_chunks, index, side="right")
-    where = np.where(np.diff(chunk_locations))[0] + 1
-    where = np.concatenate([[0], where, [len(chunk_locations)]])
-
-    out = []
-    for i in range(len(where) - 1):
-        sub_index = index[where[i] : where[i + 1]]
-        chunk = chunk_locations[where[i]]
-        if chunk > 0:
-            sub_index = sub_index - cum_chunks[chunk - 1]
-        out.append((chunk, sub_index))
-
-    return out
-
-
-def take(outname, inname, chunks, index, axis=0):
-    """Index array with an iterable of index
-
-    Handles a single index by a single list
-
-    Mimics ``np.take``
-
-    >>> chunks, dsk = take('y', 'x', [(20, 20, 20, 20)], [5, 1, 47, 3], axis=0)
-    >>> chunks
-    ((2, 1, 1),)
-    >>> dsk  # doctest: +SKIP
-    {('y', 0): (getitem, (np.concatenate, [(getitem, ('x', 0), ([1, 3, 5],)),
-                                           (getitem, ('x', 2), ([7],))],
-                                          0),
-                         (2, 0, 4, 1))}
-
-    When list is sorted we retain original block structure
-
-    >>> chunks, dsk = take('y', 'x', [(20, 20, 20, 20)], [1, 3, 5, 47], axis=0)
-    >>> chunks
-    ((3, 1),)
-    >>> dsk  # doctest: +SKIP
-    {('y', 0): (getitem, ('x', 0), ([1, 3, 5],)),
-     ('y', 2): (getitem, ('x', 2), ([7],))}
-    """
-    plan = slicing_plan(chunks[axis], index)
-    if len(plan) >= len(chunks[axis]) * 10:
-        factor = math.ceil(len(plan) / len(chunks[axis]))
-        from .core import PerformanceWarning
-
-        warnings.warn(
-            "Slicing with an out-of-order index is generating %d "
-            "times more chunks" % factor,
-            PerformanceWarning,
-            stacklevel=6,
-        )
-
-    index_lists = [idx for _, idx in plan]
-    where_index = [i for i, _ in plan]
-
-    dims = [range(len(bd)) for bd in chunks]
-
-    indims = list(dims)
-    indims[axis] = list(range(len(where_index)))
-    keys = list(product([outname], *indims))
-
-    outdims = list(dims)
-    outdims[axis] = where_index
-    slices = [[colon] * len(bd) for bd in chunks]
-    slices[axis] = index_lists
-    slices = list(product(*slices))
-    inkeys = list(product([inname], *outdims))
-    values = [(getitem, inkey, slc) for inkey, slc in zip(inkeys, slices)]
-
-    chunks2 = list(chunks)
-    chunks2[axis] = tuple(map(len, index_lists))
-    dsk = dict(zip(keys, values))
-    return tuple(chunks2), dsk
-
-
-def posify_index(shape, ind):
-    """Flip negative indices around to positive ones
-
-    >>> posify_index(10, 3)
-    3
-    >>> posify_index(10, -3)
-    7
-    >>> posify_index(10, [3, -3])
-    array([3, 7])
-
-    >>> posify_index((10, 20), (3, -3))
-    (3, 17)
-    >>> posify_index((10, 20), (3, [3, 4, -3]))  # doctest: +NORMALIZE_WHITESPACE
-    (3, array([ 3,  4, 17]))
-    """
-    if isinstance(ind, tuple):
-        return tuple(map(posify_index, shape, ind))
-    if isinstance(ind, Integral):
-        if ind < 0 and not math.isnan(shape):
-            return ind + shape
-        else:
-            return ind
-    if isinstance(ind, (np.ndarray, list)) and not math.isnan(shape):
-        ind = np.asanyarray(ind)
-        return np.where(ind < 0, ind + shape, ind)
-    return ind
-
-
-@memoize
-def _expander(where):
-    if not where:
-
-        def expand(seq, val):
-            return seq
-
-        return expand
-    else:
-        decl = """def expand(seq, val):
-            return ({left}) + tuple({right})
-        """
-        left = []
-        j = 0
-        for i in range(max(where) + 1):
-            if i in where:
-                left.append("val, ")
-            else:
-                left.append("seq[%d], " % j)
-                j += 1
-        right = "seq[%d:]" % j
-        left = "".join(left)
-        decl = decl.format(**locals())
-        ns = {}
-        exec(compile(decl, "<dynamic>", "exec"), ns, ns)
-        return ns["expand"]
-
-
-def expander(where):
-    """Create a function to insert value at many locations in sequence.
-
-    >>> expander([0, 2])(['a', 'b', 'c'], 'z')
-    ('z', 'a', 'z', 'b', 'c')
-    """
-    return _expander(tuple(where))
-
-
-def new_blockdim(dim_shape, lengths, index):
-    """
-
-    >>> new_blockdim(100, [20, 10, 20, 10, 40], slice(0, 90, 2))
-    [10, 5, 10, 5, 15]
-
-    >>> new_blockdim(100, [20, 10, 20, 10, 40], [5, 1, 30, 22])
-    [4]
-
-    >>> new_blockdim(100, [20, 10, 20, 10, 40], slice(90, 10, -2))
-    [16, 5, 10, 5, 4]
-    """
-    if index == slice(None, None, None):
-        return lengths
-    if isinstance(index, list):
-        return [len(index)]
-    assert not isinstance(index, Integral)
-    pairs = sorted(_slice_1d(dim_shape, lengths, index).items(), key=itemgetter(0))
-    slices = [
-        slice(0, lengths[i], 1) if slc == slice(None, None, None) else slc
-        for i, slc in pairs
-    ]
-    if isinstance(index, slice) and index.step and index.step < 0:
-        slices = slices[::-1]
-    return [int(math.ceil((1.0 * slc.stop - slc.start) / slc.step)) for slc in slices]
-
-
-def replace_ellipsis(n, index):
-    """Replace ... with slices, :, : ,:
-
-    >>> replace_ellipsis(4, (3, Ellipsis, 2))
-    (3, slice(None, None, None), slice(None, None, None), 2)
-
-    >>> replace_ellipsis(2, (Ellipsis, None))
-    (slice(None, None, None), slice(None, None, None), None)
-    """
-    # Careful about using in or index because index may contain arrays
-    isellipsis = [i for i, ind in enumerate(index) if ind is Ellipsis]
-    if not isellipsis:
-        return index
-    else:
-        loc = isellipsis[0]
-    extra_dimensions = n - (len(index) - sum(i is None for i in index) - 1)
-    return (
-        index[:loc] + (slice(None, None, None),) * extra_dimensions + index[loc + 1 :]
-    )
-
-
-def normalize_slice(idx, dim):
-    """Normalize slices to canonical form
-
-    Parameters
-    ----------
-    idx: slice or other index
-    dim: dimension length
-
-    Examples
-    --------
-    >>> normalize_slice(slice(0, 10, 1), 10)
-    slice(None, None, None)
-    """
-
-    if isinstance(idx, slice):
-        if math.isnan(dim):
-            return idx
-        start, stop, step = idx.indices(dim)
-        if step > 0:
-            if start == 0:
-                start = None
-            if stop >= dim:
-                stop = None
-            if step == 1:
-                step = None
-            if stop is not None and start is not None and stop < start:
-                stop = start
-        elif step < 0:
-            if start >= dim - 1:
-                start = None
-            if stop < 0:
-                stop = None
-        return slice(start, stop, step)
-    return idx
-
-
-def normalize_index(idx, shape):
-    """Normalize slicing indexes
-
-    1.  Replaces ellipses with many full slices
-    2.  Adds full slices to end of index
-    3.  Checks bounding conditions
-    4.  Replace multidimensional numpy arrays with dask arrays
-    5.  Replaces numpy arrays with lists
-    6.  Posify's integers and lists
-    7.  Normalizes slices to canonical form
-
-    Examples
-    --------
-    >>> normalize_index(1, (10,))
-    (1,)
-    >>> normalize_index(-1, (10,))
-    (9,)
-    >>> normalize_index([-1], (10,))
-    (array([9]),)
-    >>> normalize_index(slice(-3, 10, 1), (10,))
-    (slice(7, None, None),)
-    >>> normalize_index((Ellipsis, None), (10,))
-    (slice(None, None, None), None)
-    >>> normalize_index(np.array([[True, False], [False, True], [True, True]]), (3, 2))
-    (dask.array<array, shape=(3, 2), dtype=bool, chunksize=(3, 2), chunktype=numpy.ndarray>,)
-    """
-    from .core import from_array
-
-    if not isinstance(idx, tuple):
-        idx = (idx,)
-
-    # if a > 1D numpy.array is provided, cast it to a dask array
-    if len(idx) > 0 and len(shape) > 1:
-        i = idx[0]
-        if isinstance(i, np.ndarray) and i.shape == shape:
-            idx = (from_array(i), *idx[1:])
-
-    idx = replace_ellipsis(len(shape), idx)
-    n_sliced_dims = 0
-    for i in idx:
-        if hasattr(i, "ndim") and i.ndim >= 1:
-            n_sliced_dims += i.ndim
-        elif i is None:
-            continue
-        else:
-            n_sliced_dims += 1
-    idx = idx + (slice(None),) * (len(shape) - n_sliced_dims)
-    if len([i for i in idx if i is not None]) > len(shape):
-        raise IndexError("Too many indices for array")
-
-    none_shape = []
-    i = 0
-    for ind in idx:
-        if ind is not None:
-            none_shape.append(shape[i])
-            i += 1
-        else:
-            none_shape.append(None)
-
-    for i, d in zip(idx, none_shape):
-        if d is not None:
-            check_index(i, d)
-    idx = tuple(map(sanitize_index, idx))
-    idx = tuple(map(normalize_slice, idx, none_shape))
-    idx = posify_index(none_shape, idx)
-    return idx
-
-
-def check_index(ind, dimension):
-    """Check validity of index for a given dimension
-
-    Examples
-    --------
-    >>> check_index(3, 5)
-    >>> check_index(5, 5)
-    Traceback (most recent call last):
-    ...
-    IndexError: Index is not smaller than dimension 5 >= 5
-
-    >>> check_index(6, 5)
-    Traceback (most recent call last):
-    ...
-    IndexError: Index is not smaller than dimension 6 >= 5
-
-    >>> check_index(-1, 5)
-    >>> check_index(-6, 5)
-    Traceback (most recent call last):
-    ...
-    IndexError: Negative index is not greater than negative dimension -6 <= -5
-
-    >>> check_index([1, 2], 5)
-    >>> check_index([6, 3], 5)
-    Traceback (most recent call last):
-    ...
-    IndexError: Index out of bounds 5
-
-    >>> check_index(slice(0, 3), 5)
-
-    >>> check_index([True], 1)
-    >>> check_index([True, True], 3)
-    Traceback (most recent call last):
-    ...
-    IndexError: Boolean array length 2 doesn't equal dimension 3
-    >>> check_index([True, True, True], 1)
-    Traceback (most recent call last):
-    ...
-    IndexError: Boolean array length 3 doesn't equal dimension 1
-    """
-    # unknown dimension, assumed to be in bounds
-    if np.isnan(dimension):
-        return
-    elif isinstance(ind, (list, np.ndarray)):
-        x = np.asanyarray(ind)
-        if x.dtype == bool:
-            if x.size != dimension:
-                raise IndexError(
-                    "Boolean array length %s doesn't equal dimension %s"
-                    % (x.size, dimension)
-                )
-        elif (x >= dimension).any() or (x < -dimension).any():
-            raise IndexError("Index out of bounds %s" % dimension)
-    elif isinstance(ind, slice):
-        return
-    elif is_dask_collection(ind):
-        return
-    elif ind is None:
-        return
-
-    elif ind >= dimension:
-        raise IndexError(
-            "Index is not smaller than dimension %d >= %d" % (ind, dimension)
-        )
-
-    elif ind < -dimension:
-        msg = "Negative index is not greater than negative dimension %d <= -%d"
-        raise IndexError(msg % (ind, dimension))
-
-
-def slice_with_int_dask_array(x, index):
-    """Slice x with at most one 1D dask arrays of ints.
-
-    This is a helper function of :meth:`Array.__getitem__`.
-
-    Parameters
-    ----------
-    x: Array
-    index: tuple with as many elements as x.ndim, among which there are
-           one or more Array's with dtype=int
-
-    Returns
-    -------
-    tuple of (sliced x, new index)
-
-    where the new index is the same as the input, but with slice(None)
-    replaced to the original slicer where a 1D filter has been applied and
-    one less element where a zero-dimensional filter has been applied.
-    """
-    from .core import Array
-
-    assert len(index) == x.ndim
-    fancy_indexes = [
-        isinstance(idx, (tuple, list))
-        or (isinstance(idx, (np.ndarray, Array)) and idx.ndim > 0)
-        for idx in index
-    ]
-    if sum(fancy_indexes) > 1:
-        raise NotImplementedError("Don't yet support nd fancy indexing")
-
-    out_index = []
-    dropped_axis_cnt = 0
-    for in_axis, idx in enumerate(index):
-        out_axis = in_axis - dropped_axis_cnt
-        if isinstance(idx, Array) and idx.dtype.kind in "iu":
-            if idx.ndim == 0:
-                idx = idx[np.newaxis]
-                x = slice_with_int_dask_array_on_axis(x, idx, out_axis)
-                x = x[tuple(0 if i == out_axis else slice(None) for i in range(x.ndim))]
-                dropped_axis_cnt += 1
-            elif idx.ndim == 1:
-                x = slice_with_int_dask_array_on_axis(x, idx, out_axis)
-                out_index.append(slice(None))
-            else:
-                raise NotImplementedError(
-                    "Slicing with dask.array of ints only permitted when "
-                    "the indexer has zero or one dimensions"
-                )
-        else:
-            out_index.append(idx)
-    return x, tuple(out_index)
-
-
-def slice_with_int_dask_array_on_axis(x, idx, axis):
-    """Slice a ND dask array with a 1D dask arrays of ints along the given
-    axis.
-
-    This is a helper function of :func:`slice_with_int_dask_array`.
-    """
-    from .core import Array, blockwise, from_array
-    from . import chunk
-
-    assert 0 <= axis < x.ndim
-
-    if np.isnan(x.chunks[axis]).any():
-        raise NotImplementedError(
-            "Slicing an array with unknown chunks with "
-            "a dask.array of ints is not supported"
-        )
-
-    # Calculate the offset at which each chunk starts along axis
-    # e.g. chunks=(..., (5, 3, 4), ...) -> offset=[0, 5, 8]
-    offset = np.roll(np.cumsum(x.chunks[axis]), 1)
-    offset[0] = 0
-    offset = from_array(offset, chunks=1)
-    # Tamper with the declared chunks of offset to make blockwise align it with
-    # x[axis]
-    offset = Array(offset.dask, offset.name, (x.chunks[axis],), offset.dtype)
-
-    # Define axis labels for blockwise
-    x_axes = tuple(range(x.ndim))
-    idx_axes = (x.ndim,)  # arbitrary index not already in x_axes
-    offset_axes = (axis,)
-    p_axes = x_axes[: axis + 1] + idx_axes + x_axes[axis + 1 :]
-    y_axes = x_axes[:axis] + idx_axes + x_axes[axis + 1 :]
-
-    # Calculate the cartesian product of every chunk of x vs every chunk of idx
-    p = blockwise(
-        chunk.slice_with_int_dask_array,
-        p_axes,
-        x,
-        x_axes,
-        idx,
-        idx_axes,
-        offset,
-        offset_axes,
-        x_size=x.shape[axis],
-        axis=axis,
-        dtype=x.dtype,
-    )
-
-    # Aggregate on the chunks of x along axis
-    y = blockwise(
-        chunk.slice_with_int_dask_array_aggregate,
-        y_axes,
-        idx,
-        idx_axes,
-        p,
-        p_axes,
-        concatenate=True,
-        x_chunks=x.chunks[axis],
-        axis=axis,
-        dtype=x.dtype,
-    )
-    return y
-
-
-def slice_with_bool_dask_array(x, index):
-    """Slice x with one or more dask arrays of bools
-
-    This is a helper function of `Array.__getitem__`.
-
-    Parameters
-    ----------
-    x: Array
-    index: tuple with as many elements as x.ndim, among which there are
-           one or more Array's with dtype=bool
-
-    Returns
-    -------
-    tuple of (sliced x, new index)
-
-    where the new index is the same as the input, but with slice(None)
-    replaced to the original slicer when a filter has been applied.
-
-    Note: The sliced x will have nan chunks on the sliced axes.
-    """
-    from .core import Array, blockwise, elemwise
-
-    out_index = [
-        slice(None) if isinstance(ind, Array) and ind.dtype == bool else ind
-        for ind in index
-    ]
-
-    if len(index) == 1 and index[0].ndim == x.ndim:
-        if not np.isnan(x.shape).any() and not np.isnan(index[0].shape).any():
-            x = x.ravel()
-            index = tuple(i.ravel() for i in index)
-        elif x.ndim > 1:
-            warnings.warn(
-                "When slicing a Dask array of unknown chunks with a boolean mask "
-                "Dask array, the output array may have a different ordering "
-                "compared to the equivalent NumPy operation. This will raise an "
-                "error in a future release of Dask.",
-                stacklevel=3,
-            )
-        y = elemwise(getitem, x, *index, dtype=x.dtype)
-        name = "getitem-" + tokenize(x, index)
-        dsk = {(name, i): k for i, k in enumerate(core.flatten(y.__dask_keys__()))}
-        chunks = ((np.nan,) * y.npartitions,)
-        graph = HighLevelGraph.from_collections(name, dsk, dependencies=[y])
-        return Array(graph, name, chunks, x.dtype), out_index
-
-    if any(
-        isinstance(ind, Array) and ind.dtype == bool and ind.ndim != 1 for ind in index
-    ):
-        raise NotImplementedError(
-            "Slicing with dask.array of bools only permitted when "
-            "the indexer has only one dimension or when "
-            "it has the same dimension as the sliced "
-            "array"
-        )
-    indexes = [
-        ind if isinstance(ind, Array) and ind.dtype == bool else slice(None)
-        for ind in index
-    ]
-
-    arginds = []
-    i = 0
-    for ind in indexes:
-        if isinstance(ind, Array) and ind.dtype == bool:
-            new = (ind, tuple(range(i, i + ind.ndim)))
-            i += x.ndim
-        else:
-            new = (slice(None), None)
-            i += 1
-        arginds.append(new)
-
-    arginds = list(concat(arginds))
-
-    out = blockwise(
-        getitem_variadic,
-        tuple(range(x.ndim)),
-        x,
-        tuple(range(x.ndim)),
-        *arginds,
-        dtype=x.dtype
-    )
-
-    chunks = []
-    for ind, chunk in zip(index, out.chunks):
-        if isinstance(ind, Array) and ind.dtype == bool:
-            chunks.append((np.nan,) * len(chunk))
-        else:
-            chunks.append(chunk)
-    out._chunks = tuple(chunks)
-    return out, tuple(out_index)
-
-
-def getitem_variadic(x, *index):
-    return x[index]
-
-
-def make_block_sorted_slices(index, chunks):
-    """Generate blockwise-sorted index pairs for shuffling an array.
-
-    Parameters
-    ----------
-    index : ndarray
-        An array of index positions.
-    chunks : tuple
-        Chunks from the original dask array
-
-    Returns
-    -------
-    index2 : ndarray
-        Same values as `index`, but each block has been sorted
-    index3 : ndarray
-        The location of the values of `index` in `index2`
-
-    Examples
-    --------
-    >>> index = np.array([6, 0, 4, 2, 7, 1, 5, 3])
-    >>> chunks = ((4, 4),)
-    >>> a, b = make_block_sorted_slices(index, chunks)
-
-    Notice that the first set of 4 items are sorted, and the
-    second set of 4 items are sorted.
-
-    >>> a
-    array([0, 2, 4, 6, 1, 3, 5, 7])
-    >>> b
-    array([3, 0, 2, 1, 7, 4, 6, 5])
-    """
-    from .core import slices_from_chunks
-
-    slices = slices_from_chunks(chunks)
-
-    if len(slices[0]) > 1:
-        slices = [slice_[0] for slice_ in slices]
-
-    offsets = np.roll(np.cumsum(chunks[0]), 1)
-    offsets[0] = 0
-
-    index2 = np.empty_like(index)
-    index3 = np.empty_like(index)
-
-    for slice_, offset in zip(slices, offsets):
-        a = index[slice_]
-        b = np.sort(a)
-        c = offset + np.argsort(b.take(np.argsort(a)))
-        index2[slice_] = b
-        index3[slice_] = c
-
-    return index2, index3
-
-
-def shuffle_slice(x, index):
-    """A relatively efficient way to shuffle `x` according to `index`.
-
-    Parameters
-    ----------
-    x : Array
-    index : ndarray
-        This should be an ndarray the same length as `x` containing
-        each index position in ``range(0, len(x))``.
-
-    Returns
-    -------
-    Array
-    """
-    from .core import PerformanceWarning
-
-    chunks1 = chunks2 = x.chunks
-    if x.ndim > 1:
-        chunks1 = (chunks1[0],)
-    index2, index3 = make_block_sorted_slices(index, chunks1)
-    with warnings.catch_warnings():
-        warnings.simplefilter("ignore", PerformanceWarning)
-        return x[index2].rechunk(chunks2)[index3]
-
-
-class _HashIdWrapper(object):
-    """Hash and compare a wrapped object by identity instead of value"""
-
-    def __init__(self, wrapped):
-        self.wrapped = wrapped
-
-    def __eq__(self, other):
-        if not isinstance(other, _HashIdWrapper):
-            return NotImplemented
-        return self.wrapped is other.wrapped
-
-    def __ne__(self, other):
-        if not isinstance(other, _HashIdWrapper):
-            return NotImplemented
-        return self.wrapped is not other.wrapped
-
-    def __hash__(self):
-        return id(self.wrapped)
-
-
-@functools.lru_cache()
-def _cumsum(seq, initial_zero):
-    if isinstance(seq, _HashIdWrapper):
-        seq = seq.wrapped
-    if initial_zero:
-        return tuple(accumulate(add, seq, 0))
-    else:
-        return tuple(accumulate(add, seq))
-
-
-def cached_cumsum(seq, initial_zero=False):
-    """Compute :meth:`toolz.accumulate` with caching.
-
-    Caching is by the identify of `seq` rather than the value. It is thus
-    important that `seq` is a tuple of immutable objects, and this function
-    is intended for use where `seq` is a value that will persist (generally
-    block sizes).
-
-    Parameters
-    ----------
-    seq : tuple
-        Values to cumulatively sum.
-    initial_zero : bool, optional
-        If true, the return value is prefixed with a zero.
-
-    Returns
-    -------
-    tuple
-    """
-    if isinstance(seq, tuple):
-        # Look up by identity first, to avoid a linear-time __hash__
-        # if we've seen this tuple object before.
-        result = _cumsum(_HashIdWrapper(seq), initial_zero)
-    else:
-        # Construct a temporary tuple, and look up by value.
-        result = _cumsum(tuple(seq), initial_zero)
-    return result
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/stats.py b/Flaskserver/venv/Lib/site-packages/dask/array/stats.py
deleted file mode 100644
index 3da9dcb08058e61d9cd8615cf9fdff2f26028957..0000000000000000000000000000000000000000
--- a/Flaskserver/venv/Lib/site-packages/dask/array/stats.py
+++ /dev/null
@@ -1,465 +0,0 @@
-"""
-Statistical functions and tests, following scipy.stats.
-
-Some differences
-
-- We don't handle missing values at all
-
-"""
-# This is lightly adapted from scipy.stats 0.19
-# https://github.com/scipy/scipy/blob/v0.19.0/scipy/stats/stats.py
-# The original copyright notice follows:
-
-# Copyright 2002 Gary Strangman.  All rights reserved
-# Copyright 2002-2016 The SciPy Developers
-#
-# The original code from Gary Strangman was heavily adapted for
-# use in SciPy by Travis Oliphant.  The original code came with the
-# following disclaimer:
-#
-# This software is provided "as-is".  There are no expressed or implied
-# warranties of any kind, including, but not limited to, the warranties
-# of merchantability and fitness for a given application.  In no event
-# shall Gary Strangman be liable for any direct, indirect, incidental,
-# special, exemplary or consequential damages (including, but not limited
-# to, 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.
-import math
-
-import numpy as np
-import dask.array as da
-from dask.array.ufunc import wrap_elemwise
-from dask.utils import derived_from
-from dask import delayed
-
-try:
-    import scipy.stats
-except ImportError as e:
-    raise ImportError("`dask.array.stats` requires `scipy` to be installed.") from e
-from scipy.stats import distributions
-from scipy import special
-from scipy.stats.stats import (
-    Ttest_indResult,
-    Ttest_1sampResult,
-    Ttest_relResult,
-    Power_divergenceResult,
-    NormaltestResult,
-    SkewtestResult,
-    KurtosistestResult,
-    F_onewayResult,
-)
-
-
-__all__ = [
-    "ttest_ind",
-    "ttest_1samp",
-    "ttest_rel",
-    "chisquare",
-    "power_divergence",
-    "skew",
-    "skewtest",
-    "kurtosis",
-    "kurtosistest",
-    "normaltest",
-    "f_oneway",
-    "moment",
-]
-
-# -----------------
-# Statistical Tests
-# -----------------
-
-
-@derived_from(scipy.stats)
-def ttest_ind(a, b, axis=0, equal_var=True):
-    v1 = da.var(a, axis, ddof=1)  # XXX: np -> da
-    v2 = da.var(b, axis, ddof=1)  # XXX: np -> da
-    n1 = a.shape[axis]
-    n2 = b.shape[axis]
-
-    if equal_var:
-        df, denom = _equal_var_ttest_denom(v1, n1, v2, n2)
-    else:
-        df, denom = _unequal_var_ttest_denom(v1, n1, v2, n2)
-
-    res = _ttest_ind_from_stats(da.mean(a, axis), da.mean(b, axis), denom, df)
-
-    return delayed(Ttest_indResult, nout=2)(*res)
-
-
-@derived_from(scipy.stats)
-def ttest_1samp(a, popmean, axis=0, nan_policy="propagate"):
-    if nan_policy != "propagate":
-        raise NotImplementedError(
-            "`nan_policy` other than 'propagate' have not been implemented."
-        )
-    n = a.shape[axis]
-    df = n - 1
-
-    d = da.mean(a, axis) - popmean
-    v = da.var(a, axis, ddof=1)
-    denom = da.sqrt(v / float(n))
-
-    with np.errstate(divide="ignore", invalid="ignore"):
-        t = da.divide(d, denom)
-    t, prob = _ttest_finish(df, t)
-    return delayed(Ttest_1sampResult, nout=2)(t, prob)
-
-
-@derived_from(scipy.stats)
-def ttest_rel(a, b, axis=0, nan_policy="propagate"):
-    if nan_policy != "propagate":
-        raise NotImplementedError(
-            "`nan_policy` other than 'propagate' have not been implemented."
-        )
-
-    n = a.shape[axis]
-    df = float(n - 1)
-
-    d = (a - b).astype(np.float64)
-    v = da.var(d, axis, ddof=1)
-    dm = da.mean(d, axis)
-    denom = da.sqrt(v / float(n))
-
-    with np.errstate(divide="ignore", invalid="ignore"):
-        t = da.divide(dm, denom)
-    t, prob = _ttest_finish(df, t)
-
-    return delayed(Ttest_relResult, nout=2)(t, prob)
-
-
-@derived_from(scipy.stats)
-def chisquare(f_obs, f_exp=None, ddof=0, axis=0):
-    return power_divergence(f_obs, f_exp=f_exp, ddof=ddof, axis=axis, lambda_="pearson")
-
-
-@derived_from(scipy.stats)
-def power_divergence(f_obs, f_exp=None, ddof=0, axis=0, lambda_=None):
-
-    if isinstance(lambda_, str):
-        # TODO: public api
-        if lambda_ not in scipy.stats.stats._power_div_lambda_names:
-            names = repr(list(scipy.stats.stats._power_div_lambda_names.keys()))[1:-1]
-            raise ValueError(
-                "invalid string for lambda_: {0!r}.  Valid strings "
-                "are {1}".format(lambda_, names)
-            )
-        lambda_ = scipy.stats.stats._power_div_lambda_names[lambda_]
-    elif lambda_ is None:
-        lambda_ = 1
-
-    if f_exp is not None:
-        # f_exp = np.atleast_1d(np.asanyarray(f_exp))
-        pass
-    else:
-        f_exp = f_obs.mean(axis=axis, keepdims=True)
-
-    # `terms` is the array of terms that are summed along `axis` to create
-    # the test statistic.  We use some specialized code for a few special
-    # cases of lambda_.
-    if lambda_ == 1:
-        # Pearson's chi-squared statistic
-        terms = (f_obs - f_exp) ** 2 / f_exp
-    elif lambda_ == 0:
-        # Log-likelihood ratio (i.e. G-test)
-        terms = 2.0 * _xlogy(f_obs, f_obs / f_exp)
-    elif lambda_ == -1:
-        # Modified log-likelihood ratio
-        terms = 2.0 * _xlogy(f_exp, f_exp / f_obs)
-    else:
-        # General Cressie-Read power divergence.
-        terms = f_obs * ((f_obs / f_exp) ** lambda_ - 1)
-        terms /= 0.5 * lambda_ * (lambda_ + 1)
-
-    stat = terms.sum(axis=axis)
-
-    num_obs = _count(terms, axis=axis)
-    # ddof = asarray(ddof)
-    p = delayed(distributions.chi2.sf)(stat, num_obs - 1 - ddof)
-
-    return delayed(Power_divergenceResult, nout=2)(stat, p)
-
-
-@derived_from(scipy.stats)
-def skew(a, axis=0, bias=True, nan_policy="propagate"):
-    if nan_policy != "propagate":
-        raise NotImplementedError(
-            "`nan_policy` other than 'propagate' have not been implemented."
-        )
-
-    n = a.shape[axis]  # noqa; for bias
-    m2 = moment(a, 2, axis)
-    m3 = moment(a, 3, axis)
-    zero = m2 == 0
-    vals = da.where(~zero, m3 / m2 ** 1.5, 0.0)
-    # vals = da.where(~zero, (m2, m3),
-    #                 lambda m2, m3: m3 / m2**1.5,
-    #                 0.)
-    if not bias:
-        # Need a version of np.place
-        raise NotImplementedError("bias=False is not implemented.")
-
-    if vals.ndim == 0:
-        return vals
-        # TODO: scalar
-        # return vals.item()
-
-    return vals
-
-
-@derived_from(scipy.stats)
-def skewtest(a, axis=0, nan_policy="propagate"):
-    if nan_policy != "propagate":
-        raise NotImplementedError(
-            "`nan_policy` other than 'propagate' have not been implemented."
-        )
-
-    b2 = skew(a, axis)
-    n = float(a.shape[axis])
-    if n < 8:
-        raise ValueError(
-            "skewtest is not valid with less than 8 samples; %i samples"
-            " were given." % int(n)
-        )
-    y = b2 * math.sqrt(((n + 1) * (n + 3)) / (6.0 * (n - 2)))
-    beta2 = (
-        3.0
-        * (n ** 2 + 27 * n - 70)
-        * (n + 1)
-        * (n + 3)
-        / ((n - 2.0) * (n + 5) * (n + 7) * (n + 9))
-    )
-    W2 = -1 + math.sqrt(2 * (beta2 - 1))
-    delta = 1 / math.sqrt(0.5 * math.log(W2))
-    alpha = math.sqrt(2.0 / (W2 - 1))
-    y = np.where(y == 0, 1, y)
-    Z = delta * np.log(y / alpha + np.sqrt((y / alpha) ** 2 + 1))
-
-    return delayed(SkewtestResult, nout=2)(Z, 2 * distributions.norm.sf(np.abs(Z)))
-
-
-@derived_from(scipy.stats)
-def kurtosis(a, axis=0, fisher=True, bias=True, nan_policy="propagate"):
-    if nan_policy != "propagate":
-        raise NotImplementedError(
-            "`nan_policy` other than 'propagate' have not been implemented."
-        )
-    n = a.shape[axis]  # noqa; for bias
-    m2 = moment(a, 2, axis)
-    m4 = moment(a, 4, axis)
-    zero = m2 == 0
-    olderr = np.seterr(all="ignore")
-    try:
-        vals = da.where(zero, 0, m4 / m2 ** 2.0)
-    finally:
-        np.seterr(**olderr)
-
-    if not bias:
-        # need a version of np.place
-        raise NotImplementedError("bias=False is not implemented.")
-
-    if fisher:
-        return vals - 3
-    else:
-        return vals
-        # TODO: scalar; vals = vals.item()  # array scalar
-
-
-@derived_from(scipy.stats)
-def kurtosistest(a, axis=0, nan_policy="propagate"):
-    if nan_policy != "propagate":
-        raise NotImplementedError(
-            "`nan_policy` other than 'propagate' have not been implemented."
-        )
-
-    n = float(a.shape[axis])
-    b2 = kurtosis(a, axis, fisher=False)
-
-    E = 3.0 * (n - 1) / (n + 1)
-    varb2 = (
-        24.0 * n * (n - 2) * (n - 3) / ((n + 1) * (n + 1.0) * (n + 3) * (n + 5))
-    )  # [1]_ Eq. 1
-    x = (b2 - E) / np.sqrt(varb2)  # [1]_ Eq. 4
-    # [1]_ Eq. 2:
-    sqrtbeta1 = (
-        6.0
-        * (n * n - 5 * n + 2)
-        / ((n + 7) * (n + 9))
-        * np.sqrt((6.0 * (n + 3) * (n + 5)) / (n * (n - 2) * (n - 3)))
-    )
-    # [1]_ Eq. 3:
-    A = 6.0 + 8.0 / sqrtbeta1 * (2.0 / sqrtbeta1 + np.sqrt(1 + 4.0 / (sqrtbeta1 ** 2)))
-    term1 = 1 - 2 / (9.0 * A)
-    denom = 1 + x * np.sqrt(2 / (A - 4.0))
-    denom = np.where(denom < 0, 99, denom)
-    term2 = np.where(denom < 0, term1, np.power((1 - 2.0 / A) / denom, 1 / 3.0))
-    Z = (term1 - term2) / np.sqrt(2 / (9.0 * A))  # [1]_ Eq. 5
-    Z = np.where(denom == 99, 0, Z)
-    if Z.ndim == 0:
-        Z = Z[()]
-
-    # zprob uses upper tail, so Z needs to be positive
-    return delayed(KurtosistestResult, nout=2)(Z, 2 * distributions.norm.sf(np.abs(Z)))
-
-
-@derived_from(scipy.stats)
-def normaltest(a, axis=0, nan_policy="propagate"):
-    if nan_policy != "propagate":
-        raise NotImplementedError(
-            "`nan_policy` other than 'propagate' have not been implemented."
-        )
-
-    s, _ = skewtest(a, axis)
-    k, _ = kurtosistest(a, axis)
-    k2 = s * s + k * k
-    return delayed(NormaltestResult, nout=2)(k2, delayed(distributions.chi2.sf)(k2, 2))
-
-
-@derived_from(scipy.stats)
-def f_oneway(*args):
-    # args = [np.asarray(arg, dtype=float) for arg in args]
-    # ANOVA on N groups, each in its own array
-    num_groups = len(args)
-    alldata = da.concatenate(args)
-    bign = len(alldata)
-
-    # Determine the mean of the data, and subtract that from all inputs to a
-    # variance (via sum_of_sq / sq_of_sum) calculation.  Variance is invariance
-    # to a shift in location, and centering all data around zero vastly
-    # improves numerical stability.
-    offset = alldata.mean()
-    alldata -= offset
-
-    sstot = _sum_of_squares(alldata) - (_square_of_sums(alldata) / float(bign))
-    ssbn = 0
-    for a in args:
-        ssbn += _square_of_sums(a - offset) / float(len(a))
-
-    # Naming: variables ending in bn/b are for "between treatments", wn/w are
-    # for "within treatments"
-    ssbn -= _square_of_sums(alldata) / float(bign)
-    sswn = sstot - ssbn
-    dfbn = num_groups - 1
-    dfwn = bign - num_groups
-    msb = ssbn / float(dfbn)
-    msw = sswn / float(dfwn)
-    f = msb / msw
-
-    prob = _fdtrc(dfbn, dfwn, f)  # equivalent to stats.f.sf
-
-    return delayed(F_onewayResult, nout=2)(f, prob)
-
-
-@derived_from(scipy.stats)
-def moment(a, moment=1, axis=0, nan_policy="propagate"):
-    if nan_policy != "propagate":
-        raise NotImplementedError(
-            "`nan_policy` other than 'propagate' have not been implemented."
-        )
-    return da.moment(a, moment, axis=axis)
-
-
-# -------
-# Helpers
-# -------
-# Don't really want to do all of scipy.special (or do we?)
-
-_xlogy = wrap_elemwise(special.xlogy, source=special)
-_fdtrc = wrap_elemwise(special.fdtrc, source=special)
-
-
-def _equal_var_ttest_denom(v1, n1, v2, n2):
-    df = n1 + n2 - 2.0
-    svar = ((n1 - 1) * v1 + (n2 - 1) * v2) / df
-    denom = da.sqrt(svar * (1.0 / n1 + 1.0 / n2))  # XXX: np -> da
-    return df, denom
-
-
-def _unequal_var_ttest_denom(v1, n1, v2, n2):
-    vn1 = v1 / n1
-    vn2 = v2 / n2
-    with np.errstate(divide="ignore", invalid="ignore"):
-        df = (vn1 + vn2) ** 2 / (vn1 ** 2 / (n1 - 1) + vn2 ** 2 / (n2 - 1))
-
-    # If df is undefined, variances are zero (assumes n1 > 0 & n2 > 0).
-    # Hence it doesn't matter what df is as long as it's not NaN.
-    df = da.where(da.isnan(df), 1, df)  # XXX: np -> da
-    denom = da.sqrt(vn1 + vn2)
-    return df, denom
-
-
-def _ttest_ind_from_stats(mean1, mean2, denom, df):
-
-    d = mean1 - mean2
-    with np.errstate(divide="ignore", invalid="ignore"):
-        t = da.divide(d, denom)
-    t, prob = _ttest_finish(df, t)
-
-    return (t, prob)
-
-
-def _ttest_finish(df, t):
-    """Common code between all 3 t-test functions."""
-    # XXX: np.abs -> da.absolute
-    # XXX: delayed(distributions.t.sf)
-    prob = (
-        delayed(distributions.t.sf)(da.absolute(t), df) * 2
-    )  # use np.abs to get upper tail
-    if t.ndim == 0:
-        t = t[()]
-
-    return t, prob
-
-
-def _count(x, axis=None):
-    if axis is None:
-        return x.size
-    else:
-        return x.shape[axis]
-
-
-def _sum_of_squares(a, axis=0):
-    """
-    Squares each element of the input array, and returns the sum(s) of that.
-    Parameters
-    ----------
-    a : array_like
-        Input array.
-    axis : int or None, optional
-        Axis along which to calculate. Default is 0. If None, compute over
-        the whole array `a`.
-    Returns
-    -------
-    sum_of_squares : ndarray
-        The sum along the given axis for (a**2).
-    See also
-    --------
-    _square_of_sums : The square(s) of the sum(s) (the opposite of
-    `_sum_of_squares`).
-    """
-    return da.sum(a * a, axis)
-
-
-def _square_of_sums(a, axis=0):
-    """
-    Sums elements of the input array, and returns the square(s) of that sum.
-    Parameters
-    ----------
-    a : array_like
-        Input array.
-    axis : int or None, optional
-        Axis along which to calculate. Default is 0. If None, compute over
-        the whole array `a`.
-    Returns
-    -------
-    square_of_sums : float or ndarray
-        The square of the sum over `axis`.
-    See also
-    --------
-    _sum_of_squares : The sum of squares (the opposite of `square_of_sums`).
-    """
-    s = da.sum(a, axis)
-    return s * s
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/svg.py b/Flaskserver/venv/Lib/site-packages/dask/array/svg.py
deleted file mode 100644
index 29b2e7a86fc9e68ed5c23b32e95452fb5d8dd124..0000000000000000000000000000000000000000
--- a/Flaskserver/venv/Lib/site-packages/dask/array/svg.py
+++ /dev/null
@@ -1,269 +0,0 @@
-import math
-import re
-
-import numpy as np
-
-
-def svg(chunks, size=200, **kwargs):
-    """Convert chunks from Dask Array into an SVG Image
-
-    Parameters
-    ----------
-    chunks: tuple
-    size: int
-        Rough size of the image
-
-    Returns
-    -------
-    text: An svg string depicting the array as a grid of chunks
-    """
-    shape = tuple(map(sum, chunks))
-    if np.isnan(shape).any():  # don't support unknown sizes
-        raise NotImplementedError(
-            "Can't generate SVG with unknown chunk sizes.\n\n"
-            " A possible solution is with x.compute_chunk_sizes()"
-        )
-    if not all(shape):
-        raise NotImplementedError("Can't generate SVG with 0-length dimensions")
-    if len(chunks) == 0:
-        raise NotImplementedError("Can't generate SVG with 0 dimensions")
-    if len(chunks) == 1:
-        return svg_1d(chunks, size=size, **kwargs)
-    elif len(chunks) == 2:
-        return svg_2d(chunks, size=size, **kwargs)
-    elif len(chunks) == 3:
-        return svg_3d(chunks, size=size, **kwargs)
-    else:
-        return svg_nd(chunks, size=size, **kwargs)
-
-
-text_style = 'font-size="1.0rem" font-weight="100" text-anchor="middle"'
-
-
-def svg_2d(chunks, offset=(0, 0), skew=(0, 0), size=200, sizes=None):
-    shape = tuple(map(sum, chunks))
-    sizes = sizes or draw_sizes(shape, size=size)
-    y, x = grid_points(chunks, sizes)
-
-    lines, (min_x, max_x, min_y, max_y) = svg_grid(x, y, offset=offset, skew=skew)
-
-    header = (
-        '<svg width="%d" height="%d" style="stroke:rgb(0,0,0);stroke-width:1" >\n'
-        % (max_x + 50, max_y + 50)
-    )
-    footer = "\n</svg>"
-
-    if shape[0] >= 100:
-        rotate = -90
-    else:
-        rotate = 0
-
-    text = [
-        "",
-        "  <!-- Text -->",
-        '  <text x="%f" y="%f" %s >%d</text>'
-        % (max_x / 2, max_y + 20, text_style, shape[1]),
-        '  <text x="%f" y="%f" %s transform="rotate(%d,%f,%f)">%d</text>'
-        % (max_x + 20, max_y / 2, text_style, rotate, max_x + 20, max_y / 2, shape[0]),
-    ]
-
-    return header + "\n".join(lines + text) + footer
-
-
-def svg_3d(chunks, size=200, sizes=None, offset=(0, 0)):
-    shape = tuple(map(sum, chunks))
-    sizes = sizes or draw_sizes(shape, size=size)
-    x, y, z = grid_points(chunks, sizes)
-    ox, oy = offset
-
-    xy, (mnx, mxx, mny, mxy) = svg_grid(
-        x / 1.7, y, offset=(ox + 10, oy + 0), skew=(1, 0)
-    )
-
-    zx, (_, _, _, max_x) = svg_grid(z, x / 1.7, offset=(ox + 10, oy + 0), skew=(0, 1))
-    zy, (min_z, max_z, min_y, max_y) = svg_grid(
-        z, y, offset=(ox + max_x + 10, oy + max_x), skew=(0, 0)
-    )
-
-    header = (
-        '<svg width="%d" height="%d" style="stroke:rgb(0,0,0);stroke-width:1" >\n'
-        % (max_z + 50, max_y + 50)
-    )
-    footer = "\n</svg>"
-
-    if shape[1] >= 100:
-        rotate = -90
-    else:
-        rotate = 0
-
-    text = [
-        "",
-        "  <!-- Text -->",
-        '  <text x="%f" y="%f" %s >%d</text>'
-        % ((min_z + max_z) / 2, max_y + 20, text_style, shape[2]),
-        '  <text x="%f" y="%f" %s transform="rotate(%d,%f,%f)">%d</text>'
-        % (
-            max_z + 20,
-            (min_y + max_y) / 2,
-            text_style,
-            rotate,
-            max_z + 20,
-            (min_y + max_y) / 2,
-            shape[1],
-        ),
-        '  <text x="%f" y="%f" %s transform="rotate(45,%f,%f)">%d</text>'
-        % (
-            (mnx + mxx) / 2 - 10,
-            mxy - (mxx - mnx) / 2 + 20,
-            text_style,
-            (mnx + mxx) / 2 - 10,
-            mxy - (mxx - mnx) / 2 + 20,
-            shape[0],
-        ),
-    ]
-
-    return header + "\n".join(xy + zx + zy + text) + footer
-
-
-def svg_nd(chunks, size=200):
-    if len(chunks) % 3 == 1:
-        chunks = ((1,),) + chunks
-    shape = tuple(map(sum, chunks))
-    sizes = draw_sizes(shape, size=size)
-
-    chunks2 = chunks
-    sizes2 = sizes
-    out = []
-    left = 0
-    total_height = 0
-    while chunks2:
-        n = len(chunks2) % 3 or 3
-        o = svg(chunks2[:n], sizes=sizes2[:n], offset=(left, 0))
-        chunks2 = chunks2[n:]
-        sizes2 = sizes2[n:]
-
-        lines = o.split("\n")
-        header = lines[0]
-        height = float(re.search(r'height="(\d*\.?\d*)"', header).groups()[0])
-        total_height = max(total_height, height)
-        width = float(re.search(r'width="(\d*\.?\d*)"', header).groups()[0])
-        left += width + 10
-        o = "\n".join(lines[1:-1])  # remove header and footer
-
-        out.append(o)
-
-    header = (
-        '<svg width="%d" height="%d" style="stroke:rgb(0,0,0);stroke-width:1" >\n'
-        % (left, total_height)
-    )
-    footer = "\n</svg>"
-    return header + "\n\n".join(out) + footer
-
-
-def svg_lines(x1, y1, x2, y2):
-    """Convert points into lines of text for an SVG plot
-
-    Examples
-    --------
-    >>> svg_lines([0, 1], [0, 0], [10, 11], [1, 1])  # doctest: +NORMALIZE_WHITESPACE
-    ['  <line x1="0" y1="0" x2="10" y2="1" style="stroke-width:2" />',
-     '  <line x1="1" y1="0" x2="11" y2="1" style="stroke-width:2" />']
-    """
-    n = len(x1)
-    lines = [
-        '  <line x1="%d" y1="%d" x2="%d" y2="%d" />' % (x1[i], y1[i], x2[i], y2[i])
-        for i in range(n)
-    ]
-
-    lines[0] = lines[0].replace(" /", ' style="stroke-width:2" /')
-    lines[-1] = lines[-1].replace(" /", ' style="stroke-width:2" /')
-    return lines
-
-
-def svg_grid(x, y, offset=(0, 0), skew=(0, 0)):
-    """Create lines of SVG text that show a grid
-
-    Parameters
-    ----------
-    x: numpy.ndarray
-    y: numpy.ndarray
-    offset: tuple
-        translational displacement of the grid in SVG coordinates
-    skew: tuple
-    """
-    # Horizontal lines
-    x1 = np.zeros_like(y) + offset[0]
-    y1 = y + offset[1]
-    x2 = np.full_like(y, x[-1]) + offset[0]
-    y2 = y + offset[1]
-
-    if skew[0]:
-        y2 += x.max() * skew[0]
-    if skew[1]:
-        x1 += skew[1] * y
-        x2 += skew[1] * y
-
-    min_x = min(x1.min(), x2.min())
-    min_y = min(y1.min(), y2.min())
-    max_x = max(x1.max(), x2.max())
-    max_y = max(y1.max(), y2.max())
-
-    h_lines = ["", "  <!-- Horizontal lines -->"] + svg_lines(x1, y1, x2, y2)
-
-    # Vertical lines
-    x1 = x + offset[0]
-    y1 = np.zeros_like(x) + offset[1]
-    x2 = x + offset[0]
-    y2 = np.full_like(x, y[-1]) + offset[1]
-
-    if skew[0]:
-        y1 += skew[0] * x
-        y2 += skew[0] * x
-    if skew[1]:
-        x2 += skew[1] * y.max()
-
-    v_lines = ["", "  <!-- Vertical lines -->"] + svg_lines(x1, y1, x2, y2)
-
-    rect = [
-        "",
-        "  <!-- Colored Rectangle -->",
-        '  <polygon points="%f,%f %f,%f %f,%f %f,%f" style="fill:#ECB172A0;stroke-width:0"/>'
-        % (x1[0], y1[0], x1[-1], y1[-1], x2[-1], y2[-1], x2[0], y2[0]),
-    ]
-
-    return h_lines + v_lines + rect, (min_x, max_x, min_y, max_y)
-
-
-def svg_1d(chunks, sizes=None, **kwargs):
-    return svg_2d(((1,),) + chunks, **kwargs)
-
-
-def grid_points(chunks, sizes):
-    cumchunks = [np.cumsum((0,) + c) for c in chunks]
-    points = [x * size / x[-1] for x, size in zip(cumchunks, sizes)]
-    return points
-
-
-def draw_sizes(shape, size=200):
-    """ Get size in pixels for all dimensions """
-    mx = max(shape)
-    ratios = [mx / max(0.1, d) for d in shape]
-    ratios = [ratio_response(r) for r in ratios]
-    return tuple(size / r for r in ratios)
-
-
-def ratio_response(x):
-    """How we display actual size ratios
-
-    Common ratios in sizes span several orders of magnitude,
-    which is hard for us to perceive.
-
-    We keep ratios in the 1-3 range accurate, and then apply a logarithm to
-    values up until about 100 or so, at which point we stop scaling.
-    """
-    if x < math.e:
-        return x
-    elif x <= 100:
-        return math.log(x + 12.4)  # f(e) == e
-    else:
-        return math.log(100 + 12.4)
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/tests/__init__.py b/Flaskserver/venv/Lib/site-packages/dask/array/tests/__init__.py
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/__init__.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/__init__.cpython-38.pyc
deleted file mode 100644
index 4c0f6f50fac7eb47a8d44474ced12e65af04a4ee..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/__init__.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_array_core.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_array_core.cpython-38.pyc
deleted file mode 100644
index 9fbfc5e8cc154117a724108c0529457e1a56d8db..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_array_core.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_array_function.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_array_function.cpython-38.pyc
deleted file mode 100644
index ba19634fecac2ea16121ab795f0c0c5e6fab641a..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_array_function.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_array_utils.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_array_utils.cpython-38.pyc
deleted file mode 100644
index b2c8d7e4ff62c4e14718d67924bc6b1fbacde2a3..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_array_utils.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_atop.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_atop.cpython-38.pyc
deleted file mode 100644
index cc412b9c39b6d59bf9b5e7b85edd53ca55eb7c56..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_atop.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_chunk.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_chunk.cpython-38.pyc
deleted file mode 100644
index 32f0b3807d612bdef741e11935e7824f9a7850ac..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_chunk.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_creation.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_creation.cpython-38.pyc
deleted file mode 100644
index 7b334768edc1da3a1a4ce0915eb52cc79cd055d2..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_creation.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_cupy.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_cupy.cpython-38.pyc
deleted file mode 100644
index dcb693cf53b25acd64588e0f19957834b88fef6a..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_cupy.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_fft.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_fft.cpython-38.pyc
deleted file mode 100644
index c240072240e8bb60d38983e7a8b1c65a637cc0dd..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_fft.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_gufunc.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_gufunc.cpython-38.pyc
deleted file mode 100644
index 2cabc3a2feb1a9dea1354a3ba36d941cfe0fa889..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_gufunc.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_image.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_image.cpython-38.pyc
deleted file mode 100644
index 6f64e71f905a4445b47f1f775432609813f0502c..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_image.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_linalg.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_linalg.cpython-38.pyc
deleted file mode 100644
index f48d40ec639e44fe5cce41ac99ad5de0ed5a464a..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_linalg.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_linearoperator.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_linearoperator.cpython-38.pyc
deleted file mode 100644
index e7afe5eff90531bd7b5168b87f5e222601bca368..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_linearoperator.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_masked.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_masked.cpython-38.pyc
deleted file mode 100644
index e69b20b3182d0fc102b9ba411f6c3ea6f67d4f5c..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_masked.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_numpy_compat.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_numpy_compat.cpython-38.pyc
deleted file mode 100644
index f6b6f99090f4c85baa2facd0bafd2b505842b84c..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_numpy_compat.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_optimization.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_optimization.cpython-38.pyc
deleted file mode 100644
index 1293b30d283bd14b168e25d08bea4246af99c006..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_optimization.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_overlap.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_overlap.cpython-38.pyc
deleted file mode 100644
index 50f9e59fc289ced0617e5c94dbe8183c5111443a..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_overlap.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_percentiles.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_percentiles.cpython-38.pyc
deleted file mode 100644
index 50aa206764a5beb49d4414e5bc6b73310c345326..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_percentiles.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_random.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_random.cpython-38.pyc
deleted file mode 100644
index 69a5909b4d245cf2818cccda21786cc2029e6eb9..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_random.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_rechunk.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_rechunk.cpython-38.pyc
deleted file mode 100644
index db47cd736ef7a977cc43baecb07779a1bbf567e5..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_rechunk.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_reductions.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_reductions.cpython-38.pyc
deleted file mode 100644
index ebc70974640722e10e5a92c96428a31db643f60d..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_reductions.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_reshape.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_reshape.cpython-38.pyc
deleted file mode 100644
index 6340ca33f52181d5348f47e19aa604bd40090a65..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_reshape.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_routines.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_routines.cpython-38.pyc
deleted file mode 100644
index ae580ee5f7d0ad95c476ee9875f75b72d45e64c9..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_routines.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_slicing.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_slicing.cpython-38.pyc
deleted file mode 100644
index 0da4c63d8e79426f18276000e7513515168d5732..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_slicing.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_sparse.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_sparse.cpython-38.pyc
deleted file mode 100644
index 52999a534c1be5777eb03806497effda25879bd4..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_sparse.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_stats.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_stats.cpython-38.pyc
deleted file mode 100644
index 93b1fbab3c4402e3390a1c94a245669806a00651..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_stats.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_svg.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_svg.cpython-38.pyc
deleted file mode 100644
index 0b9477abfe9303ac24696bcd58b55205ad1e85c5..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_svg.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_testing.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_testing.cpython-38.pyc
deleted file mode 100644
index f8725a5284bf48033461773230e59bc986d6319a..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_testing.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_ufunc.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_ufunc.cpython-38.pyc
deleted file mode 100644
index 7161633fb4d8059393eb0a8c90b87bcf63edc0f8..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_ufunc.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_wrap.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_wrap.cpython-38.pyc
deleted file mode 100644
index b9c2915daf6c4cedbef10681b659f4e49b074095..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_wrap.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_xarray.cpython-38.pyc b/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_xarray.cpython-38.pyc
deleted file mode 100644
index 8bf8b89fd95b59073ecaa7a2f5ae406f082d6826..0000000000000000000000000000000000000000
Binary files a/Flaskserver/venv/Lib/site-packages/dask/array/tests/__pycache__/test_xarray.cpython-38.pyc and /dev/null differ
diff --git a/Flaskserver/venv/Lib/site-packages/dask/array/tests/test_array_core.py b/Flaskserver/venv/Lib/site-packages/dask/array/tests/test_array_core.py
deleted file mode 100644
index ec65561d2a76286e2e96c1df6e90c390487f9e85..0000000000000000000000000000000000000000
--- a/Flaskserver/venv/Lib/site-packages/dask/array/tests/test_array_core.py
+++ /dev/null
@@ -1,4433 +0,0 @@
-import copy
-
-import pytest
-
-np = pytest.importorskip("numpy")
-
-import os
-import time
-from io import StringIO
-from distutils.version import LooseVersion
-import operator
-from operator import add, sub, getitem
-from threading import Lock
-import warnings
-
-from tlz import merge, countby, concat
-from tlz.curried import identity
-
-import dask
-import dask.array as da
-import dask.dataframe
-from dask.base import tokenize, compute_as_if_collection
-from dask.delayed import Delayed, delayed
-from dask.utils import ignoring, tmpfile, tmpdir, key_split, apply
-from dask.utils_test import inc, dec
-
-from dask.array.core import (
-    getem,
-    getter,
-    dotmany,
-    concatenate3,
-    Array,
-    stack,
-    concatenate,
-    from_array,
-    broadcast_shapes,
-    broadcast_to,
-    blockdims_from_blockshape,
-    store,
-    optimize,
-    from_func,
-    normalize_chunks,
-    broadcast_chunks,
-    from_delayed,
-    common_blockdim,
-    concatenate_axes,
-)
-from dask.blockwise import (
-    make_blockwise_graph as top,
-    broadcast_dimensions,
-    optimize_blockwise,
-)
-from dask.array.utils import assert_eq, same_keys
-from dask.array.numpy_compat import _numpy_120
-
-from numpy import nancumsum, nancumprod
-
-
-def test_getem():
-    sol = {
-        ("X", 0, 0): (getter, "X", (slice(0, 2), slice(0, 3))),
-        ("X", 1, 0): (getter, "X", (slice(2, 4), slice(0, 3))),
-        ("X", 1, 1): (getter, "X", (slice(2, 4), slice(3, 6))),
-        ("X", 0, 1): (getter, "X", (slice(0, 2), slice(3, 6))),
-    }
-    assert getem("X", (2, 3), shape=(4, 6)) == sol
-
-
-def test_top():
-    assert top(inc, "z", "ij", "x", "ij", numblocks={"x": (2, 2)}) == {
-        ("z", 0, 0): (inc, ("x", 0, 0)),
-        ("z", 0, 1): (inc, ("x", 0, 1)),
-        ("z", 1, 0): (inc, ("x", 1, 0)),
-        ("z", 1, 1): (inc, ("x", 1, 1)),
-    }
-
-    assert top(
-        add, "z", "ij", "x", "ij", "y", "ij", numblocks={"x": (2, 2), "y": (2, 2)}
-    ) == {
-        ("z", 0, 0): (add, ("x", 0, 0), ("y", 0, 0)),
-        ("z", 0, 1): (add, ("x", 0, 1), ("y", 0, 1)),
-        ("z", 1, 0): (add, ("x", 1, 0), ("y", 1, 0)),
-        ("z", 1, 1): (add, ("x", 1, 1), ("y", 1, 1)),
-    }
-
-    assert top(
-        dotmany, "z", "ik", "x", "ij", "y", "jk", numblocks={"x": (2, 2), "y": (2, 2)}
-    ) == {
-        ("z", 0, 0): (dotmany, [("x", 0, 0), ("x", 0, 1)], [("y", 0, 0), ("y", 1, 0)]),
-        ("z", 0, 1): (dotmany, [("x", 0, 0), ("x", 0, 1)], [("y", 0, 1), ("y", 1, 1)]),
-        ("z", 1, 0): (dotmany, [("x", 1, 0), ("x", 1, 1)], [("y", 0, 0), ("y", 1, 0)]),
-        ("z", 1, 1): (dotmany, [("x", 1, 0), ("x", 1, 1)], [("y", 0, 1), ("y", 1, 1)]),
-    }
-
-    assert top(identity, "z", "", "x", "ij", numblocks={"x": (2, 2)}) == {
-        ("z",): (identity, [[("x", 0, 0), ("x", 0, 1)], [("x", 1, 0), ("x", 1, 1)]])
-    }
-
-
-def test_top_with_kwargs():
-    assert top(add, "z", "i", "x", "i", numblocks={"x": (2, 0)}, b=100) == {
-        ("z", 0): (apply, add, [("x", 0)], {"b": 100}),
-        ("z", 1): (apply, add, [("x", 1)], {"b": 100}),
-    }
-
-
-def test_top_supports_broadcasting_rules():
-    assert top(
-        add, "z", "ij", "x", "ij", "y", "ij", numblocks={"x": (1, 2), "y": (2, 1)}
-    ) == {
-        ("z", 0, 0): (add, ("x", 0, 0), ("y", 0, 0)),
-        ("z", 0, 1): (add, ("x", 0, 1), ("y", 0, 0)),
-        ("z", 1, 0): (add, ("x", 0, 0), ("y", 1, 0)),
-        ("z", 1, 1): (add, ("x", 0, 1), ("y", 1, 0)),
-    }
-
-
-def test_top_literals():
-    assert top(add, "z", "ij", "x", "ij", 123, None, numblocks={"x": (2, 2)}) == {
-        ("z", 0, 0): (add, ("x", 0, 0), 123),
-        ("z", 0, 1): (add, ("x", 0, 1), 123),
-        ("z", 1, 0): (add, ("x", 1, 0), 123),
-        ("z", 1, 1): (add, ("x", 1, 1), 123),
-    }
-
-
-def test_blockwise_literals():
-    x = da.ones((10, 10), chunks=(5, 5))
-    z = da.blockwise(add, "ij", x, "ij", 100, None, dtype=x.dtype)
-    assert_eq(z, x + 100)
-
-    z = da.blockwise(
-        lambda x, y, z: x * y + z, "ij", 2, None, x, "ij", 100, None, dtype=x.dtype
-    )
-    assert_eq(z, 2 * x + 100)
-
-    z = da.blockwise(getitem, "ij", x, "ij", slice(None), None, dtype=x.dtype)
-    assert_eq(z, x)
-
-
-def test_blockwise_1_in_shape_I():
-    def test_f(a, b):
-        assert 1 in b.shape
-
-    p, k, N = 7, 2, 5
-    da.blockwise(
-        test_f,
-        "x",
-        da.zeros((2 * p, 9, k * N), chunks=(p, 3, k)),
-        "xzt",
-        da.zeros((2 * p, 9, 1), chunks=(p, 3, -1)),
-        "xzt",
-        concatenate=True,
-        dtype=float,
-    ).compute()
-
-
-def test_blockwise_1_in_shape_II():
-    def test_f(a, b):
-        assert 1 in b.shape
-
-    p, k, N = 7, 2, 5
-    da.blockwise(
-        test_f,
-        "x",
-        da.zeros((2 * p, 9, k * N, 8), chunks=(p, 9, k, 4)),
-        "xztu",
-        da.zeros((2 * p, 9, 1, 8), chunks=(p, 9, -1, 4)),
-        "xztu",
-        concatenate=True,
-        dtype=float,
-    ).compute()
-
-
-def test_blockwise_1_in_shape_III():
-    def test_f(a, b):
-        assert 1 in b.shape
-
-    k, N = 2, 5
-    da.blockwise(
-        test_f,
-        "x",
-        da.zeros((k * N, 9, 8), chunks=(k, 3, 4)),
-        "xtu",
-        da.zeros((1, 9, 8), chunks=(-1, 3, 4)),
-        "xtu",
-        concatenate=True,
-        dtype=float,
-    ).compute()
-
-
-def test_concatenate3_on_scalars():
-    assert_eq(concatenate3([1, 2]), np.array([1, 2]))
-
-
-def test_chunked_dot_product():
-    x = np.arange(400).reshape((20, 20))
-    o = np.ones((20, 20))
-
-    d = {"x": x, "o": o}
-
-    getx = getem("x", (5, 5), shape=(20, 20))
-    geto = getem("o", (5, 5), shape=(20, 20))
-
-    result = top(
-        dotmany, "out", "ik", "x", "ij", "o", "jk", numblocks={"x": (4, 4), "o": (4, 4)}
-    )
-
-    dsk = merge(d, getx, geto, result)
-    out = dask.get(dsk, [[("out", i, j) for j in range(4)] for i in range(4)])
-
-    assert_eq(np.dot(x, o), concatenate3(out))
-
-
-def test_chunked_transpose_plus_one():
-    x = np.arange(400).reshape((20, 20))
-
-    d = {"x": x}
-
-    getx = getem("x", (5, 5), shape=(20, 20))
-
-    f = lambda x: x.T + 1
-    comp = top(f, "out", "ij", "x", "ji", numblocks={"x": (4, 4)})
-
-    dsk = merge(d, getx, comp)
-    out = dask.get(dsk, [[("out", i, j) for j in range(4)] for i in range(4)])
-
-    assert_eq(concatenate3(out), x.T + 1)
-
-
-def test_broadcast_dimensions_works_with_singleton_dimensions():
-    argpairs = [("x", "i")]
-    numblocks = {"x": ((1,),)}
-    assert broadcast_dimensions(argpairs, numblocks) == {"i": (1,)}
-
-
-def test_broadcast_dimensions():
-    argpairs = [("x", "ij"), ("y", "ij")]
-    d = {"x": ("Hello", 1), "y": (1, (2, 3))}
-    assert broadcast_dimensions(argpairs, d) == {"i": "Hello", "j": (2, 3)}
-
-
-def test_Array():
-    shape = (1000, 1000)
-    chunks = (100, 100)
-    name = "x"
-    dsk = merge({name: "some-array"}, getem(name, chunks, shape=shape))
-    a = Array(dsk, name, chunks, shape=shape, dtype="f8")
-
-    assert a.numblocks == (10, 10)
-
-    assert a.__dask_keys__() == [[("x", i, j) for j in range(10)] for i in range(10)]
-
-    assert a.chunks == ((100,) * 10, (100,) * 10)
-
-    assert a.shape == shape
-
-    assert len(a) == shape[0]
-
-    with pytest.raises(ValueError):
-        Array(dsk, name, chunks, shape=shape)
-    with pytest.raises(TypeError):
-        Array(dsk, name, chunks, shape=shape, dtype="f8", meta=np.empty(0, 0))
-
-
-def test_uneven_chunks():
-    a = Array({}, "x", chunks=(3, 3), shape=(10, 10), dtype="f8")
-    assert a.chunks == ((3, 3, 3, 1), (3, 3, 3, 1))
-
-
-def test_numblocks_suppoorts_singleton_block_dims():
-    shape = (100, 10)
-    chunks = (10, 10)
-    name = "x"
-    dsk = merge({name: "some-array"}, getem(name, shape=shape, chunks=chunks))
-    a = Array(dsk, name, chunks, shape=shape, dtype="f8")
-
-    assert set(concat(a.__dask_keys__())) == {("x", i, 0) for i in range(10)}
-
-
-def test_keys():
-    dsk = dict((("x", i, j), ()) for i in range(5) for j in range(6))
-    dx = Array(dsk, "x", chunks=(10, 10), shape=(50, 60), dtype="f8")
-    assert dx.__dask_keys__() == [[(dx.name, i, j) for j in range(6)] for i in range(5)]
-    # Cache works
-    assert dx.__dask_keys__() is dx.__dask_keys__()
-    # Test mutating names clears key cache
-    dx.dask = {("y", i, j): () for i in range(5) for j in range(6)}
-    dx.name = "y"
-    assert dx.__dask_keys__() == [[(dx.name, i, j) for j in range(6)] for i in range(5)]
-    d = Array({}, "x", (), shape=(), dtype="f8")
-    assert d.__dask_keys__() == [("x",)]
-
-
-def test_Array_computation():
-    a = Array({("x", 0, 0): np.eye(3)}, "x", shape=(3, 3), chunks=(3, 3), dtype="f8")
-    assert_eq(np.array(a), np.eye(3))
-    assert isinstance(a.compute(), np.ndarray)
-    assert float(a[0, 0]) == 1
-
-
-@pytest.mark.skipif(
-    LooseVersion(np.__version__) < "1.14.0",
-    reason="NumPy doesn't have `np.linalg._umath_linalg` yet",
-)
-def test_Array_numpy_gufunc_call__array_ufunc__01():
-    x = da.random.normal(size=(3, 10, 10), chunks=(2, 10, 10))
-    nx = x.compute()
-    ny = np.linalg._umath_linalg.inv(nx)
-    y = np.linalg._umath_linalg.inv(x, output_dtypes=float)
-    vy = y.compute()
-    assert_eq(ny, vy)
-
-
-@pytest.mark.skipif(
-    LooseVersion(np.__version__) < "1.14.0",
-    reason="NumPy doesn't have `np.linalg._umath_linalg` yet",
-)
-def test_Array_numpy_gufunc_call__array_ufunc__02():
-    x = da.random.normal(size=(3, 10, 10), chunks=(2, 10, 10))
-    nx = x.compute()
-    nw, nv = np.linalg._umath_linalg.eig(nx)
-    w, v = np.linalg._umath_linalg.eig(x, output_dtypes=(float, float))
-    vw = w.compute()
-    vv = v.compute()
-    assert_eq(nw, vw)
-    assert_eq(nv, vv)
-
-
-def test_stack():
-    a, b, c = [
-        Array(
-            getem(name, chunks=(2, 3), shape=(4, 6)),
-            name,
-            chunks=(2, 3),
-            dtype="f8",
-            shape=(4, 6),
-        )
-        for name in "ABC"
-    ]
-
-    s = stack([a, b, c], axis=0)
-
-    colon = slice(None, None, None)
-
-    assert s.shape == (3, 4, 6)
-    assert s.chunks == ((1, 1, 1), (2, 2), (3, 3))
-    assert s.chunksize == (1, 2, 3)
-    assert s.dask[(s.name, 0, 1, 0)] == (getitem, ("A", 1, 0), (None, colon, colon))
-    assert s.dask[(s.name, 2, 1, 0)] == (getitem, ("C", 1, 0), (None, colon, colon))
-    assert same_keys(s, stack([a, b, c], axis=0))
-
-    s2 = stack([a, b, c], axis=1)
-    assert s2.shape == (4, 3, 6)
-    assert s2.chunks == ((2, 2), (1, 1, 1), (3, 3))
-    assert s2.chunksize == (2, 1, 3)
-    assert s2.dask[(s2.name, 0, 1, 0)] == (getitem, ("B", 0, 0), (colon, None, colon))
-    assert s2.dask[(s2.name, 1, 1, 0)] == (getitem, ("B", 1, 0), (colon, None, colon))
-    assert same_keys(s2, stack([a, b, c], axis=1))
-
-    s2 = stack([a, b, c], axis=2)
-    assert s2.shape == (4, 6, 3)
-    assert s2.chunks == ((2, 2), (3, 3), (1, 1, 1))
-    assert s2.chunksize == (2, 3, 1)
-    assert s2.dask[(s2.name, 0, 1, 0)] == (getitem, ("A", 0, 1), (colon, colon, None))
-    assert s2.dask[(s2.name, 1, 1, 2)] == (getitem, ("C", 1, 1), (colon, colon, None))
-    assert same_keys(s2, stack([a, b, c], axis=2))
-
-    pytest.raises(ValueError, lambda: stack([]))
-    pytest.raises(ValueError, lambda: stack([a, b, c], axis=3))
-
-    assert set(b.dask.keys()).issubset(s2.dask.keys())
-
-    assert stack([a, b, c], axis=-1).chunks == stack([a, b, c], axis=2).chunks
-
-
-def test_stack_zero_size():
-    x = np.empty((2, 0, 3))
-    y = da.from_array(x, chunks=1)
-
-    result_np = np.concatenate([x, x])
-    result_da = da.concatenate([y, y])
-
-    assert_eq(result_np, result_da)
-
-
-def test_short_stack():
-    x = np.array([1])
-    d = da.from_array(x, chunks=(1,))
-    s = da.stack([d])
-    assert s.shape == (1, 1)
-    chunks = compute_as_if_collection(Array, s.dask, s.__dask_keys__())
-    assert chunks[0][0].shape == (1, 1)
-
-
-def test_stack_scalars():
-    d = da.arange(4, chunks=2)
-
-    s = da.stack([d.mean(), d.sum()])
-
-    assert s.compute().tolist() == [np.arange(4).mean(), np.arange(4).sum()]
-
-
-def test_stack_promote_type():
-    i = np.arange(10, dtype="i4")
-    f = np.arange(10, dtype="f4")
-    di = da.from_array(i, chunks=5)
-    df = da.from_array(f, chunks=5)
-    res = da.stack([di, df])
-    assert_eq(res, np.stack([i, f]))
-
-
-def test_stack_rechunk():
-    x = da.random.random(10, chunks=5)
-    y = da.random.random(10, chunks=4)
-
-    z = da.stack([x, y], axis=0)
-    assert z.shape == (2, 10)
-    assert z.chunks == ((1, 1), (4, 1, 3, 2))
-
-    assert_eq(z, np.stack([x.compute(), y.compute()], axis=0))
-
-
-def test_stack_unknown_chunksizes():
-    dd = pytest.importorskip("dask.dataframe")
-    pd = pytest.importorskip("pandas")
-
-    a_df = pd.DataFrame({"x": np.arange(12)})
-    b_df = pd.DataFrame({"y": np.arange(12) * 10})
-
-    a_ddf = dd.from_pandas(a_df, sort=False, npartitions=3)
-    b_ddf = dd.from_pandas(b_df, sort=False, npartitions=3)
-
-    a_x = a_ddf.values
-    b_x = b_ddf.values
-
-    assert np.isnan(a_x.shape[0])
-    assert np.isnan(b_x.shape[0])
-
-    with pytest.raises(ValueError) as exc_info:
-        da.stack([a_x, b_x], axis=0)
-
-    assert "shape" in str(exc_info.value)
-    assert "nan" in str(exc_info.value)
-
-    c_x = da.stack([a_x, b_x], axis=0, allow_unknown_chunksizes=True)
-
-    assert_eq(c_x, np.stack([a_df.values, b_df.values], axis=0))
-
-    with pytest.raises(ValueError) as exc_info:
-        da.stack([a_x, b_x], axis=1)
-
-    assert "shape" in str(exc_info.value)
-    assert "nan" in str(exc_info.value)
-
-    c_x = da.stack([a_x, b_x], axis=1, allow_unknown_chunksizes=True)
-
-    assert_eq(c_x, np.stack([a_df.values, b_df.values], axis=1))
-
-
-def test_concatenate():
-    a, b, c = [
-        Array(
-            getem(name, chunks=(2, 3), shape=(4, 6)),
-            name,
-            chunks=(2, 3),
-            dtype="f8",
-            shape=(4, 6),
-        )
-        for name in "ABC"
-    ]
-
-    x = concatenate([a, b, c], axis=0)
-
-    assert x.shape == (12, 6)
-    assert x.chunks == ((2, 2, 2, 2, 2, 2), (3, 3))
-    assert x.dask[(x.name, 0, 1)] == ("A", 0, 1)
-    assert x.dask[(x.name, 5, 0)] == ("C", 1, 0)
-    assert same_keys(x, concatenate([a, b, c], axis=0))
-
-    y = concatenate([a, b, c], axis=1)
-
-    assert y.shape == (4, 18)
-    assert y.chunks == ((2, 2), (3, 3, 3, 3, 3, 3))
-    assert y.dask[(y.name, 1, 0)] == ("A", 1, 0)
-    assert y.dask[(y.name, 1, 5)] == ("C", 1, 1)
-    assert same_keys(y, concatenate([a, b, c], axis=1))
-
-    assert set(b.dask.keys()).issubset(y.dask.keys())
-
-    z = concatenate([a], axis=0)
-
-    assert z.shape == a.shape
-    assert z.chunks == a.chunks
-    assert z.dask == a.dask
-    assert z is a
-
-    assert (
-        concatenate([a, b, c], axis=-1).chunks == concatenate([a, b, c], axis=1).chunks
-    )
-
-    pytest.raises(ValueError, lambda: concatenate([]))
-    pytest.raises(ValueError, lambda: concatenate([a, b, c], axis=2))
-
-
-@pytest.mark.parametrize(
-    "dtypes", [((">f8", ">f8"), "float64"), (("<f4", "<f8"), "float64")]
-)
-def test_concatenate_types(dtypes):
-    dts_in, dt_out = dtypes
-    arrs = [np.zeros(4, dtype=dt) for dt in dts_in]
-    darrs = [from_array(arr, chunks=(2,)) for arr in arrs]
-
-    x = concatenate(darrs, axis=0)
-    assert x.dtype == dt_out
-
-
-def test_concatenate_unknown_axes():
-    dd = pytest.importorskip("dask.dataframe")
-    pd = pytest.importorskip("pandas")
-
-    a_df = pd.DataFrame({"x": np.arange(12)})
-    b_df = pd.DataFrame({"y": np.arange(12) * 10})
-
-    a_ddf = dd.from_pandas(a_df, sort=False, npartitions=3)
-    b_ddf = dd.from_pandas(b_df, sort=False, npartitions=3)
-
-    a_x = a_ddf.values
-    b_x = b_ddf.values
-
-    assert np.isnan(a_x.shape[0])
-    assert np.isnan(b_x.shape[0])
-
-    da.concatenate([a_x, b_x], axis=0)  # works fine
-
-    with pytest.raises(ValueError) as exc_info:
-        da.concatenate([a_x, b_x], axis=1)  # unknown chunks
-
-    assert "nan" in str(exc_info.value)
-    assert "allow_unknown_chunksize" in str(exc_info.value)
-
-    c_x = da.concatenate(
-        [a_x, b_x], axis=1, allow_unknown_chunksizes=True
-    )  # unknown chunks
-
-    assert_eq(c_x, np.concatenate([a_df.values, b_df.values], axis=1))
-
-
-def test_concatenate_rechunk():
-    x = da.random.random((6, 6), chunks=(3, 3))
-    y = da.random.random((6, 6), chunks=(2, 2))
-
-    z = da.concatenate([x, y], axis=0)
-    assert z.shape == (12, 6)
-    assert z.chunks == ((3, 3, 2, 2, 2), (2, 1, 1, 2))
-    assert_eq(z, np.concatenate([x.compute(), y.compute()], axis=0))
-
-    z = da.concatenate([x, y], axis=1)
-    assert z.shape == (6, 12)
-    assert z.chunks == ((2, 1, 1, 2), (3, 3, 2, 2, 2))
-    assert_eq(z, np.concatenate([x.compute(), y.compute()], axis=1))
-
-
-def test_concatenate_fixlen_strings():
-    x = np.array(["a", "b", "c"])
-    y = np.array(["aa", "bb", "cc"])
-
-    a = da.from_array(x, chunks=(2,))
-    b = da.from_array(y, chunks=(2,))
-
-    assert_eq(np.concatenate([x, y]), da.concatenate([a, b]))
-
-
-def test_concatenate_zero_size():
-
-    x = np.random.random(10)
-    y = da.from_array(x, chunks=3)
-    result_np = np.concatenate([x, x[:0]])
-    result_da = da.concatenate([y, y[:0]])
-    assert_eq(result_np, result_da)
-    assert result_da is y
-
-    # dtype of a size 0 arrays can affect the output dtype
-    result_np = np.concatenate([np.zeros(0, dtype=float), np.zeros(1, dtype=int)])
-    result_da = da.concatenate([da.zeros(0, dtype=float), da.zeros(1, dtype=int)])
-
-    assert_eq(result_np, result_da)
-
-    # All empty arrays case
-    result_np = np.concatenate([np.zeros(0), np.zeros(0)])
-    result_da = da.concatenate([da.zeros(0), da.zeros(0)])
-
-    assert_eq(result_np, result_da)
-
-
-def test_block_simple_row_wise():
-    a1 = np.ones((2, 2))
-    a2 = 2 * a1
-
-    d1 = da.asarray(a1)
-    d2 = da.asarray(a2)
-
-    expected = np.block([a1, a2])
-    result = da.block([d1, d2])
-
-    assert_eq(expected, result)
-
-    expected = np.block([a1, a2[:, :0]])
-    result = da.block([d1, d2[:, :0]])
-
-    assert result is d1
-    assert_eq(expected, result)
-
-
-def test_block_simple_column_wise():
-    a1 = np.ones((2, 2))
-    a2 = 2 * a1
-
-    d1 = da.asarray(a1)
-    d2 = da.asarray(a2)
-
-    expected = np.block([[a1], [a2]])
-    result = da.block([[d1], [d2]])
-
-    assert_eq(expected, result)
-
-
-def test_block_with_1d_arrays_row_wise():
-    # # # 1-D vectors are treated as row arrays
-    a1 = np.array([1, 2, 3])
-    a2 = np.array([2, 3, 4])
-
-    d1 = da.asarray(a1)
-    d2 = da.asarray(a2)
-
-    expected = np.block([a1, a2])
-    result = da.block([d1, d2])
-
-    assert_eq(expected, result)
-
-    expected = np.block([a1, a2[:0]])
-    result = da.block([d1, d2[:0]])
-
-    assert result is d1
-    assert_eq(expected, result)
-
-
-def test_block_with_1d_arrays_multiple_rows():
-    a1 = np.array([1, 2, 3])
-    a2 = np.array([2, 3, 4])
-
-    d1 = da.asarray(a1)
-    d2 = da.asarray(a2)
-
-    expected = np.block([[a1, a2], [a1, a2]])
-    result = da.block([[d1, d2], [d1, d2]])
-
-    assert_eq(expected, result)
-
-
-def test_block_with_1d_arrays_column_wise():
-    # # # 1-D vectors are treated as row arrays
-    a1 = np.array([1, 2, 3])
-    a2 = np.array([2, 3, 4])
-
-    d1 = da.asarray(a1)
-    d2 = da.asarray(a2)
-
-    expected = np.block([[a1], [a2]])
-    result = da.block([[d1], [d2]])
-
-    assert_eq(expected, result)
-
-
-def test_block_mixed_1d_and_2d():
-    a1 = np.ones((2, 2))
-    a2 = np.array([2, 2])
-
-    d1 = da.asarray(a1)
-    d2 = da.asarray(a2)
-
-    expected = np.block([[d1], [d2]])
-    result = da.block([[a1], [a2]])
-
-    assert_eq(expected, result)
-
-
-def test_block_complicated():
-    # a bit more complicated
-    a1 = np.array([[1, 1, 1]])
-    a2 = np.array([[2, 2, 2]])
-    a3 = np.array([[3, 3, 3, 3, 3, 3]])
-    a4 = np.array([4, 4, 4, 4, 4, 4])
-    a5 = np.array(5)
-    a6 = np.array([6, 6, 6, 6, 6])
-    a7 = np.zeros((2, 6))
-
-    d1 = da.asarray(a1)
-    d2 = da.asarray(a2)
-    d3 = da.asarray(a3)
-    d4 = da.asarray(a4)
-    d5 = da.asarray(a5)
-    d6 = da.asarray(a6)
-    d7 = da.asarray(a7)
-
-    expected = np.block([[a1, a2], [a3], [a4], [a5, a6], [a7]])
-    result = da.block([[d1, d2], [d3], [d4], [d5, d6], [d7]])
-
-    assert_eq(expected, result)
-
-
-def test_block_nested():
-    a1 = np.array([1, 1, 1])
-    a2 = np.array([[2, 2, 2], [2, 2, 2], [2, 2, 2]])
-    a3 = np.array([3, 3, 3])
-    a4 = np.array([4, 4, 4])
-    a5 = np.array(5)
-    a6 = np.array([6, 6, 6, 6, 6])
-    a7 = np.zeros((2, 6))
-
-    d1 = da.asarray(a1)
-    d2 = da.asarray(a2)
-    d3 = da.asarray(a3)
-    d4 = da.asarray(a4)
-    d5 = da.asarray(a5)
-    d6 = da.asarray(a6)
-    d7 = da.asarray(a7)
-
-    expected = np.block([[np.block([[a1], [a3], [a4]]), a2], [a5, a6], [a7]])
-    result = da.block([[da.block([[d1], [d3], [d4]]), d2], [d5, d6], [d7]])
-
-    assert_eq(expected, result)
-
-
-def test_block_3d():
-    a000 = np.ones((2, 2, 2), int) * 1
-
-    a100 = np.ones((3, 2, 2), int) * 2
-    a010 = np.ones((2, 3, 2), int) * 3
-    a001 = np.ones((2, 2, 3), int) * 4
-
-    a011 = np.ones((2, 3, 3), int) * 5
-    a101 = np.ones((3, 2, 3), int) * 6
-    a110 = np.ones((3, 3, 2), int) * 7
-
-    a111 = np.ones((3, 3, 3), int) * 8
-
-    d000 = da.asarray(a000)
-
-    d100 = da.asarray(a100)
-    d010 = da.asarray(a010)
-    d001 = da.asarray(a001)
-
-    d011 = da.asarray(a011)
-    d101 = da.asarray(a101)
-    d110 = da.asarray(a110)
-
-    d111 = da.asarray(a111)
-
-    expected = np.block([[[a000, a001], [a010, a011]], [[a100, a101], [a110, a111]]])
-    result = da.block([[[d000, d001], [d010, d011]], [[d100, d101], [d110, d111]]])
-
-    assert_eq(expected, result)
-
-    expected = np.block(
-        [
-            [[a000, a001[:, :, :0]], [a010[:, :0, :], a011[:, :0, :0]]],
-            [[a100[:0, :, :], a101[:0, :, :0]], [a110[:0, :0, :], a111[:0, :0, :0]]],
-        ]
-    )
-    result = da.block(
-        [
-            [[d000, d001[:, :, :0]], [d010[:, :0, :], d011[:, :0, :0]]],
-            [[d100[:0, :, :], d101[:0, :, :0]], [d110[:0, :0, :], d111[:0, :0, :0]]],
-        ]
-    )
-
-    assert result is d000
-    assert_eq(expected, result)
-
-
-def test_block_with_mismatched_shape():
-    a = np.array([0, 0])
-    b = np.eye(2)
-
-    for arrays in [[a, b], [b, a]]:
-        with pytest.raises(ValueError):
-            da.block(arrays)
-
-
-def test_block_no_lists():
-    assert_eq(da.block(1), np.block(1))
-    assert_eq(da.block(np.eye(3)), np.block(np.eye(3)))
-
-
-def test_block_invalid_nesting():
-    for arrays in [
-        [1, [2]],
-        [1, []],
-        [[1], 2],
-        [[], 2],
-        [[[1], [2]], [[3, 4]], [5]],  # missing brackets
-    ]:
-        with pytest.raises(ValueError) as e:
-            da.block(arrays)
-        e.match(r"depths are mismatched")
-
-
-def test_block_empty_lists():
-    for arrays in [[], [[]], [[1], []]]:
-        with pytest.raises(ValueError) as e:
-            da.block(arrays)
-        e.match(r"empty")
-
-
-def test_block_tuple():
-    for arrays in [([1, 2], [3, 4]), [(1, 2), (3, 4)]]:
-        with pytest.raises(TypeError) as e:
-            da.block(arrays)
-        e.match(r"tuple")
-
-
-def test_broadcast_shapes():
-    with warnings.catch_warnings(record=True) as record:
-        assert () == broadcast_shapes()
-        assert (2, 5) == broadcast_shapes((2, 5))
-        assert (0, 5) == broadcast_shapes((0, 1), (1, 5))
-        assert np.allclose(
-            (2, np.nan), broadcast_shapes((1, np.nan), (2, 1)), equal_nan=True
-        )
-        assert np.allclose(
-            (2, np.nan), broadcast_shapes((2, 1), (1, np.nan)), equal_nan=True
-        )
-        assert (3, 4, 5) == broadcast_shapes((3, 4, 5), (4, 1), ())
-        assert (3, 4) == broadcast_shapes((3, 1), (1, 4), (4,))
-        assert (5, 6, 7, 3, 4) == broadcast_shapes((3, 1), (), (5, 6, 7, 1, 4))
-
-    assert not record
-
-    pytest.raises(ValueError, lambda: broadcast_shapes((3,), (3, 4)))
-    pytest.raises(ValueError, lambda: broadcast_shapes((2, 3), (2, 3, 1)))
-    pytest.raises(ValueError, lambda: broadcast_shapes((2, 3), (1, np.nan)))
-
-
-def test_elemwise_on_scalars():
-    x = np.arange(10, dtype=np.int64)
-    a = from_array(x, chunks=(5,))
-    assert len(a.__dask_keys__()) == 2
-    assert_eq(a.sum() ** 2, x.sum() ** 2)
-
-    y = np.arange(10, dtype=np.int32)
-    b = from_array(y, chunks=(5,))
-    result = a.sum() * b
-    # Dask 0-d arrays do not behave like numpy scalars for type promotion
-    assert result.dtype == np.int64
-    assert result.compute().dtype == np.int64
-    assert (x.sum() * y).dtype == np.int32
-    assert_eq((x.sum() * y).astype(np.int64), result)
-
-
-def test_elemwise_with_ndarrays():
-    x = np.arange(3)
-    y = np.arange(12).reshape(4, 3)
-    a = from_array(x, chunks=(3,))
-    b = from_array(y, chunks=(2, 3))
-
-    assert_eq(x + a, 2 * x)
-    assert_eq(a + x, 2 * x)
-
-    assert_eq(x + b, x + y)
-    assert_eq(b + x, x + y)
-    assert_eq(a + y, x + y)
-    assert_eq(y + a, x + y)
-    # Error on shape mismatch
-    pytest.raises(ValueError, lambda: a + y.T)
-    pytest.raises(ValueError, lambda: a + np.arange(2))
-
-
-def test_elemwise_differently_chunked():
-    x = np.arange(3)
-    y = np.arange(12).reshape(4, 3)
-    a = from_array(x, chunks=(3,))
-    b = from_array(y, chunks=(2, 2))
-
-    assert_eq(a + b, x + y)
-    assert_eq(b + a, x + y)
-
-
-def test_elemwise_dtype():
-    values = [
-        da.from_array(np.ones(5, np.float32), chunks=3),
-        da.from_array(np.ones(5, np.int16), chunks=3),
-        da.from_array(np.ones(5, np.int64), chunks=3),
-        da.from_array(np.ones((), np.float64), chunks=()) * 1e200,
-        np.ones(5, np.float32),
-        1,
-        1.0,
-        1e200,
-        np.int64(1),
-        np.ones((), np.int64),
-    ]
-    for x in values:
-        for y in values:
-            assert da.maximum(x, y).dtype == da.result_type(x, y)
-
-
-def test_operators():
-    x = np.arange(10)
-    y = np.arange(10).reshape((10, 1))
-    a = from_array(x, chunks=(5,))
-    b = from_array(y, chunks=(5, 1))
-
-    c = a + 1
-    assert_eq(c, x + 1)
-
-    c = a + b
-    assert_eq(c, x + x.reshape((10, 1)))
-
-    expr = (3 / a * b) ** 2 > 5
-    with pytest.warns(None):  # ZeroDivisionWarning
-        assert_eq(expr, (3 / x * y) ** 2 > 5)
-
-    with pytest.warns(None):  # OverflowWarning
-        c = da.exp(a)
-    assert_eq(c, np.exp(x))
-
-    assert_eq(abs(-a), a)
-    assert_eq(a, +x)
-
-
-def test_operator_dtype_promotion():
-    x = np.arange(10, dtype=np.float32)
-    y = np.array([1])
-    a = from_array(x, chunks=(5,))
-
-    assert_eq(x + 1, a + 1)  # still float32
-    assert_eq(x + 1e50, a + 1e50)  # now float64
-    assert_eq(x + y, a + y)  # also float64
-
-
-def test_field_access():
-    x = np.array([(1, 1.0), (2, 2.0)], dtype=[("a", "i4"), ("b", "f4")])
-    y = from_array(x, chunks=(1,))
-    assert_eq(y["a"], x["a"])
-    assert_eq(y[["b", "a"]], x[["b", "a"]])
-    assert same_keys(y[["b", "a"]], y[["b", "a"]])
-
-
-def test_field_access_with_shape():
-    dtype = [("col1", ("f4", (3, 2))), ("col2", ("f4", 3))]
-    data = np.ones((100, 50), dtype=dtype)
-    x = da.from_array(data, 10)
-    assert_eq(x["col1"], data["col1"])
-    assert_eq(x[["col1"]], data[["col1"]])
-    assert_eq(x["col2"], data["col2"])
-    assert_eq(x[["col1", "col2"]], data[["col1", "col2"]])
-
-
-def test_matmul():
-    x = np.random.random((5, 5))
-    y = np.random.random((5, 2))
-    a = from_array(x, chunks=(1, 5))
-    b = from_array(y, chunks=(5, 1))
-    assert_eq(operator.matmul(a, b), a.dot(b))
-    assert_eq(operator.matmul(a, b), operator.matmul(x, y))
-    assert_eq(operator.matmul(a, y), operator.matmul(x, b))
-    list_vec = list(range(1, 6))
-    assert_eq(operator.matmul(list_vec, b), operator.matmul(list_vec, y))
-    assert_eq(operator.matmul(x, list_vec), operator.matmul(a, list_vec))
-    z = np.random.random((5, 5, 5))
-    c = from_array(z, chunks=(1, 5, 1))
-    assert_eq(operator.matmul(a, z), operator.matmul(x, c))
-    assert_eq(operator.matmul(z, a), operator.matmul(c, x))
-
-
-def test_matmul_array_ufunc():
-    # regression test for https://github.com/dask/dask/issues/4353
-    x = np.random.random((5, 5))
-    y = np.random.random((5, 2))
-    a = from_array(x, chunks=(1, 5))
-    b = from_array(y, chunks=(5, 1))
-    result = b.__array_ufunc__(np.matmul, "__call__", a, b)
-    assert_eq(result, x.dot(y))
-
-
-def test_T():
-    x = np.arange(400).reshape((20, 20))
-    a = from_array(x, chunks=(5, 5))
-
-    assert_eq(x.T, a.T)
-
-
-def test_broadcast_to():
-    x = np.random.randint(10, size=(5, 1, 6))
-    a = from_array(x, chunks=(3, 1, 3))
-
-    for shape in [a.shape, (5, 0, 6), (5, 4, 6), (2, 5, 1, 6), (3, 4, 5, 4, 6)]:
-        xb = np.broadcast_to(x, shape)
-        ab = broadcast_to(a, shape)
-
-        assert_eq(xb, ab)
-
-        if a.shape == ab.shape:
-            assert a is ab
-
-    pytest.raises(ValueError, lambda: broadcast_to(a, (2, 1, 6)))
-    pytest.raises(ValueError, lambda: broadcast_to(a, (3,)))
-
-
-def test_broadcast_to_array():
-    x = np.random.randint(10, size=(5, 1, 6))
-
-    for shape in [(5, 0, 6), (5, 4, 6), (2, 5, 1, 6), (3, 4, 5, 4, 6)]:
-        a = np.broadcast_to(x, shape)
-        d = broadcast_to(x, shape)
-
-        assert_eq(a, d)
-
-
-def test_broadcast_to_scalar():
-    x = 5
-
-    for shape in [tuple(), (0,), (2, 3), (5, 4, 6), (2, 5, 1, 6), (3, 4, 5, 4, 6)]:
-        a = np.broadcast_to(x, shape)
-        d = broadcast_to(x, shape)
-
-        assert_eq(a, d)
-
-
-def test_broadcast_to_chunks():
-    x = np.random.randint(10, size=(5, 1, 6))
-    a = from_array(x, chunks=(3, 1, 3))
-
-    for shape, chunks, expected_chunks in [
-        ((5, 3, 6), (3, -1, 3), ((3, 2), (3,), (3, 3))),
-        ((5, 3, 6), (3, 1, 3), ((3, 2), (1, 1, 1), (3, 3))),
-        ((2, 5, 3, 6), (1, 3, 1, 3), ((1, 1), (3, 2), (1, 1, 1), (3, 3))),
-    ]:
-        xb = np.broadcast_to(x, shape)
-        ab = broadcast_to(a, shape, chunks=chunks)
-        assert_eq(xb, ab)
-        assert ab.chunks == expected_chunks
-
-    with pytest.raises(ValueError):
-        broadcast_to(a, a.shape, chunks=((2, 3), (1,), (3, 3)))
-    with pytest.raises(ValueError):
-        broadcast_to(a, a.shape, chunks=((3, 2), (3,), (3, 3)))
-    with pytest.raises(ValueError):
-        broadcast_to(a, (5, 2, 6), chunks=((3, 2), (3,), (3, 3)))
-
-
-def test_broadcast_arrays():
-    assert np.broadcast_arrays() == da.broadcast_arrays()
-
-    a = np.arange(4)
-    d_a = da.from_array(a, chunks=tuple(s // 2 for s in a.shape))
-
-    a_0 = np.arange(4)[None, :]
-    a_1 = np.arange(4)[:, None]
-
-    d_a_0 = d_a[None, :]
-    d_a_1 = d_a[:, None]
-
-    a_r = np.broadcast_arrays(a_0, a_1)
-    d_r = da.broadcast_arrays(d_a_0, d_a_1)
-
-    assert isinstance(d_r, list)
-    assert len(a_r) == len(d_r)
-
-    for e_a_r, e_d_r in zip(a_r, d_r):
-        assert_eq(e_a_r, e_d_r)
-
-
-def test_broadcast_arrays_uneven_chunks():
-    x = da.ones(30, chunks=(3,))
-    y = da.ones(30, chunks=(5,))
-    z = np.broadcast_arrays(x, y)
-
-    assert_eq(z, z)
-
-    x = da.ones((1, 30), chunks=(1, 3))
-    y = da.ones(30, chunks=(5,))
-    z = np.broadcast_arrays(x, y)
-
-    assert_eq(z, z)
-
-
-@pytest.mark.parametrize(
-    "u_shape, v_shape",
-    [
-        [tuple(), (2, 3)],
-        [(1,), (2, 3)],
-        [(1, 1), (2, 3)],
-        [(0, 3), (1, 3)],
-        [(2, 0), (2, 1)],
-        [(1, 0), (2, 1)],
-        [(0, 1), (1, 3)],
-    ],
-)
-def test_broadcast_operator(u_shape, v_shape):
-    u = np.random.random(u_shape)
-    v = np.random.random(v_shape)
-
-    d_u = from_array(u, chunks=1)
-    d_v = from_array(v, chunks=1)
-
-    w = u * v
-    d_w = d_u * d_v
-
-    assert_eq(w, d_w)
-
-
-@pytest.mark.parametrize(
-    "original_shape,new_shape,chunks",
-    [
-        ((10,), (10,), (3, 3, 4)),
-        ((10,), (10, 1, 1), 5),
-        ((10,), (1, 10), 5),
-        ((24,), (2, 3, 4), 12),
-        ((1, 24), (2, 3, 4), 12),
-        ((2, 3, 4), (24,), (1, 3, 4)),
-        ((2, 3, 4), (24,), 4),
-        ((2, 3, 4), (24, 1), 4),
-        ((2, 3, 4), (1, 24), 4),
-        ((4, 4, 1), (4, 4), 2),
-        ((4, 4), (4, 4, 1), 2),
-        ((1, 4, 4), (4, 4), 2),
-        ((1, 4, 4), (4, 4, 1), 2),
-        ((1, 4, 4), (1, 1, 4, 4), 2),
-        ((4, 4), (1, 4, 4, 1), 2),
-        ((4, 4), (1, 4, 4), 2),
-        ((2, 3), (2, 3), (1, 2)),
-        ((2, 3), (3, 2), 3),
-        ((4, 2, 3), (4, 6), 4),
-        ((3, 4, 5, 6), (3, 4, 5, 6), (2, 3, 4, 5)),
-        ((), (1,), 1),
-        ((1,), (), 1),
-        ((24,), (3, 8), 24),
-        ((24,), (4, 6), 6),
-        ((24,), (4, 3, 2), 6),
-        ((24,), (4, 6, 1), 6),
-        ((24,), (4, 6), (6, 12, 6)),
-        ((64, 4), (8, 8, 4), (16, 2)),
-        ((4, 64), (4, 8, 4, 2), (2, 16)),
-        ((4, 8, 4, 2), (2, 1, 2, 32, 2), (2, 4, 2, 2)),
-        ((4, 1, 4), (4, 4), (2, 1, 2)),
-        ((0, 10), (0, 5, 2), (5, 5)),
-        ((5, 0, 2), (0, 10), (5, 2, 2)),
-        ((0,), (2, 0, 2), (4,)),
-        ((2, 0, 2), (0,), (4, 4, 4)),
-    ],
-)
-def test_reshape(original_shape, new_shape, chunks):
-    x = np.random.randint(10, size=original_shape)
-    a = from_array(x, chunks=chunks)
-
-    xr = x.reshape(new_shape)
-    ar = a.reshape(new_shape)
-
-    if a.shape == new_shape:
-        assert a is ar
-
-    assert_eq(xr, ar)
-
-
-def test_reshape_exceptions():
-    x = np.random.randint(10, size=(5,))
-    a = from_array(x, chunks=(2,))
-    with pytest.raises(ValueError):
-        da.reshape(a, (100,))
-
-
-def test_reshape_splat():
-    x = da.ones((5, 5), chunks=(2, 2))
-    assert_eq(x.reshape((25,)), x.reshape(25))
-
-
-def test_reshape_fails_for_dask_only():
-    cases = [((3, 4), (4, 3), 2)]
-    for original_shape, new_shape, chunks in cases:
-        x = np.random.randint(10, size=original_shape)
-        a = from_array(x, chunks=chunks)
-        assert x.reshape(new_shape).shape == new_shape
-        with pytest.raises(ValueError):
-            da.reshape(a, new_shape)
-
-
-def test_reshape_unknown_dimensions():
-    for original_shape in [(24,), (2, 12), (2, 3, 4)]:
-        for new_shape in [(-1,), (2, -1), (-1, 3, 4)]:
-            x = np.random.randint(10, size=original_shape)
-            a = from_array(x, 24)
-            assert_eq(x.reshape(new_shape), a.reshape(new_shape))
-
-    pytest.raises(ValueError, lambda: da.reshape(a, (-1, -1)))
-
-
-def test_full():
-    d = da.full((3, 4), 2, chunks=((2, 1), (2, 2)))
-    assert d.chunks == ((2, 1), (2, 2))
-    assert_eq(d, np.full((3, 4), 2))
-
-
-def test_map_blocks():
-    x = np.arange(400).reshape((20, 20))
-    d = from_array(x, chunks=(7, 7))
-
-    e = d.map_blocks(inc, dtype=d.dtype)
-
-    assert d.chunks == e.chunks
-    assert_eq(e, x + 1)
-
-    e = d.map_blocks(inc, name="increment")
-    assert e.name.startswith("increment-")
-
-    assert d.map_blocks(inc, name="foo").name != d.map_blocks(dec, name="foo").name
-
-    d = from_array(x, chunks=(10, 10))
-    e = d.map_blocks(lambda x: x[::2, ::2], chunks=(5, 5), dtype=d.dtype)
-
-    assert e.chunks == ((5, 5), (5, 5))
-    assert_eq(e, x[::2, ::2])
-
-    d = from_array(x, chunks=(8, 8))
-    e = d.map_blocks(
-        lambda x: x[::2, ::2], chunks=((4, 4, 2), (4, 4, 2)), dtype=d.dtype
-    )
-
-    assert_eq(e, x[::2, ::2])
-
-
-def test_map_blocks2():
-    x = np.arange(10, dtype="i8")
-    d = from_array(x, chunks=(2,))
-
-    def func(block, block_id=None, c=0):
-        return np.ones_like(block) * sum(block_id) + c
-
-    out = d.map_blocks(func, dtype="i8")
-    expected = np.array([0, 0, 1, 1, 2, 2, 3, 3, 4, 4], dtype="i8")
-
-    assert_eq(out, expected)
-    assert same_keys(d.map_blocks(func, dtype="i8"), out)
-
-    out = d.map_blocks(func, dtype="i8", c=1)
-    expected = expected + 1
-
-    assert_eq(out, expected)
-    assert same_keys(d.map_blocks(func, dtype="i8", c=1), out)
-
-
-def test_map_blocks_block_info():
-    x = da.arange(50, chunks=10)
-
-    def func(a, b, c, block_info=None):
-        for idx in [0, 2, None]:  # positions in args
-            assert block_info[idx]["shape"] == (50,)
-            assert block_info[idx]["num-chunks"] == (5,)
-            start, stop = block_info[idx]["array-location"][0]
-            assert stop - start == 10
-            assert 0 <= start <= 40
-            assert 10 <= stop <= 50
-
-            assert 0 <= block_info[idx]["chunk-location"][0] <= 4
-        assert block_info[None]["chunk-shape"] == (10,)
-        assert block_info[None]["dtype"] == x.dtype
-
-        return a + b + c
-
-    z = da.map_blocks(func, x, 100, x + 1, dtype=x.dtype)
-    assert_eq(z, x + x + 1 + 100)
-
-
-def test_map_blocks_block_info_with_new_axis():
-    # https://github.com/dask/dask/issues/4298
-    values = da.from_array(np.array(["a", "a", "b", "c"]), 2)
-
-    def func(x, block_info=None):
-        assert set(block_info.keys()) == {0, None}
-        assert block_info[0]["shape"] == (4,)
-        assert block_info[0]["num-chunks"] == (2,)
-        assert block_info[None]["shape"] == (4, 3)
-        assert block_info[None]["num-chunks"] == (2, 1)
-        assert block_info[None]["chunk-shape"] == (2, 3)
-        assert block_info[None]["dtype"] == np.dtype("f8")
-
-        assert block_info[0]["chunk-location"] in {(0,), (1,)}
-
-        if block_info[0]["chunk-location"] == (0,):
-            assert block_info[0]["array-location"] == [(0, 2)]
-            assert block_info[None]["chunk-location"] == (0, 0)
-            assert block_info[None]["array-location"] == [(0, 2), (0, 3)]
-        elif block_info[0]["chunk-location"] == (1,):
-            assert block_info[0]["array-location"] == [(2, 4)]
-            assert block_info[None]["chunk-location"] == (1, 0)
-            assert block_info[None]["array-location"] == [(2, 4), (0, 3)]
-
-        return np.ones((len(x), 3))
-
-    z = values.map_blocks(func, chunks=((2, 2), 3), new_axis=1, dtype="f8")
-    assert_eq(z, np.ones((4, 3), dtype="f8"))
-
-
-def test_map_blocks_block_info_with_drop_axis():
-    # https://github.com/dask/dask/issues/4584
-    values = da.from_array(
-        np.array(
-            [[1, 2, 4], [8, 16, 32], [64, 128, 256], [1024, 2048, 4096]], dtype="u4"
-        ),
-        (2, 1),
-    )
-
-    def func(x, block_info=None):
-        assert set(block_info.keys()) == {0, None}
-        assert block_info[0]["shape"] == (4, 3)
-        # drop_axis concatenates along the dropped dimension, hence not (2, 3)
-        assert block_info[0]["num-chunks"] == (2, 1)
-        assert block_info[None]["shape"] == (4,)
-        assert block_info[None]["num-chunks"] == (2,)
-        assert block_info[None]["chunk-shape"] == (2,)
-        assert block_info[None]["dtype"] == np.dtype("u4")
-
-        assert block_info[0]["chunk-location"] in {(0, 0), (1, 0)}
-
-        if block_info[0]["chunk-location"] == (0, 0):
-            assert block_info[0]["array-location"] == [(0, 2), (0, 3)]
-            assert block_info[None]["chunk-location"] == (0,)
-            assert block_info[None]["array-location"] == [(0, 2)]
-        elif block_info[0]["chunk-location"] == (1, 0):
-            assert block_info[0]["array-location"] == [(2, 4), (0, 3)]
-            assert block_info[None]["chunk-location"] == (1,)
-            assert block_info[None]["array-location"] == [(2, 4)]
-
-        return np.sum(x, axis=1, dtype="u4")
-
-    z = values.map_blocks(func, drop_axis=1, dtype="u4")
-    assert_eq(z, np.array([7, 56, 448, 7168], dtype="u4"))
-
-
-def test_map_blocks_block_info_with_broadc