Add files using upload-large-folder tool

.venv/lib/python3.11/site-packages/aiohttp-3.11.12.dist-info/INSTALLER

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

.venv/lib/python3.11/site-packages/aiohttp-3.11.12.dist-info/LICENSE.txt

@@ -0,0 +1,13 @@
+   Copyright aio-libs contributors.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

.venv/lib/python3.11/site-packages/aiohttp-3.11.12.dist-info/METADATA

@@ -0,0 +1,250 @@
+Metadata-Version: 2.2
+Name: aiohttp
+Version: 3.11.12
+Summary: Async http client/server framework (asyncio)
+Home-page: https://github.com/aio-libs/aiohttp
+Maintainer: aiohttp team <team@aiohttp.org>
+Maintainer-email: team@aiohttp.org
+License: Apache-2.0
+Project-URL: Chat: Matrix, https://matrix.to/#/#aio-libs:matrix.org
+Project-URL: Chat: Matrix Space, https://matrix.to/#/#aio-libs-space:matrix.org
+Project-URL: CI: GitHub Actions, https://github.com/aio-libs/aiohttp/actions?query=workflow%3ACI
+Project-URL: Coverage: codecov, https://codecov.io/github/aio-libs/aiohttp
+Project-URL: Docs: Changelog, https://docs.aiohttp.org/en/stable/changes.html
+Project-URL: Docs: RTD, https://docs.aiohttp.org
+Project-URL: GitHub: issues, https://github.com/aio-libs/aiohttp/issues
+Project-URL: GitHub: repo, https://github.com/aio-libs/aiohttp
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Framework :: AsyncIO
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Internet :: WWW/HTTP
+Requires-Python: >=3.9
+Description-Content-Type: text/x-rst
+License-File: LICENSE.txt
+Requires-Dist: aiohappyeyeballs>=2.3.0
+Requires-Dist: aiosignal>=1.1.2
+Requires-Dist: async-timeout<6.0,>=4.0; python_version < "3.11"
+Requires-Dist: attrs>=17.3.0
+Requires-Dist: frozenlist>=1.1.1
+Requires-Dist: multidict<7.0,>=4.5
+Requires-Dist: propcache>=0.2.0
+Requires-Dist: yarl<2.0,>=1.17.0
+Provides-Extra: speedups
+Requires-Dist: aiodns>=3.2.0; (sys_platform == "linux" or sys_platform == "darwin") and extra == "speedups"
+Requires-Dist: Brotli; platform_python_implementation == "CPython" and extra == "speedups"
+Requires-Dist: brotlicffi; platform_python_implementation != "CPython" and extra == "speedups"
+
+==================================
+Async http client/server framework
+==================================
+
+.. image:: https://raw.githubusercontent.com/aio-libs/aiohttp/master/docs/aiohttp-plain.svg
+   :height: 64px
+   :width: 64px
+   :alt: aiohttp logo
+
+|
+
+.. image:: https://github.com/aio-libs/aiohttp/workflows/CI/badge.svg
+   :target: https://github.com/aio-libs/aiohttp/actions?query=workflow%3ACI
+   :alt: GitHub Actions status for master branch
+
+.. image:: https://codecov.io/gh/aio-libs/aiohttp/branch/master/graph/badge.svg
+   :target: https://codecov.io/gh/aio-libs/aiohttp
+   :alt: codecov.io status for master branch
+
+.. image:: https://img.shields.io/endpoint?url=https://codspeed.io/badge.json
+   :target: https://codspeed.io/aio-libs/aiohttp
+   :alt: Codspeed.io status for aiohttp
+
+.. image:: https://badge.fury.io/py/aiohttp.svg
+   :target: https://pypi.org/project/aiohttp
+   :alt: Latest PyPI package version
+
+.. image:: https://readthedocs.org/projects/aiohttp/badge/?version=latest
+   :target: https://docs.aiohttp.org/
+   :alt: Latest Read The Docs
+
+.. image:: https://img.shields.io/matrix/aio-libs:matrix.org?label=Discuss%20on%20Matrix%20at%20%23aio-libs%3Amatrix.org&logo=matrix&server_fqdn=matrix.org&style=flat
+   :target: https://matrix.to/#/%23aio-libs:matrix.org
+   :alt: Matrix Room — #aio-libs:matrix.org
+
+.. image:: https://img.shields.io/matrix/aio-libs-space:matrix.org?label=Discuss%20on%20Matrix%20at%20%23aio-libs-space%3Amatrix.org&logo=matrix&server_fqdn=matrix.org&style=flat
+   :target: https://matrix.to/#/%23aio-libs-space:matrix.org
+   :alt: Matrix Space — #aio-libs-space:matrix.org
+
+
+Key Features
+============
+
+- Supports both client and server side of HTTP protocol.
+- Supports both client and server Web-Sockets out-of-the-box and avoids
+  Callback Hell.
+- Provides Web-server with middleware and pluggable routing.
+
+
+Getting started
+===============
+
+Client
+------
+
+To get something from the web:
+
+.. code-block:: python
+
+  import aiohttp
+  import asyncio
+
+  async def main():
+
+      async with aiohttp.ClientSession() as session:
+          async with session.get('http://python.org') as response:
+
+              print("Status:", response.status)
+              print("Content-type:", response.headers['content-type'])
+
+              html = await response.text()
+              print("Body:", html[:15], "...")
+
+  asyncio.run(main())
+
+This prints:
+
+.. code-block::
+
+    Status: 200
+    Content-type: text/html; charset=utf-8
+    Body: <!doctype html> ...
+
+Coming from `requests <https://requests.readthedocs.io/>`_ ? Read `why we need so many lines <https://aiohttp.readthedocs.io/en/latest/http_request_lifecycle.html>`_.
+
+Server
+------
+
+An example using a simple server:
+
+.. code-block:: python
+
+    # examples/server_simple.py
+    from aiohttp import web
+
+    async def handle(request):
+        name = request.match_info.get('name', "Anonymous")
+        text = "Hello, " + name
+        return web.Response(text=text)
+
+    async def wshandle(request):
+        ws = web.WebSocketResponse()
+        await ws.prepare(request)
+
+        async for msg in ws:
+            if msg.type == web.WSMsgType.text:
+                await ws.send_str("Hello, {}".format(msg.data))
+            elif msg.type == web.WSMsgType.binary:
+                await ws.send_bytes(msg.data)
+            elif msg.type == web.WSMsgType.close:
+                break
+
+        return ws
+
+
+    app = web.Application()
+    app.add_routes([web.get('/', handle),
+                    web.get('/echo', wshandle),
+                    web.get('/{name}', handle)])
+
+    if __name__ == '__main__':
+        web.run_app(app)
+
+
+Documentation
+=============
+
+https://aiohttp.readthedocs.io/
+
+
+Demos
+=====
+
+https://github.com/aio-libs/aiohttp-demos
+
+
+External links
+==============
+
+* `Third party libraries
+  <http://aiohttp.readthedocs.io/en/latest/third_party.html>`_
+* `Built with aiohttp
+  <http://aiohttp.readthedocs.io/en/latest/built_with.html>`_
+* `Powered by aiohttp
+  <http://aiohttp.readthedocs.io/en/latest/powered_by.html>`_
+
+Feel free to make a Pull Request for adding your link to these pages!
+
+
+Communication channels
+======================
+
+*aio-libs Discussions*: https://github.com/aio-libs/aiohttp/discussions
+
+*Matrix*: `#aio-libs:matrix.org <https://matrix.to/#/#aio-libs:matrix.org>`_
+
+We support `Stack Overflow
+<https://stackoverflow.com/questions/tagged/aiohttp>`_.
+Please add *aiohttp* tag to your question there.
+
+Requirements
+============
+
+- attrs_
+- multidict_
+- yarl_
+- frozenlist_
+
+Optionally you may install the aiodns_ library (highly recommended for sake of speed).
+
+.. _aiodns: https://pypi.python.org/pypi/aiodns
+.. _attrs: https://github.com/python-attrs/attrs
+.. _multidict: https://pypi.python.org/pypi/multidict
+.. _frozenlist: https://pypi.org/project/frozenlist/
+.. _yarl: https://pypi.python.org/pypi/yarl
+.. _async-timeout: https://pypi.python.org/pypi/async_timeout
+
+License
+=======
+
+``aiohttp`` is offered under the Apache 2 license.
+
+
+Keepsafe
+========
+
+The aiohttp community would like to thank Keepsafe
+(https://www.getkeepsafe.com) for its support in the early days of
+the project.
+
+
+Source code
+===========
+
+The latest developer version is available in a GitHub repository:
+https://github.com/aio-libs/aiohttp
+
+Benchmarks
+==========
+
+If you are interested in efficiency, the AsyncIO community maintains a
+list of benchmarks on the official wiki:
+https://github.com/python/asyncio/wiki/Benchmarks

.venv/lib/python3.11/site-packages/aiohttp-3.11.12.dist-info/RECORD

@@ -0,0 +1,131 @@
+aiohttp-3.11.12.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+aiohttp-3.11.12.dist-info/LICENSE.txt,sha256=n4DQ2311WpQdtFchcsJw7L2PCCuiFd3QlZhZQu2Uqes,588
+aiohttp-3.11.12.dist-info/METADATA,sha256=d7xgT5HQPw4R1cWYIK6lQbOoCkFYV5505hAhDZWALcA,7712
+aiohttp-3.11.12.dist-info/RECORD,,
+aiohttp-3.11.12.dist-info/WHEEL,sha256=bWgrYGwmr1oqID2askDfuFruhD_BtRXYD33vDqPTClc,151
+aiohttp-3.11.12.dist-info/top_level.txt,sha256=iv-JIaacmTl-hSho3QmphcKnbRRYx1st47yjz_178Ro,8
+aiohttp/.hash/_cparser.pxd.hash,sha256=hYa9Vje-oMs2eh_7MfCPOh2QW_1x1yCjcZuc7AmwLd0,121
+aiohttp/.hash/_find_header.pxd.hash,sha256=_mbpD6vM-CVCKq3ulUvsOAz5Wdo88wrDzfpOsMQaMNA,125
+aiohttp/.hash/_http_parser.pyx.hash,sha256=GBgZjCNbtZApPhf9-gHpS5Z2WMIzM-vgp5VSZIEvZfk,125
+aiohttp/.hash/_http_writer.pyx.hash,sha256=-UgSF82qclpxjP0og_gcFEsstXRKF9e3Ou4wziAyDvI,125
+aiohttp/.hash/hdrs.py.hash,sha256=v6IaKbsxjsdQxBzhb5AjP0x_9G3rUe84D7avf7AI4cs,116
+aiohttp/__init__.py,sha256=NFDgrak_EkgNNzRQ9Ka63rIzkN_IYocFcIERyltx5ys,7840
+aiohttp/__pycache__/__init__.cpython-311.pyc,,
+aiohttp/__pycache__/abc.cpython-311.pyc,,
+aiohttp/__pycache__/base_protocol.cpython-311.pyc,,
+aiohttp/__pycache__/client.cpython-311.pyc,,
+aiohttp/__pycache__/client_exceptions.cpython-311.pyc,,
+aiohttp/__pycache__/client_proto.cpython-311.pyc,,
+aiohttp/__pycache__/client_reqrep.cpython-311.pyc,,
+aiohttp/__pycache__/client_ws.cpython-311.pyc,,
+aiohttp/__pycache__/compression_utils.cpython-311.pyc,,
+aiohttp/__pycache__/connector.cpython-311.pyc,,
+aiohttp/__pycache__/cookiejar.cpython-311.pyc,,
+aiohttp/__pycache__/formdata.cpython-311.pyc,,
+aiohttp/__pycache__/hdrs.cpython-311.pyc,,
+aiohttp/__pycache__/helpers.cpython-311.pyc,,
+aiohttp/__pycache__/http.cpython-311.pyc,,
+aiohttp/__pycache__/http_exceptions.cpython-311.pyc,,
+aiohttp/__pycache__/http_parser.cpython-311.pyc,,
+aiohttp/__pycache__/http_websocket.cpython-311.pyc,,
+aiohttp/__pycache__/http_writer.cpython-311.pyc,,
+aiohttp/__pycache__/log.cpython-311.pyc,,
+aiohttp/__pycache__/multipart.cpython-311.pyc,,
+aiohttp/__pycache__/payload.cpython-311.pyc,,
+aiohttp/__pycache__/payload_streamer.cpython-311.pyc,,
+aiohttp/__pycache__/pytest_plugin.cpython-311.pyc,,
+aiohttp/__pycache__/resolver.cpython-311.pyc,,
+aiohttp/__pycache__/streams.cpython-311.pyc,,
+aiohttp/__pycache__/tcp_helpers.cpython-311.pyc,,
+aiohttp/__pycache__/test_utils.cpython-311.pyc,,
+aiohttp/__pycache__/tracing.cpython-311.pyc,,
+aiohttp/__pycache__/typedefs.cpython-311.pyc,,
+aiohttp/__pycache__/web.cpython-311.pyc,,
+aiohttp/__pycache__/web_app.cpython-311.pyc,,
+aiohttp/__pycache__/web_exceptions.cpython-311.pyc,,
+aiohttp/__pycache__/web_fileresponse.cpython-311.pyc,,
+aiohttp/__pycache__/web_log.cpython-311.pyc,,
+aiohttp/__pycache__/web_middlewares.cpython-311.pyc,,
+aiohttp/__pycache__/web_protocol.cpython-311.pyc,,
+aiohttp/__pycache__/web_request.cpython-311.pyc,,
+aiohttp/__pycache__/web_response.cpython-311.pyc,,
+aiohttp/__pycache__/web_routedef.cpython-311.pyc,,
+aiohttp/__pycache__/web_runner.cpython-311.pyc,,
+aiohttp/__pycache__/web_server.cpython-311.pyc,,
+aiohttp/__pycache__/web_urldispatcher.cpython-311.pyc,,
+aiohttp/__pycache__/web_ws.cpython-311.pyc,,
+aiohttp/__pycache__/worker.cpython-311.pyc,,
+aiohttp/_cparser.pxd,sha256=8jGIg-VJ9p3llwCakUYDsPGxA4HiZe9dmK9Jmtlz-5g,4318
+aiohttp/_find_header.pxd,sha256=0GfwFCPN2zxEKTO1_MA5sYq2UfzsG8kcV3aTqvwlz3g,68
+aiohttp/_headers.pxi,sha256=n701k28dVPjwRnx5j6LpJhLTfj7dqu2vJt7f0O60Oyg,2007
+aiohttp/_http_parser.cpython-311-x86_64-linux-gnu.so,sha256=rulksFv5PZ7AOPoQuR2P1THFflfukMumxkEfRfdFk0Y,2826344
+aiohttp/_http_parser.pyx,sha256=wQdADj5LizwC_7nFGr8nIlk6GpoaQeQ0359H0HMKGuM,28241
+aiohttp/_http_writer.cpython-311-x86_64-linux-gnu.so,sha256=zMYCtCYo-xjYJpSCcVx6UdBpGSHm_pMgnpM7JUmsWXA,463752
+aiohttp/_http_writer.pyx,sha256=fiCck_EVgRiTX7VtAoV2AldjuesJMFPev4TWd9Fx8jo,4597
+aiohttp/_websocket/.hash/mask.pxd.hash,sha256=Y0zBddk_ck3pi9-BFzMcpkcvCKvwvZ4GTtZFb9u1nxQ,128
+aiohttp/_websocket/.hash/mask.pyx.hash,sha256=90owpXYM8_kIma4KUcOxhWSk-Uv4NVMBoCYeFM1B3d0,128
+aiohttp/_websocket/.hash/reader_c.pxd.hash,sha256=EoZjkF_tAFEbGvV0oRY2GZOSuAfWFWFjMhXgq6mQExo,132
+aiohttp/_websocket/__init__.py,sha256=Mar3R9_vBN_Ea4lsW7iTAVXD7OKswKPGqF5xgSyt77k,44
+aiohttp/_websocket/__pycache__/__init__.cpython-311.pyc,,
+aiohttp/_websocket/__pycache__/helpers.cpython-311.pyc,,
+aiohttp/_websocket/__pycache__/models.cpython-311.pyc,,
+aiohttp/_websocket/__pycache__/reader.cpython-311.pyc,,
+aiohttp/_websocket/__pycache__/reader_c.cpython-311.pyc,,
+aiohttp/_websocket/__pycache__/reader_py.cpython-311.pyc,,
+aiohttp/_websocket/__pycache__/writer.cpython-311.pyc,,
+aiohttp/_websocket/helpers.py,sha256=P-XLv8IUaihKzDenVUqfKU5DJbWE5HvG8uhvUZK8Ic4,5038
+aiohttp/_websocket/mask.cpython-311-x86_64-linux-gnu.so,sha256=hq3aHe5ZVl5ENFRtaXjZcSrbS-ITBwqGgEneGVphY1w,245952
+aiohttp/_websocket/mask.pxd,sha256=sBmZ1Amym9kW4Ge8lj1fLZ7mPPya4LzLdpkQExQXv5M,112
+aiohttp/_websocket/mask.pyx,sha256=BHjOtV0O0w7xp9p0LNADRJvGmgfPn9sGeJvSs0fL__4,1397
+aiohttp/_websocket/models.py,sha256=XAzjs_8JYszWXIgZ6R3ZRrF-tX9Q_6LiD49WRYojopM,2121
+aiohttp/_websocket/reader.py,sha256=eC4qS0c5sOeQ2ebAHLaBpIaTVFaSKX79pY2xvh3Pqyw,1030
+aiohttp/_websocket/reader_c.cpython-311-x86_64-linux-gnu.so,sha256=bnETOmm4gSxKkarM68sAEhBjSd_bQt0GgDD2W7V8cUQ,1906008
+aiohttp/_websocket/reader_c.pxd,sha256=9rMWCpAC1jng7_gtqLjRlqQv9q7UkOn63tIQfq2k8Gc,2444
+aiohttp/_websocket/reader_c.py,sha256=anZsBKZWlL8SO8gArsZMDstH37qBuZOvJA7jtj0Z95M,17975
+aiohttp/_websocket/reader_py.py,sha256=anZsBKZWlL8SO8gArsZMDstH37qBuZOvJA7jtj0Z95M,17975
+aiohttp/_websocket/writer.py,sha256=T3P36iMrzVPPC2XeScserHMD5vd9an6yizWzqDUkRZ0,7077
+aiohttp/abc.py,sha256=JLMOxrKLGTDaPRLfraY1pl-xka53YiHhAH9yaF9QRXQ,6512
+aiohttp/base_protocol.py,sha256=Tp8cxUPQvv9kUPk3w6lAzk6d2MAzV3scwI_3Go3C47c,3025
+aiohttp/client.py,sha256=isdfGlM4O5ILr4F4gBABlybxo4MQ1tNaMm7zjMcrfrM,54309
+aiohttp/client_exceptions.py,sha256=uyKbxI2peZhKl7lELBMx3UeusNkfpemPWpGFq0r6JeM,11367
+aiohttp/client_proto.py,sha256=dV7u9floGWG-_xtD2fLUYqiANG6VsJtq0HMlTjf1g-g,10015
+aiohttp/client_reqrep.py,sha256=VAgh0NxP2HvYWx6nX1Pr8FINc1m-W8-5q2zKeZV68n8,43925
+aiohttp/client_ws.py,sha256=_n4hVk71H5rK8TFOIYT0bPTIHOmMCQ3FDFSrU7ctpfI,15031
+aiohttp/compression_utils.py,sha256=0J3EAOR-0HehlYIudJXRu_Kr6hrYCY0IfuJ1px9MhQs,5681
+aiohttp/connector.py,sha256=yW8vyZz4cmXbScbBkCneMF0giSl0WZPJ2NnNw-TegbQ,60225
+aiohttp/cookiejar.py,sha256=PYR1K1mkLa24Hm6c9UEJnAitccNzz97CbsJyQ2ULAlU,17615
+aiohttp/formdata.py,sha256=CUJnCWDNHFcXSYZ_TupaT6rHkY-Q7ghssvWzaYBPIo0,6552
+aiohttp/hdrs.py,sha256=2rj5MyA-6yRdYPhW5UKkW4iNWhEAlGIOSBH5D4FmKNE,5111
+aiohttp/helpers.py,sha256=KqPQECeiJ_EhA93k7-5ZoVdZH0sk_4n0tCoM_E-iMnE,29091
+aiohttp/http.py,sha256=8o8j8xH70OWjnfTWA9V44NR785QPxEPrUtzMXiAVpwc,1842
+aiohttp/http_exceptions.py,sha256=RYmBycJvvPerKkgXXm8v145I1N-fbsgSpcsbNIC-gdE,2961
+aiohttp/http_parser.py,sha256=UqerYPJzA1MqLmeG1jURhTNO1YhwUASK3QVcNEz0me8,36851
+aiohttp/http_websocket.py,sha256=8VXFKw6KQUEmPg48GtRMB37v0gTK7A0inoxXuDxMZEc,842
+aiohttp/http_writer.py,sha256=pRIyfOmL3cZmdWDWBBJ2cZEwEJzLWzlPPAJInaPLThI,7595
+aiohttp/log.py,sha256=BbNKx9e3VMIm0xYjZI0IcBBoS7wjdeIeSaiJE7-qK2g,325
+aiohttp/multipart.py,sha256=SABIvo3vhXzG4bLDZ0C4V3yG_86vAb-3Zb9Li7BVmI8,36944
+aiohttp/payload.py,sha256=rCA9JJI_RMCik_7qNIaC1Bh21aXhABGYK2tsYeaHRQ4,15793
+aiohttp/payload_streamer.py,sha256=ZzEYyfzcjGWkVkK3XR2pBthSCSIykYvY3Wr5cGQ2eTc,2211
+aiohttp/py.typed,sha256=sow9soTwP9T_gEAQSVh7Gb8855h04Nwmhs2We-JRgZM,7
+aiohttp/pytest_plugin.py,sha256=AfJ6VIWzsp5KgpXRREsX3yqGUZrJyfb7zzcMqzWxz7I,12768
+aiohttp/resolver.py,sha256=sJ8-LYCtl_g9f6gn_5X2NFQ9FQ72Q2Mr4_rLxo9NVeI,6375
+aiohttp/streams.py,sha256=U-qTkuAqIfpJChuKEy-vYn8nQ_Z1MVcW0WO2DHiJz_o,22329
+aiohttp/tcp_helpers.py,sha256=BSadqVWaBpMFDRWnhaaR941N9MiDZ7bdTrxgCb0CW-M,961
+aiohttp/test_utils.py,sha256=r7kBasmZtC3tQY5OmyMaIl1B9P8Bnnq1oM3npVcAPKs,22811
+aiohttp/tracing.py,sha256=66XQwtdR5DHv8p953eeNL0l8o6iHDaNwH9bBaybHXD4,15137
+aiohttp/typedefs.py,sha256=wUlqwe9Mw9W8jT3HsYJcYk00qP3EMPz3nTkYXmeNN48,1657
+aiohttp/web.py,sha256=As5nqGQy4QXWMXSaOsh0JudSVVJVIt_nr3n0b8CaMb0,18422
+aiohttp/web_app.py,sha256=Zre0QHM9JAp4d7jrj5NRxlPnfTrKLNuA42Rdsh8Q2TI,19554
+aiohttp/web_exceptions.py,sha256=7nIuiwhZ39vJJ9KrWqArA5QcWbUdqkz2CLwEpJapeN8,10360
+aiohttp/web_fileresponse.py,sha256=FRsS0p9r1KU5y8ceG0QXBYnrL6xggjbxcXSmI6qIR4k,16504
+aiohttp/web_log.py,sha256=rX5D7xLOX2B6BMdiZ-chme_KfJfW5IXEoFwLfkfkajs,7865
+aiohttp/web_middlewares.py,sha256=sFI0AgeNjdyAjuz92QtMIpngmJSOxrqe2Jfbs4BNUu0,4165
+aiohttp/web_protocol.py,sha256=PMCLcrUlC_-2U9ZxnMyWFiaekNvbswmXiIdmhRcMLHM,25630
+aiohttp/web_request.py,sha256=j_SSX9s-d3ZeNyqUTpFIaPUaNdSqHwb7yfc0ufL8xFA,29750
+aiohttp/web_response.py,sha256=65aliDETi7rZ8P76ksuHQI0ZTu1cKpclCSailNu105M,28696
+aiohttp/web_routedef.py,sha256=VT1GAx6BrawoDh5RwBwBu5wSABSqgWwAe74AUCyZAEo,6110
+aiohttp/web_runner.py,sha256=v1G1nKiOOQgFnTSR4IMc6I9ReEFDMaHtMLvO_roDM-A,11786
+aiohttp/web_server.py,sha256=-9WDKUAiR9ll-rSdwXSqG6YjaoW79d1R4y0BGSqgUMA,2888
+aiohttp/web_urldispatcher.py,sha256=TIMxFmhLjERseG0xcZv2Ef9Xuo_GTBRqBqeMkCgL0K8,43825
+aiohttp/web_ws.py,sha256=EOQX3LYqlrkNQHlFTaNpZkQpOYRCZfR-m1bHT4Iseq8,22488
+aiohttp/worker.py,sha256=0lvxRNMjGM47ddlQWtci53ri9YN42Su1Vdd_Z7zMMH0,8040

.venv/lib/python3.11/site-packages/aiohttp-3.11.12.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.8.0)
+Root-Is-Purelib: false
+Tag: cp311-cp311-manylinux_2_17_x86_64
+Tag: cp311-cp311-manylinux2014_x86_64
+

