Add files using upload-large-folder tool

wemm/lib/python3.10/site-packages/accelerate-1.2.1.dist-info/INSTALLER

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

wemm/lib/python3.10/site-packages/accelerate-1.2.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+accelerate

wemm/lib/python3.10/site-packages/boto3-1.26.118.dist-info/INSTALLER

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

wemm/lib/python3.10/site-packages/boto3-1.26.118.dist-info/LICENSE

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

wemm/lib/python3.10/site-packages/boto3-1.26.118.dist-info/top_level.txt

@@ -0,0 +1 @@
+boto3

wemm/lib/python3.10/site-packages/jinja2-3.1.5.dist-info/INSTALLER

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

wemm/lib/python3.10/site-packages/lit-18.1.8.dist-info/INSTALLER

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

wemm/lib/python3.10/site-packages/lit-18.1.8.dist-info/METADATA

@@ -0,0 +1,88 @@
+Metadata-Version: 2.1
+Name: lit
+Version: 18.1.8
+Summary: A Software Testing Tool
+Home-page: http://llvm.org
+Author: Daniel Dunbar
+Author-email: daniel@minormatter.com
+License: Apache-2.0 with LLVM exception
+Keywords: test C++ automatic discovery
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Topic :: Software Development :: Testing
+License-File: LICENSE.TXT
+
+===============================
+ lit - A Software Testing Tool
+===============================
+
+About
+=====
+
+*lit* is a portable tool for executing LLVM and Clang style test suites,
+summarizing their results, and providing indication of failures. *lit* is
+designed to be a lightweight testing tool with as simple a user interface as
+possible.
+
+
+Features
+========
+
+ * Portable!
+ * Flexible test discovery.
+ * Parallel test execution.
+ * Support for multiple test formats and test suite designs.
+
+
+Documentation
+=============
+
+The official *lit* documentation is in the man page, available online at the LLVM
+Command Guide: http://llvm.org/cmds/lit.html.
+
+
+Source
+======
+
+The *lit* source is available as part of LLVM, in the LLVM source repository:
+https://github.com/llvm/llvm-project/tree/main/llvm/utils/lit
+
+
+Contributing to lit
+===================
+
+Please browse the issues labeled *tools:llvm-lit* in LLVM's issue tracker for
+ideas on what to work on:
+https://github.com/llvm/llvm-project/labels/tools%3Allvm-lit
+
+Before submitting patches, run the test suite to ensure nothing has regressed::
+
+    # From within your LLVM source directory.
+    utils/lit/lit.py \
+        --path /path/to/your/llvm/build/bin \
+        utils/lit/tests
+
+Note that lit's tests depend on ``not`` and ``FileCheck``, LLVM utilities.
+You will need to have built LLVM tools in order to run lit's test suite
+successfully.
+
+You'll also want to confirm that lit continues to work when testing LLVM.
+Follow the instructions in http://llvm.org/docs/TestingGuide.html to run the
+regression test suite:
+
+    make check-llvm
+
+And be sure to run the llvm-lit wrapper script as well:
+
+    /path/to/your/llvm/build/bin/llvm-lit utils/lit/tests
+
+Finally, make sure lit works when installed via setuptools:
+
+    python utils/lit/setup.py install
+    lit --path /path/to/your/llvm/build/bin utils/lit/tests
+

wemm/lib/python3.10/site-packages/lit-18.1.8.dist-info/RECORD

@@ -0,0 +1,67 @@
+../../../bin/lit,sha256=wAQ2RaOuoxIpQB2Vghy5cBwQs1ADzGEKdmFiYkI7uwE,217
+lit-18.1.8.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+lit-18.1.8.dist-info/LICENSE.TXT,sha256=jYXBBX10Lll5hcfU5jILAVqROThc_0y64G_8Dr6Jr-4,15141
+lit-18.1.8.dist-info/METADATA,sha256=wWTOEzjFOnByj9vUpg-7m6z4w6wOxxQm0bV8JKtErgA,2516
+lit-18.1.8.dist-info/RECORD,,
+lit-18.1.8.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lit-18.1.8.dist-info/WHEEL,sha256=yQN5g4mg4AybRjkgi-9yy4iQEFibGQmlz78Pik5Or-A,92
+lit-18.1.8.dist-info/entry_points.txt,sha256=VkD2kCAmwO0d87cx0ZmqEiJ9Pw_38l-E9bWJ_cV-eRw,38
+lit-18.1.8.dist-info/top_level.txt,sha256=re7FJOS-i0hzk2jilipjbt2x1XAfweNrDeWsfDbiraw,4
+lit/BooleanExpression.py,sha256=au2js-cvxFZf9IIyHsHZK86FSejNDAvP9qxIbJ3BHZ4,12039
+lit/LitConfig.py,sha256=p5--IGnsVhbNmcOCXUGUvEC0ItnYWq44jg10GMxIszM,8431
+lit/LitTestCase.py,sha256=X9QmPKZ43_ynMVagmqQyx9UbmOP8O4GofApCFCfTsVY,1593
+lit/ProgressBar.py,sha256=1S0AM7Zl9A-2vOPTDr_mYzqTCYkef0ZdyZxK7DzjR7k,11087
+lit/ShCommands.py,sha256=2C6r-4Mf-z3axTpsLtFlq3sulf1A6YEmozv9Xnv1DTk,3242
+lit/ShUtil.py,sha256=pRRwmMkTlXdipvKXEkHnB2HNL4ssfzDkj_89ckKy8lA,8811
+lit/Test.py,sha256=WI24gogrtizHfk_H2Hxddu291QTGBTMkn6134KSjYkU,13734
+lit/TestRunner.py,sha256=t37BiqWKwOLnuC3rn0d0UNEe8PD84kPCAjTAq2DTlD4,84905
+lit/TestTimes.py,sha256=L1n8NDZCZBxTv9tpIm9-kz9RdQfa-VHwsG_0vkvFXiQ,1629
+lit/TestingConfig.py,sha256=Nb68jG6vMibHfn3oTU4CvPWVOPnzSRRStbBriP_kFRU,8690
+lit/__init__.py,sha256=B53XbNxbmy10HEpv2uSfm0oR4JDIY1yGDba2wZA86Ug,191
+lit/__pycache__/BooleanExpression.cpython-310.pyc,,
+lit/__pycache__/LitConfig.cpython-310.pyc,,
+lit/__pycache__/LitTestCase.cpython-310.pyc,,
+lit/__pycache__/ProgressBar.cpython-310.pyc,,
+lit/__pycache__/ShCommands.cpython-310.pyc,,
+lit/__pycache__/ShUtil.cpython-310.pyc,,
+lit/__pycache__/Test.cpython-310.pyc,,
+lit/__pycache__/TestRunner.cpython-310.pyc,,
+lit/__pycache__/TestTimes.cpython-310.pyc,,
+lit/__pycache__/TestingConfig.cpython-310.pyc,,
+lit/__pycache__/__init__.cpython-310.pyc,,
+lit/__pycache__/cl_arguments.cpython-310.pyc,,
+lit/__pycache__/discovery.cpython-310.pyc,,
+lit/__pycache__/display.cpython-310.pyc,,
+lit/__pycache__/main.cpython-310.pyc,,
+lit/__pycache__/reports.cpython-310.pyc,,
+lit/__pycache__/run.cpython-310.pyc,,
+lit/__pycache__/util.cpython-310.pyc,,
+lit/__pycache__/worker.cpython-310.pyc,,
+lit/builtin_commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lit/builtin_commands/__pycache__/__init__.cpython-310.pyc,,
+lit/builtin_commands/__pycache__/cat.cpython-310.pyc,,
+lit/builtin_commands/__pycache__/diff.cpython-310.pyc,,
+lit/builtin_commands/cat.py,sha256=SSu5cLp93tFTxb4i6qtuF5JhGa5ce4AvUOPLklKaObM,1892
+lit/builtin_commands/diff.py,sha256=DgPO2kTHKZwfxn1oNp-S2T1cjpQJtf4EcLeMGX5RgtE,9802
+lit/cl_arguments.py,sha256=TP0MW8TImuPM31tX-E4Z4azhkNk-ChmcVBhhIBzJLyE,11174
+lit/discovery.py,sha256=f_Ze7eIqLlSBew7pcvLOxRHiPqAvkQnFrD5Dc4qRjMI,9618
+lit/display.py,sha256=iDzxhcDR-qGgOga-fYh-N8JlsBZqKNNomTj4HldWr4s,5987
+lit/formats/__init__.py,sha256=N8-_QUMtwIKB_2sg_AxT7fTjfrvygb4xtzeAy6gUZxU,215
+lit/formats/__pycache__/__init__.cpython-310.pyc,,
+lit/formats/__pycache__/base.cpython-310.pyc,,
+lit/formats/__pycache__/googletest.cpython-310.pyc,,
+lit/formats/__pycache__/shtest.cpython-310.pyc,,
+lit/formats/base.py,sha256=WfzVSdoMxwWEw864_nTNRP0MJFvYC483jMuFd0GEJiM,2299
+lit/formats/googletest.py,sha256=u_YLpvDyMG9jnoD2zXNEgKe91IHlNNE97oyCnVrXqW4,14953
+lit/formats/shtest.py,sha256=0TqWvzIgO-wAdPVAdc3ZObn5LgPWRwIZHECxQkNXR18,992
+lit/llvm/__init__.py,sha256=dRYTMMuZZ8AbNmUbAu7tF0oGyiEGKsg08Za2V_i-7KU,176
+lit/llvm/__pycache__/__init__.cpython-310.pyc,,
+lit/llvm/__pycache__/config.cpython-310.pyc,,
+lit/llvm/__pycache__/subst.cpython-310.pyc,,
+lit/llvm/config.py,sha256=w61DQA3aEKzlaxfvS45pCk6NjlFMlsXCUVu0N8GzkG4,32023
+lit/llvm/subst.py,sha256=tcNyKU9DnjpmJK5nPg4OY3PwTpq-yPtWYew2ihrOXVA,5430
+lit/main.py,sha256=6-zVGJg4k8Zsew36foQ_ZyJC5spD_07_DkrimoNpC1E,11855
+lit/reports.py,sha256=z_tW12WmBsib4utxqPUqWCeuCMxqwcLlh4619teM2sI,11056
+lit/run.py,sha256=ElgAxiSVweS5X-O0dw4zytjdq7Uyb5B7MNHh-abneB8,4692
+lit/util.py,sha256=BFYG2BA7keivLMrU8uFeDurBgrA2CXxQYfQcM6iRjTE,17299
+lit/worker.py,sha256=734wH1gJsGPgioa6vHydMhEzWNsH0ceqrzCcBjjcNxI,2666

wemm/lib/python3.10/site-packages/networkx/classes/tests/test_coreviews.py

@@ -0,0 +1,362 @@
+import pickle
+
+import pytest
+
+import networkx as nx
+
+
+class TestAtlasView:
+    # node->data
+    def setup_method(self):
+        self.d = {0: {"color": "blue", "weight": 1.2}, 1: {}, 2: {"color": 1}}
+        self.av = nx.classes.coreviews.AtlasView(self.d)
+
+    def test_pickle(self):
+        view = self.av
+        pview = pickle.loads(pickle.dumps(view, -1))
+        assert view == pview
+        assert view.__slots__ == pview.__slots__
+        pview = pickle.loads(pickle.dumps(view))
+        assert view == pview
+        assert view.__slots__ == pview.__slots__
+
+    def test_len(self):
+        assert len(self.av) == len(self.d)
+
+    def test_iter(self):
+        assert list(self.av) == list(self.d)
+
+    def test_getitem(self):
+        assert self.av[1] is self.d[1]
+        assert self.av[2]["color"] == 1
+        pytest.raises(KeyError, self.av.__getitem__, 3)
+
+    def test_copy(self):
+        avcopy = self.av.copy()
+        assert avcopy[0] == self.av[0]
+        assert avcopy == self.av
+        assert avcopy[0] is not self.av[0]
+        assert avcopy is not self.av
+        avcopy[5] = {}
+        assert avcopy != self.av
+
+        avcopy[0]["ht"] = 4
+        assert avcopy[0] != self.av[0]
+        self.av[0]["ht"] = 4
+        assert avcopy[0] == self.av[0]
+        del self.av[0]["ht"]
+
+        assert not hasattr(self.av, "__setitem__")
+
+    def test_items(self):
+        assert sorted(self.av.items()) == sorted(self.d.items())
+
+    def test_str(self):
+        out = str(self.d)
+        assert str(self.av) == out
+
+    def test_repr(self):
+        out = "AtlasView(" + str(self.d) + ")"
+        assert repr(self.av) == out
+
+
+class TestAdjacencyView:
+    # node->nbr->data
+    def setup_method(self):
+        dd = {"color": "blue", "weight": 1.2}
+        self.nd = {0: dd, 1: {}, 2: {"color": 1}}
+        self.adj = {3: self.nd, 0: {3: dd}, 1: {}, 2: {3: {"color": 1}}}
+        self.adjview = nx.classes.coreviews.AdjacencyView(self.adj)
+
+    def test_pickle(self):
+        view = self.adjview
+        pview = pickle.loads(pickle.dumps(view, -1))
+        assert view == pview
+        assert view.__slots__ == pview.__slots__
+
+    def test_len(self):
+        assert len(self.adjview) == len(self.adj)
+
+    def test_iter(self):
+        assert list(self.adjview) == list(self.adj)
+
+    def test_getitem(self):
+        assert self.adjview[1] is not self.adj[1]
+        assert self.adjview[3][0] is self.adjview[0][3]
+        assert self.adjview[2][3]["color"] == 1
+        pytest.raises(KeyError, self.adjview.__getitem__, 4)
+
+    def test_copy(self):
+        avcopy = self.adjview.copy()
+        assert avcopy[0] == self.adjview[0]
+        assert avcopy[0] is not self.adjview[0]
+
+        avcopy[2][3]["ht"] = 4
+        assert avcopy[2] != self.adjview[2]
+        self.adjview[2][3]["ht"] = 4
+        assert avcopy[2] == self.adjview[2]
+        del self.adjview[2][3]["ht"]
+
+        assert not hasattr(self.adjview, "__setitem__")
+
+    def test_items(self):
+        view_items = sorted((n, dict(d)) for n, d in self.adjview.items())
+        assert view_items == sorted(self.adj.items())
+
+    def test_str(self):
+        out = str(dict(self.adj))
+        assert str(self.adjview) == out
+
+    def test_repr(self):
+        out = self.adjview.__class__.__name__ + "(" + str(self.adj) + ")"
+        assert repr(self.adjview) == out
+
+
+class TestMultiAdjacencyView(TestAdjacencyView):
+    # node->nbr->key->data
+    def setup_method(self):
+        dd = {"color": "blue", "weight": 1.2}
+        self.kd = {0: dd, 1: {}, 2: {"color": 1}}
+        self.nd = {3: self.kd, 0: {3: dd}, 1: {0: {}}, 2: {3: {"color": 1}}}
+        self.adj = {3: self.nd, 0: {3: {3: dd}}, 1: {}, 2: {3: {8: {}}}}
+        self.adjview = nx.classes.coreviews.MultiAdjacencyView(self.adj)
+
+    def test_getitem(self):
+        assert self.adjview[1] is not self.adj[1]
+        assert self.adjview[3][0][3] is self.adjview[0][3][3]
+        assert self.adjview[3][2][3]["color"] == 1
+        pytest.raises(KeyError, self.adjview.__getitem__, 4)
+
+    def test_copy(self):
+        avcopy = self.adjview.copy()
+        assert avcopy[0] == self.adjview[0]
+        assert avcopy[0] is not self.adjview[0]
+
+        avcopy[2][3][8]["ht"] = 4
+        assert avcopy[2] != self.adjview[2]
+        self.adjview[2][3][8]["ht"] = 4
+        assert avcopy[2] == self.adjview[2]
+        del self.adjview[2][3][8]["ht"]
+
+        assert not hasattr(self.adjview, "__setitem__")
+
+
+class TestUnionAtlas:
+    # node->data
+    def setup_method(self):
+        self.s = {0: {"color": "blue", "weight": 1.2}, 1: {}, 2: {"color": 1}}
+        self.p = {3: {"color": "blue", "weight": 1.2}, 4: {}, 2: {"watch": 2}}
+        self.av = nx.classes.coreviews.UnionAtlas(self.s, self.p)
+
+    def test_pickle(self):
+        view = self.av
+        pview = pickle.loads(pickle.dumps(view, -1))
+        assert view == pview
+        assert view.__slots__ == pview.__slots__
+
+    def test_len(self):
+        assert len(self.av) == len(self.s.keys() | self.p.keys()) == 5
+
+    def test_iter(self):
+        assert set(self.av) == set(self.s) | set(self.p)
+
+    def test_getitem(self):
+        assert self.av[0] is self.s[0]
+        assert self.av[4] is self.p[4]
+        assert self.av[2]["color"] == 1
+        pytest.raises(KeyError, self.av[2].__getitem__, "watch")
+        pytest.raises(KeyError, self.av.__getitem__, 8)
+
+    def test_copy(self):
+        avcopy = self.av.copy()
+        assert avcopy[0] == self.av[0]
+        assert avcopy[0] is not self.av[0]
+        assert avcopy is not self.av
+        avcopy[5] = {}
+        assert avcopy != self.av
+
+        avcopy[0]["ht"] = 4
+        assert avcopy[0] != self.av[0]
+        self.av[0]["ht"] = 4
+        assert avcopy[0] == self.av[0]
+        del self.av[0]["ht"]
+
+        assert not hasattr(self.av, "__setitem__")
+
+    def test_items(self):
+        expected = dict(self.p.items())
+        expected.update(self.s)
+        assert sorted(self.av.items()) == sorted(expected.items())
+
+    def test_str(self):
+        out = str(dict(self.av))
+        assert str(self.av) == out
+
+    def test_repr(self):
+        out = f"{self.av.__class__.__name__}({self.s}, {self.p})"
+        assert repr(self.av) == out
+
+
+class TestUnionAdjacency:
+    # node->nbr->data
+    def setup_method(self):
+        dd = {"color": "blue", "weight": 1.2}
+        self.nd = {0: dd, 1: {}, 2: {"color": 1}}
+        self.s = {3: self.nd, 0: {}, 1: {}, 2: {3: {"color": 1}}}
+        self.p = {3: {}, 0: {3: dd}, 1: {0: {}}, 2: {1: {"color": 1}}}
+        self.adjview = nx.classes.coreviews.UnionAdjacency(self.s, self.p)
+
+    def test_pickle(self):
+        view = self.adjview
+        pview = pickle.loads(pickle.dumps(view, -1))
+        assert view == pview
+        assert view.__slots__ == pview.__slots__
+
+    def test_len(self):
+        assert len(self.adjview) == len(self.s)
+
+    def test_iter(self):
+        assert sorted(self.adjview) == sorted(self.s)
+
+    def test_getitem(self):
+        assert self.adjview[1] is not self.s[1]
+        assert self.adjview[3][0] is self.adjview[0][3]
+        assert self.adjview[2][3]["color"] == 1
+        pytest.raises(KeyError, self.adjview.__getitem__, 4)
+
+    def test_copy(self):
+        avcopy = self.adjview.copy()
+        assert avcopy[0] == self.adjview[0]
+        assert avcopy[0] is not self.adjview[0]
+
+        avcopy[2][3]["ht"] = 4
+        assert avcopy[2] != self.adjview[2]
+        self.adjview[2][3]["ht"] = 4
+        assert avcopy[2] == self.adjview[2]
+        del self.adjview[2][3]["ht"]
+
+        assert not hasattr(self.adjview, "__setitem__")
+
+    def test_str(self):
+        out = str(dict(self.adjview))
+        assert str(self.adjview) == out
+
+    def test_repr(self):
+        clsname = self.adjview.__class__.__name__
+        out = f"{clsname}({self.s}, {self.p})"
+        assert repr(self.adjview) == out
+
+
+class TestUnionMultiInner(TestUnionAdjacency):
+    # nbr->key->data
+    def setup_method(self):
+        dd = {"color": "blue", "weight": 1.2}
+        self.kd = {7: {}, "ekey": {}, 9: {"color": 1}}
+        self.s = {3: self.kd, 0: {7: dd}, 1: {}, 2: {"key": {"color": 1}}}
+        self.p = {3: {}, 0: {3: dd}, 1: {}, 2: {1: {"span": 2}}}
+        self.adjview = nx.classes.coreviews.UnionMultiInner(self.s, self.p)
+
+    def test_len(self):
+        assert len(self.adjview) == len(self.s.keys() | self.p.keys()) == 4
+
+    def test_getitem(self):
+        assert self.adjview[1] is not self.s[1]
+        assert self.adjview[0][7] is self.adjview[0][3]
+        assert self.adjview[2]["key"]["color"] == 1
+        assert self.adjview[2][1]["span"] == 2
+        pytest.raises(KeyError, self.adjview.__getitem__, 4)
+        pytest.raises(KeyError, self.adjview[1].__getitem__, "key")
+
+    def test_copy(self):
+        avcopy = self.adjview.copy()
+        assert avcopy[0] == self.adjview[0]
+        assert avcopy[0] is not self.adjview[0]
+
+        avcopy[2][1]["width"] = 8
+        assert avcopy[2] != self.adjview[2]
+        self.adjview[2][1]["width"] = 8
+        assert avcopy[2] == self.adjview[2]
+        del self.adjview[2][1]["width"]
+
+        assert not hasattr(self.adjview, "__setitem__")
+        assert hasattr(avcopy, "__setitem__")
+
+
+class TestUnionMultiAdjacency(TestUnionAdjacency):
+    # node->nbr->key->data
+    def setup_method(self):
+        dd = {"color": "blue", "weight": 1.2}
+        self.kd = {7: {}, 8: {}, 9: {"color": 1}}
+        self.nd = {3: self.kd, 0: {9: dd}, 1: {8: {}}, 2: {9: {"color": 1}}}
+        self.s = {3: self.nd, 0: {3: {7: dd}}, 1: {}, 2: {3: {8: {}}}}
+        self.p = {3: {}, 0: {3: {9: dd}}, 1: {}, 2: {1: {8: {}}}}
+        self.adjview = nx.classes.coreviews.UnionMultiAdjacency(self.s, self.p)
+
+    def test_getitem(self):
+        assert self.adjview[1] is not self.s[1]
+        assert self.adjview[3][0][9] is self.adjview[0][3][9]
+        assert self.adjview[3][2][9]["color"] == 1
+        pytest.raises(KeyError, self.adjview.__getitem__, 4)
+
+    def test_copy(self):
+        avcopy = self.adjview.copy()
+        assert avcopy[0] == self.adjview[0]
+        assert avcopy[0] is not self.adjview[0]
+
+        avcopy[2][3][8]["ht"] = 4
+        assert avcopy[2] != self.adjview[2]
+        self.adjview[2][3][8]["ht"] = 4
+        assert avcopy[2] == self.adjview[2]
+        del self.adjview[2][3][8]["ht"]
+
+        assert not hasattr(self.adjview, "__setitem__")
+        assert hasattr(avcopy, "__setitem__")
+
+
+class TestFilteredGraphs:
+    def setup_method(self):
+        self.Graphs = [nx.Graph, nx.DiGraph, nx.MultiGraph, nx.MultiDiGraph]
+
+    def test_hide_show_nodes(self):
+        SubGraph = nx.subgraph_view
+        for Graph in self.Graphs:
+            G = nx.path_graph(4, Graph)
+            SG = G.subgraph([2, 3])
+            RG = SubGraph(G, filter_node=nx.filters.hide_nodes([0, 1]))
+            assert SG.nodes == RG.nodes
+            assert SG.edges == RG.edges
+            SGC = SG.copy()
+            RGC = RG.copy()
+            assert SGC.nodes == RGC.nodes
+            assert SGC.edges == RGC.edges
+
+    def test_str_repr(self):
+        SubGraph = nx.subgraph_view
+        for Graph in self.Graphs:
+            G = nx.path_graph(4, Graph)
+            SG = G.subgraph([2, 3])
+            RG = SubGraph(G, filter_node=nx.filters.hide_nodes([0, 1]))
+            str(SG.adj)
+            str(RG.adj)
+            repr(SG.adj)
+            repr(RG.adj)
+            str(SG.adj[2])
+            str(RG.adj[2])
+            repr(SG.adj[2])
+            repr(RG.adj[2])
+
+    def test_copy(self):
+        SubGraph = nx.subgraph_view
+        for Graph in self.Graphs:
+            G = nx.path_graph(4, Graph)
+            SG = G.subgraph([2, 3])
+            RG = SubGraph(G, filter_node=nx.filters.hide_nodes([0, 1]))
+            RsG = SubGraph(G, filter_node=nx.filters.show_nodes([2, 3]))
+            assert G.adj.copy() == G.adj
+            assert G.adj[2].copy() == G.adj[2]
+            assert SG.adj.copy() == SG.adj
+            assert SG.adj[2].copy() == SG.adj[2]
+            assert RG.adj.copy() == RG.adj
+            assert RG.adj[2].copy() == RG.adj[2]
+            assert RsG.adj.copy() == RsG.adj
+            assert RsG.adj[2].copy() == RsG.adj[2]

wemm/lib/python3.10/site-packages/nvidia_cublas_cu11-11.10.3.66.dist-info/INSTALLER

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

wemm/lib/python3.10/site-packages/nvidia_cublas_cu11-11.10.3.66.dist-info/METADATA