.venv/lib/python3.11/site-packages/aiohttp-3.11.12.dist-info/top_level.txt

@@ -0,0 +1 @@
+aiohttp

.venv/lib/python3.11/site-packages/aiohttp_cors/__about__.py

@@ -0,0 +1,28 @@
+# Copyright 2015 Vladimir Rutsky <vladimir@rutsky.org>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Library meta information.
+
+This module must be stand-alone executable.
+"""
+
+__title__ = "aiohttp-cors"
+__version__ = "0.7.0"
+__author__ = "Vladimir Rutsky and aio-libs team"
+__email__ = "vladimir@rutsky.org"
+__summary__ = "CORS support for aiohttp"
+__uri__ = "https://github.com/aio-libs/aiohttp-cors"
+__license__ = "Apache License, Version 2.0"
+__copyright__ = "2015-2018 {}".format(__author__)

.venv/lib/python3.11/site-packages/aiohttp_cors/__init__.py

@@ -0,0 +1,67 @@
+# Copyright 2015 Vladimir Rutsky <vladimir@rutsky.org>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""CORS support for aiohttp.
+"""
+
+from typing import Mapping, Union, Any
+
+from aiohttp import web
+
+from .__about__ import (
+    __title__, __version__, __author__, __email__, __summary__, __uri__,
+    __license__, __copyright__,
+)
+from .resource_options import ResourceOptions
+from .cors_config import CorsConfig
+from .mixin import CorsViewMixin, custom_cors
+
+__all__ = (
+    "__title__", "__version__", "__author__", "__email__", "__summary__",
+    "__uri__", "__license__", "__copyright__",
+    "setup", "CorsConfig", "ResourceOptions", "CorsViewMixin", "custom_cors"
+)
+
+
+APP_CONFIG_KEY = "aiohttp_cors"
+
+
+def setup(app: web.Application, *,
+          defaults: Mapping[str, Union[ResourceOptions,
+                                       Mapping[str, Any]]]=None) -> CorsConfig:
+    """Setup CORS processing for the application.
+
+    To enable CORS for a resource you need to explicitly add route for
+    that resource using `CorsConfig.add()` method::
+
+        app = aiohttp.web.Application()
+        cors = aiohttp_cors.setup(app)
+        cors.add(
+            app.router.add_route("GET", "/resource", handler),
+            {
+                "*": aiohttp_cors.ResourceOptions(
+                    allow_credentials=True,
+                    expose_headers="*",
+                    allow_headers="*"),
+            })
+
+    :param app:
+        The application for which CORS will be configured.
+    :param defaults:
+        Default settings for origins.
+    )
+    """
+    cors = CorsConfig(app, defaults=defaults)
+    app[APP_CONFIG_KEY] = cors
+    return cors

.venv/lib/python3.11/site-packages/aiohttp_cors/abc.py

@@ -0,0 +1,100 @@
+# Copyright 2015 Vladimir Rutsky <vladimir@rutsky.org>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Abstract base classes.
+"""
+
+from abc import ABCMeta, abstractmethod
+
+from aiohttp import web
+
+
+__all__ = ("AbstractRouterAdapter",)
+
+
+class AbstractRouterAdapter(metaclass=ABCMeta):
+    """Router adapter for handling CORS configuration interface.
+
+    `AbstractRouter` doesn't specify how HTTP requests are delivered
+    to handlers, and aiohttp_cors doesn't rely on specific implementation
+    details.
+
+    In general Router can be seen as a substance that allows to setup handlers
+    for specific HTTP methods and requests paths, lets call these Router's
+    items routing entities.
+    Generic Router is configured with set of routing entities and their
+    handlers.
+
+    This adapter assumes that its reasonable to configure CORS for same
+    routing entities as used in `AbstractRouter`.
+    Routing entities will be added to CorsConfig to enable CORS for them.
+
+    For example, for aiohttp < 0.21.0 routing entity would be
+    `aiohttp.web.Route` — tuple of (HTTP method, URI path).
+    And CORS can be configured for each `aiohttp.web.Route`.
+
+    In aiohttp >= 0.21.0 there are two routing entities: Resource and Route.
+    You can configure CORS for Resource (which will be interpreted as default
+    for all Routes on Resoures), and configure CORS for specific Route.
+    """
+
+    @abstractmethod
+    def add_preflight_handler(self,
+                              routing_entity,
+                              handler,
+                              webview: bool=False):
+        """Add OPTIONS handler for all routes defined by `routing_entity`.
+
+        Does nothing if CORS handler already handles routing entity.
+        Should fail if there are conflicting user-defined OPTIONS handlers.
+        """
+
+    @abstractmethod
+    def is_preflight_request(self, request: web.Request) -> bool:
+        """Is `request` is a CORS preflight request."""
+
+    @abstractmethod
+    def is_cors_enabled_on_request(self, request: web.Request) -> bool:
+        """Is `request` is a request for CORS-enabled resource."""
+
+    @abstractmethod
+    def set_config_for_routing_entity(self,
+                                      routing_entity,
+                                      config):
+        """Record configuration for routing entity.
+
+        If router implements hierarchical routing entities, stored config
+        can be used in hierarchical manner too.
+
+        Should raise if there is conflicting configuration for the routing
+        entity.
+        """
+
+    @abstractmethod
+    async def get_preflight_request_config(
+            self,
+            preflight_request: web.Request,
+            origin: str,
+            requested_method: str):
+        """Get stored CORS configuration for specified HTTP method and origin
+        that corresponds to preflight request.
+
+        Should raise KeyError if CORS is not configured or not enabled
+        for specified HTTP method.
+        """
+
+    @abstractmethod
+    def get_non_preflight_request_config(self, request: web.Request):
+        """Get stored CORS configuration for routing entity that handles
+        specified request."""

.venv/lib/python3.11/site-packages/aiohttp_cors/cors_config.py

@@ -0,0 +1,263 @@
+# Copyright 2015 Vladimir Rutsky <vladimir@rutsky.org>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""CORS configuration container class definition.
+"""
+
+import collections
+import warnings
+from typing import Mapping, Union, Any
+
+from aiohttp import hdrs, web
+
+from .urldispatcher_router_adapter import ResourcesUrlDispatcherRouterAdapter
+from .abc import AbstractRouterAdapter
+from .resource_options import ResourceOptions
+from .preflight_handler import _PreflightHandler
+
+__all__ = (
+    "CorsConfig",
+)
+
+# Positive response to Access-Control-Allow-Credentials
+_TRUE = "true"
+# CORS simple response headers:
+# <http://www.w3.org/TR/cors/#simple-response-header>
+_SIMPLE_RESPONSE_HEADERS = frozenset([
+    hdrs.CACHE_CONTROL,
+    hdrs.CONTENT_LANGUAGE,
+    hdrs.CONTENT_TYPE,
+    hdrs.EXPIRES,
+    hdrs.LAST_MODIFIED,
+    hdrs.PRAGMA
+])
+
+
+def _parse_config_options(
+        config: Mapping[str, Union[ResourceOptions, Mapping[str, Any]]]=None):
+    """Parse CORS configuration (default or per-route)
+
+    :param config:
+        Mapping from Origin to Resource configuration (allowed headers etc)
+        defined either as mapping or `ResourceOptions` instance.
+
+    Raises `ValueError` if configuration is not correct.
+    """
+
+    if config is None:
+        return {}
+
+    if not isinstance(config, collections.abc.Mapping):
+        raise ValueError(
+            "Config must be mapping, got '{}'".format(config))
+
+    parsed = {}
+
+    options_keys = {
+        "allow_credentials", "expose_headers", "allow_headers", "max_age"
+    }
+
+    for origin, options in config.items():
+        # TODO: check that all origins are properly formatted.
+        # This is not a security issue, since origin is compared as strings.
+        if not isinstance(origin, str):
+            raise ValueError(
+                "Origin must be string, got '{}'".format(origin))
+
+        if isinstance(options, ResourceOptions):
+            resource_options = options
+
+        else:
+            if not isinstance(options, collections.abc.Mapping):
+                raise ValueError(
+                    "Origin options must be either "
+                    "aiohttp_cors.ResourceOptions instance or mapping, "
+                    "got '{}'".format(options))
+
+            unexpected_args = frozenset(options.keys()) - options_keys
+            if unexpected_args:
+                raise ValueError(
+                    "Unexpected keywords in resource options: {}".format(
+                        # pylint: disable=bad-builtin
+                        ",".join(map(str, unexpected_args))))
+
+            resource_options = ResourceOptions(**options)
+
+        parsed[origin] = resource_options
+
+    return parsed
+
+
+_ConfigType = Mapping[str, Union[ResourceOptions, Mapping[str, Any]]]
+
+
+class _CorsConfigImpl(_PreflightHandler):
+
+    def __init__(self,
+                 app: web.Application,
+                 router_adapter: AbstractRouterAdapter):
+        self._app = app
+
+        self._router_adapter = router_adapter
+
+        # Register hook for all responses.  This hook handles CORS-related
+        # headers on non-preflight requests.
+        self._app.on_response_prepare.append(self._on_response_prepare)
+
+    def add(self,
+            routing_entity,
+            config: _ConfigType=None):
+        """Enable CORS for specific route or resource.
+
+        If route is passed CORS is enabled for route's resource.
+
+        :param routing_entity:
+            Route or Resource for which CORS should be enabled.
+        :param config:
+            CORS options for the route.
+        :return: `routing_entity`.
+        """
+
+        parsed_config = _parse_config_options(config)
+
+        self._router_adapter.add_preflight_handler(
+            routing_entity, self._preflight_handler)
+        self._router_adapter.set_config_for_routing_entity(
+            routing_entity, parsed_config)
+
+        return routing_entity
+
+    async def _on_response_prepare(self,
+                                   request: web.Request,
+                                   response: web.StreamResponse):
+        """Non-preflight CORS request response processor.
+
+        If request is done on CORS-enabled route, process request parameters
+        and set appropriate CORS response headers.
+        """
+        if (not self._router_adapter.is_cors_enabled_on_request(request) or
+                self._router_adapter.is_preflight_request(request)):
+            # Either not CORS enabled route, or preflight request which is
+            # handled in its own handler.
+            return
+
+        # Processing response of non-preflight CORS-enabled request.
+
+        config = self._router_adapter.get_non_preflight_request_config(request)
+
+        # Handle according to part 6.1 of the CORS specification.
+
+        origin = request.headers.get(hdrs.ORIGIN)
+        if origin is None:
+            # Terminate CORS according to CORS 6.1.1.
+            return
+
+        options = config.get(origin, config.get("*"))
+        if options is None:
+            # Terminate CORS according to CORS 6.1.2.
+            return
+
+        assert hdrs.ACCESS_CONTROL_ALLOW_ORIGIN not in response.headers
+        assert hdrs.ACCESS_CONTROL_ALLOW_CREDENTIALS not in response.headers
+        assert hdrs.ACCESS_CONTROL_EXPOSE_HEADERS not in response.headers
+
+        # Process according to CORS 6.1.4.
+        # Set exposed headers (server headers exposed to client) before
+        # setting any other headers.
+        if options.expose_headers == "*":
+            # Expose all headers that are set in response.
+            exposed_headers = \
+                frozenset(response.headers.keys()) - _SIMPLE_RESPONSE_HEADERS
+            response.headers[hdrs.ACCESS_CONTROL_EXPOSE_HEADERS] = \
+                ",".join(exposed_headers)
+
+        elif options.expose_headers:
+            # Expose predefined list of headers.
+            response.headers[hdrs.ACCESS_CONTROL_EXPOSE_HEADERS] = \
+                ",".join(options.expose_headers)
+
+        # Process according to CORS 6.1.3.
+        # Set allowed origin.
+        response.headers[hdrs.ACCESS_CONTROL_ALLOW_ORIGIN] = origin
+        if options.allow_credentials:
+            # Set allowed credentials.
+            response.headers[hdrs.ACCESS_CONTROL_ALLOW_CREDENTIALS] = _TRUE
+
+    async def _get_config(self, request, origin, request_method):
+        config = \
+            await self._router_adapter.get_preflight_request_config(
+                request, origin, request_method)
+        return config
+
+
+class CorsConfig:
+    """CORS configuration instance.
+
+    The instance holds default CORS parameters and per-route options specified
+    in `add()` method.
+
+    Each `aiohttp.web.Application` can have exactly one instance of this class.
+    """
+
+    def __init__(self, app: web.Application, *,
+                 defaults: _ConfigType=None,
+                 router_adapter: AbstractRouterAdapter=None):
+        """Construct CORS configuration.
+
+        :param app:
+            Application for which CORS configuration is built.
+        :param defaults:
+            Default CORS settings for origins.
+        :param router_adapter:
+            Router adapter. Required if application uses non-default router.
+        """
+
+        self.defaults = _parse_config_options(defaults)
+
+        self._cors_impl = None
+
+        self._resources_router_adapter = None
+        self._resources_cors_impl = None
+
+        self._old_routes_cors_impl = None
+
+        if router_adapter is None:
+            router_adapter = \
+                ResourcesUrlDispatcherRouterAdapter(app.router, self.defaults)
+
+        self._cors_impl = _CorsConfigImpl(app, router_adapter)
+
+    def add(self,
+            routing_entity,
+            config: _ConfigType = None,
+            webview: bool=False):
+        """Enable CORS for specific route or resource.
+
+        If route is passed CORS is enabled for route's resource.
+
+        :param routing_entity:
+            Route or Resource for which CORS should be enabled.
+        :param config:
+            CORS options for the route.
+        :return: `routing_entity`.
+        """
+
+        if webview:
+            warnings.warn('webview argument is deprecated, '
+                          'views are handled authomatically without '
+                          'extra settings',
+                          DeprecationWarning,
+                          stacklevel=2)
+
+        return self._cors_impl.add(routing_entity, config)