@@ -0,0 +1,37 @@
+Metadata-Version: 2.1
+Name: nvidia-cublas-cu11
+Version: 11.10.3.66
+Summary: CUBLAS native runtime libraries
+Home-page: https://developer.nvidia.com/cuda-zone
+Author: Nvidia CUDA Installer Team
+Author-email: cuda_installer@nvidia.com
+License: NVIDIA Proprietary Software
+Keywords: cuda,nvidia,runtime,machine learning,deep learning
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: Other/Proprietary License
+Classifier: Natural Language :: English
+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 :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: Microsoft :: Windows
+Requires-Python: >=3
+License-File: License.txt
+Requires-Dist: setuptools
+Requires-Dist: wheel
+
+CUBLAS native runtime libraries

wemm/lib/python3.10/site-packages/nvidia_cublas_cu11-11.10.3.66.dist-info/RECORD

@@ -0,0 +1,16 @@
+nvidia/cublas/include/cublas.h,sha256=a0lLqy-k47NuwyDjuueC3W0Mpc908MTU7o5sMJqE-1w,41246
+nvidia/cublas/include/cublasLt.h,sha256=FeRzOTFwOl0TPCMgnF6qH7RB_3gyJk6D18wodbWE2jM,69858
+nvidia/cublas/include/cublasXt.h,sha256=CW9dyXYGSUW1wEXrVVyhU6OxBK1PUvMoYdVGlQT7L9A,37380
+nvidia/cublas/include/cublas_api.h,sha256=NzuoObejh0gJfney-ufSeL8aZKHNF9I-V52bqtMcmHQ,220682
+nvidia/cublas/include/cublas_v2.h,sha256=DrT-TOKePZcfL_ld1ECGv2F30_9KznXxj5WXoABe2v4,8811
+nvidia/cublas/include/nvblas.h,sha256=dXCLR-2oUiJFzLsDtIAK09m42ct4G0HWdYzBUuDPXpc,23341
+nvidia/cublas/lib/libcublas.so.11,sha256=8VRUT5B05j14BHbR6N9mtBAAjGurzUTHGA9rXhGwjRc,151346592
+nvidia/cublas/lib/libcublasLt.so.11,sha256=hfFE3-ey71iNK2iKvz_dUajiahTkGgEcEtQf6K_JoEE,332762424
+nvidia/cublas/lib/libnvblas.so.11,sha256=eX1B5mULurQr_r_5l-tYnOcm7S_P7Y55WHtkcUIyVDA,733032
+nvidia_cublas_cu11-11.10.3.66.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+nvidia_cublas_cu11-11.10.3.66.dist-info/License.txt,sha256=rW9YU_ugyg0VnQ9Y1JrkmDDC-Mk_epJki5zpCttMbM0,59262
+nvidia_cublas_cu11-11.10.3.66.dist-info/METADATA,sha256=jBjkDirkcXbmo4mvN540Y-WdlX5SWynVAhl7MRzlMd4,1554
+nvidia_cublas_cu11-11.10.3.66.dist-info/RECORD,,
+nvidia_cublas_cu11-11.10.3.66.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nvidia_cublas_cu11-11.10.3.66.dist-info/WHEEL,sha256=-kQi_VMfvRQozZJT7HUPMfY-5vLo0LVTmAylNJ3Ft98,106
+nvidia_cublas_cu11-11.10.3.66.dist-info/top_level.txt,sha256=R64cT8LTfPfNCPStolkkVMRTsUQTajy66oibURM4Loc,14

wemm/lib/python3.10/site-packages/nvidia_cublas_cu11-11.10.3.66.dist-info/WHEEL

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

wemm/lib/python3.10/site-packages/qcloud_cos/ai_recognition.py

@@ -0,0 +1,1048 @@
+# -*- coding=utf-8
+import json
+
+from qcloud_cos import CosS3Auth
+from qcloud_cos.cos_client import logger, CosS3Client
+from .cos_comm import *
+
+
+class AIRecognitionClient(CosS3Client):
+
+    def cos_create_ai_object_detect_job(self, Bucket, ObjectKey="",
+        DetectUrl=None, **kwargs):
+        """ 图像主体检测 https://cloud.tencent.com/document/product/460/97979
+
+        :param Bucket(string) 存储桶名称.
+        :param ObjectKey(string) 设置 ObjectKey.
+        :param DetectUrl(string) 您可以通过填写 detect-url 处理任意公网可访问的图片链接。不填写 detect-url 时，后台会默认处理 ObjectKey ，填写了 detect-url 时，后台会处理 detect-url 链接，无需再填写 ObjectKey。 detect-url 示例：http://www.example.com/abc.jpg ，需要进行 UrlEncode，处理后为http%25253A%25252F%25252Fwww.example.com%25252Fabc.jpg。.
+        :param kwargs:(dict) 设置上传的headers.
+        :return(dict): response header.
+        :return(dict): 请求成功返回的结果,dict类型.
+
+        .. code-block:: python
+
+            config = CosConfig(Region=region, SecretId=secret_id, SecretKey=secret_key, Token=token)  # 获取配置对象
+            client = CosS3Client(config)
+            #  图像主体检测
+            response, data = client.cos_create_ai_object_detect_job(
+                Bucket='bucket',
+                ObjectKey='',
+                DetectUrl=''
+            )
+            print data
+            print response
+        """
+        headers = mapped(kwargs)
+        final_headers = {}
+        params = {}
+        for key in headers:
+            if key.startswith("response"):
+                params[key] = headers[key]
+            else:
+                final_headers[key] = headers[key]
+        headers = final_headers
+        params["ci-process"] = "AIObjectDetect"
+        if DetectUrl is not None:
+            params["detect-url"] = DetectUrl
+
+        params = format_values(params)
+
+        path = "/" + ObjectKey
+        url = self._conf.uri(bucket=Bucket, path=path)
+
+        logger.info(
+            "cos_create_ai_object_detect_job result, url=:{url} ,headers=:{headers}, params=:{params}".format(
+                url=url,
+                headers=headers,
+                params=params))
+        rt = self.send_request(
+            method='GET',
+            url=url,
+            auth=CosS3Auth(self._conf, path, params=params),
+            params=params,
+            headers=headers,
+            ci_request=False)
+
+        data = rt.content
+        response = dict(**rt.headers)
+        if 'Content-Type' in response:
+            if response['Content-Type'] == 'application/xml':
+                data = xml_to_dict(rt.content)
+                format_dict(data, ['Response'])
+            elif response['Content-Type'].startswith('application/json'):
+                data = rt.json()
+
+        return response, data
+
+    def cos_goods_matting(self, Bucket, ObjectKey="", DetectUrl=None,
+        CenterLayout=0, PaddingLayout=None, Stream=True, **kwargs):
+        """ 商品抠图 https://cloud.tencent.com/document/product/460/79735
+
+        :param Bucket(string) 存储桶名称.
+        :param ObjectKey(string) 设置 ObjectKey.
+        :param DetectUrl(string) 您可以通过填写 detect-url 处理任意公网可访问的图片链接。不填写 detect-url 时，后台会默认处理 ObjectKey ，填写了 detect-url 时，后台会处理 detect-url 链接，无需再填写 ObjectKey.
+        :param CenterLayout(int) 抠图商品居中显示； 值为1时居中显示，值为0时不作处理，默认为0.
+        :param PaddingLayout(string) 将处理后的图片四边进行留白，形式为 padding-layout=<dx>x<dy>，左右两边各进行 dx 像素的留白，上下两边各进行 dy 像素的留白.
+        :param kwargs:(dict) 设置上传的headers.
+        :return(dict): response header.
+        :return(dict): 请求成功返回的结果,dict类型.
+
+        .. code-block:: python
+
+            config = CosConfig(Region=region, SecretId=secret_id, SecretKey=secret_key, Token=token)  # 获取配置对象
+            client = CosS3Client(config)
+            #  商品抠图
+            response, data = client.cos_goods_matting(
+                Bucket='bucket',
+                ObjectKey='',
+                DetectUrl=''
+            )
+            print data
+            print response
+        """
+        params = {}
+        if DetectUrl is not None:
+            params["detect-url"] = DetectUrl
+        if CenterLayout != 0:
+            params["center-layout"] = CenterLayout
+        if PaddingLayout is not None:
+            params["padding-layout"] = PaddingLayout
+        path = "/" + ObjectKey
+        return self.ci_process(Bucket=Bucket, Key=path,
+                               CiProcess="GoodsMatting", Params=params,
+                               NeedHeader=True, Stream=Stream, **kwargs)
+
+    def cos_ai_body_recognition(self, Bucket, ObjectKey='', DetectUrl=None,
+        **kwargs):
+        """ 人体识别 https://cloud.tencent.com/document/product/460/83196
+
+            :param Bucket(string) 存储桶名称.
+            :param ObjectKey(string) 设置 ObjectKey.
+            :param DetectUrl(string) 您可以通过填写 detect-url 处理任意公网可访问的图片链接。不填写 detect-url 时，后台会默认处理 ObjectKey ，填写了 detect-url 时，后台会处理 detect-url 链接，无需再填写 ObjectKey detect-url 示例：http://www.example.com/abc.jpg ，需要进行 UrlEncode，处理后为http%25253A%25252F%25252Fwww.example.com%25252Fabc.jpg.
+            :param kwargs:(dict) 设置上传的headers.
+            :return(dict): response header.
+            :return(dict): 请求成功返回的结果,dict类型.
+
+            .. code-block:: python
+
+                config = CosConfig(Region=region, SecretId=secret_id, SecretKey=secret_key, Token=token)  # 获取配置对象
+                client = CosS3Client(config)
+                #  人体识别
+                response, data = client.cos_ai_body_recognition(
+                    Bucket='bucket',
+                    ObjectKey='',
+                    DetectUrl=''
+                )
+                print data
+                print response
+            """
+
+        params = {}
+        if DetectUrl is not None:
+            params["detect-url"] = DetectUrl
+
+        path = "/" + ObjectKey
+        return self.ci_process(Bucket=Bucket, Key=path,
+                               CiProcess="AIBodyRecognition", Params=params,
+                               NeedHeader=True, **kwargs)
+
+    def cos_ai_detect_face(self, Bucket, ObjectKey, MaxFaceNum=1, **kwargs):
+        """ 人脸检测 https://cloud.tencent.com/document/product/460/63223
+
+            :param Bucket(string) 存储桶名称.
+            :param ObjectKey(string) 设置 ObjectKey.
+            :param MaxFaceNum(int) 最多处理的人脸数目。默认值为1（仅检测图片中面积最大的那张人脸），最大���为120。此参数用于控制处理待检测图片中的人脸个数，值越小，处理速度越快。.
+            :param kwargs:(dict) 设置上传的headers.
+            :return(dict): response header.
+            :return(dict): 请求成功返回的结果,dict类型.
+
+            .. code-block:: python
+
+                config = CosConfig(Region=region, SecretId=secret_id, SecretKey=secret_key, Token=token)  # 获取配置对象
+                client = CosS3Client(config)
+                #  人脸检测
+                response, data = client.cos_ai_detect_face(
+                    Bucket='bucket',
+                    ObjectKey='',
+                    MaxFaceNum=''
+                )
+                print data
+                print response
+            """
+
+        params = {}
+        params["max-face-num"] = MaxFaceNum
+
+        path = "/" + ObjectKey
+        return self.ci_process(Bucket=Bucket, Key=path, CiProcess="DetectFace",
+                               Params=params, NeedHeader=True, **kwargs)
+
+    def cos_ai_detect_pet(self, Bucket, ObjectKey, **kwargs):
+        """ 宠物识别 https://cloud.tencent.com/document/product/460/95753
+
+            :param Bucket(string) 存储桶名称.
+            :param ObjectKey(string) 设置 ObjectKey.
+            :param kwargs:(dict) 设置上传的headers.
+            :return(dict): response header.
+            :return(dict): 请求成功返回的结果,dict类型.
+
+            .. code-block:: python
+
+                config = CosConfig(Region=region, SecretId=secret_id, SecretKey=secret_key, Token=token)  # 获取配置对象
+                client = CosS3Client(config)
+                #  宠物识别
+                response, data = client.cos_ai_detect_pet(
+                    Bucket='bucket',
+                    ObjectKey=''
+                )
+                print data
+                print response
+            """
+
+        params = {}
+
+        path = "/" + ObjectKey
+        return self.ci_process(Bucket=Bucket, Key=path, CiProcess="detect-pet",
+                               Params=params, NeedHeader=True, **kwargs)
+
+    def cos_ai_enhance_image(self, Bucket, ObjectKey='', Denoise=3,
+        Sharpen=3, DetectUrl=None, IgnoreError=None, Stream=True, **kwargs):
+        """ 图像增强 https://cloud.tencent.com/document/product/460/83792
+
+            :param Bucket(string) 存储桶名称.
+            :param ObjectKey(string) 设置 ObjectKey.
+            :param Denoise(int) 去噪强度值，取值范围为 0 - 5 之间的整数，值为 0 时不进行去噪操作，默认值为3。.
+            :param Sharpen(int) 锐化强度值，取值范围为 0 - 5 之间的整数，值为 0 时不进行锐化操作，默认值为3。.
+            :param DetectUrl(string) 您可以通过填写 detect-url 处理任意公网可访问的图片链接。不填写 detect-url  时，后台会默认处理 ObjectKey ，填写了detect-url 时，后台会处理 detect-url链接，无需再填写 ObjectKey ，detect-url 示例：http://www.example.com/abc.jpg ，需要进行 UrlEncode，处理后为  http%25253A%25252F%25252Fwww.example.com%25252Fabc.jpg.
+            :param IgnoreError(int) .
+            :param kwargs:(dict) 设置上传的headers.
+            :return(dict): response header.
+            :return(dict): 请求成功返回的结果,dict类型.
+
+            .. code-block:: python
+
+                config = CosConfig(Region=region, SecretId=secret_id, SecretKey=secret_key, Token=token)  # 获取配置对象
+                client = CosS3Client(config)
+                #  图像增强
+                response, data = client.cos_ai_enhance_image(
+                    Bucket='bucket',
+                    ObjectKey='',
+                    Denoise='',
+                    Sharpen='',
+                    DetectUrl='',
+                    IgnoreError=''
+                )
+                print data
+                print response
+            """
+
+        params = {}
+        if Denoise is not None:
+            params["denoise"] = Denoise
+        if Sharpen is not None:
+            params["sharpen"] = Sharpen
+        if DetectUrl is not None:
+            params["detect-url"] = DetectUrl
+        if IgnoreError is not None:
+            params["ignore-error"] = IgnoreError
+
+        path = "/" + ObjectKey
+        return self.ci_process(Bucket=Bucket, Key=path,
+                               CiProcess="AIEnhanceImage", Params=params,
+                               NeedHeader=True, Stream=Stream, **kwargs)
+
+    def cos_ai_face_effect(self, Bucket, Type, ObjectKey="", DetectUrl=None,
+        Whitening=30, Smoothing=10, FaceLifting=70, EyeEnlarging=70,
+        Gender=None, Age=None, **kwargs):
+        """ 人脸特效 https://cloud.tencent.com/document/product/460/47197
+
+            :param Bucket(string) 存储桶名称.
+            :param ObjectKey(string) 设置 ObjectKey.
+            :param DetectUrl(string) 您可以通过填写 detect-url 处理任意公网可访问的图片链接。不填写 detect-url 时，后台会默认处理 ObjectKey ，填写了 detect-url 时，后台会处理 detect-url 链接，无需再填写 ObjectKey detect-url 示例：http://www.example.com/abc.jpg ，需要进行 UrlEncode，处理后为http%25253A%25252F%25252Fwww.example.com%25252Fabc.jpg。.
+            :param Type(string) 人脸特效类型，人脸美颜：face-beautify；人脸性别转换：face-gender-transformation；人脸年龄变化：face-age-transformation；人像分割：face-segmentation.
+            :param Whitening(int) type为face-beautify时生效，美白程度，取值范围[0,100]。0不美白，100代表最高程度。默认值30.
+            :param Smoothing(int) type为face-beautify时生效，磨皮程度，取值范围[0,100]。0不磨皮，100代表最高程度。默认值10.
+            :param FaceLifting(int) type为face-beautify时生效，瘦脸程度，取值范围[0,100]。0不瘦脸，100代表最高程度。默认值70.
+            :param EyeEnlarging(int) type为face-beautify时生效，大眼程度，取值范围[0,100]。0不大眼，100代表最高程度。默认值70.
+            :param Gender(int) type为face-gender-transformation时生效，选择转换方向，0：男变女，1：女变男。无默认值，为必选项。限制：仅对图片中面积最大的人脸进行转换。.
+            :param Age(int) type为face-age-transformation时生效，变化到的人脸年龄,[10,80]。无默认值，为必选项。限制：仅对图片中面积最大的人脸进行转换。.
+            :param kwargs:(dict) 设置上传的headers.
+            :return(dict): response header.
+            :return(dict): 请求成功返回的结果,dict类型.
+
+            .. code-block:: python
+
+                config = CosConfig(Region=region, SecretId=secret_id, SecretKey=secret_key, Token=token)  # 获取配置对象
+                client = CosS3Client(config)
+                #  人脸特效
+                response, data = client.cos_ai_face_effect(
+                    Bucket='bucket',
+                    ObjectKey='',
+                    DetectUrl='',
+                    Type='',
+                    Whitening='',
+                    Smoothing='',
+                    FaceLifting='',
+                    EyeEnlarging='',
+                    Gender='',
+                    Age=''
+                )
+                print data
+                print response
+            """
+
+        params = {}
+        params["type"] = Type
+        if DetectUrl is not None:
+            params["detect-url"] = DetectUrl
+        if Whitening is not None:
+            params["whitening"] = Whitening
+        if Smoothing is not None:
+            params["smoothing"] = Smoothing
+        if FaceLifting is not None:
+            params["faceLifting"] = FaceLifting
+        if EyeEnlarging is not None:
+            params["eyeEnlarging"] = EyeEnlarging
+        if Gender is not None:
+            params["gender"] = Gender
+        if Age is not None:
+            params["age"] = Age
+
+        path = "/" + ObjectKey
+        return self.ci_process(Bucket=Bucket, Key=path, CiProcess="face-effect",
+                               Params=params, NeedHeader=True, **kwargs)
+
+    def cos_ai_game_rec(self, Bucket, ObjectKey='', DetectUrl=None, **kwargs):
+        """ 游戏场景识别 https://cloud.tencent.com/document/product/460/93153
+
+            :param Bucket(string) 存储桶名称.
+            :param ObjectKey(string) 图片地址.
+            :param DetectUrl(string) 您可以通过填写 detect-url 对任意公网可访问的图片进行游戏场景识别。不填写 detect-url 时，后台会默认处理 objectkey ；填写了 detect-url 时，后台会处理 detect-url 链接，无需再填写 objectkey ， detect-url 示例：http://www.example.com/abc.jpg。.
+            :param kwargs:(dict) 设置上传的headers.
+            :return(dict): response header.
+            :return(dict): 请求成功返回的结果,dict类型.
+
+            .. code-block:: python
+
+                config = CosConfig(Region=region, SecretId=secret_id, SecretKey=secret_key, Token=token)  # 获取配置对象
+                client = CosS3Client(config)
+                #  游戏场景识别
+                response, data = client.cos_ai_game_rec(
+                    Bucket='bucket',
+                    ObjectKey='',
+                    DetectUrl=''
+                )
+                print data
+                print response
+            """
+
+        params = {}
+        if DetectUrl is not None:
+            params["detect-url"] = DetectUrl
+
+        path = "/" + ObjectKey
+        return self.ci_process(Bucket=Bucket, Key=path, CiProcess="AIGameRec",
+                               Params=params, NeedHeader=True, **kwargs)
+
+    def cos_ai_id_card_ocr(self, Bucket, ObjectKey, CardSide=None, Config=None,
+        **kwargs):
+        """ 身份证识别 https://cloud.tencent.com/document/product/460/48638
+
+            :param Bucket(string) 存储桶名称.
+            :param ObjectKey(string) 设置 ObjectKey.
+            :param CardSide(string) FRONT：身份证有照片的一面（人像面）BACK：身份证有国徽的一面（国徽面）该参数如果不填，将为您自动判断身份证正反面.
+            :param Config(string) 以下可选字段均为 bool 类型，默认 false：CropIdCard，身份证照片裁剪（去掉证件外多余的边缘、自动矫正拍摄角度）CropPortrait，人像照片裁剪（自动抠取身份证头像区域）CopyWarn，复印件告警BorderCheckWarn，边框和框内遮挡告警ReshootWarn，翻拍告警DetectPsWarn，PS 检测告警TempIdWarn，临时身份证告警InvalidDateWarn，身份证有效日期不合法告警Quality，图片质量分数（评价图片的模糊程度）MultiCardDetect，是否开启多卡证检测参数设置方式参考：Config = {"CropIdCard":true,"CropPortrait":true}.
+            :param kwargs:(dict) 设置上传的headers.
+            :return(dict): response header.
+            :return(dict): 请求成功返回的结果,dict类型.
+
+            .. code-block:: python
+
+                config = CosConfig(Region=region, SecretId=secret_id, SecretKey=secret_key, Token=token)  # 获取配置对象
+                client = CosS3Client(config)
+                #  身份证识别
+                response, data = client.cos_aiid_card_ocr(
+                    Bucket='bucket',
+                    ObjectKey='',
+                    CardSide='',
+                    Config=''
+                )
+                print data
+                print response
+            """
+
+        params = {}
+        if CardSide is not None:
+            params["CardSide"] = CardSide
+        if Config is not None:
+            params["Config"] = Config
+
+        path = "/" + ObjectKey
+        return self.ci_process(Bucket=Bucket, Key=path, CiProcess="IDCardOCR",
+                               Params=params, NeedHeader=True, **kwargs)
+
+    def cos_ai_image_coloring(self, Bucket, ObjectKey="", DetectUrl=None,
+        Stream=True, **kwargs):
+        """ 图片上色 https://cloud.tencent.com/document/product/460/83794
+
+            :param Bucket(string) 存储桶名称.
+            :param ObjectKey(string) 设置 ObjectKey.
+            :param DetectUrl(string) 待上色图片url，需要进行urlencode，与ObjectKey二选其一，如果同时存在，则默认以ObjectKey为准.
+            :param kwargs:(dict) 设置上传的headers.
+            :return(dict): response header.
+            :return(dict): 请求成功返回的结果,dict类型.
+
+            .. code-block:: python
+
+                config = CosConfig(Region=region, SecretId=secret_id, SecretKey=secret_key, Token=token)  # 获取配置对象
+                client = CosS3Client(config)
+                #  图片上色
+                response, data = client.cos_ai_image_coloring(
+                    Bucket='bucket',
+                    ObjectKey='',
+                    DetectUrl=''
+                )
+                print data
+                print response
+            """
+
+        params = {}
+        if DetectUrl is not None:
+            params["detect-url"] = DetectUrl
+
+        path = "/" + ObjectKey
+        return self.ci_process(Bucket=Bucket, Key=path,
+                               CiProcess="AIImageColoring", Params=params,
+                               Stream=Stream, NeedHeader=True, **kwargs)
+
+    def cos_ai_image_crop(self, Bucket, Width, Height, ObjectKey="",
+        DetectUrl=None, Fixed=0, IgnoreError=None, Stream=True, **kwargs):
+        """ 图像智能裁剪 https://cloud.tencent.com/document/product/460/83791
+
+            :param Bucket(string) 存储桶名称.
+            :param ObjectKey(string) 设置 ObjectKey.
+            :param DetectUrl(string) 您可以通过填写 detect-url 处理任意公网可访问的图片链接。不填写 detect-url 时，后台会默认处理 ObjectKey ，填写了 detect-url 时，后台会处理 detect-url 链接，无需再填写 ObjectKey detect-url 示例：http://www.example.com/abc.jpg ，需要进行 UrlEncode，处理后为http%25253A%25252F%25252Fwww.example.com%25252Fabc.jpg.
+            :param Width(int) 需要裁剪区域的宽度，与height共同组成所需裁剪的图片宽高比例；输入数字请大于0、小于图片宽度的像素值.
+            :param Height(int) 需要裁剪区域的高度，与width共同组成所需裁剪的图片宽高比例；输入数字请大于0、小于图片高度的像素值；width : height建议取值在[1, 2.5]之间，超过这个范围可能会影响效果.
+            :param Fixed(int) 是否严格按照 width 和 height 的值进行输出。取值为0时，宽高比例（width : height）会简化为最简分数，即如果width输入10、height输入20，会简化为1：2；取值为1时，输出图片的宽度等于width，高度等于height；默认值为0.
+            :param IgnoreError(int) 当此参数为1时，针对文件过大等导致处理失败的场景，会直接返回原图而不报错.
+            :param kwargs:(dict) 设置上传的headers.
+            :return(dict): response header.
+            :return(dict): 请求成功返回的结果,dict类型.
+
+            .. code-block:: python
+
+                config = CosConfig(Region=region, SecretId=secret_id, SecretKey=secret_key, Token=token)  # 获取配置对象
+                client = CosS3Client(config)
+                #  图像智能裁剪
+                response, data = client.cos_ai_image_crop(
+                    Bucket='bucket',
+                    ObjectKey='',
+                    DetectUrl='',
+                    Width='',
+                    Height='',
+                    Fixed='',
+                    IgnoreError=''
+                )
+                print data
+                print response
+            """
+
+        params = {}
+        params["width"] = Width
+        params["height"] = Height
+        if DetectUrl is not None:
+            params["detect-url"] = DetectUrl
+        if Fixed is not None:
+            params["fixed"] = Fixed
+        if IgnoreError is not None:
+            params["ignore-error"] = IgnoreError
+
+        path = "/" + ObjectKey
+        return self.ci_process(Bucket=Bucket, Key=path, CiProcess="AIImageCrop",
+                               Params=params, NeedHeader=True, Stream=Stream,
+                               **kwargs)
+
+    def cos_ai_license_rec(self, Bucket, CardType, ObjectKey='', DetectUrl=None,
+        **kwargs):
+        """ 卡证识别 https://cloud.tencent.com/document/product/460/96767
+
+            :param Bucket(string) 存储桶名称.
+            :param ObjectKey(string) 设置 ObjectKey.
+            :param DetectUrl(string) 您可以通过填写 detect-url 处理任意公网可访问的图片链接。不填写 detect-url 时，后台会默认处理 ObjectKey ，填写了 detect-url 时，后台会处理 detect-url 链接，无需再填写 ObjectKey detect-url 示例：http://www.example.com/abc.jpg ，需要进行 UrlEncode，处理后为http%25253A%25252F%25252Fwww.example.com%25252Fabc.jpg.
+            :param CardType(string) 卡证识别类型，有效值为IDCard，DriverLicense。<br>IDCard表示身份证；DriverLicense表示驾驶证，默认：DriverLicense.
+            :param kwargs:(dict) 设置上传的headers.
+            :return(dict): response header.
+            :return(dict): 请求成功返回的结果,dict类型.
+
+            .. code-block:: python
+
+                config = CosConfig(Region=region, SecretId=secret_id, SecretKey=secret_key, Token=token)  # 获取配置对象
+                client = CosS3Client(config)
+                #  卡证识别
+                response, data = client.cos_ai_license_rec(
+                    Bucket='bucket',
+                    ObjectKey='',
+                    DetectUrl='',
+                    CardType=''
+                )
+                print data
+                print response
+            """
+
+        params = {}
+        params["ci-process"] = "AILicenseRec"
+        params["CardType"] = CardType
+        if DetectUrl is not None:
+            params["detect-url"] = DetectUrl
+
+        path = "/" + ObjectKey
+        return self.ci_process(Bucket=Bucket, Key=path,
+                               CiProcess="AILicenseRec", Params=params,
+                               NeedHeader=True, **kwargs)
+
+    def cos_ai_pic_matting(self, Bucket, ObjectKey='', DetectUrl=None,
+        CenterLayout=0, PaddingLayout=None, Stream=True, **kwargs):
+        """ 通用抠图 https://cloud.tencent.com/document/product/460/106750
+
+            :param Bucket(string) 存储桶名称.
+            :param ObjectKey(string) 设置 ObjectKey.
+            :param DetectUrl(string) 您可以通过填写 detect-url 处理任意公网可访问的图片链接。不填写 detect-url 时，后台会默认处理 ObjectKey ，填写了 detect-url 时，后台会处理 detect-url 链接，无需再填写 ObjectKey detect-url 示例：http://www.example.com/abc.jpg ，需要进行 UrlEncode，处理后为http%25253A%25252F%25252Fwww.example.com%25252Fabc.jpg。.
+            :param CenterLayout(int) 抠图主体居中显示；值为1时居中显示，值为0不做处理，默认为0.
+            :param PaddingLayout(string) 将处理后的图片四边进行留白，形式为 padding-layout=<dx>x<dy>，左右两边各进行 dx 像素的留白，上下两边各进行 dy 像素的留白，例如：padding-layout=20x10默认不进行留白操作，dx、dy 最大值为1000像素。.
+            :param kwargs:(dict) 设置上传的headers.
+            :return(dict): response header.
+            :return(dict): 请求成功返回的结果,dict类型.
+
+            .. code-block:: python
+
+                config = CosConfig(Region=region, SecretId=secret_id, SecretKey=secret_key, Token=token)  # 获取配置对象
+                client = CosS3Client(config)
+                #  通用抠图
+                response, data = client.cos_ai_pic_matting(
+                    Bucket='bucket',
+                    ObjectKey='',
+                    DetectUrl='',
+                    CenterLayout='',
+                    PaddingLayout=''
+                )
+                print data
+                print response
+            """
+
+        params = {}
+        if DetectUrl is not None:
+            params["detect-url"] = DetectUrl
+        if CenterLayout is not None:
+            params["center-layout"] = CenterLayout
+        if PaddingLayout is not None:
+            params["padding-layout"] = PaddingLayout
+
+        path = "/" + ObjectKey
+        return self.ci_process(Bucket=Bucket, Key=path,
+                               CiProcess="AIPicMatting", Params=params,
+                               NeedHeader=True, Stream=Stream, **kwargs)
+
+    def cos_ai_portrait_matting(self, Bucket, ObjectKey='', DetectUrl=None,
+        CenterLayout=0, PaddingLayout=None, Stream=True, **kwargs):
+        """ 人像抠图 https://cloud.tencent.com/document/product/460/106751
+
+            :param Bucket(string) 存储桶名称.
+            :param ObjectKey(string) 设置 ObjectKey.
+            :param DetectUrl(string) 您可以通过填写 detect-url 处理任意公网可访问的图片链接。不填写 detect-url 时，后台会默认处理 ObjectKey ，填写了 detect-url 时，后台会处理 detect-url 链接，无需再填写 ObjectKey。 detect-url 示例：http://www.example.com/abc.jpg，需要进行 UrlEncode，处理后为http%25253A%25252F%25252Fwww.example.com%25252Fabc.jpg。.
+            :param CenterLayout(int) 抠图主体居中显示；值为1时居中显示，值为0不做处理，默认为0.
+            :param PaddingLayout(string) 将处理后的图片四边进行留白，形式为 padding-layout=x，左右两边各进行 dx 像素的留白，上下两边各进行 dy 像素的留白，例如：padding-layout=20x10默认不进行留白操作，dx、dy最大值为1000像素。.
+            :param kwargs:(dict) 设置上传的headers.
+            :return(dict): response header.
+            :return(dict): 请求成功返回的结果,dict类型.
+
+            .. code-block:: python
+
+                config = CosConfig(Region=region, SecretId=secret_id, SecretKey=secret_key, Token=token)  # 获取配置对象
+                client = CosS3Client(config)
+                #  人像抠图
+                response, data = client.cos_ai_portrait_matting(
+                    Bucket='bucket',
+                    ObjectKey='',
+                    DetectUrl='',
+                    CenterLayout='',
+                    PaddingLayout=''
+                )
+                print data
+                print response
+            """
+
+        params = {}
+        if DetectUrl is not None:
+            params["detect-url"] = DetectUrl
+        if CenterLayout is not None:
+            params["center-layout"] = CenterLayout
+        if PaddingLayout is not None:
+            params["padding-layout"] = PaddingLayout
+
+        path = "/" + ObjectKey
+        return self.ci_process(Bucket=Bucket, Key=path,
+                               CiProcess="AIPortraitMatting", Params=params,
+                               NeedHeader=True, Stream=Stream, **kwargs)
+
+    def cos_auto_translation_block(self, Bucket, InputText, SourceLang,
+        TargetLang, TextDomain='general', TextStyle='sentence', **kwargs):
+        """ 实时文字翻译 https://cloud.tencent.com/document/product/460/83547
+
+            :param Bucket(string) 存储桶名称.
+            :param InputText(string) 待翻译的文本.
+            :param SourceLang(string) 输入语言，如 "zh".
+            :param TargetLang(string) 输出语言，如 "en".
+            :param TextDomain(string) 文本所属业务领域，如: "ecommerce", //缺省值为 general.
+            :param TextStyle(string) 文本类型，如: "title", //缺省值为 sentence.
+            :param kwargs:(dict) 设置上传的headers.
+            :return(dict): response header.
+            :return(dict): 请求成功返回的结果,dict类型.
+
+            .. code-block:: python
+
+                config = CosConfig(Region=region, SecretId=secret_id, SecretKey=secret_key, Token=token)  # 获取配置对象
+                client = CosS3Client(config)
+                #  实时文字翻译
+                response, data = client.cos_auto_translation_block(
+                    Bucket='bucket',
+                    InputText='',
+                    SourceLang='',
+                    TargetLang='',
+                    TextDomain='',
+                    TextStyle=''
+                )
+                print data
+                print response
+            """
+
+        params = {}
+        params["InputText"] = InputText
+        params["SourceLang"] = SourceLang
+        params["TargetLang"] = TargetLang
+        if TextDomain is not None:
+            params["TextDomain"] = TextDomain
+        if TextStyle is not None:
+            params["TextStyle"] = TextStyle
+
+        path = "/"
+        return self.ci_process(Bucket=Bucket, Key=path,
+                               CiProcess="AutoTranslationBlock", Params=params,
+                               NeedHeader=True, **kwargs)
+
+    def cos_get_action_sequence(self, Bucket, **kwargs):
+        """ 获取动作顺序 https://cloud.tencent.com/document/product/460/48648
+
+            :param Bucket(string) 存储桶名称.
+            :param kwargs:(dict) 设置上传的headers.
+            :return(dict): response header.
+            :return(dict): 请求成功返回的结果,dict类型.
+
+            .. code-block:: python
+
+                config = CosConfig(Region=region, SecretId=secret_id, SecretKey=secret_key, Token=token)  # 获取配置对象
+                client = CosS3Client(config)
+                #  获取动作顺序
+                response, data = client.cos_get_action_sequence(
+                    Bucket='bucket'
+                )
+                print data
+                print response
+            """
+
+        params = {}
+
+        path = "/"
+        return self.ci_process(Bucket=Bucket, Key=path,
+                               CiProcess="GetActionSequence", Params=params,
+                               NeedHeader=True, **kwargs)
+
+    def cos_get_live_code(self, Bucket, **kwargs):
+        """ 获取数字验证码 https://cloud.tencent.com/document/product/460/48647
+
+            :param Bucket(string) 存储桶名称.
+            :param kwargs:(dict) 设置上传的headers.
+            :return(dict): response header.
+            :return(dict): 请求成功返回的结果,dict类型.
+
+            .. code-block:: python
+
+                config = CosConfig(Region=region, SecretId=secret_id, SecretKey=secret_key, Token=token)  # 获取配置对象
+                client = CosS3Client(config)
+                #  获取数字验证码
+                response, data = client.cos_get_live_code(
+                    Bucket='bucket'
+                )
+                print data
+                print response
+            """
+
+        params = {}
+        path = "/"
+        return self.ci_process(Bucket=Bucket, Key=path, CiProcess="GetLiveCode",
+                               Params=params, NeedHeader=True, **kwargs)
+
+    def cos_image_repair(self, Bucket, ObjectKey="", DetectUrl=None,
+        MaskPic=None, MaskPoly=None, Stream=True, **kwargs):
+        """ 图像修复 https://cloud.tencent.com/document/product/460/79042
+
+            :param Bucket(string) 存储桶名称.
+            :param ObjectKey(string) 设置 ObjectKey.
+            :param kwargs:(dict) 设置上传的headers.
+            :return(dict): response header.
+            :return(dict): 请求成功返回的结果,dict类型.
+
+            .. code-block:: python
+
+                config = CosConfig(Region=region, SecretId=secret_id, SecretKey=secret_key, Token=token)  # 获取配置对象
+                client = CosS3Client(config)
+                #  图像修复
+                response, data = client.cos_image_repair(
+                    Bucket='bucket',
+                    ObjectKey=''
+                )
+                print data
+                print response
+            """
+
+        params = {}
+        if DetectUrl is not None:
+            params['detect-url'] = DetectUrl
+        if MaskPic is not None:
+            params['MaskPic'] = MaskPic
+        if MaskPoly is not None:
+            params['MaskPoly'] = MaskPoly
+        path = "/" + ObjectKey
+        return self.ci_process(Bucket=Bucket, Key=path, CiProcess="ImageRepair",
+                               Params=params, NeedHeader=True, Stream=Stream,
+                               **kwargs)
+
+    def cos_liveness_recognition(self, Bucket, ObjectKey, IdCard, Name,
+        LivenessType, ValidateData=None, BestFrameNum=None, **kwargs):
+        """ 活体人脸核身 https://cloud.tencent.com/document/product/460/48641
+
+            :param Bucket(string) 存储桶名称.
+            :param ObjectKey(string) 设置 ObjectKey.
+            :param IdCard(string) 身份证号.
+            :param Name(string) 姓名。中文请使用 UTF-8编码.
+            :param LivenessType(string) 活体检测类型，取值：LIP/ACTION/SILENTLIP 为数字模式，ACTION 为动作模式，SILENT 为静默模式，三种模式选择一种传入.
+            :param ValidateData(string) 数字模式传参：数字验证码（1234），需先调用接口获取数字验证码动作模式传参：传动作顺序（2，1 or 1，2），需先调用接口获取动作顺序静默模式传参：空.
+            :param BestFrameNum(int) 需要返回多张最佳截图，取值范围1 - 10，不设置默认返回一张最佳截图.
+            :param kwargs:(dict) 设置上传的headers.
+            :return(dict): response header.
+            :return(dict): 请求成功返回的结果,dict类型.
+
+            .. code-block:: python
+
+                config = CosConfig(Region=region, SecretId=secret_id, SecretKey=secret_key, Token=token)  # 获取配置对象
+                client = CosS3Client(config)
+                #  活体人脸核身
+                response, data = client.cos_liveness_recognition(
+                    Bucket='bucket',
+                    ObjectKey='',
+                    CiProcess='',
+                    IdCard='',
+                    Name='',
+                    LivenessType='',
+                    ValidateData='',
+                    BestFrameNum=''
+                )
+                print data
+                print response
+            """
+
+        params = {}
+        params["IdCard"] = IdCard
+        params["Name"] = Name
+        params["LivenessType"] = LivenessType
+        if ValidateData is not None:
+            params["ValidateData"] = ValidateData
+        if BestFrameNum is not None:
+            params["BestFrameNum"] = BestFrameNum
+
+        path = "/" + ObjectKey
+        return self.ci_process(Bucket=Bucket, Key=path,
+                               CiProcess="LivenessRecognition",
+                               Params=params, NeedHeader=True, **kwargs)
+
+    def ci_image_search_bucket(self, Bucket, Body, **kwargs):
+        """ 开通以图搜图 https://cloud.tencent.com/document/product/460/63899
+
+            :param Bucket(string) 存储桶名称.
+            :param Body:(dict) 开通以图搜图配置信息.
+            :param kwargs:(dict) 设置上传的headers.
+            :return(dict): response header.
+            :return(dict): 请求成功返回的结果,dict类型.
+
+            .. code-block:: python
+
+                config = CosConfig(Region=region, SecretId=secret_id, SecretKey=secret_key, Token=token)  # 获取配置对象
+                client = CosS3Client(config)
+                #  开通以图搜图
+                response, data = client.ci_image_search_bucket(
+                    Bucket='bucket',
+                    Body={}
+                )
+                print data
+                print response
+            """
+        headers = mapped(kwargs)
+        final_headers = {}
+        params = {}
+        for key in headers:
+            if key.startswith("response"):
+                params[key] = headers[key]
+            else:
+                final_headers[key] = headers[key]
+        headers = final_headers
+
+        params = format_values(params)
+        xml_config = format_xml(data=Body, root='Request')
+        path = "/" + "ImageSearchBucket"
+        url = self._conf.uri(bucket=Bucket, path=path,
+                             endpoint=self._conf._endpoint_ci)
+
+        logger.info(
+            "ci_image_search_bucket result, url=:{url} ,headers=:{headers}, params=:{params},xml_config=:{xml_config}".format(
+                url=url,
+                headers=headers,
+                params=params,
+                xml_config=xml_config))
+        rt = self.send_request(
+            method='POST',
+            url=url,
+            data=xml_config,
+            auth=CosS3Auth(self._conf, path, params=params),
+            params=params,
+            headers=headers,
+            ci_request=True)
+
+        data = rt.content
+        response = dict(**rt.headers)
+        if 'Content-Type' in response:
+            if response[
+                'Content-Type'] == 'application/xml' and 'Content-Length' in response and \
+                response['Content-Length'] != 0:
+                data = xml_to_dict(rt.content)
+                format_dict(data, ['Response'])
+            elif response['Content-Type'].startswith('application/json'):
+                data = rt.json()
+
+        return response, data
+
+    def cos_add_image_search(self, Bucket, ObjectKey, Body, **kwargs):
+        """ 添加图库图片 https://cloud.tencent.com/document/product/460/63900
+
+            :param Bucket(string) 存储桶名称.
+            :param ObjectKey(string) 设置 ObjectKey.
+            :param Body:(dict) 添加图库图片配置信息.
+            :param kwargs:(dict) 设置上传的headers.
+            :return(dict): response header.
+            :return(dict): 请求成功返回的结果,dict类型.
+
+            .. code-block:: python
+
+                config = CosConfig(Region=region, SecretId=secret_id, SecretKey=secret_key, Token=token)  # 获取配置对象
+                client = CosS3Client(config)
+                #  添加图库图片
+                response, data = client.cos_add_image_search(
+                    Bucket='bucket',
+                    ObjectKey='',
+                    Body={}
+                )
+                print data
+                print response
+            """
+        headers = mapped(kwargs)
+        final_headers = {}
+        params = {}
+        for key in headers:
+            if key.startswith("response"):
+                params[key] = headers[key]
+            else:
+                final_headers[key] = headers[key]
+        headers = final_headers
+        params["ci-process"] = "ImageSearch"
+        params["action"] = "AddImage"
+        params = format_values(params)
+
+        xml_config = format_xml(data=Body, root='Request')
+
+        path = "/" + ObjectKey
+        url = self._conf.uri(bucket=Bucket, path=path)
+
+        logger.info(
+            "cos_add_image_search result, url=:{url} ,headers=:{headers}, params=:{params},xml_config=:{xml_config}".format(
+                url=url,
+                headers=headers,
+                params=params,
+                xml_config=xml_config))
+        rt = self.send_request(
+            method='POST',
+            url=url,
+            data=xml_config,
+            auth=CosS3Auth(self._conf, path, params=params),
+            params=params,
+            headers=headers,
+            ci_request=False)
+
+        data = rt.content
+        response = dict(**rt.headers)
+        if 'Content-Type' in response:
+            if response[
+                'Content-Type'] == 'application/xml' and 'Content-Length' in response and \
+                response['Content-Length'] != 0:
+                data = xml_to_dict(rt.content)
+                format_dict(data, ['Response'])
+            elif response['Content-Type'].startswith('application/json'):
+                data = rt.json()
+
+        return response, data
+
+    def cos_get_search_image(self, Bucket, ObjectKey, MatchThreshold=0,
+        Offset=0, Limit=10, Filter=None, **kwargs):
+        """ 图片搜索接口 https://cloud.tencent.com/document/product/460/63901
+
+            :param Bucket(string) 存储桶名称.
+            :param ObjectKey(string) 设置 ObjectKey.
+            :param MatchThreshold(int) 出参 Score 中，只有超过 MatchThreshold 值的结果才会返回。默认为0.
+            :param Offset(int) 起始序号，默认值为0.
+            :param Limit(int) 返回数量，默认值为10，最大值为100.
+            :param Filter(string) 针对入库时提交的 Tags 信息进行条件过滤。支持>、>=、<、<=、=、!=，多个条件之间支持 AND 和 OR 进行连接.
+            :param kwargs:(dict) 设置上传的headers.
+            :return(dict): response header.
+            :return(dict): 请求成功返回的结果,dict类型.
+
+            .. code-block:: python
+
+                config = CosConfig(Region=region, SecretId=secret_id, SecretKey=secret_key, Token=token)  # 获取配置对象
+                client = CosS3Client(config)
+                #  图片搜索接口
+                response, data = client.cos_get_search_image(
+                    Bucket='bucket',
+                    ObjectKey='',
+                    MatchThreshold='',
+                    Offset='',
+                    Limit='',
+                    Filter=''
+                )
+                print data
+                print response
+            """
+        headers = mapped(kwargs)
+        final_headers = {}
+        params = {}
+        for key in headers:
+            if key.startswith("response"):
+                params[key] = headers[key]
+            else:
+                final_headers[key] = headers[key]
+        headers = final_headers
+        params["ci-process"] = "ImageSearch"
+        params["action"] = "SearchImage"
+        if MatchThreshold is not None:
+            params["MatchThreshold"] = MatchThreshold
+        if Offset is not None:
+            params["Offset"] = Offset
+        if Limit is not None:
+            params["Limit"] = Limit
+        if Filter is not None:
+            params["Filter"] = Filter
+
+        params = format_values(params)
+
+        path = "/" + ObjectKey
+        url = self._conf.uri(bucket=Bucket, path=path)
+
+        logger.info(
+            "cos_get_search_image result, url=:{url} ,headers=:{headers}, params=:{params}".format(
+                url=url,
+                headers=headers,
+                params=params))
+        rt = self.send_request(
+            method='GET',
+            url=url,
+            auth=CosS3Auth(self._conf, path, params=params),
+            params=params,
+            headers=headers,
+            ci_request=False)
+
+        data = rt.content
+        response = dict(**rt.headers)
+        if 'Content-Type' in response:
+            if response[
+                'Content-Type'] == 'application/xml' and 'Content-Length' in response and \
+                response['Content-Length'] != 0:
+                data = xml_to_dict(rt.content)
+                format_dict(data, ['Response'])
+            elif response['Content-Type'].startswith('application/json'):
+                data = rt.json()
+
+        return response, data
+
+    def cos_delete_image_search(self, Bucket, ObjectKey, Body, **kwargs):
+        """ 删除图库图片 https://cloud.tencent.com/document/product/460/63902
+
+            :param Bucket(string) 存储桶名称.
+            :param ObjectKey(string) 设置 ObjectKey.
+            :param Body:(dict) 删除图库图片配置信息.
+            :param kwargs:(dict) 设置上传的headers.
+            :return(dict): response header.
+            :return(dict): 请求成功返回的结果,dict类型.
+
+            .. code-block:: python
+
+                config = CosConfig(Region=region, SecretId=secret_id, SecretKey=secret_key, Token=token)  # 获取配置对象
+                client = CosS3Client(config)
+                #  删除图库图片
+                response, data = client.cos_delete_image_search(
+                    Bucket='bucket',
+                    ObjectKey='',
+                    Body={}
+                )
+                print data
+                print response
+            """
+        headers = mapped(kwargs)
+        final_headers = {}
+        params = {}
+        for key in headers:
+            if key.startswith("response"):
+                params[key] = headers[key]
+            else:
+                final_headers[key] = headers[key]
+        headers = final_headers
+
+        params["ci-process"] = "ImageSearch"
+        params["action"] = "DeleteImage"
+        params = format_values(params)
+        body = format_xml(data=Body, root='Request')
+        path = "/" + ObjectKey
+        url = self._conf.uri(bucket=Bucket, path=path)
+
+        logger.info(
+            "cos_delete_image_search result, url=:{url} ,headers=:{headers}, params=:{params},body=:{body}".format(
+                url=url,
+                headers=headers,
+                params=params,
+                body=body))
+        rt = self.send_request(
+            method='POST',
+            url=url,
+            data=body,
+            auth=CosS3Auth(self._conf, path, params=params),
+            params=params,
+            headers=headers,
+            ci_request=False)
+
+        data = rt.content
+        response = dict(**rt.headers)
+        if 'Content-Type' in response:
+            if response['Content-Type'] == 'application/xml' and 'Content-Length' in response and \
+                response['Content-Length'] != 0:
+                data = xml_to_dict(rt.content)
+                format_dict(data, ['Response'])
+            elif response['Content-Type'].startswith('application/json'):
+                data = rt.json()
+
+        return response, data

wemm/lib/python3.10/site-packages/qcloud_cos/cos_comm.py