.venv/lib/python3.11/site-packages/aiohttp_cors/mixin.py

@@ -0,0 +1,47 @@
+import collections
+
+from .preflight_handler import _PreflightHandler
+
+
+def custom_cors(config):
+    def wrapper(function):
+        name = "{}_cors_config".format(function.__name__)
+        setattr(function, name, config)
+        return function
+    return wrapper
+
+
+class CorsViewMixin(_PreflightHandler):
+    cors_config = None
+
+    @classmethod
+    def get_request_config(cls, request, request_method):
+        try:
+            from . import APP_CONFIG_KEY
+            cors = request.app[APP_CONFIG_KEY]
+        except KeyError:
+            raise ValueError("aiohttp-cors is not configured.")
+
+        method = getattr(cls, request_method.lower(), None)
+
+        if not method:
+            raise KeyError()
+
+        config_property_key = "{}_cors_config".format(request_method.lower())
+
+        custom_config = getattr(method, config_property_key, None)
+        if not custom_config:
+            custom_config = {}
+
+        class_config = cls.cors_config
+        if not class_config:
+            class_config = {}
+
+        return collections.ChainMap(custom_config, class_config, cors.defaults)
+
+    async def _get_config(self, request, origin, request_method):
+        return self.get_request_config(request, request_method)
+
+    async def options(self):
+        response = await self._preflight_handler(self.request)
+        return response

.venv/lib/python3.11/site-packages/aiohttp_cors/preflight_handler.py

@@ -0,0 +1,130 @@
+from aiohttp import hdrs, web
+
+# Positive response to Access-Control-Allow-Credentials
+_TRUE = "true"
+
+
+class _PreflightHandler:
+
+    @staticmethod
+    def _parse_request_method(request: web.Request):
+        """Parse Access-Control-Request-Method header of the preflight request
+        """
+        method = request.headers.get(hdrs.ACCESS_CONTROL_REQUEST_METHOD)
+        if method is None:
+            raise web.HTTPForbidden(
+                text="CORS preflight request failed: "
+                     "'Access-Control-Request-Method' header is not specified")
+
+        # FIXME: validate method string (ABNF: method = token), if parsing
+        # fails, raise HTTPForbidden.
+
+        return method
+
+    @staticmethod
+    def _parse_request_headers(request: web.Request):
+        """Parse Access-Control-Request-Headers header or the preflight request
+
+        Returns set of headers in upper case.
+        """
+        headers = request.headers.get(hdrs.ACCESS_CONTROL_REQUEST_HEADERS)
+        if headers is None:
+            return frozenset()
+
+        # FIXME: validate each header string, if parsing fails, raise
+        # HTTPForbidden.
+        # FIXME: check, that headers split and stripped correctly (according
+        # to ABNF).
+        headers = (h.strip(" \t").upper() for h in headers.split(","))
+        # pylint: disable=bad-builtin
+        return frozenset(filter(None, headers))
+
+    async def _get_config(self, request, origin, request_method):
+        raise NotImplementedError()
+
+    async def _preflight_handler(self, request: web.Request):
+        """CORS preflight request handler"""
+
+        # Handle according to part 6.2 of the CORS specification.
+
+        origin = request.headers.get(hdrs.ORIGIN)
+        if origin is None:
+            # Terminate CORS according to CORS 6.2.1.
+            raise web.HTTPForbidden(
+                text="CORS preflight request failed: "
+                     "origin header is not specified in the request")
+
+        # CORS 6.2.3. Doing it out of order is not an error.
+        request_method = self._parse_request_method(request)
+
+        # CORS 6.2.5. Doing it out of order is not an error.
+
+        try:
+            config = \
+                await self._get_config(request, origin, request_method)
+        except KeyError:
+            raise web.HTTPForbidden(
+                text="CORS preflight request failed: "
+                     "request method {!r} is not allowed "
+                     "for {!r} origin".format(request_method, origin))
+
+        if not config:
+            # No allowed origins for the route.
+            # Terminate CORS according to CORS 6.2.1.
+            raise web.HTTPForbidden(
+                text="CORS preflight request failed: "
+                     "no origins are allowed")
+
+        options = config.get(origin, config.get("*"))
+        if options is None:
+            # No configuration for the origin - deny.
+            # Terminate CORS according to CORS 6.2.2.
+            raise web.HTTPForbidden(
+                text="CORS preflight request failed: "
+                     "origin '{}' is not allowed".format(origin))
+
+        # CORS 6.2.4
+        request_headers = self._parse_request_headers(request)
+
+        # CORS 6.2.6
+        if options.allow_headers == "*":
+            pass
+        else:
+            disallowed_headers = request_headers - options.allow_headers
+            if disallowed_headers:
+                raise web.HTTPForbidden(
+                    text="CORS preflight request failed: "
+                         "headers are not allowed: {}".format(
+                             ", ".join(disallowed_headers)))
+
+        # Ok, CORS actual request with specified in the preflight request
+        # parameters is allowed.
+        # Set appropriate headers and return 200 response.
+
+        response = web.Response()
+
+        # CORS 6.2.7
+        response.headers[hdrs.ACCESS_CONTROL_ALLOW_ORIGIN] = origin
+        if options.allow_credentials:
+            # Set allowed credentials.
+            response.headers[hdrs.ACCESS_CONTROL_ALLOW_CREDENTIALS] = _TRUE
+
+        # CORS 6.2.8
+        if options.max_age is not None:
+            response.headers[hdrs.ACCESS_CONTROL_MAX_AGE] = \
+                str(options.max_age)
+
+        # CORS 6.2.9
+        # TODO: more optimal for client preflight request cache would be to
+        # respond with ALL allowed methods.
+        response.headers[hdrs.ACCESS_CONTROL_ALLOW_METHODS] = request_method
+
+        # CORS 6.2.10
+        if request_headers:
+            # Note: case of the headers in the request is changed, but this
+            # shouldn't be a problem, since the headers should be compared in
+            # the case-insensitive way.
+            response.headers[hdrs.ACCESS_CONTROL_ALLOW_HEADERS] = \
+                ",".join(request_headers)
+
+        return response

.venv/lib/python3.11/site-packages/aiohttp_cors/resource_options.py

@@ -0,0 +1,153 @@
+# Copyright 2015 Vladimir Rutsky <vladimir@rutsky.org>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Resource CORS options class definition.
+"""
+
+import numbers
+import collections
+import collections.abc
+
+__all__ = ("ResourceOptions",)
+
+
+def _is_proper_sequence(seq):
+    """Returns is seq is sequence and not string."""
+    return (isinstance(seq, collections.abc.Sequence) and
+            not isinstance(seq, str))
+
+
+class ResourceOptions(collections.namedtuple(
+        "Base",
+        ("allow_credentials", "expose_headers", "allow_headers", "max_age",
+         "allow_methods"))):
+    """Resource CORS options."""
+
+    __slots__ = ()
+
+    def __init__(self, *, allow_credentials=False, expose_headers=(),
+                 allow_headers=(), max_age=None, allow_methods=None):
+        """Construct resource CORS options.
+
+        Options will be normalized.
+
+        :param allow_credentials:
+            Is passing client credentials to the resource from other origin
+            is allowed.
+            See <http://www.w3.org/TR/cors/#user-credentials> for
+            the definition.
+        :type allow_credentials: bool
+            Is passing client credentials to the resource from other origin
+            is allowed.
+
+        :param expose_headers:
+            Server headers that are allowed to be exposed to the client.
+            Simple response headers are excluded from this set, see
+            <http://www.w3.org/TR/cors/#list-of-exposed-headers>.
+        :type expose_headers: sequence of strings or ``*`` string.
+
+        :param allow_headers:
+            Client headers that are allowed to be passed to the resource.
+            See <http://www.w3.org/TR/cors/#list-of-headers>.
+        :type allow_headers: sequence of strings or ``*`` string.
+
+        :param max_age:
+            How long the results of a preflight request can be cached in a
+            preflight result cache (in seconds).
+            See <http://www.w3.org/TR/cors/#http-access-control-max-age>.
+
+        :param allow_methods:
+            List of allowed methods or ``*``string. Can be used in resource or
+            global defaults, but not in specific route.
+
+            It's not required to specify all allowed methods for specific
+            resource, routes that have explicit CORS configuration will be
+            treated as if their methods are allowed.
+        """
+        super().__init__()
+
+    def __new__(cls, *, allow_credentials=False, expose_headers=(),
+                allow_headers=(), max_age=None, allow_methods=None):
+        """Normalize source parameters and store them in namedtuple."""
+
+        if not isinstance(allow_credentials, bool):
+            raise ValueError(
+                "'allow_credentials' must be boolean, "
+                "got '{!r}'".format(allow_credentials))
+        _allow_credentials = allow_credentials
+
+        # `expose_headers` is either "*", or sequence of strings.
+        if expose_headers == "*":
+            _expose_headers = expose_headers
+        elif not _is_proper_sequence(expose_headers):
+            raise ValueError(
+                "'expose_headers' must be either '*', or sequence of strings, "
+                "got '{!r}'".format(expose_headers))
+        elif expose_headers:
+            # "Access-Control-Expose-Headers" ":" #field-name
+            # TODO: Check that headers are valid.
+            # TODO: Remove headers that in the _SIMPLE_RESPONSE_HEADERS set
+            # according to
+            # <http://www.w3.org/TR/cors/#list-of-exposed-headers>.
+            _expose_headers = frozenset(expose_headers)
+        else:
+            # No headers exposed.
+            _expose_headers = frozenset()
+
+        # `allow_headers` is either "*", or set of headers in upper case.
+        if allow_headers == "*":
+            _allow_headers = allow_headers
+        elif not _is_proper_sequence(allow_headers):
+            raise ValueError(
+                "'allow_headers' must be either '*', or sequence of strings, "
+                "got '{!r}'".format(allow_headers))
+        else:
+            # TODO: Check that headers are valid.
+            _allow_headers = frozenset(h.upper() for h in allow_headers)
+
+        if max_age is None:
+            _max_age = None
+        else:
+            if not isinstance(max_age, numbers.Integral) or max_age < 0:
+                raise ValueError(
+                    "'max_age' must be non-negative integer, "
+                    "got '{!r}'".format(max_age))
+            _max_age = max_age
+
+        if allow_methods is None or allow_methods == "*":
+            _allow_methods = allow_methods
+        elif not _is_proper_sequence(allow_methods):
+            raise ValueError(
+                "'allow_methods' must be either '*', or sequence of strings, "
+                "got '{!r}'".format(allow_methods))
+        else:
+            # TODO: Check that methods are valid.
+            _allow_methods = frozenset(m.upper() for m in allow_methods)
+
+        return super().__new__(
+            cls,
+            allow_credentials=_allow_credentials,
+            expose_headers=_expose_headers,
+            allow_headers=_allow_headers,
+            max_age=_max_age,
+            allow_methods=_allow_methods)
+
+    def is_method_allowed(self, method):
+        if self.allow_methods is None:
+            return False
+
+        if self.allow_methods == '*':
+            return True
+
+        return method.upper() in self.allow_methods

.venv/lib/python3.11/site-packages/aiohttp_cors/urldispatcher_router_adapter.py

@@ -0,0 +1,324 @@
+# Copyright 2015 Vladimir Rutsky <vladimir@rutsky.org>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""AbstractRouterAdapter for aiohttp.web.UrlDispatcher.
+"""
+import collections
+
+from typing import Union
+
+from aiohttp import web
+from aiohttp import hdrs
+
+from .abc import AbstractRouterAdapter
+from .mixin import CorsViewMixin
+
+
+# There several usage patterns of routes which should be handled
+# differently.
+#
+# 1. Using new Resources:
+#
+#     resource = app.router.add_resource(path)
+#     cors.add(resource, resource_defaults=...)
+#     cors.add(resource.add_route(method1, handler1), config=...)
+#     cors.add(resource.add_route(method2, handler2), config=...)
+#     cors.add(resource.add_route(method3, handler3), config=...)
+#
+# Here all related Routes (i.e. routes with the same path) are in
+# a single Resource.
+#
+# 2. Using `router.add_static()`:
+#
+#     route1 = app.router.add_static(
+#         "/images", "/usr/share/app/images/")
+#     cors.add(route1, config=...)
+#
+# Here old-style `web.StaticRoute` is created and wrapped with
+# `web.ResourceAdapter`.
+#
+# 3. Using old `router.add_route()`:
+#
+#     cors.add(app.router.add_route(method1, path, hand1), config=...)
+#     cors.add(app.router.add_route(method2, path, hand2), config=...)
+#     cors.add(app.router.add_route(method3, path, hand3), config=...)
+#
+# This creates three Resources with single Route in each.
+#
+# 4. Using deprecated `register_route` with manually created
+#    `web.Route`:
+#
+#     route1 = RouteSubclass(...)
+#     app.router.register_route(route1)
+#     cors.add(route1, config=...)
+#
+# Here old-style route is wrapped with `web.ResourceAdapter`.
+#
+# Preflight requests is roughly an OPTIONS request with query
+# "is specific HTTP method is allowed".
+# In order to properly handle preflight request we need to know which
+# routes have enabled CORS on the request path and CORS configuration
+# for requested HTTP method.
+#
+# In case of new usage pattern it's simple: we need to take a look at
+# self._resource_config[resource][method] for the processing resource.
+#
+# In case of old usage pattern we need to iterate over routes with
+# enabled CORS and check is requested path and HTTP method is accepted
+# by a route.
+
+
+class _ResourceConfig:
+    def __init__(self, default_config):
+        # Resource default config.
+        self.default_config = default_config
+
+        # HTTP method to route configuration.
+        self.method_config = {}
+
+
+def _is_web_view(entity, strict=True):
+    webview = False
+    if isinstance(entity, web.AbstractRoute):
+        handler = entity.handler
+        if isinstance(handler, type) and issubclass(handler, web.View):
+            webview = True
+            if not issubclass(handler, CorsViewMixin):
+                if strict:
+                    raise ValueError("web view should be derived from "
+                                     "aiohttp_cors.WebViewMixig for working "
+                                     "with the library")
+                else:
+                    return False
+    return webview
+
+
+class ResourcesUrlDispatcherRouterAdapter(AbstractRouterAdapter):
+    """Adapter for `UrlDispatcher` for Resources-based routing only.
+
+    Should be used with routes added in the following way:
+
+        resource = app.router.add_resource(path)
+        cors.add(resource, resource_defaults=...)
+        cors.add(resource.add_route(method1, handler1), config=...)
+        cors.add(resource.add_route(method2, handler2), config=...)
+        cors.add(resource.add_route(method3, handler3), config=...)
+    """
+
+    def __init__(self,
+                 router: web.UrlDispatcher,
+                 defaults):
+        """
+        :param defaults:
+            Default CORS configuration.
+        """
+        self._router = router
+
+        # Default configuration for all routes.
+        self._default_config = defaults
+
+        # Mapping from Resource to _ResourceConfig.
+        self._resource_config = {}
+
+        self._resources_with_preflight_handlers = set()
+        self._preflight_routes = set()
+
+    def add_preflight_handler(
+            self,
+            routing_entity: Union[web.Resource, web.StaticResource,
+                                  web.ResourceRoute],
+            handler):
+        """Add OPTIONS handler for all routes defined by `routing_entity`.
+
+        Does nothing if CORS handler already handles routing entity.
+        Should fail if there are conflicting user-defined OPTIONS handlers.
+        """
+
+        if isinstance(routing_entity, web.Resource):
+            resource = routing_entity
+
+            # Add preflight handler for Resource, if not yet added.
+
+            if resource in self._resources_with_preflight_handlers:
+                # Preflight handler already added for this resource.
+                return
+            for route_obj in resource:
+                if route_obj.method == hdrs.METH_OPTIONS:
+                    if route_obj.handler is handler:
+                        return  # already added
+                    else:
+                        raise ValueError(
+                            "{!r} already has OPTIONS handler {!r}"
+                            .format(resource, route_obj.handler))
+                elif route_obj.method == hdrs.METH_ANY:
+                    if _is_web_view(route_obj):
+                        self._preflight_routes.add(route_obj)
+                        self._resources_with_preflight_handlers.add(resource)
+                        return
+                    else:
+                        raise ValueError("{!r} already has a '*' handler "
+                                         "for all methods".format(resource))
+
+            preflight_route = resource.add_route(hdrs.METH_OPTIONS, handler)
+            self._preflight_routes.add(preflight_route)
+            self._resources_with_preflight_handlers.add(resource)
+
+        elif isinstance(routing_entity, web.StaticResource):
+            resource = routing_entity
+
+            # Add preflight handler for Resource, if not yet added.
+
+            if resource in self._resources_with_preflight_handlers:
+                # Preflight handler already added for this resource.
+                return
+
+            resource.set_options_route(handler)
+            preflight_route = resource._routes[hdrs.METH_OPTIONS]
+            self._preflight_routes.add(preflight_route)
+            self._resources_with_preflight_handlers.add(resource)
+
+        elif isinstance(routing_entity, web.ResourceRoute):
+            route = routing_entity
+
+            if not self.is_cors_for_resource(route.resource):
+                self.add_preflight_handler(route.resource, handler)
+
+        else:
+            raise ValueError(
+                "Resource or ResourceRoute expected, got {!r}".format(
+                    routing_entity))
+
+    def is_cors_for_resource(self, resource: web.Resource) -> bool:
+        """Is CORS is configured for the resource"""
+        return resource in self._resources_with_preflight_handlers
+
+    def _request_route(self, request: web.Request) -> web.ResourceRoute:
+        match_info = request.match_info
+        assert isinstance(match_info, web.UrlMappingMatchInfo)
+        return match_info.route
+
+    def _request_resource(self, request: web.Request) -> web.Resource:
+        return self._request_route(request).resource
+
+    def is_preflight_request(self, request: web.Request) -> bool:
+        """Is `request` is a CORS preflight request."""
+        route = self._request_route(request)
+        if _is_web_view(route, strict=False):
+            return request.method == 'OPTIONS'
+        return route in self._preflight_routes
+
+    def is_cors_enabled_on_request(self, request: web.Request) -> bool:
+        """Is `request` is a request for CORS-enabled resource."""
+
+        return self._request_resource(request) in self._resource_config
+
+    def set_config_for_routing_entity(
+            self,
+            routing_entity: Union[web.Resource, web.StaticResource,
+                                  web.ResourceRoute],
+            config):
+        """Record configuration for resource or it's route."""
+
+        if isinstance(routing_entity, (web.Resource, web.StaticResource)):
+            resource = routing_entity
+
+            # Add resource configuration or fail if it's already added.
+            if resource in self._resource_config:
+                raise ValueError(
+                    "CORS is already configured for {!r} resource.".format(
+                        resource))
+
+            self._resource_config[resource] = _ResourceConfig(
+                default_config=config)
+
+        elif isinstance(routing_entity, web.ResourceRoute):
+            route = routing_entity
+
+            # Add resource's route configuration or fail if it's already added.
+            if route.resource not in self._resource_config:
+                self.set_config_for_routing_entity(route.resource, config)
+
+            if route.resource not in self._resource_config:
+                raise ValueError(
+                    "Can't setup CORS for {!r} request, "
+                    "CORS must be enabled for route's resource first.".format(
+                        route))
+
+            resource_config = self._resource_config[route.resource]
+
+            if route.method in resource_config.method_config:
+                raise ValueError(
+                    "Can't setup CORS for {!r} route: CORS already "
+                    "configured on resource {!r} for {} method".format(
+                        route, route.resource, route.method))
+
+            resource_config.method_config[route.method] = config
+
+        else:
+            raise ValueError(
+                "Resource or ResourceRoute expected, got {!r}".format(
+                    routing_entity))
+
+    async def get_preflight_request_config(
+            self,
+            preflight_request: web.Request,
+            origin: str,
+            requested_method: str):
+        assert self.is_preflight_request(preflight_request)
+
+        resource = self._request_resource(preflight_request)
+        resource_config = self._resource_config[resource]
+        defaulted_config = collections.ChainMap(
+            resource_config.default_config,
+            self._default_config)
+
+        options = defaulted_config.get(origin, defaulted_config.get("*"))
+        if options is not None and options.is_method_allowed(requested_method):
+            # Requested method enabled for CORS in defaults, override it with
+            # explicit route configuration (if any).
+            route_config = resource_config.method_config.get(
+                requested_method, {})
+
+        else:
+            # Requested method is not enabled in defaults.
+            # Enable CORS for it only if explicit configuration exists.
+            route_config = resource_config.method_config[requested_method]
+
+        defaulted_config = collections.ChainMap(route_config, defaulted_config)
+
+        return defaulted_config
+
+    def get_non_preflight_request_config(self, request: web.Request):
+        """Get stored CORS configuration for routing entity that handles
+        specified request."""
+
+        assert self.is_cors_enabled_on_request(request)
+
+        resource = self._request_resource(request)
+        resource_config = self._resource_config[resource]
+        # Take Route config (if any) with defaults from Resource CORS
+        # configuration and global defaults.
+        route = request.match_info.route
+        if _is_web_view(route, strict=False):
+            method_config = request.match_info.handler.get_request_config(
+                request, request.method)
+        else:
+            method_config = resource_config.method_config.get(request.method,
+                                                              {})
+        defaulted_config = collections.ChainMap(
+            method_config,
+            resource_config.default_config,
+            self._default_config)
+
+        return defaulted_config