@@ -0,0 +1,594 @@
+# -*- coding=utf-8
+
+from six import text_type, binary_type, string_types
+from six.moves.urllib.parse import quote, unquote, urlparse
+import hashlib
+import base64
+import os
+import io
+import re
+import sys
+import threading
+import xml.dom.minidom
+import xml.etree.ElementTree
+from datetime import datetime
+from xmltodict import unparse
+from .xml2dict import Xml2Dict
+from .cos_exception import CosClientError
+from .cos_exception import CosServiceError
+
+SINGLE_UPLOAD_LENGTH = 5 * 1024 * 1024 * 1024  # 单次上传文件最大为5GB
+DEFAULT_CHUNK_SIZE = 1024 * 1024  # 计算MD5值时,文件单次读取的块大小为1MB
+# kwargs中params到http headers的映射
+maplist = {
+    'ContentLength': 'Content-Length',
+    'ContentMD5': 'Content-MD5',
+    'ContentType': 'Content-Type',
+    'CacheControl': 'Cache-Control',
+    'ContentDisposition': 'Content-Disposition',
+    'ContentEncoding': 'Content-Encoding',
+    'ContentLanguage': 'Content-Language',
+    'Expires': 'Expires',
+    'ResponseContentType': 'response-content-type',
+    'ResponseContentLanguage': 'response-content-language',
+    'ResponseExpires': 'response-expires',
+    'ResponseCacheControl': 'response-cache-control',
+    'ResponseContentDisposition': 'response-content-disposition',
+    'ResponseContentEncoding': 'response-content-encoding',
+    'Metadata': 'Metadata',
+    'ACL': 'x-cos-acl',
+    'GrantFullControl': 'x-cos-grant-full-control',
+    'GrantWrite': 'x-cos-grant-write',
+    'GrantRead': 'x-cos-grant-read',
+    'StorageClass': 'x-cos-storage-class',
+    'Range': 'Range',
+    'IfMatch': 'If-Match',
+    'IfNoneMatch': 'If-None-Match',
+    'IfModifiedSince': 'If-Modified-Since',
+    'IfUnmodifiedSince': 'If-Unmodified-Since',
+    'CopySourceIfMatch': 'x-cos-copy-source-If-Match',
+    'CopySourceIfNoneMatch': 'x-cos-copy-source-If-None-Match',
+    'CopySourceIfModifiedSince': 'x-cos-copy-source-If-Modified-Since',
+    'CopySourceIfUnmodifiedSince': 'x-cos-copy-source-If-Unmodified-Since',
+    'VersionId': 'versionId',
+    'ServerSideEncryption': 'x-cos-server-side-encryption',
+    'SSEKMSKeyId': 'x-cos-server-side-encryption-cos-kms-key-id',
+    'SSEKMSContext': 'x-cos-server-side-encryption-context',
+    'SSECustomerAlgorithm': 'x-cos-server-side-encryption-customer-algorithm',
+    'SSECustomerKey': 'x-cos-server-side-encryption-customer-key',
+    'SSECustomerKeyMD5': 'x-cos-server-side-encryption-customer-key-MD5',
+    'CopySourceSSECustomerAlgorithm': 'x-cos-copy-source-server-side-encryption-customer-algorithm',
+    'CopySourceSSECustomerKey': 'x-cos-copy-source-server-side-encryption-customer-key',
+    'CopySourceSSECustomerKeyMD5': 'x-cos-copy-source-server-side-encryption-customer-key-MD5',
+    'Referer': 'Referer',
+    'PicOperations': 'Pic-Operations',
+    'TrafficLimit': 'x-cos-traffic-limit',
+    'Accept': 'Accept'
+}
+
+
+def to_str(s):
+    """非字符串转换为字符串"""
+    if isinstance(s, text_type) or isinstance(s, binary_type):
+        return s
+    return str(s)
+
+
+def to_unicode(s):
+    """将字符串转为unicode"""
+    if isinstance(s, binary_type):
+        try:
+            return s.decode('utf-8')
+        except UnicodeDecodeError as e:
+            raise CosClientError('your bytes strings can not be decoded in utf8, utf8 support only!')
+    return s
+
+
+def to_bytes(s):
+    """将字符串转为bytes"""
+    if isinstance(s, text_type):
+        try:
+            return s.encode('utf-8')
+        except UnicodeEncodeError as e:
+            raise CosClientError('your unicode strings can not encoded in utf8, utf8 support only!')
+    return s
+
+
+def get_raw_md5(data):
+    """计算md5 md5的输入必须为bytes"""
+    data = to_bytes(data)
+    m2 = hashlib.md5(data)
+    etag = '"' + str(m2.hexdigest()) + '"'
+    return etag
+
+
+def get_md5(data):
+    """计算 base64 md5 md5的输入必须为bytes"""
+    data = to_bytes(data)
+    m2 = hashlib.md5(data)
+    MD5 = base64.standard_b64encode(m2.digest())
+    return MD5
+
+
+def get_content_md5(body):
+    """计算任何输入流的md5值"""
+    if isinstance(body, text_type) or isinstance(body, binary_type):
+        return get_md5(body)
+    elif hasattr(body, 'tell') and hasattr(body, 'seek') and hasattr(body, 'read'):
+        file_position = body.tell()  # 记录文件当前位置
+        # avoid OOM
+        md5 = hashlib.md5()
+        chunk = body.read(DEFAULT_CHUNK_SIZE)
+        while chunk:
+            md5.update(to_bytes(chunk))
+            chunk = body.read(DEFAULT_CHUNK_SIZE)
+        md5_str = base64.standard_b64encode(md5.digest())
+        try:
+            body.seek(file_position)  # 恢复初始的文件位置
+        except Exception as e:
+            raise CosClientError('seek unsupported to calculate md5!')
+        return md5_str
+    else:
+        raise CosClientError('unsupported body type to calculate md5!')
+    return None
+
+
+def dict_to_xml(data):
+    """V5使用xml格式，将输入的dict转换为xml"""
+    doc = xml.dom.minidom.Document()
+    root = doc.createElement('CompleteMultipartUpload')
+    doc.appendChild(root)
+
+    if 'Part' not in data:
+        raise CosClientError("Invalid Parameter, Part Is Required!")
+
+    for i in data['Part']:
+        nodePart = doc.createElement('Part')
+
+        if 'PartNumber' not in i:
+            raise CosClientError("Invalid Parameter, PartNumber Is Required!")
+
+        nodeNumber = doc.createElement('PartNumber')
+        nodeNumber.appendChild(doc.createTextNode(str(i['PartNumber'])))
+
+        if 'ETag' not in i:
+            raise CosClientError("Invalid Parameter, ETag Is Required!")
+
+        nodeETag = doc.createElement('ETag')
+        nodeETag.appendChild(doc.createTextNode(str(i['ETag'])))
+
+        nodePart.appendChild(nodeNumber)
+        nodePart.appendChild(nodeETag)
+        root.appendChild(nodePart)
+    return doc.toxml('utf-8')
+
+
+def xml_to_dict(data, origin_str="", replace_str=""):
+    """V5使用xml格式，将response中的xml转换为dict"""
+    root = xml.etree.ElementTree.fromstring(data)
+    xmldict = Xml2Dict(root)
+    xmlstr = str(xmldict)
+    xmlstr = xmlstr.replace("{http://www.qcloud.com/document/product/436/7751}", "")
+    xmlstr = xmlstr.replace("{https://cloud.tencent.com/document/product/436}", "")
+    xmlstr = xmlstr.replace("{http://doc.s3.amazonaws.com/2006-03-01}", "")
+    xmlstr = xmlstr.replace("{http://s3.amazonaws.com/doc/2006-03-01/}", "")
+    xmlstr = xmlstr.replace("{http://www.w3.org/2001/XMLSchema-instance}", "")
+    if origin_str:
+        xmlstr = xmlstr.replace(origin_str, replace_str)
+    xmldict = eval(xmlstr)
+    return xmldict
+
+
+# def get_id_from_xml(data, name):
+#     """解析xml中的特定字段"""
+#     tree = xml.dom.minidom.parseString(data)
+#     root = tree.documentElement
+#     result = root.getElementsByTagName(name)
+#     # use childNodes to get a list, if has no child get itself
+#     return result[0].childNodes[0].nodeValue
+
+
+def mapped(headers):
+    """S3到COS参数的一个映射"""
+    _headers = dict()
+    for i in headers:
+        if i in maplist:
+            if i == 'Metadata':
+                for meta in headers[i]:
+                    _headers[meta] = headers[i][meta]
+            else:
+                _headers[maplist[i]] = headers[i]
+        else:
+            raise CosClientError('No Parameter Named ' + i + ' Please Check It')
+    return _headers
+
+
+# def format_xml(data, root, lst=list(), parent_child=False):
+#     """将dict转换为xml, xml_config是一个bytes"""
+#     if parent_child:
+#         xml_config = dicttoxml(data, item_func=lambda x: x[:-2], custom_root=root, attr_type=False)
+#     else:
+#         xml_config = dicttoxml(data, item_func=lambda x: x, custom_root=root, attr_type=False)
+#     for i in lst:
+#         xml_config = xml_config.replace(to_bytes(i + i), to_bytes(i))
+#     return xml_config
+
+
+def format_xml(data, root):
+    """将dict转换为xml, xml_config是一个bytes"""
+    input_dict = {root: data}
+    xml_config = unparse(input_dict=input_dict).encode('utf-8')
+    return xml_config
+
+
+def format_values(data):
+    """格式化headers和params中的values为bytes"""
+    for i in data:
+        data[i] = to_bytes(data[i])
+    return data
+
+
+def format_endpoint(endpoint, region, module, EnableOldDomain, EnableInternalDomain):
+    # 客户使用全球加速域名时，只会传endpoint不会传region。此时这样endpointCi和region同时为None，就会报错。
+    if not endpoint and not region and module == u'cos.':
+        raise CosClientError("Region or Endpoint is required not empty!")
+
+    """格式化终端域名"""
+    if endpoint:
+        return to_unicode(endpoint)
+    elif region:
+        region = format_region(region, module, EnableOldDomain, EnableInternalDomain)
+        if EnableOldDomain:
+            return u"{region}.myqcloud.com".format(region=region)
+        else:
+            return u"{region}.tencentcos.cn".format(region=region)
+    else:
+        return None
+
+def switch_hostname(host):
+    if not host:
+        raise CosClientError("Host is required not empty!")
+    
+    # *.cos.*-*.myqcloud.com
+    if re.match(r'^.*\.cos\..*\-.*\.myqcloud\.com$', host):
+        host = host[:-len(".myqcloud.com")] + ".tencentcos.cn"
+    
+    return host
+
+def switch_hostname_for_url(url):
+    if not url:
+        raise CosClientError("Url is required not empty!")
+
+    url_parsed = urlparse(url)
+    if url_parsed.hostname is not None:
+        host = url_parsed.hostname
+        new_host = switch_hostname(host)
+        if host != new_host:
+            new_url = url.replace(host, new_host)
+            return new_url
+
+    return url
+
+
+def format_region(region, module, EnableOldDomain, EnableInternalDomain):
+    """格式化地域"""
+    if not isinstance(region, string_types):
+        raise CosClientError("region is not string type")
+    if not region:
+        raise CosClientError("region is required not empty!")
+    region = to_unicode(region)
+    if not re.match(r'^[A-Za-z0-9][A-Za-z0-9.\-]*[A-Za-z0-9]$', region):
+        raise CosClientError("region format is illegal, only digit, letter and - is allowed!")
+    if region.find(module) != -1:
+        return region  # 传入cos.ap-beijing-1这样显示加上cos.的region
+    if region == u'cn-north' or region == u'cn-south' or region == u'cn-east' or region == u'cn-south-2' or region == u'cn-southwest' or region == u'sg':
+        return region  # 老域名不能加cos.
+    #  支持v4域名映射到v5
+
+    # 转换为内部域名 (只有新域名才支持内部域名)
+    if not EnableOldDomain and EnableInternalDomain and module == u'cos.':
+        module = u'cos-internal.'
+
+    if region == u'cossh':
+        return module + u'ap-shanghai'
+    if region == u'cosgz':
+        return module + u'ap-guangzhou'
+    if region == 'cosbj':
+        return module + u'ap-beijing'
+    if region == 'costj':
+        return module + u'ap-beijing-1'
+    if region == u'coscd':
+        return module + u'ap-chengdu'
+    if region == u'cossgp':
+        return module + u'ap-singapore'
+    if region == u'coshk':
+        return module + u'ap-hongkong'
+    if region == u'cosca':
+        return module + u'na-toronto'
+    if region == u'cosger':
+        return module + u'eu-frankfurt'
+
+    return module + region  # 新域名加上cos.
+
+
+def format_bucket(bucket, appid):
+    """兼容新老bucket长短命名,appid为空默认为长命名,appid不为空则认为是短命名"""
+    if not isinstance(bucket, string_types):
+        raise CosClientError("bucket is not string")
+    if not bucket:
+        raise CosClientError("bucket is required not empty")
+    if not (re.match(r'^[A-Za-z0-9][A-Za-z0-9\-]*[A-Za-z0-9]$', bucket) or re.match('^[A-Za-z0-9]$', bucket)):
+        raise CosClientError("bucket format is illegal, only digit, letter and - is allowed!")
+    # appid为空直接返回bucket
+    if not appid:
+        return to_unicode(bucket)
+    if not isinstance(appid, string_types):
+        raise CosClientError("appid is not string")
+    bucket = to_unicode(bucket)
+    appid = to_unicode(appid)
+    # appid不为空,检查是否以-appid结尾
+    if bucket.endswith(u"-" + appid):
+        return bucket
+    return bucket + u"-" + appid
+
+
+def path_simplify_check(path):
+    """将path按照posix路径语义合并后,如果结果为空或'/'则抛异常"""
+    path = to_unicode(path)
+    stack = list()
+    tokens = path.split(u'/')
+    for token in tokens:
+        if token == u'..':
+            if stack:
+                stack.pop()
+        elif token and token != u'.':
+            stack.append(token)
+    path = u'/' + u'/'.join(stack)
+    if path == u'/':
+        raise CosClientError("GetObject Key is invalid")
+
+
+def format_path(path):
+    """检查path是否合法,格式化path"""
+    if not isinstance(path, string_types):
+        raise CosClientError("key is not string")
+    if not path:
+        raise CosClientError("Key is required not empty")
+    path = to_unicode(path)
+    if path[0] == u'/':
+        path = path[1:]
+    # 提前对path进行encode
+    path = quote(to_bytes(path), b'/-_.~')
+    return path
+
+
+def get_copy_source_info(CopySource, EnableOldDomain, EnableInternalDomain):
+    """获取拷贝源的所有信息"""
+    appid = u""
+    versionid = u""
+    region = u""
+    endpoint = u""
+    if 'Appid' in CopySource:
+        appid = CopySource['Appid']
+    if 'Bucket' in CopySource:
+        bucket = CopySource['Bucket']
+        bucket = format_bucket(bucket, appid)
+    else:
+        raise CosClientError('CopySource Need Parameter Bucket')
+    if 'Region' in CopySource:
+        region = CopySource['Region']
+    if 'Endpoint' in CopySource:
+        endpoint = CopySource['Endpoint']
+    endpoint = format_endpoint(endpoint, region, u'cos.', EnableOldDomain, EnableInternalDomain)
+    if 'Key' in CopySource:
+        path = to_unicode(CopySource['Key'])
+        if path and path[0] == '/':
+            path = path[1:]
+    else:
+        raise CosClientError('CopySource Need Parameter Key')
+    if 'VersionId' in CopySource:
+        versionid = to_unicode(CopySource['VersionId'])
+    return bucket, path, endpoint, versionid
+
+
+def gen_copy_source_url(CopySource, EnableOldDomain, EnableInternalDomain):
+    """拼接拷贝源url"""
+    bucket, path, endpoint, versionid = get_copy_source_info(CopySource, EnableOldDomain, EnableInternalDomain)
+    path = format_path(path)
+    if versionid != u'':
+        path = path + u'?versionId=' + versionid
+    url = u"{bucket}.{endpoint}/{path}".format(
+        bucket=bucket,
+        endpoint=endpoint,
+        path=path
+    )
+    return url
+
+
+def gen_copy_source_range(begin_range, end_range):
+    """拼接bytes=begin-end形式的字符串"""
+    range = u"bytes={first}-{end}".format(
+        first=to_unicode(begin_range),
+        end=to_unicode(end_range)
+    )
+    return range
+
+
+def get_file_like_object_length(data):
+    try:
+        total_length = os.fstat(data.fileno()).st_size
+    except IOError:
+        if hasattr(data, '__len__'):
+            total_length = len(data)
+        else:
+            # support BytesIO file-like object
+            total_length = len(data.getvalue())
+    try:
+        current_position = data.tell()
+    except IOError:
+        current_position = 0
+    content_len = total_length - current_position
+    return content_len
+
+
+def check_object_content_length(data):
+    """put_object接口和upload_part接口的文件大小不允许超过5G"""
+    content_len = 0
+    if isinstance(data, text_type) or isinstance(data, binary_type):
+        content_len = len(to_bytes(data))
+    elif hasattr(data, 'fileno') and hasattr(data, 'tell'):
+        content_len = get_file_like_object_length(data)
+    else:
+        # can not get the content-length, use chunked to upload the file
+        pass
+    if content_len > SINGLE_UPLOAD_LENGTH:
+        raise CosClientError('The object size you upload can not be larger than 5GB in put_object or upload_part')
+    return None
+
+
+def format_dict(data, key_lst):
+    """转换返回dict中的可重复字段为list"""
+    if not (isinstance(data, dict) and isinstance(key_lst, list)):
+        return data
+    for key in key_lst:
+        # 将dict转为list，保持一致
+        if key in data and (isinstance(data[key], dict) or isinstance(data[key], string_types)):
+            lst = []
+            lst.append(data[key])
+            data[key] = lst
+        if key in data and data[key] is None:
+            lst = []
+            data[key] = lst
+    return data
+
+
+def format_dict_or_list(data, key_lst):
+    """转换返回dict或list中的可重复字段为list"""
+    if not ((isinstance(data, list) or isinstance(data, dict)) and isinstance(key_lst, list)):
+        return data
+    if isinstance(data, dict):
+        return format_dict(data, key_lst)
+
+    for data_item in data:
+        format_dict(data_item, key_lst)
+
+    return data
+
+
+def decode_result(data, key_lst, multi_key_list):
+    """decode结果中的字段"""
+    for key in key_lst:
+        if key in data and data[key]:
+            data[key] = unquote(data[key])
+    for multi_key in multi_key_list:
+        if multi_key[0] in data:
+            for item in data[multi_key[0]]:
+                if multi_key[1] in item and item[multi_key[1]]:
+                    item[multi_key[1]] = unquote(item[multi_key[1]])
+    return data
+
+
+def get_date(yy, mm, dd):
+    """获取lifecycle中Date字段"""
+    date_str = datetime(yy, mm, dd).isoformat()
+    final_date_str = date_str + '+08:00'
+    return final_date_str
+
+
+def parse_object_canned_acl(result_acl, rsp_headers):
+    """根据ACL返回的body信息,以及default头部来判断CannedACL"""
+    if "x-cos-acl" in rsp_headers and rsp_headers["x-cos-acl"] == "default":
+        return "default"
+    public_read = {'Grantee': {'Type': 'Group', 'URI': 'http://cam.qcloud.com/groups/global/AllUsers'},
+                   'Permission': 'READ'}
+    if 'AccessControlList' in result_acl and result_acl['AccessControlList'] is not None and 'Grant' in result_acl['AccessControlList']:
+        if public_read in result_acl['AccessControlList']['Grant']:
+            return "public-read"
+    return "private"
+
+
+def parse_bucket_canned_acl(result_acl):
+    """根据ACL返回的body信息来判断Bucket CannedACL"""
+    public_read = {'Grantee': {'Type': 'Group', 'URI': 'http://cam.qcloud.com/groups/global/AllUsers'},
+                   'Permission': 'READ'}
+    public_write = {'Grantee': {'Type': 'Group', 'URI': 'http://cam.qcloud.com/groups/global/AllUsers'},
+                    'Permission': 'WRITE'}
+    if 'AccessControlList' in result_acl and result_acl['AccessControlList'] is not None and 'Grant' in result_acl['AccessControlList']:
+        if public_read in result_acl['AccessControlList']['Grant']:
+            if public_write in result_acl['AccessControlList']['Grant']:
+                return "public-read-write"
+            return "public-read"
+    return "private"
+
+
+def client_can_retry(file_position, **kwargs):
+    """如果客户端请求中不包含data则可以重试,以及判断包含data的请求是否可以重试"""
+    if 'data' not in kwargs:
+        return True
+    body = kwargs['data']
+    if isinstance(body, text_type) or isinstance(body, binary_type):
+        return True
+    if file_position is not None and hasattr(body, 'tell') and hasattr(body, 'seek') and hasattr(body, 'read'):
+        try:
+            kwargs['data'].seek(file_position)
+            return True
+        except Exception as ioe:
+            return False
+    return False
+
+
+class CiDetectType():
+    """ci内容设备的类型设置,可与操作设多个"""
+    PORN = 1
+    TERRORIST = 2
+    POLITICS = 4
+    ADS = 8
+    ILLEGAL = 16
+    ABUSE = 32
+    TEENAGER = 64
+
+    @staticmethod
+    def get_detect_type_str(DetectType):
+        """获取审核的文字描述，这里只支持ci域名的入参，cos的跟这个还不一样"""
+        detect_type = ''
+        if DetectType & CiDetectType.PORN > 0:
+            detect_type += 'Porn'
+        if DetectType & CiDetectType.TERRORIST > 0:
+            if len(detect_type) > 0:
+                detect_type += ','
+            detect_type += 'Terrorism'
+        if DetectType & CiDetectType.POLITICS > 0:
+            if len(detect_type) > 0:
+                detect_type += ','
+            detect_type += 'Politics'
+        if DetectType & CiDetectType.ADS > 0:
+            if len(detect_type) > 0:
+                detect_type += ','
+            detect_type += 'Ads'
+        if DetectType & CiDetectType.ILLEGAL > 0:
+            if len(detect_type) > 0:
+                detect_type += ','
+            detect_type += 'Illegal'
+        if DetectType & CiDetectType.ABUSE > 0:
+            if len(detect_type) > 0:
+                detect_type += ','
+            detect_type += 'Abuse'
+        if DetectType & CiDetectType.TEENAGER > 0:
+            if len(detect_type) > 0:
+                detect_type += ','
+            detect_type += 'Teenager'
+
+        return detect_type
+
+
+class ProgressCallback():
+    def __init__(self, file_size, progress_callback):
+        self.__lock = threading.Lock()
+        self.__finished_size = 0
+        self.__file_size = file_size
+        self.__progress_callback = progress_callback
+
+    def report(self, size):
+        with self.__lock:
+            self.__finished_size += size
+            self.__progress_callback(self.__finished_size, self.__file_size)

wemm/lib/python3.10/site-packages/simplejson-3.19.3.dist-info/LICENSE.txt

@@ -0,0 +1,79 @@
+simplejson is dual-licensed software. It is available under the terms
+of the MIT license, or the Academic Free License version 2.1. The full
+text of each license agreement is included below. This code is also
+licensed to the Python Software Foundation (PSF) under a Contributor
+Agreement.
+
+MIT License
+===========
+
+Copyright (c) 2006 Bob Ippolito
+
+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.
+
+Academic Free License v. 2.1
+============================
+
+Copyright (c) 2006 Bob Ippolito.  All rights reserved.
+
+This Academic Free License (the "License") applies to any original work of authorship (the "Original Work") whose owner (the "Licensor") has placed the following notice immediately following the copyright notice for the Original Work:
+
+Licensed under the Academic Free License version 2.1
+
+1) Grant of Copyright License. Licensor hereby grants You a world-wide, royalty-free, non-exclusive, perpetual, sublicenseable license to do the following:
+
+a) to reproduce the Original Work in copies;
+
+b) to prepare derivative works ("Derivative Works") based upon the Original Work;
+
+c) to distribute copies of the Original Work and Derivative Works to the public;
+
+d) to perform the Original Work publicly; and
+
+e) to display the Original Work publicly.
+
+2) Grant of Patent License. Licensor hereby grants You a world-wide, royalty-free, non-exclusive, perpetual, sublicenseable license, under patent claims owned or controlled by the Licensor that are embodied in the Original Work as furnished by the Licensor, to make, use, sell and offer for sale the Original Work and Derivative Works.
+
+3) Grant of Source Code License. The term "Source Code" means the preferred form of the Original Work for making modifications to it and all available documentation describing how to modify the Original Work. Licensor hereby agrees to provide a machine-readable copy of the Source Code of the Original Work along with each copy of the Original Work that Licensor distributes. Licensor reserves the right to satisfy this obligation by placing a machine-readable copy of the Source Code in an information repository reasonably calculated to permit inexpensive and convenient access by You for as long as Licensor continues to distribute the Original Work, and by publishing the address of that information repository in a notice immediately following the copyright notice that applies to the Original Work.
+
+4) Exclusions From License Grant. Neither the names of Licensor, nor the names of any contributors to the Original Work, nor any of their trademarks or service marks, may be used to endorse or promote products derived from this Original Work without express prior written permission of the Licensor. Nothing in this License shall be deemed to grant any rights to trademarks, copyrights, patents, trade secrets or any other intellectual property of Licensor except as expressly stated herein. No patent license is granted to make, use, sell or offer to sell embodiments of any patent claims other than the licensed claims defined in Section 2. No right is granted to the trademarks of Licensor even if such marks are included in the Original Work. Nothing in this License shall be interpreted to prohibit Licensor from licensing under different terms from this License any Original Work that Licensor otherwise would have a right to license.
+
+5) This section intentionally omitted.
+
+6) Attribution Rights. You must retain, in the Source Code of any Derivative Works that You create, all copyright, patent or trademark notices from the Source Code of the Original Work, as well as any notices of licensing and any descriptive text identified therein as an "Attribution Notice." You must cause the Source Code for any Derivative Works that You create to carry a prominent Attribution Notice reasonably calculated to inform recipients that You have modified the Original Work.
+
+7) Warranty of Provenance and Disclaimer of Warranty. Licensor warrants that the copyright in and to the Original Work and the patent rights granted herein by Licensor are owned by the Licensor or are sublicensed to You under the terms of this License with the permission of the contributor(s) of those copyrights and patent rights. Except as expressly stated in the immediately proceeding sentence, the Original Work is provided under this License on an "AS IS" BASIS and WITHOUT WARRANTY, either express or implied, including, without limitation, the warranties of NON-INFRINGEMENT, MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY OF THE ORIGINAL WORK IS WITH YOU. This DISCLAIMER OF WARRANTY constitutes an essential part of this License. No license to Original Work is granted hereunder except under this disclaimer.
+
+8) Limitation of Liability. Under no circumstances and under no legal theory, whether in tort (including negligence), contract, or otherwise, shall the Licensor be liable to any person for any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or the use of the Original Work including, without limitation, damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses. This limitation of liability shall not apply to liability for death or personal injury resulting from Licensor's negligence to the extent applicable law prohibits such limitation. Some jurisdictions do not allow the exclusion or limitation of incidental or consequential damages, so this exclusion and limitation may not apply to You.
+
+9) Acceptance and Termination. If You distribute copies of the Original Work or a Derivative Work, You must make a reasonable effort under the circumstances to obtain the express assent of recipients to the terms of this License. Nothing else but this License (or another written agreement between Licensor and You) grants You permission to create Derivative Works based upon the Original Work or to exercise any of the rights granted in Section 1 herein, and any attempt to do so except under the terms of this License (or another written agreement between Licensor and You) is expressly prohibited by U.S. copyright law, the equivalent laws of other countries, and by international treaty. Therefore, by exercising any of the rights granted to You in Section 1 herein, You indicate Your acceptance of this License and all of its terms and conditions.
+
+10) Termination for Patent Action. This License shall terminate automatically and You may no longer exercise any of the rights granted to You by this License as of the date You commence an action, including a cross-claim or counterclaim, against Licensor or any licensee alleging that the Original Work infringes a patent. This termination provision shall not apply for an action alleging patent infringement by combinations of the Original Work with other software or hardware.
+
+11) Jurisdiction, Venue and Governing Law. Any action or suit relating to this License may be brought only in the courts of a jurisdiction wherein the Licensor resides or in which Licensor conducts its primary business, and under the laws of that jurisdiction excluding its conflict-of-law provisions. The application of the United Nations Convention on Contracts for the International Sale of Goods is expressly excluded. Any use of the Original Work outside the scope of this License or after its termination shall be subject to the requirements and penalties of the U.S. Copyright Act, 17 U.S.C. § 101 et seq., the equivalent laws of other countries, and international treaty. This section shall survive the termination of this License.
+
+12) Attorneys Fees. In any action to enforce the terms of this License or seeking damages relating thereto, the prevailing party shall be entitled to recover its costs and expenses, including, without limitation, reasonable attorneys' fees and costs incurred in connection with such action, including any appeal of such action. This section shall survive the termination of this License.
+
+13) Miscellaneous. This License represents the complete agreement concerning the subject matter hereof. If any provision of this License is held to be unenforceable, such provision shall be reformed only to the extent necessary to make it enforceable.
+
+14) Definition of "You" in This License. "You" throughout this License, whether in upper or lower case, means an individual or a legal entity exercising rights under, and complying with all of the terms of, this License. For legal entities, "You" includes any entity that controls, is controlled by, or is under common control with you. For purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity.
+
+15) Right to Use. You may use the Original Work in all ways not otherwise restricted or conditioned by this License or by law, and Licensor promises not to interfere with or be responsible for such uses by You.
+
+This license is Copyright (C) 2003-2004 Lawrence E. Rosen. All rights reserved. Permission is hereby granted to copy and distribute this license without modification. This license may not be modified without the express written permission of its copyright owner.