.venv/lib/python3.11/site-packages/frozenlist/__init__.py

@@ -0,0 +1,98 @@
+import os
+import sys
+import types
+from collections.abc import MutableSequence
+from functools import total_ordering
+from typing import Any, Type
+
+__version__ = "1.5.0"
+
+__all__ = ("FrozenList", "PyFrozenList")  # type: Tuple[str, ...]
+
+
+NO_EXTENSIONS = bool(os.environ.get("FROZENLIST_NO_EXTENSIONS"))  # type: bool
+
+
+@total_ordering
+class FrozenList(MutableSequence):
+    __slots__ = ("_frozen", "_items")
+
+    if sys.version_info >= (3, 9):
+        __class_getitem__ = classmethod(types.GenericAlias)
+    else:
+
+        @classmethod
+        def __class_getitem__(
+            cls: Type["FrozenList"],
+            cls_item: Any,
+        ) -> Type["FrozenList"]:
+            return cls
+
+    def __init__(self, items=None):
+        self._frozen = False
+        if items is not None:
+            items = list(items)
+        else:
+            items = []
+        self._items = items
+
+    @property
+    def frozen(self):
+        return self._frozen
+
+    def freeze(self):
+        self._frozen = True
+
+    def __getitem__(self, index):
+        return self._items[index]
+
+    def __setitem__(self, index, value):
+        if self._frozen:
+            raise RuntimeError("Cannot modify frozen list.")
+        self._items[index] = value
+
+    def __delitem__(self, index):
+        if self._frozen:
+            raise RuntimeError("Cannot modify frozen list.")
+        del self._items[index]
+
+    def __len__(self):
+        return self._items.__len__()
+
+    def __iter__(self):
+        return self._items.__iter__()
+
+    def __reversed__(self):
+        return self._items.__reversed__()
+
+    def __eq__(self, other):
+        return list(self) == other
+
+    def __le__(self, other):
+        return list(self) <= other
+
+    def insert(self, pos, item):
+        if self._frozen:
+            raise RuntimeError("Cannot modify frozen list.")
+        self._items.insert(pos, item)
+
+    def __repr__(self):
+        return f"<FrozenList(frozen={self._frozen}, {self._items!r})>"
+
+    def __hash__(self):
+        if self._frozen:
+            return hash(tuple(self))
+        else:
+            raise RuntimeError("Cannot hash unfrozen list.")
+
+
+PyFrozenList = FrozenList
+
+
+if not NO_EXTENSIONS:
+    try:
+        from ._frozenlist import FrozenList as CFrozenList  # type: ignore
+    except ImportError:  # pragma: no cover
+        pass
+    else:
+        FrozenList = CFrozenList  # type: ignore

.venv/lib/python3.11/site-packages/frozenlist/__init__.pyi

@@ -0,0 +1,47 @@
+from typing import (
+    Generic,
+    Iterable,
+    Iterator,
+    List,
+    MutableSequence,
+    Optional,
+    TypeVar,
+    Union,
+    overload,
+)
+
+_T = TypeVar("_T")
+_Arg = Union[List[_T], Iterable[_T]]
+
+class FrozenList(MutableSequence[_T], Generic[_T]):
+    def __init__(self, items: Optional[_Arg[_T]] = None) -> None: ...
+    @property
+    def frozen(self) -> bool: ...
+    def freeze(self) -> None: ...
+    @overload
+    def __getitem__(self, i: int) -> _T: ...
+    @overload
+    def __getitem__(self, s: slice) -> FrozenList[_T]: ...
+    @overload
+    def __setitem__(self, i: int, o: _T) -> None: ...
+    @overload
+    def __setitem__(self, s: slice, o: Iterable[_T]) -> None: ...
+    @overload
+    def __delitem__(self, i: int) -> None: ...
+    @overload
+    def __delitem__(self, i: slice) -> None: ...
+    def __len__(self) -> int: ...
+    def __iter__(self) -> Iterator[_T]: ...
+    def __reversed__(self) -> Iterator[_T]: ...
+    def __eq__(self, other: object) -> bool: ...
+    def __le__(self, other: FrozenList[_T]) -> bool: ...
+    def __ne__(self, other: object) -> bool: ...
+    def __lt__(self, other: FrozenList[_T]) -> bool: ...
+    def __ge__(self, other: FrozenList[_T]) -> bool: ...
+    def __gt__(self, other: FrozenList[_T]) -> bool: ...
+    def insert(self, pos: int, item: _T) -> None: ...
+    def __repr__(self) -> str: ...
+    def __hash__(self) -> int: ...
+
+# types for C accelerators are the same
+CFrozenList = PyFrozenList = FrozenList

.venv/lib/python3.11/site-packages/frozenlist/_frozenlist.pyx

@@ -0,0 +1,123 @@
+import sys
+import types
+from collections.abc import MutableSequence
+
+
+cdef class FrozenList:
+
+    if sys.version_info >= (3, 9):
+        __class_getitem__ = classmethod(types.GenericAlias)
+    else:
+        @classmethod
+        def __class_getitem__(cls, cls_item):
+            return cls
+
+    cdef readonly bint frozen
+    cdef list _items
+
+    def __init__(self, items=None):
+        self.frozen = False
+        if items is not None:
+            items = list(items)
+        else:
+            items = []
+        self._items = items
+
+    cdef object _check_frozen(self):
+        if self.frozen:
+            raise RuntimeError("Cannot modify frozen list.")
+
+    cdef inline object _fast_len(self):
+        return len(self._items)
+
+    def freeze(self):
+        self.frozen = True
+
+    def __getitem__(self, index):
+        return self._items[index]
+
+    def __setitem__(self, index, value):
+        self._check_frozen()
+        self._items[index] = value
+
+    def __delitem__(self, index):
+        self._check_frozen()
+        del self._items[index]
+
+    def __len__(self):
+        return self._fast_len()
+
+    def __iter__(self):
+        return self._items.__iter__()
+
+    def __reversed__(self):
+        return self._items.__reversed__()
+
+    def __richcmp__(self, other, op):
+        if op == 0:  # <
+            return list(self) < other
+        if op == 1:  # <=
+            return list(self) <= other
+        if op == 2:  # ==
+            return list(self) == other
+        if op == 3:  # !=
+            return list(self) != other
+        if op == 4:  # >
+            return list(self) > other
+        if op == 5:  # =>
+            return list(self) >= other
+
+    def insert(self, pos, item):
+        self._check_frozen()
+        self._items.insert(pos, item)
+
+    def __contains__(self, item):
+        return item in self._items
+
+    def __iadd__(self, items):
+        self._check_frozen()
+        self._items += list(items)
+        return self
+
+    def index(self, item):
+        return self._items.index(item)
+
+    def remove(self, item):
+        self._check_frozen()
+        self._items.remove(item)
+
+    def clear(self):
+        self._check_frozen()
+        self._items.clear()
+
+    def extend(self, items):
+        self._check_frozen()
+        self._items += list(items)
+
+    def reverse(self):
+        self._check_frozen()
+        self._items.reverse()
+
+    def pop(self, index=-1):
+        self._check_frozen()
+        return self._items.pop(index)
+
+    def append(self, item):
+        self._check_frozen()
+        return self._items.append(item)
+
+    def count(self, item):
+        return self._items.count(item)
+
+    def __repr__(self):
+        return '<FrozenList(frozen={}, {!r})>'.format(self.frozen,
+                                                      self._items)
+
+    def __hash__(self):
+        if self.frozen:
+            return hash(tuple(self._items))
+        else:
+            raise RuntimeError("Cannot hash unfrozen list.")
+
+
+MutableSequence.register(FrozenList)

.venv/lib/python3.11/site-packages/frozenlist/py.typed

@@ -0,0 +1 @@
+Marker

.venv/lib/python3.11/site-packages/googleapiclient/__init__.py

@@ -0,0 +1,27 @@
+# Copyright 2014 Google Inc. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Set default logging handler to avoid "No handler found" warnings.
+import logging
+
+try:  # Python 2.7+
+    from logging import NullHandler
+except ImportError:
+
+    class NullHandler(logging.Handler):
+        def emit(self, record):
+            pass
+
+
+logging.getLogger(__name__).addHandler(NullHandler())

.venv/lib/python3.11/site-packages/googleapiclient/_auth.py

@@ -0,0 +1,167 @@
+# Copyright 2016 Google Inc. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Helpers for authentication using oauth2client or google-auth."""
+
+import httplib2
+
+try:
+    import google.auth
+    import google.auth.credentials
+
+    HAS_GOOGLE_AUTH = True
+except ImportError:  # pragma: NO COVER
+    HAS_GOOGLE_AUTH = False
+
+try:
+    import google_auth_httplib2
+except ImportError:  # pragma: NO COVER
+    google_auth_httplib2 = None
+
+try:
+    import oauth2client
+    import oauth2client.client
+
+    HAS_OAUTH2CLIENT = True
+except ImportError:  # pragma: NO COVER
+    HAS_OAUTH2CLIENT = False
+
+
+def credentials_from_file(filename, scopes=None, quota_project_id=None):
+    """Returns credentials loaded from a file."""
+    if HAS_GOOGLE_AUTH:
+        credentials, _ = google.auth.load_credentials_from_file(
+            filename, scopes=scopes, quota_project_id=quota_project_id
+        )
+        return credentials
+    else:
+        raise EnvironmentError(
+            "client_options.credentials_file is only supported in google-auth."
+        )
+
+
+def default_credentials(scopes=None, quota_project_id=None):
+    """Returns Application Default Credentials."""
+    if HAS_GOOGLE_AUTH:
+        credentials, _ = google.auth.default(
+            scopes=scopes, quota_project_id=quota_project_id
+        )
+        return credentials
+    elif HAS_OAUTH2CLIENT:
+        if scopes is not None or quota_project_id is not None:
+            raise EnvironmentError(
+                "client_options.scopes and client_options.quota_project_id are not supported in oauth2client."
+                "Please install google-auth."
+            )
+        return oauth2client.client.GoogleCredentials.get_application_default()
+    else:
+        raise EnvironmentError(
+            "No authentication library is available. Please install either "
+            "google-auth or oauth2client."
+        )
+
+
+def with_scopes(credentials, scopes):
+    """Scopes the credentials if necessary.
+
+    Args:
+        credentials (Union[
+            google.auth.credentials.Credentials,
+            oauth2client.client.Credentials]): The credentials to scope.
+        scopes (Sequence[str]): The list of scopes.
+
+    Returns:
+        Union[google.auth.credentials.Credentials,
+            oauth2client.client.Credentials]: The scoped credentials.
+    """
+    if HAS_GOOGLE_AUTH and isinstance(credentials, google.auth.credentials.Credentials):
+        return google.auth.credentials.with_scopes_if_required(credentials, scopes)
+    else:
+        try:
+            if credentials.create_scoped_required():
+                return credentials.create_scoped(scopes)
+            else:
+                return credentials
+        except AttributeError:
+            return credentials
+
+
+def authorized_http(credentials):
+    """Returns an http client that is authorized with the given credentials.
+
+    Args:
+        credentials (Union[
+            google.auth.credentials.Credentials,
+            oauth2client.client.Credentials]): The credentials to use.
+
+    Returns:
+        Union[httplib2.Http, google_auth_httplib2.AuthorizedHttp]: An
+            authorized http client.
+    """
+    from googleapiclient.http import build_http
+
+    if HAS_GOOGLE_AUTH and isinstance(credentials, google.auth.credentials.Credentials):
+        if google_auth_httplib2 is None:
+            raise ValueError(
+                "Credentials from google.auth specified, but "
+                "google-api-python-client is unable to use these credentials "
+                "unless google-auth-httplib2 is installed. Please install "
+                "google-auth-httplib2."
+            )
+        return google_auth_httplib2.AuthorizedHttp(credentials, http=build_http())
+    else:
+        return credentials.authorize(build_http())
+
+
+def refresh_credentials(credentials):
+    # Refresh must use a new http instance, as the one associated with the
+    # credentials could be a AuthorizedHttp or an oauth2client-decorated
+    # Http instance which would cause a weird recursive loop of refreshing
+    # and likely tear a hole in spacetime.
+    refresh_http = httplib2.Http()
+    if HAS_GOOGLE_AUTH and isinstance(credentials, google.auth.credentials.Credentials):
+        request = google_auth_httplib2.Request(refresh_http)
+        return credentials.refresh(request)
+    else:
+        return credentials.refresh(refresh_http)
+
+
+def apply_credentials(credentials, headers):
+    # oauth2client and google-auth have the same interface for this.
+    if not is_valid(credentials):
+        refresh_credentials(credentials)
+    return credentials.apply(headers)
+
+
+def is_valid(credentials):
+    if HAS_GOOGLE_AUTH and isinstance(credentials, google.auth.credentials.Credentials):
+        return credentials.valid
+    else:
+        return (
+            credentials.access_token is not None
+            and not credentials.access_token_expired
+        )
+
+
+def get_credentials_from_http(http):
+    if http is None:
+        return None
+    elif hasattr(http.request, "credentials"):
+        return http.request.credentials
+    elif hasattr(http, "credentials") and not isinstance(
+        http.credentials, httplib2.Credentials
+    ):
+        return http.credentials
+    else:
+        return None

.venv/lib/python3.11/site-packages/googleapiclient/_helpers.py