wemm/lib/python3.10/site-packages/torchgen/api/lazy.py

@@ -0,0 +1,470 @@
+from typing import Any, Dict, List, Optional, Tuple, Union
+
+from torchgen.api.types import (
+    BaseCppType,
+    BaseCType,
+    boolT,
+    CType,
+    deviceT,
+    doubleT,
+    layoutT,
+    ListCType,
+    longT,
+    memoryFormatT,
+    NamedCType,
+    OptionalCType,
+    scalarT,
+    scalarTypeT,
+    stringT,
+    SymIntT,
+    VectorCType,
+)
+
+from torchgen.model import (
+    Argument,
+    BaseTy,
+    BaseType,
+    FunctionSchema,
+    ListType,
+    OperatorName,
+    OptionalType,
+    Return,
+    TensorOptionsArguments,
+    Type,
+)
+
+
+_valueT = None
+
+
+# A ValueT is an IR type which represents the computation of a Tensor.  In other
+# words, a PyTorch user will do operations on lazy tensors, and each output lazy
+# tensor internally tracks a ValueT representing the IR node that would have
+# actually produced the value of this tensor for real.
+#
+# This is configurable because different lazy tensor backends (LTC vs XLA) will
+# have different IR representations.  (Though, arguably, after unification they
+# shouldn't!)
+def getValueT() -> BaseCppType:
+    global _valueT
+    if not _valueT:
+        raise NotImplementedError(
+            "The value type needs to be set with setValueT() in run_gen_lazy_tensor()"
+        )
+
+    return _valueT
+
+
+def setValueT(val: BaseCppType) -> None:
+    global _valueT
+    _valueT = val
+
+
+# this is a bad hack. I need to refactor the data model to represent each arg in the schema as an object,
+# making it easier to represent special properties of an arg.
+tensorListValueT = BaseCppType("torch::lazy", "Value")
+
+
+def process_ir_type(
+    typ: Type, properties: "LazyIrProperties", *, symint: bool
+) -> Union[BaseCType, VectorCType, OptionalCType, ListCType]:
+    """
+    This function takes a type from NativeFunctions and converts it for use with
+    lazy tensor codegen.
+
+    Type conversion for lazy currently consists of
+     (1) changing at::Tensors into lazy::Values
+     (2) wrapping everything in a BaseCType
+     (3) making cpp-reference types into cpp-value types (e.g. vector instead of IntArrayRef)
+
+    (1) converts at::Tensors to lazy::Values (which wrap lazy::Nodes, with which Lazy IR represents tensors.)
+    There is special handling for Optional[Tensor] or List[Tensor], etc- hence 'tensor-like'
+
+    This is incomplete- there are assertions in places that it's expected to need to add
+    more types as the codegen is used with more operators.
+    """
+    if isinstance(typ, BaseType):
+        if typ.name == BaseTy.Tensor:
+            return BaseCType(getValueT())
+        elif typ.name == BaseTy.Scalar:
+            if properties.TreatScalarsAsConstants:
+                return BaseCType(scalarT)
+            # at::scalar has special handling,
+            # and is wrapped in an lazy::Value just like at::tensor
+            return BaseCType(getValueT())
+        elif typ.name == BaseTy.ScalarType:
+            return BaseCType(scalarTypeT)
+        elif typ.name == BaseTy.int:
+            return BaseCType(longT)
+        elif typ.name == BaseTy.SymInt:
+            if symint:
+                return BaseCType(getValueT())
+            else:
+                return BaseCType(longT)
+        elif typ.name == BaseTy.bool:
+            return BaseCType(boolT)
+        elif typ.name == BaseTy.float:
+            return BaseCType(doubleT)
+        elif typ.name == BaseTy.str:
+            return BaseCType(stringT)
+        elif typ.name == BaseTy.Device:
+            return BaseCType(deviceT)
+        elif typ.name == BaseTy.Layout:
+            return BaseCType(layoutT)
+        elif typ.name == BaseTy.MemoryFormat:
+            return BaseCType(memoryFormatT)
+        else:
+            raise AssertionError(f"TODO add support for type {repr(typ)}")
+    elif isinstance(typ, OptionalType):
+        return OptionalCType(process_ir_type(typ.elem, properties, symint=symint))
+    elif isinstance(typ, ListType):
+        if str(typ.elem) == "Tensor?":
+            # TODO(whc) is this actually correct? or should it use a Vector like above
+            return ListCType(OptionalCType(BaseCType(getValueT())))
+        elif str(typ.elem) == "Tensor":
+            # this is a TensorList which comes in from GetTensorList as a Value
+            return BaseCType(tensorListValueT)
+        elif typ.elem == BaseType(BaseTy.SymInt):
+            # TODO: return a value type.  The problem here is analogous to
+            # the problem with tensorListValueT: if you have SymInt[] you
+            # cannot conveniently save the list of Value directly, as nodes
+            # expect to save values as a vector for ALL arguments.  So you
+            # need a separate IR node that represents all of the size nodes
+            # assembled into a list.  I'm not an LTC dev so I don't want to
+            # figure it out right now.  Y'all figure it out...
+            return VectorCType(BaseCType(longT))
+
+        else:
+            return VectorCType(process_ir_type(typ.elem, properties, symint=symint))
+    else:
+        raise AssertionError(f"unrecognized type {repr(typ)}")
+
+
+# TODO: Determining this based off of CType is bad; this should be computed
+# from Type directly; then the same logic as process_ir_type can be used
+#
+# Invariant: passed typ should be an *owning* CType (e.g., we will report
+# that ArrayRef<Value> is NOT a value type)
+def isValueType(typ: CType, properties: "Optional[LazyIrProperties]" = None) -> bool:
+    """
+    Given a type, determine if it is a Value-like type.  This is equivalent to
+    being Tensor-like, but assumes the type has already been transformed.
+    """
+    if isinstance(typ, BaseCType):
+        # I am regretting my naming conventions, but now we are wrapping at::scalar in
+        # lazy value, while preserving other 'scalar' types as scalars in the IR
+        treat_scalars_as_constants = properties and properties.TreatScalarsAsConstants
+        return (
+            typ.type == getValueT()
+            or (typ.type == scalarT and not treat_scalars_as_constants)
+            or typ.type == SymIntT
+        )
+    elif typ == VectorCType(BaseCType(SymIntT)):
+        # TODO: report True for this
+        return False
+    elif isinstance(typ, (OptionalCType, ListCType, VectorCType)):
+        return isValueType(typ.elem, properties)
+    return False
+
+
+def isSymIntType(typ: Type) -> bool:
+    return isinstance(typ, BaseType) and typ.name == BaseTy.SymInt
+
+
+def isWrappedScalarType(typ: Type) -> bool:
+    """
+    Given a type, determine if it is a c10::scalar which we will wrap in a lazy Value.
+    Since we literally change the type from scalarT to valueT, information is lost.
+    This function helps build a list of wrapped scalars to save that information
+    """
+    if isinstance(typ, BaseType):
+        # I am regretting my naming conventions, but now we are wrapping at::scalar in
+        # lazy value, while preserving other 'scalar' types as scalars in the IR
+        return typ.name == BaseTy.Scalar
+    elif isinstance(typ, (OptionalType, ListType)):
+        return isWrappedScalarType(typ.elem)
+    return False
+
+
+# TODO: dedupe with Type.is_generator_like
+def isGeneratorType(typ: Type) -> bool:
+    if isinstance(typ, BaseType):
+        return typ.name == BaseTy.Generator
+    elif isinstance(typ, (OptionalType)):
+        return isGeneratorType(typ.elem)
+    return False
+
+
+# This class caches a few derived properties computed from an Argument
+# and LazyIrProperties
+class LazyArgument:
+    name: str
+    orig_type: Type
+    lazy_type_: Optional[CType]
+    is_wrapped_scalar: bool
+    is_generator: bool
+    # TODO: this is lies, it is false for symint list
+    is_symint_or_list: bool
+
+    # Whether or not we are treating this as symint or not
+    symint: bool
+
+    # true if this argument is or contains a lazy IR value
+    is_lazy_value: bool
+
+    def __init__(self, arg: Argument, properties: "LazyIrProperties", *, symint: bool):
+        self.name = arg.name
+        self.orig_type = arg.type
+        self.symint = symint
+        self.is_optional = isinstance(arg.type, OptionalType)
+        self.is_generator = isGeneratorType(arg.type)
+        if self.is_generator:
+            assert (
+                self.is_optional
+            ), "We expect all generators are optional since currently they are"
+            # there is no handling for generators in TorchScript IR (or XLA)
+            # so we fall back to eager if the (optional)generator has value, and otherwise
+            # its null and safe to exclude from lazy IR
+            self.lazy_type_ = None
+        else:
+            self.lazy_type_ = process_ir_type(arg.type, properties, symint=symint)
+        self.is_wrapped_scalar = isWrappedScalarType(arg.type)
+        self.is_symint_or_list = symint and (
+            isSymIntType(arg.type)
+            or (isinstance(arg.type, OptionalType) and isSymIntType(arg.type.elem))
+            # TODO: lists of symints are not currently treated as value types
+            # or (isinstance(arg.type, ListType) and isSymIntType(arg.type.elem))
+        )
+
+        self.is_lazy_value = not self.is_generator and isValueType(
+            self.lazy_type, properties
+        )
+
+    @property
+    def lazy_type(self) -> CType:
+        assert (
+            self.lazy_type_ is not None
+        ), f"Attempted to access lazy_type for invalid argument {self.name}"
+        return self.lazy_type_
+
+
+class LazyIrProperties:
+    """Collection of properties for an IR node
+
+    The property groups are listed below. Each group is mutually
+    exclusive, meaning that only one property from each group can be True
+    at any one time. The properties can be accessed as if they were normal
+    attributes. The mutual exclusivity is automatically handled.
+    """
+
+    Properties: Tuple[Tuple[str, ...], ...] = (
+        (
+            "ShapePrecompute",  # Assume shape has been precomputed
+            "ShapeCompute",  # Need to compute the shape on construction
+            "ShapeCache",  # Utilize the shape cache to defer computation
+        ),
+        (
+            "Lower",  # Codegen full lower function
+            "LowerDeclOnly",  # Codegen only lower function declaration
+        ),
+        (
+            "CanBeReused",  # Codegen full reuse function
+            "CanBeReusedDeclOnly",  # Codegen only reuse function declaration
+        ),
+        (
+            "CreateFn",  # Codegen full create function
+            "CreateFnDeclOnly",  # Codegen only create function declaration
+        ),
+        (
+            "TreatScalarsAsConstants",  # Treat Scalars as constants instead of handling like values
+        ),
+    )
+
+    def __init__(self, *default_properties: str):
+        properties: Dict[Tuple[str, ...], Optional[str]] = {
+            p: None for p in LazyIrProperties.Properties
+        }
+        self.__dict__["properties"] = properties
+        for p in default_properties:
+            setattr(self, p, True)
+
+    def __getattr__(self, key: str) -> Any:
+        properties = self.__dict__["properties"]
+        for values in LazyIrProperties.Properties:
+            if key in values:
+                return properties[values] == key
+
+        return self.__getattribute__(key)
+
+    def __setattr__(self, key: str, value: Any) -> Any:
+        properties = self.__dict__["properties"]
+        for values in LazyIrProperties.Properties:
+            if key in values:
+                properties[values] = key if value else None
+                return value
+
+        raise KeyError(f"Invalid property: {key}")
+
+
+# Inspired by a FunctionSchema object, a LazyIrSchema holds the schema of a Lazy IR node.
+# Unlike a FunctionSchema, it has no round-trippable string form (relating to the YAML),
+# but carries type information from a native FunctionSchema modified for use with IR nodes,
+# and preserving original argument names.
+#
+# TODO: This is not idiomatic with how other torchgen APIs transform on schema.
+class LazyIrSchema:
+    # The name of the operator this function schema describes.
+    name: "OperatorName"
+
+    positional_args: Tuple[LazyArgument, ...]
+    keyword_args: Tuple[LazyArgument, ...]
+
+    # TODO: Need to handle collisions with argument names at some point
+    returns: Tuple["Return", ...]
+
+    # if this schema has a Generator arg, list its orig ctype/name but don't
+    # build a LazyArgument since lazy IR doesn't support it
+    generator_arg: Optional[NamedCType] = None
+
+    # original function schema
+    func: FunctionSchema
+
+    # Whether or not we are code-genning for SymInt or not
+    symint: bool
+
+    properties: LazyIrProperties = LazyIrProperties(
+        # default properties
+        "ShapePrecompute",
+        "Lower",
+        "CanBeReused",
+    )
+    opkind: Optional[str] = None
+
+    def __init__(
+        self,
+        func: FunctionSchema,
+        properties: Optional[LazyIrProperties] = None,
+        *,
+        symint: bool,
+    ):
+        if properties:
+            self.properties = properties
+
+        self.func = func
+        self.symint = symint
+        positional_args: List[LazyArgument] = []
+        for arg_field in ["pre_self_positional", "self_arg", "post_self_positional"]:
+            if arg_field == "self_arg" and func.arguments.self_arg is not None:
+                arg = getattr(func.arguments, "self_arg").argument
+                positional_args.append(
+                    LazyArgument(arg, self.properties, symint=symint)
+                )
+            elif getattr(func.arguments, arg_field) is not None:
+                positional_args.extend(
+                    LazyArgument(arg, self.properties, symint=symint)
+                    for arg in getattr(func.arguments, arg_field)
+                )
+        self.positional_args = tuple(positional_args)
+
+        keyword_args: List[LazyArgument] = []
+        for arg_field in [
+            "pre_tensor_options_kwarg_only",
+            "tensor_options",
+            "post_tensor_options_kwarg_only",
+            "out",
+        ]:
+            curr_args = getattr(func.arguments, arg_field)
+            if curr_args is not None:
+                if isinstance(curr_args, TensorOptionsArguments):
+                    curr_args = curr_args.all()
+                for arg in curr_args:
+                    if isGeneratorType(arg.type):
+                        assert (
+                            self.generator_arg is None
+                        ), "We expect there is only one generator arg"
+                        self.generator_arg = NamedCType(arg.name, arg.type)
+                keyword_args.extend(
+                    LazyArgument(arg, self.properties, symint=symint)
+                    for arg in curr_args
+                )
+        self.keyword_args = tuple(keyword_args)
+        self.name = func.name
+        self.returns = func.returns
+
+    @property
+    def node_name(self) -> str:
+        """
+        Return camel-case version of op in node.
+
+        Note: This function also appends any `overload_name` in the operation.
+        For example, if the op is `bitwise_and.Tensor`, the returned name
+        will be `BitwiseAndTensor`.
+        """
+        op_name = f"{self.name.name}_{self.name.overload_name}".lower()
+        return "".join(word.capitalize() or "" for word in op_name.split("_"))
+
+    @property
+    def aten_name(self) -> str:
+        return str(self.name.name)
+
+    @property
+    def base_name(self) -> str:
+        return f"{self.name.name.base}"
+
+    def filtered_args(
+        self,
+        positional: bool = True,
+        keyword: bool = True,
+        values: bool = True,
+        scalars: bool = True,
+        generator: bool = False,
+    ) -> List[LazyArgument]:
+        # This function maintains the sorted order of arguments but provides different filtered views.
+        # Some parts of the code care about kwargs vs args (TS lowerings),
+        # other parts care about whether they need to wrap the arg in a lazy value or leave it alone.
+        # Generators are special cased, as they are needed for fallback/shape-inference but not supported
+        # in TS lowerings and therefore also omitted from lazy IR.
+        args: List[LazyArgument] = []
+        if positional:
+            args.extend(self.positional_args)
+        if keyword:
+            args.extend(self.keyword_args)
+
+        if values and scalars and generator:
+            return args
+        elif values and scalars:
+            return [a for a in args if not a.is_generator]
+        elif values:
+            return [a for a in args if a.is_lazy_value]
+        elif scalars:
+            return [
+                a
+                for a in args
+                if not a.is_lazy_value and (generator or not a.is_generator)
+            ]
+
+        return []
+
+    @property
+    def positional_values(self) -> List[LazyArgument]:
+        return self.filtered_args(
+            positional=True, keyword=False, values=True, scalars=False
+        )
+
+    @property
+    def positional_scalars(self) -> List[LazyArgument]:
+        return self.filtered_args(
+            positional=True, keyword=False, values=False, scalars=True
+        )
+
+    @property
+    def keyword_values(self) -> List[LazyArgument]:
+        return self.filtered_args(
+            positional=False, keyword=True, values=True, scalars=False
+        )
+
+    @property
+    def keyword_scalars(self) -> List[LazyArgument]:
+        return self.filtered_args(
+            positional=False, keyword=True, values=False, scalars=True
+        )

wemm/lib/python3.10/site-packages/torchgen/api/types/signatures.py