@@ -0,0 +1,207 @@
+# Copyright 2015 Google Inc. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Helper functions for commonly used utilities."""
+
+import functools
+import inspect
+import logging
+import urllib
+
+logger = logging.getLogger(__name__)
+
+POSITIONAL_WARNING = "WARNING"
+POSITIONAL_EXCEPTION = "EXCEPTION"
+POSITIONAL_IGNORE = "IGNORE"
+POSITIONAL_SET = frozenset(
+    [POSITIONAL_WARNING, POSITIONAL_EXCEPTION, POSITIONAL_IGNORE]
+)
+
+positional_parameters_enforcement = POSITIONAL_WARNING
+
+_SYM_LINK_MESSAGE = "File: {0}: Is a symbolic link."
+_IS_DIR_MESSAGE = "{0}: Is a directory"
+_MISSING_FILE_MESSAGE = "Cannot access {0}: No such file or directory"
+
+
+def positional(max_positional_args):
+    """A decorator to declare that only the first N arguments may be positional.
+
+    This decorator makes it easy to support Python 3 style keyword-only
+    parameters. For example, in Python 3 it is possible to write::
+
+        def fn(pos1, *, kwonly1=None, kwonly2=None):
+            ...
+
+    All named parameters after ``*`` must be a keyword::
+
+        fn(10, 'kw1', 'kw2')  # Raises exception.
+        fn(10, kwonly1='kw1')  # Ok.
+
+    Example
+    ^^^^^^^
+
+    To define a function like above, do::
+
+        @positional(1)
+        def fn(pos1, kwonly1=None, kwonly2=None):
+            ...
+
+    If no default value is provided to a keyword argument, it becomes a
+    required keyword argument::
+
+        @positional(0)
+        def fn(required_kw):
+            ...
+
+    This must be called with the keyword parameter::
+
+        fn()  # Raises exception.
+        fn(10)  # Raises exception.
+        fn(required_kw=10)  # Ok.
+
+    When defining instance or class methods always remember to account for
+    ``self`` and ``cls``::
+
+        class MyClass(object):
+
+            @positional(2)
+            def my_method(self, pos1, kwonly1=None):
+                ...
+
+            @classmethod
+            @positional(2)
+            def my_method(cls, pos1, kwonly1=None):
+                ...
+
+    The positional decorator behavior is controlled by
+    ``_helpers.positional_parameters_enforcement``, which may be set to
+    ``POSITIONAL_EXCEPTION``, ``POSITIONAL_WARNING`` or
+    ``POSITIONAL_IGNORE`` to raise an exception, log a warning, or do
+    nothing, respectively, if a declaration is violated.
+
+    Args:
+        max_positional_arguments: Maximum number of positional arguments. All
+                                  parameters after this index must be
+                                  keyword only.
+
+    Returns:
+        A decorator that prevents using arguments after max_positional_args
+        from being used as positional parameters.
+
+    Raises:
+        TypeError: if a keyword-only argument is provided as a positional
+                   parameter, but only if
+                   _helpers.positional_parameters_enforcement is set to
+                   POSITIONAL_EXCEPTION.
+    """
+
+    def positional_decorator(wrapped):
+        @functools.wraps(wrapped)
+        def positional_wrapper(*args, **kwargs):
+            if len(args) > max_positional_args:
+                plural_s = ""
+                if max_positional_args != 1:
+                    plural_s = "s"
+                message = (
+                    "{function}() takes at most {args_max} positional "
+                    "argument{plural} ({args_given} given)".format(
+                        function=wrapped.__name__,
+                        args_max=max_positional_args,
+                        args_given=len(args),
+                        plural=plural_s,
+                    )
+                )
+                if positional_parameters_enforcement == POSITIONAL_EXCEPTION:
+                    raise TypeError(message)
+                elif positional_parameters_enforcement == POSITIONAL_WARNING:
+                    logger.warning(message)
+            return wrapped(*args, **kwargs)
+
+        return positional_wrapper
+
+    if isinstance(max_positional_args, int):
+        return positional_decorator
+    else:
+        args, _, _, defaults, _, _, _ = inspect.getfullargspec(max_positional_args)
+        return positional(len(args) - len(defaults))(max_positional_args)
+
+
+def parse_unique_urlencoded(content):
+    """Parses unique key-value parameters from urlencoded content.
+
+    Args:
+        content: string, URL-encoded key-value pairs.
+
+    Returns:
+        dict, The key-value pairs from ``content``.
+
+    Raises:
+        ValueError: if one of the keys is repeated.
+    """
+    urlencoded_params = urllib.parse.parse_qs(content)
+    params = {}
+    for key, value in urlencoded_params.items():
+        if len(value) != 1:
+            msg = "URL-encoded content contains a repeated value:" "%s -> %s" % (
+                key,
+                ", ".join(value),
+            )
+            raise ValueError(msg)
+        params[key] = value[0]
+    return params
+
+
+def update_query_params(uri, params):
+    """Updates a URI with new query parameters.
+
+    If a given key from ``params`` is repeated in the ``uri``, then
+    the URI will be considered invalid and an error will occur.
+
+    If the URI is valid, then each value from ``params`` will
+    replace the corresponding value in the query parameters (if
+    it exists).
+
+    Args:
+        uri: string, A valid URI, with potential existing query parameters.
+        params: dict, A dictionary of query parameters.
+
+    Returns:
+        The same URI but with the new query parameters added.
+    """
+    parts = urllib.parse.urlparse(uri)
+    query_params = parse_unique_urlencoded(parts.query)
+    query_params.update(params)
+    new_query = urllib.parse.urlencode(query_params)
+    new_parts = parts._replace(query=new_query)
+    return urllib.parse.urlunparse(new_parts)
+
+
+def _add_query_parameter(url, name, value):
+    """Adds a query parameter to a url.
+
+    Replaces the current value if it already exists in the URL.
+
+    Args:
+        url: string, url to add the query parameter to.
+        name: string, query parameter name.
+        value: string, query parameter value.
+
+    Returns:
+        Updated query parameter. Does not update the url if value is None.
+    """
+    if value is None:
+        return url
+    else:
+        return update_query_params(url, {name: value})

.venv/lib/python3.11/site-packages/googleapiclient/channel.py