@@ -0,0 +1,422 @@
+from dataclasses import dataclass
+
+from typing import Iterator, List, Optional, Sequence, Set, Tuple, Union
+
+from torchgen.model import (
+    BackendIndex,
+    FunctionSchema,
+    NativeFunction,
+    NativeFunctionsGroup,
+    NativeFunctionsViewGroup,
+)
+
+from .types_base import Binding, CType, Expr
+
+
+@dataclass(frozen=True)
+class CppSignature:
+    """
+    A CppSignature represents a single overload in the C++ API.  For
+    any given function schema, there may be multiple CppSignatures
+    corresponding to it, based on how we desugar to C++.  See also
+    CppSignatureGroup.
+    """
+
+    # The schema this signature is derived from
+    func: FunctionSchema
+
+    # Is this a C++ signature for a method, i.e. Tensor::my_op(...)?
+    method: bool
+
+    # Is this a faithful C++ signature (i.e. following the JIT schema) or a convenience API
+    # (i.e. with a potential TensorOptions argument and out arguments in the front)
+    faithful: bool
+
+    # Is this a symint C++ signature.  For BC reasons, functions that take
+    # SymInts still present as int64_t in C++, and the SymInt variant is
+    # offered at a different overload name
+    symint: bool
+
+    # The set of C++ arguments which should not have defaults applied to them
+    cpp_no_default_args: Set[str]
+
+    # Is this a fallback C++ binding?  Fallback bindings are enabled by
+    # manual_cpp_binding: True and are alternate, non-public API that
+    # lets manual C++ binding implementors access the binding that would
+    # have been automatically generated
+    fallback_binding: bool = False
+
+    # Return the unpacked argument structure of this signature,
+    # discarding information about which arguments are semantically
+    # related to each other.
+    def arguments(self) -> Sequence[Binding]:
+        return cpp.arguments(
+            self.func.arguments,
+            faithful=self.faithful,
+            symint=self.symint,
+            method=self.method,
+            cpp_no_default_args=self.cpp_no_default_args,
+        )
+
+    def name(self, *, suppress_symint_suffix: bool = False) -> str:
+        n = cpp.name(
+            self.func,
+            faithful_name_for_out_overloads=self.faithful,
+            symint_overload=False if suppress_symint_suffix else self.symint,
+        )
+        if self.fallback_binding:
+            n = f"__dispatch_{n}"
+        return n
+
+    # Render the C++ declaration for this signature
+    def decl(
+        self,
+        *,
+        name: Optional[str] = None,
+        prefix: str = "",
+        is_redispatching_fn: bool = False,
+        suppress_symint_suffix: bool = False,
+    ) -> str:
+        returns_type = cpp.returns_type(
+            self.func.returns, symint=self.symint
+        ).cpp_type()
+        cpp_args = [a.decl() for a in self.arguments()]
+        if is_redispatching_fn:
+            cpp_args = ["c10::DispatchKeySet dispatchKeySet"] + cpp_args
+        cpp_args_str = ", ".join(cpp_args)
+        if name is None:
+            name = prefix + self.name(suppress_symint_suffix=suppress_symint_suffix)
+        return f"{returns_type} {name}({cpp_args_str})"
+
+    # Render the C++ definition for this signature, not including
+    # the body (with curly braces)
+    def defn(
+        self,
+        *,
+        name: Optional[str] = None,
+        prefix: str = "",
+        is_redispatching_fn: bool = False,
+    ) -> str:
+        returns_type = cpp.returns_type(
+            self.func.returns, symint=self.symint
+        ).cpp_type()
+        cpp_args = [a.defn() for a in self.arguments()]
+        if is_redispatching_fn:
+            cpp_args = ["c10::DispatchKeySet dispatchKeySet"] + cpp_args
+        cpp_args_str = ", ".join(cpp_args)
+        if name is None:
+            name = prefix + self.name()
+        return f"{returns_type} {name}({cpp_args_str})"
+
+    def ptr_type(self) -> str:
+        args_types_str = ", ".join(a.type for a in self.arguments())
+        return f"{cpp.returns_type(self.func.returns, symint=self.symint).cpp_type()} (*)({args_types_str})"
+
+    # Return the C++ function type, e.g., something like int(bool)
+    def type(self) -> str:
+        args_types_str = ", ".join(a.type for a in self.arguments())
+        return f"{cpp.returns_type(self.func.returns, symint=self.symint).cpp_type()} ({args_types_str})"
+
+
+# Represents group of all CppSignatures associated with a
+# FunctionSchema.  Right now, that's the regular, user-visible
+# signature, as well as a "faithful" signature which doesn't
+# have grouping.
+@dataclass(frozen=True)
+class CppSignatureGroup:
+    func: FunctionSchema
+    signature: CppSignature
+    faithful_signature: Optional[CppSignature]
+    symint_signature: Optional[CppSignature]
+    symint_faithful_signature: Optional[CppSignature]
+
+    def most_faithful_signature(self) -> CppSignature:
+        if self.faithful_signature:
+            return self.faithful_signature
+        else:
+            return self.signature
+
+    def signatures(self, *, symint: bool = True) -> Iterator[CppSignature]:
+        yield self.signature
+        if self.faithful_signature:
+            yield self.faithful_signature
+        if symint:
+            if self.symint_signature:
+                yield self.symint_signature
+            if self.symint_faithful_signature:
+                yield self.symint_faithful_signature
+
+    @staticmethod
+    def from_native_function(
+        f: NativeFunction, *, method: bool, fallback_binding: bool = False
+    ) -> "CppSignatureGroup":
+        func = f.func
+
+        def make_sig(*, faithful: bool, symint: bool) -> CppSignature:
+            return CppSignature(
+                func=func,
+                faithful=faithful,
+                symint=symint,
+                method=method,
+                fallback_binding=fallback_binding,
+                cpp_no_default_args=f.cpp_no_default_args,
+            )
+
+        def make_sigs(*, symint: bool) -> Tuple[CppSignature, Optional[CppSignature]]:
+            faithful_signature: Optional[CppSignature] = None
+            if func.arguments.tensor_options is not None or len(func.arguments.out) > 0:
+                faithful_signature = make_sig(faithful=True, symint=symint)
+            signature = make_sig(faithful=False, symint=symint)
+            return signature, faithful_signature
+
+        signature, faithful_signature = make_sigs(symint=False)
+        symint_signature: Optional[CppSignature] = None
+        symint_faithful_signature: Optional[CppSignature] = None
+        if func.has_symint():
+            symint_signature, symint_faithful_signature = make_sigs(symint=True)
+
+        return CppSignatureGroup(
+            func=func,
+            signature=signature,
+            faithful_signature=faithful_signature,
+            symint_signature=symint_signature,
+            symint_faithful_signature=symint_faithful_signature,
+        )
+
+
+@dataclass(frozen=True)
+class DispatcherSignature:
+    # The schema this signature is derived from
+    func: FunctionSchema
+
+    # Allows you to prepend an arbitrary prefix to the signature name.
+    # This is useful for parts of the codegen that generate wrappers around kernels,
+    # and need to avoid naming collisions.
+    prefix: str = ""
+
+    symint: bool = True
+
+    def arguments(self) -> List[Binding]:
+        return dispatcher.arguments(self.func, symint=self.symint)
+
+    def name(self) -> str:
+        return self.prefix + dispatcher.name(self.func)
+
+    def decl(self, name: Optional[str] = None) -> str:
+        args_str = ", ".join(a.decl() for a in self.arguments())
+        if name is None:
+            name = self.name()
+        return f"{self.returns_type().cpp_type()} {name}({args_str})"
+
+    def defn(
+        self, name: Optional[str] = None, *, is_redispatching_fn: bool = False
+    ) -> str:
+        args = [a.defn() for a in self.arguments()]
+        if is_redispatching_fn:
+            args = ["c10::DispatchKeySet dispatchKeySet"] + args
+        args_str = ", ".join(args)
+        if name is None:
+            name = self.name()
+        return f"{self.returns_type().cpp_type()} {name}({args_str})"
+
+    def exprs(self) -> List[Expr]:
+        return [Expr(a.name, a.nctype) for a in self.arguments()]
+
+    def returns_type(self) -> CType:
+        return dispatcher.returns_type(self.func.returns, symint=self.symint)
+
+    def ptr_type(self) -> str:
+        dispatcher_args_types_str = ", ".join(a.type for a in self.arguments())
+        return f"{self.returns_type().cpp_type()} (*)({dispatcher_args_types_str})"
+
+    # Return the C++ function type, e.g., something like int(bool)
+    def type(self) -> str:
+        dispatcher_args_types_str = ", ".join(a.type for a in self.arguments())
+        return f"{self.returns_type().cpp_type()} ({dispatcher_args_types_str})"
+
+    @staticmethod
+    def from_schema(
+        func: FunctionSchema, *, prefix: str = "", symint: bool = True
+    ) -> "DispatcherSignature":
+        return DispatcherSignature(func, prefix, symint)
+
+
+@dataclass(frozen=True)
+class NativeSignature:
+    # The schema this signature is derived from
+    func: FunctionSchema
+
+    symint: bool
+
+    prefix: str = ""
+
+    def name(self) -> str:
+        return self.prefix + native.name(self.func)
+
+    def decl(self, name: Optional[str] = None) -> str:
+        args_str = ", ".join(a.decl() for a in self.arguments())
+        if name is None:
+            name = self.name()
+        return f"{native.returns_type(self.func.returns, symint=self.symint).cpp_type()} {name}({args_str})"
+
+    def defn(self, name: Optional[str] = None) -> str:
+        args_str = ", ".join(a.defn() for a in self.arguments())
+        if name is None:
+            name = self.name()
+        return f"{native.returns_type(self.func.returns, symint=self.symint).cpp_type()} {name}({args_str})"
+
+    def ptr_type(self) -> str:
+        # don't include defaults in type signature!
+        args_str = ", ".join(a.defn() for a in self.arguments())
+        return f"{native.returns_type(self.func.returns, symint=self.symint).cpp_type()} (*)({args_str})"
+
+    def arguments(self) -> List[Binding]:
+        return native.arguments(self.func, symint=self.symint)
+
+    def returns_type(self) -> CType:
+        return native.returns_type(self.func.returns, symint=self.symint)
+
+    def dispatcher_exprs(self) -> List[Expr]:
+        return translate.translate(
+            self.arguments(), dispatcher.arguments(self.func), method=False
+        )
+
+
+@dataclass(frozen=True)
+class ViewInverseSignature:
+    g: NativeFunctionsViewGroup
+
+    def name(self) -> str:
+        assert self.g.view_copy is not None
+        return functionalization.name(self.g, is_reverse=True, include_namespace=False)
+
+    def decl(self) -> str:
+        assert self.g.view_copy is not None
+        return_type = functionalization.returns_type(self.g.view_copy.func)
+        decls = [
+            a.decl()
+            for a in functionalization.inner_arguments(
+                self.g.view_copy.func, is_reverse=True
+            )
+        ]
+        return f"static {return_type.cpp_type()} {self.name()}({', '.join(decls)});"
+
+
+@dataclass(frozen=True)
+class FunctionalizationLambda:
+    g: NativeFunctionsViewGroup
+
+    # are we generating the forward lambda or the reverse lambda?
+    is_reverse: bool
+
+    def captures(self) -> List[Expr]:
+        # The lambda lives inside of a kernel following the dispatcher API, so its outer context is the dispatcher arguments
+        # We also need to read the "reapply views" TLS at the time that the functionalization kernel was executed,
+        # and plumb it into the lambda.
+        outer_ctx = dispatcher.arguments(self.g.view.func) + [
+            functionalization.reapply_views_binding
+        ]
+        capture_bindings = functionalization.capture_arguments(
+            self.g.view.func, is_reverse=self.is_reverse
+        )
+        # allow_expensive_conversions is set because we want to convert
+        # some reference types (IntArrayRef) to value types (vector<int64_t>).
+        capture_exprs = translate.translate(
+            outer_ctx, capture_bindings, method=False, allow_expensive_conversions=True
+        )
+        return capture_exprs
+
+    def decl(self) -> str:
+        return_type = functionalization.returns_type(self.g.view.func)
+        capture_str = ", ".join(
+            f"{val.type.name} = {val.expr}" for val in self.captures()
+        )
+        decls = [
+            a.decl()
+            for a in functionalization.outer_arguments(is_reverse=self.is_reverse)
+        ]
+        return f"[{capture_str}]({', '.join(decls)}) -> {return_type.cpp_type()}"
+
+    def inner_call(self, *, reapply_views: Optional[bool] = None) -> str:
+        inner_call_name = functionalization.name(
+            self.g,
+            is_reverse=self.is_reverse,
+            include_namespace=True,
+            reapply_views=reapply_views,
+        )
+
+        arg_ctx = functionalization.outer_arguments(is_reverse=self.is_reverse)
+        capture_ctx = functionalization.capture_arguments(
+            self.g.view.func, is_reverse=self.is_reverse
+        )
+        full_ctx = arg_ctx + capture_ctx
+
+        assert self.g.view_copy is not None
+        call_bindings = functionalization.inner_arguments(
+            self.g.view_copy.func, is_reverse=self.is_reverse
+        )
+        maybe_index = functionalization.inner_call_index(self.g.view_copy.func)
+        call_exprs = [
+            e.expr for e in translate.translate(full_ctx, call_bindings, method=False)
+        ]
+        if not self.is_reverse and maybe_index is not None:
+            return f'{inner_call_name}({", ".join(call_exprs)})[{maybe_index.name}];'
+        else:
+            return f'{inner_call_name}({", ".join(call_exprs)});'
+
+    @staticmethod
+    def from_func(
+        g: NativeFunctionsViewGroup, *, is_reverse: bool
+    ) -> "FunctionalizationLambda":
+        return FunctionalizationLambda(g, is_reverse)
+
+
+@dataclass(frozen=True)
+class StructuredImplSignature:
+    g: NativeFunctionsGroup
+    name: str
+
+    def defn(self, name: Optional[str] = None) -> str:
+        args_str = ", ".join(a.defn() for a in self.arguments())
+        return f"TORCH_IMPL_FUNC({self.name})({args_str})"
+
+    def arguments(self) -> List[Binding]:
+        return structured.impl_arguments(self.g)
+
+
+# Helper functions
+
+
+def kernel_signature(
+    f: NativeFunction, backend_index: BackendIndex, *, prefix: str = ""
+) -> Union["NativeSignature", "DispatcherSignature"]:
+    # Note [External Backends Follow Dispatcher API]
+    # Kernel signatures for in-tree backends follow the "native" API,
+    # while kernels for out-of-tree backends follow the dispatcher API.
+    # See the comments in `native.py` for details, but historically there have been
+    # some small differences in schema convention between them and the Dispatcher API.
+    # Any differences that require translating between the two will results in a runtime cost,
+    # so we'd like to keep the differences as small as possible.
+    # With external backends, we'd like to enforce that they write their kernels with schemas
+    # that match the Dispatcher API directly, if they can.
+    meta = backend_index.get_kernel(f)
+    symint = meta is not None and meta.supports_symint()
+    if symint:
+        assert (
+            f.func.has_symint()
+        ), f"attempted to define symint kernel for {backend_index.dispatch_key} without SymInt in schema"
+    if backend_index.external:
+        return DispatcherSignature.from_schema(f.func, prefix=prefix, symint=symint)
+    else:
+        return NativeSignature(f.func, prefix=prefix, symint=symint)
+
+
+# Functions only, no types
+from torchgen.api import (
+    cpp,
+    dispatcher,
+    functionalization,
+    native,
+    structured,
+    translate,
+)

wemm/lib/python3.10/site-packages/torchgen/api/unboxing.py

@@ -0,0 +1,248 @@
+from typing import List, Tuple
+
+from torchgen.api import cpp
+from torchgen.api.types import Binding, CppSignatureGroup, CType
+from torchgen.model import (
+    Argument,
+    BaseTy,
+    BaseType,
+    ListType,
+    NativeFunction,
+    OptionalType,
+    Type,
+)
+
+# This file generates the code for unboxing wrappers, i.e., the glue logic to unbox a boxed operator and convert the
+# ivalues from stack to correct arguments to the unboxed kernel, based on corresponding JIT schema. This codegen is
+# an alternative way to generate unboxing wrappers similar to the existing C++ metaprogramming approach but gets the
+# job done statically. These generated unboxing wrappers will be useful under the scenario where we need to register
+# a fixed set of operators known at compile time and thus can save some time in runtime initialization phase.
+#
+# Here's an example on how the codegen works:
+#
+# - Function Schema (source of truth)
+#
+#      aten::empty.names(int[] size, *, Dimname[]? names,
+#                        ScalarType? dtype=None, Layout? layout=None,
+#                        Device? device=None, bool? pin_memory=None,
+#                        MemoryFormat? memory_format=None) -> Tensor
+# - Argument Conversion
+#       Generates C++ code to convert an ivalue (from stack) to its underlying C++ type.
+#    - int[] size
+#        ```cpp
+#           const c10::List<c10::IValue> size_list_in = (std::move(peek(stack, 0, 7))).toList();
+#
+#           std::vector<int64_t> size_vec;
+#           for (c10::IValue size_elem: size_list_in) {
+#               int64_t size_base = size_elem.to<int64_t>();
+#               size_vec.push_back(size_base);
+#           }
+#           at::ArrayRef<int64_t> size_list_out(size_vec);
+#                                 ~~~~~~~~~~~~~ <-- The converted argument from ivalues in the stack.
+#                                                   Will be passed to unboxed kernel.
+#       ```
+#    - Dimname[]? names
+#       ```cpp
+#           c10::optional<c10::IValue> names_opt = (std::move(peek(stack, 1, 7))).toOptional<c10::IValue>();
+#           c10::optional<at::ArrayRef<at::Dimname>> names_opt_out;
+#           if (names_opt.has_value()) {
+#                         ~~~~~~~~~~~ <-- Unwrapping optional shell
+#               const c10::IValue names_opt_in = names_opt.value();
+#               const c10::List<c10::IValue> names_list_in = names_opt_in.toList();
+#
+#               std::vector<at::Dimname> names_vec;
+#               for (c10::IValue names_elem: names_list_in) {
+#                                ~~~~~~~~~~~~~~~~~~~~~~~~~ <-- Unrolling list, then convert elements one by one.
+#                   at::Dimname names_base = names_elem.to<at::Dimname>();
+#                   names_vec.push_back(names_base);
+#               }
+#               at::ArrayRef<at::Dimname> names_list_out(names_vec);
+#
+#               names_opt_out = c10::optional<at::ArrayRef<at::Dimname>>(names_list_out);
+#           } else {
+#               names_opt_out = c10::optional<at::ArrayRef<at::Dimname>>();
+#           }
+#       ```
+#    - ScalarType? dtype (similarly for the rest of the arguments)
+#       ```cpp
+#           c10::optional<c10::IValue> dtype_opt = (std::move(peek(stack, 2, 7))).toOptional<c10::IValue>();
+#           c10::optional<at::ScalarType> dtype_opt_out;
+#           if (dtype_opt.has_value()) {
+#               const c10::IValue dtype_opt_in = dtype_opt.value();
+#               at::ScalarType dtype_base = dtype_opt_in.to<at::ScalarType>();
+#                                                        ~~~~~~~~~~~~~~~~~~~~ <-- For base types, convert ivalue to it
+#                                                                                 directly using ".to<T>()" API.
+#               dtype_opt_out = c10::optional<at::ScalarType>(dtype_base);
+#           } else {
+#               dtype_opt_out = c10::optional<at::ScalarType>();
+#           }
+#       ```
+#
+# - Unboxed Kernel Call
+#   ```cpp
+#       auto result_ = torch::empty(
+#           size_list_out,
+#           names_opt_out,
+#           options,
+#           memory_format_opt_out
+#       );
+#   ```
+#
+# - Push Result Back to Stack
+#   ```cpp
+#       drop(stack, 7);
+#       pack(stack, std::move(result_));
+#   ```
+connector = "\n\t"
+
+
+# Return unboxing function name for a NativeFunction
+def name(f: NativeFunction) -> str:
+    return f.func.name.unambiguous_name()
+
+
+# Convert all the arguments in a NativeFunction to C++ code
+def convert_arguments(f: NativeFunction) -> Tuple[List[Binding], List[str]]:
+    # we need the 'self' argument so method needs to be False
+    args = (
+        CppSignatureGroup.from_native_function(f, method=False)
+        .most_faithful_signature()
+        .arguments()
+    )
+    code_list = [
+        f"c10::IValue {args[i].name} = std::move(peek(stack, {i}, {len(args)}));"
+        for i in range(len(args))
+    ] + [""]
+    binding_list = []
+    for i, arg in enumerate(args):
+        # expecting only Argument
+        if not isinstance(arg.argument, Argument):
+            raise Exception(
+                f"Unexpected argument type, expecting `Argument` but got {arg}"
+            )
+        argument: Argument = arg.argument
+        unboxed_name, _, code, decl = argumenttype_ivalue_convert(
+            argument.type,
+            argument.name,
+            mutable=argument.is_write,
+        )
+        code_list.extend(decl)
+        code_list.extend(code)
+        binding_list.append(arg.with_name(unboxed_name))
+    return binding_list, code_list
+
+
+# Takes in the type, name and mutability corresponding to an argument, and generates a tuple of:
+# (1) the C++ code necessary to unbox the argument
+# (2) A Binding corresponding to the newly created unboxed variable, including variable name and its CType
+def argumenttype_ivalue_convert(
+    t: Type, arg_name: str, *, mutable: bool = False
+) -> Tuple[str, CType, List[str], List[str]]:
+    # Unboxing is for mobile, which doesn't care about SymInts
+    ctype = cpp.argumenttype_type(
+        t=t, mutable=mutable, binds=arg_name, symint=False
+    ).type
+
+    if isinstance(t, BaseType):
+        out_name = f"{arg_name}_base"
+        code, decl = _gen_code_base_type(
+            arg_name=arg_name, out_name=out_name, ctype=ctype
+        )
+    elif isinstance(t, OptionalType):
+        out_name = f"{arg_name}_opt_out"
+        code, decl = _gen_code_optional_type(
+            arg_name=arg_name,
+            out_name=out_name,
+            t=t,
+            ctype=ctype,
+        )
+    elif isinstance(t, ListType):
+        out_name = f"{arg_name}_list_out"
+        code, decl = _gen_code_list_type(
+            arg_name=arg_name,
+            out_name=out_name,
+            t=t,
+            ctype=ctype,
+        )
+    else:
+        raise Exception(f"Cannot handle type {t}. arg_name: {arg_name}")
+    return out_name, ctype, code, decl
+
+
+def _gen_code_base_type(
+    arg_name: str, out_name: str, ctype: CType
+) -> Tuple[List[str], List[str]]:
+    return [
+        f"{ctype.cpp_type(strip_ref=True)} {out_name} = {arg_name}.to<{ctype.cpp_type(strip_ref=True)}>();"
+    ], []
+
+
+def _gen_code_optional_type(
+    arg_name: str, out_name: str, t: OptionalType, ctype: CType
+) -> Tuple[List[str], List[str]]:
+    in_name = f"{arg_name}_opt_in"
+    res_name, _, res_code, decl = argumenttype_ivalue_convert(t.elem, in_name)
+    return (
+        f"""
+c10::optional<c10::IValue> {arg_name}_opt = {arg_name}.toOptional<c10::IValue>();
+{ctype.cpp_type(strip_ref=True)} {out_name};
+if ({arg_name}_opt.has_value()) {{
+    const c10::IValue {in_name} = {arg_name}_opt.value();
+    {connector.join(res_code)}
+    {out_name} = {ctype.cpp_type(strip_ref=True)}({res_name});
+}} else {{
+    {out_name} = {ctype.cpp_type(strip_ref=True)}();
+}}
+        """.split(
+            "\n"
+        ),
+        decl,
+    )
+
+
+def _gen_code_list_type(
+    arg_name: str, out_name: str, t: ListType, ctype: CType
+) -> Tuple[List[str], List[str]]:
+    in_name = f"{arg_name}_list_in"
+    elem_name = f"{arg_name}_elem"
+    code = [f"const c10::List<c10::IValue> {in_name} = {arg_name}.toList();"]
+    res_name, res_ctype, res_code, decl = argumenttype_ivalue_convert(t.elem, elem_name)
+    # handle list type with size, e.g., bool[4]
+    if isinstance(t.elem, BaseType) and t.elem.name == BaseTy.bool and t.size:
+        code.extend(
+            f"""
+{ctype.cpp_type(strip_ref=True)} {out_name} = as_array<{res_ctype.cpp_type(strip_ref=True)}, {t.size}>({in_name});
+            """.split(
+                "\n"
+            )
+        )
+    # we have to use c10::List for optional element. e.g., Tensor?[] -> c10::List<c10::optional<at::Tensor>>
+    elif isinstance(t.elem, OptionalType):
+        code.extend(
+            f"""
+{ctype.cpp_type(strip_ref=True)} {out_name};
+for (c10::IValue {elem_name}: {in_name}) {{
+    {connector.join(res_code)}
+    {out_name}.push_back({res_name});
+}}
+            """.split(
+                "\n"
+            )
+        )
+    else:
+        # use ArrayRef as default.
+        vec_name = arg_name + "_vec"
+        # need to bring vector instantiation out of scope so that ArrayRef has valid data
+        decl.append(f"std::vector<{res_ctype.cpp_type(strip_ref=True)}> {vec_name};")
+        code.extend(
+            f"""
+for (c10::IValue {elem_name}: {in_name}) {{
+    {connector.join(res_code)}
+    {vec_name}.push_back({res_name});
+}}
+{ctype.cpp_type(strip_ref=True)} {out_name}({vec_name});
+            """.split(
+                "\n"
+            )
+        )
+    return code, decl

wemm/lib/python3.10/site-packages/torchgen/dest/__init__.py

@@ -0,0 +1,19 @@
+from .lazy_ir import (
+    generate_non_native_lazy_ir_nodes as generate_non_native_lazy_ir_nodes,
+    GenLazyIR as GenLazyIR,
+    GenLazyNativeFuncDefinition as GenLazyNativeFuncDefinition,
+    GenLazyShapeInferenceDefinition as GenLazyShapeInferenceDefinition,
+)
+from .native_functions import (
+    compute_native_function_declaration as compute_native_function_declaration,
+)
+from .register_dispatch_key import (
+    gen_registration_headers as gen_registration_headers,
+    gen_registration_helpers as gen_registration_helpers,
+    RegisterDispatchKey as RegisterDispatchKey,
+)
+from .ufunc import (
+    compute_ufunc_cpu as compute_ufunc_cpu,
+    compute_ufunc_cpu_kernel as compute_ufunc_cpu_kernel,
+    compute_ufunc_cuda as compute_ufunc_cuda,
+)

wemm/lib/python3.10/site-packages/torchgen/dest/ufunc.py

@@ -0,0 +1,545 @@
+from dataclasses import dataclass
+from typing import Dict, List, Optional, Sequence, Tuple, Union
+
+import torchgen.api.ufunc as ufunc
+from torchgen.api.translate import translate
+from torchgen.api.types import (
+    BaseCType,
+    Binding,
+    CType,
+    Expr,
+    NamedCType,
+    opmath_t,
+    scalar_t,
+    StructuredImplSignature,
+    VectorizedCType,
+)
+from torchgen.api.ufunc import UfunctorBindings
+from torchgen.context import with_native_function
+from torchgen.model import (
+    Argument,
+    BaseTy,
+    BaseType,
+    DispatchKey,
+    NativeFunctionsGroup,
+    ScalarType,
+    UfuncKey,
+)
+from torchgen.utils import OrderedSet
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ #
+#
+#                                  CUDA STUFF
+#
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ #
+
+# NB: not bothering to generate dispatch stub forward declaration in header,
+# we can just paste it whereever necessary
+
+# TODO: use BackendIndex
+# dispatch_key: DispatchKey  # only CPU/CUDA right now
+
+
+# Represents functors for implementing CUDA ufuncs.
+# Functors are templated by scalar_t because when USERS instantiate functors
+# they are templated.  A functor looks something like this:
+#
+#   template <typename scalar_t>
+#   struct CUDAFunctorOnSelf_add {
+#     using opmath_t = at::opmath_type<scalar_t>;
+#     opmath_t other_;
+#     opmath_t alpha_;
+#     CUDAFunctorOnSelf_add(opmath_t other, opmath_t alpha)
+#         : other_(other), alpha_(alpha) {}
+#     __device__ scalar_t operator()(scalar_t self) {
+#       return ufunc::add(static_cast<opmath_t>(self), other_, alpha_);
+#     }
+#   };
+#
+@dataclass(frozen=True)
+class UfunctorSignature:
+    g: NativeFunctionsGroup
+    scalar_tensor_idx: Optional[int]
+    name: str
+
+    def arguments(self) -> UfunctorBindings:
+        return ufunc.ufunctor_arguments(
+            self.g, scalar_tensor_idx=self.scalar_tensor_idx, scalar_t=scalar_t
+        )
+
+    def fields(self) -> List[Binding]:
+        # fields are renamed to have a trailing underscore, as is conventional
+        return [b.rename(f"{b.name}_") for b in self.arguments().ctor]
+
+    def returns_type(self) -> CType:
+        # TODO: don't hardcode; return type will be inferred based on tags on
+        # the native function
+        return BaseCType(scalar_t)
+
+    def decl_fields(self) -> str:
+        return "\n".join(f"{f.type} {f.name};" for f in self.fields())
+
+    def inline_defn_ctor(self) -> str:
+        args_str = ", ".join(a.decl() for a in self.arguments().ctor)
+        # NB: hypothetically could do this with translate but the
+        # transition here is very regular
+        init_str = ", ".join(f"{a.name}_({a.name})" for a in self.arguments().ctor)
+        return f"{self.name}({args_str}) : {init_str} {{}}"
+
+    def decl_apply(self) -> str:
+        args_str = ", ".join(a.decl() for a in self.arguments().apply)
+        return f"{self.returns_type().cpp_type()} operator()({args_str}) const"
+
+
+@dataclass(frozen=True)
+class UfuncSignature:
+    g: NativeFunctionsGroup
+    name: str
+    compute_t: CType
+
+    def arguments(self) -> List[Binding]:
+        return ufunc.ufunc_arguments(self.g, compute_t=self.compute_t)
+
+    def call(self, ctx: Sequence[Union[Binding, Expr]]) -> str:
+        return f"{self.name}({', '.join(a.expr for a in translate(ctx, self.arguments()))})"
+
+
+# steps:
+#   1. take the functional signature
+#   2. use api.ufunc to convert it to template signature.  this establishes
+#      the type of the template function
+#   3. use api.ufunc (II) to generate a split struct / operator() signature.
+#      this establish context in which we call the template signature
+#
+# StructuredImplSignature context
+#   ~> functor constructor sig
+#
+# Functor constructor context
+#   ~> functor fields sig
+#
+# Functor apply context (functor fields + functor apply sig)
+#   ~> template sig
+#
+
+
+def eligible_for_binary_scalar_specialization(g: NativeFunctionsGroup) -> bool:
+    num_tensors = sum(
+        1 for a in g.functional.func.arguments.flat_non_out if a.type.is_tensor_like()
+    )
+    return num_tensors == 2
+
+
+def compute_ufunc_cuda_functors(
+    g: NativeFunctionsGroup,
+) -> Tuple[Dict[ScalarType, Dict[UfuncKey, UfunctorSignature]], str]:
+    # First, build the functors.
+    ufunctor_sigs: Dict[ScalarType, Dict[UfuncKey, UfunctorSignature]] = {}
+    ufunctors: List[str] = []
+    loops = g.out.ufunc_inner_loop
+    scalar_tensor_idx_lookup = {
+        UfuncKey.CUDAFunctorOnSelf: 1,
+        UfuncKey.CUDAFunctorOnOther: 0,
+        UfuncKey.CUDAFunctor: None,
+    }
+    if eligible_for_binary_scalar_specialization(g):
+        keys = [
+            UfuncKey.CUDAFunctorOnSelf,
+            UfuncKey.CUDAFunctorOnOther,
+            UfuncKey.CUDAFunctor,
+        ]
+    else:
+        keys = [UfuncKey.CUDAFunctor]
+        for k in [UfuncKey.CUDAFunctorOnSelf, UfuncKey.CUDAFunctorOnOther]:
+            assert k not in loops, f"cannot use {k} on non-binary function"
+    for k in keys:
+        # If the key was directly defined, skip functor codegen; we assume the
+        # user already done it for us
+        if k in loops:
+            ufunctor_sig = UfunctorSignature(
+                g, scalar_tensor_idx=scalar_tensor_idx_lookup[k], name=loops[k].name
+            )
+            for dtype in loops[k].supported_dtypes:
+                ufunctor_sigs.setdefault(dtype, {})[k] = ufunctor_sig
+            continue
+
+        # Note [ScalarOnly and Generic must match names for CUDA]
+        # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+        # Otherwise, look in ANY of the generic entries.  For simplicity of
+        # codegen, both ScalarOnly and Generic are defined, the ufunc name
+        # must match  (if they didn't match, we'd have to generate distinct
+        # functors per dtype, which is awful, so we're not going to do it unless
+        # someone really forces us to)
+        ufunc_name = None
+        supported_dtypes: OrderedSet[ScalarType] = OrderedSet()
+        for lk in [UfuncKey.ScalarOnly, UfuncKey.Generic]:
+            if lk not in loops:
+                continue
+            if ufunc_name is None:
+                ufunc_name = loops[lk].name
+            else:
+                # See Note [ScalarOnly and Generic must match names for CUDA]
+                assert (
+                    ufunc_name == loops[lk].name
+                ), "ScalarOnly and Generic must have same ufunc name"
+            supported_dtypes |= loops[lk].supported_dtypes
+        assert ufunc_name is not None
+
+        name = f"{k}_{ufunc_name}"
+        ufunctor_sig = UfunctorSignature(
+            g, scalar_tensor_idx=scalar_tensor_idx_lookup[k], name=name
+        )
+        for dtype in supported_dtypes:
+            ufunctor_sigs.setdefault(dtype, {})[k] = ufunctor_sig
+
+        ufunc_sig = UfuncSignature(
+            g, name=f"ufunc::{ufunc_name}", compute_t=BaseCType(opmath_t)
+        )
+        apply_ctx = ufunctor_sig.fields() + ufunctor_sig.arguments().apply
+        ufunctors.append(
+            f"""
+template <typename scalar_t>
+struct {ufunctor_sig.name} {{
+  using opmath_t = at::opmath_type<scalar_t>;
+  {ufunctor_sig.decl_fields()}
+  {ufunctor_sig.inline_defn_ctor()}
+  __device__ {ufunctor_sig.decl_apply()} {{
+    return {ufunc_sig.call(apply_ctx)};
+  }}
+}};
+"""
+        )
+
+    return ufunctor_sigs, "\n".join(ufunctors)
+
+
+@dataclass(frozen=True)
+class BinaryScalarSpecializationConfig:
+    scalar_idx: int
+    ctor_tensor: str
+    ufunc_key: UfuncKey
+
+
+BinaryScalarSpecializationConfigs = [
+    BinaryScalarSpecializationConfig(
+        scalar_idx=0,
+        ctor_tensor="self",
+        ufunc_key=UfuncKey.CUDAFunctorOnOther,
+    ),
+    BinaryScalarSpecializationConfig(
+        scalar_idx=1,
+        ctor_tensor="other",
+        ufunc_key=UfuncKey.CUDAFunctorOnSelf,
+    ),
+]
+
+
+def compute_ufunc_cuda_dtype_body(
+    g: NativeFunctionsGroup,
+    dtype: ScalarType,
+    inner_loops: Dict[UfuncKey, UfunctorSignature],
+    parent_ctx: Sequence[Binding],
+) -> str:
+    body = "using opmath_t = at::opmath_type<scalar_t>;"
+    body += "if (false) {}\n"  # for ease of codegen
+    for config in BinaryScalarSpecializationConfigs:
+        if config.ufunc_key not in inner_loops:
+            continue
+        ufunctor_sig = inner_loops[config.ufunc_key]
+        scalar_idx = config.scalar_idx + 1
+        # Make a copy and at the same time widen the type (not permissible
+        # without copy; we don't want to mutate the input argument anyway)
+        ctx: List[Union[Expr, Binding]] = list(parent_ctx)
+        ctx.append(
+            Expr(
+                expr=f"iter.scalar_value<opmath_t>({scalar_idx})",
+                type=NamedCType(config.ctor_tensor, BaseCType(opmath_t)),
+            )
+        )
+        ufunctor_ctor_exprs_str = ", ".join(
+            a.expr for a in translate(ctx, ufunctor_sig.arguments().ctor)
+        )
+
+        # NB: ufunctor must be allocated before iter.remove_operand is called,
+        # as it relies on iter
+        body += f"""\
+else if (iter.is_cpu_scalar({scalar_idx})) {{
+  {ufunctor_sig.name}<scalar_t> ufunctor({ufunctor_ctor_exprs_str});
+  iter.remove_operand({scalar_idx});
+  gpu_kernel(iter, ufunctor);
+}}"""
+
+    ufunctor_sig = inner_loops[UfuncKey.CUDAFunctor]
+    ufunctor_ctor_exprs_str = ", ".join(
+        a.expr for a in translate(parent_ctx, ufunctor_sig.arguments().ctor)
+    )
+    body += f"""
+else {{
+  gpu_kernel(iter, {ufunctor_sig.name}<scalar_t>({ufunctor_ctor_exprs_str}));
+}}
+    """
+    return body
+
+
+@with_native_function
+def compute_ufunc_cuda(g: NativeFunctionsGroup) -> str:
+    # First, build the functors, indexing them by dtype
+    ufunctor_sigs, ufunctors = compute_ufunc_cuda_functors(g)
+
+    # Next, build the conditionals
+    sig = StructuredImplSignature(g, ufunc.kernel_name(g, DispatchKey.CUDA))
+    dtype_cases = []
+    for dtype, inner_ufunc_sigs in ufunctor_sigs.items():
+        dtype_cases.append(
+            f"""
+AT_DISPATCH_CASE(at::ScalarType::{dtype},
+  [&]() {{
+    {compute_ufunc_cuda_dtype_body(g, dtype, inner_ufunc_sigs, sig.arguments())}
+  }}
+)
+"""
+        )
+
+    dtype_cases_str = "\n".join(dtype_cases)
+
+    stub_sig = StubSignature(g)
+
+    return f"""
+{ufunctors}
+
+{stub_sig.type_defn()};
+{stub_sig.dispatch_decl()};
+
+{stub_sig.kernel_defn()} {{
+  AT_DISPATCH_SWITCH(iter.common_dtype(), "{sig.name}",
+    {dtype_cases_str}
+  );
+}}
+REGISTER_DISPATCH({stub_sig.name}, &{stub_sig.kernel_name});
+
+{sig.defn()} {{
+  {stub_sig.direct_call(sig.arguments())};
+}}
+"""
+
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ #
+#
+#                                   CPU STUFF
+#
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ #
+
+
+@dataclass(frozen=True)
+class StubSignature:
+    g: NativeFunctionsGroup
+
+    @property
+    def name(self) -> str:
+        return f"{str(self.g.functional.func.name.name)}_stub"
+
+    @property
+    def kernel_name(self) -> str:
+        return f"{str(self.g.functional.func.name.name)}_kernel"
+
+    @property
+    def type_name(self) -> str:
+        return f"{str(self.g.functional.func.name.name)}_fn"
+
+    def arguments(self) -> List[Binding]:
+        return ufunc.stub_arguments(self.g)
+
+    def type(self) -> str:
+        cpp_args = self.arguments()
+        return f"void(*)(TensorIteratorBase&, {', '.join(a.type for a in cpp_args)})"
+
+    def dispatch_decl(self) -> str:
+        return f"DECLARE_DISPATCH({self.type_name}, {self.name})"
+
+    def dispatch_defn(self) -> str:
+        return f"DEFINE_DISPATCH({self.name})"
+
+    def kernel_defn(self) -> str:
+        return f"void {self.kernel_name}(TensorIteratorBase& iter, {', '.join(a.defn() for a in self.arguments())})"
+
+    def type_defn(self) -> str:
+        return f"using {self.type_name} = {self.type()}"
+
+    # must be called from context where this is TensorIteratorBase*
+    def call(self, ctx: Sequence[Binding]) -> str:
+        return f"{self.name}(device_type(), *this, {', '.join(a.expr for a in translate(ctx, self.arguments()))})"
+
+    # used in CUDA to skip the unnecessary dynamic dispatch
+    def direct_call(self, ctx: Sequence[Binding]) -> str:
+        return f"{self.kernel_name}(*this, {', '.join(a.expr for a in translate(ctx, self.arguments()))})"
+
+
+@with_native_function
+def compute_ufunc_cpu(g: NativeFunctionsGroup) -> str:
+    stub_sig = StubSignature(g)
+    sig = StructuredImplSignature(g, ufunc.kernel_name(g, DispatchKey.CPU))
+
+    return f"""
+{stub_sig.type_defn()};
+{stub_sig.dispatch_decl()};
+{stub_sig.dispatch_defn()};
+
+{sig.defn()} {{
+  {stub_sig.call(sig.arguments())};
+}}
+"""
+
+
+def compute_ufunc_cpu_dtype_body(
+    g: NativeFunctionsGroup,
+    dtype: ScalarType,
+    inner_loops: Dict[UfuncKey, UfuncSignature],
+    parent_ctx: Sequence[Binding],
+) -> str:
+    assert UfuncKey.CPUScalar in inner_loops, f"{dtype}, {inner_loops.keys()}"
+    assert inner_loops.keys() <= {UfuncKey.CPUScalar, UfuncKey.CPUVector}
+    scalar_loop = inner_loops[UfuncKey.CPUScalar]
+    vec_loop = None
+    if UfuncKey.CPUVector in inner_loops:
+        vec_loop = inner_loops[UfuncKey.CPUVector]
+
+    # NB: We DON'T use translate here, because translate is
+    # incapable of CSE'ing the scalar accesses in case it is also
+    # used by Vectorized; also, the unpacking here is very simple
+    # and only affects Scalar; everything else is implicitly captured
+    # by the lambda
+
+    # Setup scalar in scope
+    body = []
+    ctx = []
+    for b in parent_ctx:
+        if isinstance(b.argument, Argument) and b.argument.type != BaseType(
+            BaseTy.Scalar
+        ):
+            continue
+        body.append(f"auto _s_{b.name} = {b.name}.to<scalar_t>();")
+        ctx.append(Expr(f"_s_{b.name}", NamedCType(b.nctype.name, BaseCType(scalar_t))))
+    if vec_loop is not None:
+        for b in parent_ctx:
+            if isinstance(b.argument, Argument) and b.argument.type != BaseType(
+                BaseTy.Scalar
+            ):
+                continue
+            body.append(
+                f"auto _v_{b.name} = at::vec::Vectorized<scalar_t>(_s_{b.name});"
+            )
+            ctx.append(
+                Expr(
+                    f"_v_{b.name}",
+                    NamedCType(b.nctype.name, VectorizedCType(BaseCType(scalar_t))),
+                )
+            )
+
+    # Setup lambda signature
+    # NB: simplified version of ufunctor_arguments
+    scalar_bindings = []
+    vec_bindings = []
+    for a in g.functional.func.arguments.flat_non_out:
+        if not a.type.is_tensor_like():
+            continue
+        assert a.type == BaseType(BaseTy.Tensor)
+        scalar_bindings.append(
+            Binding(
+                name=a.name,
+                nctype=NamedCType(a.name, BaseCType(scalar_t)),
+                argument=a,
+            )
+        )
+        if vec_loop is not None:
+            vec_bindings.append(
+                Binding(
+                    name=a.name,
+                    nctype=NamedCType(a.name, VectorizedCType(BaseCType(scalar_t))),
+                    argument=a,
+                )
+            )
+
+    def with_ctx(b: Sequence[Binding]) -> List[Union[Expr, Binding]]:
+        r: List[Union[Expr, Binding]] = []
+        r.extend(ctx)
+        r.extend(b)
+        return r
+
+    body_str = "\n".join(body)
+    if vec_loop is not None:
+        return f"""
+{body_str}
+cpu_kernel_vec(iter,
+  [=]({', '.join(b.decl() for b in scalar_bindings)}) {{ return {scalar_loop.call(with_ctx(scalar_bindings))}; }},
+  [=]({', '.join(b.decl() for b in vec_bindings)}) {{ return {vec_loop.call(with_ctx(vec_bindings))}; }}
+);
+"""
+    else:
+        return f"""
+{body_str}
+cpu_kernel(iter,
+  [=]({', '.join(b.decl() for b in scalar_bindings)}) {{ return {scalar_loop.call(with_ctx(scalar_bindings))}; }}
+);
+"""
+
+
+@with_native_function
+def compute_ufunc_cpu_kernel(g: NativeFunctionsGroup) -> str:
+    stub_sig = StubSignature(g)
+
+    # Reindex the ufunc by dtypes; processing generic/scalaronly as well
+    loops = g.out.ufunc_inner_loop
+    ufunc_sigs: Dict[ScalarType, Dict[UfuncKey, UfuncSignature]] = {}
+    for k in [UfuncKey.CPUScalar, UfuncKey.CPUVector]:
+        lks = []
+        # ORDER MATTERS: this specifies overriding precedence
+        if k in loops:  # should happen rarely
+            lks.append(k)
+        if UfuncKey.ScalarOnly in loops and k is UfuncKey.CPUScalar:
+            lks.append(UfuncKey.ScalarOnly)
+        if UfuncKey.Generic in loops:
+            lks.append(UfuncKey.Generic)
+        # TODO: don't hardcode ufunc:: namespace here, should be centralized smh
+        for lk in lks:
+            for dtype in loops[lk].supported_dtypes:
+                compute_t: CType
+                if k is UfuncKey.CPUScalar:
+                    compute_t = BaseCType(scalar_t)
+                elif k is UfuncKey.CPUVector:
+                    compute_t = VectorizedCType(BaseCType(scalar_t))
+                else:
+                    raise AssertionError()
+                inner_ufunc_sigs = ufunc_sigs.setdefault(dtype, {})
+                if k not in inner_ufunc_sigs:
+                    inner_ufunc_sigs[k] = UfuncSignature(
+                        g, name=f"ufunc::{loops[lk].name}", compute_t=compute_t
+                    )
+
+    # Build the conditionals
+    dtype_cases = []
+    for dtype, inner_ufunc_sigs in ufunc_sigs.items():
+        dtype_cases.append(
+            f"""
+AT_DISPATCH_CASE(at::ScalarType::{dtype},
+  [&]() {{
+    {compute_ufunc_cpu_dtype_body(g, dtype, inner_ufunc_sigs, stub_sig.arguments())}
+  }}
+)
+"""
+        )
+
+    dtype_cases_str = "\n".join(dtype_cases)
+    return f"""
+namespace {{
+
+{stub_sig.kernel_defn()} {{
+  AT_DISPATCH_SWITCH(iter.common_dtype(), "{stub_sig.name}",
+    {dtype_cases_str}
+  );
+}}
+
+}} // anonymous namespace
+
+{stub_sig.type_defn()};
+{stub_sig.dispatch_decl()};
+REGISTER_DISPATCH({stub_sig.name}, &{stub_sig.kernel_name});
+"""

wemm/lib/python3.10/site-packages/torchgen/gen_executorch.py