@@ -0,0 +1,315 @@
+# Copyright 2014 Google Inc. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Channel notifications support.
+
+Classes and functions to support channel subscriptions and notifications
+on those channels.
+
+Notes:
+  - This code is based on experimental APIs and is subject to change.
+  - Notification does not do deduplication of notification ids, that's up to
+    the receiver.
+  - Storing the Channel between calls is up to the caller.
+
+
+Example setting up a channel:
+
+  # Create a new channel that gets notifications via webhook.
+  channel = new_webhook_channel("https://example.com/my_web_hook")
+
+  # Store the channel, keyed by 'channel.id'. Store it before calling the
+  # watch method because notifications may start arriving before the watch
+  # method returns.
+  ...
+
+  resp = service.objects().watchAll(
+    bucket="some_bucket_id", body=channel.body()).execute()
+  channel.update(resp)
+
+  # Store the channel, keyed by 'channel.id'. Store it after being updated
+  # since the resource_id value will now be correct, and that's needed to
+  # stop a subscription.
+  ...
+
+
+An example Webhook implementation using webapp2. Note that webapp2 puts
+headers in a case insensitive dictionary, as headers aren't guaranteed to
+always be upper case.
+
+  id = self.request.headers[X_GOOG_CHANNEL_ID]
+
+  # Retrieve the channel by id.
+  channel = ...
+
+  # Parse notification from the headers, including validating the id.
+  n = notification_from_headers(channel, self.request.headers)
+
+  # Do app specific stuff with the notification here.
+  if n.resource_state == 'sync':
+    # Code to handle sync state.
+  elif n.resource_state == 'exists':
+    # Code to handle the exists state.
+  elif n.resource_state == 'not_exists':
+    # Code to handle the not exists state.
+
+
+Example of unsubscribing.
+
+  service.channels().stop(channel.body()).execute()
+"""
+from __future__ import absolute_import
+
+import datetime
+import uuid
+
+from googleapiclient import _helpers as util
+from googleapiclient import errors
+
+# The unix time epoch starts at midnight 1970.
+EPOCH = datetime.datetime(1970, 1, 1)
+
+# Map the names of the parameters in the JSON channel description to
+# the parameter names we use in the Channel class.
+CHANNEL_PARAMS = {
+    "address": "address",
+    "id": "id",
+    "expiration": "expiration",
+    "params": "params",
+    "resourceId": "resource_id",
+    "resourceUri": "resource_uri",
+    "type": "type",
+    "token": "token",
+}
+
+X_GOOG_CHANNEL_ID = "X-GOOG-CHANNEL-ID"
+X_GOOG_MESSAGE_NUMBER = "X-GOOG-MESSAGE-NUMBER"
+X_GOOG_RESOURCE_STATE = "X-GOOG-RESOURCE-STATE"
+X_GOOG_RESOURCE_URI = "X-GOOG-RESOURCE-URI"
+X_GOOG_RESOURCE_ID = "X-GOOG-RESOURCE-ID"
+
+
+def _upper_header_keys(headers):
+    new_headers = {}
+    for k, v in headers.items():
+        new_headers[k.upper()] = v
+    return new_headers
+
+
+class Notification(object):
+    """A Notification from a Channel.
+
+    Notifications are not usually constructed directly, but are returned
+    from functions like notification_from_headers().
+
+    Attributes:
+      message_number: int, The unique id number of this notification.
+      state: str, The state of the resource being monitored.
+      uri: str, The address of the resource being monitored.
+      resource_id: str, The unique identifier of the version of the resource at
+        this event.
+    """
+
+    @util.positional(5)
+    def __init__(self, message_number, state, resource_uri, resource_id):
+        """Notification constructor.
+
+        Args:
+          message_number: int, The unique id number of this notification.
+          state: str, The state of the resource being monitored. Can be one
+            of "exists", "not_exists", or "sync".
+          resource_uri: str, The address of the resource being monitored.
+          resource_id: str, The identifier of the watched resource.
+        """
+        self.message_number = message_number
+        self.state = state
+        self.resource_uri = resource_uri
+        self.resource_id = resource_id
+
+
+class Channel(object):
+    """A Channel for notifications.
+
+    Usually not constructed directly, instead it is returned from helper
+    functions like new_webhook_channel().
+
+    Attributes:
+      type: str, The type of delivery mechanism used by this channel. For
+        example, 'web_hook'.
+      id: str, A UUID for the channel.
+      token: str, An arbitrary string associated with the channel that
+        is delivered to the target address with each event delivered
+        over this channel.
+      address: str, The address of the receiving entity where events are
+        delivered. Specific to the channel type.
+      expiration: int, The time, in milliseconds from the epoch, when this
+        channel will expire.
+      params: dict, A dictionary of string to string, with additional parameters
+        controlling delivery channel behavior.
+      resource_id: str, An opaque id that identifies the resource that is
+        being watched. Stable across different API versions.
+      resource_uri: str, The canonicalized ID of the watched resource.
+    """
+
+    @util.positional(5)
+    def __init__(
+        self,
+        type,
+        id,
+        token,
+        address,
+        expiration=None,
+        params=None,
+        resource_id="",
+        resource_uri="",
+    ):
+        """Create a new Channel.
+
+        In user code, this Channel constructor will not typically be called
+        manually since there are functions for creating channels for each specific
+        type with a more customized set of arguments to pass.
+
+        Args:
+          type: str, The type of delivery mechanism used by this channel. For
+            example, 'web_hook'.
+          id: str, A UUID for the channel.
+          token: str, An arbitrary string associated with the channel that
+            is delivered to the target address with each event delivered
+            over this channel.
+          address: str,  The address of the receiving entity where events are
+            delivered. Specific to the channel type.
+          expiration: int, The time, in milliseconds from the epoch, when this
+            channel will expire.
+          params: dict, A dictionary of string to string, with additional parameters
+            controlling delivery channel behavior.
+          resource_id: str, An opaque id that identifies the resource that is
+            being watched. Stable across different API versions.
+          resource_uri: str, The canonicalized ID of the watched resource.
+        """
+        self.type = type
+        self.id = id
+        self.token = token
+        self.address = address
+        self.expiration = expiration
+        self.params = params
+        self.resource_id = resource_id
+        self.resource_uri = resource_uri
+
+    def body(self):
+        """Build a body from the Channel.
+
+        Constructs a dictionary that's appropriate for passing into watch()
+        methods as the value of body argument.
+
+        Returns:
+          A dictionary representation of the channel.
+        """
+        result = {
+            "id": self.id,
+            "token": self.token,
+            "type": self.type,
+            "address": self.address,
+        }
+        if self.params:
+            result["params"] = self.params
+        if self.resource_id:
+            result["resourceId"] = self.resource_id
+        if self.resource_uri:
+            result["resourceUri"] = self.resource_uri
+        if self.expiration:
+            result["expiration"] = self.expiration
+
+        return result
+
+    def update(self, resp):
+        """Update a channel with information from the response of watch().
+
+        When a request is sent to watch() a resource, the response returned
+        from the watch() request is a dictionary with updated channel information,
+        such as the resource_id, which is needed when stopping a subscription.
+
+        Args:
+          resp: dict, The response from a watch() method.
+        """
+        for json_name, param_name in CHANNEL_PARAMS.items():
+            value = resp.get(json_name)
+            if value is not None:
+                setattr(self, param_name, value)
+
+
+def notification_from_headers(channel, headers):
+    """Parse a notification from the webhook request headers, validate
+      the notification, and return a Notification object.
+
+    Args:
+      channel: Channel, The channel that the notification is associated with.
+      headers: dict, A dictionary like object that contains the request headers
+        from the webhook HTTP request.
+
+    Returns:
+      A Notification object.
+
+    Raises:
+      errors.InvalidNotificationError if the notification is invalid.
+      ValueError if the X-GOOG-MESSAGE-NUMBER can't be converted to an int.
+    """
+    headers = _upper_header_keys(headers)
+    channel_id = headers[X_GOOG_CHANNEL_ID]
+    if channel.id != channel_id:
+        raise errors.InvalidNotificationError(
+            "Channel id mismatch: %s != %s" % (channel.id, channel_id)
+        )
+    else:
+        message_number = int(headers[X_GOOG_MESSAGE_NUMBER])
+        state = headers[X_GOOG_RESOURCE_STATE]
+        resource_uri = headers[X_GOOG_RESOURCE_URI]
+        resource_id = headers[X_GOOG_RESOURCE_ID]
+        return Notification(message_number, state, resource_uri, resource_id)
+
+
+@util.positional(2)
+def new_webhook_channel(url, token=None, expiration=None, params=None):
+    """Create a new webhook Channel.
+
+    Args:
+      url: str, URL to post notifications to.
+      token: str, An arbitrary string associated with the channel that
+        is delivered to the target address with each notification delivered
+        over this channel.
+      expiration: datetime.datetime, A time in the future when the channel
+        should expire. Can also be None if the subscription should use the
+        default expiration. Note that different services may have different
+        limits on how long a subscription lasts. Check the response from the
+        watch() method to see the value the service has set for an expiration
+        time.
+      params: dict, Extra parameters to pass on channel creation. Currently
+        not used for webhook channels.
+    """
+    expiration_ms = 0
+    if expiration:
+        delta = expiration - EPOCH
+        expiration_ms = (
+            delta.microseconds / 1000 + (delta.seconds + delta.days * 24 * 3600) * 1000
+        )
+        if expiration_ms < 0:
+            expiration_ms = 0
+
+    return Channel(
+        "web_hook",
+        str(uuid.uuid4()),
+        token,
+        url,
+        expiration=expiration_ms,
+        params=params,
+    )

.venv/lib/python3.11/site-packages/googleapiclient/discovery.py

@@ -0,0 +1,1662 @@
+# Copyright 2014 Google Inc. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Client for discovery based APIs.
+
+A client library for Google's discovery based APIs.
+"""
+from __future__ import absolute_import
+
+__author__ = "jcgregorio@google.com (Joe Gregorio)"
+__all__ = ["build", "build_from_document", "fix_method_name", "key2param"]
+
+from collections import OrderedDict
+import collections.abc
+
+# Standard library imports
+import copy
+from email.generator import BytesGenerator
+from email.mime.multipart import MIMEMultipart
+from email.mime.nonmultipart import MIMENonMultipart
+import http.client as http_client
+import io
+import json
+import keyword
+import logging
+import mimetypes
+import os
+import re
+import urllib
+
+import google.api_core.client_options
+from google.auth.exceptions import MutualTLSChannelError
+from google.auth.transport import mtls
+from google.oauth2 import service_account
+
+# Third-party imports
+import httplib2
+import uritemplate
+
+try:
+    import google_auth_httplib2
+except ImportError:  # pragma: NO COVER
+    google_auth_httplib2 = None
+
+try:
+    from google.api_core import universe
+
+    HAS_UNIVERSE = True
+except ImportError:
+    HAS_UNIVERSE = False
+
+# Local imports
+from googleapiclient import _auth, mimeparse
+from googleapiclient._helpers import _add_query_parameter, positional
+from googleapiclient.errors import (
+    HttpError,
+    InvalidJsonError,
+    MediaUploadSizeError,
+    UnacceptableMimeTypeError,
+    UnknownApiNameOrVersion,
+    UnknownFileType,
+)
+from googleapiclient.http import (
+    BatchHttpRequest,
+    HttpMock,
+    HttpMockSequence,
+    HttpRequest,
+    MediaFileUpload,
+    MediaUpload,
+    build_http,
+)
+from googleapiclient.model import JsonModel, MediaModel, RawModel
+from googleapiclient.schema import Schemas
+
+# The client library requires a version of httplib2 that supports RETRIES.
+httplib2.RETRIES = 1
+
+logger = logging.getLogger(__name__)
+
+URITEMPLATE = re.compile("{[^}]*}")
+VARNAME = re.compile("[a-zA-Z0-9_-]+")
+DISCOVERY_URI = (
+    "https://www.googleapis.com/discovery/v1/apis/" "{api}/{apiVersion}/rest"
+)
+V1_DISCOVERY_URI = DISCOVERY_URI
+V2_DISCOVERY_URI = (
+    "https://{api}.googleapis.com/$discovery/rest?" "version={apiVersion}"
+)
+DEFAULT_METHOD_DOC = "A description of how to use this function"
+HTTP_PAYLOAD_METHODS = frozenset(["PUT", "POST", "PATCH"])
+
+_MEDIA_SIZE_BIT_SHIFTS = {"KB": 10, "MB": 20, "GB": 30, "TB": 40}
+BODY_PARAMETER_DEFAULT_VALUE = {"description": "The request body.", "type": "object"}
+MEDIA_BODY_PARAMETER_DEFAULT_VALUE = {
+    "description": (
+        "The filename of the media request body, or an instance "
+        "of a MediaUpload object."
+    ),
+    "type": "string",
+    "required": False,
+}
+MEDIA_MIME_TYPE_PARAMETER_DEFAULT_VALUE = {
+    "description": (
+        "The MIME type of the media request body, or an instance "
+        "of a MediaUpload object."
+    ),
+    "type": "string",
+    "required": False,
+}
+_PAGE_TOKEN_NAMES = ("pageToken", "nextPageToken")
+
+# Parameters controlling mTLS behavior. See https://google.aip.dev/auth/4114.
+GOOGLE_API_USE_CLIENT_CERTIFICATE = "GOOGLE_API_USE_CLIENT_CERTIFICATE"
+GOOGLE_API_USE_MTLS_ENDPOINT = "GOOGLE_API_USE_MTLS_ENDPOINT"
+GOOGLE_CLOUD_UNIVERSE_DOMAIN = "GOOGLE_CLOUD_UNIVERSE_DOMAIN"
+DEFAULT_UNIVERSE = "googleapis.com"
+# Parameters accepted by the stack, but not visible via discovery.
+# TODO(dhermes): Remove 'userip' in 'v2'.
+STACK_QUERY_PARAMETERS = frozenset(["trace", "pp", "userip", "strict"])
+STACK_QUERY_PARAMETER_DEFAULT_VALUE = {"type": "string", "location": "query"}
+
+
+class APICoreVersionError(ValueError):
+    def __init__(self):
+        message = (
+            "google-api-core >= 2.18.0 is required to use the universe domain feature."
+        )
+        super().__init__(message)
+
+
+# Library-specific reserved words beyond Python keywords.
+RESERVED_WORDS = frozenset(["body"])
+
+# patch _write_lines to avoid munging '\r' into '\n'
+# ( https://bugs.python.org/issue18886 https://bugs.python.org/issue19003 )
+class _BytesGenerator(BytesGenerator):
+    _write_lines = BytesGenerator.write
+
+
+def fix_method_name(name):
+    """Fix method names to avoid '$' characters and reserved word conflicts.
+
+    Args:
+      name: string, method name.
+
+    Returns:
+      The name with '_' appended if the name is a reserved word and '$' and '-'
+      replaced with '_'.
+    """
+    name = name.replace("$", "_").replace("-", "_")
+    if keyword.iskeyword(name) or name in RESERVED_WORDS:
+        return name + "_"
+    else:
+        return name
+
+
+def key2param(key):
+    """Converts key names into parameter names.
+
+    For example, converting "max-results" -> "max_results"
+
+    Args:
+      key: string, the method key name.
+
+    Returns:
+      A safe method name based on the key name.
+    """
+    result = []
+    key = list(key)
+    if not key[0].isalpha():
+        result.append("x")
+    for c in key:
+        if c.isalnum():
+            result.append(c)
+        else:
+            result.append("_")
+
+    return "".join(result)
+
+
+@positional(2)
+def build(
+    serviceName,
+    version,
+    http=None,
+    discoveryServiceUrl=None,
+    developerKey=None,
+    model=None,
+    requestBuilder=HttpRequest,
+    credentials=None,
+    cache_discovery=True,
+    cache=None,
+    client_options=None,
+    adc_cert_path=None,
+    adc_key_path=None,
+    num_retries=1,
+    static_discovery=None,
+    always_use_jwt_access=False,
+):
+    """Construct a Resource for interacting with an API.
+
+    Construct a Resource object for interacting with an API. The serviceName and
+    version are the names from the Discovery service.
+
+    Args:
+      serviceName: string, name of the service.
+      version: string, the version of the service.
+      http: httplib2.Http, An instance of httplib2.Http or something that acts
+        like it that HTTP requests will be made through.
+      discoveryServiceUrl: string, a URI Template that points to the location of
+        the discovery service. It should have two parameters {api} and
+        {apiVersion} that when filled in produce an absolute URI to the discovery
+        document for that service.
+      developerKey: string, key obtained from
+        https://code.google.com/apis/console.
+      model: googleapiclient.Model, converts to and from the wire format.
+      requestBuilder: googleapiclient.http.HttpRequest, encapsulator for an HTTP
+        request.
+      credentials: oauth2client.Credentials or
+        google.auth.credentials.Credentials, credentials to be used for
+        authentication.
+      cache_discovery: Boolean, whether or not to cache the discovery doc.
+      cache: googleapiclient.discovery_cache.base.CacheBase, an optional
+        cache object for the discovery documents.
+      client_options: Mapping object or google.api_core.client_options, client
+        options to set user options on the client.
+        (1) The API endpoint should be set through client_options. If API endpoint
+        is not set, `GOOGLE_API_USE_MTLS_ENDPOINT` environment variable can be used
+        to control which endpoint to use.
+        (2) client_cert_source is not supported, client cert should be provided using
+        client_encrypted_cert_source instead. In order to use the provided client
+        cert, `GOOGLE_API_USE_CLIENT_CERTIFICATE` environment variable must be
+        set to `true`.
+        More details on the environment variables are here:
+        https://google.aip.dev/auth/4114
+      adc_cert_path: str, client certificate file path to save the application
+        default client certificate for mTLS. This field is required if you want to
+        use the default client certificate. `GOOGLE_API_USE_CLIENT_CERTIFICATE`
+        environment variable must be set to `true` in order to use this field,
+        otherwise this field doesn't nothing.
+        More details on the environment variables are here:
+        https://google.aip.dev/auth/4114
+      adc_key_path: str, client encrypted private key file path to save the
+        application default client encrypted private key for mTLS. This field is
+        required if you want to use the default client certificate.
+        `GOOGLE_API_USE_CLIENT_CERTIFICATE` environment variable must be set to
+        `true` in order to use this field, otherwise this field doesn't nothing.
+        More details on the environment variables are here:
+        https://google.aip.dev/auth/4114
+      num_retries: Integer, number of times to retry discovery with
+        randomized exponential backoff in case of intermittent/connection issues.
+      static_discovery: Boolean, whether or not to use the static discovery docs
+        included in the library. The default value for `static_discovery` depends
+        on the value of `discoveryServiceUrl`. `static_discovery` will default to
+        `True` when `discoveryServiceUrl` is also not provided, otherwise it will
+        default to `False`.
+      always_use_jwt_access: Boolean, whether always use self signed JWT for service
+        account credentials. This only applies to
+        google.oauth2.service_account.Credentials.
+
+    Returns:
+      A Resource object with methods for interacting with the service.
+
+    Raises:
+      google.auth.exceptions.MutualTLSChannelError: if there are any problems
+        setting up mutual TLS channel.
+    """
+    params = {"api": serviceName, "apiVersion": version}
+
+    # The default value for `static_discovery` depends on the value of
+    # `discoveryServiceUrl`. `static_discovery` will default to `True` when
+    # `discoveryServiceUrl` is also not provided, otherwise it will default to
+    # `False`. This is added for backwards compatability with
+    # google-api-python-client 1.x which does not support the `static_discovery`
+    # parameter.
+    if static_discovery is None:
+        if discoveryServiceUrl is None:
+            static_discovery = True
+        else:
+            static_discovery = False
+
+    if http is None:
+        discovery_http = build_http()
+    else:
+        discovery_http = http
+
+    service = None
+
+    for discovery_url in _discovery_service_uri_options(discoveryServiceUrl, version):
+        requested_url = uritemplate.expand(discovery_url, params)
+
+        try:
+            content = _retrieve_discovery_doc(
+                requested_url,
+                discovery_http,
+                cache_discovery,
+                serviceName,
+                version,
+                cache,
+                developerKey,
+                num_retries=num_retries,
+                static_discovery=static_discovery,
+            )
+            service = build_from_document(
+                content,
+                base=discovery_url,
+                http=http,
+                developerKey=developerKey,
+                model=model,
+                requestBuilder=requestBuilder,
+                credentials=credentials,
+                client_options=client_options,
+                adc_cert_path=adc_cert_path,
+                adc_key_path=adc_key_path,
+                always_use_jwt_access=always_use_jwt_access,
+            )
+            break  # exit if a service was created
+        except HttpError as e:
+            if e.resp.status == http_client.NOT_FOUND:
+                continue
+            else:
+                raise e
+
+    # If discovery_http was created by this function, we are done with it
+    # and can safely close it
+    if http is None:
+        discovery_http.close()
+
+    if service is None:
+        raise UnknownApiNameOrVersion("name: %s  version: %s" % (serviceName, version))
+    else:
+        return service
+
+
+def _discovery_service_uri_options(discoveryServiceUrl, version):
+    """
+      Returns Discovery URIs to be used for attempting to build the API Resource.
+
+    Args:
+      discoveryServiceUrl:
+          string, the Original Discovery Service URL preferred by the customer.
+      version:
+          string, API Version requested
+
+    Returns:
+        A list of URIs to be tried for the Service Discovery, in order.
+    """
+
+    if discoveryServiceUrl is not None:
+        return [discoveryServiceUrl]
+    if version is None:
+        # V1 Discovery won't work if the requested version is None
+        logger.warning(
+            "Discovery V1 does not support empty versions. Defaulting to V2..."
+        )
+        return [V2_DISCOVERY_URI]
+    else:
+        return [DISCOVERY_URI, V2_DISCOVERY_URI]
+
+
+def _retrieve_discovery_doc(
+    url,
+    http,
+    cache_discovery,
+    serviceName,
+    version,
+    cache=None,
+    developerKey=None,
+    num_retries=1,
+    static_discovery=True,
+):
+    """Retrieves the discovery_doc from cache or the internet.
+
+    Args:
+      url: string, the URL of the discovery document.
+      http: httplib2.Http, An instance of httplib2.Http or something that acts
+        like it through which HTTP requests will be made.
+      cache_discovery: Boolean, whether or not to cache the discovery doc.
+      serviceName: string, name of the service.
+      version: string, the version of the service.
+      cache: googleapiclient.discovery_cache.base.Cache, an optional cache
+        object for the discovery documents.
+      developerKey: string, Key for controlling API usage, generated
+        from the API Console.
+      num_retries: Integer, number of times to retry discovery with
+        randomized exponential backoff in case of intermittent/connection issues.
+      static_discovery: Boolean, whether or not to use the static discovery docs
+        included in the library.
+
+    Returns:
+      A unicode string representation of the discovery document.
+    """
+    from . import discovery_cache
+
+    if cache_discovery:
+        if cache is None:
+            cache = discovery_cache.autodetect()
+        if cache:
+            content = cache.get(url)
+            if content:
+                return content
+
+    # When `static_discovery=True`, use static discovery artifacts included
+    # with the library
+    if static_discovery:
+        content = discovery_cache.get_static_doc(serviceName, version)
+        if content:
+            return content
+        else:
+            raise UnknownApiNameOrVersion(
+                "name: %s  version: %s" % (serviceName, version)
+            )
+
+    actual_url = url
+    # REMOTE_ADDR is defined by the CGI spec [RFC3875] as the environment
+    # variable that contains the network address of the client sending the
+    # request. If it exists then add that to the request for the discovery
+    # document to avoid exceeding the quota on discovery requests.
+    if "REMOTE_ADDR" in os.environ:
+        actual_url = _add_query_parameter(url, "userIp", os.environ["REMOTE_ADDR"])
+    if developerKey:
+        actual_url = _add_query_parameter(url, "key", developerKey)
+    logger.debug("URL being requested: GET %s", actual_url)
+
+    # Execute this request with retries build into HttpRequest
+    # Note that it will already raise an error if we don't get a 2xx response
+    req = HttpRequest(http, HttpRequest.null_postproc, actual_url)
+    resp, content = req.execute(num_retries=num_retries)
+
+    try:
+        content = content.decode("utf-8")
+    except AttributeError:
+        pass
+
+    try:
+        service = json.loads(content)
+    except ValueError as e:
+        logger.error("Failed to parse as JSON: " + content)
+        raise InvalidJsonError()
+    if cache_discovery and cache:
+        cache.set(url, content)
+    return content
+
+
+def _check_api_core_compatible_with_credentials_universe(credentials):
+    if not HAS_UNIVERSE:
+        credentials_universe = getattr(credentials, "universe_domain", None)
+        if credentials_universe and credentials_universe != DEFAULT_UNIVERSE:
+            raise APICoreVersionError
+
+
+@positional(1)
+def build_from_document(
+    service,
+    base=None,
+    future=None,
+    http=None,
+    developerKey=None,
+    model=None,
+    requestBuilder=HttpRequest,
+    credentials=None,
+    client_options=None,
+    adc_cert_path=None,
+    adc_key_path=None,
+    always_use_jwt_access=False,
+):
+    """Create a Resource for interacting with an API.
+
+    Same as `build()`, but constructs the Resource object from a discovery
+    document that is it given, as opposed to retrieving one over HTTP.
+
+    Args:
+      service: string or object, the JSON discovery document describing the API.
+        The value passed in may either be the JSON string or the deserialized
+        JSON.
+      base: string, base URI for all HTTP requests, usually the discovery URI.
+        This parameter is no longer used as rootUrl and servicePath are included
+        within the discovery document. (deprecated)
+      future: string, discovery document with future capabilities (deprecated).
+      http: httplib2.Http, An instance of httplib2.Http or something that acts
+        like it that HTTP requests will be made through.
+      developerKey: string, Key for controlling API usage, generated
+        from the API Console.
+      model: Model class instance that serializes and de-serializes requests and
+        responses.
+      requestBuilder: Takes an http request and packages it up to be executed.
+      credentials: oauth2client.Credentials or
+        google.auth.credentials.Credentials, credentials to be used for
+        authentication.
+      client_options: Mapping object or google.api_core.client_options, client
+        options to set user options on the client.
+        (1) The API endpoint should be set through client_options. If API endpoint
+        is not set, `GOOGLE_API_USE_MTLS_ENDPOINT` environment variable can be used
+        to control which endpoint to use.
+        (2) client_cert_source is not supported, client cert should be provided using
+        client_encrypted_cert_source instead. In order to use the provided client
+        cert, `GOOGLE_API_USE_CLIENT_CERTIFICATE` environment variable must be
+        set to `true`.
+        More details on the environment variables are here:
+        https://google.aip.dev/auth/4114
+      adc_cert_path: str, client certificate file path to save the application
+        default client certificate for mTLS. This field is required if you want to
+        use the default client certificate. `GOOGLE_API_USE_CLIENT_CERTIFICATE`
+        environment variable must be set to `true` in order to use this field,
+        otherwise this field doesn't nothing.
+        More details on the environment variables are here:
+        https://google.aip.dev/auth/4114
+      adc_key_path: str, client encrypted private key file path to save the
+        application default client encrypted private key for mTLS. This field is
+        required if you want to use the default client certificate.
+        `GOOGLE_API_USE_CLIENT_CERTIFICATE` environment variable must be set to
+        `true` in order to use this field, otherwise this field doesn't nothing.
+        More details on the environment variables are here:
+        https://google.aip.dev/auth/4114
+      always_use_jwt_access: Boolean, whether always use self signed JWT for service
+        account credentials. This only applies to
+        google.oauth2.service_account.Credentials.
+
+    Returns:
+      A Resource object with methods for interacting with the service.
+
+    Raises:
+      google.auth.exceptions.MutualTLSChannelError: if there are any problems
+        setting up mutual TLS channel.
+    """
+
+    if client_options is None:
+        client_options = google.api_core.client_options.ClientOptions()
+    if isinstance(client_options, collections.abc.Mapping):
+        client_options = google.api_core.client_options.from_dict(client_options)
+
+    if http is not None:
+        # if http is passed, the user cannot provide credentials
+        banned_options = [
+            (credentials, "credentials"),
+            (client_options.credentials_file, "client_options.credentials_file"),
+        ]
+        for option, name in banned_options:
+            if option is not None:
+                raise ValueError(
+                    "Arguments http and {} are mutually exclusive".format(name)
+                )
+
+    if isinstance(service, str):
+        service = json.loads(service)
+    elif isinstance(service, bytes):
+        service = json.loads(service.decode("utf-8"))
+
+    if "rootUrl" not in service and isinstance(http, (HttpMock, HttpMockSequence)):
+        logger.error(
+            "You are using HttpMock or HttpMockSequence without"
+            + "having the service discovery doc in cache. Try calling "
+            + "build() without mocking once first to populate the "
+            + "cache."
+        )
+        raise InvalidJsonError()
+
+    # If an API Endpoint is provided on client options, use that as the base URL
+    base = urllib.parse.urljoin(service["rootUrl"], service["servicePath"])
+    universe_domain = None
+    if HAS_UNIVERSE:
+        universe_domain_env = os.getenv(GOOGLE_CLOUD_UNIVERSE_DOMAIN, None)
+        universe_domain = universe.determine_domain(
+            client_options.universe_domain, universe_domain_env
+        )
+        base = base.replace(universe.DEFAULT_UNIVERSE, universe_domain)
+    else:
+        client_universe = getattr(client_options, "universe_domain", None)
+        if client_universe:
+            raise APICoreVersionError
+
+    audience_for_self_signed_jwt = base
+    if client_options.api_endpoint:
+        base = client_options.api_endpoint
+
+    schema = Schemas(service)
+
+    # If the http client is not specified, then we must construct an http client
+    # to make requests. If the service has scopes, then we also need to setup
+    # authentication.
+    if http is None:
+        # Does the service require scopes?
+        scopes = list(
+            service.get("auth", {}).get("oauth2", {}).get("scopes", {}).keys()
+        )
+
+        # If so, then the we need to setup authentication if no developerKey is
+        # specified.
+        if scopes and not developerKey:
+            # Make sure the user didn't pass multiple credentials
+            if client_options.credentials_file and credentials:
+                raise google.api_core.exceptions.DuplicateCredentialArgs(
+                    "client_options.credentials_file and credentials are mutually exclusive."
+                )
+            # Check for credentials file via client options
+            if client_options.credentials_file:
+                credentials = _auth.credentials_from_file(
+                    client_options.credentials_file,
+                    scopes=client_options.scopes,
+                    quota_project_id=client_options.quota_project_id,
+                )
+            # If the user didn't pass in credentials, attempt to acquire application
+            # default credentials.
+            if credentials is None:
+                credentials = _auth.default_credentials(
+                    scopes=client_options.scopes,
+                    quota_project_id=client_options.quota_project_id,
+                )
+
+            # Check google-api-core >= 2.18.0 if credentials' universe != "googleapis.com".
+            _check_api_core_compatible_with_credentials_universe(credentials)
+
+            # The credentials need to be scoped.
+            # If the user provided scopes via client_options don't override them
+            if not client_options.scopes:
+                credentials = _auth.with_scopes(credentials, scopes)
+
+        # For google-auth service account credentials, enable self signed JWT if
+        # always_use_jwt_access is true.
+        if (
+            credentials
+            and isinstance(credentials, service_account.Credentials)
+            and always_use_jwt_access
+            and hasattr(service_account.Credentials, "with_always_use_jwt_access")
+        ):
+            credentials = credentials.with_always_use_jwt_access(always_use_jwt_access)
+            credentials._create_self_signed_jwt(audience_for_self_signed_jwt)
+
+        # If credentials are provided, create an authorized http instance;
+        # otherwise, skip authentication.
+        if credentials:
+            http = _auth.authorized_http(credentials)
+
+        # If the service doesn't require scopes then there is no need for
+        # authentication.
+        else:
+            http = build_http()
+
+        # Obtain client cert and create mTLS http channel if cert exists.
+        client_cert_to_use = None
+        use_client_cert = os.getenv(GOOGLE_API_USE_CLIENT_CERTIFICATE, "false")
+        if not use_client_cert in ("true", "false"):
+            raise MutualTLSChannelError(
+                "Unsupported GOOGLE_API_USE_CLIENT_CERTIFICATE value. Accepted values: true, false"
+            )
+        if client_options and client_options.client_cert_source:
+            raise MutualTLSChannelError(
+                "ClientOptions.client_cert_source is not supported, please use ClientOptions.client_encrypted_cert_source."
+            )
+        if use_client_cert == "true":
+            if (
+                client_options
+                and hasattr(client_options, "client_encrypted_cert_source")
+                and client_options.client_encrypted_cert_source
+            ):
+                client_cert_to_use = client_options.client_encrypted_cert_source
+            elif (
+                adc_cert_path and adc_key_path and mtls.has_default_client_cert_source()
+            ):
+                client_cert_to_use = mtls.default_client_encrypted_cert_source(
+                    adc_cert_path, adc_key_path
+                )
+        if client_cert_to_use:
+            cert_path, key_path, passphrase = client_cert_to_use()
+
+            # The http object we built could be google_auth_httplib2.AuthorizedHttp
+            # or httplib2.Http. In the first case we need to extract the wrapped
+            # httplib2.Http object from google_auth_httplib2.AuthorizedHttp.
+            http_channel = (
+                http.http
+                if google_auth_httplib2
+                and isinstance(http, google_auth_httplib2.AuthorizedHttp)
+                else http
+            )
+            http_channel.add_certificate(key_path, cert_path, "", passphrase)
+
+        # If user doesn't provide api endpoint via client options, decide which
+        # api endpoint to use.
+        if "mtlsRootUrl" in service and (
+            not client_options or not client_options.api_endpoint
+        ):
+            mtls_endpoint = urllib.parse.urljoin(
+                service["mtlsRootUrl"], service["servicePath"]
+            )
+            use_mtls_endpoint = os.getenv(GOOGLE_API_USE_MTLS_ENDPOINT, "auto")
+
+            if not use_mtls_endpoint in ("never", "auto", "always"):
+                raise MutualTLSChannelError(
+                    "Unsupported GOOGLE_API_USE_MTLS_ENDPOINT value. Accepted values: never, auto, always"
+                )
+
+            # Switch to mTLS endpoint, if environment variable is "always", or
+            # environment varibable is "auto" and client cert exists.
+            if use_mtls_endpoint == "always" or (
+                use_mtls_endpoint == "auto" and client_cert_to_use
+            ):
+                if HAS_UNIVERSE and universe_domain != universe.DEFAULT_UNIVERSE:
+                    raise MutualTLSChannelError(
+                        f"mTLS is not supported in any universe other than {universe.DEFAULT_UNIVERSE}."
+                    )
+                base = mtls_endpoint
+    else:
+        # Check google-api-core >= 2.18.0 if credentials' universe != "googleapis.com".
+        http_credentials = getattr(http, "credentials", None)
+        _check_api_core_compatible_with_credentials_universe(http_credentials)
+
+    if model is None:
+        features = service.get("features", [])
+        model = JsonModel("dataWrapper" in features)
+
+    return Resource(
+        http=http,
+        baseUrl=base,
+        model=model,
+        developerKey=developerKey,
+        requestBuilder=requestBuilder,
+        resourceDesc=service,
+        rootDesc=service,
+        schema=schema,
+        universe_domain=universe_domain,
+    )
+
+
+def _cast(value, schema_type):
+    """Convert value to a string based on JSON Schema type.
+
+    See http://tools.ietf.org/html/draft-zyp-json-schema-03 for more details on
+    JSON Schema.
+
+    Args:
+      value: any, the value to convert
+      schema_type: string, the type that value should be interpreted as
+
+    Returns:
+      A string representation of 'value' based on the schema_type.
+    """
+    if schema_type == "string":
+        if type(value) == type("") or type(value) == type(""):
+            return value
+        else:
+            return str(value)
+    elif schema_type == "integer":
+        return str(int(value))
+    elif schema_type == "number":
+        return str(float(value))
+    elif schema_type == "boolean":
+        return str(bool(value)).lower()
+    else:
+        if type(value) == type("") or type(value) == type(""):
+            return value
+        else:
+            return str(value)
+
+
+def _media_size_to_long(maxSize):
+    """Convert a string media size, such as 10GB or 3TB into an integer.
+
+    Args:
+      maxSize: string, size as a string, such as 2MB or 7GB.
+
+    Returns:
+      The size as an integer value.
+    """
+    if len(maxSize) < 2:
+        return 0
+    units = maxSize[-2:].upper()
+    bit_shift = _MEDIA_SIZE_BIT_SHIFTS.get(units)
+    if bit_shift is not None:
+        return int(maxSize[:-2]) << bit_shift
+    else:
+        return int(maxSize)
+
+
+def _media_path_url_from_info(root_desc, path_url):
+    """Creates an absolute media path URL.
+
+    Constructed using the API root URI and service path from the discovery
+    document and the relative path for the API method.
+
+    Args:
+      root_desc: Dictionary; the entire original deserialized discovery document.
+      path_url: String; the relative URL for the API method. Relative to the API
+          root, which is specified in the discovery document.
+
+    Returns:
+      String; the absolute URI for media upload for the API method.
+    """
+    return "%(root)supload/%(service_path)s%(path)s" % {
+        "root": root_desc["rootUrl"],
+        "service_path": root_desc["servicePath"],
+        "path": path_url,
+    }
+
+
+def _fix_up_parameters(method_desc, root_desc, http_method, schema):
+    """Updates parameters of an API method with values specific to this library.
+
+    Specifically, adds whatever global parameters are specified by the API to the
+    parameters for the individual method. Also adds parameters which don't
+    appear in the discovery document, but are available to all discovery based
+    APIs (these are listed in STACK_QUERY_PARAMETERS).
+
+    SIDE EFFECTS: This updates the parameters dictionary object in the method
+    description.
+
+    Args:
+      method_desc: Dictionary with metadata describing an API method. Value comes
+          from the dictionary of methods stored in the 'methods' key in the
+          deserialized discovery document.
+      root_desc: Dictionary; the entire original deserialized discovery document.
+      http_method: String; the HTTP method used to call the API method described
+          in method_desc.
+      schema: Object, mapping of schema names to schema descriptions.
+
+    Returns:
+      The updated Dictionary stored in the 'parameters' key of the method
+          description dictionary.
+    """
+    parameters = method_desc.setdefault("parameters", {})
+
+    # Add in the parameters common to all methods.
+    for name, description in root_desc.get("parameters", {}).items():
+        parameters[name] = description
+
+    # Add in undocumented query parameters.
+    for name in STACK_QUERY_PARAMETERS:
+        parameters[name] = STACK_QUERY_PARAMETER_DEFAULT_VALUE.copy()
+
+    # Add 'body' (our own reserved word) to parameters if the method supports
+    # a request payload.
+    if http_method in HTTP_PAYLOAD_METHODS and "request" in method_desc:
+        body = BODY_PARAMETER_DEFAULT_VALUE.copy()
+        body.update(method_desc["request"])
+        parameters["body"] = body
+
+    return parameters
+
+
+def _fix_up_media_upload(method_desc, root_desc, path_url, parameters):
+    """Adds 'media_body' and 'media_mime_type' parameters if supported by method.
+
+    SIDE EFFECTS: If there is a 'mediaUpload' in the method description, adds
+    'media_upload' key to parameters.
+
+    Args:
+      method_desc: Dictionary with metadata describing an API method. Value comes
+          from the dictionary of methods stored in the 'methods' key in the
+          deserialized discovery document.
+      root_desc: Dictionary; the entire original deserialized discovery document.
+      path_url: String; the relative URL for the API method. Relative to the API
+          root, which is specified in the discovery document.
+      parameters: A dictionary describing method parameters for method described
+          in method_desc.
+
+    Returns:
+      Triple (accept, max_size, media_path_url) where:
+        - accept is a list of strings representing what content types are
+          accepted for media upload. Defaults to empty list if not in the
+          discovery document.
+        - max_size is a long representing the max size in bytes allowed for a
+          media upload. Defaults to 0L if not in the discovery document.
+        - media_path_url is a String; the absolute URI for media upload for the
+          API method. Constructed using the API root URI and service path from
+          the discovery document and the relative path for the API method. If
+          media upload is not supported, this is None.
+    """
+    media_upload = method_desc.get("mediaUpload", {})
+    accept = media_upload.get("accept", [])
+    max_size = _media_size_to_long(media_upload.get("maxSize", ""))
+    media_path_url = None
+
+    if media_upload:
+        media_path_url = _media_path_url_from_info(root_desc, path_url)
+        parameters["media_body"] = MEDIA_BODY_PARAMETER_DEFAULT_VALUE.copy()
+        parameters["media_mime_type"] = MEDIA_MIME_TYPE_PARAMETER_DEFAULT_VALUE.copy()
+
+    return accept, max_size, media_path_url
+
+
+def _fix_up_method_description(method_desc, root_desc, schema):
+    """Updates a method description in a discovery document.
+
+    SIDE EFFECTS: Changes the parameters dictionary in the method description with
+    extra parameters which are used locally.
+
+    Args:
+      method_desc: Dictionary with metadata describing an API method. Value comes
+          from the dictionary of methods stored in the 'methods' key in the
+          deserialized discovery document.
+      root_desc: Dictionary; the entire original deserialized discovery document.
+      schema: Object, mapping of schema names to schema descriptions.
+
+    Returns:
+      Tuple (path_url, http_method, method_id, accept, max_size, media_path_url)
+      where:
+        - path_url is a String; the relative URL for the API method. Relative to
+          the API root, which is specified in the discovery document.
+        - http_method is a String; the HTTP method used to call the API method
+          described in the method description.
+        - method_id is a String; the name of the RPC method associated with the
+          API method, and is in the method description in the 'id' key.
+        - accept is a list of strings representing what content types are
+          accepted for media upload. Defaults to empty list if not in the
+          discovery document.
+        - max_size is a long representing the max size in bytes allowed for a
+          media upload. Defaults to 0L if not in the discovery document.
+        - media_path_url is a String; the absolute URI for media upload for the
+          API method. Constructed using the API root URI and service path from
+          the discovery document and the relative path for the API method. If
+          media upload is not supported, this is None.
+    """
+    path_url = method_desc["path"]
+    http_method = method_desc["httpMethod"]
+    method_id = method_desc["id"]
+
+    parameters = _fix_up_parameters(method_desc, root_desc, http_method, schema)
+    # Order is important. `_fix_up_media_upload` needs `method_desc` to have a
+    # 'parameters' key and needs to know if there is a 'body' parameter because it
+    # also sets a 'media_body' parameter.
+    accept, max_size, media_path_url = _fix_up_media_upload(
+        method_desc, root_desc, path_url, parameters
+    )
+
+    return path_url, http_method, method_id, accept, max_size, media_path_url
+
+
+def _fix_up_media_path_base_url(media_path_url, base_url):
+    """
+    Update the media upload base url if its netloc doesn't match base url netloc.
+
+    This can happen in case the base url was overridden by
+    client_options.api_endpoint.
+
+    Args:
+      media_path_url: String; the absolute URI for media upload.
+      base_url: string, base URL for the API. All requests are relative to this URI.
+
+    Returns:
+      String; the absolute URI for media upload.
+    """
+    parsed_media_url = urllib.parse.urlparse(media_path_url)
+    parsed_base_url = urllib.parse.urlparse(base_url)
+    if parsed_media_url.netloc == parsed_base_url.netloc:
+        return media_path_url
+    return urllib.parse.urlunparse(
+        parsed_media_url._replace(netloc=parsed_base_url.netloc)
+    )
+
+
+def _urljoin(base, url):
+    """Custom urljoin replacement supporting : before / in url."""
+    # In general, it's unsafe to simply join base and url. However, for
+    # the case of discovery documents, we know:
+    #  * base will never contain params, query, or fragment
+    #  * url will never contain a scheme or net_loc.
+    # In general, this means we can safely join on /; we just need to
+    # ensure we end up with precisely one / joining base and url. The
+    # exception here is the case of media uploads, where url will be an
+    # absolute url.
+    if url.startswith("http://") or url.startswith("https://"):
+        return urllib.parse.urljoin(base, url)
+    new_base = base if base.endswith("/") else base + "/"
+    new_url = url[1:] if url.startswith("/") else url
+    return new_base + new_url
+
+
+# TODO(dhermes): Convert this class to ResourceMethod and make it callable
+class ResourceMethodParameters(object):
+    """Represents the parameters associated with a method.
+
+    Attributes:
+      argmap: Map from method parameter name (string) to query parameter name
+          (string).
+      required_params: List of required parameters (represented by parameter
+          name as string).
+      repeated_params: List of repeated parameters (represented by parameter
+          name as string).
+      pattern_params: Map from method parameter name (string) to regular
+          expression (as a string). If the pattern is set for a parameter, the
+          value for that parameter must match the regular expression.
+      query_params: List of parameters (represented by parameter name as string)
+          that will be used in the query string.
+      path_params: Set of parameters (represented by parameter name as string)
+          that will be used in the base URL path.
+      param_types: Map from method parameter name (string) to parameter type. Type
+          can be any valid JSON schema type; valid values are 'any', 'array',
+          'boolean', 'integer', 'number', 'object', or 'string'. Reference:
+          http://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.1
+      enum_params: Map from method parameter name (string) to list of strings,
+         where each list of strings is the list of acceptable enum values.
+    """
+
+    def __init__(self, method_desc):
+        """Constructor for ResourceMethodParameters.
+
+        Sets default values and defers to set_parameters to populate.
+
+        Args:
+          method_desc: Dictionary with metadata describing an API method. Value
+              comes from the dictionary of methods stored in the 'methods' key in
+              the deserialized discovery document.
+        """
+        self.argmap = {}
+        self.required_params = []
+        self.repeated_params = []
+        self.pattern_params = {}
+        self.query_params = []
+        # TODO(dhermes): Change path_params to a list if the extra URITEMPLATE
+        #                parsing is gotten rid of.
+        self.path_params = set()
+        self.param_types = {}
+        self.enum_params = {}
+
+        self.set_parameters(method_desc)
+
+    def set_parameters(self, method_desc):
+        """Populates maps and lists based on method description.
+
+        Iterates through each parameter for the method and parses the values from
+        the parameter dictionary.
+
+        Args:
+          method_desc: Dictionary with metadata describing an API method. Value
+              comes from the dictionary of methods stored in the 'methods' key in
+              the deserialized discovery document.
+        """
+        parameters = method_desc.get("parameters", {})
+        sorted_parameters = OrderedDict(sorted(parameters.items()))
+        for arg, desc in sorted_parameters.items():
+            param = key2param(arg)
+            self.argmap[param] = arg
+
+            if desc.get("pattern"):
+                self.pattern_params[param] = desc["pattern"]
+            if desc.get("enum"):
+                self.enum_params[param] = desc["enum"]
+            if desc.get("required"):
+                self.required_params.append(param)
+            if desc.get("repeated"):
+                self.repeated_params.append(param)
+            if desc.get("location") == "query":
+                self.query_params.append(param)
+            if desc.get("location") == "path":
+                self.path_params.add(param)
+            self.param_types[param] = desc.get("type", "string")
+
+        # TODO(dhermes): Determine if this is still necessary. Discovery based APIs
+        #                should have all path parameters already marked with
+        #                'location: path'.
+        for match in URITEMPLATE.finditer(method_desc["path"]):
+            for namematch in VARNAME.finditer(match.group(0)):
+                name = key2param(namematch.group(0))
+                self.path_params.add(name)
+                if name in self.query_params:
+                    self.query_params.remove(name)
+
+
+def createMethod(methodName, methodDesc, rootDesc, schema):
+    """Creates a method for attaching to a Resource.
+
+    Args:
+      methodName: string, name of the method to use.
+      methodDesc: object, fragment of deserialized discovery document that
+        describes the method.
+      rootDesc: object, the entire deserialized discovery document.
+      schema: object, mapping of schema names to schema descriptions.
+    """
+    methodName = fix_method_name(methodName)
+    (
+        pathUrl,
+        httpMethod,
+        methodId,
+        accept,
+        maxSize,
+        mediaPathUrl,
+    ) = _fix_up_method_description(methodDesc, rootDesc, schema)
+
+    parameters = ResourceMethodParameters(methodDesc)
+
+    def method(self, **kwargs):
+        # Don't bother with doc string, it will be over-written by createMethod.
+
+        # Validate credentials for the configured universe.
+        self._validate_credentials()
+
+        for name in kwargs:
+            if name not in parameters.argmap:
+                raise TypeError("Got an unexpected keyword argument {}".format(name))
+
+        # Remove args that have a value of None.
+        keys = list(kwargs.keys())
+        for name in keys:
+            if kwargs[name] is None:
+                del kwargs[name]
+
+        for name in parameters.required_params:
+            if name not in kwargs:
+                # temporary workaround for non-paging methods incorrectly requiring
+                # page token parameter (cf. drive.changes.watch vs. drive.changes.list)
+                if name not in _PAGE_TOKEN_NAMES or _findPageTokenName(
+                    _methodProperties(methodDesc, schema, "response")
+                ):
+                    raise TypeError('Missing required parameter "%s"' % name)
+
+        for name, regex in parameters.pattern_params.items():
+            if name in kwargs:
+                if isinstance(kwargs[name], str):
+                    pvalues = [kwargs[name]]
+                else:
+                    pvalues = kwargs[name]
+                for pvalue in pvalues:
+                    if re.match(regex, pvalue) is None:
+                        raise TypeError(
+                            'Parameter "%s" value "%s" does not match the pattern "%s"'
+                            % (name, pvalue, regex)
+                        )
+
+        for name, enums in parameters.enum_params.items():
+            if name in kwargs:
+                # We need to handle the case of a repeated enum
+                # name differently, since we want to handle both
+                # arg='value' and arg=['value1', 'value2']
+                if name in parameters.repeated_params and not isinstance(
+                    kwargs[name], str
+                ):
+                    values = kwargs[name]
+                else:
+                    values = [kwargs[name]]
+                for value in values:
+                    if value not in enums:
+                        raise TypeError(
+                            'Parameter "%s" value "%s" is not an allowed value in "%s"'
+                            % (name, value, str(enums))
+                        )
+
+        actual_query_params = {}
+        actual_path_params = {}
+        for key, value in kwargs.items():
+            to_type = parameters.param_types.get(key, "string")
+            # For repeated parameters we cast each member of the list.
+            if key in parameters.repeated_params and type(value) == type([]):
+                cast_value = [_cast(x, to_type) for x in value]
+            else:
+                cast_value = _cast(value, to_type)
+            if key in parameters.query_params:
+                actual_query_params[parameters.argmap[key]] = cast_value
+            if key in parameters.path_params:
+                actual_path_params[parameters.argmap[key]] = cast_value
+        body_value = kwargs.get("body", None)
+        media_filename = kwargs.get("media_body", None)
+        media_mime_type = kwargs.get("media_mime_type", None)
+
+        if self._developerKey:
+            actual_query_params["key"] = self._developerKey
+
+        model = self._model
+        if methodName.endswith("_media"):
+            model = MediaModel()
+        elif "response" not in methodDesc:
+            model = RawModel()
+
+        api_version = methodDesc.get("apiVersion", None)
+
+        headers = {}
+        headers, params, query, body = model.request(
+            headers, actual_path_params, actual_query_params, body_value, api_version
+        )
+
+        expanded_url = uritemplate.expand(pathUrl, params)
+        url = _urljoin(self._baseUrl, expanded_url + query)
+
+        resumable = None
+        multipart_boundary = ""
+
+        if media_filename:
+            # Ensure we end up with a valid MediaUpload object.
+            if isinstance(media_filename, str):
+                if media_mime_type is None:
+                    logger.warning(
+                        "media_mime_type argument not specified: trying to auto-detect for %s",
+                        media_filename,
+                    )
+                    media_mime_type, _ = mimetypes.guess_type(media_filename)
+                if media_mime_type is None:
+                    raise UnknownFileType(media_filename)
+                if not mimeparse.best_match([media_mime_type], ",".join(accept)):
+                    raise UnacceptableMimeTypeError(media_mime_type)
+                media_upload = MediaFileUpload(media_filename, mimetype=media_mime_type)
+            elif isinstance(media_filename, MediaUpload):
+                media_upload = media_filename
+            else:
+                raise TypeError("media_filename must be str or MediaUpload.")
+
+            # Check the maxSize
+            if media_upload.size() is not None and media_upload.size() > maxSize > 0:
+                raise MediaUploadSizeError("Media larger than: %s" % maxSize)
+
+            # Use the media path uri for media uploads
+            expanded_url = uritemplate.expand(mediaPathUrl, params)
+            url = _urljoin(self._baseUrl, expanded_url + query)
+            url = _fix_up_media_path_base_url(url, self._baseUrl)
+            if media_upload.resumable():
+                url = _add_query_parameter(url, "uploadType", "resumable")
+
+            if media_upload.resumable():
+                # This is all we need to do for resumable, if the body exists it gets
+                # sent in the first request, otherwise an empty body is sent.
+                resumable = media_upload
+            else:
+                # A non-resumable upload
+                if body is None:
+                    # This is a simple media upload
+                    headers["content-type"] = media_upload.mimetype()
+                    body = media_upload.getbytes(0, media_upload.size())
+                    url = _add_query_parameter(url, "uploadType", "media")
+                else:
+                    # This is a multipart/related upload.
+                    msgRoot = MIMEMultipart("related")
+                    # msgRoot should not write out it's own headers
+                    setattr(msgRoot, "_write_headers", lambda self: None)
+
+                    # attach the body as one part
+                    msg = MIMENonMultipart(*headers["content-type"].split("/"))
+                    msg.set_payload(body)
+                    msgRoot.attach(msg)
+
+                    # attach the media as the second part
+                    msg = MIMENonMultipart(*media_upload.mimetype().split("/"))
+                    msg["Content-Transfer-Encoding"] = "binary"
+
+                    payload = media_upload.getbytes(0, media_upload.size())
+                    msg.set_payload(payload)
+                    msgRoot.attach(msg)
+                    # encode the body: note that we can't use `as_string`, because
+                    # it plays games with `From ` lines.
+                    fp = io.BytesIO()
+                    g = _BytesGenerator(fp, mangle_from_=False)
+                    g.flatten(msgRoot, unixfrom=False)
+                    body = fp.getvalue()
+
+                    multipart_boundary = msgRoot.get_boundary()
+                    headers["content-type"] = (
+                        "multipart/related; " 'boundary="%s"'
+                    ) % multipart_boundary
+                    url = _add_query_parameter(url, "uploadType", "multipart")
+
+        logger.debug("URL being requested: %s %s" % (httpMethod, url))
+        return self._requestBuilder(
+            self._http,
+            model.response,
+            url,
+            method=httpMethod,
+            body=body,
+            headers=headers,
+            methodId=methodId,
+            resumable=resumable,
+        )
+
+    docs = [methodDesc.get("description", DEFAULT_METHOD_DOC), "\n\n"]
+    if len(parameters.argmap) > 0:
+        docs.append("Args:\n")
+
+    # Skip undocumented params and params common to all methods.
+    skip_parameters = list(rootDesc.get("parameters", {}).keys())
+    skip_parameters.extend(STACK_QUERY_PARAMETERS)
+
+    all_args = list(parameters.argmap.keys())
+    args_ordered = [key2param(s) for s in methodDesc.get("parameterOrder", [])]
+
+    # Move body to the front of the line.
+    if "body" in all_args:
+        args_ordered.append("body")
+
+    for name in sorted(all_args):
+        if name not in args_ordered:
+            args_ordered.append(name)
+
+    for arg in args_ordered:
+        if arg in skip_parameters:
+            continue
+
+        repeated = ""
+        if arg in parameters.repeated_params:
+            repeated = " (repeated)"
+        required = ""
+        if arg in parameters.required_params:
+            required = " (required)"
+        paramdesc = methodDesc["parameters"][parameters.argmap[arg]]
+        paramdoc = paramdesc.get("description", "A parameter")
+        if "$ref" in paramdesc:
+            docs.append(
+                ("  %s: object, %s%s%s\n    The object takes the form of:\n\n%s\n\n")
+                % (
+                    arg,
+                    paramdoc,
+                    required,
+                    repeated,
+                    schema.prettyPrintByName(paramdesc["$ref"]),
+                )
+            )
+        else:
+            paramtype = paramdesc.get("type", "string")
+            docs.append(
+                "  %s: %s, %s%s%s\n" % (arg, paramtype, paramdoc, required, repeated)
+            )
+        enum = paramdesc.get("enum", [])
+        enumDesc = paramdesc.get("enumDescriptions", [])
+        if enum and enumDesc:
+            docs.append("    Allowed values\n")
+            for (name, desc) in zip(enum, enumDesc):
+                docs.append("      %s - %s\n" % (name, desc))
+    if "response" in methodDesc:
+        if methodName.endswith("_media"):
+            docs.append("\nReturns:\n  The media object as a string.\n\n    ")
+        else:
+            docs.append("\nReturns:\n  An object of the form:\n\n    ")
+            docs.append(schema.prettyPrintSchema(methodDesc["response"]))
+
+    setattr(method, "__doc__", "".join(docs))
+    return (methodName, method)
+
+
+def createNextMethod(
+    methodName,
+    pageTokenName="pageToken",
+    nextPageTokenName="nextPageToken",
+    isPageTokenParameter=True,
+):
+    """Creates any _next methods for attaching to a Resource.
+
+    The _next methods allow for easy iteration through list() responses.
+
+    Args:
+      methodName: string, name of the method to use.
+      pageTokenName: string, name of request page token field.
+      nextPageTokenName: string, name of response page token field.
+      isPageTokenParameter: Boolean, True if request page token is a query
+          parameter, False if request page token is a field of the request body.
+    """
+    methodName = fix_method_name(methodName)
+
+    def methodNext(self, previous_request, previous_response):
+        """Retrieves the next page of results.
+
+        Args:
+          previous_request: The request for the previous page. (required)
+          previous_response: The response from the request for the previous page. (required)
+
+        Returns:
+          A request object that you can call 'execute()' on to request the next
+          page. Returns None if there are no more items in the collection.
+        """
+        # Retrieve nextPageToken from previous_response
+        # Use as pageToken in previous_request to create new request.
+
+        nextPageToken = previous_response.get(nextPageTokenName, None)
+        if not nextPageToken:
+            return None
+
+        request = copy.copy(previous_request)
+
+        if isPageTokenParameter:
+            # Replace pageToken value in URI
+            request.uri = _add_query_parameter(
+                request.uri, pageTokenName, nextPageToken
+            )
+            logger.debug("Next page request URL: %s %s" % (methodName, request.uri))
+        else:
+            # Replace pageToken value in request body
+            model = self._model
+            body = model.deserialize(request.body)
+            body[pageTokenName] = nextPageToken
+            request.body = model.serialize(body)
+            request.body_size = len(request.body)
+            if "content-length" in request.headers:
+                del request.headers["content-length"]
+            logger.debug("Next page request body: %s %s" % (methodName, body))
+
+        return request
+
+    return (methodName, methodNext)
+
+
+class Resource(object):
+    """A class for interacting with a resource."""
+
+    def __init__(
+        self,
+        http,
+        baseUrl,
+        model,
+        requestBuilder,
+        developerKey,
+        resourceDesc,
+        rootDesc,
+        schema,
+        universe_domain=universe.DEFAULT_UNIVERSE if HAS_UNIVERSE else "",
+    ):
+        """Build a Resource from the API description.
+
+        Args:
+          http: httplib2.Http, Object to make http requests with.
+          baseUrl: string, base URL for the API. All requests are relative to this
+              URI.
+          model: googleapiclient.Model, converts to and from the wire format.
+          requestBuilder: class or callable that instantiates an
+              googleapiclient.HttpRequest object.
+          developerKey: string, key obtained from
+              https://code.google.com/apis/console
+          resourceDesc: object, section of deserialized discovery document that
+              describes a resource. Note that the top level discovery document
+              is considered a resource.
+          rootDesc: object, the entire deserialized discovery document.
+          schema: object, mapping of schema names to schema descriptions.
+          universe_domain: string, the universe for the API. The default universe
+          is "googleapis.com".
+        """
+        self._dynamic_attrs = []
+
+        self._http = http
+        self._baseUrl = baseUrl
+        self._model = model
+        self._developerKey = developerKey
+        self._requestBuilder = requestBuilder
+        self._resourceDesc = resourceDesc
+        self._rootDesc = rootDesc
+        self._schema = schema
+        self._universe_domain = universe_domain
+        self._credentials_validated = False
+
+        self._set_service_methods()
+
+    def _set_dynamic_attr(self, attr_name, value):
+        """Sets an instance attribute and tracks it in a list of dynamic attributes.
+
+        Args:
+          attr_name: string; The name of the attribute to be set
+          value: The value being set on the object and tracked in the dynamic cache.
+        """
+        self._dynamic_attrs.append(attr_name)
+        self.__dict__[attr_name] = value
+
+    def __getstate__(self):
+        """Trim the state down to something that can be pickled.
+
+        Uses the fact that the instance variable _dynamic_attrs holds attrs that
+        will be wiped and restored on pickle serialization.
+        """
+        state_dict = copy.copy(self.__dict__)
+        for dynamic_attr in self._dynamic_attrs:
+            del state_dict[dynamic_attr]
+        del state_dict["_dynamic_attrs"]
+        return state_dict
+
+    def __setstate__(self, state):
+        """Reconstitute the state of the object from being pickled.
+
+        Uses the fact that the instance variable _dynamic_attrs holds attrs that
+        will be wiped and restored on pickle serialization.
+        """
+        self.__dict__.update(state)
+        self._dynamic_attrs = []
+        self._set_service_methods()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc, exc_tb):
+        self.close()
+
+    def close(self):
+        """Close httplib2 connections."""
+        # httplib2 leaves sockets open by default.
+        # Cleanup using the `close` method.
+        # https://github.com/httplib2/httplib2/issues/148
+        self._http.close()
+
+    def _set_service_methods(self):
+        self._add_basic_methods(self._resourceDesc, self._rootDesc, self._schema)
+        self._add_nested_resources(self._resourceDesc, self._rootDesc, self._schema)
+        self._add_next_methods(self._resourceDesc, self._schema)
+
+    def _add_basic_methods(self, resourceDesc, rootDesc, schema):
+        # If this is the root Resource, add a new_batch_http_request() method.
+        if resourceDesc == rootDesc:
+            batch_uri = "%s%s" % (
+                rootDesc["rootUrl"],
+                rootDesc.get("batchPath", "batch"),
+            )
+
+            def new_batch_http_request(callback=None):
+                """Create a BatchHttpRequest object based on the discovery document.
+
+                Args:
+                  callback: callable, A callback to be called for each response, of the
+                    form callback(id, response, exception). The first parameter is the
+                    request id, and the second is the deserialized response object. The
+                    third is an apiclient.errors.HttpError exception object if an HTTP
+                    error occurred while processing the request, or None if no error
+                    occurred.
+
+                Returns:
+                  A BatchHttpRequest object based on the discovery document.
+                """
+                return BatchHttpRequest(callback=callback, batch_uri=batch_uri)
+
+            self._set_dynamic_attr("new_batch_http_request", new_batch_http_request)
+
+        # Add basic methods to Resource
+        if "methods" in resourceDesc:
+            for methodName, methodDesc in resourceDesc["methods"].items():
+                fixedMethodName, method = createMethod(
+                    methodName, methodDesc, rootDesc, schema
+                )
+                self._set_dynamic_attr(
+                    fixedMethodName, method.__get__(self, self.__class__)
+                )
+                # Add in _media methods. The functionality of the attached method will
+                # change when it sees that the method name ends in _media.
+                if methodDesc.get("supportsMediaDownload", False):
+                    fixedMethodName, method = createMethod(
+                        methodName + "_media", methodDesc, rootDesc, schema
+                    )
+                    self._set_dynamic_attr(
+                        fixedMethodName, method.__get__(self, self.__class__)
+                    )
+
+    def _add_nested_resources(self, resourceDesc, rootDesc, schema):
+        # Add in nested resources
+        if "resources" in resourceDesc:
+
+            def createResourceMethod(methodName, methodDesc):
+                """Create a method on the Resource to access a nested Resource.
+
+                Args:
+                  methodName: string, name of the method to use.
+                  methodDesc: object, fragment of deserialized discovery document that
+                    describes the method.
+                """
+                methodName = fix_method_name(methodName)
+
+                def methodResource(self):
+                    return Resource(
+                        http=self._http,
+                        baseUrl=self._baseUrl,
+                        model=self._model,
+                        developerKey=self._developerKey,
+                        requestBuilder=self._requestBuilder,
+                        resourceDesc=methodDesc,
+                        rootDesc=rootDesc,
+                        schema=schema,
+                        universe_domain=self._universe_domain,
+                    )
+
+                setattr(methodResource, "__doc__", "A collection resource.")
+                setattr(methodResource, "__is_resource__", True)
+
+                return (methodName, methodResource)
+
+            for methodName, methodDesc in resourceDesc["resources"].items():
+                fixedMethodName, method = createResourceMethod(methodName, methodDesc)
+                self._set_dynamic_attr(
+                    fixedMethodName, method.__get__(self, self.__class__)
+                )
+
+    def _add_next_methods(self, resourceDesc, schema):
+        # Add _next() methods if and only if one of the names 'pageToken' or
+        # 'nextPageToken' occurs among the fields of both the method's response
+        # type either the method's request (query parameters) or request body.
+        if "methods" not in resourceDesc:
+            return
+        for methodName, methodDesc in resourceDesc["methods"].items():
+            nextPageTokenName = _findPageTokenName(
+                _methodProperties(methodDesc, schema, "response")
+            )
+            if not nextPageTokenName:
+                continue
+            isPageTokenParameter = True
+            pageTokenName = _findPageTokenName(methodDesc.get("parameters", {}))
+            if not pageTokenName:
+                isPageTokenParameter = False
+                pageTokenName = _findPageTokenName(
+                    _methodProperties(methodDesc, schema, "request")
+                )
+            if not pageTokenName:
+                continue
+            fixedMethodName, method = createNextMethod(
+                methodName + "_next",
+                pageTokenName,
+                nextPageTokenName,
+                isPageTokenParameter,
+            )
+            self._set_dynamic_attr(
+                fixedMethodName, method.__get__(self, self.__class__)
+            )
+
+    def _validate_credentials(self):
+        """Validates client's and credentials' universe domains are consistent.
+
+        Returns:
+            bool: True iff the configured universe domain is valid.
+
+        Raises:
+            UniverseMismatchError: If the configured universe domain is not valid.
+        """
+        credentials = getattr(self._http, "credentials", None)
+
+        self._credentials_validated = (
+            (
+                self._credentials_validated
+                or universe.compare_domains(self._universe_domain, credentials)
+            )
+            if HAS_UNIVERSE
+            else True
+        )
+        return self._credentials_validated
+
+
+def _findPageTokenName(fields):
+    """Search field names for one like a page token.
+
+    Args:
+      fields: container of string, names of fields.
+
+    Returns:
+      First name that is either 'pageToken' or 'nextPageToken' if one exists,
+      otherwise None.
+    """
+    return next(
+        (tokenName for tokenName in _PAGE_TOKEN_NAMES if tokenName in fields), None
+    )
+
+
+def _methodProperties(methodDesc, schema, name):
+    """Get properties of a field in a method description.
+
+    Args:
+      methodDesc: object, fragment of deserialized discovery document that
+        describes the method.
+      schema: object, mapping of schema names to schema descriptions.
+      name: string, name of top-level field in method description.
+
+    Returns:
+      Object representing fragment of deserialized discovery document
+      corresponding to 'properties' field of object corresponding to named field
+      in method description, if it exists, otherwise empty dict.
+    """
+    desc = methodDesc.get(name, {})
+    if "$ref" in desc:
+        desc = schema.get(desc["$ref"], {})
+    return desc.get("properties", {})