@@ -0,0 +1,779 @@
+import argparse
+import os
+import pathlib
+from collections import defaultdict
+from dataclasses import dataclass
+from typing import Callable, Dict, List, Optional, Sequence, TextIO, Tuple, Union
+
+import yaml
+
+# Parse native_functions.yaml into a sequence of NativeFunctions and Backend Indices.
+from torchgen import dest
+from torchgen.api import cpp as aten_cpp
+from torchgen.api.types import CppSignature, CppSignatureGroup, CType, NamedCType
+from torchgen.context import method_with_native_function, with_native_function_and_index
+from torchgen.executorch.api import et_cpp
+from torchgen.executorch.api.custom_ops import (
+    ComputeNativeFunctionStub,
+    gen_custom_ops_registration,
+)
+from torchgen.executorch.api.types import ExecutorchCppSignature
+from torchgen.executorch.api.unboxing import Unboxing
+from torchgen.gen import (
+    get_custom_build_selector,
+    get_native_function_declarations,
+    get_native_function_schema_registrations,
+    LineLoader,
+    parse_native_yaml,
+    ParsedYaml,
+)
+from torchgen.model import (
+    BackendIndex,
+    BackendMetadata,
+    DispatchKey,
+    is_cuda_dispatch_key,
+    Location,
+    NativeFunction,
+    NativeFunctionsGroup,
+    OperatorName,
+    Variant,
+)
+from torchgen.selective_build.selector import SelectiveBuilder
+from torchgen.utils import (
+    context,
+    FileManager,
+    make_file_manager,
+    mapMaybe,
+    NamespaceHelper,
+)
+
+
+def static_dispatch(
+    sig: Union[CppSignature, ExecutorchCppSignature],
+    f: NativeFunction,
+    backend_indices: List[BackendIndex],
+) -> str:
+    """
+    For a given `NativeFunction`, find out the corresponding native function and dispatch to it. If zero or more than one
+    native function exists, error out. A simplified version of register_dispatch_key.py
+    Arguments:
+        sig: A CppSignature for this native function we want to use.
+        f: NativeFunction to generate static dispatch.
+        backend_indices: All available backends.
+    Return:
+        C++ code to call backend-specific functions, e.g., "return at::native::add(self, other, scale);"
+    """
+    if len(backend_indices) == 0 or f.manual_kernel_registration:
+        return ""
+
+    backends = [b for b in backend_indices if b.has_kernel(f)]
+    static_block = None
+    if len(backends) == 1:
+        backend_metadata = backends[0].get_kernel(f)
+        if backend_metadata:
+            args = ", ".join(a.name for a in sig.arguments())
+            # Here we are assuming there's no difference between CppSignature and NativeSignature for Executorch.
+            static_block = f"return ::{backend_metadata.cpp_namespace}::{backend_metadata.kernel}({args});"
+    else:
+        static_block = f"""
+ET_ASSERT_UNREACHABLE_MSG("The number of native function(s) binding to {f.func.name} is {len(backends)}.");
+    """
+    return f"""
+// {f.namespace}::{f.func}
+TORCH_API inline {sig.decl()} {{
+    {static_block}
+}}
+"""
+
+
+# Generates Functions.h, which provides the functional public C++ API,
+# and the scaffolding to call into the dispatcher from these functions.
+@dataclass(frozen=True)
+class ComputeFunction:
+    static_dispatch_backend_indices: List[BackendIndex]
+
+    selector: SelectiveBuilder
+
+    use_aten_lib: bool
+
+    is_custom_op: Callable[[NativeFunction], bool]
+
+    @method_with_native_function
+    def __call__(self, f: NativeFunction) -> Optional[str]:
+        if not self.selector.is_root_operator(f"{f.namespace}::{f.func.name}"):
+            return None
+        if Variant.function not in f.variants:
+            return None
+        sig: Union[CppSignature, ExecutorchCppSignature] = (
+            CppSignatureGroup.from_native_function(
+                f, method=False, fallback_binding=f.manual_cpp_binding
+            ).most_faithful_signature()
+            if self.use_aten_lib
+            else ExecutorchCppSignature.from_native_function(f)
+        )
+        if self.use_aten_lib and not self.is_custom_op(f):
+            comma = ", "
+
+            return f"""
+// {f.namespace}::{f.func}
+TORCH_API inline {sig.decl()} {{
+    return at::{sig.name()}({comma.join(e.name for e in sig.arguments())});
+}}
+            """
+
+        else:
+            return static_dispatch(
+                sig,
+                f,
+                backend_indices=self.static_dispatch_backend_indices,
+            )
+
+
+# Generates RegisterCodegenUnboxedKernels.cpp.
+@dataclass(frozen=True)
+class ComputeCodegenUnboxedKernels:
+    selector: SelectiveBuilder
+
+    use_aten_lib: bool
+
+    @method_with_native_function
+    def __call__(self, f: NativeFunction) -> str:
+        if not self.selector.is_root_operator(f"{f.namespace}::{f.func.name}"):
+            return ""
+        sig: Union[CppSignature, ExecutorchCppSignature]
+        argument_type_gen: Callable[..., NamedCType]
+        return_type_gen: Callable[..., CType]
+        if self.use_aten_lib:
+            sig = CppSignatureGroup.from_native_function(
+                f, method=False, fallback_binding=f.manual_cpp_binding
+            ).most_faithful_signature()
+            argument_type_gen = aten_cpp.argumenttype_type
+            return_type_gen = aten_cpp.returns_type
+        else:
+            sig = ExecutorchCppSignature.from_native_function(f)
+            argument_type_gen = et_cpp.argumenttype_type
+            return_type_gen = et_cpp.returns_type
+        # parse arguments into C++ code
+        binding_list, code_list = Unboxing(
+            argument_type_gen=argument_type_gen
+        ).convert_arguments(sig.arguments())
+
+        # for each C++ argument, generate the conversion code
+        code_connector = "\n\t"
+        arg_connector = ", "
+
+        args_str = f"{arg_connector.join(e.name for e in binding_list)}"
+
+        if len(f.func.returns) == 0:
+            if len(f.func.arguments.out) == 0:
+                raise Exception(
+                    f"Can't handle native function {f.func} with no returns and no out yet."
+                )
+            out = f.func.arguments.out[0]
+            return_assignment = f"""stack[{len(binding_list)}] = &{out.name};"""
+            ret_prefix = ""
+        else:
+            if len(f.func.arguments.out) == 0:
+                return_assignment = (
+                    f"""*stack[{len(binding_list)}] = EValue(result_);"""
+                )
+                ret_prefix = return_type_gen(f.func.returns).cpp_type() + " result_ = "
+            else:
+                return_assignment = ""
+                ret_prefix = ""
+
+        return f"""
+Operator(
+    "{f.namespace}::{f.func.name}",
+    [](EValue** stack) {{
+        {code_connector.join(code_list)}
+
+        EXECUTORCH_SCOPE_PROF("native_call_{f.func.name}");
+        {ret_prefix}torch::executor::{f.namespace}::{sig.name()}({args_str});
+
+        {return_assignment}
+    }}
+),
+"""
+
+
+def gen_unboxing(
+    *,
+    native_functions: Sequence[NativeFunction],
+    cpu_fm: FileManager,
+    selector: SelectiveBuilder,
+    use_aten_lib: bool,
+) -> None:
+    def key_func(fn: Union[NativeFunction, NativeFunctionsGroup]) -> str:
+        return fn.root_name
+
+    cpu_fm.write_sharded(
+        "RegisterCodegenUnboxedKernels.cpp",
+        native_functions,
+        key_fn=key_func,
+        env_callable=lambda fn: {
+            "unboxed_ops": [ComputeCodegenUnboxedKernels(selector, use_aten_lib)(fn)],
+        },
+        num_shards=1,
+        sharded_keys={"unboxed_ops"},
+    )
+
+
+@with_native_function_and_index
+def compute_native_function_declaration(
+    g: Union[NativeFunctionsGroup, NativeFunction], backend_index: BackendIndex
+) -> List[str]:
+    assert isinstance(g, NativeFunction)
+    sig = ExecutorchCppSignature.from_native_function(f=g)
+    metadata = backend_index.get_kernel(g)
+    if metadata is None:
+        return []
+    prefix = "static" if backend_index.external else "TORCH_API"
+    return [f"{prefix} {sig.decl(name=metadata.kernel)};"]
+
+
+def gen_functions_declarations(
+    *,
+    native_functions: Sequence[NativeFunction],
+    static_dispatch_idx: List[BackendIndex],
+    selector: SelectiveBuilder,
+    use_aten_lib: bool,
+    custom_ops_native_functions: Optional[Sequence[NativeFunction]] = None,
+) -> str:
+    """
+    Generates namespace separated C++ function API inline declaration/definitions.
+    Native functions are grouped by namespaces and the generated code is wrapped inside
+    namespace blocks.
+
+    E.g., for `custom_1::foo.out` in yaml file we will generate a C++ API as a symbol
+    in `torch::executor::custom_1::foo_out`. This way we avoid symbol conflict when
+    the other `custom_2::foo.out` is available.
+    """
+    ns_grouped_functions = defaultdict(list)
+    for native_function in native_functions:
+        ns_grouped_functions[native_function.namespace].append(native_function)
+    functions_declarations = ""
+    newline = "\n"
+    for namespace in ns_grouped_functions:
+        ns_helper = NamespaceHelper(
+            namespace_str=namespace,
+            entity_name="",
+            max_level=3,
+        )
+        declarations = list(
+            mapMaybe(
+                ComputeFunction(
+                    static_dispatch_backend_indices=static_dispatch_idx,
+                    selector=selector,
+                    use_aten_lib=use_aten_lib,
+                    is_custom_op=lambda f: custom_ops_native_functions is not None
+                    and f in custom_ops_native_functions,
+                ),
+                ns_grouped_functions[namespace],
+            )
+        )
+        functions_declarations += f"""
+{ns_helper.prologue}
+{newline.join(declarations)}
+{ns_helper.epilogue}
+        """
+    return functions_declarations
+
+
+def gen_headers(
+    *,
+    native_functions: Sequence[NativeFunction],
+    custom_ops_native_functions: Sequence[NativeFunction],
+    static_dispatch_idx: List[BackendIndex],
+    selector: SelectiveBuilder,
+    backend_indices: Dict[DispatchKey, BackendIndex],
+    cpu_fm: FileManager,
+    use_aten_lib: bool,
+) -> None:
+    aten_headers = ["#include <ATen/Functions.h>"]
+    if custom_ops_native_functions:
+        cpu_fm.write_with_template(
+            "CustomOpsNativeFunctions.h",
+            "NativeFunctions.h",
+            lambda: {
+                "nativeFunctions_declarations": get_native_function_declarations(
+                    grouped_native_functions=custom_ops_native_functions,
+                    backend_indices=backend_indices,
+                    native_function_decl_gen=dest.compute_native_function_declaration,
+                ),
+            },
+        )
+        aten_headers.append('#include "CustomOpsNativeFunctions.h"')
+    cpu_fm.write(
+        "Functions.h",
+        lambda: {
+            "static_dispatch_extra_headers": aten_headers
+            if use_aten_lib
+            else ['#include "NativeFunctions.h"'],
+            "Functions_declarations": gen_functions_declarations(
+                native_functions=native_functions,
+                static_dispatch_idx=static_dispatch_idx,
+                selector=selector,
+                use_aten_lib=use_aten_lib,
+                custom_ops_native_functions=custom_ops_native_functions,
+            ),
+        },
+    )
+
+    cpu_fm.write(
+        "NativeFunctions.h",
+        lambda: {
+            "nativeFunctions_declarations": get_native_function_declarations(
+                grouped_native_functions=native_functions,
+                backend_indices=backend_indices,
+                native_function_decl_gen=dest.compute_native_function_declaration
+                if use_aten_lib
+                else compute_native_function_declaration,
+            ),
+        },
+    )
+
+
+def gen_custom_ops(
+    *,
+    native_functions: Sequence[NativeFunction],
+    selector: SelectiveBuilder,
+    backend_indices: Dict[DispatchKey, BackendIndex],
+    cpu_fm: FileManager,
+    rocm: bool,
+) -> None:
+    dispatch_key = DispatchKey.CPU
+    backend_index = backend_indices[dispatch_key]
+    (
+        anonymous_definition,
+        static_init_dispatch_registrations,
+    ) = gen_custom_ops_registration(
+        native_functions=native_functions,
+        selector=selector,
+        backend_index=backend_index,
+        rocm=rocm,
+    )
+    cpu_fm.write_with_template(
+        f"Register{dispatch_key}CustomOps.cpp",
+        "RegisterDispatchKeyCustomOps.cpp",
+        lambda: {
+            "ops_headers": '#include "CustomOpsNativeFunctions.h"',
+            "DispatchKey": dispatch_key,
+            "dispatch_namespace": dispatch_key.lower(),
+            "dispatch_namespaced_definitions": "",
+            "dispatch_anonymous_definitions": anonymous_definition,
+            "static_init_dispatch_registrations": static_init_dispatch_registrations,
+        },
+    )
+    cpu_fm.write_with_template(
+        f"Register{dispatch_key}Stub.cpp",
+        "RegisterDispatchKeyCustomOps.cpp",
+        lambda: {
+            "ops_headers": "",
+            "DispatchKey": dispatch_key,
+            "dispatch_namespace": dispatch_key.lower(),
+            "dispatch_namespaced_definitions": "",
+            "dispatch_anonymous_definitions": list(
+                mapMaybe(ComputeNativeFunctionStub(), native_functions)
+            ),
+            "static_init_dispatch_registrations": static_init_dispatch_registrations,
+        },
+    )
+
+    (
+        aten_schema_registrations,
+        schema_registrations,
+    ) = get_native_function_schema_registrations(
+        native_functions=native_functions,
+        schema_selector=selector,
+    )
+    cpu_fm.write(
+        "RegisterSchema.cpp",
+        lambda: {
+            "schema_registrations": schema_registrations,
+            "aten_schema_registrations": aten_schema_registrations,
+        },
+    )
+
+
+def translate_native_yaml(
+    tags_yaml_path: str,
+    aten_yaml_path: str,
+    native_yaml_path: Optional[str],
+    use_aten_lib: bool,
+    out_file: TextIO,
+) -> None:
+    """Translates Executorch DSL dialect to use the same syntax as
+    native_functions.yaml. The major difference is that Executorch DSL dialect
+    supports "op" key, where it refers to the operator name in native_functions.yaml.
+
+    For example, a functions.yaml may have the following entry:
+
+    - op: add.out
+      ...
+
+    It needs to be translated to the following:
+
+    - func: add.out(Tensor self, Tensor other, *, Scalar alpha=1, Tensor(a!) out) -> Tensor(a!)
+      ...
+
+    We go in aten_yaml_path and find the operator schema for "add.out" and add it
+    to the original functions.yaml. We also add required field "variants", where for
+    Executorch it will always be "function".
+
+    For ATen mode we don't have to do the translation because native_yaml_path is
+    the same as native_functions.yaml.
+
+    Args:
+        tags_yaml_path: Path to a tags.yaml file to satisfy codegen parsing.
+            It is not optional.
+        aten_yaml_path: Path to ATen operator yaml file native_functions.yaml.
+        native_yaml_path: Path to a functions.yaml file to parse.
+            If the path does not exist in the filesystem, it is treated as an
+            empty file. If `custom_ops_yaml_path` exists, the contents of that
+            file are appended to the yaml input to be parsed.
+        use_aten_lib: We use this flag to determine if we want to generate native
+            functions. In ATen mode we should generate out= variants.
+        out_file: The IO object that we are writing into.
+    Returns:
+        None
+    """
+    if use_aten_lib:
+        with open(aten_yaml_path, "r") as aten_yaml:
+            out_file.writelines(aten_yaml.readlines())
+        return
+    aten_parsed_yaml = parse_native_yaml(
+        aten_yaml_path,
+        tags_yaml_path,
+        None,
+        skip_native_fns_gen=False,
+    )
+    aten_native_functions = aten_parsed_yaml.native_functions
+    schema_dict = {
+        f"{f.namespace}::{f.func.name}": str(f.func) for f in aten_native_functions
+    }
+    if (
+        not native_yaml_path
+        or not os.path.exists(native_yaml_path)
+        or os.stat(native_yaml_path).st_size == 0
+    ):
+        return
+    with open(native_yaml_path, "r") as native_yaml:
+        native_es = yaml.load(native_yaml, Loader=LineLoader)
+        if not native_es:
+            return
+        for e in native_es:
+            assert isinstance(e.get("__line__"), int), e
+            loc = Location(native_yaml_path, e.pop("__line__"))
+            with context(lambda: f"in {loc}:\n  "):
+                if "variants" not in e:
+                    e["variants"] = "function"
+                if "func" in e:
+                    continue
+                assert isinstance(e.get("op"), str), e
+                opname = e.pop("op")
+                if "::" not in opname:
+                    opname = "aten::" + opname
+                assert opname in schema_dict
+                e["func"] = schema_dict.get(opname)
+        yaml.dump(native_es, out_file, width=1000)
+
+
+def convert_backend_indices(
+    bs: Dict[DispatchKey, Dict[OperatorName, BackendMetadata]]
+) -> Dict[DispatchKey, BackendIndex]:
+    indices: Dict[DispatchKey, BackendIndex] = defaultdict(
+        lambda: BackendIndex(
+            dispatch_key=DispatchKey.Undefined,
+            use_out_as_primary=True,
+            external=False,
+            device_guard=False,
+            index={},
+        )
+    )
+    for k, v in bs.items():
+        indices[k] = BackendIndex(
+            dispatch_key=k,
+            use_out_as_primary=True,
+            external=False,
+            # Only cuda-like devices in tree require device guards
+            device_guard=is_cuda_dispatch_key(k),
+            index=v,
+        )
+    return indices
+
+
+def parse_yaml(
+    path: Optional[str],
+    tags_yaml_path: str,
+    function_filter: Callable[[NativeFunction], bool],
+    skip_native_fns_gen: bool = False,
+) -> Tuple[
+    List[NativeFunction], Dict[DispatchKey, Dict[OperatorName, BackendMetadata]]
+]:
+    if path and os.path.exists(path) and os.stat(path).st_size > 0:
+        parsed_yaml = parse_native_yaml(
+            path,
+            tags_yaml_path,
+            None,
+            skip_native_fns_gen=skip_native_fns_gen,
+        )
+        native_functions = list(filter(function_filter, parsed_yaml.native_functions))
+        op_names = [f.func.name for f in native_functions]
+
+        def map_index(
+            m: Dict[OperatorName, BackendMetadata]
+        ) -> Dict[OperatorName, BackendMetadata]:
+            return {op: m[op] for op in m if op in op_names}
+
+        backend_indices = {
+            k: map_index(b.index) for (k, b) in parsed_yaml.backend_indices.items()
+        }
+        return native_functions, backend_indices
+    else:
+        return [], {}
+
+
+def parse_yaml_files(
+    tags_yaml_path: str,
+    aten_yaml_path: str,
+    native_yaml_path: Optional[str],
+    custom_ops_yaml_path: Optional[str],
+    selector: SelectiveBuilder,
+    use_aten_lib: bool,
+) -> Tuple[ParsedYaml, Optional[ParsedYaml]]:
+    """Parses functions.yaml and custom_ops.yaml files.
+
+    Args:
+        tags_yaml_path: Path to a tags.yaml file to satisfy codegen parsing.
+            It is not optional.
+        aten_yaml_path: Path to ATen operator yaml file native_functions.yaml.
+        native_yaml_path: Path to a functions.yaml file to parse.
+            If the path does not exist in the filesystem, it is treated as an
+            empty file. If `custom_ops_yaml_path` exists, the contents of that
+            file are appended to the yaml input to be parsed.
+        custom_ops_yaml_path: Path to a custom_ops.yaml file to parse. If
+            the path does not exist in the filesystem, it is ignored.
+        selector: For selective build.
+        use_aten_lib: We use this flag to determine if we want to generate native
+            functions. In ATen mode we should generate out= variants.
+    Returns:
+        A tuple with two elements:
+        [0]: The parsed results of concatenating the contents of
+             `native_yaml_path` and `custom_ops_yaml_path`.
+        [1]: The parsed results of the contents of `custom_ops_yaml_path`, if
+             present. If not present, None.
+    """
+    import tempfile
+
+    # only include selected ops, this is because we want to avoid
+    def function_filter(f: NativeFunction) -> bool:
+        return selector.is_native_function_selected(f)
+
+    with tempfile.TemporaryDirectory() as tmpdirname:
+        translated_yaml_path = os.path.join(tmpdirname, "translated.yaml")
+        with open(translated_yaml_path, "w") as translated:
+            translate_native_yaml(
+                tags_yaml_path,
+                aten_yaml_path,
+                native_yaml_path,
+                use_aten_lib,
+                translated,
+            )
+        translated_functions, translated_backend_indices = parse_yaml(
+            translated_yaml_path, tags_yaml_path, function_filter, not use_aten_lib
+        )
+        custom_ops_functions, custom_ops_backend_indices = parse_yaml(
+            custom_ops_yaml_path, tags_yaml_path, function_filter, True
+        )
+
+        combined_functions = translated_functions + custom_ops_functions
+        combined_backend_indices: Dict[
+            DispatchKey, Dict[OperatorName, BackendMetadata]
+        ] = defaultdict(dict)
+        combined_backend_indices.update(translated_backend_indices)
+
+        for dk in custom_ops_backend_indices:
+            if dk not in combined_backend_indices:
+                combined_backend_indices.update({dk: custom_ops_backend_indices[dk]})
+            else:
+                combined_backend_indices[dk] = {
+                    **combined_backend_indices[dk],
+                    **custom_ops_backend_indices[dk],
+                }
+
+        combined_yaml = ParsedYaml(
+            combined_functions, convert_backend_indices(combined_backend_indices)
+        )
+        custom_ops_parsed_yaml = ParsedYaml(
+            custom_ops_functions, convert_backend_indices(custom_ops_backend_indices)
+        )
+    return combined_yaml, custom_ops_parsed_yaml
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Generate operator source files")
+    # Although we don't refer to --source-path directly, make_file_manager()
+    # expects it to point to a directory that contains a templates/ subdirectory
+    # containing the file templates.
+    parser.add_argument(
+        "-s",
+        "--source-path",
+        help="path to source directory for kernel templates",
+    )
+    parser.add_argument(
+        "--functions-yaml-path",
+        "--functions_yaml_path",
+        help="path to the functions.yaml file to use. Optional, but at least "
+        "one of --functions-yaml-path and --custom-ops-yaml-path must be "
+        "specified.",
+    )
+    parser.add_argument(
+        "--custom-ops-yaml-path",
+        "--custom_ops_yaml_path",
+        help="path to the custom_ops.yaml file to use. Optional, but at least "
+        "one of --functions-yaml-path and --custom-ops-yaml-path must be "
+        "specified.",
+    )
+    parser.add_argument(
+        "--aten-yaml-path",
+        "--aten_yaml_path",
+        help="path to native_functions.yaml file.",
+    )
+    # Note that make_file_manager() also looks at --install-dir.
+    parser.add_argument(
+        "-d",
+        "--install-dir",
+        "--install_dir",
+        help="output directory",
+        default="build/generated",
+    )
+    parser.add_argument(
+        "-o",
+        "--output-dependencies",
+        help="output a list of dependencies into the given file and exit",
+    )
+    # Although we don't refer to --dry-run directly, make_file_manager() looks
+    # for it.
+    parser.add_argument(
+        "--dry-run",
+        action="store_true",
+        help="run without writing any files (still updates outputs)",
+    )
+    parser.add_argument(
+        "--static-dispatch-backend",
+        "--static_dispatch_backend",
+        nargs="*",
+        help="generate static dispatch code for the specific backend (if set)",
+    )
+    parser.add_argument(
+        "--op-registration-whitelist",
+        "--op_registration_whitelist",
+        nargs="*",
+        help="filter op registrations by the whitelist (if set); "
+        "each item is `namespace`::`operator name` without overload name; "
+        "e.g.: aten::empty aten::conv2d ...",
+    )
+    parser.add_argument(
+        "--op-selection-yaml-path",
+        "--op_selection_yaml_path",
+        help="Provide a path to the operator selection (for custom build) YAML "
+        "that contains the information about the set of selected operators "
+        "and their categories (training, ...). Each operator is either a "
+        "full operator name with overload or just a bare operator name. "
+        "The operator names also contain the namespace prefix (e.g. aten::)",
+    )
+    parser.add_argument(
+        "--tags-path",
+        help="Path to tags.yaml. Required by yaml parsing in codegen system.",
+    )
+    parser.add_argument(
+        "--rocm",
+        action="store_true",
+        help="reinterpret CUDA as ROCm/HIP and adjust filepaths accordingly",
+    )
+    parser.add_argument(
+        "--use-aten-lib",
+        "--use_aten_lib",
+        action="store_true",
+        help="a boolean flag to indicate whether we use ATen kernels or not, in the future this flag will be per "
+        "operator",
+    )
+    parser.add_argument(
+        "--generate",
+        type=str,
+        nargs="*",
+        choices=["headers", "sources"],
+        default=["headers", "sources"],
+        help="Generate only a subset of files",
+    )
+    options = parser.parse_args()
+    assert options.tags_path, "tags.yaml is required by codegen yaml parsing."
+
+    selector = get_custom_build_selector(
+        options.op_registration_whitelist,
+        options.op_selection_yaml_path,
+    )
+
+    parsed_yaml, custom_ops_parsed_yaml = parse_yaml_files(
+        aten_yaml_path=options.aten_yaml_path,
+        tags_yaml_path=options.tags_path,
+        native_yaml_path=options.functions_yaml_path,
+        custom_ops_yaml_path=options.custom_ops_yaml_path,
+        selector=selector,
+        use_aten_lib=options.use_aten_lib,
+    )
+    native_functions, backend_indices = (
+        parsed_yaml.native_functions,
+        parsed_yaml.backend_indices,
+    )
+    custom_ops_native_functions = (
+        custom_ops_parsed_yaml.native_functions if custom_ops_parsed_yaml else []
+    )
+
+    cpu_fm = make_file_manager(options=options)
+
+    static_dispatch_idx: List[BackendIndex] = [backend_indices[DispatchKey.CPU]]
+
+    if "headers" in options.generate:
+        gen_headers(
+            native_functions=native_functions,
+            custom_ops_native_functions=custom_ops_native_functions,
+            static_dispatch_idx=static_dispatch_idx,
+            selector=selector,
+            backend_indices=backend_indices,
+            cpu_fm=cpu_fm,
+            use_aten_lib=options.use_aten_lib,
+        )
+
+    if "sources" in options.generate:
+        gen_unboxing(
+            native_functions=native_functions,
+            cpu_fm=cpu_fm,
+            selector=selector,
+            use_aten_lib=options.use_aten_lib,
+        )
+        if custom_ops_native_functions:
+            gen_custom_ops(
+                native_functions=custom_ops_native_functions,
+                selector=selector,
+                backend_indices=backend_indices,
+                cpu_fm=cpu_fm,
+                rocm=options.rocm,
+            )
+
+    if options.output_dependencies:
+        depfile_path = pathlib.Path(options.output_dependencies).resolve()
+        depfile_name = depfile_path.name
+        depfile_stem = depfile_path.stem
+
+        for fm, prefix in [
+            (cpu_fm, ""),
+        ]:
+            varname = prefix + depfile_stem
+            path = depfile_path.parent / (prefix + depfile_name)
+            fm.write_outputs(varname, str(path))
+
+
+if __name__ == "__main__":
+    main()

wemm/lib/python3.10/site-packages/torchgen/packaged/ATen/native/tags.yaml

@@ -0,0 +1,47 @@
+# This yaml file contains all the possible tags that can be defined in `tags` in `native_functions.yaml`
+
+- tag: inplace_view
+  desc: |
+          This tag indicates if an operator *only* modifies the tensor metadata
+- tag: view_copy
+  desc: |
+          This tag indicates operators that are *_copy* variants
+          of view/aliasing operators. If an operator has a view_copy tag,
+          then it should have the name {op}_copy, where {op} is a view operator.
+- tag: dynamic_output_shape
+  desc: |
+          This tag indicates if an operator's output's shape depends on input Tensor
+          data.
+- tag: data_dependent_output
+  desc: |
+          Operator has a non-Tensor output whose value is dependent on the data
+          of Tensor inputs.  Among other things, this implies that this operator
+          cannot be run with meta tensor (since data is not available), nor
+          can it be symbolically traced.
+- tag: generated
+  desc: |
+          This tag indicates that the operator doesn't have an explicit entry in
+          native_functions.yaml, and instead was generated automatically by the codegen.
+- tag: nondeterministic_seeded
+  desc: |
+          This tag indicates if an operator is nondeterminstically seeded (ie is random)
+          such that the operator intentionally produces different results when run twice on the same inputs.
+- tag: nondeterministic_bitwise
+  desc: |
+          This tag indicates if an operator doesn't guarentee bitwise equivalence
+          across different runs of an operator with identical inputs.
+- tag: core
+  desc: |
+          Core aten ops is a subset of aten ops that remains after aten-to-aten decomposition and
+          functionalization pass. Core aten ops are fully functional and adhere to single static
+          assignment (SSA): this implies there will be no `inplace` or `_out` variants in this opset.
+          This opset is designed to serve as the functional IR to interface with compiler backends.
+          In contrast to primTorch, core aten opset doesn't decompose ops into explicit
+          type promotion and broadcasting ops.
+          Core aten ops is also effectively the opset produced by torchdynamo.export(aten_graph=True),
+          and thus can be used as an opset for export purpose.
+- tag: pointwise
+  desc: |
+          Pointwise operators are operators where each element of the output is computed only by accessing
+          the corresponding element of all the broadcasted inputs. The output shape will be the broadcasted
+          shape of the inputs.

wemm/lib/python3.10/site-packages/torchgen/packaged/ATen/templates/DispatchKeyFunction.h

@@ -0,0 +1,23 @@
+#pragma once
+// ${generated_comment}
+
+// NB: The implementing C++ file is RegisterDispatchKey.cpp
+
+// The only #includes we need are for custom classes that have defaults in the C++ API
+#include <c10/core/MemoryFormat.h>
+#include <c10/core/Scalar.h>
+#include <ATen/core/Reduction.h>
+
+// Forward declarations of any types needed in the operator signatures.
+// We can't directly include these classes because it will cause circular include dependencies.
+// This file is included by TensorBody.h, which defines the Tensor class.
+#include <ATen/core/ATen_fwd.h>
+
+namespace at {
+
+namespace ${dispatch_namespace} {
+
+${dispatch_namespaced_declarations}
+
+} // namespace ${dispatch_namespace}
+} // namespace at

wemm/lib/python3.10/site-packages/torchgen/packaged/ATen/templates/NativeFunction.h

@@ -0,0 +1,17 @@
+#pragma once
+
+// ${generated_comment}
+
+#include <c10/core/Scalar.h>
+#include <c10/core/Storage.h>
+#include <c10/core/TensorOptions.h>
+#include <c10/util/Deprecated.h>
+#include <c10/util/Optional.h>
+#include <c10/core/QScheme.h>
+#include <ATen/core/Reduction.h>
+#include <ATen/core/Tensor.h>
+#include <tuple>
+#include <vector>
+${extra_includes}
+
+${native_function_declarations}

wemm/lib/python3.10/site-packages/torchgen/packaged/ATen/templates/NativeMetaFunctions.h

@@ -0,0 +1,19 @@
+#pragma once
+
+// ${generated_comment}
+
+#include <ATen/core/Tensor.h>
+#include <ATen/core/IListRef.h>
+#include <ATen/TensorMeta.h>
+#include <ATen/TensorIterator.h>
+
+${NativeMetaFunctions_includes}
+
+namespace at {
+
+namespace meta {
+
+${NativeMetaFunctions_declarations}
+
+} // namespace meta
+} // namespace at

wemm/lib/python3.10/site-packages/torchgen/packaged/ATen/templates/Operators.h

@@ -0,0 +1,74 @@
+#pragma once
+
+// ${generated_comment}
+
+#ifdef TORCH_ASSERT_NO_OPERATORS
+#error This change adds a dependency on native_functions.yaml,             \
+  meaning the file will need to be re-compiled every time an operator      \
+  is changed or added. Consider if your change would be better placed in   \
+  another file, or if a more specific header might achieve the same goal.  \
+  See NOTE: [Tensor vs. TensorBase]
+#endif
+
+#if defined(AT_PER_OPERATOR_HEADERS) && defined(TORCH_ASSERT_ONLY_METHOD_OPERATORS)
+#error This change adds a dependency on all pytorch operators, meaning the     \
+  file will need to be re-compiled every time an operator is changed or added. \
+  Consider including a specific operator from <ATen/ops/{my_operator}_ops.h>   \
+  and see NOTE [TORCH_ASSERT_ONLY_METHOD_OPERATORS].
+#endif
+
+#include <c10/core/SymInt.h>
+#include <c10/core/SymIntArrayRef.h>
+#include <c10/core/Scalar.h>
+#include <c10/core/TensorOptions.h>
+#include <c10/core/QScheme.h>
+#include <c10/util/OptionalArrayRef.h>
+#include <tuple>
+#include <vector>
+
+${Operators_includes}
+
+// Extension writers: do you write wrapper functions? Are you frustrated with
+// resolving overloads of operators? Are you frustrated with dealing with
+// pointer-to-methods and resolving overloads of pointer-to-methods?? Look no
+// further, this is the utility for you.
+//
+// Given an operator schema: aten::op.overload(...
+//
+// Use ATEN_FN2(op, overload) to get a *function* version of the operator
+// that is guaranteed to not be overloaded. This means that you can safely
+// decltype(&ATEN_FN2(op, overload)) it. NB: the 2 means this macro takes 2 args.
+//
+// Given an operator schema without an overload name: aten::op(...
+//
+// Use ATEN_FN(op) to get an unambiguous *function* version of the operator.
+//
+// There is some interesting behavior for out= operations.
+// ATEN_FN2(sin, out) gives a function that is *faithful* to the schema;
+// that is, the order of arguments is exactly what it looks like in the schema.
+
+#define ATEN_FN2(op_name, overload) at::_ops::op_name##_##overload::call
+#define ATEN_FN(op_name) at::_ops::op_name::call
+
+// Separately, ATEN_OP(op) and ATEN_OP2(op, overload) define a class containing compile-time
+// metadata about a given aten operator.
+// Notable data on the class includes:
+// - ATEN_OP2(add, Tensor)::name // returns the string name: "add"
+// - ATEN_OP2(add, Tensor)::overload_name // returns the string overload name: "Tensor"
+// - ATEN_OP2(add, Tensor)::schema // returns the C++ schema type: at::Tensor (const at::Tensor &, const at::Tensor &, const at::Scalar &)
+// - ATEN_OP2(add, Tensor)::schema_str // returns the string jit type: "add.Tensor(Tensor self, Tensor other, *, Scalar alpha=1) -> Tensor"
+
+#define ATEN_OP2(op_name, overload) at::_ops::op_name##_##overload
+#define ATEN_OP(op_name) at::_ops::op_name
+
+// WARNING: Please do not call any of the ops in the _ops namespace directly.
+// Use the ATEN_FN macros. We do not guarantee stability of the naming
+// scheme for the functions in at::_ops
+
+// See Note [The ATen Operators API] for details of the at::_ops namespace
+
+namespace at {
+namespace _ops {
+${Operators_declarations}
+} // namespace _ops
+} // namespace at

wemm/lib/python3.10/site-packages/torchgen/packaged/ATen/templates/RedispatchFunctions.h

@@ -0,0 +1,32 @@
+#pragma once
+
+// ${generated_comment}
+
+#ifdef TORCH_ASSERT_ONLY_METHOD_OPERATORS
+#error This change adds a dependency on all pytorch operators, meaning the     \
+  file will need to be re-compiled every time an operator is changed or added. \
+  Consider using the at::_ops::{name}::redispatch() interface by including     \
+  the specific operator from <ATen/ops/{my_operator}_ops.h>
+#endif
+
+#include <c10/core/Scalar.h>
+#include <ATen/Tensor.h>
+#include <c10/core/Storage.h>
+#include <ATen/core/Generator.h>
+#include <c10/util/Deprecated.h>
+#include <ATen/DeviceGuard.h>
+#include <c10/core/TensorOptions.h>
+#include <ATen/core/Reduction.h>
+#include <c10/util/Optional.h>
+#include <ATen/TensorUtils.h>
+#include <ATen/Context.h>
+#include <ATen/TracerMode.h>
+#include <ATen/Operators.h>
+
+namespace at {
+
+namespace redispatch {
+    ${function_redispatch_definitions}
+} // namespace redispatch
+
+}