.venv/lib/python3.11/site-packages/googleapiclient/discovery_cache/__init__.py

@@ -0,0 +1,78 @@
+# Copyright 2014 Google Inc. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Caching utility for the discovery document."""
+
+from __future__ import absolute_import
+
+import logging
+import os
+
+LOGGER = logging.getLogger(__name__)
+
+DISCOVERY_DOC_MAX_AGE = 60 * 60 * 24  # 1 day
+DISCOVERY_DOC_DIR = os.path.join(
+    os.path.dirname(os.path.realpath(__file__)), "documents"
+)
+
+
+def autodetect():
+    """Detects an appropriate cache module and returns it.
+
+    Returns:
+      googleapiclient.discovery_cache.base.Cache, a cache object which
+      is auto detected, or None if no cache object is available.
+    """
+    if "GAE_ENV" in os.environ:
+        try:
+            from . import appengine_memcache
+
+            return appengine_memcache.cache
+        except Exception:
+            pass
+    try:
+        from . import file_cache
+
+        return file_cache.cache
+    except Exception:
+        LOGGER.info(
+            "file_cache is only supported with oauth2client<4.0.0", exc_info=False
+        )
+        return None
+
+
+def get_static_doc(serviceName, version):
+    """Retrieves the discovery document from the directory defined in
+    DISCOVERY_DOC_DIR corresponding to the serviceName and version provided.
+
+    Args:
+        serviceName: string, name of the service.
+        version: string, the version of the service.
+
+    Returns:
+        A string containing the contents of the JSON discovery document,
+        otherwise None if the JSON discovery document was not found.
+    """
+
+    content = None
+    doc_name = "{}.{}.json".format(serviceName, version)
+
+    try:
+        with open(os.path.join(DISCOVERY_DOC_DIR, doc_name), "r") as f:
+            content = f.read()
+    except FileNotFoundError:
+        # File does not exist. Nothing to do here.
+        pass
+
+    return content

.venv/lib/python3.11/site-packages/googleapiclient/discovery_cache/appengine_memcache.py

@@ -0,0 +1,55 @@
+# Copyright 2014 Google Inc. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""App Engine memcache based cache for the discovery document."""
+
+import logging
+
+# This is only an optional dependency because we only import this
+# module when google.appengine.api.memcache is available.
+from google.appengine.api import memcache
+
+from . import base
+from ..discovery_cache import DISCOVERY_DOC_MAX_AGE
+
+LOGGER = logging.getLogger(__name__)
+
+NAMESPACE = "google-api-client"
+
+
+class Cache(base.Cache):
+    """A cache with app engine memcache API."""
+
+    def __init__(self, max_age):
+        """Constructor.
+
+        Args:
+          max_age: Cache expiration in seconds.
+        """
+        self._max_age = max_age
+
+    def get(self, url):
+        try:
+            return memcache.get(url, namespace=NAMESPACE)
+        except Exception as e:
+            LOGGER.warning(e, exc_info=True)
+
+    def set(self, url, content):
+        try:
+            memcache.set(url, content, time=int(self._max_age), namespace=NAMESPACE)
+        except Exception as e:
+            LOGGER.warning(e, exc_info=True)
+
+
+cache = Cache(max_age=DISCOVERY_DOC_MAX_AGE)