Add files using upload-large-folder tool

pgsql/pgAdmin 4/python/Lib/site-packages/PyJWT-2.8.0.dist-info/AUTHORS.rst

@@ -0,0 +1,7 @@
+Authors
+=======
+
+``pyjwt`` is currently written and maintained by `Jose Padilla <https://github.com/jpadilla>`_.
+Originally written and maintained by `Jeff Lindsay <https://github.com/progrium>`_.
+
+A full list of contributors can be found on GitHub’s `overview <https://github.com/jpadilla/pyjwt/graphs/contributors>`_.

pgsql/pgAdmin 4/python/Lib/site-packages/PyJWT-2.8.0.dist-info/INSTALLER

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

pgsql/pgAdmin 4/python/Lib/site-packages/PyJWT-2.8.0.dist-info/LICENSE

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

pgsql/pgAdmin 4/python/Lib/site-packages/PyJWT-2.8.0.dist-info/METADATA

@@ -0,0 +1,107 @@
+Metadata-Version: 2.1
+Name: PyJWT
+Version: 2.8.0
+Summary: JSON Web Token implementation in Python
+Home-page: https://github.com/jpadilla/pyjwt
+Author: Jose Padilla
+Author-email: hello@jpadilla.com
+License: MIT
+Keywords: json,jwt,security,signing,token,web
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Natural Language :: English
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Utilities
+Requires-Python: >=3.7
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+License-File: AUTHORS.rst
+Requires-Dist: typing-extensions ; python_version <= "3.7"
+Provides-Extra: crypto
+Requires-Dist: cryptography (>=3.4.0) ; extra == 'crypto'
+Provides-Extra: dev
+Requires-Dist: sphinx (<5.0.0,>=4.5.0) ; extra == 'dev'
+Requires-Dist: sphinx-rtd-theme ; extra == 'dev'
+Requires-Dist: zope.interface ; extra == 'dev'
+Requires-Dist: cryptography (>=3.4.0) ; extra == 'dev'
+Requires-Dist: pytest (<7.0.0,>=6.0.0) ; extra == 'dev'
+Requires-Dist: coverage[toml] (==5.0.4) ; extra == 'dev'
+Requires-Dist: pre-commit ; extra == 'dev'
+Provides-Extra: docs
+Requires-Dist: sphinx (<5.0.0,>=4.5.0) ; extra == 'docs'
+Requires-Dist: sphinx-rtd-theme ; extra == 'docs'
+Requires-Dist: zope.interface ; extra == 'docs'
+Provides-Extra: tests
+Requires-Dist: pytest (<7.0.0,>=6.0.0) ; extra == 'tests'
+Requires-Dist: coverage[toml] (==5.0.4) ; extra == 'tests'
+
+PyJWT
+=====
+
+.. image:: https://github.com/jpadilla/pyjwt/workflows/CI/badge.svg
+   :target: https://github.com/jpadilla/pyjwt/actions?query=workflow%3ACI
+
+.. image:: https://img.shields.io/pypi/v/pyjwt.svg
+   :target: https://pypi.python.org/pypi/pyjwt
+
+.. image:: https://codecov.io/gh/jpadilla/pyjwt/branch/master/graph/badge.svg
+   :target: https://codecov.io/gh/jpadilla/pyjwt
+
+.. image:: https://readthedocs.org/projects/pyjwt/badge/?version=stable
+   :target: https://pyjwt.readthedocs.io/en/stable/
+
+A Python implementation of `RFC 7519 <https://tools.ietf.org/html/rfc7519>`_. Original implementation was written by `@progrium <https://github.com/progrium>`_.
+
+Sponsor
+-------
+
++--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+| |auth0-logo| | If you want to quickly add secure token-based authentication to Python projects, feel free to check Auth0's Python SDK and free plan at `auth0.com/developers <https://auth0.com/developers?utm_source=GHsponsor&utm_medium=GHsponsor&utm_campaign=pyjwt&utm_content=auth>`_. |
++--------------+-----------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
+
+.. |auth0-logo| image:: https://user-images.githubusercontent.com/83319/31722733-de95bbde-b3ea-11e7-96bf-4f4e8f915588.png
+
+Installing
+----------
+
+Install with **pip**:
+
+.. code-block:: console
+
+    $ pip install PyJWT
+
+
+Usage
+-----
+
+.. code-block:: pycon
+
+    >>> import jwt
+    >>> encoded = jwt.encode({"some": "payload"}, "secret", algorithm="HS256")
+    >>> print(encoded)
+    eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzb21lIjoicGF5bG9hZCJ9.4twFt5NiznN84AWoo1d7KO1T_yoc0Z6XOpOVswacPZg
+    >>> jwt.decode(encoded, "secret", algorithms=["HS256"])
+    {'some': 'payload'}
+
+Documentation
+-------------
+
+View the full docs online at https://pyjwt.readthedocs.io/en/stable/
+
+
+Tests
+-----
+
+You can run tests from the project root after cloning with:
+
+.. code-block:: console
+
+    $ tox

pgsql/pgAdmin 4/python/Lib/site-packages/PyJWT-2.8.0.dist-info/RECORD

@@ -0,0 +1,32 @@
+PyJWT-2.8.0.dist-info/AUTHORS.rst,sha256=klzkNGECnu2_VY7At89_xLBF3vUSDruXk3xwgUBxzwc,322
+PyJWT-2.8.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+PyJWT-2.8.0.dist-info/LICENSE,sha256=eXp6ICMdTEM-nxkR2xcx0GtYKLmPSZgZoDT3wPVvXOU,1085
+PyJWT-2.8.0.dist-info/METADATA,sha256=pV2XZjvithGcVesLHWAv0J4T5t8Qc66fip2sbxwoz1o,4160
+PyJWT-2.8.0.dist-info/RECORD,,
+PyJWT-2.8.0.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
+PyJWT-2.8.0.dist-info/top_level.txt,sha256=RP5DHNyJbMq2ka0FmfTgoSaQzh7e3r5XuCWCO8a00k8,4
+jwt/__init__.py,sha256=mV9lg6n4-0xiqCKaE1eEPC9a4j6sEkEYQcKghULE7kU,1670
+jwt/__pycache__/__init__.cpython-311.pyc,,
+jwt/__pycache__/algorithms.cpython-311.pyc,,
+jwt/__pycache__/api_jwk.cpython-311.pyc,,
+jwt/__pycache__/api_jws.cpython-311.pyc,,
+jwt/__pycache__/api_jwt.cpython-311.pyc,,
+jwt/__pycache__/exceptions.cpython-311.pyc,,
+jwt/__pycache__/help.cpython-311.pyc,,
+jwt/__pycache__/jwk_set_cache.cpython-311.pyc,,
+jwt/__pycache__/jwks_client.cpython-311.pyc,,
+jwt/__pycache__/types.cpython-311.pyc,,
+jwt/__pycache__/utils.cpython-311.pyc,,
+jwt/__pycache__/warnings.cpython-311.pyc,,
+jwt/algorithms.py,sha256=RDsv5Lm3bzwsiWT3TynT7JR41R6H6s_fWUGOIqd9x_I,29800
+jwt/api_jwk.py,sha256=HPxVqgBZm7RTaEXydciNBCuYNKDYOC_prTdaN9toGbo,4196
+jwt/api_jws.py,sha256=da17RrDe0PDccTbx3rx2lLezEG_c_YGw_vVHa335IOk,11099
+jwt/api_jwt.py,sha256=yF9DwF1kt3PA5n_TiU0OmHd0LtPHfe4JCE1XOfKPjw0,12638
+jwt/exceptions.py,sha256=KDC3M7cTrpR4OQXVURlVMThem0pfANSgBxRz-ttivmo,1046
+jwt/help.py,sha256=Jrp84fG43sCwmSIaDtY08I6ZR2VE7NhrTff89tYSE40,1749
+jwt/jwk_set_cache.py,sha256=hBKmN-giU7-G37L_XKgc_OZu2ah4wdbj1ZNG_GkoSE8,959
+jwt/jwks_client.py,sha256=9W8JVyGByQgoLbBN1u5iY1_jlgfnnukeOBTpqaM_9SE,4222
+jwt/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+jwt/types.py,sha256=VnhGv_VFu5a7_mrPoSCB7HaNLrJdhM8Sq1sSfEg0gLU,99
+jwt/utils.py,sha256=PAI05_8MHQCxWQTDlwN0hTtTIT2DTTZ28mm1x6-26UY,3903
+jwt/warnings.py,sha256=50XWOnyNsIaqzUJTk6XHNiIDykiL763GYA92MjTKmok,59

pgsql/pgAdmin 4/python/Lib/site-packages/PyJWT-2.8.0.dist-info/WHEEL

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

pgsql/pgAdmin 4/python/Lib/site-packages/PyJWT-2.8.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+jwt

pgsql/pgAdmin 4/python/Lib/site-packages/PyNaCl-1.5.0.dist-info/INSTALLER

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

pgsql/pgAdmin 4/python/Lib/site-packages/PyNaCl-1.5.0.dist-info/LICENSE

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

pgsql/pgAdmin 4/python/Lib/site-packages/PyNaCl-1.5.0.dist-info/METADATA

@@ -0,0 +1,246 @@
+Metadata-Version: 2.1
+Name: PyNaCl
+Version: 1.5.0
+Summary: Python binding to the Networking and Cryptography (NaCl) library
+Home-page: https://github.com/pyca/pynacl/
+Author: The PyNaCl developers
+Author-email: cryptography-dev@python.org
+License: Apache License 2.0
+Platform: UNKNOWN
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Requires-Python: >=3.6
+License-File: LICENSE
+Requires-Dist: cffi (>=1.4.1)
+Provides-Extra: docs
+Requires-Dist: sphinx (>=1.6.5) ; extra == 'docs'
+Requires-Dist: sphinx-rtd-theme ; extra == 'docs'
+Provides-Extra: tests
+Requires-Dist: pytest (!=3.3.0,>=3.2.1) ; extra == 'tests'
+Requires-Dist: hypothesis (>=3.27.0) ; extra == 'tests'
+
+===============================================
+PyNaCl: Python binding to the libsodium library
+===============================================
+
+.. image:: https://img.shields.io/pypi/v/pynacl.svg
+    :target: https://pypi.org/project/PyNaCl/
+    :alt: Latest Version
+
+.. image:: https://codecov.io/github/pyca/pynacl/coverage.svg?branch=main
+    :target: https://codecov.io/github/pyca/pynacl?branch=main
+
+.. image:: https://img.shields.io/pypi/pyversions/pynacl.svg
+    :target: https://pypi.org/project/PyNaCl/
+    :alt: Compatible Python Versions
+
+PyNaCl is a Python binding to `libsodium`_, which is a fork of the
+`Networking and Cryptography library`_. These libraries have a stated goal of
+improving usability, security and speed. It supports Python 3.6+ as well as
+PyPy 3.
+
+.. _libsodium: https://github.com/jedisct1/libsodium
+.. _Networking and Cryptography library: https://nacl.cr.yp.to/
+
+Features
+--------
+
+* Digital signatures
+* Secret-key encryption
+* Public-key encryption
+* Hashing and message authentication
+* Password based key derivation and password hashing
+
+`Changelog`_
+------------
+
+.. _Changelog: https://pynacl.readthedocs.io/en/stable/changelog/
+
+Installation
+============
+
+Binary wheel install
+--------------------
+
+PyNaCl ships as a binary wheel on macOS, Windows and Linux ``manylinux1`` [#many]_ ,
+so all dependencies are included. Make sure you have an up-to-date pip
+and run:
+
+.. code-block:: console
+
+    $ pip install pynacl
+
+Faster wheel build
+------------------
+
+You can define the environment variable ``LIBSODIUM_MAKE_ARGS`` to pass arguments to ``make``
+and enable `parallelization`_:
+
+.. code-block:: console
+
+    $ LIBSODIUM_MAKE_ARGS=-j4 pip install pynacl
+
+Linux source build
+------------------
+
+PyNaCl relies on `libsodium`_, a portable C library. A copy is bundled
+with PyNaCl so to install you can run:
+
+.. code-block:: console
+
+    $ pip install pynacl
+
+If you'd prefer to use the version of ``libsodium`` provided by your
+distribution, you can disable the bundled copy during install by running:
+
+.. code-block:: console
+
+    $ SODIUM_INSTALL=system pip install pynacl
+
+.. warning:: Usage of the legacy ``easy_install`` command provided by setuptools
+   is generally discouraged, and is completely unsupported in PyNaCl's case.
+
+.. _parallelization: https://www.gnu.org/software/make/manual/html_node/Parallel.html
+
+.. _libsodium: https://github.com/jedisct1/libsodium
+
+.. [#many] `manylinux1 wheels <https://www.python.org/dev/peps/pep-0513/>`_
+    are built on a baseline linux environment based on Centos 5.11
+    and should work on most x86 and x86_64 glibc based linux environments.
+
+Changelog
+=========
+
+1.5.0 (2022-01-07)
+------------------
+
+* **BACKWARDS INCOMPATIBLE:** Removed support for Python 2.7 and Python 3.5.
+* **BACKWARDS INCOMPATIBLE:** We no longer distribute ``manylinux1``
+  wheels.
+* Added ``manylinux2014``, ``manylinux_2_24``, ``musllinux``, and macOS
+  ``universal2`` wheels (the latter supports macOS ``arm64``).
+* Update ``libsodium`` to 1.0.18-stable (July 25, 2021 release).
+* Add inline type hints.
+
+1.4.0 (2020-05-25)
+------------------
+
+* Update ``libsodium`` to 1.0.18.
+* **BACKWARDS INCOMPATIBLE:** We no longer distribute 32-bit ``manylinux1``
+  wheels. Continuing to produce them was a maintenance burden.
+* Added support for Python 3.8, and removed support for Python 3.4.
+* Add low level bindings for extracting the seed and the public key
+  from crypto_sign_ed25519 secret key
+* Add low level bindings for deterministic random generation.
+* Add ``wheel`` and ``setuptools`` setup_requirements in ``setup.py`` (#485)
+* Fix checks on very slow builders (#481, #495)
+* Add low-level bindings to ed25519 arithmetic functions
+* Update low-level blake2b state implementation
+* Fix wrong short-input behavior of SealedBox.decrypt() (#517)
+* Raise CryptPrefixError exception instead of InvalidkeyError when trying
+  to check a password against a verifier stored in a unknown format (#519)
+* Add support for minimal builds of libsodium. Trying to call functions
+  not available in a minimal build will raise an UnavailableError
+  exception. To compile a minimal build of the bundled libsodium, set
+  the SODIUM_INSTALL_MINIMAL environment variable to any non-empty
+  string (e.g. ``SODIUM_INSTALL_MINIMAL=1``) for setup.
+
+1.3.0 2018-09-26
+----------------
+
+* Added support for Python 3.7.
+* Update ``libsodium`` to 1.0.16.
+* Run and test all code examples in PyNaCl docs through sphinx's
+  doctest builder.
+* Add low-level bindings for chacha20-poly1305 AEAD constructions.
+* Add low-level bindings for the chacha20-poly1305 secretstream constructions.
+* Add low-level bindings for ed25519ph pre-hashed signing construction.
+* Add low-level bindings for constant-time increment and addition
+  on fixed-precision big integers represented as little-endian
+  byte sequences.
+* Add low-level bindings for the ISO/IEC 7816-4 compatible padding API.
+* Add low-level bindings for libsodium's crypto_kx... key exchange
+  construction.
+* Set hypothesis deadline to None in tests/test_pwhash.py to avoid
+  incorrect test failures on slower processor architectures.  GitHub
+  issue #370
+
+1.2.1 - 2017-12-04
+------------------
+
+* Update hypothesis minimum allowed version.
+* Infrastructure: add proper configuration for readthedocs builder
+  runtime environment.
+
+1.2.0 - 2017-11-01
+------------------
+
+* Update ``libsodium`` to 1.0.15.
+* Infrastructure: add jenkins support for automatic build of
+  ``manylinux1`` binary wheels
+* Added support for ``SealedBox`` construction.
+* Added support for ``argon2i`` and ``argon2id`` password hashing constructs
+  and restructured high-level password hashing implementation to expose
+  the same interface for all hashers.
+* Added support for 128 bit ``siphashx24`` variant of ``siphash24``.
+* Added support for ``from_seed`` APIs for X25519 keypair generation.
+* Dropped support for Python 3.3.
+
+1.1.2 - 2017-03-31
+------------------
+
+* reorder link time library search path when using bundled
+  libsodium
+
+1.1.1 - 2017-03-15
+------------------
+
+* Fixed a circular import bug in ``nacl.utils``.
+
+1.1.0 - 2017-03-14
+------------------
+
+* Dropped support for Python 2.6.
+* Added ``shared_key()`` method on ``Box``.
+* You can now pass ``None`` to ``nonce`` when encrypting with ``Box`` or
+  ``SecretBox`` and it will automatically generate a random nonce.
+* Added support for ``siphash24``.
+* Added support for ``blake2b``.
+* Added support for ``scrypt``.
+* Update ``libsodium`` to 1.0.11.
+* Default to the bundled ``libsodium`` when compiling.
+* All raised exceptions are defined mixing-in
+  ``nacl.exceptions.CryptoError``
+
+1.0.1 - 2016-01-24
+------------------
+
+* Fix an issue with absolute paths that prevented the creation of wheels.
+
+1.0 - 2016-01-23
+----------------
+
+* PyNaCl has been ported to use the new APIs available in cffi 1.0+.
+  Due to this change we no longer support PyPy releases older than 2.6.
+* Python 3.2 support has been dropped.
+* Functions to convert between Ed25519 and Curve25519 keys have been added.
+
+0.3.0 - 2015-03-04
+------------------
+
+* The low-level API (`nacl.c.*`) has been changed to match the
+  upstream NaCl C/C++ conventions (as well as those of other NaCl bindings).
+  The order of arguments and return values has changed significantly. To
+  avoid silent failures, `nacl.c` has been removed, and replaced with
+  `nacl.bindings` (with the new argument ordering). If you have code which
+  calls these functions (e.g. `nacl.c.crypto_box_keypair()`), you must review
+  the new docstrings and update your code/imports to match the new
+  conventions.
+
+

pgsql/pgAdmin 4/python/Lib/site-packages/PyNaCl-1.5.0.dist-info/RECORD

@@ -0,0 +1,68 @@
+PyNaCl-1.5.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+PyNaCl-1.5.0.dist-info/LICENSE,sha256=d69bve2VkRS216XupRiyvjZOBPT0qV-eh9mHDCdxPSQ,9868
+PyNaCl-1.5.0.dist-info/METADATA,sha256=U9PLLkcKk_YC_Tl5OSoMiAmblalKU9qFsRtxiwa-TiM,8656
+PyNaCl-1.5.0.dist-info/RECORD,,
+PyNaCl-1.5.0.dist-info/WHEEL,sha256=nYCSW5p8tLyDU-wbqo3uRlCluAzwxLmyyRK2pVs4-Ag,100
+PyNaCl-1.5.0.dist-info/top_level.txt,sha256=wfdEOI_G2RIzmzsMyhpqP17HUh6Jcqi99to9aHLEslo,13
+nacl/__init__.py,sha256=W0JhVbFcnhlrEtK0tdRGDcX8aucbKCQmRBmf9hGFWQY,1155
+nacl/__pycache__/__init__.cpython-311.pyc,,
+nacl/__pycache__/encoding.cpython-311.pyc,,
+nacl/__pycache__/exceptions.cpython-311.pyc,,
+nacl/__pycache__/hash.cpython-311.pyc,,
+nacl/__pycache__/hashlib.cpython-311.pyc,,
+nacl/__pycache__/public.cpython-311.pyc,,
+nacl/__pycache__/secret.cpython-311.pyc,,
+nacl/__pycache__/signing.cpython-311.pyc,,
+nacl/__pycache__/utils.cpython-311.pyc,,
+nacl/_sodium.pyd,sha256=1zPCPGpLIWJaT_B_ZWK6iCvL2w9QgmJpQZ2N4FdPiM0,348672
+nacl/bindings/__init__.py,sha256=erC7ta0z7XQSmfeYcnCVhFKqBtkkK6wJq8PKsEnjqSg,17448
+nacl/bindings/__pycache__/__init__.cpython-311.pyc,,
+nacl/bindings/__pycache__/crypto_aead.cpython-311.pyc,,
+nacl/bindings/__pycache__/crypto_box.cpython-311.pyc,,
+nacl/bindings/__pycache__/crypto_core.cpython-311.pyc,,
+nacl/bindings/__pycache__/crypto_generichash.cpython-311.pyc,,
+nacl/bindings/__pycache__/crypto_hash.cpython-311.pyc,,
+nacl/bindings/__pycache__/crypto_kx.cpython-311.pyc,,
+nacl/bindings/__pycache__/crypto_pwhash.cpython-311.pyc,,
+nacl/bindings/__pycache__/crypto_scalarmult.cpython-311.pyc,,
+nacl/bindings/__pycache__/crypto_secretbox.cpython-311.pyc,,
+nacl/bindings/__pycache__/crypto_secretstream.cpython-311.pyc,,
+nacl/bindings/__pycache__/crypto_shorthash.cpython-311.pyc,,
+nacl/bindings/__pycache__/crypto_sign.cpython-311.pyc,,
+nacl/bindings/__pycache__/randombytes.cpython-311.pyc,,
+nacl/bindings/__pycache__/sodium_core.cpython-311.pyc,,
+nacl/bindings/__pycache__/utils.cpython-311.pyc,,
+nacl/bindings/crypto_aead.py,sha256=fxSgpeI48HkxwsZEk9cTxigdJ5k7PvMh1mxr7M0LK9A,16156
+nacl/bindings/crypto_box.py,sha256=6M7qSZu806POBtEoK5e9Ui-JcSYaFDI6tTnllVJ0F7U,10463
+nacl/bindings/crypto_core.py,sha256=KccKcEGpoEsQjkYRcwpsBse-g_iGXNgQHeb1gCdZR4E,14148
+nacl/bindings/crypto_generichash.py,sha256=8nEG1ntZSqVOTAV6-_EZg-gNbV5UJc-SbDUa2GdkxRs,9133
+nacl/bindings/crypto_hash.py,sha256=8GO8el_rZgD2ITJyEbiejHXZimfrxckXc9cUppv1vpk,2238
+nacl/bindings/crypto_kx.py,sha256=8gmFRbU7NKHqCLZ1HsObilmeTboYFW6tEJCEUucje9Q,6923
+nacl/bindings/crypto_pwhash.py,sha256=sIugQ9Rx8KTy3vnOsQwz_kV2PhqwqVOsfbkR_sKnudc,19448
+nacl/bindings/crypto_scalarmult.py,sha256=gMNDgWl-P6ua8I3kAM2yt4dNzK9gY742C424z-yBMUU,8484
+nacl/bindings/crypto_secretbox.py,sha256=WEX2_Ea79pQkUshr_sVlslA28Zx_66tYFawW1qipleY,3000
+nacl/bindings/crypto_secretstream.py,sha256=3uZN9XET8AeFKn365K2gfcZKYjkOFfyLr8GCUw8Wx6g,11522
+nacl/bindings/crypto_shorthash.py,sha256=NDmmvG77ZhGLmbK0USoLW2dOveUcGdUFqL1fi5ozcDc,2684
+nacl/bindings/crypto_sign.py,sha256=IMKXZCAb8oF0tLQR6UcpJk0zTRFDeW4IWNvo9XdZfgw,10669
+nacl/bindings/randombytes.py,sha256=JmR-o2Bpj1ssJp8GDj4KgutPknEZGgogUSdnW4kRI5Q,1614
+nacl/bindings/sodium_core.py,sha256=8o4mDDahmmAIf4Xk3hJE5C-B6Ms5mbeu64_ylW9kY6I,1072
+nacl/bindings/utils.py,sha256=2WefZr1MOFTWKn6h6ODuw4u8D9PEfDWMaayXiPUm6RA,4439
+nacl/encoding.py,sha256=xKwjFb5F1jEfmazetwtaQpsUPvzYLh3RU6Wkiq56NzI,3020
+nacl/exceptions.py,sha256=gM8gN01HFGCUw8L1VjmEhBPf00r-igNJo-nAEsrhEBU,2539
+nacl/hash.py,sha256=_H8JOPecwna4GP8CaMorghfetykbuO9q4oteek9bfVo,6574
+nacl/hashlib.py,sha256=x74Z29ExS3e5yFV0Mzij9gnU_eRKWwkD6YPYfI5eUFw,4543
+nacl/public.py,sha256=kVoz1R9zkNnczDUsBDnYYXL_6C9jsga6ph3rk32uFNo,15215
+nacl/pwhash/__init__.py,sha256=2vX9OivKZsrMVjh2vjfbdBVDsUml8AEnIRsa1d6ZzG0,2750
+nacl/pwhash/__pycache__/__init__.cpython-311.pyc,,
+nacl/pwhash/__pycache__/_argon2.cpython-311.pyc,,
+nacl/pwhash/__pycache__/argon2i.cpython-311.pyc,,
+nacl/pwhash/__pycache__/argon2id.cpython-311.pyc,,
+nacl/pwhash/__pycache__/scrypt.cpython-311.pyc,,
+nacl/pwhash/_argon2.py,sha256=uR1Y_DnX8RZIfmTHborlXWcJ-re_wDryOIhVYssjj8I,1828
+nacl/pwhash/argon2i.py,sha256=dJmM_bVP0LALK9I4TfaZsWqEah7z7sprd3mw8TRPr-4,4537
+nacl/pwhash/argon2id.py,sha256=dJ7kpU-b07YzMPlrsMW9K_tV-xnA0bE7pj-ZFo-z0wc,4568
+nacl/pwhash/scrypt.py,sha256=_qbeDojJzzE42RvwwUsELA8pGgXDInb1ht6ec1w3_1Y,7197
+nacl/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nacl/secret.py,sha256=YShCAvKF7sHAGOBRSnWKMJvJChQ7SuhlQXRCz32MdrM,12413
+nacl/signing.py,sha256=CR9ZRXYSrdZFkNiIQTIplFS8UQ0Z_OzXqaaQ_HdhSQ4,8587
+nacl/utils.py,sha256=iEQ0LtPtyV7Cqo4wpn9CvQunwsM5ShEZlO9IvT1r4dk,2429

pgsql/pgAdmin 4/python/Lib/site-packages/PyNaCl-1.5.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.37.1)
+Root-Is-Purelib: false
+Tag: cp36-abi3-win_amd64
+

pgsql/pgAdmin 4/python/Lib/site-packages/PyNaCl-1.5.0.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+_sodium
+nacl

pgsql/pgAdmin 4/python/Lib/site-packages/SQLAlchemy-2.0.30.dist-info/INSTALLER

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

pgsql/pgAdmin 4/python/Lib/site-packages/SQLAlchemy-2.0.30.dist-info/LICENSE

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

pgsql/pgAdmin 4/python/Lib/site-packages/SQLAlchemy-2.0.30.dist-info/METADATA

@@ -0,0 +1,242 @@
+Metadata-Version: 2.1
+Name: SQLAlchemy
+Version: 2.0.30
+Summary: Database Abstraction Library
+Home-page: https://www.sqlalchemy.org
+Author: Mike Bayer
+Author-email: mike_mp@zzzcomputing.com
+License: MIT
+Project-URL: Documentation, https://docs.sqlalchemy.org
+Project-URL: Issue Tracker, https://github.com/sqlalchemy/sqlalchemy/
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Database :: Front-Ends
+Requires-Python: >=3.7
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+Requires-Dist: typing-extensions >=4.6.0
+Requires-Dist: greenlet !=0.4.17 ; platform_machine == "aarch64" or (platform_machine == "ppc64le" or (platform_machine == "x86_64" or (platform_machine == "amd64" or (platform_machine == "AMD64" or (platform_machine == "win32" or platform_machine == "WIN32")))))
+Requires-Dist: importlib-metadata ; python_version < "3.8"
+Provides-Extra: aiomysql
+Requires-Dist: greenlet !=0.4.17 ; extra == 'aiomysql'
+Requires-Dist: aiomysql >=0.2.0 ; extra == 'aiomysql'
+Provides-Extra: aioodbc
+Requires-Dist: greenlet !=0.4.17 ; extra == 'aioodbc'
+Requires-Dist: aioodbc ; extra == 'aioodbc'
+Provides-Extra: aiosqlite
+Requires-Dist: greenlet !=0.4.17 ; extra == 'aiosqlite'
+Requires-Dist: aiosqlite ; extra == 'aiosqlite'
+Requires-Dist: typing-extensions !=3.10.0.1 ; extra == 'aiosqlite'
+Provides-Extra: asyncio
+Requires-Dist: greenlet !=0.4.17 ; extra == 'asyncio'
+Provides-Extra: asyncmy
+Requires-Dist: greenlet !=0.4.17 ; extra == 'asyncmy'
+Requires-Dist: asyncmy !=0.2.4,!=0.2.6,>=0.2.3 ; extra == 'asyncmy'
+Provides-Extra: mariadb_connector
+Requires-Dist: mariadb !=1.1.2,!=1.1.5,>=1.0.1 ; extra == 'mariadb_connector'
+Provides-Extra: mssql
+Requires-Dist: pyodbc ; extra == 'mssql'
+Provides-Extra: mssql_pymssql
+Requires-Dist: pymssql ; extra == 'mssql_pymssql'
+Provides-Extra: mssql_pyodbc
+Requires-Dist: pyodbc ; extra == 'mssql_pyodbc'
+Provides-Extra: mypy
+Requires-Dist: mypy >=0.910 ; extra == 'mypy'
+Provides-Extra: mysql
+Requires-Dist: mysqlclient >=1.4.0 ; extra == 'mysql'
+Provides-Extra: mysql_connector
+Requires-Dist: mysql-connector-python ; extra == 'mysql_connector'
+Provides-Extra: oracle
+Requires-Dist: cx-oracle >=8 ; extra == 'oracle'
+Provides-Extra: oracle_oracledb
+Requires-Dist: oracledb >=1.0.1 ; extra == 'oracle_oracledb'
+Provides-Extra: postgresql
+Requires-Dist: psycopg2 >=2.7 ; extra == 'postgresql'
+Provides-Extra: postgresql_asyncpg
+Requires-Dist: greenlet !=0.4.17 ; extra == 'postgresql_asyncpg'
+Requires-Dist: asyncpg ; extra == 'postgresql_asyncpg'
+Provides-Extra: postgresql_pg8000
+Requires-Dist: pg8000 >=1.29.1 ; extra == 'postgresql_pg8000'
+Provides-Extra: postgresql_psycopg
+Requires-Dist: psycopg >=3.0.7 ; extra == 'postgresql_psycopg'
+Provides-Extra: postgresql_psycopg2binary
+Requires-Dist: psycopg2-binary ; extra == 'postgresql_psycopg2binary'
+Provides-Extra: postgresql_psycopg2cffi
+Requires-Dist: psycopg2cffi ; extra == 'postgresql_psycopg2cffi'
+Provides-Extra: postgresql_psycopgbinary
+Requires-Dist: psycopg[binary] >=3.0.7 ; extra == 'postgresql_psycopgbinary'
+Provides-Extra: pymysql
+Requires-Dist: pymysql ; extra == 'pymysql'
+Provides-Extra: sqlcipher
+Requires-Dist: sqlcipher3-binary ; extra == 'sqlcipher'
+
+SQLAlchemy
+==========
+
+|PyPI| |Python| |Downloads|
+
+.. |PyPI| image:: https://img.shields.io/pypi/v/sqlalchemy
+    :target: https://pypi.org/project/sqlalchemy
+    :alt: PyPI
+
+.. |Python| image:: https://img.shields.io/pypi/pyversions/sqlalchemy
+    :target: https://pypi.org/project/sqlalchemy
+    :alt: PyPI - Python Version
+
+.. |Downloads| image:: https://static.pepy.tech/badge/sqlalchemy/month
+    :target: https://pepy.tech/project/sqlalchemy
+    :alt: PyPI - Downloads
+
+
+The Python SQL Toolkit and Object Relational Mapper
+
+Introduction
+-------------
+
+SQLAlchemy is the Python SQL toolkit and Object Relational Mapper
+that gives application developers the full power and
+flexibility of SQL. SQLAlchemy provides a full suite
+of well known enterprise-level persistence patterns,
+designed for efficient and high-performing database
+access, adapted into a simple and Pythonic domain
+language.
+
+Major SQLAlchemy features include:
+
+* An industrial strength ORM, built
+  from the core on the identity map, unit of work,
+  and data mapper patterns.   These patterns
+  allow transparent persistence of objects
+  using a declarative configuration system.
+  Domain models
+  can be constructed and manipulated naturally,
+  and changes are synchronized with the
+  current transaction automatically.
+* A relationally-oriented query system, exposing
+  the full range of SQL's capabilities
+  explicitly, including joins, subqueries,
+  correlation, and most everything else,
+  in terms of the object model.
+  Writing queries with the ORM uses the same
+  techniques of relational composition you use
+  when writing SQL.  While you can drop into
+  literal SQL at any time, it's virtually never
+  needed.
+* A comprehensive and flexible system
+  of eager loading for related collections and objects.
+  Collections are cached within a session,
+  and can be loaded on individual access, all
+  at once using joins, or by query per collection
+  across the full result set.
+* A Core SQL construction system and DBAPI
+  interaction layer.  The SQLAlchemy Core is
+  separate from the ORM and is a full database
+  abstraction layer in its own right, and includes
+  an extensible Python-based SQL expression
+  language, schema metadata, connection pooling,
+  type coercion, and custom types.
+* All primary and foreign key constraints are
+  assumed to be composite and natural.  Surrogate
+  integer primary keys are of course still the
+  norm, but SQLAlchemy never assumes or hardcodes
+  to this model.
+* Database introspection and generation.  Database
+  schemas can be "reflected" in one step into
+  Python structures representing database metadata;
+  those same structures can then generate
+  CREATE statements right back out - all within
+  the Core, independent of the ORM.
+
+SQLAlchemy's philosophy:
+
+* SQL databases behave less and less like object
+  collections the more size and performance start to
+  matter; object collections behave less and less like
+  tables and rows the more abstraction starts to matter.
+  SQLAlchemy aims to accommodate both of these
+  principles.
+* An ORM doesn't need to hide the "R".   A relational
+  database provides rich, set-based functionality
+  that should be fully exposed.   SQLAlchemy's
+  ORM provides an open-ended set of patterns
+  that allow a developer to construct a custom
+  mediation layer between a domain model and
+  a relational schema, turning the so-called
+  "object relational impedance" issue into
+  a distant memory.
+* The developer, in all cases, makes all decisions
+  regarding the design, structure, and naming conventions
+  of both the object model as well as the relational
+  schema.   SQLAlchemy only provides the means
+  to automate the execution of these decisions.
+* With SQLAlchemy, there's no such thing as
+  "the ORM generated a bad query" - you
+  retain full control over the structure of
+  queries, including how joins are organized,
+  how subqueries and correlation is used, what
+  columns are requested.  Everything SQLAlchemy
+  does is ultimately the result of a developer-initiated 
+  decision.
+* Don't use an ORM if the problem doesn't need one.
+  SQLAlchemy consists of a Core and separate ORM
+  component.   The Core offers a full SQL expression
+  language that allows Pythonic construction
+  of SQL constructs that render directly to SQL
+  strings for a target database, returning
+  result sets that are essentially enhanced DBAPI
+  cursors.
+* Transactions should be the norm.  With SQLAlchemy's
+  ORM, nothing goes to permanent storage until
+  commit() is called.  SQLAlchemy encourages applications
+  to create a consistent means of delineating
+  the start and end of a series of operations.
+* Never render a literal value in a SQL statement.
+  Bound parameters are used to the greatest degree
+  possible, allowing query optimizers to cache
+  query plans effectively and making SQL injection
+  attacks a non-issue.
+
+Documentation
+-------------
+
+Latest documentation is at:
+
+https://www.sqlalchemy.org/docs/
+
+Installation / Requirements
+---------------------------
+
+Full documentation for installation is at
+`Installation <https://www.sqlalchemy.org/docs/intro.html#installation>`_.
+
+Getting Help / Development / Bug reporting
+------------------------------------------
+
+Please refer to the `SQLAlchemy Community Guide <https://www.sqlalchemy.org/support.html>`_.
+
+Code of Conduct
+---------------
+
+Above all, SQLAlchemy places great emphasis on polite, thoughtful, and
+constructive communication between users and developers.
+Please see our current Code of Conduct at
+`Code of Conduct <https://www.sqlalchemy.org/codeofconduct.html>`_.
+
+License
+-------
+
+SQLAlchemy is distributed under the `MIT license
+<https://www.opensource.org/licenses/mit-license.php>`_.
+

pgsql/pgAdmin 4/python/Lib/site-packages/SQLAlchemy-2.0.30.dist-info/RECORD

@@ -0,0 +1,530 @@
+SQLAlchemy-2.0.30.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+SQLAlchemy-2.0.30.dist-info/LICENSE,sha256=eYQKk6tEYK_iQW6ePf95YIdsg66dK-JwXoOhBNSXQOs,1119
+SQLAlchemy-2.0.30.dist-info/METADATA,sha256=CFhk2rMbYqY0BKA_EXnTh60t76X9jVylfeYJXdFtcAE,9844
+SQLAlchemy-2.0.30.dist-info/RECORD,,
+SQLAlchemy-2.0.30.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+SQLAlchemy-2.0.30.dist-info/WHEEL,sha256=nSybvzWlmdJnHiUQSY-d7V1ycwEVUTqXiTvr2eshg44,102
+SQLAlchemy-2.0.30.dist-info/top_level.txt,sha256=rp-ZgB7D8G11ivXON5VGPjupT1voYmWqkciDt5Uaw_Q,11
+sqlalchemy/__init__.py,sha256=5bmbSs8TTDzkjc4FtkQKI8WvmicPtjfPg-zCQhte1eI,13327
+sqlalchemy/__pycache__/__init__.cpython-311.pyc,,
+sqlalchemy/__pycache__/events.cpython-311.pyc,,
+sqlalchemy/__pycache__/exc.cpython-311.pyc,,
+sqlalchemy/__pycache__/inspection.cpython-311.pyc,,
+sqlalchemy/__pycache__/log.cpython-311.pyc,,
+sqlalchemy/__pycache__/schema.cpython-311.pyc,,
+sqlalchemy/__pycache__/types.cpython-311.pyc,,
+sqlalchemy/connectors/__init__.py,sha256=A2AI8p63aT0jT5CsVX33xlTfiGWliOcGahlK0RyTLXg,494
+sqlalchemy/connectors/__pycache__/__init__.cpython-311.pyc,,
+sqlalchemy/connectors/__pycache__/aioodbc.cpython-311.pyc,,
+sqlalchemy/connectors/__pycache__/asyncio.cpython-311.pyc,,
+sqlalchemy/connectors/__pycache__/pyodbc.cpython-311.pyc,,
+sqlalchemy/connectors/aioodbc.py,sha256=fg3xfG-5gLsy-DSyVonNNKYhOf0_lzHmixRFa5edtWI,5462
+sqlalchemy/connectors/asyncio.py,sha256=OHCD6Jtk0RBjmS4DGVwngAqBSVsLe6Auj4IrJMh6Lvc,6082
+sqlalchemy/connectors/pyodbc.py,sha256=IG5lLCyFbnv1wB85HQuMO3S5piWHaB660OBWvBIQhbg,8750
+sqlalchemy/cyextension/__init__.py,sha256=Hlfk91RinbOuNF_fybR5R2UtiIcTeUOXS66QOfSSCV0,250
+sqlalchemy/cyextension/__pycache__/__init__.cpython-311.pyc,,
+sqlalchemy/cyextension/collections.cp311-win_amd64.pyd,sha256=lHBCKiG8IB7uP7nz0MlJyKpUxjpUu_w9O5WBsiPwq0U,175104
+sqlalchemy/cyextension/collections.pyx,sha256=GXPkr9cHRLW3Vcu-ik3dVBZMR-zf0Q5_K4J-_8yV-gk,12980
+sqlalchemy/cyextension/immutabledict.cp311-win_amd64.pyd,sha256=mFLMhNRta3uYfdSCq2ah5ai3KK09c0I6T5JrZrYkfe0,72704
+sqlalchemy/cyextension/immutabledict.pxd,sha256=5iGndSbJCgCkNmRbJ_z14RANs2dSSnAzyiRPUTBk58Y,299
+sqlalchemy/cyextension/immutabledict.pyx,sha256=IhB2pR49CrORXQ3LXMFpuCIRc6I08QNvIylE1cPQA5o,3668
+sqlalchemy/cyextension/processors.cp311-win_amd64.pyd,sha256=YLQHyoN_7JijAuwBt1lbHQwU1jQRjEZXxnshm40oyb4,58368
+sqlalchemy/cyextension/processors.pyx,sha256=V9gzqXiNHWsa5DBgYl-3KzclFHY8kXGF_TD1xHFE7eM,1860
+sqlalchemy/cyextension/resultproxy.cp311-win_amd64.pyd,sha256=IsBgDSN0SYKheogaDMKswUWNgdkuHHyhThprTfbW9CY,60928
+sqlalchemy/cyextension/resultproxy.pyx,sha256=h_RrKasbLtKK3LqUh6UiWtkumBlKtcN5eeB_1bZROMA,2827
+sqlalchemy/cyextension/util.cp311-win_amd64.pyd,sha256=viHyeVi1yiqnP0qjfWwUcJLH5LrbZsWRZlI3z9hpsFU,72704
+sqlalchemy/cyextension/util.pyx,sha256=50QYpSAKgLSUfhFEQgSN2e1qHWCMh_b6ZNlErDUS7ec,2621
+sqlalchemy/dialects/__init__.py,sha256=SJfQyxMhOL58EB-S6GQv_0jf2oP7MMfmVdlV2UxGWQo,1831
+sqlalchemy/dialects/__pycache__/__init__.cpython-311.pyc,,
+sqlalchemy/dialects/__pycache__/_typing.cpython-311.pyc,,
+sqlalchemy/dialects/_typing.py,sha256=mN2r8mU8z-mRh4YS3VeK8Nv_IKJmE0Mb1CrJ-ptILas,913
+sqlalchemy/dialects/mssql/__init__.py,sha256=r3oTfX2LLbJAGhM57wdPLWxaZBzunkcmyaTbW0FjLuY,1968
+sqlalchemy/dialects/mssql/__pycache__/__init__.cpython-311.pyc,,
+sqlalchemy/dialects/mssql/__pycache__/aioodbc.cpython-311.pyc,,
+sqlalchemy/dialects/mssql/__pycache__/base.cpython-311.pyc,,
+sqlalchemy/dialects/mssql/__pycache__/information_schema.cpython-311.pyc,,
+sqlalchemy/dialects/mssql/__pycache__/json.cpython-311.pyc,,
+sqlalchemy/dialects/mssql/__pycache__/provision.cpython-311.pyc,,
+sqlalchemy/dialects/mssql/__pycache__/pymssql.cpython-311.pyc,,
+sqlalchemy/dialects/mssql/__pycache__/pyodbc.cpython-311.pyc,,
+sqlalchemy/dialects/mssql/aioodbc.py,sha256=b9bhUKcVj4NzoqJIDfECeE_Rmt51sRy8OOUFz_R3vpg,2086
+sqlalchemy/dialects/mssql/base.py,sha256=eGtwgBdABesJ0AnVTXl6HnisZaCB42TZlN6POgpf0ss,136308
+sqlalchemy/dialects/mssql/information_schema.py,sha256=A1UJAoFb3UtE8YCY3heBgeTMkzWq3j7C2caZ3gcMGZk,8338
+sqlalchemy/dialects/mssql/json.py,sha256=nZVVsgmR4Z4dNn9cv5Gucq596gsQ0MvASPuEEtz-Gek,4949
+sqlalchemy/dialects/mssql/provision.py,sha256=pa-b74Xr2qsto3BFG1O0I_B25TUT3TOecg6cAKuRcf8,5517
+sqlalchemy/dialects/mssql/pymssql.py,sha256=f7xqRif9Dp64de9G8yuC4OyWArwXy_oVq5X0oiwIX4E,4163
+sqlalchemy/dialects/mssql/pyodbc.py,sha256=YVI19AnrqxPCBwDqcjrO_rqUUWbV2re7E8iLuV1ilqE,27801
+sqlalchemy/dialects/mysql/__init__.py,sha256=PPQDwNqcpxWMt3nFQ66KefX9T9iz7d8lybEwKlfXB1U,2254
+sqlalchemy/dialects/mysql/__pycache__/__init__.cpython-311.pyc,,
+sqlalchemy/dialects/mysql/__pycache__/aiomysql.cpython-311.pyc,,
+sqlalchemy/dialects/mysql/__pycache__/asyncmy.cpython-311.pyc,,
+sqlalchemy/dialects/mysql/__pycache__/base.cpython-311.pyc,,
+sqlalchemy/dialects/mysql/__pycache__/cymysql.cpython-311.pyc,,
+sqlalchemy/dialects/mysql/__pycache__/dml.cpython-311.pyc,,
+sqlalchemy/dialects/mysql/__pycache__/enumerated.cpython-311.pyc,,
+sqlalchemy/dialects/mysql/__pycache__/expression.cpython-311.pyc,,
+sqlalchemy/dialects/mysql/__pycache__/json.cpython-311.pyc,,
+sqlalchemy/dialects/mysql/__pycache__/mariadb.cpython-311.pyc,,
+sqlalchemy/dialects/mysql/__pycache__/mariadbconnector.cpython-311.pyc,,
+sqlalchemy/dialects/mysql/__pycache__/mysqlconnector.cpython-311.pyc,,
+sqlalchemy/dialects/mysql/__pycache__/mysqldb.cpython-311.pyc,,
+sqlalchemy/dialects/mysql/__pycache__/provision.cpython-311.pyc,,
+sqlalchemy/dialects/mysql/__pycache__/pymysql.cpython-311.pyc,,
+sqlalchemy/dialects/mysql/__pycache__/pyodbc.cpython-311.pyc,,
+sqlalchemy/dialects/mysql/__pycache__/reflection.cpython-311.pyc,,
+sqlalchemy/dialects/mysql/__pycache__/reserved_words.cpython-311.pyc,,
+sqlalchemy/dialects/mysql/__pycache__/types.cpython-311.pyc,,
+sqlalchemy/dialects/mysql/aiomysql.py,sha256=-YFqFQEx0M2pww3xvsOlaVKflTeoUfIsM8BgfhP1MP0,10296
+sqlalchemy/dialects/mysql/asyncmy.py,sha256=h9BBhGsqPG2LWdoh0lPieRLhaQ_BJrhxwsR_G5yPLDQ,10370
+sqlalchemy/dialects/mysql/base.py,sha256=LQ-nvj7HIQSntwAycof93th3kpMBatHl402HNQ8z9hc,124297
+sqlalchemy/dialects/mysql/cymysql.py,sha256=0mRP3gFe2t7iJYQqJz1Os_TztFwMAF34w2MmXe-4B_w,2384
+sqlalchemy/dialects/mysql/dml.py,sha256=n31-m4vfOIL0MdHpUdIfTLgaMzusfQ-yHYoJWO_ndEc,7864
+sqlalchemy/dialects/mysql/enumerated.py,sha256=Nz9Sv3ENX-1T18aEoOY8QfZlAcwRf65lIOse7vwjil8,8692
+sqlalchemy/dialects/mysql/expression.py,sha256=uxD1fICubfGh8BhAn6WoeS8AF6hAVEvreDShXqRZTqM,4238
+sqlalchemy/dialects/mysql/json.py,sha256=i0Lrd_7VKTd3fNm6kQKzrtPERuW0JeSw7XSUWnl1HQI,2350
+sqlalchemy/dialects/mysql/mariadb.py,sha256=WoNxkjiPfIbWAkrVEU9MTM7mePeLHZ2uiJsyfvcpv1s,885
+sqlalchemy/dialects/mysql/mariadbconnector.py,sha256=76uTMieZ6o3_m0HCP1hdamMWjovy5-fK_mk8SfNrD34,8843
+sqlalchemy/dialects/mysql/mysqlconnector.py,sha256=1ga6IV7lVLH9BKsMh2M2wSz78l5a82BZnyRqJMaS5Qw,5854
+sqlalchemy/dialects/mysql/mysqldb.py,sha256=l9bse7w0BwZrM96A_LKdyK4p0D_ksjflLX_OShj4JTk,9805
+sqlalchemy/dialects/mysql/provision.py,sha256=2ecdVRnZSXy5GF3hpLtQp3T8QW-oFjtTSQgbEePDH1k,3581
+sqlalchemy/dialects/mysql/pymysql.py,sha256=Kxi_A34-nbQ5UEFSmy14TXc1v43-1SZ8gE628REGTFo,4220
+sqlalchemy/dialects/mysql/pyodbc.py,sha256=CZCEnhyLIgbuiAW32Cw7N1m1aiQv1eBB34pV-txOs70,4435
+sqlalchemy/dialects/mysql/reflection.py,sha256=wn8qKHxDb9Dnr8zC_uEgAVjk2lVuObvqPOEiad8568c,23499
+sqlalchemy/dialects/mysql/reserved_words.py,sha256=qzej7CIVFz2Q2ywue7nKL59cca2kzXhKpDOSQYMlxjU,9829
+sqlalchemy/dialects/mysql/types.py,sha256=wqfI5QZ8__Uzn9cYefTMZ387cJJJgbNkCDE9Ax2k1pY,25117
+sqlalchemy/dialects/oracle/__init__.py,sha256=_yFT_k0R6yc7MKQG-Al9QZt8wYZsiCtpkhNlba5xqn8,1560
+sqlalchemy/dialects/oracle/__pycache__/__init__.cpython-311.pyc,,
+sqlalchemy/dialects/oracle/__pycache__/base.cpython-311.pyc,,
+sqlalchemy/dialects/oracle/__pycache__/cx_oracle.cpython-311.pyc,,
+sqlalchemy/dialects/oracle/__pycache__/dictionary.cpython-311.pyc,,
+sqlalchemy/dialects/oracle/__pycache__/oracledb.cpython-311.pyc,,
+sqlalchemy/dialects/oracle/__pycache__/provision.cpython-311.pyc,,
+sqlalchemy/dialects/oracle/__pycache__/types.cpython-311.pyc,,
+sqlalchemy/dialects/oracle/base.py,sha256=haztCHFbuhnhpcBUr8h1PDLXAavdwtpIjgOg_PSDI_A,121486
+sqlalchemy/dialects/oracle/cx_oracle.py,sha256=3Tx3DKvqcCKyXupBuCiCL4B8D5TDO934Q7LYsLJjlkk,57058
+sqlalchemy/dialects/oracle/dictionary.py,sha256=tmAZLEACqBAPBE0SEV2jr1R4aPcpNOrbomJl-UmgiR4,20026
+sqlalchemy/dialects/oracle/oracledb.py,sha256=kuw08rp-tXKPOtGGutqcs5o2gvRptQXAzNBqPVZoLxg,9798
+sqlalchemy/dialects/oracle/provision.py,sha256=KKlXDQnC8n6BjLJWA7AJg3lwXluH1OyStqfP2Uf9rq0,8524
+sqlalchemy/dialects/oracle/types.py,sha256=U9EReFRcr0PiwOxT9vg2cA7WOix8LQ2sVp0gRkMHcPo,8518
+sqlalchemy/dialects/postgresql/__init__.py,sha256=C0BhKzUkClwGfAetbBIEd4KQohOtSmfHo5TwhoZLCK0,4059
+sqlalchemy/dialects/postgresql/__pycache__/__init__.cpython-311.pyc,,
+sqlalchemy/dialects/postgresql/__pycache__/_psycopg_common.cpython-311.pyc,,
+sqlalchemy/dialects/postgresql/__pycache__/array.cpython-311.pyc,,
+sqlalchemy/dialects/postgresql/__pycache__/asyncpg.cpython-311.pyc,,
+sqlalchemy/dialects/postgresql/__pycache__/base.cpython-311.pyc,,
+sqlalchemy/dialects/postgresql/__pycache__/dml.cpython-311.pyc,,
+sqlalchemy/dialects/postgresql/__pycache__/ext.cpython-311.pyc,,
+sqlalchemy/dialects/postgresql/__pycache__/hstore.cpython-311.pyc,,
+sqlalchemy/dialects/postgresql/__pycache__/json.cpython-311.pyc,,
+sqlalchemy/dialects/postgresql/__pycache__/named_types.cpython-311.pyc,,
+sqlalchemy/dialects/postgresql/__pycache__/operators.cpython-311.pyc,,
+sqlalchemy/dialects/postgresql/__pycache__/pg8000.cpython-311.pyc,,
+sqlalchemy/dialects/postgresql/__pycache__/pg_catalog.cpython-311.pyc,,
+sqlalchemy/dialects/postgresql/__pycache__/provision.cpython-311.pyc,,
+sqlalchemy/dialects/postgresql/__pycache__/psycopg.cpython-311.pyc,,
+sqlalchemy/dialects/postgresql/__pycache__/psycopg2.cpython-311.pyc,,
+sqlalchemy/dialects/postgresql/__pycache__/psycopg2cffi.cpython-311.pyc,,
+sqlalchemy/dialects/postgresql/__pycache__/ranges.cpython-311.pyc,,
+sqlalchemy/dialects/postgresql/__pycache__/types.cpython-311.pyc,,
+sqlalchemy/dialects/postgresql/_psycopg_common.py,sha256=fYFqLVxNxAqh3nOvzGOv3Pfpm2BsclHrk71MJZrpJKo,5883
+sqlalchemy/dialects/postgresql/array.py,sha256=_vzfyGBY1NsT6blooCgHrLC38VZbM4UWKQHgXLmmyYs,14159
+sqlalchemy/dialects/postgresql/asyncpg.py,sha256=g2pZ8FhZtyE8-tD33WEFD2nA9H3mANq2mUtfiag1GIs,41502
+sqlalchemy/dialects/postgresql/base.py,sha256=wS7qpm6T_MpcV5wlcPPAxFun75wOshKq9eXqLRqeAdQ,183996
+sqlalchemy/dialects/postgresql/dml.py,sha256=uMiqxEkji-UXqk8gO1ramQEvEfCugYmy8Cv1cnG7DQs,11522
+sqlalchemy/dialects/postgresql/ext.py,sha256=ct6NQfMAfBnLYhybpF2wPEq-p8-U0tEpy-aq8NwqJLw,16758
+sqlalchemy/dialects/postgresql/hstore.py,sha256=4jAZQMPWl3VE4weDRZrgrbVDRZJTM3X0Xj4twr5znYQ,11938
+sqlalchemy/dialects/postgresql/json.py,sha256=XSt9Vj71cv-FFpaOVMt-hiJ8Id-nVgup_V0eRAMU4SM,11542
+sqlalchemy/dialects/postgresql/named_types.py,sha256=Ykl4GWSf5pQynkAWfZsAjgYU0R_TSvEvaZrb8mI4PuQ,18103
+sqlalchemy/dialects/postgresql/operators.py,sha256=iyZuyx_daRyJjiS5rw-XnZlaWj1bmRiHdy5MXzBrFZw,2937
+sqlalchemy/dialects/postgresql/pg8000.py,sha256=TPJXX078vW0FSwZ-DlWNkEOXg7Z4xk8IFwi1droMhPw,19302
+sqlalchemy/dialects/postgresql/pg_catalog.py,sha256=rG_AGLtjSQ6DAnkqAiurYpnIuLhN9Ib_QydWbmjK--s,9554
+sqlalchemy/dialects/postgresql/provision.py,sha256=Uo_6vxVzFryFjLqsrvesRO55VqHrnsAs_pBH_8JtFcA,5937
+sqlalchemy/dialects/postgresql/psycopg.py,sha256=kL1wUUN7V-GlveQPdf7iVWtthUZVJQNW9wNASX3RotI,24159
+sqlalchemy/dialects/postgresql/psycopg2.py,sha256=4aYG9D0ZdYMtGZ-jtCxB8094N7ddpfp2hQJ7PmziqYo,32481
+sqlalchemy/dialects/postgresql/psycopg2cffi.py,sha256=hFg-9GH08ApPy3foVPUdJKwCEzNSv2zD5l4nH97AqgI,1817
+sqlalchemy/dialects/postgresql/ranges.py,sha256=oiTmnZ-hd5WqqGNsXbuOJfoNxpbso_M_49gky8dlCrE,33978
+sqlalchemy/dialects/postgresql/types.py,sha256=pd1QmuGwJFLqpY2tK-Ql3FNjtT1Ha-lVvfaR9dimvHc,7603
+sqlalchemy/dialects/sqlite/__init__.py,sha256=MmQfjHun1U_4q-Dq_yhs9RzAX0VLixSwWeY5xWiDwag,1239
+sqlalchemy/dialects/sqlite/__pycache__/__init__.cpython-311.pyc,,
+sqlalchemy/dialects/sqlite/__pycache__/aiosqlite.cpython-311.pyc,,
+sqlalchemy/dialects/sqlite/__pycache__/base.cpython-311.pyc,,
+sqlalchemy/dialects/sqlite/__pycache__/dml.cpython-311.pyc,,
+sqlalchemy/dialects/sqlite/__pycache__/json.cpython-311.pyc,,
+sqlalchemy/dialects/sqlite/__pycache__/provision.cpython-311.pyc,,
+sqlalchemy/dialects/sqlite/__pycache__/pysqlcipher.cpython-311.pyc,,
+sqlalchemy/dialects/sqlite/__pycache__/pysqlite.cpython-311.pyc,,
+sqlalchemy/dialects/sqlite/aiosqlite.py,sha256=TgobCILLu2mjGvDgMTxX3-CPxkj_c5LDYRDJHo5W5qg,12701
+sqlalchemy/dialects/sqlite/base.py,sha256=8Ft5tZeT1lHiWliTwoJaNslf8PRITVKKWhjhhRCeVDk,99576
+sqlalchemy/dialects/sqlite/dml.py,sha256=8JV6Ise7WtmFniy590X5b19AYZcE51M6N5hef7d9JoA,8683
+sqlalchemy/dialects/sqlite/json.py,sha256=-9afZnBt07vInCX20CKzjlTG85wHTO5_cxhcYU4phDc,2869
+sqlalchemy/dialects/sqlite/provision.py,sha256=nAXZPEjXFrb6a1LxXZMqKmkQoXgl3MPsSHuMyBQ76NU,5830
+sqlalchemy/dialects/sqlite/pysqlcipher.py,sha256=p0KfzHBwANDMwKTKEJCjR5RxMYqQwS4E8KXjl3Bx6Fw,5511
+sqlalchemy/dialects/sqlite/pysqlite.py,sha256=l1nNdt0e4P4LiqesERAt8sngot8jh8sDc7HZDL_R14Q,28801
+sqlalchemy/dialects/type_migration_guidelines.txt,sha256=gyh3JCauAIFi_9XEfqm3vYv_jb2Eqcz2HjpmC9ZEPMM,8384
+sqlalchemy/engine/__init__.py,sha256=93FWhb62dLCidc6e4FE65wq_P8GeoWQG1OG6RZMBqhM,2880
+sqlalchemy/engine/__pycache__/__init__.cpython-311.pyc,,
+sqlalchemy/engine/__pycache__/_py_processors.cpython-311.pyc,,
+sqlalchemy/engine/__pycache__/_py_row.cpython-311.pyc,,
+sqlalchemy/engine/__pycache__/_py_util.cpython-311.pyc,,
+sqlalchemy/engine/__pycache__/base.cpython-311.pyc,,
+sqlalchemy/engine/__pycache__/characteristics.cpython-311.pyc,,
+sqlalchemy/engine/__pycache__/create.cpython-311.pyc,,
+sqlalchemy/engine/__pycache__/cursor.cpython-311.pyc,,
+sqlalchemy/engine/__pycache__/default.cpython-311.pyc,,
+sqlalchemy/engine/__pycache__/events.cpython-311.pyc,,
+sqlalchemy/engine/__pycache__/interfaces.cpython-311.pyc,,
+sqlalchemy/engine/__pycache__/mock.cpython-311.pyc,,
+sqlalchemy/engine/__pycache__/processors.cpython-311.pyc,,
+sqlalchemy/engine/__pycache__/reflection.cpython-311.pyc,,
+sqlalchemy/engine/__pycache__/result.cpython-311.pyc,,
+sqlalchemy/engine/__pycache__/row.cpython-311.pyc,,
+sqlalchemy/engine/__pycache__/strategies.cpython-311.pyc,,
+sqlalchemy/engine/__pycache__/url.cpython-311.pyc,,
+sqlalchemy/engine/__pycache__/util.cpython-311.pyc,,
+sqlalchemy/engine/_py_processors.py,sha256=-jlAYPM6etmuKeViiI7BD41kqY0Pr8nzaox22TPqCCQ,3880
+sqlalchemy/engine/_py_row.py,sha256=UEGCjAeRsggcUn0QB0PdFC82kuykrOiOZ1KGq_Gf_qQ,3915
+sqlalchemy/engine/_py_util.py,sha256=nh1XoVq1b-eGgkdzbqFqzje0RNSmVWotoa6yaB7J5Sw,2558
+sqlalchemy/engine/base.py,sha256=kKfJ47SMw3LHw4LzfAXzunnGVAL44DFRS_s3c42OVww,126271
+sqlalchemy/engine/characteristics.py,sha256=hfTuHv_WxSNHOS_LFIypSb27lqoZKRXIQKyT7ay5lTY,4920
+sqlalchemy/engine/create.py,sha256=-SCpvMx3DIwt8TD6Cyh_ChieKQ8y3hDD9YLDBIKgY6o,34081
+sqlalchemy/engine/cursor.py,sha256=zKN-AiwE-0KkvdWqhg8dOAT4R1U1a4I0tFgAqzihSnE,78573
+sqlalchemy/engine/default.py,sha256=4y8rliMWsWeMd1gGEljZH0dNrJ1JoXwj36tKfVfic7k,86485
+sqlalchemy/engine/events.py,sha256=e0VHj69fH20sB7gocBhr5Rs2FjR8ioY4iE8VQt70oJg,38332
+sqlalchemy/engine/interfaces.py,sha256=xc_QjKogI0vWG1BQMb-0pexDrmgyy1jQR9xvRW5ECOE,116227
+sqlalchemy/engine/mock.py,sha256=wInBRiHwydTc5ELQLivdezDd1ikbSMVXgLVzZrSC0iQ,4310
+sqlalchemy/engine/processors.py,sha256=w4MiVMlU6VvfhIW49nygbHcwX8FteGpz7g3IGEqtZb8,2440
+sqlalchemy/engine/reflection.py,sha256=TO-tymk7BsfAzc6Fi0GmwtYyOWjfMGkyvytJyMVz_oY,77216
+sqlalchemy/engine/result.py,sha256=U245Q3kGUOugqjmv-qSkx8eyDn27fLYV5agIoBHXQCA,79985
+sqlalchemy/engine/row.py,sha256=g7ZqmsqX_BtRUzY-zfXoZZ4-5xZ_KJEVbvqKHUIlqRg,12433
+sqlalchemy/engine/strategies.py,sha256=fD4DJn0AD371wlUa7s5Sy4j7QtgGyP7gMy_kUyqCLDQ,461
+sqlalchemy/engine/url.py,sha256=tOCRmKkqrpsIfNeSDoy6KKTLtQAMtoIn9xa5kmJQebk,31694
+sqlalchemy/engine/util.py,sha256=wIrPulEwr7kAxJ-vNj5QSPGNfWoFx5B4zzJdXu_ZIFg,5849
+sqlalchemy/event/__init__.py,sha256=09qZzHwt0PkIDsPwuPUVJvNakjtCBjuUJeY0AEJ9j7k,1022
+sqlalchemy/event/__pycache__/__init__.cpython-311.pyc,,
+sqlalchemy/event/__pycache__/api.cpython-311.pyc,,
+sqlalchemy/event/__pycache__/attr.cpython-311.pyc,,
+sqlalchemy/event/__pycache__/base.cpython-311.pyc,,
+sqlalchemy/event/__pycache__/legacy.cpython-311.pyc,,
+sqlalchemy/event/__pycache__/registry.cpython-311.pyc,,
+sqlalchemy/event/api.py,sha256=I7XWFczjgl3RcBH_52TbQ0S3_W4RZz1Be9dXkxtFw5U,8451
+sqlalchemy/event/attr.py,sha256=-SHjzXMOs7IICPSgNwpgRS3FIEeLIpB5PyvVlpw8Gp8,21406
+sqlalchemy/event/base.py,sha256=haAsH-KuvvY52A6OjwATfvCXy3hdYGgZxkDZiOqbMvI,15416
+sqlalchemy/event/legacy.py,sha256=a8VEvS83PvgbomNnaSa3okZmTkxl_buZ7Lfilechjh8,8473
+sqlalchemy/event/registry.py,sha256=f31k0FLqIlWpOK9tksiYXnv-yuZPPz9iLQqvKEYV7ko,11221
+sqlalchemy/events.py,sha256=OAy8TK21lWzSe8bDUnAbmsP82bsBYy0LL19hR6y3BrM,542
+sqlalchemy/exc.py,sha256=k01TD2xp2BM3DrXdo2U5r8yuRfsoqBND4kwvtD1SVN0,24806
+sqlalchemy/ext/__init__.py,sha256=YbMQmRS_9HxRyWM-KA_F76WOss1_Em1ZcrnQDIDXoOc,333
+sqlalchemy/ext/__pycache__/__init__.cpython-311.pyc,,
+sqlalchemy/ext/__pycache__/associationproxy.cpython-311.pyc,,
+sqlalchemy/ext/__pycache__/automap.cpython-311.pyc,,
+sqlalchemy/ext/__pycache__/baked.cpython-311.pyc,,
+sqlalchemy/ext/__pycache__/compiler.cpython-311.pyc,,
+sqlalchemy/ext/__pycache__/horizontal_shard.cpython-311.pyc,,
+sqlalchemy/ext/__pycache__/hybrid.cpython-311.pyc,,
+sqlalchemy/ext/__pycache__/indexable.cpython-311.pyc,,
+sqlalchemy/ext/__pycache__/instrumentation.cpython-311.pyc,,
+sqlalchemy/ext/__pycache__/mutable.cpython-311.pyc,,
+sqlalchemy/ext/__pycache__/orderinglist.cpython-311.pyc,,
+sqlalchemy/ext/__pycache__/serializer.cpython-311.pyc,,
+sqlalchemy/ext/associationproxy.py,sha256=MBtGwISA4wwT9i6op8jfY6u9lCUYn_4JCqtxZpjggok,67776
+sqlalchemy/ext/asyncio/__init__.py,sha256=tKYIrERYf8hov9m8DuKWRO_53qhrvj2jRmIYjSGQ2Po,1342
+sqlalchemy/ext/asyncio/__pycache__/__init__.cpython-311.pyc,,
+sqlalchemy/ext/asyncio/__pycache__/base.cpython-311.pyc,,
+sqlalchemy/ext/asyncio/__pycache__/engine.cpython-311.pyc,,
+sqlalchemy/ext/asyncio/__pycache__/exc.cpython-311.pyc,,
+sqlalchemy/ext/asyncio/__pycache__/result.cpython-311.pyc,,
+sqlalchemy/ext/asyncio/__pycache__/scoping.cpython-311.pyc,,
+sqlalchemy/ext/asyncio/__pycache__/session.cpython-311.pyc,,
+sqlalchemy/ext/asyncio/base.py,sha256=slWQTFdgQQlkzrnx3m5a9xT8IRg4iM0gkEbypXr_YXQ,9184
+sqlalchemy/ext/asyncio/engine.py,sha256=HJ5IZD0_xfVOMEGYZ1XtDir73SpzBk6ODDUN75ltvzo,49656
+sqlalchemy/ext/asyncio/exc.py,sha256=0awLfUB4PhEPVVTKYluyor1tW91GPZZnvdQ-GGSOmJY,660
+sqlalchemy/ext/asyncio/result.py,sha256=MtKAqA7hwYIdkpRxlCgHNYYzlB7dvqCtEp-aoDdFjDA,31370
+sqlalchemy/ext/asyncio/scoping.py,sha256=CiMQ7ewPNsyEtl9aGOiEZOrUaNYOTP_LrR0_xkdV3r8,54211
+sqlalchemy/ext/asyncio/session.py,sha256=vqP3qYsUyVqXas30zdMmnymXLrNCYqgExeWrgK-Hcn0,65028
+sqlalchemy/ext/automap.py,sha256=q9_8jk1puxgfGiYTX5il6snOHNv6bOAE7nRlQbym_cY,63280
+sqlalchemy/ext/baked.py,sha256=jc6vPocoXXsvdZsOsqgT4kG6guWSZD1TdPjoRBmkbRU,18381
+sqlalchemy/ext/compiler.py,sha256=PbvelWqZdzL6y1C6rEc8ledF79t_04MtYV26RUwNhik,20946
+sqlalchemy/ext/declarative/__init__.py,sha256=MHSOffOS4MWcqshAuLNQv0vDXpK_Z3lpGXTm1riyLls,1883
+sqlalchemy/ext/declarative/__pycache__/__init__.cpython-311.pyc,,
+sqlalchemy/ext/declarative/__pycache__/extensions.cpython-311.pyc,,
+sqlalchemy/ext/declarative/extensions.py,sha256=aPpW0PvTKH3CoSMhsOY5GcUMZOVq-OFsV1hflxmb3Lw,20095
+sqlalchemy/ext/horizontal_shard.py,sha256=V8vXEt5ZQb_PM39agZD2IyoQNGSqVI1MhY-6mNV5MRY,17231
+sqlalchemy/ext/hybrid.py,sha256=UpWd9hOD5I3hCT5FJW9twSDyShDVyygRIFtv-FmMHgM,53972
+sqlalchemy/ext/indexable.py,sha256=aDlVpN4rilRrer9qKg3kO7fqnqB5NX4M5qzYuYM8pvw,11373
+sqlalchemy/ext/instrumentation.py,sha256=lFsJECWlN1oc1E0r9TaQDZcxAx4VOz6PSHYrl5fLk9Y,16157
+sqlalchemy/ext/mutable.py,sha256=nAz3_lF2xkYSARt7GAWQh-OUMcnpe6s1ocjvQGxCPkc,38428
+sqlalchemy/ext/mypy/__init__.py,sha256=aqT8_9sNwzC8PIaEZ4zkCYGBvYPaDD3eCgJtJuk3g6A,247
+sqlalchemy/ext/mypy/__pycache__/__init__.cpython-311.pyc,,
+sqlalchemy/ext/mypy/__pycache__/apply.cpython-311.pyc,,
+sqlalchemy/ext/mypy/__pycache__/decl_class.cpython-311.pyc,,
+sqlalchemy/ext/mypy/__pycache__/infer.cpython-311.pyc,,
+sqlalchemy/ext/mypy/__pycache__/names.cpython-311.pyc,,
+sqlalchemy/ext/mypy/__pycache__/plugin.cpython-311.pyc,,
+sqlalchemy/ext/mypy/__pycache__/util.cpython-311.pyc,,
+sqlalchemy/ext/mypy/apply.py,sha256=1Qb-_FpQ_0LVB2KFA5hVjfPv6DDMIcxXe86Ts1X9GBk,10870
+sqlalchemy/ext/mypy/decl_class.py,sha256=f2iWiFVlDFqGb_IoGGotI3IEOUErh25sLT7B_cMfx0g,17899
+sqlalchemy/ext/mypy/infer.py,sha256=O-3IjELDSBEAwGGxRM7lr0NWwGD0HMK4vda_iY6iwjs,19959
+sqlalchemy/ext/mypy/names.py,sha256=2bHYuQJe71c9JtuJSZP-WWGiOJmY9-FuMQGMDBB6dRs,10814
+sqlalchemy/ext/mypy/plugin.py,sha256=TDTziLsYFRqyX8UcQMtBBa6TFR4z9N-XNO8wRkHlEOI,10053
+sqlalchemy/ext/mypy/util.py,sha256=3iQ1zVpXSUoj2aHa-Kkg4O83JOzqVd8TDEwpZj3SWWs,9786
+sqlalchemy/ext/orderinglist.py,sha256=r7La_3nZlGevIgsBL1IB30FvWO_tZHlTKo_FWwid-aY,14800
+sqlalchemy/ext/serializer.py,sha256=_7gottqRCI-qkW4Go4o2EnOSnieKDCQ8jQ6muHXw-RM,6363
+sqlalchemy/future/__init__.py,sha256=6-qPdjMHX-V-kAPjTQgNuHztmYiwKlJhKhhljuETvoQ,528
+sqlalchemy/future/__pycache__/__init__.cpython-311.pyc,,
+sqlalchemy/future/__pycache__/engine.cpython-311.pyc,,
+sqlalchemy/future/engine.py,sha256=N_5W2ab5-ueedWzqNdgLPzTW9audT1IbxF6FCDLRZOc,510
+sqlalchemy/inspection.py,sha256=GpmMuSAZ53u4W__iGpvzQKCBMFnTxnHt4Lo7Nq1FSKM,5237
+sqlalchemy/log.py,sha256=Sg6PGR_wmseiCCpJfRDEkaMs08XTPPsf0X_iYJLvzS0,8895
+sqlalchemy/orm/__init__.py,sha256=I-XesvuyjkAAwnsiF5FnXRLNV6W2nW70EnGAIt2GAjU,8633
+sqlalchemy/orm/__pycache__/__init__.cpython-311.pyc,,
+sqlalchemy/orm/__pycache__/_orm_constructors.cpython-311.pyc,,
+sqlalchemy/orm/__pycache__/_typing.cpython-311.pyc,,
+sqlalchemy/orm/__pycache__/attributes.cpython-311.pyc,,
+sqlalchemy/orm/__pycache__/base.cpython-311.pyc,,
+sqlalchemy/orm/__pycache__/bulk_persistence.cpython-311.pyc,,
+sqlalchemy/orm/__pycache__/clsregistry.cpython-311.pyc,,
+sqlalchemy/orm/__pycache__/collections.cpython-311.pyc,,
+sqlalchemy/orm/__pycache__/context.cpython-311.pyc,,
+sqlalchemy/orm/__pycache__/decl_api.cpython-311.pyc,,
+sqlalchemy/orm/__pycache__/decl_base.cpython-311.pyc,,
+sqlalchemy/orm/__pycache__/dependency.cpython-311.pyc,,
+sqlalchemy/orm/__pycache__/descriptor_props.cpython-311.pyc,,
+sqlalchemy/orm/__pycache__/dynamic.cpython-311.pyc,,
+sqlalchemy/orm/__pycache__/evaluator.cpython-311.pyc,,
+sqlalchemy/orm/__pycache__/events.cpython-311.pyc,,
+sqlalchemy/orm/__pycache__/exc.cpython-311.pyc,,
+sqlalchemy/orm/__pycache__/identity.cpython-311.pyc,,
+sqlalchemy/orm/__pycache__/instrumentation.cpython-311.pyc,,
+sqlalchemy/orm/__pycache__/interfaces.cpython-311.pyc,,
+sqlalchemy/orm/__pycache__/loading.cpython-311.pyc,,
+sqlalchemy/orm/__pycache__/mapped_collection.cpython-311.pyc,,
+sqlalchemy/orm/__pycache__/mapper.cpython-311.pyc,,
+sqlalchemy/orm/__pycache__/path_registry.cpython-311.pyc,,
+sqlalchemy/orm/__pycache__/persistence.cpython-311.pyc,,
+sqlalchemy/orm/__pycache__/properties.cpython-311.pyc,,
+sqlalchemy/orm/__pycache__/query.cpython-311.pyc,,
+sqlalchemy/orm/__pycache__/relationships.cpython-311.pyc,,
+sqlalchemy/orm/__pycache__/scoping.cpython-311.pyc,,
+sqlalchemy/orm/__pycache__/session.cpython-311.pyc,,
+sqlalchemy/orm/__pycache__/state.cpython-311.pyc,,
+sqlalchemy/orm/__pycache__/state_changes.cpython-311.pyc,,
+sqlalchemy/orm/__pycache__/strategies.cpython-311.pyc,,
+sqlalchemy/orm/__pycache__/strategy_options.cpython-311.pyc,,
+sqlalchemy/orm/__pycache__/sync.cpython-311.pyc,,
+sqlalchemy/orm/__pycache__/unitofwork.cpython-311.pyc,,
+sqlalchemy/orm/__pycache__/util.cpython-311.pyc,,
+sqlalchemy/orm/__pycache__/writeonly.cpython-311.pyc,,
+sqlalchemy/orm/_orm_constructors.py,sha256=xLdlm6hTk7mDHZLpUi5Y3QOZkI9rAHtze2tQQRZVerg,101932
+sqlalchemy/orm/_typing.py,sha256=Z9GZT8Vb-wFwvHeOeVE37dvmCWdItLZnqI_pLin4cMc,5152
+sqlalchemy/orm/attributes.py,sha256=n4gfW0mFEqwRqezFwd5SBIIusK3B9EgBtnTS1Splq34,95370
+sqlalchemy/orm/base.py,sha256=1yljObgot8oYfYoq3X13jfMMxSfdrMcLMPCcBPrrf9s,28437
+sqlalchemy/orm/bulk_persistence.py,sha256=arYeLK98O2jhX-VdtVLqaOUc-f-F0re6Q3m2BoSymWM,72141
+sqlalchemy/orm/clsregistry.py,sha256=ZumBI7I2O-l93LbA4eyMKm0w6al-nNS2QV1VDcJxGko,18528
+sqlalchemy/orm/collections.py,sha256=lHjP6uDz0WdwedTqyh_8R2_nzRAK_5ONCIoisHrsb94,53797
+sqlalchemy/orm/context.py,sha256=2nMlrdBEtqLSIsk2cxoIUa71UUrWEFGJh3utZNCyxw4,115700
+sqlalchemy/orm/decl_api.py,sha256=i6mXKqNrCxu3bJKhhBt_KtsPZHVVDHemAFEQpUdQvAM,65881
+sqlalchemy/orm/decl_base.py,sha256=g6bhTg5M9hsf3JVnMaqn1NS7MTdBJY--L-qf9aQabgs,83753
+sqlalchemy/orm/dependency.py,sha256=glstmbB4t-PIRA47u9NgTyyxbENfyQuG9Uzj2iezB_s,48935
+sqlalchemy/orm/descriptor_props.py,sha256=PpDt83EX72AhCbBjixQDpYG1P1MqWqGdA-bJpXMSxSw,38254
+sqlalchemy/orm/dynamic.py,sha256=m7V2GPS5__4y_hP7BQjD66b6BVEre1pzPwaj2bmRFRM,10084
+sqlalchemy/orm/evaluator.py,sha256=gQIDxuoB5Ut2hiFdN768U67JusVkbFt-Bdna_T8npPA,12293
+sqlalchemy/orm/events.py,sha256=UHJ9ZD1WFrFssXbrGEVq0KJQkId0VgKACAnORFVlabg,130962
+sqlalchemy/orm/exc.py,sha256=fd24WdW3CP3oxFcz9CLXPeBIAfqJZbKv7K4G-5X4EOg,7641
+sqlalchemy/orm/identity.py,sha256=fOpANTf73r12F_w9DhVoyjkAdh8ldgJcNnwxx0GY8YM,9551
+sqlalchemy/orm/instrumentation.py,sha256=a8vi3qEAyO7Z9PYksLkFi_YzxqQhzB-anblegiAtsFw,25075
+sqlalchemy/orm/interfaces.py,sha256=tTV0drZDoYX2MhHUYQEGoALuTWxgfNdnKeYM3I38BO8,49971
+sqlalchemy/orm/loading.py,sha256=RCEUmTS--9QntLQcnwYVxHRsC3ILE58AVNHb8MGcybg,59959
+sqlalchemy/orm/mapped_collection.py,sha256=AeSzQwj56cLr1tVMC0B-3JsC74IAP7_gbr-EPc4_2uw,20250
+sqlalchemy/orm/mapper.py,sha256=WSDQZ_rwMd6mEwJDaS9oztcCBuNjw7fb5NlJiaLQtl0,175509
+sqlalchemy/orm/path_registry.py,sha256=GQS4KatFTi_6LKdi6I4185igHE6DDwrm8b1AMOHMom4,26731
+sqlalchemy/orm/persistence.py,sha256=MKb7TuSLJUQpyqnHxf6uNmGXSznmZgkkFTD04nHbNUQ,63483
+sqlalchemy/orm/properties.py,sha256=DicF2OHW-b5z7xJrahELKd5OPm9cVfTIYjQcoEM1naw,30192
+sqlalchemy/orm/query.py,sha256=7cxWJw-bfxtNEwUIitF3MW3JiJPMJu4EnAbl-lMI5aY,120990
+sqlalchemy/orm/relationships.py,sha256=tj00j1ISHQmJbWeegWn8U29lL6WUnqd8fdY7NRHcLWU,132144
+sqlalchemy/orm/scoping.py,sha256=aAQMIAAZ-M_m6UGndmkUiDazcphE-klw6wZjFT2Az7E,80842
+sqlalchemy/orm/session.py,sha256=jlPYQoKYTO1ragBcPpaXbO8OU4TgW5vTwrv59hVUBr8,200540
+sqlalchemy/orm/state.py,sha256=9opH8AR6LnbCRmW1lN2RxEQyxnEi1rcDXlySqrDeUiw,38656
+sqlalchemy/orm/state_changes.py,sha256=4i90vDgBGvVGUzhlonlBkZBAZFOWaAXij2X8OEA3-BA,7013
+sqlalchemy/orm/strategies.py,sha256=GFppPikNxZJdsi4DW1HcU6pv-EvIeFvTI8K_LDY5nmk,117550
+sqlalchemy/orm/strategy_options.py,sha256=XwkyZ0vu1_P9hrecyROHw7wsjqstuKfsfGAm4W_78x8,87935
+sqlalchemy/orm/sync.py,sha256=aMEMhYTj2rtJZJvjqm-cUx2CoQxYl8P6YddCLpLelhM,5943
+sqlalchemy/orm/unitofwork.py,sha256=THggzzAaqmYh5PBDob5dHTP_YyHXYdscs3fIxtRV-gE,27829
+sqlalchemy/orm/util.py,sha256=FSxDa0XwheHyU28ahF1KfdaPp_-9n4P5D_CO2GhjIOQ,83076
+sqlalchemy/orm/writeonly.py,sha256=j5DcpZKOv1tLGQLhKfk-Uw-B0yEG7LezwJWNTq0FtWQ,22983
+sqlalchemy/pool/__init__.py,sha256=ZKUPMKdBU57mhu677UsvRs5Aq9s9BwIbMmSNRoTRPoY,1848
+sqlalchemy/pool/__pycache__/__init__.cpython-311.pyc,,
+sqlalchemy/pool/__pycache__/base.cpython-311.pyc,,
+sqlalchemy/pool/__pycache__/events.cpython-311.pyc,,
+sqlalchemy/pool/__pycache__/impl.cpython-311.pyc,,
+sqlalchemy/pool/base.py,sha256=D0sKTRla6wpIFbELyGY2JEHUHR324rveIl93qjjmYr8,53751
+sqlalchemy/pool/events.py,sha256=ysyFh0mNDpL4N4rQ-o_BC6tpo_zt0_au_QLBgJqaKY8,13517
+sqlalchemy/pool/impl.py,sha256=BU5vUQ6NDFIldsG9og6mtO14SsqwpUqvwyGqZsKT6i0,19525
+sqlalchemy/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sqlalchemy/schema.py,sha256=UFhZjGmYoqN3zkId7M4CbVCd8KaeZUfKUjdlk0sHQ_E,3264
+sqlalchemy/sql/__init__.py,sha256=T16ZB3Za0Tq1LQGXeJuuxDkyu2t-XHR2t-8QH1mE1Uw,5965
+sqlalchemy/sql/__pycache__/__init__.cpython-311.pyc,,
+sqlalchemy/sql/__pycache__/_dml_constructors.cpython-311.pyc,,
+sqlalchemy/sql/__pycache__/_elements_constructors.cpython-311.pyc,,
+sqlalchemy/sql/__pycache__/_orm_types.cpython-311.pyc,,
+sqlalchemy/sql/__pycache__/_py_util.cpython-311.pyc,,
+sqlalchemy/sql/__pycache__/_selectable_constructors.cpython-311.pyc,,
+sqlalchemy/sql/__pycache__/_typing.cpython-311.pyc,,
+sqlalchemy/sql/__pycache__/annotation.cpython-311.pyc,,
+sqlalchemy/sql/__pycache__/base.cpython-311.pyc,,
+sqlalchemy/sql/__pycache__/cache_key.cpython-311.pyc,,
+sqlalchemy/sql/__pycache__/coercions.cpython-311.pyc,,
+sqlalchemy/sql/__pycache__/compiler.cpython-311.pyc,,
+sqlalchemy/sql/__pycache__/crud.cpython-311.pyc,,
+sqlalchemy/sql/__pycache__/ddl.cpython-311.pyc,,
+sqlalchemy/sql/__pycache__/default_comparator.cpython-311.pyc,,
+sqlalchemy/sql/__pycache__/dml.cpython-311.pyc,,
+sqlalchemy/sql/__pycache__/elements.cpython-311.pyc,,
+sqlalchemy/sql/__pycache__/events.cpython-311.pyc,,
+sqlalchemy/sql/__pycache__/expression.cpython-311.pyc,,
+sqlalchemy/sql/__pycache__/functions.cpython-311.pyc,,
+sqlalchemy/sql/__pycache__/lambdas.cpython-311.pyc,,
+sqlalchemy/sql/__pycache__/naming.cpython-311.pyc,,
+sqlalchemy/sql/__pycache__/operators.cpython-311.pyc,,
+sqlalchemy/sql/__pycache__/roles.cpython-311.pyc,,
+sqlalchemy/sql/__pycache__/schema.cpython-311.pyc,,
+sqlalchemy/sql/__pycache__/selectable.cpython-311.pyc,,
+sqlalchemy/sql/__pycache__/sqltypes.cpython-311.pyc,,
+sqlalchemy/sql/__pycache__/traversals.cpython-311.pyc,,
+sqlalchemy/sql/__pycache__/type_api.cpython-311.pyc,,
+sqlalchemy/sql/__pycache__/util.cpython-311.pyc,,
+sqlalchemy/sql/__pycache__/visitors.cpython-311.pyc,,
+sqlalchemy/sql/_dml_constructors.py,sha256=1xMH5Kd6SLhlFwfIs_lOXGC8GTrqW8mQM7Kc3cKyLuw,4007
+sqlalchemy/sql/_elements_constructors.py,sha256=gYSQwuVF0rTd40zGCrPzHdBAZj5kaCtf27S6sCVhbSU,64895
+sqlalchemy/sql/_orm_types.py,sha256=_bzlAh3-vTIZoLvAM2ry1SF7rsYRM3-jupfhGWZZn5Y,645
+sqlalchemy/sql/_py_util.py,sha256=VzThcXk7fKqT9_mZmXrkxePdwyyl_wIciCftzl2Z_-g,2248
+sqlalchemy/sql/_selectable_constructors.py,sha256=mRgtlGyctlb1LMBqFxgn0eGzIXMbyZtQafjUuJWhYjs,19415
+sqlalchemy/sql/_typing.py,sha256=FzAwrbL9o2CMluxxj1MfYh9ut7NDqkzD6dkWk5tz_dI,13231
+sqlalchemy/sql/annotation.py,sha256=PslN1KQV9hN8Ji4k8I3-W-cDuRMCCLwMmJcg-n86Yy4,18830
+sqlalchemy/sql/base.py,sha256=e8lPtvznlRmFilfvhO0721rsq2ShadtRoivSvIcAI2o,76084
+sqlalchemy/sql/cache_key.py,sha256=nEvUQ4yjtWWblrKjLLDd_b9i5zudgYhkOdJvI1U8Lvo,34725
+sqlalchemy/sql/coercions.py,sha256=O6PA7Gzhr9XQedJs3zIngCivN1vcrNyEhFueN5CqriI,41882
+sqlalchemy/sql/compiler.py,sha256=LHzSUkjNiJZlKGRovv0v6oy7omVD-YRSGN_2NKpEzn4,282463
+sqlalchemy/sql/crud.py,sha256=I5nPPnujtNKHC5C2v1vW4A0mbyomwChT21IYOX3z5fw,58190
+sqlalchemy/sql/ddl.py,sha256=NbW8F3UT4BTnda5w5TNPGxXPtv0wHSNB51hhr4gBSJM,46980
+sqlalchemy/sql/default_comparator.py,sha256=lXmd8yAUzfyeP5w4vebrQG99oC0bTrmdGc0crBq1GKw,17259
+sqlalchemy/sql/dml.py,sha256=lt5FC6BbJNotE65U-fmvEovBxkADfKBnVcnkVYYQxUM,67431
+sqlalchemy/sql/elements.py,sha256=ugtfbolfLwgoxKYpu1zKEJBs5eYIpKAw4pYhKIRWMfQ,180054
+sqlalchemy/sql/events.py,sha256=pG3jqJbPX18N9Amp47aXiQYMYD_HL_lOXHk-0m8m7Hw,18745
+sqlalchemy/sql/expression.py,sha256=T-AgCPp30tgKQYLKeSyqQg_VoJFE69m2yDTz6fn-u1E,7748
+sqlalchemy/sql/functions.py,sha256=9iazLxbvCMH35CzgtZaNJ0IUn8wz04w9DofY3jNfIHc,65817
+sqlalchemy/sql/lambdas.py,sha256=eKlhUhD8urNVvOm_1tUf8ESPIpo2qTAidKHJEarUhj8,50741
+sqlalchemy/sql/naming.py,sha256=ERVjqo6fBHBw2BwNgpbb5cvsCkq1jjdztczP9BKzVt8,7070
+sqlalchemy/sql/operators.py,sha256=6rpSbuFon7iIUCT4SDowYctDyOmFpe2-FdLu2HIX3x8,78508
+sqlalchemy/sql/roles.py,sha256=8nO4y1hbP1cA8IzeOn6uPgNZNVILb3E-IMeJWOIScu8,7985
+sqlalchemy/sql/schema.py,sha256=YwuzYFaP7BtJr5dDoEBIRbYbqE4spMhbux51zL7DDuU,235372
+sqlalchemy/sql/selectable.py,sha256=xz5T08lU9xHpCQKyXRaot7TsEalzmpjqHOOI_DqlJTw,240437
+sqlalchemy/sql/sqltypes.py,sha256=Yo0FaBhO9EZ_IvKqaqsPjzNPjb1V_goVK13I1KJlwno,129862
+sqlalchemy/sql/traversals.py,sha256=p2iXAQc0FvV-l1Q3NNMxIhRYTm8U3Ul630jG3Ys6qCI,34611
+sqlalchemy/sql/type_api.py,sha256=Okt_vXFk8L0_mDHiX5lrtAgirx62EUnXKyBMpmV62yw,85511
+sqlalchemy/sql/util.py,sha256=ftTiyNGeJK0MIRMqWMV7Xf8iZuiRGocoJRp3MIO3F3Y,49563
+sqlalchemy/sql/visitors.py,sha256=oudlabsf9qleuC78GFe_iflRSAD8H-HjaM7T8Frc538,37482
+sqlalchemy/testing/__init__.py,sha256=8iT66v5k4J9RmquaH4GLI2DjEA7c_JZSTVig-uuBNw8,3221
+sqlalchemy/testing/__pycache__/__init__.cpython-311.pyc,,
+sqlalchemy/testing/__pycache__/assertions.cpython-311.pyc,,
+sqlalchemy/testing/__pycache__/assertsql.cpython-311.pyc,,
+sqlalchemy/testing/__pycache__/asyncio.cpython-311.pyc,,
+sqlalchemy/testing/__pycache__/config.cpython-311.pyc,,
+sqlalchemy/testing/__pycache__/engines.cpython-311.pyc,,
+sqlalchemy/testing/__pycache__/entities.cpython-311.pyc,,
+sqlalchemy/testing/__pycache__/exclusions.cpython-311.pyc,,
+sqlalchemy/testing/__pycache__/pickleable.cpython-311.pyc,,
+sqlalchemy/testing/__pycache__/profiling.cpython-311.pyc,,
+sqlalchemy/testing/__pycache__/provision.cpython-311.pyc,,
+sqlalchemy/testing/__pycache__/requirements.cpython-311.pyc,,
+sqlalchemy/testing/__pycache__/schema.cpython-311.pyc,,
+sqlalchemy/testing/__pycache__/util.cpython-311.pyc,,
+sqlalchemy/testing/__pycache__/warnings.cpython-311.pyc,,
+sqlalchemy/testing/assertions.py,sha256=bBn2Ep89FF-WBmzh0VkvnJ9gNMKuqk8OXq7ALpUwar4,32428
+sqlalchemy/testing/assertsql.py,sha256=gj4YRBR9cjOtS1WgR3nsyIze1tmqctsNs1uCV8N2Q4w,17333
+sqlalchemy/testing/asyncio.py,sha256=xYuWjKFHzolBLgddy1ePI9l8KRRUOWpT-FWjhtV2Ei0,3965
+sqlalchemy/testing/config.py,sha256=jfFVUiAOm8im6SlqyAdZVSaA51kmADgfBDqrHnngH7c,12517
+sqlalchemy/testing/engines.py,sha256=8R7nbmLNUv2w7tiyVpiVI1s-57wpEs70UAgY-pkPX8k,13953
+sqlalchemy/testing/entities.py,sha256=Um-DFSz81p06DhTK899ZRUOZRw3FtUDeNMVHcIg3eLc,3471
+sqlalchemy/testing/exclusions.py,sha256=8kjsaFfjCvPlLsQLD_LIDwuqvVlIVbD5qTWBlKdtNkM,12895
+sqlalchemy/testing/fixtures/__init__.py,sha256=B1IFCzEVdCqhEvFrLmgxZ_Fr08jDus5FddSA-lnnAAU,1226
+sqlalchemy/testing/fixtures/__pycache__/__init__.cpython-311.pyc,,
+sqlalchemy/testing/fixtures/__pycache__/base.cpython-311.pyc,,
+sqlalchemy/testing/fixtures/__pycache__/mypy.cpython-311.pyc,,
+sqlalchemy/testing/fixtures/__pycache__/orm.cpython-311.pyc,,
+sqlalchemy/testing/fixtures/__pycache__/sql.cpython-311.pyc,,
+sqlalchemy/testing/fixtures/base.py,sha256=S0ODuph0jA2Za4GN3NNhYVIqN9jAa3Q9Vd1N4O4rcTc,12622
+sqlalchemy/testing/fixtures/mypy.py,sha256=2H8QxvGvwsb_Z3alRtvCvfXeqGjOb8aemfoYxQiuGMc,12285
+sqlalchemy/testing/fixtures/orm.py,sha256=6JvQpIfmgmSTH3Hie4nhmUFfvH0pseujIFA9Lup2Dzw,6322
+sqlalchemy/testing/fixtures/sql.py,sha256=BLtJYAQZ3NjIwNrK_E9miordz7utWzjYqePj88hN3NA,16267
+sqlalchemy/testing/pickleable.py,sha256=uYLl557iNep6jSOVl0vK1GwaLHUKidALoPJc-QIrC08,2988
+sqlalchemy/testing/plugin/__init__.py,sha256=bbtVIt7LzVnUCcVxHWRH2owOQD067bQwwhyMf_whqHs,253
+sqlalchemy/testing/plugin/__pycache__/__init__.cpython-311.pyc,,
+sqlalchemy/testing/plugin/__pycache__/bootstrap.cpython-311.pyc,,
+sqlalchemy/testing/plugin/__pycache__/plugin_base.cpython-311.pyc,,
+sqlalchemy/testing/plugin/__pycache__/pytestplugin.cpython-311.pyc,,
+sqlalchemy/testing/plugin/bootstrap.py,sha256=USn6pE-JcE5pSmnEd2wad3goKLx2hdJS3AUUFpXHm-I,1736
+sqlalchemy/testing/plugin/plugin_base.py,sha256=CgrNj2wj9KNALu9YfnGSaHX2fXfTtiim_cfx0CPVoy8,22357
+sqlalchemy/testing/plugin/pytestplugin.py,sha256=acuAWFec8QGzC_AWOhTsRRgB6dttkbNdoyGVb7WvTng,28524
+sqlalchemy/testing/profiling.py,sha256=o8_V3TpF_WytudMQQLm1UxlfNDrLCWxUvkH-Kd0unKU,10472
+sqlalchemy/testing/provision.py,sha256=ciWoXf3P9ql4hh1yBp0RNEtPr5vyvPbd8RD_DYxNG9U,15115
+sqlalchemy/testing/requirements.py,sha256=L_DKVqVxVMbB3JveC_6UhD5oVry2KjBHPxfQd35hrWQ,53600
+sqlalchemy/testing/schema.py,sha256=z2Z5rm3iJ1-vgifUxwzxEjt1qu7QOyr3TeDnQdCHlWE,6737
+sqlalchemy/testing/suite/__init__.py,sha256=YvTEqUNHaBlgLgWDAWn79mQrUR4VBGUHtprywJlmDT8,741
+sqlalchemy/testing/suite/__pycache__/__init__.cpython-311.pyc,,
+sqlalchemy/testing/suite/__pycache__/test_cte.cpython-311.pyc,,
+sqlalchemy/testing/suite/__pycache__/test_ddl.cpython-311.pyc,,
+sqlalchemy/testing/suite/__pycache__/test_deprecations.cpython-311.pyc,,
+sqlalchemy/testing/suite/__pycache__/test_dialect.cpython-311.pyc,,
+sqlalchemy/testing/suite/__pycache__/test_insert.cpython-311.pyc,,
+sqlalchemy/testing/suite/__pycache__/test_reflection.cpython-311.pyc,,
+sqlalchemy/testing/suite/__pycache__/test_results.cpython-311.pyc,,
+sqlalchemy/testing/suite/__pycache__/test_rowcount.cpython-311.pyc,,
+sqlalchemy/testing/suite/__pycache__/test_select.cpython-311.pyc,,
+sqlalchemy/testing/suite/__pycache__/test_sequence.cpython-311.pyc,,
+sqlalchemy/testing/suite/__pycache__/test_types.cpython-311.pyc,,
+sqlalchemy/testing/suite/__pycache__/test_unicode_ddl.cpython-311.pyc,,
+sqlalchemy/testing/suite/__pycache__/test_update_delete.cpython-311.pyc,,
+sqlalchemy/testing/suite/test_cte.py,sha256=C_viXJKClFAm91rtPb42tiAA7gYJwKkqGYVJYap0cLM,6662
+sqlalchemy/testing/suite/test_ddl.py,sha256=k6D6RreLkDSSpRUM2hQz-_CA48qV2PYx_2LNyUSoZzE,12420
+sqlalchemy/testing/suite/test_deprecations.py,sha256=SKRFZDteBO1rw9-BQjDic5nh7fdyw2ypVOewR2pj7-Q,5490
+sqlalchemy/testing/suite/test_dialect.py,sha256=ftOWRXWOotB2_jMJJqwoH9f3X2ucc1HwwOiXp573GwM,23663
+sqlalchemy/testing/suite/test_insert.py,sha256=v3zrUZaGlke3cI4vabHg7xaI4gNqcHhtMPgYuf0mOxc,19454
+sqlalchemy/testing/suite/test_reflection.py,sha256=C6P9ccG5Eog5uiIHO4s6M7ThnBbEUZKh83CmOMn-KSo,109594
+sqlalchemy/testing/suite/test_results.py,sha256=1SlvhdioM1_ZrkQX2IJbJgXNHuleizwAge6-XvHtA0s,16405
+sqlalchemy/testing/suite/test_rowcount.py,sha256=DCEGxorDcrT5JCLd3_SNQeZmxT6sKIcuKxX1r6vK4Mg,8158
+sqlalchemy/testing/suite/test_select.py,sha256=NwHUSVc4UptVYMGjp3QVLr0OpGxpz2qJG4cNWZW8vTo,60462
+sqlalchemy/testing/suite/test_sequence.py,sha256=sIqkfgVqPIgl4lm75EPdag9gK-rTHfUm3pWX-JijPy4,10240
+sqlalchemy/testing/suite/test_types.py,sha256=i1fCIXERdtGABdp_T3l1vaPH9AhQ80DJvbjOPbeng1c,67748
+sqlalchemy/testing/suite/test_unicode_ddl.py,sha256=juF_KTK1nGrSlsL8z0Ky0rFSNkPGheLB3e0Kq3yRqss,6330
+sqlalchemy/testing/suite/test_update_delete.py,sha256=TnJI5U_ZEuu3bni4sH-S6CENxvSZwDgZL-FKSV45bAo,4133
+sqlalchemy/testing/util.py,sha256=jX9jlUHSH-7_2OCypZUvitP8JkJbNdr5_ZxU6Aa8DPY,14599
+sqlalchemy/testing/warnings.py,sha256=3EhbTlPe4gJnoydj-OKueNOOtGwIRF2kV4XvlFwFYOA,1598
+sqlalchemy/types.py,sha256=unCm_O8qKxU3LjLbqeqSNQSsK5k5R5POsyEx2gH6CF4,3244
+sqlalchemy/util/__init__.py,sha256=3-O9j9qPk-gTx6hlyLsISc_JOW5MhjV0J_L5nV19qI8,8436
+sqlalchemy/util/__pycache__/__init__.cpython-311.pyc,,
+sqlalchemy/util/__pycache__/_collections.cpython-311.pyc,,
+sqlalchemy/util/__pycache__/_concurrency_py3k.cpython-311.pyc,,
+sqlalchemy/util/__pycache__/_has_cy.cpython-311.pyc,,
+sqlalchemy/util/__pycache__/_py_collections.cpython-311.pyc,,
+sqlalchemy/util/__pycache__/compat.cpython-311.pyc,,
+sqlalchemy/util/__pycache__/concurrency.cpython-311.pyc,,
+sqlalchemy/util/__pycache__/deprecations.cpython-311.pyc,,
+sqlalchemy/util/__pycache__/langhelpers.cpython-311.pyc,,
+sqlalchemy/util/__pycache__/preloaded.cpython-311.pyc,,
+sqlalchemy/util/__pycache__/queue.cpython-311.pyc,,
+sqlalchemy/util/__pycache__/tool_support.cpython-311.pyc,,
+sqlalchemy/util/__pycache__/topological.cpython-311.pyc,,
+sqlalchemy/util/__pycache__/typing.cpython-311.pyc,,
+sqlalchemy/util/_collections.py,sha256=O3iqq0R9TbcXNyFk8nG4QLwkUzdWkCFmqBYcDrajvl8,20778
+sqlalchemy/util/_concurrency_py3k.py,sha256=FRTlTPGNcw4YNPlIDn7TNYPUmIBZdVoicRo8aKp4rSY,9481
+sqlalchemy/util/_has_cy.py,sha256=IHGc5hUFbXQuv1a1z2P8yVwz0yGbCYXyQM2qsdcBTyg,1287
+sqlalchemy/util/_py_collections.py,sha256=2PUqiKIsF8d-gNDAAqYI8WE6XPyRf1flRLkVsJeXuOo,17255
+sqlalchemy/util/compat.py,sha256=ojCAtKHlkqNdYB33PXbAP0zTH1ZXYdTZkJl32cqGnMQ,9014
+sqlalchemy/util/concurrency.py,sha256=zlmuK99p5cPpEPxBQYSDfLHP0Pbuw4iDeUzU49Pb1Ow,3412
+sqlalchemy/util/deprecations.py,sha256=AnHpDWHi7g2gv_QUTGStQTnr0J94lIF-3aFLOsv9yzg,12372
+sqlalchemy/util/langhelpers.py,sha256=f3IhEhNMnohDNDqSWWABPZi6U9ZrF0YGHyAc4h3n91Y,67099
+sqlalchemy/util/preloaded.py,sha256=78Sl7VjzTOPajbovvARxNeuZb-iYRpEvL5k8m5Bz4vQ,6054
+sqlalchemy/util/queue.py,sha256=4SbSbVamUECjCDpMPR035N1ooVHt9W5GjbqkxfZmH5k,10507
+sqlalchemy/util/tool_support.py,sha256=DuurikYgDUIIxk3gubUKl6rs-etXt3eeHaZ4ZkIyJXQ,6336
+sqlalchemy/util/topological.py,sha256=_NdtAghZjhZ4e2fwWHmn25erP5cvtGgOUMplsCa_VCE,3578
+sqlalchemy/util/typing.py,sha256=oir6FlMQOcfAfbTKaUDSYSVf94M0r1z6aF3qr3f-UnI,17251

pgsql/pgAdmin 4/python/Lib/site-packages/SQLAlchemy-2.0.30.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.43.0)
+Root-Is-Purelib: false
+Tag: cp311-cp311-win_amd64
+

pgsql/pgAdmin 4/python/Lib/site-packages/SQLAlchemy-2.0.30.dist-info/top_level.txt

@@ -0,0 +1 @@
+sqlalchemy

pgsql/pgAdmin 4/python/Lib/site-packages/_distutils_hack/__init__.py

@@ -0,0 +1,220 @@
+# don't import any costly modules
+import sys
+import os
+
+
+def warn_distutils_present():
+    if 'distutils' not in sys.modules:
+        return
+    import warnings
+
+    warnings.warn(
+        "Distutils was imported before Setuptools, but importing Setuptools "
+        "also replaces the `distutils` module in `sys.modules`. This may lead "
+        "to undesirable behaviors or errors. To avoid these issues, avoid "
+        "using distutils directly, ensure that setuptools is installed in the "
+        "traditional way (e.g. not an editable install), and/or make sure "
+        "that setuptools is always imported before distutils."
+    )
+
+
+def clear_distutils():
+    if 'distutils' not in sys.modules:
+        return
+    import warnings
+
+    warnings.warn("Setuptools is replacing distutils.")
+    mods = [
+        name
+        for name in sys.modules
+        if name == "distutils" or name.startswith("distutils.")
+    ]
+    for name in mods:
+        del sys.modules[name]
+
+
+def enabled():
+    """
+    Allow selection of distutils by environment variable.
+    """
+    which = os.environ.get('SETUPTOOLS_USE_DISTUTILS', 'local')
+    return which == 'local'
+
+
+def ensure_local_distutils():
+    import importlib
+
+    clear_distutils()
+
+    # With the DistutilsMetaFinder in place,
+    # perform an import to cause distutils to be
+    # loaded from setuptools._distutils. Ref #2906.
+    with shim():
+        importlib.import_module('distutils')
+
+    # check that submodules load as expected
+    core = importlib.import_module('distutils.core')
+    assert '_distutils' in core.__file__, core.__file__
+    assert 'setuptools._distutils.log' not in sys.modules
+
+
+def do_override():
+    """
+    Ensure that the local copy of distutils is preferred over stdlib.
+
+    See https://github.com/pypa/setuptools/issues/417#issuecomment-392298401
+    for more motivation.
+    """
+    if enabled():
+        warn_distutils_present()
+        ensure_local_distutils()
+
+
+class _TrivialRe:
+    def __init__(self, *patterns):
+        self._patterns = patterns
+
+    def match(self, string):
+        return all(pat in string for pat in self._patterns)
+
+
+class DistutilsMetaFinder:
+    def find_spec(self, fullname, path, target=None):
+        # optimization: only consider top level modules and those
+        # found in the CPython test suite.
+        if path is not None and not fullname.startswith('test.'):
+            return None
+
+        method_name = 'spec_for_{fullname}'.format(**locals())
+        method = getattr(self, method_name, lambda: None)
+        return method()
+
+    def spec_for_distutils(self):
+        if self.is_cpython():
+            return None
+
+        import importlib
+        import importlib.abc
+        import importlib.util
+
+        try:
+            mod = importlib.import_module('setuptools._distutils')
+        except Exception:
+            # There are a couple of cases where setuptools._distutils
+            # may not be present:
+            # - An older Setuptools without a local distutils is
+            #   taking precedence. Ref #2957.
+            # - Path manipulation during sitecustomize removes
+            #   setuptools from the path but only after the hook
+            #   has been loaded. Ref #2980.
+            # In either case, fall back to stdlib behavior.
+            return None
+
+        class DistutilsLoader(importlib.abc.Loader):
+            def create_module(self, spec):
+                mod.__name__ = 'distutils'
+                return mod
+
+            def exec_module(self, module):
+                pass
+
+        return importlib.util.spec_from_loader(
+            'distutils', DistutilsLoader(), origin=mod.__file__
+        )
+
+    @staticmethod
+    def is_cpython():
+        """
+        Suppress supplying distutils for CPython (build and tests).
+        Ref #2965 and #3007.
+        """
+        return os.path.isfile('pybuilddir.txt')
+
+    def spec_for_pip(self):
+        """
+        Ensure stdlib distutils when running under pip.
+        See pypa/pip#8761 for rationale.
+        """
+        if sys.version_info >= (3, 12) or self.pip_imported_during_build():
+            return
+        clear_distutils()
+        self.spec_for_distutils = lambda: None
+
+    @classmethod
+    def pip_imported_during_build(cls):
+        """
+        Detect if pip is being imported in a build script. Ref #2355.
+        """
+        import traceback
+
+        return any(
+            cls.frame_file_is_setup(frame) for frame, line in traceback.walk_stack(None)
+        )
+
+    @staticmethod
+    def frame_file_is_setup(frame):
+        """
+        Return True if the indicated frame suggests a setup.py file.
+        """
+        # some frames may not have __file__ (#2940)
+        return frame.f_globals.get('__file__', '').endswith('setup.py')
+
+    def spec_for_sensitive_tests(self):
+        """
+        Ensure stdlib distutils when running select tests under CPython.
+
+        python/cpython#91169
+        """
+        clear_distutils()
+        self.spec_for_distutils = lambda: None
+
+    sensitive_tests = (
+        [
+            'test.test_distutils',
+            'test.test_peg_generator',
+            'test.test_importlib',
+        ]
+        if sys.version_info < (3, 10)
+        else [
+            'test.test_distutils',
+        ]
+    )
+
+
+for name in DistutilsMetaFinder.sensitive_tests:
+    setattr(
+        DistutilsMetaFinder,
+        f'spec_for_{name}',
+        DistutilsMetaFinder.spec_for_sensitive_tests,
+    )
+
+
+DISTUTILS_FINDER = DistutilsMetaFinder()
+
+
+def add_shim():
+    DISTUTILS_FINDER in sys.meta_path or insert_shim()
+
+
+class shim:
+    def __enter__(self):
+        insert_shim()
+
+    def __exit__(self, exc, value, tb):
+        _remove_shim()
+
+
+def insert_shim():
+    sys.meta_path.insert(0, DISTUTILS_FINDER)
+
+
+def _remove_shim():
+    try:
+        sys.meta_path.remove(DISTUTILS_FINDER)
+    except ValueError:
+        pass
+
+
+if sys.version_info < (3, 12):
+    # DistutilsMetaFinder can only be disabled in Python < 3.12 (PEP 632)
+    remove_shim = _remove_shim

pgsql/pgAdmin 4/python/Lib/site-packages/_distutils_hack/override.py

@@ -0,0 +1 @@
+__import__('_distutils_hack').do_override()

pgsql/pgAdmin 4/python/Lib/site-packages/psycopg-3.1.12.dist-info/INSTALLER

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

pgsql/pgAdmin 4/python/Lib/site-packages/psycopg-3.1.12.dist-info/LICENSE.txt

@@ -0,0 +1,165 @@
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

pgsql/pgAdmin 4/python/Lib/site-packages/psycopg-3.1.12.dist-info/METADATA

@@ -0,0 +1,94 @@
+Metadata-Version: 2.1
+Name: psycopg
+Version: 3.1.12
+Summary: PostgreSQL database adapter for Python
+Home-page: https://psycopg.org/psycopg3/
+Author: Daniele Varrazzo
+Author-email: daniele.varrazzo@gmail.com
+License: GNU Lesser General Public License v3 (LGPLv3)
+Project-URL: Homepage, https://psycopg.org/
+Project-URL: Documentation, https://psycopg.org/psycopg3/docs/
+Project-URL: Changes, https://psycopg.org/psycopg3/docs/news.html
+Project-URL: Code, https://github.com/psycopg/psycopg
+Project-URL: Issue Tracker, https://github.com/psycopg/psycopg/issues
+Project-URL: Download, https://pypi.org/project/psycopg/
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: GNU Lesser General Public License v3 (LGPLv3)
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Database
+Classifier: Topic :: Database :: Front-Ends
+Classifier: Topic :: Software Development
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.7
+Description-Content-Type: text/x-rst
+License-File: LICENSE.txt
+Requires-Dist: typing-extensions >=4.1
+Requires-Dist: backports.zoneinfo >=0.2.0 ; python_version < "3.9"
+Requires-Dist: tzdata ; sys_platform == "win32"
+Provides-Extra: binary
+Requires-Dist: psycopg-binary ==3.1.12 ; extra == 'binary'
+Provides-Extra: c
+Requires-Dist: psycopg-c ==3.1.12 ; extra == 'c'
+Provides-Extra: dev
+Requires-Dist: black >=23.1.0 ; extra == 'dev'
+Requires-Dist: dnspython >=2.1 ; extra == 'dev'
+Requires-Dist: flake8 >=4.0 ; extra == 'dev'
+Requires-Dist: mypy >=1.4.1 ; extra == 'dev'
+Requires-Dist: types-setuptools >=57.4 ; extra == 'dev'
+Requires-Dist: wheel >=0.37 ; extra == 'dev'
+Provides-Extra: docs
+Requires-Dist: Sphinx >=5.0 ; extra == 'docs'
+Requires-Dist: furo ==2022.6.21 ; extra == 'docs'
+Requires-Dist: sphinx-autobuild >=2021.3.14 ; extra == 'docs'
+Requires-Dist: sphinx-autodoc-typehints >=1.12 ; extra == 'docs'
+Provides-Extra: pool
+Requires-Dist: psycopg-pool ; extra == 'pool'
+Provides-Extra: test
+Requires-Dist: anyio <4.0,>=3.6.2 ; extra == 'test'
+Requires-Dist: mypy >=1.4.1 ; extra == 'test'
+Requires-Dist: pproxy >=2.7 ; extra == 'test'
+Requires-Dist: pytest >=6.2.5 ; extra == 'test'
+Requires-Dist: pytest-cov >=3.0 ; extra == 'test'
+Requires-Dist: pytest-randomly >=3.5 ; extra == 'test'
+
+Psycopg 3: PostgreSQL database adapter for Python
+=================================================
+
+Psycopg 3 is a modern implementation of a PostgreSQL adapter for Python.
+
+This distribution contains the pure Python package ``psycopg``.
+
+
+Installation
+------------
+
+In short, run the following::
+
+    pip install --upgrade pip           # to upgrade pip
+    pip install "psycopg[binary,pool]"  # to install package and dependencies
+
+If something goes wrong, and for more information about installation, please
+check out the `Installation documentation`__.
+
+.. __: https://www.psycopg.org/psycopg3/docs/basic/install.html#
+
+
+Hacking
+-------
+
+For development information check out `the project readme`__.
+
+.. __: https://github.com/psycopg/psycopg#readme
+
+
+Copyright (C) 2020 The Psycopg Team

pgsql/pgAdmin 4/python/Lib/site-packages/psycopg-3.1.12.dist-info/RECORD

@@ -0,0 +1,132 @@
+psycopg-3.1.12.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+psycopg-3.1.12.dist-info/LICENSE.txt,sha256=46mU2C5kSwOnkqkw9XQAJlhBL2JAf1_uCD8lVcXyMRg,7652
+psycopg-3.1.12.dist-info/METADATA,sha256=yrUhbqJiFa1CXqekrEaS9370qMoGcAoULhXZ0cC-SQc,3599
+psycopg-3.1.12.dist-info/RECORD,,
+psycopg-3.1.12.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+psycopg-3.1.12.dist-info/WHEEL,sha256=yQN5g4mg4AybRjkgi-9yy4iQEFibGQmlz78Pik5Or-A,92
+psycopg-3.1.12.dist-info/top_level.txt,sha256=npthKx2_OEoahttYqdsIPlRUgjS_bQBmfpDCVxQcPGo,8
+psycopg/__init__.py,sha256=IALSmAJ3hedCpA_mesbu-Df0jtdSj87uqkerLNmxpvA,3055
+psycopg/__pycache__/__init__.cpython-311.pyc,,
+psycopg/__pycache__/_adapters_map.cpython-311.pyc,,
+psycopg/__pycache__/_cmodule.cpython-311.pyc,,
+psycopg/__pycache__/_column.cpython-311.pyc,,
+psycopg/__pycache__/_compat.cpython-311.pyc,,
+psycopg/__pycache__/_dns.cpython-311.pyc,,
+psycopg/__pycache__/_encodings.cpython-311.pyc,,
+psycopg/__pycache__/_enums.cpython-311.pyc,,
+psycopg/__pycache__/_pipeline.cpython-311.pyc,,
+psycopg/__pycache__/_preparing.cpython-311.pyc,,
+psycopg/__pycache__/_queries.cpython-311.pyc,,
+psycopg/__pycache__/_struct.cpython-311.pyc,,
+psycopg/__pycache__/_tpc.cpython-311.pyc,,
+psycopg/__pycache__/_transform.cpython-311.pyc,,
+psycopg/__pycache__/_typeinfo.cpython-311.pyc,,
+psycopg/__pycache__/_tz.cpython-311.pyc,,
+psycopg/__pycache__/_wrappers.cpython-311.pyc,,
+psycopg/__pycache__/abc.cpython-311.pyc,,
+psycopg/__pycache__/adapt.cpython-311.pyc,,
+psycopg/__pycache__/client_cursor.cpython-311.pyc,,
+psycopg/__pycache__/connection.cpython-311.pyc,,
+psycopg/__pycache__/connection_async.cpython-311.pyc,,
+psycopg/__pycache__/conninfo.cpython-311.pyc,,
+psycopg/__pycache__/copy.cpython-311.pyc,,
+psycopg/__pycache__/cursor.cpython-311.pyc,,
+psycopg/__pycache__/cursor_async.cpython-311.pyc,,
+psycopg/__pycache__/dbapi20.cpython-311.pyc,,
+psycopg/__pycache__/errors.cpython-311.pyc,,
+psycopg/__pycache__/generators.cpython-311.pyc,,
+psycopg/__pycache__/postgres.cpython-311.pyc,,
+psycopg/__pycache__/rows.cpython-311.pyc,,
+psycopg/__pycache__/server_cursor.cpython-311.pyc,,
+psycopg/__pycache__/sql.cpython-311.pyc,,
+psycopg/__pycache__/transaction.cpython-311.pyc,,
+psycopg/__pycache__/version.cpython-311.pyc,,
+psycopg/__pycache__/waiting.cpython-311.pyc,,
+psycopg/_adapters_map.py,sha256=PTWGZk1lQo4ajvU93NV-5SSQ6pza8L1vjcukjEdKeCQ,10739
+psycopg/_cmodule.py,sha256=q6CxV-8shy72bscUFaeltbREcA8lUJ6IEFjuf4X8HfU,786
+psycopg/_column.py,sha256=TF_XEIpltbGMyXtLV2I1fL9Kgzi8KmQVOxWDedmb_nY,3803
+psycopg/_compat.py,sha256=7bA8L_rzgUZQ01_lJAs7kGj3ElgWFQtnbc4lKwUq2Lg,1763
+psycopg/_dns.py,sha256=tMxJCt1r-E-sSZjR1Yur66CaaCdUnaI4DHwSLES5Pzs,7316
+psycopg/_encodings.py,sha256=GTzriHVX0j1eDcR0gpeKp5zJaZkVe0I3a1vTiyVewXY,4518
+psycopg/_enums.py,sha256=GXJG0OqgQRaUOisysI3iWEvtGko8xrFJwAmnbehci-0,1678
+psycopg/_pipeline.py,sha256=qf7Hnf9oBSzUfdkmKtaellHbGjyaSK8aR5qFiPg-a4M,10525
+psycopg/_preparing.py,sha256=vHtIFcFkz4PINKNNevMb4uaaUXfy36e_23MY0Be3uxE,6203
+psycopg/_queries.py,sha256=_yLbHBymZK2D9lFR1Ox0Cj5ZllOiiH3e3-a18HReRUU,13240
+psycopg/_struct.py,sha256=jgJpHymLt899gaIPDlTUBkx3T6yTKBCr92DXR23loNY,2014
+psycopg/_tpc.py,sha256=3cWUSpUg0RgI_PEXCKmsr-ubHIKcqfsWX6MxOtKhUns,3583
+psycopg/_transform.py,sha256=7CqDv_MKvFC_RbbwINdNj25io5apuDu2TbqWXjDAVnw,11575
+psycopg/_typeinfo.py,sha256=PN_3o68sFGsk605wbQcy6Q1B1KzHT58ZFzqZmAAYTSw,14726
+psycopg/_tz.py,sha256=2O-tdDIVg1ckvbZ2W5gWX7O2O-RkotGEtCggn-NIT8U,1200
+psycopg/_wrappers.py,sha256=wKZt_ar8QuRgEKC6tuwamYXCwB1P7IZQsmgYdVOlAhU,3126
+psycopg/abc.py,sha256=kQ62n9TnSfZZjYrZN71CMNk9oRBIKKcWXIl-tLIInfk,7725
+psycopg/adapt.py,sha256=hnWdPy1ylx8gLMTBq99vevqmOhOyQJcDPnKuQ3SV3Vk,5307
+psycopg/client_cursor.py,sha256=F0yIS7YMDegIEtSIvzTxJ0naR6k00PWnevsxRcPoOcU,2815
+psycopg/connection.py,sha256=R_Zdmk6D8DIqujzT1y0vIk0t-U33Hp_bQd6qDxsu9QM,34386
+psycopg/connection_async.py,sha256=6Fj0bf-RWXfKXuhgCUv1pDyD-UgRJc1kleK0sUUtv1E,14172
+psycopg/conninfo.py,sha256=wbul7hMsnk38e1WBOEZ2LyYbcBXLQOyT9fAqABxiVeU,11906
+psycopg/copy.py,sha256=CGBMcAIeh7AlwD8R2dr6um-_OF9cVbLIHzWiFPfO-ag,29828
+psycopg/crdb/__init__.py,sha256=kyfsUIGuFvQTpLuXJcQ6gMpOB5WXeWtBa2wQjaqE3-g,396
+psycopg/crdb/__pycache__/__init__.cpython-311.pyc,,
+psycopg/crdb/__pycache__/_types.cpython-311.pyc,,
+psycopg/crdb/__pycache__/connection.cpython-311.pyc,,
+psycopg/crdb/_types.py,sha256=ELUBFTS3UD_P2cIR68IVRZQ3Gv2CzJQvdbqt2LMB5Z4,5891
+psycopg/crdb/connection.py,sha256=qxXG1DqIro6ezbxyifOE55ZwKdWFMrtJyK05LNaIGSo,5394
+psycopg/cursor.py,sha256=zQRYZGzaFmV9FuD1Eo0t8WznKy7T_QSBocAODT8LBQE,31437
+psycopg/cursor_async.py,sha256=n_nAcycsL3xM0gqmfeerV9Wl5rnd9VnAHr2yXFPGq9I,8017
+psycopg/dbapi20.py,sha256=-kzMT8Rn9-U2IMctFAEjVNlWFDvAHH_Q13B3k6T6TEo,3175
+psycopg/errors.py,sha256=HdFMiNN-1TQwv_lg5s-s9beYAmZ7czxa0iSJGWMEngw,45226
+psycopg/generators.py,sha256=JkfSSQXoWAFBnnHKTFH9k0eoPQtl6ET_8ZSyK6j_zbA,9948
+psycopg/postgres.py,sha256=FpWMrMHSrmUpzmItstDD35Kks5yLskRY4XVoKGzKCAg,4986
+psycopg/pq/__init__.py,sha256=1zGPgm9Zf31MfBaX7jz-t_F8YA1lRJNQx1rDJ1cnGAI,3880
+psycopg/pq/__pycache__/__init__.cpython-311.pyc,,
+psycopg/pq/__pycache__/_debug.cpython-311.pyc,,
+psycopg/pq/__pycache__/_enums.cpython-311.pyc,,
+psycopg/pq/__pycache__/_pq_ctypes.cpython-311.pyc,,
+psycopg/pq/__pycache__/abc.cpython-311.pyc,,
+psycopg/pq/__pycache__/misc.cpython-311.pyc,,
+psycopg/pq/__pycache__/pq_ctypes.cpython-311.pyc,,
+psycopg/pq/_debug.py,sha256=jfIsSITc43a1AlNdaOd0r7UhbV6wc2ed1zBJ8n3Y4BA,3051
+psycopg/pq/_enums.py,sha256=a5crxkDrP6NMBcdYuGnoL-QExEg-qqe0QtNc9SFXt1U,5660
+psycopg/pq/_pq_ctypes.py,sha256=tr9BeMMEOnjCC8t4uZIxlyZJc-zKgztQ63hvGs0FcT4,20061
+psycopg/pq/abc.py,sha256=PGhs5_MOfYhyo23r8PLZxozK9bVH2ACe8c8TnewYPmw,7767
+psycopg/pq/misc.py,sha256=1VCWIvzebWNG1Ej7KJI5NpWsPFJReaJRGoM1VODpMJ0,3957
+psycopg/pq/pq_ctypes.py,sha256=oU085qsovMe453T-QM848j_ODetxeLagNpcTDpoL8RI,35791
+psycopg/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+psycopg/rows.py,sha256=jMWlUMqVehBB_PWkn_o2rnvwJrz2xQz2BIyq-hqoYyM,7318
+psycopg/server_cursor.py,sha256=fkOaZ_sTKmqVm1R190rKu1IcC3DcE7VI0Er0rsx4l68,15006
+psycopg/sql.py,sha256=1VlZ5esUXJYTU-h796FfnHJCnsiYPDcvrzjJfC_qlxo,15925
+psycopg/transaction.py,sha256=oX9XpQuxirjnKZuYV4U9_H9fm5RoJE97SWJxS6oV8Cw,9458
+psycopg/types/__init__.py,sha256=JPAkV4EfkXwdsr76_U1DsQV19c8aQNSB6kgud4bhXeM,181
+psycopg/types/__pycache__/__init__.cpython-311.pyc,,
+psycopg/types/__pycache__/array.cpython-311.pyc,,
+psycopg/types/__pycache__/bool.cpython-311.pyc,,
+psycopg/types/__pycache__/composite.cpython-311.pyc,,
+psycopg/types/__pycache__/datetime.cpython-311.pyc,,
+psycopg/types/__pycache__/enum.cpython-311.pyc,,
+psycopg/types/__pycache__/hstore.cpython-311.pyc,,
+psycopg/types/__pycache__/json.cpython-311.pyc,,
+psycopg/types/__pycache__/multirange.cpython-311.pyc,,
+psycopg/types/__pycache__/net.cpython-311.pyc,,
+psycopg/types/__pycache__/none.cpython-311.pyc,,
+psycopg/types/__pycache__/numeric.cpython-311.pyc,,
+psycopg/types/__pycache__/range.cpython-311.pyc,,
+psycopg/types/__pycache__/shapely.cpython-311.pyc,,
+psycopg/types/__pycache__/string.cpython-311.pyc,,
+psycopg/types/__pycache__/uuid.cpython-311.pyc,,
+psycopg/types/array.py,sha256=0vt0wg9D4P2xGRBllNWX6fndYvqr8PXag3l7n6oaQB0,15281
+psycopg/types/bool.py,sha256=yLbDw8HCl26j7MFB3xlkaTdSK0pBrk2NKe5NuY4lc_w,1137
+psycopg/types/composite.py,sha256=WY0Dq1iWN7BVOsOylTuZDvF9kwe5qbbKsaNX5EkBlAE,10419
+psycopg/types/datetime.py,sha256=yoViTWpRkkdBImVebjwSjFufHLu9BBV_YIAuHRINzZ8,24788
+psycopg/types/enum.py,sha256=NycuVchMGFiFJUX6dNpP86HM128hZ5zMbiRKNtghWGA,6295
+psycopg/types/hstore.py,sha256=JzBWyNibHiMK-P8Ab-F0hzqOpICrqrGNTIkhiEQbxMY,4103
+psycopg/types/json.py,sha256=FJ6MJkYuJ-VzLeJ2MhGxKJt_7kS-qSbsYlicXMpNQQ0,7404
+psycopg/types/multirange.py,sha256=SfR4a6Abhx6f1pN2E2T3HTmjubqct0kLRKoC0ayaK7s,16689
+psycopg/types/net.py,sha256=JIU0Odz8yJ_lbGanYoQ-kSrSF5k0lHYNn12wwn4uVho,6941
+psycopg/types/none.py,sha256=4b96Aw0WSW6Jpo_HMIvKUkivAxkxvHJzvzy-Q6Uf-60,613
+psycopg/types/numeric.py,sha256=RpeY0CfipDcR4t15sc3ZbytK90lFCLCJEOIhicMkpuk,13703
+psycopg/types/range.py,sha256=9_033Zst39mbG5-pB0ZNCGh12CZcX4Melyy4JJahkkA,20777
+psycopg/types/shapely.py,sha256=aWzPUJr2FL6eATd-KcHslvWmXo6idxb3_G-sZ92ngDk,2443
+psycopg/types/string.py,sha256=hWqmXSkX1da7Bg7JSuu-5f4ea6Ho3Aklz8lO89rfGzE,7662
+psycopg/types/uuid.py,sha256=5xqkVcZ22jX7a2oU9PXz_71y6VKpO5EYj8AITiSQNBE,1616
+psycopg/version.py,sha256=a9jFaoEVxlYNfqfR-EAM4p0_vQBx1RQzjU5nrEpIVs4,376
+psycopg/waiting.py,sha256=Rh5MEz8VNgCD4l60zUOxG-dDBFw2QSez1ftyKKaS6pg,12110

pgsql/pgAdmin 4/python/Lib/site-packages/psycopg-3.1.12.dist-info/WHEEL

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

pgsql/pgAdmin 4/python/Lib/site-packages/psycopg-3.1.12.dist-info/top_level.txt

@@ -0,0 +1 @@
+psycopg

pgsql/pgAdmin 4/python/Lib/site-packages/psycopg/__init__.py

@@ -0,0 +1,110 @@
+"""
+psycopg -- PostgreSQL database adapter for Python
+"""
+
+# Copyright (C) 2020 The Psycopg Team
+
+import logging
+
+from . import pq  # noqa: F401 import early to stabilize side effects
+from . import types
+from . import postgres
+from ._tpc import Xid
+from .copy import Copy, AsyncCopy
+from ._enums import IsolationLevel
+from .cursor import Cursor
+from .errors import Warning, Error, InterfaceError, DatabaseError
+from .errors import DataError, OperationalError, IntegrityError
+from .errors import InternalError, ProgrammingError, NotSupportedError
+from ._column import Column
+from .conninfo import ConnectionInfo
+from ._pipeline import Pipeline, AsyncPipeline
+from .connection import BaseConnection, Connection, Notify
+from .transaction import Rollback, Transaction, AsyncTransaction
+from .cursor_async import AsyncCursor
+from .server_cursor import AsyncServerCursor, ServerCursor
+from .client_cursor import AsyncClientCursor, ClientCursor
+from .connection_async import AsyncConnection
+
+from . import dbapi20
+from .dbapi20 import BINARY, DATETIME, NUMBER, ROWID, STRING
+from .dbapi20 import Binary, Date, DateFromTicks, Time, TimeFromTicks
+from .dbapi20 import Timestamp, TimestampFromTicks
+
+from .version import __version__ as __version__  # noqa: F401
+
+# Set the logger to a quiet default, can be enabled if needed
+logger = logging.getLogger("psycopg")
+if logger.level == logging.NOTSET:
+    logger.setLevel(logging.WARNING)
+
+# DBAPI compliance
+connect = Connection.connect
+apilevel = "2.0"
+threadsafety = 2
+paramstyle = "pyformat"
+
+# register default adapters for PostgreSQL
+adapters = postgres.adapters  # exposed by the package
+postgres.register_default_adapters(adapters)
+
+# After the default ones, because these can deal with the bytea oid better
+dbapi20.register_dbapi20_adapters(adapters)
+
+# Must come after all the types have been registered
+types.array.register_all_arrays(adapters)
+
+# Note: defining the exported methods helps both Sphynx in documenting that
+# this is the canonical place to obtain them and should be used by MyPy too,
+# so that function signatures are consistent with the documentation.
+__all__ = [
+    "AsyncClientCursor",
+    "AsyncConnection",
+    "AsyncCopy",
+    "AsyncCursor",
+    "AsyncPipeline",
+    "AsyncServerCursor",
+    "AsyncTransaction",
+    "BaseConnection",
+    "ClientCursor",
+    "Column",
+    "Connection",
+    "ConnectionInfo",
+    "Copy",
+    "Cursor",
+    "IsolationLevel",
+    "Notify",
+    "Pipeline",
+    "Rollback",
+    "ServerCursor",
+    "Transaction",
+    "Xid",
+    # DBAPI exports
+    "connect",
+    "apilevel",
+    "threadsafety",
+    "paramstyle",
+    "Warning",
+    "Error",
+    "InterfaceError",
+    "DatabaseError",
+    "DataError",
+    "OperationalError",
+    "IntegrityError",
+    "InternalError",
+    "ProgrammingError",
+    "NotSupportedError",
+    # DBAPI type constructors and singletons
+    "Binary",
+    "Date",
+    "DateFromTicks",
+    "Time",
+    "TimeFromTicks",
+    "Timestamp",
+    "TimestampFromTicks",
+    "BINARY",
+    "DATETIME",
+    "NUMBER",
+    "ROWID",
+    "STRING",
+]

pgsql/pgAdmin 4/python/Lib/site-packages/psycopg/_adapters_map.py

@@ -0,0 +1,296 @@
+"""
+Mapping from types/oids to Dumpers/Loaders
+"""
+
+# Copyright (C) 2020 The Psycopg Team
+
+from typing import Any, Dict, List, Optional, Type, TypeVar, Union
+from typing import cast, TYPE_CHECKING
+
+from . import pq
+from . import errors as e
+from .abc import Dumper, Loader
+from ._enums import PyFormat as PyFormat
+from ._cmodule import _psycopg
+from ._typeinfo import TypesRegistry
+
+if TYPE_CHECKING:
+    from .connection import BaseConnection
+
+RV = TypeVar("RV")
+
+
+class AdaptersMap:
+    r"""
+    Establish how types should be converted between Python and PostgreSQL in
+    an `~psycopg.abc.AdaptContext`.
+
+    `!AdaptersMap` maps Python types to `~psycopg.adapt.Dumper` classes to
+    define how Python types are converted to PostgreSQL, and maps OIDs to
+    `~psycopg.adapt.Loader` classes to establish how query results are
+    converted to Python.
+
+    Every `!AdaptContext` object has an underlying `!AdaptersMap` defining how
+    types are converted in that context, exposed as the
+    `~psycopg.abc.AdaptContext.adapters` attribute: changing such map allows
+    to customise adaptation in a context without changing separated contexts.
+
+    When a context is created from another context (for instance when a
+    `~psycopg.Cursor` is created from a `~psycopg.Connection`), the parent's
+    `!adapters` are used as template for the child's `!adapters`, so that every
+    cursor created from the same connection use the connection's types
+    configuration, but separate connections have independent mappings.
+
+    Once created, `!AdaptersMap` are independent. This means that objects
+    already created are not affected if a wider scope (e.g. the global one) is
+    changed.
+
+    The connections adapters are initialised using a global `!AdptersMap`
+    template, exposed as `psycopg.adapters`: changing such mapping allows to
+    customise the type mapping for every connections created afterwards.
+
+    The object can start empty or copy from another object of the same class.
+    Copies are copy-on-write: if the maps are updated make a copy. This way
+    extending e.g. global map by a connection or a connection map from a cursor
+    is cheap: a copy is only made on customisation.
+    """
+
+    __module__ = "psycopg.adapt"
+
+    types: TypesRegistry
+
+    _dumpers: Dict[PyFormat, Dict[Union[type, str], Type[Dumper]]]
+    _dumpers_by_oid: List[Dict[int, Type[Dumper]]]
+    _loaders: List[Dict[int, Type[Loader]]]
+
+    # Record if a dumper or loader has an optimised version.
+    _optimised: Dict[type, type] = {}
+
+    def __init__(
+        self,
+        template: Optional["AdaptersMap"] = None,
+        types: Optional[TypesRegistry] = None,
+    ):
+        if template:
+            self._dumpers = template._dumpers.copy()
+            self._own_dumpers = _dumpers_shared.copy()
+            template._own_dumpers = _dumpers_shared.copy()
+
+            self._dumpers_by_oid = template._dumpers_by_oid[:]
+            self._own_dumpers_by_oid = [False, False]
+            template._own_dumpers_by_oid = [False, False]
+
+            self._loaders = template._loaders[:]
+            self._own_loaders = [False, False]
+            template._own_loaders = [False, False]
+
+            self.types = TypesRegistry(template.types)
+
+        else:
+            self._dumpers = {fmt: {} for fmt in PyFormat}
+            self._own_dumpers = _dumpers_owned.copy()
+
+            self._dumpers_by_oid = [{}, {}]
+            self._own_dumpers_by_oid = [True, True]
+
+            self._loaders = [{}, {}]
+            self._own_loaders = [True, True]
+
+            self.types = types or TypesRegistry()
+
+    # implement the AdaptContext protocol too
+    @property
+    def adapters(self) -> "AdaptersMap":
+        return self
+
+    @property
+    def connection(self) -> Optional["BaseConnection[Any]"]:
+        return None
+
+    def register_dumper(
+        self, cls: Union[type, str, None], dumper: Type[Dumper]
+    ) -> None:
+        """
+        Configure the context to use `!dumper` to convert objects of type `!cls`.
+
+        If two dumpers with different `~Dumper.format` are registered for the
+        same type, the last one registered will be chosen when the query
+        doesn't specify a format (i.e. when the value is used with a ``%s``
+        "`~PyFormat.AUTO`" placeholder).
+
+        :param cls: The type to manage.
+        :param dumper: The dumper to register for `!cls`.
+
+        If `!cls` is specified as string it will be lazy-loaded, so that it
+        will be possible to register it without importing it before. In this
+        case it should be the fully qualified name of the object (e.g.
+        ``"uuid.UUID"``).
+
+        If `!cls` is None, only use the dumper when looking up using
+        `get_dumper_by_oid()`, which happens when we know the Postgres type to
+        adapt to, but not the Python type that will be adapted (e.g. in COPY
+        after using `~psycopg.Copy.set_types()`).
+
+        """
+        if not (cls is None or isinstance(cls, (str, type))):
+            raise TypeError(
+                f"dumpers should be registered on classes, got {cls} instead"
+            )
+
+        if _psycopg:
+            dumper = self._get_optimised(dumper)
+
+        # Register the dumper both as its format and as auto
+        # so that the last dumper registered is used in auto (%s) format
+        if cls:
+            for fmt in (PyFormat.from_pq(dumper.format), PyFormat.AUTO):
+                if not self._own_dumpers[fmt]:
+                    self._dumpers[fmt] = self._dumpers[fmt].copy()
+                    self._own_dumpers[fmt] = True
+
+                self._dumpers[fmt][cls] = dumper
+
+        # Register the dumper by oid, if the oid of the dumper is fixed
+        if dumper.oid:
+            if not self._own_dumpers_by_oid[dumper.format]:
+                self._dumpers_by_oid[dumper.format] = self._dumpers_by_oid[
+                    dumper.format
+                ].copy()
+                self._own_dumpers_by_oid[dumper.format] = True
+
+            self._dumpers_by_oid[dumper.format][dumper.oid] = dumper
+
+    def register_loader(self, oid: Union[int, str], loader: Type["Loader"]) -> None:
+        """
+        Configure the context to use `!loader` to convert data of oid `!oid`.
+
+        :param oid: The PostgreSQL OID or type name to manage.
+        :param loader: The loar to register for `!oid`.
+
+        If `oid` is specified as string, it refers to a type name, which is
+        looked up in the `types` registry. `
+
+        """
+        if isinstance(oid, str):
+            oid = self.types[oid].oid
+        if not isinstance(oid, int):
+            raise TypeError(f"loaders should be registered on oid, got {oid} instead")
+
+        if _psycopg:
+            loader = self._get_optimised(loader)
+
+        fmt = loader.format
+        if not self._own_loaders[fmt]:
+            self._loaders[fmt] = self._loaders[fmt].copy()
+            self._own_loaders[fmt] = True
+
+        self._loaders[fmt][oid] = loader
+
+    def get_dumper(self, cls: type, format: PyFormat) -> Type["Dumper"]:
+        """
+        Return the dumper class for the given type and format.
+
+        Raise `~psycopg.ProgrammingError` if a class is not available.
+
+        :param cls: The class to adapt.
+        :param format: The format to dump to. If `~psycopg.adapt.PyFormat.AUTO`,
+            use the last one of the dumpers registered on `!cls`.
+        """
+        try:
+            # Fast path: the class has a known dumper.
+            return self._dumpers[format][cls]
+        except KeyError:
+            if format not in self._dumpers:
+                raise ValueError(f"bad dumper format: {format}")
+
+            # If the KeyError was caused by cls missing from dmap, let's
+            # look for different cases.
+            dmap = self._dumpers[format]
+
+        # Look for the right class, including looking at superclasses
+        for scls in cls.__mro__:
+            if scls in dmap:
+                return dmap[scls]
+
+            # If the adapter is not found, look for its name as a string
+            fqn = scls.__module__ + "." + scls.__qualname__
+            if fqn in dmap:
+                # Replace the class name with the class itself
+                d = dmap[scls] = dmap.pop(fqn)
+                return d
+
+        format = PyFormat(format)
+        raise e.ProgrammingError(
+            f"cannot adapt type {cls.__name__!r} using placeholder '%{format.value}'"
+            f" (format: {format.name})"
+        )
+
+    def get_dumper_by_oid(self, oid: int, format: pq.Format) -> Type["Dumper"]:
+        """
+        Return the dumper class for the given oid and format.
+
+        Raise `~psycopg.ProgrammingError` if a class is not available.
+
+        :param oid: The oid of the type to dump to.
+        :param format: The format to dump to.
+        """
+        try:
+            dmap = self._dumpers_by_oid[format]
+        except KeyError:
+            raise ValueError(f"bad dumper format: {format}")
+
+        try:
+            return dmap[oid]
+        except KeyError:
+            info = self.types.get(oid)
+            if info:
+                msg = (
+                    f"cannot find a dumper for type {info.name} (oid {oid})"
+                    f" format {pq.Format(format).name}"
+                )
+            else:
+                msg = (
+                    f"cannot find a dumper for unknown type with oid {oid}"
+                    f" format {pq.Format(format).name}"
+                )
+            raise e.ProgrammingError(msg)
+
+    def get_loader(self, oid: int, format: pq.Format) -> Optional[Type["Loader"]]:
+        """
+        Return the loader class for the given oid and format.
+
+        Return `!None` if not found.
+
+        :param oid: The oid of the type to load.
+        :param format: The format to load from.
+        """
+        return self._loaders[format].get(oid)
+
+    @classmethod
+    def _get_optimised(self, cls: Type[RV]) -> Type[RV]:
+        """Return the optimised version of a Dumper or Loader class.
+
+        Return the input class itself if there is no optimised version.
+        """
+        try:
+            return self._optimised[cls]
+        except KeyError:
+            pass
+
+        # Check if the class comes from psycopg.types and there is a class
+        # with the same name in psycopg_c._psycopg.
+        from psycopg import types
+
+        if cls.__module__.startswith(types.__name__):
+            new = cast(Type[RV], getattr(_psycopg, cls.__name__, None))
+            if new:
+                self._optimised[cls] = new
+                return new
+
+        self._optimised[cls] = cls
+        return cls
+
+
+# Micro-optimization: copying these objects is faster than creating new dicts
+_dumpers_owned = dict.fromkeys(PyFormat, True)
+_dumpers_shared = dict.fromkeys(PyFormat, False)

pgsql/pgAdmin 4/python/Lib/site-packages/psycopg/_cmodule.py

@@ -0,0 +1,24 @@
+"""
+Simplify access to the _psycopg module
+"""
+
+# Copyright (C) 2021 The Psycopg Team
+
+from typing import Optional
+
+from . import pq
+
+__version__: Optional[str] = None
+
+# Note: "c" must the first attempt so that mypy associates the variable the
+# right module interface. It will not result Optional, but hey.
+if pq.__impl__ == "c":
+    from psycopg_c import _psycopg as _psycopg
+    from psycopg_c import __version__ as __version__  # noqa: F401
+elif pq.__impl__ == "binary":
+    from psycopg_binary import _psycopg as _psycopg  # type: ignore
+    from psycopg_binary import __version__ as __version__  # type: ignore  # noqa: F401
+elif pq.__impl__ == "python":
+    _psycopg = None  # type: ignore
+else:
+    raise ImportError(f"can't find _psycopg optimised module in {pq.__impl__!r}")

pgsql/pgAdmin 4/python/Lib/site-packages/psycopg/_column.py

@@ -0,0 +1,142 @@
+"""
+The Column object in Cursor.description
+"""
+
+# Copyright (C) 2020 The Psycopg Team
+
+from typing import Any, NamedTuple, Optional, Sequence, TYPE_CHECKING
+from operator import attrgetter
+
+if TYPE_CHECKING:
+    from .cursor import BaseCursor
+
+
+class ColumnData(NamedTuple):
+    ftype: int
+    fmod: int
+    fsize: int
+
+
+class Column(Sequence[Any]):
+    __module__ = "psycopg"
+
+    def __init__(self, cursor: "BaseCursor[Any, Any]", index: int):
+        res = cursor.pgresult
+        assert res
+
+        fname = res.fname(index)
+        if fname:
+            self._name = fname.decode(cursor._encoding)
+        else:
+            # COPY_OUT results have columns but no name
+            self._name = f"column_{index + 1}"
+
+        self._data = ColumnData(
+            ftype=res.ftype(index),
+            fmod=res.fmod(index),
+            fsize=res.fsize(index),
+        )
+        self._type = cursor.adapters.types.get(self._data.ftype)
+
+    _attrs = tuple(
+        attrgetter(attr)
+        for attr in """
+            name type_code display_size internal_size precision scale null_ok
+            """.split()
+    )
+
+    def __repr__(self) -> str:
+        return (
+            f"<Column {self.name!r},"
+            f" type: {self._type_display()} (oid: {self.type_code})>"
+        )
+
+    def __len__(self) -> int:
+        return 7
+
+    def _type_display(self) -> str:
+        parts = []
+        parts.append(self._type.name if self._type else str(self.type_code))
+
+        mod1 = self.precision
+        if mod1 is None:
+            mod1 = self.display_size
+        if mod1:
+            parts.append(f"({mod1}")
+            if self.scale:
+                parts.append(f", {self.scale}")
+            parts.append(")")
+
+        if self._type and self.type_code == self._type.array_oid:
+            parts.append("[]")
+
+        return "".join(parts)
+
+    def __getitem__(self, index: Any) -> Any:
+        if isinstance(index, slice):
+            return tuple(getter(self) for getter in self._attrs[index])
+        else:
+            return self._attrs[index](self)
+
+    @property
+    def name(self) -> str:
+        """The name of the column."""
+        return self._name
+
+    @property
+    def type_code(self) -> int:
+        """The numeric OID of the column."""
+        return self._data.ftype
+
+    @property
+    def display_size(self) -> Optional[int]:
+        """The field size, for :sql:`varchar(n)`, None otherwise."""
+        if not self._type:
+            return None
+
+        if self._type.name in ("varchar", "char"):
+            fmod = self._data.fmod
+            if fmod >= 0:
+                return fmod - 4
+
+        return None
+
+    @property
+    def internal_size(self) -> Optional[int]:
+        """The internal field size for fixed-size types, None otherwise."""
+        fsize = self._data.fsize
+        return fsize if fsize >= 0 else None
+
+    @property
+    def precision(self) -> Optional[int]:
+        """The number of digits for fixed precision types."""
+        if not self._type:
+            return None
+
+        dttypes = ("time", "timetz", "timestamp", "timestamptz", "interval")
+        if self._type.name == "numeric":
+            fmod = self._data.fmod
+            if fmod >= 0:
+                return fmod >> 16
+
+        elif self._type.name in dttypes:
+            fmod = self._data.fmod
+            if fmod >= 0:
+                return fmod & 0xFFFF
+
+        return None
+
+    @property
+    def scale(self) -> Optional[int]:
+        """The number of digits after the decimal point if available."""
+        if self._type and self._type.name == "numeric":
+            fmod = self._data.fmod - 4
+            if fmod >= 0:
+                return fmod & 0xFFFF
+
+        return None
+
+    @property
+    def null_ok(self) -> Optional[bool]:
+        """Always `!None`"""
+        return None

pgsql/pgAdmin 4/python/Lib/site-packages/psycopg/_compat.py

@@ -0,0 +1,72 @@
+"""
+compatibility functions for different Python versions
+"""
+
+# Copyright (C) 2021 The Psycopg Team
+
+import sys
+import asyncio
+from typing import Any, Awaitable, Generator, Optional, Sequence, Union, TypeVar
+
+# NOTE: TypeAlias cannot be exported by this module, as pyright special-cases it.
+# For this raisin it must be imported directly from typing_extension where used.
+# See https://github.com/microsoft/pyright/issues/4197
+from typing_extensions import TypeAlias
+
+if sys.version_info >= (3, 8):
+    from typing import Protocol
+else:
+    from typing_extensions import Protocol
+
+T = TypeVar("T")
+FutureT: TypeAlias = Union["asyncio.Future[T]", Generator[Any, None, T], Awaitable[T]]
+
+if sys.version_info >= (3, 8):
+    create_task = asyncio.create_task
+    from math import prod
+
+else:
+
+    def create_task(
+        coro: FutureT[T], name: Optional[str] = None
+    ) -> "asyncio.Future[T]":
+        return asyncio.create_task(coro)
+
+    from functools import reduce
+
+    def prod(seq: Sequence[int]) -> int:
+        return reduce(int.__mul__, seq, 1)
+
+
+if sys.version_info >= (3, 9):
+    from zoneinfo import ZoneInfo
+    from functools import cache
+    from collections import Counter, deque as Deque
+else:
+    from typing import Counter, Deque
+    from functools import lru_cache
+    from backports.zoneinfo import ZoneInfo
+
+    cache = lru_cache(maxsize=None)
+
+if sys.version_info >= (3, 10):
+    from typing import TypeGuard
+else:
+    from typing_extensions import TypeGuard
+
+if sys.version_info >= (3, 11):
+    from typing import LiteralString
+else:
+    from typing_extensions import LiteralString
+
+__all__ = [
+    "Counter",
+    "Deque",
+    "LiteralString",
+    "Protocol",
+    "TypeGuard",
+    "ZoneInfo",
+    "cache",
+    "create_task",
+    "prod",
+]

pgsql/pgAdmin 4/python/Lib/site-packages/psycopg/_dns.py

@@ -0,0 +1,223 @@
+# type: ignore  # dnspython is currently optional and mypy fails if missing
+"""
+DNS query support
+"""
+
+# Copyright (C) 2021 The Psycopg Team
+
+import os
+import re
+import warnings
+from random import randint
+from typing import Any, DefaultDict, Dict, List, NamedTuple, Optional, Sequence
+from typing import TYPE_CHECKING
+from collections import defaultdict
+
+try:
+    from dns.resolver import Resolver, Cache
+    from dns.asyncresolver import Resolver as AsyncResolver
+    from dns.exception import DNSException
+except ImportError:
+    raise ImportError(
+        "the module psycopg._dns requires the package 'dnspython' installed"
+    )
+
+from . import errors as e
+from .conninfo import resolve_hostaddr_async as resolve_hostaddr_async_
+
+if TYPE_CHECKING:
+    from dns.rdtypes.IN.SRV import SRV
+
+resolver = Resolver()
+resolver.cache = Cache()
+
+async_resolver = AsyncResolver()
+async_resolver.cache = Cache()
+
+
+async def resolve_hostaddr_async(params: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Perform async DNS lookup of the hosts and return a new params dict.
+
+    .. deprecated:: 3.1
+        The use of this function is not necessary anymore, because
+        `psycopg.AsyncConnection.connect()` performs non-blocking name
+        resolution automatically.
+    """
+    warnings.warn(
+        "from psycopg 3.1, resolve_hostaddr_async() is not needed anymore",
+        DeprecationWarning,
+    )
+    return await resolve_hostaddr_async_(params)
+
+
+def resolve_srv(params: Dict[str, Any]) -> Dict[str, Any]:
+    """Apply SRV DNS lookup as defined in :RFC:`2782`."""
+    return Rfc2782Resolver().resolve(params)
+
+
+async def resolve_srv_async(params: Dict[str, Any]) -> Dict[str, Any]:
+    """Async equivalent of `resolve_srv()`."""
+    return await Rfc2782Resolver().resolve_async(params)
+
+
+class HostPort(NamedTuple):
+    host: str
+    port: str
+    totry: bool = False
+    target: Optional[str] = None
+
+
+class Rfc2782Resolver:
+    """Implement SRV RR Resolution as per RFC 2782
+
+    The class is organised to minimise code duplication between the sync and
+    the async paths.
+    """
+
+    re_srv_rr = re.compile(r"^(?P<service>_[^\.]+)\.(?P<proto>_[^\.]+)\.(?P<target>.+)")
+
+    def resolve(self, params: Dict[str, Any]) -> Dict[str, Any]:
+        """Update the parameters host and port after SRV lookup."""
+        attempts = self._get_attempts(params)
+        if not attempts:
+            return params
+
+        hps = []
+        for hp in attempts:
+            if hp.totry:
+                hps.extend(self._resolve_srv(hp))
+            else:
+                hps.append(hp)
+
+        return self._return_params(params, hps)
+
+    async def resolve_async(self, params: Dict[str, Any]) -> Dict[str, Any]:
+        """Update the parameters host and port after SRV lookup."""
+        attempts = self._get_attempts(params)
+        if not attempts:
+            return params
+
+        hps = []
+        for hp in attempts:
+            if hp.totry:
+                hps.extend(await self._resolve_srv_async(hp))
+            else:
+                hps.append(hp)
+
+        return self._return_params(params, hps)
+
+    def _get_attempts(self, params: Dict[str, Any]) -> List[HostPort]:
+        """
+        Return the list of host, and for each host if SRV lookup must be tried.
+
+        Return an empty list if no lookup is requested.
+        """
+        # If hostaddr is defined don't do any resolution.
+        if params.get("hostaddr", os.environ.get("PGHOSTADDR", "")):
+            return []
+
+        host_arg: str = params.get("host", os.environ.get("PGHOST", ""))
+        hosts_in = host_arg.split(",")
+        port_arg: str = str(params.get("port", os.environ.get("PGPORT", "")))
+        ports_in = port_arg.split(",")
+
+        if len(ports_in) == 1:
+            # If only one port is specified, it applies to all the hosts.
+            ports_in *= len(hosts_in)
+        if len(ports_in) != len(hosts_in):
+            # ProgrammingError would have been more appropriate, but this is
+            # what the raise if the libpq fails connect in the same case.
+            raise e.OperationalError(
+                f"cannot match {len(hosts_in)} hosts with {len(ports_in)} port numbers"
+            )
+
+        out = []
+        srv_found = False
+        for host, port in zip(hosts_in, ports_in):
+            m = self.re_srv_rr.match(host)
+            if m or port.lower() == "srv":
+                srv_found = True
+                target = m.group("target") if m else None
+                hp = HostPort(host=host, port=port, totry=True, target=target)
+            else:
+                hp = HostPort(host=host, port=port)
+            out.append(hp)
+
+        return out if srv_found else []
+
+    def _resolve_srv(self, hp: HostPort) -> List[HostPort]:
+        try:
+            ans = resolver.resolve(hp.host, "SRV")
+        except DNSException:
+            ans = ()
+        return self._get_solved_entries(hp, ans)
+
+    async def _resolve_srv_async(self, hp: HostPort) -> List[HostPort]:
+        try:
+            ans = await async_resolver.resolve(hp.host, "SRV")
+        except DNSException:
+            ans = ()
+        return self._get_solved_entries(hp, ans)
+
+    def _get_solved_entries(
+        self, hp: HostPort, entries: "Sequence[SRV]"
+    ) -> List[HostPort]:
+        if not entries:
+            # No SRV entry found. Delegate the libpq a QNAME=target lookup
+            if hp.target and hp.port.lower() != "srv":
+                return [HostPort(host=hp.target, port=hp.port)]
+            else:
+                return []
+
+        # If there is precisely one SRV RR, and its Target is "." (the root
+        # domain), abort.
+        if len(entries) == 1 and str(entries[0].target) == ".":
+            return []
+
+        return [
+            HostPort(host=str(entry.target).rstrip("."), port=str(entry.port))
+            for entry in self.sort_rfc2782(entries)
+        ]
+
+    def _return_params(
+        self, params: Dict[str, Any], hps: List[HostPort]
+    ) -> Dict[str, Any]:
+        if not hps:
+            # Nothing found, we ended up with an empty list
+            raise e.OperationalError("no host found after SRV RR lookup")
+
+        out = params.copy()
+        out["host"] = ",".join(hp.host for hp in hps)
+        out["port"] = ",".join(str(hp.port) for hp in hps)
+        return out
+
+    def sort_rfc2782(self, ans: "Sequence[SRV]") -> "List[SRV]":
+        """
+        Implement the priority/weight ordering defined in RFC 2782.
+        """
+        # Divide the entries by priority:
+        priorities: DefaultDict[int, "List[SRV]"] = defaultdict(list)
+        out: "List[SRV]" = []
+        for entry in ans:
+            priorities[entry.priority].append(entry)
+
+        for pri, entries in sorted(priorities.items()):
+            if len(entries) == 1:
+                out.append(entries[0])
+                continue
+
+            entries.sort(key=lambda ent: ent.weight)
+            total_weight = sum(ent.weight for ent in entries)
+            while entries:
+                r = randint(0, total_weight)
+                csum = 0
+                for i, ent in enumerate(entries):
+                    csum += ent.weight
+                    if csum >= r:
+                        break
+                out.append(ent)
+                total_weight -= ent.weight
+                del entries[i]
+
+        return out

pgsql/pgAdmin 4/python/Lib/site-packages/psycopg/_encodings.py

@@ -0,0 +1,170 @@
+"""
+Mappings between PostgreSQL and Python encodings.
+"""
+
+# Copyright (C) 2020 The Psycopg Team
+
+import re
+import string
+import codecs
+from typing import Any, Dict, Optional, TYPE_CHECKING
+
+from .pq._enums import ConnStatus
+from .errors import NotSupportedError
+from ._compat import cache
+
+if TYPE_CHECKING:
+    from .pq.abc import PGconn
+    from .connection import BaseConnection
+
+OK = ConnStatus.OK
+
+
+_py_codecs = {
+    "BIG5": "big5",
+    "EUC_CN": "gb2312",
+    "EUC_JIS_2004": "euc_jis_2004",
+    "EUC_JP": "euc_jp",
+    "EUC_KR": "euc_kr",
+    # "EUC_TW": not available in Python
+    "GB18030": "gb18030",
+    "GBK": "gbk",
+    "ISO_8859_5": "iso8859-5",
+    "ISO_8859_6": "iso8859-6",
+    "ISO_8859_7": "iso8859-7",
+    "ISO_8859_8": "iso8859-8",
+    "JOHAB": "johab",
+    "KOI8R": "koi8-r",
+    "KOI8U": "koi8-u",
+    "LATIN1": "iso8859-1",
+    "LATIN10": "iso8859-16",
+    "LATIN2": "iso8859-2",
+    "LATIN3": "iso8859-3",
+    "LATIN4": "iso8859-4",
+    "LATIN5": "iso8859-9",
+    "LATIN6": "iso8859-10",
+    "LATIN7": "iso8859-13",
+    "LATIN8": "iso8859-14",
+    "LATIN9": "iso8859-15",
+    # "MULE_INTERNAL": not available in Python
+    "SHIFT_JIS_2004": "shift_jis_2004",
+    "SJIS": "shift_jis",
+    # this actually means no encoding, see PostgreSQL docs
+    # it is special-cased by the text loader.
+    "SQL_ASCII": "ascii",
+    "UHC": "cp949",
+    "UTF8": "utf-8",
+    "WIN1250": "cp1250",
+    "WIN1251": "cp1251",
+    "WIN1252": "cp1252",
+    "WIN1253": "cp1253",
+    "WIN1254": "cp1254",
+    "WIN1255": "cp1255",
+    "WIN1256": "cp1256",
+    "WIN1257": "cp1257",
+    "WIN1258": "cp1258",
+    "WIN866": "cp866",
+    "WIN874": "cp874",
+}
+
+py_codecs: Dict[bytes, str] = {}
+py_codecs.update((k.encode(), v) for k, v in _py_codecs.items())
+
+# Add an alias without underscore, for lenient lookups
+py_codecs.update(
+    (k.replace("_", "").encode(), v) for k, v in _py_codecs.items() if "_" in k
+)
+
+pg_codecs = {v: k.encode() for k, v in _py_codecs.items()}
+
+
+def conn_encoding(conn: "Optional[BaseConnection[Any]]") -> str:
+    """
+    Return the Python encoding name of a psycopg connection.
+
+    Default to utf8 if the connection has no encoding info.
+    """
+    if not conn or conn.closed:
+        return "utf-8"
+
+    pgenc = conn.pgconn.parameter_status(b"client_encoding") or b"UTF8"
+    return pg2pyenc(pgenc)
+
+
+def pgconn_encoding(pgconn: "PGconn") -> str:
+    """
+    Return the Python encoding name of a libpq connection.
+
+    Default to utf8 if the connection has no encoding info.
+    """
+    if pgconn.status != OK:
+        return "utf-8"
+
+    pgenc = pgconn.parameter_status(b"client_encoding") or b"UTF8"
+    return pg2pyenc(pgenc)
+
+
+def conninfo_encoding(conninfo: str) -> str:
+    """
+    Return the Python encoding name passed in a conninfo string. Default to utf8.
+
+    Because the input is likely to come from the user and not normalised by the
+    server, be somewhat lenient (non-case-sensitive lookup, ignore noise chars).
+    """
+    from .conninfo import conninfo_to_dict
+
+    params = conninfo_to_dict(conninfo)
+    pgenc = params.get("client_encoding")
+    if pgenc:
+        try:
+            return pg2pyenc(pgenc.encode())
+        except NotSupportedError:
+            pass
+
+    return "utf-8"
+
+
+@cache
+def py2pgenc(name: str) -> bytes:
+    """Convert a Python encoding name to PostgreSQL encoding name.
+
+    Raise LookupError if the Python encoding is unknown.
+    """
+    return pg_codecs[codecs.lookup(name).name]
+
+
+@cache
+def pg2pyenc(name: bytes) -> str:
+    """Convert a PostgreSQL encoding name to Python encoding name.
+
+    Raise NotSupportedError if the PostgreSQL encoding is not supported by
+    Python.
+    """
+    try:
+        return py_codecs[name.replace(b"-", b"").replace(b"_", b"").upper()]
+    except KeyError:
+        sname = name.decode("utf8", "replace")
+        raise NotSupportedError(f"codec not available in Python: {sname!r}")
+
+
+def _as_python_identifier(s: str, prefix: str = "f") -> str:
+    """
+    Reduce a string to a valid Python identifier.
+
+    Replace all non-valid chars with '_' and prefix the value with `!prefix` if
+    the first letter is an '_'.
+    """
+    if not s.isidentifier():
+        if s[0] in "1234567890":
+            s = prefix + s
+        if not s.isidentifier():
+            s = _re_clean.sub("_", s)
+    # namedtuple fields cannot start with underscore. So...
+    if s[0] == "_":
+        s = prefix + s
+    return s
+
+
+_re_clean = re.compile(
+    f"[^{string.ascii_lowercase}{string.ascii_uppercase}{string.digits}_]"
+)

pgsql/pgAdmin 4/python/Lib/site-packages/psycopg/_enums.py

@@ -0,0 +1,79 @@
+"""
+Enum values for psycopg
+
+These values are defined by us and are not necessarily dependent on
+libpq-defined enums.
+"""
+
+# Copyright (C) 2020 The Psycopg Team
+
+from enum import Enum, IntEnum
+from selectors import EVENT_READ, EVENT_WRITE
+
+from . import pq
+
+
+class Wait(IntEnum):
+    R = EVENT_READ
+    W = EVENT_WRITE
+    RW = EVENT_READ | EVENT_WRITE
+
+
+class Ready(IntEnum):
+    R = EVENT_READ
+    W = EVENT_WRITE
+    RW = EVENT_READ | EVENT_WRITE
+
+
+class PyFormat(str, Enum):
+    """
+    Enum representing the format wanted for a query argument.
+
+    The value `AUTO` allows psycopg to choose the best format for a certain
+    parameter.
+    """
+
+    __module__ = "psycopg.adapt"
+
+    AUTO = "s"
+    """Automatically chosen (``%s`` placeholder)."""
+    TEXT = "t"
+    """Text parameter (``%t`` placeholder)."""
+    BINARY = "b"
+    """Binary parameter (``%b`` placeholder)."""
+
+    @classmethod
+    def from_pq(cls, fmt: pq.Format) -> "PyFormat":
+        return _pg2py[fmt]
+
+    @classmethod
+    def as_pq(cls, fmt: "PyFormat") -> pq.Format:
+        return _py2pg[fmt]
+
+
+class IsolationLevel(IntEnum):
+    """
+    Enum representing the isolation level for a transaction.
+    """
+
+    __module__ = "psycopg"
+
+    READ_UNCOMMITTED = 1
+    """:sql:`READ UNCOMMITTED` isolation level."""
+    READ_COMMITTED = 2
+    """:sql:`READ COMMITTED` isolation level."""
+    REPEATABLE_READ = 3
+    """:sql:`REPEATABLE READ` isolation level."""
+    SERIALIZABLE = 4
+    """:sql:`SERIALIZABLE` isolation level."""
+
+
+_py2pg = {
+    PyFormat.TEXT: pq.Format.TEXT,
+    PyFormat.BINARY: pq.Format.BINARY,
+}
+
+_pg2py = {
+    pq.Format.TEXT: PyFormat.TEXT,
+    pq.Format.BINARY: PyFormat.BINARY,
+}

pgsql/pgAdmin 4/python/Lib/site-packages/psycopg/_pipeline.py

@@ -0,0 +1,298 @@
+"""
+commands pipeline management
+"""
+
+# Copyright (C) 2021 The Psycopg Team
+
+import logging
+from types import TracebackType
+from typing import Any, List, Optional, Union, Tuple, Type, TypeVar, TYPE_CHECKING
+from typing_extensions import TypeAlias
+
+from . import pq
+from . import errors as e
+from .abc import PipelineCommand, PQGen
+from ._compat import Deque
+from .pq.misc import connection_summary
+from ._encodings import pgconn_encoding
+from ._preparing import Key, Prepare
+from .generators import pipeline_communicate, fetch_many, send
+
+if TYPE_CHECKING:
+    from .pq.abc import PGresult
+    from .cursor import BaseCursor
+    from .connection import BaseConnection, Connection
+    from .connection_async import AsyncConnection
+
+
+PendingResult: TypeAlias = Union[
+    None, Tuple["BaseCursor[Any, Any]", Optional[Tuple[Key, Prepare, bytes]]]
+]
+
+FATAL_ERROR = pq.ExecStatus.FATAL_ERROR
+PIPELINE_ABORTED = pq.ExecStatus.PIPELINE_ABORTED
+BAD = pq.ConnStatus.BAD
+
+ACTIVE = pq.TransactionStatus.ACTIVE
+
+logger = logging.getLogger("psycopg")
+
+
+class BasePipeline:
+    command_queue: Deque[PipelineCommand]
+    result_queue: Deque[PendingResult]
+    _is_supported: Optional[bool] = None
+
+    def __init__(self, conn: "BaseConnection[Any]") -> None:
+        self._conn = conn
+        self.pgconn = conn.pgconn
+        self.command_queue = Deque[PipelineCommand]()
+        self.result_queue = Deque[PendingResult]()
+        self.level = 0
+
+    def __repr__(self) -> str:
+        cls = f"{self.__class__.__module__}.{self.__class__.__qualname__}"
+        info = connection_summary(self._conn.pgconn)
+        return f"<{cls} {info} at 0x{id(self):x}>"
+
+    @property
+    def status(self) -> pq.PipelineStatus:
+        return pq.PipelineStatus(self.pgconn.pipeline_status)
+
+    @classmethod
+    def is_supported(cls) -> bool:
+        """Return `!True` if the psycopg libpq wrapper supports pipeline mode."""
+        if BasePipeline._is_supported is None:
+            BasePipeline._is_supported = not cls._not_supported_reason()
+        return BasePipeline._is_supported
+
+    @classmethod
+    def _not_supported_reason(cls) -> str:
+        """Return the reason why the pipeline mode is not supported.
+
+        Return an empty string if pipeline mode is supported.
+        """
+        # Support only depends on the libpq functions available in the pq
+        # wrapper, not on the database version.
+        if pq.version() < 140000:
+            return (
+                f"libpq too old {pq.version()};"
+                " v14 or greater required for pipeline mode"
+            )
+
+        if pq.__build_version__ < 140000:
+            return (
+                f"libpq too old: module built for {pq.__build_version__};"
+                " v14 or greater required for pipeline mode"
+            )
+
+        return ""
+
+    def _enter_gen(self) -> PQGen[None]:
+        if not self.is_supported():
+            raise e.NotSupportedError(
+                f"pipeline mode not supported: {self._not_supported_reason()}"
+            )
+        if self.level == 0:
+            self.pgconn.enter_pipeline_mode()
+        elif self.command_queue or self.pgconn.transaction_status == ACTIVE:
+            # Nested pipeline case.
+            #  Transaction might be ACTIVE when the pipeline uses an "implicit
+            #  transaction", typically in autocommit mode. But when entering a
+            #  Psycopg transaction(), we expect the IDLE state. By sync()-ing,
+            #  we make sure all previous commands are completed and the
+            #  transaction gets back to IDLE.
+            yield from self._sync_gen()
+        self.level += 1
+
+    def _exit(self, exc: Optional[BaseException]) -> None:
+        self.level -= 1
+        if self.level == 0 and self.pgconn.status != BAD:
+            try:
+                self.pgconn.exit_pipeline_mode()
+            except e.OperationalError as exc2:
+                # Notice that this error might be pretty irrecoverable. It
+                # happens on COPY, for instance: even if sync succeeds, exiting
+                # fails with "cannot exit pipeline mode with uncollected results"
+                if exc:
+                    logger.warning("error ignored exiting %r: %s", self, exc2)
+                else:
+                    raise exc2.with_traceback(None)
+
+    def _sync_gen(self) -> PQGen[None]:
+        self._enqueue_sync()
+        yield from self._communicate_gen()
+        yield from self._fetch_gen(flush=False)
+
+    def _exit_gen(self) -> PQGen[None]:
+        """
+        Exit current pipeline by sending a Sync and fetch back all remaining results.
+        """
+        try:
+            self._enqueue_sync()
+            yield from self._communicate_gen()
+        finally:
+            # No need to force flush since we emitted a sync just before.
+            yield from self._fetch_gen(flush=False)
+
+    def _communicate_gen(self) -> PQGen[None]:
+        """Communicate with pipeline to send commands and possibly fetch
+        results, which are then processed.
+        """
+        fetched = yield from pipeline_communicate(self.pgconn, self.command_queue)
+        exception = None
+        for results in fetched:
+            queued = self.result_queue.popleft()
+            try:
+                self._process_results(queued, results)
+            except e.Error as exc:
+                if exception is None:
+                    exception = exc
+        if exception is not None:
+            raise exception
+
+    def _fetch_gen(self, *, flush: bool) -> PQGen[None]:
+        """Fetch available results from the connection and process them with
+        pipeline queued items.
+
+        If 'flush' is True, a PQsendFlushRequest() is issued in order to make
+        sure results can be fetched. Otherwise, the caller may emit a
+        PQpipelineSync() call to ensure the output buffer gets flushed before
+        fetching.
+        """
+        if not self.result_queue:
+            return
+
+        if flush:
+            self.pgconn.send_flush_request()
+            yield from send(self.pgconn)
+
+        exception = None
+        while self.result_queue:
+            results = yield from fetch_many(self.pgconn)
+            if not results:
+                # No more results to fetch, but there may still be pending
+                # commands.
+                break
+            queued = self.result_queue.popleft()
+            try:
+                self._process_results(queued, results)
+            except e.Error as exc:
+                if exception is None:
+                    exception = exc
+        if exception is not None:
+            raise exception
+
+    def _process_results(
+        self, queued: PendingResult, results: List["PGresult"]
+    ) -> None:
+        """Process a results set fetched from the current pipeline.
+
+        This matches 'results' with its respective element in the pipeline
+        queue. For commands (None value in the pipeline queue), results are
+        checked directly. For prepare statement creation requests, update the
+        cache. Otherwise, results are attached to their respective cursor.
+        """
+        if queued is None:
+            (result,) = results
+            if result.status == FATAL_ERROR:
+                raise e.error_from_result(result, encoding=pgconn_encoding(self.pgconn))
+            elif result.status == PIPELINE_ABORTED:
+                raise e.PipelineAborted("pipeline aborted")
+        else:
+            cursor, prepinfo = queued
+            if prepinfo:
+                key, prep, name = prepinfo
+                # Update the prepare state of the query.
+                cursor._conn._prepared.validate(key, prep, name, results)
+            cursor._set_results_from_pipeline(results)
+
+    def _enqueue_sync(self) -> None:
+        """Enqueue a PQpipelineSync() command."""
+        self.command_queue.append(self.pgconn.pipeline_sync)
+        self.result_queue.append(None)
+
+
+class Pipeline(BasePipeline):
+    """Handler for connection in pipeline mode."""
+
+    __module__ = "psycopg"
+    _conn: "Connection[Any]"
+    _Self = TypeVar("_Self", bound="Pipeline")
+
+    def __init__(self, conn: "Connection[Any]") -> None:
+        super().__init__(conn)
+
+    def sync(self) -> None:
+        """Sync the pipeline, send any pending command and receive and process
+        all available results.
+        """
+        try:
+            with self._conn.lock:
+                self._conn.wait(self._sync_gen())
+        except e._NO_TRACEBACK as ex:
+            raise ex.with_traceback(None)
+
+    def __enter__(self: _Self) -> _Self:
+        with self._conn.lock:
+            self._conn.wait(self._enter_gen())
+        return self
+
+    def __exit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> None:
+        try:
+            with self._conn.lock:
+                self._conn.wait(self._exit_gen())
+        except Exception as exc2:
+            # Don't clobber an exception raised in the block with this one
+            if exc_val:
+                logger.warning("error ignored terminating %r: %s", self, exc2)
+            else:
+                raise exc2.with_traceback(None)
+        finally:
+            self._exit(exc_val)
+
+
+class AsyncPipeline(BasePipeline):
+    """Handler for async connection in pipeline mode."""
+
+    __module__ = "psycopg"
+    _conn: "AsyncConnection[Any]"
+    _Self = TypeVar("_Self", bound="AsyncPipeline")
+
+    def __init__(self, conn: "AsyncConnection[Any]") -> None:
+        super().__init__(conn)
+
+    async def sync(self) -> None:
+        try:
+            async with self._conn.lock:
+                await self._conn.wait(self._sync_gen())
+        except e._NO_TRACEBACK as ex:
+            raise ex.with_traceback(None)
+
+    async def __aenter__(self: _Self) -> _Self:
+        async with self._conn.lock:
+            await self._conn.wait(self._enter_gen())
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> None:
+        try:
+            async with self._conn.lock:
+                await self._conn.wait(self._exit_gen())
+        except Exception as exc2:
+            # Don't clobber an exception raised in the block with this one
+            if exc_val:
+                logger.warning("error ignored terminating %r: %s", self, exc2)
+            else:
+                raise exc2.with_traceback(None)
+        finally:
+            self._exit(exc_val)

pgsql/pgAdmin 4/python/Lib/site-packages/psycopg/_preparing.py

@@ -0,0 +1,194 @@
+"""
+Support for prepared statements
+"""
+
+# Copyright (C) 2020 The Psycopg Team
+
+from enum import IntEnum, auto
+from typing import Iterator, Optional, Sequence, Tuple, TYPE_CHECKING
+from collections import OrderedDict
+from typing_extensions import TypeAlias
+
+from . import pq
+from ._compat import Deque
+from ._queries import PostgresQuery
+
+if TYPE_CHECKING:
+    from .pq.abc import PGresult
+
+Key: TypeAlias = Tuple[bytes, Tuple[int, ...]]
+
+COMMAND_OK = pq.ExecStatus.COMMAND_OK
+TUPLES_OK = pq.ExecStatus.TUPLES_OK
+
+
+class Prepare(IntEnum):
+    NO = auto()
+    YES = auto()
+    SHOULD = auto()
+
+
+class PrepareManager:
+    # Number of times a query is executed before it is prepared.
+    prepare_threshold: Optional[int] = 5
+
+    # Maximum number of prepared statements on the connection.
+    prepared_max: int = 100
+
+    def __init__(self) -> None:
+        # Map (query, types) to the number of times the query was seen.
+        self._counts: OrderedDict[Key, int] = OrderedDict()
+
+        # Map (query, types) to the name of the statement if  prepared.
+        self._names: OrderedDict[Key, bytes] = OrderedDict()
+
+        # Counter to generate prepared statements names
+        self._prepared_idx = 0
+
+        self._maint_commands = Deque[bytes]()
+
+    @staticmethod
+    def key(query: PostgresQuery) -> Key:
+        return (query.query, query.types)
+
+    def get(
+        self, query: PostgresQuery, prepare: Optional[bool] = None
+    ) -> Tuple[Prepare, bytes]:
+        """
+        Check if a query is prepared, tell back whether to prepare it.
+        """
+        if prepare is False or self.prepare_threshold is None:
+            # The user doesn't want this query to be prepared
+            return Prepare.NO, b""
+
+        key = self.key(query)
+        name = self._names.get(key)
+        if name:
+            # The query was already prepared in this session
+            return Prepare.YES, name
+
+        count = self._counts.get(key, 0)
+        if count >= self.prepare_threshold or prepare:
+            # The query has been executed enough times and needs to be prepared
+            name = f"_pg3_{self._prepared_idx}".encode()
+            self._prepared_idx += 1
+            return Prepare.SHOULD, name
+        else:
+            # The query is not to be prepared yet
+            return Prepare.NO, b""
+
+    def _should_discard(self, prep: Prepare, results: Sequence["PGresult"]) -> bool:
+        """Check if we need to discard our entire state: it should happen on
+        rollback or on dropping objects, because the same object may get
+        recreated and postgres would fail internal lookups.
+        """
+        if self._names or prep == Prepare.SHOULD:
+            for result in results:
+                if result.status != COMMAND_OK:
+                    continue
+                cmdstat = result.command_status
+                if cmdstat and (cmdstat.startswith(b"DROP ") or cmdstat == b"ROLLBACK"):
+                    return self.clear()
+        return False
+
+    @staticmethod
+    def _check_results(results: Sequence["PGresult"]) -> bool:
+        """Return False if 'results' are invalid for prepared statement cache."""
+        if len(results) != 1:
+            # We cannot prepare a multiple statement
+            return False
+
+        status = results[0].status
+        if COMMAND_OK != status != TUPLES_OK:
+            # We don't prepare failed queries or other weird results
+            return False
+
+        return True
+
+    def _rotate(self) -> None:
+        """Evict an old value from the cache.
+
+        If it was prepared, deallocate it. Do it only once: if the cache was
+        resized, deallocate gradually.
+        """
+        if len(self._counts) > self.prepared_max:
+            self._counts.popitem(last=False)
+
+        if len(self._names) > self.prepared_max:
+            name = self._names.popitem(last=False)[1]
+            self._maint_commands.append(b"DEALLOCATE " + name)
+
+    def maybe_add_to_cache(
+        self, query: PostgresQuery, prep: Prepare, name: bytes
+    ) -> Optional[Key]:
+        """Handle 'query' for possible addition to the cache.
+
+        If a new entry has been added, return its key. Return None otherwise
+        (meaning the query is already in cache or cache is not enabled).
+        """
+        # don't do anything if prepared statements are disabled
+        if self.prepare_threshold is None:
+            return None
+
+        key = self.key(query)
+        if key in self._counts:
+            if prep is Prepare.SHOULD:
+                del self._counts[key]
+                self._names[key] = name
+            else:
+                self._counts[key] += 1
+                self._counts.move_to_end(key)
+            return None
+
+        elif key in self._names:
+            self._names.move_to_end(key)
+            return None
+
+        else:
+            if prep is Prepare.SHOULD:
+                self._names[key] = name
+            else:
+                self._counts[key] = 1
+            return key
+
+    def validate(
+        self,
+        key: Key,
+        prep: Prepare,
+        name: bytes,
+        results: Sequence["PGresult"],
+    ) -> None:
+        """Validate cached entry with 'key' by checking query 'results'.
+
+        Possibly record a command to perform maintenance on database side.
+        """
+        if self._should_discard(prep, results):
+            return
+
+        if not self._check_results(results):
+            self._names.pop(key, None)
+            self._counts.pop(key, None)
+        else:
+            self._rotate()
+
+    def clear(self) -> bool:
+        """Clear the cache of the maintenance commands.
+
+        Clear the internal state and prepare a command to clear the state of
+        the server.
+        """
+        self._counts.clear()
+        if self._names:
+            self._names.clear()
+            self._maint_commands.clear()
+            self._maint_commands.append(b"DEALLOCATE ALL")
+            return True
+        else:
+            return False
+
+    def get_maintenance_commands(self) -> Iterator[bytes]:
+        """
+        Iterate over the commands needed to align the server state to our state
+        """
+        while self._maint_commands:
+            yield self._maint_commands.popleft()

pgsql/pgAdmin 4/python/Lib/site-packages/psycopg/_queries.py

@@ -0,0 +1,415 @@
+"""
+Utility module to manipulate queries
+"""
+
+# Copyright (C) 2020 The Psycopg Team
+
+import re
+from typing import Any, Callable, Dict, List, Mapping, Match, NamedTuple, Optional
+from typing import Sequence, Tuple, Union, TYPE_CHECKING
+from functools import lru_cache
+from typing_extensions import TypeAlias
+
+from . import pq
+from . import errors as e
+from .sql import Composable
+from .abc import Buffer, Query, Params
+from ._enums import PyFormat
+from ._encodings import conn_encoding
+
+if TYPE_CHECKING:
+    from .abc import Transformer
+
+MAX_CACHED_STATEMENT_LENGTH = 4096
+MAX_CACHED_STATEMENT_PARAMS = 50
+
+
+class QueryPart(NamedTuple):
+    pre: bytes
+    item: Union[int, str]
+    format: PyFormat
+
+
+class PostgresQuery:
+    """
+    Helper to convert a Python query and parameters into Postgres format.
+    """
+
+    __slots__ = """
+        query params types formats
+        _tx _want_formats _parts _encoding _order
+        """.split()
+
+    def __init__(self, transformer: "Transformer"):
+        self._tx = transformer
+
+        self.params: Optional[Sequence[Optional[Buffer]]] = None
+        # these are tuples so they can be used as keys e.g. in prepared stmts
+        self.types: Tuple[int, ...] = ()
+
+        # The format requested by the user and the ones to really pass Postgres
+        self._want_formats: Optional[List[PyFormat]] = None
+        self.formats: Optional[Sequence[pq.Format]] = None
+
+        self._encoding = conn_encoding(transformer.connection)
+        self._parts: List[QueryPart]
+        self.query = b""
+        self._order: Optional[List[str]] = None
+
+    def convert(self, query: Query, vars: Optional[Params]) -> None:
+        """
+        Set up the query and parameters to convert.
+
+        The results of this function can be obtained accessing the object
+        attributes (`query`, `params`, `types`, `formats`).
+        """
+        if isinstance(query, str):
+            bquery = query.encode(self._encoding)
+        elif isinstance(query, Composable):
+            bquery = query.as_bytes(self._tx)
+        else:
+            bquery = query
+
+        if vars is not None:
+            # Avoid caching queries extremely long or with a huge number of
+            # parameters. They are usually generated by ORMs and have poor
+            # cacheablility (e.g. INSERT ... VALUES (...), (...) with varying
+            # numbers of tuples.
+            # see https://github.com/psycopg/psycopg/discussions/628
+            if (
+                len(bquery) <= MAX_CACHED_STATEMENT_LENGTH
+                and len(vars) <= MAX_CACHED_STATEMENT_PARAMS
+            ):
+                f: _Query2Pg = _query2pg
+            else:
+                f = _query2pg_nocache
+
+            (self.query, self._want_formats, self._order, self._parts) = f(
+                bquery, self._encoding
+            )
+        else:
+            self.query = bquery
+            self._want_formats = self._order = None
+
+        self.dump(vars)
+
+    def dump(self, vars: Optional[Params]) -> None:
+        """
+        Process a new set of variables on the query processed by `convert()`.
+
+        This method updates `params` and `types`.
+        """
+        if vars is not None:
+            params = _validate_and_reorder_params(self._parts, vars, self._order)
+            assert self._want_formats is not None
+            self.params = self._tx.dump_sequence(params, self._want_formats)
+            self.types = self._tx.types or ()
+            self.formats = self._tx.formats
+        else:
+            self.params = None
+            self.types = ()
+            self.formats = None
+
+
+# The type of the _query2pg() and _query2pg_nocache() methods
+_Query2Pg: TypeAlias = Callable[
+    [bytes, str], Tuple[bytes, List[PyFormat], Optional[List[str]], List[QueryPart]]
+]
+
+
+def _query2pg_nocache(
+    query: bytes, encoding: str
+) -> Tuple[bytes, List[PyFormat], Optional[List[str]], List[QueryPart]]:
+    """
+    Convert Python query and params into something Postgres understands.
+
+    - Convert Python placeholders (``%s``, ``%(name)s``) into Postgres
+      format (``$1``, ``$2``)
+    - placeholders can be %s, %t, or %b (auto, text or binary)
+    - return ``query`` (bytes), ``formats`` (list of formats) ``order``
+      (sequence of names used in the query, in the position they appear)
+      ``parts`` (splits of queries and placeholders).
+    """
+    parts = _split_query(query, encoding)
+    order: Optional[List[str]] = None
+    chunks: List[bytes] = []
+    formats = []
+
+    if isinstance(parts[0].item, int):
+        for part in parts[:-1]:
+            assert isinstance(part.item, int)
+            chunks.append(part.pre)
+            chunks.append(b"$%d" % (part.item + 1))
+            formats.append(part.format)
+
+    elif isinstance(parts[0].item, str):
+        seen: Dict[str, Tuple[bytes, PyFormat]] = {}
+        order = []
+        for part in parts[:-1]:
+            assert isinstance(part.item, str)
+            chunks.append(part.pre)
+            if part.item not in seen:
+                ph = b"$%d" % (len(seen) + 1)
+                seen[part.item] = (ph, part.format)
+                order.append(part.item)
+                chunks.append(ph)
+                formats.append(part.format)
+            else:
+                if seen[part.item][1] != part.format:
+                    raise e.ProgrammingError(
+                        f"placeholder '{part.item}' cannot have different formats"
+                    )
+                chunks.append(seen[part.item][0])
+
+    # last part
+    chunks.append(parts[-1].pre)
+
+    return b"".join(chunks), formats, order, parts
+
+
+# Note: the cache size is 128 items, but someone has reported throwing ~12k
+# queries (of type `INSERT ... VALUES (...), (...)` with a varying amount of
+# records), and the resulting cache size is >100Mb. So, we will avoid to cache
+# large queries or queries with a large number of params. See
+# https://github.com/sqlalchemy/sqlalchemy/discussions/10270
+_query2pg = lru_cache()(_query2pg_nocache)
+
+
+class PostgresClientQuery(PostgresQuery):
+    """
+    PostgresQuery subclass merging query and arguments client-side.
+    """
+
+    __slots__ = ("template",)
+
+    def convert(self, query: Query, vars: Optional[Params]) -> None:
+        """
+        Set up the query and parameters to convert.
+
+        The results of this function can be obtained accessing the object
+        attributes (`query`, `params`, `types`, `formats`).
+        """
+        if isinstance(query, str):
+            bquery = query.encode(self._encoding)
+        elif isinstance(query, Composable):
+            bquery = query.as_bytes(self._tx)
+        else:
+            bquery = query
+
+        if vars is not None:
+            if (
+                len(bquery) <= MAX_CACHED_STATEMENT_LENGTH
+                and len(vars) <= MAX_CACHED_STATEMENT_PARAMS
+            ):
+                f: _Query2PgClient = _query2pg_client
+            else:
+                f = _query2pg_client_nocache
+
+            (self.template, self._order, self._parts) = f(bquery, self._encoding)
+        else:
+            self.query = bquery
+            self._order = None
+
+        self.dump(vars)
+
+    def dump(self, vars: Optional[Params]) -> None:
+        """
+        Process a new set of variables on the query processed by `convert()`.
+
+        This method updates `params` and `types`.
+        """
+        if vars is not None:
+            params = _validate_and_reorder_params(self._parts, vars, self._order)
+            self.params = tuple(
+                self._tx.as_literal(p) if p is not None else b"NULL" for p in params
+            )
+            self.query = self.template % self.params
+        else:
+            self.params = None
+
+
+_Query2PgClient: TypeAlias = Callable[
+    [bytes, str], Tuple[bytes, Optional[List[str]], List[QueryPart]]
+]
+
+
+def _query2pg_client_nocache(
+    query: bytes, encoding: str
+) -> Tuple[bytes, Optional[List[str]], List[QueryPart]]:
+    """
+    Convert Python query and params into a template to perform client-side binding
+    """
+    parts = _split_query(query, encoding, collapse_double_percent=False)
+    order: Optional[List[str]] = None
+    chunks: List[bytes] = []
+
+    if isinstance(parts[0].item, int):
+        for part in parts[:-1]:
+            assert isinstance(part.item, int)
+            chunks.append(part.pre)
+            chunks.append(b"%s")
+
+    elif isinstance(parts[0].item, str):
+        seen: Dict[str, Tuple[bytes, PyFormat]] = {}
+        order = []
+        for part in parts[:-1]:
+            assert isinstance(part.item, str)
+            chunks.append(part.pre)
+            if part.item not in seen:
+                ph = b"%s"
+                seen[part.item] = (ph, part.format)
+                order.append(part.item)
+                chunks.append(ph)
+            else:
+                chunks.append(seen[part.item][0])
+                order.append(part.item)
+
+    # last part
+    chunks.append(parts[-1].pre)
+
+    return b"".join(chunks), order, parts
+
+
+_query2pg_client = lru_cache()(_query2pg_client_nocache)
+
+
+def _validate_and_reorder_params(
+    parts: List[QueryPart], vars: Params, order: Optional[List[str]]
+) -> Sequence[Any]:
+    """
+    Verify the compatibility between a query and a set of params.
+    """
+    # Try concrete types, then abstract types
+    t = type(vars)
+    if t is list or t is tuple:
+        sequence = True
+    elif t is dict:
+        sequence = False
+    elif isinstance(vars, Sequence) and not isinstance(vars, (bytes, str)):
+        sequence = True
+    elif isinstance(vars, Mapping):
+        sequence = False
+    else:
+        raise TypeError(
+            "query parameters should be a sequence or a mapping,"
+            f" got {type(vars).__name__}"
+        )
+
+    if sequence:
+        if len(vars) != len(parts) - 1:
+            raise e.ProgrammingError(
+                f"the query has {len(parts) - 1} placeholders but"
+                f" {len(vars)} parameters were passed"
+            )
+        if vars and not isinstance(parts[0].item, int):
+            raise TypeError("named placeholders require a mapping of parameters")
+        return vars  # type: ignore[return-value]
+
+    else:
+        if vars and len(parts) > 1 and not isinstance(parts[0][1], str):
+            raise TypeError(
+                "positional placeholders (%s) require a sequence of parameters"
+            )
+        try:
+            return [vars[item] for item in order or ()]  # type: ignore[call-overload]
+        except KeyError:
+            raise e.ProgrammingError(
+                "query parameter missing:"
+                f" {', '.join(sorted(i for i in order or () if i not in vars))}"
+            )
+
+
+_re_placeholder = re.compile(
+    rb"""(?x)
+        %                       # a literal %
+        (?:
+            (?:
+                \( ([^)]+) \)   # or a name in (braces)
+                .               # followed by a format
+            )
+            |
+            (?:.)               # or any char, really
+        )
+        """
+)
+
+
+def _split_query(
+    query: bytes, encoding: str = "ascii", collapse_double_percent: bool = True
+) -> List[QueryPart]:
+    parts: List[Tuple[bytes, Optional[Match[bytes]]]] = []
+    cur = 0
+
+    # pairs [(fragment, match], with the last match None
+    m = None
+    for m in _re_placeholder.finditer(query):
+        pre = query[cur : m.span(0)[0]]
+        parts.append((pre, m))
+        cur = m.span(0)[1]
+    if m:
+        parts.append((query[cur:], None))
+    else:
+        parts.append((query, None))
+
+    rv = []
+
+    # drop the "%%", validate
+    i = 0
+    phtype = None
+    while i < len(parts):
+        pre, m = parts[i]
+        if m is None:
+            # last part
+            rv.append(QueryPart(pre, 0, PyFormat.AUTO))
+            break
+
+        ph = m.group(0)
+        if ph == b"%%":
+            # unescape '%%' to '%' if necessary, then merge the parts
+            if collapse_double_percent:
+                ph = b"%"
+            pre1, m1 = parts[i + 1]
+            parts[i + 1] = (pre + ph + pre1, m1)
+            del parts[i]
+            continue
+
+        if ph == b"%(":
+            raise e.ProgrammingError(
+                "incomplete placeholder:"
+                f" '{query[m.span(0)[0]:].split()[0].decode(encoding)}'"
+            )
+        elif ph == b"% ":
+            # explicit messasge for a typical error
+            raise e.ProgrammingError(
+                "incomplete placeholder: '%'; if you want to use '%' as an"
+                " operator you can double it up, i.e. use '%%'"
+            )
+        elif ph[-1:] not in b"sbt":
+            raise e.ProgrammingError(
+                "only '%s', '%b', '%t' are allowed as placeholders, got"
+                f" '{m.group(0).decode(encoding)}'"
+            )
+
+        # Index or name
+        item: Union[int, str]
+        item = m.group(1).decode(encoding) if m.group(1) else i
+
+        if not phtype:
+            phtype = type(item)
+        elif phtype is not type(item):
+            raise e.ProgrammingError(
+                "positional and named placeholders cannot be mixed"
+            )
+
+        format = _ph_to_fmt[ph[-1:]]
+        rv.append(QueryPart(pre, item, format))
+        i += 1
+
+    return rv
+
+
+_ph_to_fmt = {
+    b"s": PyFormat.AUTO,
+    b"t": PyFormat.TEXT,
+    b"b": PyFormat.BINARY,
+}

pgsql/pgAdmin 4/python/Lib/site-packages/psycopg/_struct.py

@@ -0,0 +1,57 @@
+"""
+Utility functions to deal with binary structs.
+"""
+
+# Copyright (C) 2020 The Psycopg Team
+
+import struct
+from typing import Callable, cast, Optional, Tuple
+from typing_extensions import TypeAlias
+
+from .abc import Buffer
+from . import errors as e
+from ._compat import Protocol
+
+PackInt: TypeAlias = Callable[[int], bytes]
+UnpackInt: TypeAlias = Callable[[Buffer], Tuple[int]]
+PackFloat: TypeAlias = Callable[[float], bytes]
+UnpackFloat: TypeAlias = Callable[[Buffer], Tuple[float]]
+
+
+class UnpackLen(Protocol):
+    def __call__(self, data: Buffer, start: Optional[int]) -> Tuple[int]:
+        ...
+
+
+pack_int2 = cast(PackInt, struct.Struct("!h").pack)
+pack_uint2 = cast(PackInt, struct.Struct("!H").pack)
+pack_int4 = cast(PackInt, struct.Struct("!i").pack)
+pack_uint4 = cast(PackInt, struct.Struct("!I").pack)
+pack_int8 = cast(PackInt, struct.Struct("!q").pack)
+pack_float4 = cast(PackFloat, struct.Struct("!f").pack)
+pack_float8 = cast(PackFloat, struct.Struct("!d").pack)
+
+unpack_int2 = cast(UnpackInt, struct.Struct("!h").unpack)
+unpack_uint2 = cast(UnpackInt, struct.Struct("!H").unpack)
+unpack_int4 = cast(UnpackInt, struct.Struct("!i").unpack)
+unpack_uint4 = cast(UnpackInt, struct.Struct("!I").unpack)
+unpack_int8 = cast(UnpackInt, struct.Struct("!q").unpack)
+unpack_float4 = cast(UnpackFloat, struct.Struct("!f").unpack)
+unpack_float8 = cast(UnpackFloat, struct.Struct("!d").unpack)
+
+_struct_len = struct.Struct("!i")
+pack_len = cast(Callable[[int], bytes], _struct_len.pack)
+unpack_len = cast(UnpackLen, _struct_len.unpack_from)
+
+
+def pack_float4_bug_304(x: float) -> bytes:
+    raise e.InterfaceError(
+        "cannot dump Float4: Python affected by bug #304. Note that the psycopg-c"
+        " and psycopg-binary packages are not affected by this issue."
+        " See https://github.com/psycopg/psycopg/issues/304"
+    )
+
+
+# If issue #304 is detected, raise an error instead of dumping wrong data.
+if struct.Struct("!f").pack(1.0) != bytes.fromhex("3f800000"):
+    pack_float4 = pack_float4_bug_304

pgsql/pgAdmin 4/python/Lib/site-packages/psycopg/_tpc.py

@@ -0,0 +1,116 @@
+"""
+psycopg two-phase commit support
+"""
+
+# Copyright (C) 2021 The Psycopg Team
+
+import re
+import datetime as dt
+from base64 import b64encode, b64decode
+from typing import Optional, Union
+from dataclasses import dataclass, replace
+
+_re_xid = re.compile(r"^(\d+)_([^_]*)_([^_]*)$")
+
+
+@dataclass(frozen=True)
+class Xid:
+    """A two-phase commit transaction identifier.
+
+    The object can also be unpacked as a 3-item tuple (`format_id`, `gtrid`,
+    `bqual`).
+
+    """
+
+    format_id: Optional[int]
+    gtrid: str
+    bqual: Optional[str]
+    prepared: Optional[dt.datetime] = None
+    owner: Optional[str] = None
+    database: Optional[str] = None
+
+    @classmethod
+    def from_string(cls, s: str) -> "Xid":
+        """Try to parse an XA triple from the string.
+
+        This may fail for several reasons. In such case return an unparsed Xid.
+        """
+        try:
+            return cls._parse_string(s)
+        except Exception:
+            return Xid(None, s, None)
+
+    def __str__(self) -> str:
+        return self._as_tid()
+
+    def __len__(self) -> int:
+        return 3
+
+    def __getitem__(self, index: int) -> Union[int, str, None]:
+        return (self.format_id, self.gtrid, self.bqual)[index]
+
+    @classmethod
+    def _parse_string(cls, s: str) -> "Xid":
+        m = _re_xid.match(s)
+        if not m:
+            raise ValueError("bad Xid format")
+
+        format_id = int(m.group(1))
+        gtrid = b64decode(m.group(2)).decode()
+        bqual = b64decode(m.group(3)).decode()
+        return cls.from_parts(format_id, gtrid, bqual)
+
+    @classmethod
+    def from_parts(
+        cls, format_id: Optional[int], gtrid: str, bqual: Optional[str]
+    ) -> "Xid":
+        if format_id is not None:
+            if bqual is None:
+                raise TypeError("if format_id is specified, bqual must be too")
+            if not 0 <= format_id < 0x80000000:
+                raise ValueError("format_id must be a non-negative 32-bit integer")
+            if len(bqual) > 64:
+                raise ValueError("bqual must be not longer than 64 chars")
+            if len(gtrid) > 64:
+                raise ValueError("gtrid must be not longer than 64 chars")
+
+        elif bqual is None:
+            raise TypeError("if format_id is None, bqual must be None too")
+
+        return Xid(format_id, gtrid, bqual)
+
+    def _as_tid(self) -> str:
+        """
+        Return the PostgreSQL transaction_id for this XA xid.
+
+        PostgreSQL wants just a string, while the DBAPI supports the XA
+        standard and thus a triple. We use the same conversion algorithm
+        implemented by JDBC in order to allow some form of interoperation.
+
+        see also: the pgjdbc implementation
+          http://cvs.pgfoundry.org/cgi-bin/cvsweb.cgi/jdbc/pgjdbc/org/
+            postgresql/xa/RecoveredXid.java?rev=1.2
+        """
+        if self.format_id is None or self.bqual is None:
+            # Unparsed xid: return the gtrid.
+            return self.gtrid
+
+        # XA xid: mash together the components.
+        egtrid = b64encode(self.gtrid.encode()).decode()
+        ebqual = b64encode(self.bqual.encode()).decode()
+
+        return f"{self.format_id}_{egtrid}_{ebqual}"
+
+    @classmethod
+    def _get_recover_query(cls) -> str:
+        return "SELECT gid, prepared, owner, database FROM pg_prepared_xacts"
+
+    @classmethod
+    def _from_record(
+        cls, gid: str, prepared: dt.datetime, owner: str, database: str
+    ) -> "Xid":
+        xid = Xid.from_string(gid)
+        return replace(xid, prepared=prepared, owner=owner, database=database)
+
+
+Xid.__module__ = "psycopg"

pgsql/pgAdmin 4/python/Lib/site-packages/psycopg/_transform.py

@@ -0,0 +1,354 @@
+"""
+Helper object to transform values between Python and PostgreSQL
+"""
+
+# Copyright (C) 2020 The Psycopg Team
+
+from typing import Any, Dict, List, Optional, Sequence, Tuple
+from typing import DefaultDict, TYPE_CHECKING
+from collections import defaultdict
+from typing_extensions import TypeAlias
+
+from . import pq
+from . import postgres
+from . import errors as e
+from .abc import Buffer, LoadFunc, AdaptContext, PyFormat, DumperKey, NoneType
+from .rows import Row, RowMaker
+from .postgres import INVALID_OID, TEXT_OID
+from ._encodings import pgconn_encoding
+
+if TYPE_CHECKING:
+    from .abc import Dumper, Loader
+    from .adapt import AdaptersMap
+    from .pq.abc import PGresult
+    from .connection import BaseConnection
+
+DumperCache: TypeAlias = Dict[DumperKey, "Dumper"]
+OidDumperCache: TypeAlias = Dict[int, "Dumper"]
+LoaderCache: TypeAlias = Dict[int, "Loader"]
+
+TEXT = pq.Format.TEXT
+PY_TEXT = PyFormat.TEXT
+
+
+class Transformer(AdaptContext):
+    """
+    An object that can adapt efficiently between Python and PostgreSQL.
+
+    The life cycle of the object is the query, so it is assumed that attributes
+    such as the server version or the connection encoding will not change. The
+    object have its state so adapting several values of the same type can be
+    optimised.
+
+    """
+
+    __module__ = "psycopg.adapt"
+
+    __slots__ = """
+        types formats
+        _conn _adapters _pgresult _dumpers _loaders _encoding _none_oid
+        _oid_dumpers _oid_types _row_dumpers _row_loaders
+        """.split()
+
+    types: Optional[Tuple[int, ...]]
+    formats: Optional[List[pq.Format]]
+
+    _adapters: "AdaptersMap"
+    _pgresult: Optional["PGresult"]
+    _none_oid: int
+
+    def __init__(self, context: Optional[AdaptContext] = None):
+        self._pgresult = self.types = self.formats = None
+
+        # WARNING: don't store context, or you'll create a loop with the Cursor
+        if context:
+            self._adapters = context.adapters
+            self._conn = context.connection
+        else:
+            self._adapters = postgres.adapters
+            self._conn = None
+
+        # mapping fmt, class -> Dumper instance
+        self._dumpers: DefaultDict[PyFormat, DumperCache]
+        self._dumpers = defaultdict(dict)
+
+        # mapping fmt, oid -> Dumper instance
+        # Not often used, so create it only if needed.
+        self._oid_dumpers: Optional[Tuple[OidDumperCache, OidDumperCache]]
+        self._oid_dumpers = None
+
+        # mapping fmt, oid -> Loader instance
+        self._loaders: Tuple[LoaderCache, LoaderCache] = ({}, {})
+
+        self._row_dumpers: Optional[List["Dumper"]] = None
+
+        # sequence of load functions from value to python
+        # the length of the result columns
+        self._row_loaders: List[LoadFunc] = []
+
+        # mapping oid -> type sql representation
+        self._oid_types: Dict[int, bytes] = {}
+
+        self._encoding = ""
+
+    @classmethod
+    def from_context(cls, context: Optional[AdaptContext]) -> "Transformer":
+        """
+        Return a Transformer from an AdaptContext.
+
+        If the context is a Transformer instance, just return it.
+        """
+        if isinstance(context, Transformer):
+            return context
+        else:
+            return cls(context)
+
+    @property
+    def connection(self) -> Optional["BaseConnection[Any]"]:
+        return self._conn
+
+    @property
+    def encoding(self) -> str:
+        if not self._encoding:
+            conn = self.connection
+            self._encoding = pgconn_encoding(conn.pgconn) if conn else "utf-8"
+        return self._encoding
+
+    @property
+    def adapters(self) -> "AdaptersMap":
+        return self._adapters
+
+    @property
+    def pgresult(self) -> Optional["PGresult"]:
+        return self._pgresult
+
+    def set_pgresult(
+        self,
+        result: Optional["PGresult"],
+        *,
+        set_loaders: bool = True,
+        format: Optional[pq.Format] = None,
+    ) -> None:
+        self._pgresult = result
+
+        if not result:
+            self._nfields = self._ntuples = 0
+            if set_loaders:
+                self._row_loaders = []
+            return
+
+        self._ntuples = result.ntuples
+        nf = self._nfields = result.nfields
+
+        if not set_loaders:
+            return
+
+        if not nf:
+            self._row_loaders = []
+            return
+
+        fmt: pq.Format
+        fmt = result.fformat(0) if format is None else format  # type: ignore
+        self._row_loaders = [
+            self.get_loader(result.ftype(i), fmt).load for i in range(nf)
+        ]
+
+    def set_dumper_types(self, types: Sequence[int], format: pq.Format) -> None:
+        self._row_dumpers = [self.get_dumper_by_oid(oid, format) for oid in types]
+        self.types = tuple(types)
+        self.formats = [format] * len(types)
+
+    def set_loader_types(self, types: Sequence[int], format: pq.Format) -> None:
+        self._row_loaders = [self.get_loader(oid, format).load for oid in types]
+
+    def dump_sequence(
+        self, params: Sequence[Any], formats: Sequence[PyFormat]
+    ) -> Sequence[Optional[Buffer]]:
+        nparams = len(params)
+        out: List[Optional[Buffer]] = [None] * nparams
+
+        # If we have dumpers, it means set_dumper_types had been called, in
+        # which case self.types and self.formats are set to sequences of the
+        # right size.
+        if self._row_dumpers:
+            for i in range(nparams):
+                param = params[i]
+                if param is not None:
+                    out[i] = self._row_dumpers[i].dump(param)
+            return out
+
+        types = [self._get_none_oid()] * nparams
+        pqformats = [TEXT] * nparams
+
+        for i in range(nparams):
+            param = params[i]
+            if param is None:
+                continue
+            dumper = self.get_dumper(param, formats[i])
+            out[i] = dumper.dump(param)
+            types[i] = dumper.oid
+            pqformats[i] = dumper.format
+
+        self.types = tuple(types)
+        self.formats = pqformats
+
+        return out
+
+    def as_literal(self, obj: Any) -> bytes:
+        dumper = self.get_dumper(obj, PY_TEXT)
+        rv = dumper.quote(obj)
+        # If the result is quoted, and the oid not unknown or text,
+        # add an explicit type cast.
+        # Check the last char because the first one might be 'E'.
+        oid = dumper.oid
+        if oid and rv and rv[-1] == b"'"[0] and oid != TEXT_OID:
+            try:
+                type_sql = self._oid_types[oid]
+            except KeyError:
+                ti = self.adapters.types.get(oid)
+                if ti:
+                    if oid < 8192:
+                        # builtin: prefer "timestamptz" to "timestamp with time zone"
+                        type_sql = ti.name.encode(self.encoding)
+                    else:
+                        type_sql = ti.regtype.encode(self.encoding)
+                    if oid == ti.array_oid:
+                        type_sql += b"[]"
+                else:
+                    type_sql = b""
+                self._oid_types[oid] = type_sql
+
+            if type_sql:
+                rv = b"%s::%s" % (rv, type_sql)
+
+        if not isinstance(rv, bytes):
+            rv = bytes(rv)
+        return rv
+
+    def get_dumper(self, obj: Any, format: PyFormat) -> "Dumper":
+        """
+        Return a Dumper instance to dump `!obj`.
+        """
+        # Normally, the type of the object dictates how to dump it
+        key = type(obj)
+
+        # Reuse an existing Dumper class for objects of the same type
+        cache = self._dumpers[format]
+        try:
+            dumper = cache[key]
+        except KeyError:
+            # If it's the first time we see this type, look for a dumper
+            # configured for it.
+            try:
+                dcls = self.adapters.get_dumper(key, format)
+            except e.ProgrammingError as ex:
+                raise ex from None
+            else:
+                cache[key] = dumper = dcls(key, self)
+
+        # Check if the dumper requires an upgrade to handle this specific value
+        key1 = dumper.get_key(obj, format)
+        if key1 is key:
+            return dumper
+
+        # If it does, ask the dumper to create its own upgraded version
+        try:
+            return cache[key1]
+        except KeyError:
+            dumper = cache[key1] = dumper.upgrade(obj, format)
+            return dumper
+
+    def _get_none_oid(self) -> int:
+        try:
+            return self._none_oid
+        except AttributeError:
+            pass
+
+        try:
+            rv = self._none_oid = self._adapters.get_dumper(NoneType, PY_TEXT).oid
+        except KeyError:
+            raise e.InterfaceError("None dumper not found")
+
+        return rv
+
+    def get_dumper_by_oid(self, oid: int, format: pq.Format) -> "Dumper":
+        """
+        Return a Dumper to dump an object to the type with given oid.
+        """
+        if not self._oid_dumpers:
+            self._oid_dumpers = ({}, {})
+
+        # Reuse an existing Dumper class for objects of the same type
+        cache = self._oid_dumpers[format]
+        try:
+            return cache[oid]
+        except KeyError:
+            # If it's the first time we see this type, look for a dumper
+            # configured for it.
+            dcls = self.adapters.get_dumper_by_oid(oid, format)
+            cache[oid] = dumper = dcls(NoneType, self)
+
+        return dumper
+
+    def load_rows(self, row0: int, row1: int, make_row: RowMaker[Row]) -> List[Row]:
+        res = self._pgresult
+        if not res:
+            raise e.InterfaceError("result not set")
+
+        if not (0 <= row0 <= self._ntuples and 0 <= row1 <= self._ntuples):
+            raise e.InterfaceError(
+                f"rows must be included between 0 and {self._ntuples}"
+            )
+
+        records = []
+        for row in range(row0, row1):
+            record: List[Any] = [None] * self._nfields
+            for col in range(self._nfields):
+                val = res.get_value(row, col)
+                if val is not None:
+                    record[col] = self._row_loaders[col](val)
+            records.append(make_row(record))
+
+        return records
+
+    def load_row(self, row: int, make_row: RowMaker[Row]) -> Optional[Row]:
+        res = self._pgresult
+        if not res:
+            return None
+
+        if not 0 <= row < self._ntuples:
+            return None
+
+        record: List[Any] = [None] * self._nfields
+        for col in range(self._nfields):
+            val = res.get_value(row, col)
+            if val is not None:
+                record[col] = self._row_loaders[col](val)
+
+        return make_row(record)
+
+    def load_sequence(self, record: Sequence[Optional[Buffer]]) -> Tuple[Any, ...]:
+        if len(self._row_loaders) != len(record):
+            raise e.ProgrammingError(
+                f"cannot load sequence of {len(record)} items:"
+                f" {len(self._row_loaders)} loaders registered"
+            )
+
+        return tuple(
+            (self._row_loaders[i](val) if val is not None else None)
+            for i, val in enumerate(record)
+        )
+
+    def get_loader(self, oid: int, format: pq.Format) -> "Loader":
+        try:
+            return self._loaders[format][oid]
+        except KeyError:
+            pass
+
+        loader_cls = self._adapters.get_loader(oid, format)
+        if not loader_cls:
+            loader_cls = self._adapters.get_loader(INVALID_OID, format)
+            if not loader_cls:
+                raise e.InterfaceError("unknown oid loader not found")
+        loader = self._loaders[format][oid] = loader_cls(oid, self)
+        return loader

pgsql/pgAdmin 4/python/Lib/site-packages/psycopg/_typeinfo.py

@@ -0,0 +1,500 @@
+"""
+Information about PostgreSQL types
+
+These types allow to read information from the system catalog and provide
+information to the adapters if needed.
+"""
+
+# Copyright (C) 2020 The Psycopg Team
+from enum import Enum
+from typing import Any, Dict, Iterator, Optional, overload
+from typing import Sequence, Tuple, Type, TypeVar, Union, TYPE_CHECKING
+from typing_extensions import TypeAlias
+
+from . import errors as e
+from .abc import AdaptContext, Query
+from .rows import dict_row
+from ._encodings import conn_encoding
+
+if TYPE_CHECKING:
+    from .connection import BaseConnection, Connection
+    from .connection_async import AsyncConnection
+    from .sql import Identifier, SQL
+
+T = TypeVar("T", bound="TypeInfo")
+RegistryKey: TypeAlias = Union[str, int, Tuple[type, int]]
+
+
+class TypeInfo:
+    """
+    Hold information about a PostgreSQL base type.
+    """
+
+    __module__ = "psycopg.types"
+
+    def __init__(
+        self,
+        name: str,
+        oid: int,
+        array_oid: int,
+        *,
+        regtype: str = "",
+        delimiter: str = ",",
+    ):
+        self.name = name
+        self.oid = oid
+        self.array_oid = array_oid
+        self.regtype = regtype or name
+        self.delimiter = delimiter
+
+    def __repr__(self) -> str:
+        return (
+            f"<{self.__class__.__qualname__}:"
+            f" {self.name} (oid: {self.oid}, array oid: {self.array_oid})>"
+        )
+
+    @overload
+    @classmethod
+    def fetch(
+        cls: Type[T], conn: "Connection[Any]", name: Union[str, "Identifier"]
+    ) -> Optional[T]:
+        ...
+
+    @overload
+    @classmethod
+    async def fetch(
+        cls: Type[T], conn: "AsyncConnection[Any]", name: Union[str, "Identifier"]
+    ) -> Optional[T]:
+        ...
+
+    @classmethod
+    def fetch(
+        cls: Type[T], conn: "BaseConnection[Any]", name: Union[str, "Identifier"]
+    ) -> Any:
+        """Query a system catalog to read information about a type."""
+        from .sql import Composable
+        from .connection import Connection
+        from .connection_async import AsyncConnection
+
+        if isinstance(name, Composable):
+            name = name.as_string(conn)
+
+        if isinstance(conn, Connection):
+            return cls._fetch(conn, name)
+        elif isinstance(conn, AsyncConnection):
+            return cls._fetch_async(conn, name)
+        else:
+            raise TypeError(
+                f"expected Connection or AsyncConnection, got {type(conn).__name__}"
+            )
+
+    @classmethod
+    def _fetch(cls: Type[T], conn: "Connection[Any]", name: str) -> Optional[T]:
+        # This might result in a nested transaction. What we want is to leave
+        # the function with the connection in the state we found (either idle
+        # or intrans)
+        try:
+            with conn.transaction():
+                if conn_encoding(conn) == "ascii":
+                    conn.execute("set local client_encoding to utf8")
+                with conn.cursor(row_factory=dict_row) as cur:
+                    cur.execute(cls._get_info_query(conn), {"name": name})
+                    recs = cur.fetchall()
+        except e.UndefinedObject:
+            return None
+
+        return cls._from_records(name, recs)
+
+    @classmethod
+    async def _fetch_async(
+        cls: Type[T], conn: "AsyncConnection[Any]", name: str
+    ) -> Optional[T]:
+        try:
+            async with conn.transaction():
+                if conn_encoding(conn) == "ascii":
+                    await conn.execute("set local client_encoding to utf8")
+                async with conn.cursor(row_factory=dict_row) as cur:
+                    await cur.execute(cls._get_info_query(conn), {"name": name})
+                    recs = await cur.fetchall()
+        except e.UndefinedObject:
+            return None
+
+        return cls._from_records(name, recs)
+
+    @classmethod
+    def _from_records(
+        cls: Type[T], name: str, recs: Sequence[Dict[str, Any]]
+    ) -> Optional[T]:
+        if len(recs) == 1:
+            return cls(**recs[0])
+        elif not recs:
+            return None
+        else:
+            raise e.ProgrammingError(f"found {len(recs)} different types named {name}")
+
+    def register(self, context: Optional[AdaptContext] = None) -> None:
+        """
+        Register the type information, globally or in the specified `!context`.
+        """
+        if context:
+            types = context.adapters.types
+        else:
+            from . import postgres
+
+            types = postgres.types
+
+        types.add(self)
+
+        if self.array_oid:
+            from .types.array import register_array
+
+            register_array(self, context)
+
+    @classmethod
+    def _get_info_query(cls, conn: "BaseConnection[Any]") -> Query:
+        from .sql import SQL
+
+        return SQL(
+            """\
+SELECT
+    typname AS name, oid, typarray AS array_oid,
+    oid::regtype::text AS regtype, typdelim AS delimiter
+FROM pg_type t
+WHERE t.oid = {regtype}
+ORDER BY t.oid
+"""
+        ).format(regtype=cls._to_regtype(conn))
+
+    @classmethod
+    def _has_to_regtype_function(cls, conn: "BaseConnection[Any]") -> bool:
+        # to_regtype() introduced in PostgreSQL 9.4 and CockroachDB 22.2
+        info = conn.info
+        if info.vendor == "PostgreSQL":
+            return info.server_version >= 90400
+        elif info.vendor == "CockroachDB":
+            return info.server_version >= 220200
+        else:
+            return False
+
+    @classmethod
+    def _to_regtype(cls, conn: "BaseConnection[Any]") -> "SQL":
+        # `to_regtype()` returns the type oid or NULL, unlike the :: operator,
+        # which returns the type or raises an exception, which requires
+        # a transaction rollback and leaves traces in the server logs.
+
+        from .sql import SQL
+
+        if cls._has_to_regtype_function(conn):
+            return SQL("to_regtype(%(name)s)")
+        else:
+            return SQL("%(name)s::regtype")
+
+    def _added(self, registry: "TypesRegistry") -> None:
+        """Method called by the `!registry` when the object is added there."""
+        pass
+
+
+class RangeInfo(TypeInfo):
+    """Manage information about a range type."""
+
+    __module__ = "psycopg.types.range"
+
+    def __init__(
+        self,
+        name: str,
+        oid: int,
+        array_oid: int,
+        *,
+        regtype: str = "",
+        subtype_oid: int,
+    ):
+        super().__init__(name, oid, array_oid, regtype=regtype)
+        self.subtype_oid = subtype_oid
+
+    @classmethod
+    def _get_info_query(cls, conn: "BaseConnection[Any]") -> Query:
+        from .sql import SQL
+
+        return SQL(
+            """\
+SELECT t.typname AS name, t.oid AS oid, t.typarray AS array_oid,
+    t.oid::regtype::text AS regtype,
+    r.rngsubtype AS subtype_oid
+FROM pg_type t
+JOIN pg_range r ON t.oid = r.rngtypid
+WHERE t.oid = {regtype}
+"""
+        ).format(regtype=cls._to_regtype(conn))
+
+    def _added(self, registry: "TypesRegistry") -> None:
+        # Map ranges subtypes to info
+        registry._registry[RangeInfo, self.subtype_oid] = self
+
+
+class MultirangeInfo(TypeInfo):
+    """Manage information about a multirange type."""
+
+    __module__ = "psycopg.types.multirange"
+
+    def __init__(
+        self,
+        name: str,
+        oid: int,
+        array_oid: int,
+        *,
+        regtype: str = "",
+        range_oid: int,
+        subtype_oid: int,
+    ):
+        super().__init__(name, oid, array_oid, regtype=regtype)
+        self.range_oid = range_oid
+        self.subtype_oid = subtype_oid
+
+    @classmethod
+    def _get_info_query(cls, conn: "BaseConnection[Any]") -> Query:
+        from .sql import SQL
+
+        if conn.info.server_version < 140000:
+            raise e.NotSupportedError(
+                "multirange types are only available from PostgreSQL 14"
+            )
+
+        return SQL(
+            """\
+SELECT t.typname AS name, t.oid AS oid, t.typarray AS array_oid,
+    t.oid::regtype::text AS regtype,
+    r.rngtypid AS range_oid, r.rngsubtype AS subtype_oid
+FROM pg_type t
+JOIN pg_range r ON t.oid = r.rngmultitypid
+WHERE t.oid = {regtype}
+"""
+        ).format(regtype=cls._to_regtype(conn))
+
+    def _added(self, registry: "TypesRegistry") -> None:
+        # Map multiranges ranges and subtypes to info
+        registry._registry[MultirangeInfo, self.range_oid] = self
+        registry._registry[MultirangeInfo, self.subtype_oid] = self
+
+
+class CompositeInfo(TypeInfo):
+    """Manage information about a composite type."""
+
+    __module__ = "psycopg.types.composite"
+
+    def __init__(
+        self,
+        name: str,
+        oid: int,
+        array_oid: int,
+        *,
+        regtype: str = "",
+        field_names: Sequence[str],
+        field_types: Sequence[int],
+    ):
+        super().__init__(name, oid, array_oid, regtype=regtype)
+        self.field_names = field_names
+        self.field_types = field_types
+        # Will be set by register() if the `factory` is a type
+        self.python_type: Optional[type] = None
+
+    @classmethod
+    def _get_info_query(cls, conn: "BaseConnection[Any]") -> Query:
+        from .sql import SQL
+
+        return SQL(
+            """\
+SELECT
+    t.typname AS name, t.oid AS oid, t.typarray AS array_oid,
+    t.oid::regtype::text AS regtype,
+    coalesce(a.fnames, '{{}}') AS field_names,
+    coalesce(a.ftypes, '{{}}') AS field_types
+FROM pg_type t
+LEFT JOIN (
+    SELECT
+        attrelid,
+        array_agg(attname) AS fnames,
+        array_agg(atttypid) AS ftypes
+    FROM (
+        SELECT a.attrelid, a.attname, a.atttypid
+        FROM pg_attribute a
+        JOIN pg_type t ON t.typrelid = a.attrelid
+        WHERE t.oid = {regtype}
+        AND a.attnum > 0
+        AND NOT a.attisdropped
+        ORDER BY a.attnum
+    ) x
+    GROUP BY attrelid
+) a ON a.attrelid = t.typrelid
+WHERE t.oid = {regtype}
+"""
+        ).format(regtype=cls._to_regtype(conn))
+
+
+class EnumInfo(TypeInfo):
+    """Manage information about an enum type."""
+
+    __module__ = "psycopg.types.enum"
+
+    def __init__(
+        self,
+        name: str,
+        oid: int,
+        array_oid: int,
+        labels: Sequence[str],
+    ):
+        super().__init__(name, oid, array_oid)
+        self.labels = labels
+        # Will be set by register_enum()
+        self.enum: Optional[Type[Enum]] = None
+
+    @classmethod
+    def _get_info_query(cls, conn: "BaseConnection[Any]") -> Query:
+        from .sql import SQL
+
+        return SQL(
+            """\
+SELECT name, oid, array_oid, array_agg(label) AS labels
+FROM (
+    SELECT
+        t.typname AS name, t.oid AS oid, t.typarray AS array_oid,
+        e.enumlabel AS label
+    FROM pg_type t
+    LEFT JOIN  pg_enum e
+    ON e.enumtypid = t.oid
+    WHERE t.oid = {regtype}
+    ORDER BY e.enumsortorder
+) x
+GROUP BY name, oid, array_oid
+"""
+        ).format(regtype=cls._to_regtype(conn))
+
+
+class TypesRegistry:
+    """
+    Container for the information about types in a database.
+    """
+
+    __module__ = "psycopg.types"
+
+    def __init__(self, template: Optional["TypesRegistry"] = None):
+        self._registry: Dict[RegistryKey, TypeInfo]
+
+        # Make a shallow copy: it will become a proper copy if the registry
+        # is edited.
+        if template:
+            self._registry = template._registry
+            self._own_state = False
+            template._own_state = False
+        else:
+            self.clear()
+
+    def clear(self) -> None:
+        self._registry = {}
+        self._own_state = True
+
+    def add(self, info: TypeInfo) -> None:
+        self._ensure_own_state()
+        if info.oid:
+            self._registry[info.oid] = info
+        if info.array_oid:
+            self._registry[info.array_oid] = info
+        self._registry[info.name] = info
+
+        if info.regtype and info.regtype not in self._registry:
+            self._registry[info.regtype] = info
+
+        # Allow info to customise further their relation with the registry
+        info._added(self)
+
+    def __iter__(self) -> Iterator[TypeInfo]:
+        seen = set()
+        for t in self._registry.values():
+            if id(t) not in seen:
+                seen.add(id(t))
+                yield t
+
+    @overload
+    def __getitem__(self, key: Union[str, int]) -> TypeInfo:
+        ...
+
+    @overload
+    def __getitem__(self, key: Tuple[Type[T], int]) -> T:
+        ...
+
+    def __getitem__(self, key: RegistryKey) -> TypeInfo:
+        """
+        Return info about a type, specified by name or oid
+
+        :param key: the name or oid of the type to look for.
+
+        Raise KeyError if not found.
+        """
+        if isinstance(key, str):
+            if key.endswith("[]"):
+                key = key[:-2]
+        elif not isinstance(key, (int, tuple)):
+            raise TypeError(f"the key must be an oid or a name, got {type(key)}")
+        try:
+            return self._registry[key]
+        except KeyError:
+            raise KeyError(f"couldn't find the type {key!r} in the types registry")
+
+    @overload
+    def get(self, key: Union[str, int]) -> Optional[TypeInfo]:
+        ...
+
+    @overload
+    def get(self, key: Tuple[Type[T], int]) -> Optional[T]:
+        ...
+
+    def get(self, key: RegistryKey) -> Optional[TypeInfo]:
+        """
+        Return info about a type, specified by name or oid
+
+        :param key: the name or oid of the type to look for.
+
+        Unlike `__getitem__`, return None if not found.
+        """
+        try:
+            return self[key]
+        except KeyError:
+            return None
+
+    def get_oid(self, name: str) -> int:
+        """
+        Return the oid of a PostgreSQL type by name.
+
+        :param key: the name of the type to look for.
+
+        Return the array oid if the type ends with "``[]``"
+
+        Raise KeyError if the name is unknown.
+        """
+        t = self[name]
+        if name.endswith("[]"):
+            return t.array_oid
+        else:
+            return t.oid
+
+    def get_by_subtype(self, cls: Type[T], subtype: Union[int, str]) -> Optional[T]:
+        """
+        Return info about a `TypeInfo` subclass by its element name or oid.
+
+        :param cls: the subtype of `!TypeInfo` to look for. Currently
+            supported are `~psycopg.types.range.RangeInfo` and
+            `~psycopg.types.multirange.MultirangeInfo`.
+        :param subtype: The name or OID of the subtype of the element to look for.
+        :return: The `!TypeInfo` object of class `!cls` whose subtype is
+            `!subtype`. `!None` if the element or its range are not found.
+        """
+        try:
+            info = self[subtype]
+        except KeyError:
+            return None
+        return self.get((cls, info.oid))
+
+    def _ensure_own_state(self) -> None:
+        # Time to write! so, copy.
+        if not self._own_state:
+            self._registry = self._registry.copy()
+            self._own_state = True

pgsql/pgAdmin 4/python/Lib/site-packages/psycopg/_tz.py

@@ -0,0 +1,44 @@
+"""
+Timezone utility functions.
+"""
+
+# Copyright (C) 2020 The Psycopg Team
+
+import logging
+from typing import Dict, Optional, Union
+from datetime import timezone, tzinfo
+
+from .pq.abc import PGconn
+from ._compat import ZoneInfo
+
+logger = logging.getLogger("psycopg")
+
+_timezones: Dict[Union[None, bytes], tzinfo] = {
+    None: timezone.utc,
+    b"UTC": timezone.utc,
+}
+
+
+def get_tzinfo(pgconn: Optional[PGconn]) -> tzinfo:
+    """Return the Python timezone info of the connection's timezone."""
+    tzname = pgconn.parameter_status(b"TimeZone") if pgconn else None
+    try:
+        return _timezones[tzname]
+    except KeyError:
+        sname = tzname.decode() if tzname else "UTC"
+        try:
+            zi: tzinfo = ZoneInfo(sname)
+        except (KeyError, OSError):
+            logger.warning("unknown PostgreSQL timezone: %r; will use UTC", sname)
+            zi = timezone.utc
+        except Exception as ex:
+            logger.warning(
+                "error handling PostgreSQL timezone: %r; will use UTC (%s - %s)",
+                sname,
+                type(ex).__name__,
+                ex,
+            )
+            zi = timezone.utc
+
+        _timezones[tzname] = zi
+        return zi

pgsql/pgAdmin 4/python/Lib/site-packages/psycopg/_wrappers.py

@@ -0,0 +1,137 @@
+"""
+Wrappers for numeric types.
+"""
+
+# Copyright (C) 2020 The Psycopg Team
+
+# Wrappers to force numbers to be cast as specific PostgreSQL types
+
+# These types are implemented here but exposed by `psycopg.types.numeric`.
+# They are defined here to avoid a circular import.
+_MODULE = "psycopg.types.numeric"
+
+
+class Int2(int):
+    """
+    Force dumping a Python `!int` as a PostgreSQL :sql:`smallint/int2`.
+    """
+
+    __module__ = _MODULE
+    __slots__ = ()
+
+    def __new__(cls, arg: int) -> "Int2":
+        return super().__new__(cls, arg)
+
+    def __str__(self) -> str:
+        return super().__repr__()
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}({super().__repr__()})"
+
+
+class Int4(int):
+    """
+    Force dumping a Python `!int` as a PostgreSQL :sql:`integer/int4`.
+    """
+
+    __module__ = _MODULE
+    __slots__ = ()
+
+    def __new__(cls, arg: int) -> "Int4":
+        return super().__new__(cls, arg)
+
+    def __str__(self) -> str:
+        return super().__repr__()
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}({super().__repr__()})"
+
+
+class Int8(int):
+    """
+    Force dumping a Python `!int` as a PostgreSQL :sql:`bigint/int8`.
+    """
+
+    __module__ = _MODULE
+    __slots__ = ()
+
+    def __new__(cls, arg: int) -> "Int8":
+        return super().__new__(cls, arg)
+
+    def __str__(self) -> str:
+        return super().__repr__()
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}({super().__repr__()})"
+
+
+class IntNumeric(int):
+    """
+    Force dumping a Python `!int` as a PostgreSQL :sql:`numeric/decimal`.
+    """
+
+    __module__ = _MODULE
+    __slots__ = ()
+
+    def __new__(cls, arg: int) -> "IntNumeric":
+        return super().__new__(cls, arg)
+
+    def __str__(self) -> str:
+        return super().__repr__()
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}({super().__repr__()})"
+
+
+class Float4(float):
+    """
+    Force dumping a Python `!float` as a PostgreSQL :sql:`float4/real`.
+    """
+
+    __module__ = _MODULE
+    __slots__ = ()
+
+    def __new__(cls, arg: float) -> "Float4":
+        return super().__new__(cls, arg)
+
+    def __str__(self) -> str:
+        return super().__repr__()
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}({super().__repr__()})"
+
+
+class Float8(float):
+    """
+    Force dumping a Python `!float` as a PostgreSQL :sql:`float8/double precision`.
+    """
+
+    __module__ = _MODULE
+    __slots__ = ()
+
+    def __new__(cls, arg: float) -> "Float8":
+        return super().__new__(cls, arg)
+
+    def __str__(self) -> str:
+        return super().__repr__()
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}({super().__repr__()})"
+
+
+class Oid(int):
+    """
+    Force dumping a Python `!int` as a PostgreSQL :sql:`oid`.
+    """
+
+    __module__ = _MODULE
+    __slots__ = ()
+
+    def __new__(cls, arg: int) -> "Oid":
+        return super().__new__(cls, arg)
+
+    def __str__(self) -> str:
+        return super().__repr__()
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}({super().__repr__()})"

pgsql/pgAdmin 4/python/Lib/site-packages/psycopg/version.py

@@ -0,0 +1,14 @@
+"""
+psycopg distribution version file.
+"""
+
+# Copyright (C) 2020 The Psycopg Team
+
+# Use a versioning scheme as defined in
+# https://www.python.org/dev/peps/pep-0440/
+
+# STOP AND READ! if you change:
+__version__ = "3.1.12"
+# also change:
+# - `docs/news.rst` to declare this as the current version or an unreleased one
+# - `psycopg_c/psycopg_c/version.py` to the same version.

pgsql/pgAdmin 4/python/Lib/site-packages/psycopg/waiting.py

@@ -0,0 +1,393 @@
+"""
+Code concerned with waiting in different contexts (blocking, async, etc).
+
+These functions are designed to consume the generators returned by the
+`generators` module function and to return their final value.
+
+"""
+
+# Copyright (C) 2020 The Psycopg Team
+
+
+import os
+import sys
+import select
+import selectors
+from typing import Optional
+from asyncio import get_event_loop, wait_for, Event, TimeoutError
+from selectors import DefaultSelector
+
+from . import errors as e
+from .abc import RV, PQGen, PQGenConn, WaitFunc
+from ._enums import Wait as Wait, Ready as Ready  # re-exported
+from ._cmodule import _psycopg
+
+WAIT_R = Wait.R
+WAIT_W = Wait.W
+WAIT_RW = Wait.RW
+READY_R = Ready.R
+READY_W = Ready.W
+READY_RW = Ready.RW
+
+
+def wait_selector(gen: PQGen[RV], fileno: int, timeout: Optional[float] = None) -> RV:
+    """
+    Wait for a generator using the best strategy available.
+
+    :param gen: a generator performing database operations and yielding
+        `Ready` values when it would block.
+    :param fileno: the file descriptor to wait on.
+    :param timeout: timeout (in seconds) to check for other interrupt, e.g.
+        to allow Ctrl-C.
+    :type timeout: float
+    :return: whatever `!gen` returns on completion.
+
+    Consume `!gen`, scheduling `fileno` for completion when it is reported to
+    block. Once ready again send the ready state back to `!gen`.
+    """
+    try:
+        s = next(gen)
+        with DefaultSelector() as sel:
+            while True:
+                sel.register(fileno, s)
+                rlist = None
+                while not rlist:
+                    rlist = sel.select(timeout=timeout)
+                sel.unregister(fileno)
+                # note: this line should require a cast, but mypy doesn't complain
+                ready: Ready = rlist[0][1]
+                assert s & ready
+                s = gen.send(ready)
+
+    except StopIteration as ex:
+        rv: RV = ex.args[0] if ex.args else None
+        return rv
+
+
+def wait_conn(gen: PQGenConn[RV], timeout: Optional[float] = None) -> RV:
+    """
+    Wait for a connection generator using the best strategy available.
+
+    :param gen: a generator performing database operations and yielding
+        (fd, `Ready`) pairs when it would block.
+    :param timeout: timeout (in seconds) to check for other interrupt, e.g.
+        to allow Ctrl-C. If zero or None, wait indefinitely.
+    :type timeout: float
+    :return: whatever `!gen` returns on completion.
+
+    Behave like in `wait()`, but take the fileno to wait from the generator
+    itself, which might change during processing.
+    """
+    try:
+        fileno, s = next(gen)
+        if not timeout:
+            timeout = None
+        with DefaultSelector() as sel:
+            while True:
+                sel.register(fileno, s)
+                rlist = sel.select(timeout=timeout)
+                sel.unregister(fileno)
+                if not rlist:
+                    raise e.ConnectionTimeout("connection timeout expired")
+                ready: Ready = rlist[0][1]  # type: ignore[assignment]
+                fileno, s = gen.send(ready)
+
+    except StopIteration as ex:
+        rv: RV = ex.args[0] if ex.args else None
+        return rv
+
+
+async def wait_async(
+    gen: PQGen[RV], fileno: int, timeout: Optional[float] = None
+) -> RV:
+    """
+    Coroutine waiting for a generator to complete.
+
+    :param gen: a generator performing database operations and yielding
+        `Ready` values when it would block.
+    :param fileno: the file descriptor to wait on.
+    :return: whatever `!gen` returns on completion.
+
+    Behave like in `wait()`, but exposing an `asyncio` interface.
+    """
+    # Use an event to block and restart after the fd state changes.
+    # Not sure this is the best implementation but it's a start.
+    ev = Event()
+    loop = get_event_loop()
+    ready: Ready
+    s: Wait
+
+    def wakeup(state: Ready) -> None:
+        nonlocal ready
+        ready |= state  # type: ignore[assignment]
+        ev.set()
+
+    try:
+        s = next(gen)
+        while True:
+            reader = s & WAIT_R
+            writer = s & WAIT_W
+            if not reader and not writer:
+                raise e.InternalError(f"bad poll status: {s}")
+            ev.clear()
+            ready = 0  # type: ignore[assignment]
+            if reader:
+                loop.add_reader(fileno, wakeup, READY_R)
+            if writer:
+                loop.add_writer(fileno, wakeup, READY_W)
+            try:
+                if timeout is None:
+                    await ev.wait()
+                else:
+                    try:
+                        await wait_for(ev.wait(), timeout)
+                    except TimeoutError:
+                        pass
+            finally:
+                if reader:
+                    loop.remove_reader(fileno)
+                if writer:
+                    loop.remove_writer(fileno)
+            s = gen.send(ready)
+
+    except StopIteration as ex:
+        rv: RV = ex.args[0] if ex.args else None
+        return rv
+
+
+async def wait_conn_async(gen: PQGenConn[RV], timeout: Optional[float] = None) -> RV:
+    """
+    Coroutine waiting for a connection generator to complete.
+
+    :param gen: a generator performing database operations and yielding
+        (fd, `Ready`) pairs when it would block.
+    :param timeout: timeout (in seconds) to check for other interrupt, e.g.
+        to allow Ctrl-C. If zero or None, wait indefinitely.
+    :return: whatever `!gen` returns on completion.
+
+    Behave like in `wait()`, but take the fileno to wait from the generator
+    itself, which might change during processing.
+    """
+    # Use an event to block and restart after the fd state changes.
+    # Not sure this is the best implementation but it's a start.
+    ev = Event()
+    loop = get_event_loop()
+    ready: Ready
+    s: Wait
+
+    def wakeup(state: Ready) -> None:
+        nonlocal ready
+        ready = state
+        ev.set()
+
+    try:
+        fileno, s = next(gen)
+        if not timeout:
+            timeout = None
+        while True:
+            reader = s & WAIT_R
+            writer = s & WAIT_W
+            if not reader and not writer:
+                raise e.InternalError(f"bad poll status: {s}")
+            ev.clear()
+            ready = 0  # type: ignore[assignment]
+            if reader:
+                loop.add_reader(fileno, wakeup, READY_R)
+            if writer:
+                loop.add_writer(fileno, wakeup, READY_W)
+            try:
+                await wait_for(ev.wait(), timeout)
+            finally:
+                if reader:
+                    loop.remove_reader(fileno)
+                if writer:
+                    loop.remove_writer(fileno)
+            fileno, s = gen.send(ready)
+
+    except TimeoutError:
+        raise e.ConnectionTimeout("connection timeout expired")
+
+    except StopIteration as ex:
+        rv: RV = ex.args[0] if ex.args else None
+        return rv
+
+
+# Specialised implementation of wait functions.
+
+
+def wait_select(gen: PQGen[RV], fileno: int, timeout: Optional[float] = None) -> RV:
+    """
+    Wait for a generator using select where supported.
+
+    BUG: on Linux, can't select on FD >= 1024. On Windows it's fine.
+    """
+    try:
+        s = next(gen)
+
+        empty = ()
+        fnlist = (fileno,)
+        while True:
+            rl, wl, xl = select.select(
+                fnlist if s & WAIT_R else empty,
+                fnlist if s & WAIT_W else empty,
+                fnlist,
+                timeout,
+            )
+            ready = 0
+            if rl:
+                ready = READY_R
+            if wl:
+                ready |= READY_W
+            if not ready:
+                continue
+            # assert s & ready
+            s = gen.send(ready)  # type: ignore
+
+    except StopIteration as ex:
+        rv: RV = ex.args[0] if ex.args else None
+        return rv
+
+
+if hasattr(selectors, "EpollSelector"):
+    _epoll_evmasks = {
+        WAIT_R: select.EPOLLONESHOT | select.EPOLLIN | select.EPOLLERR,
+        WAIT_W: select.EPOLLONESHOT | select.EPOLLOUT | select.EPOLLERR,
+        WAIT_RW: select.EPOLLONESHOT
+        | (select.EPOLLIN | select.EPOLLOUT | select.EPOLLERR),
+    }
+else:
+    _epoll_evmasks = {}
+
+
+def wait_epoll(gen: PQGen[RV], fileno: int, timeout: Optional[float] = None) -> RV:
+    """
+    Wait for a generator using epoll where supported.
+
+    Parameters are like for `wait()`. If it is detected that the best selector
+    strategy is `epoll` then this function will be used instead of `wait`.
+
+    See also: https://linux.die.net/man/2/epoll_ctl
+
+    BUG: if the connection FD is closed, `epoll.poll()` hangs. Same for
+    EpollSelector. For this reason, wait_poll() is currently preferable.
+    To reproduce the bug:
+
+        export PSYCOPG_WAIT_FUNC=wait_epoll
+        pytest tests/test_concurrency.py::test_concurrent_close
+    """
+    try:
+        s = next(gen)
+
+        if timeout is None or timeout < 0:
+            timeout = 0
+        else:
+            timeout = int(timeout * 1000.0)
+
+        with select.epoll() as epoll:
+            evmask = _epoll_evmasks[s]
+            epoll.register(fileno, evmask)
+            while True:
+                fileevs = None
+                while not fileevs:
+                    fileevs = epoll.poll(timeout)
+                ev = fileevs[0][1]
+                ready = 0
+                if ev & ~select.EPOLLOUT:
+                    ready = READY_R
+                if ev & ~select.EPOLLIN:
+                    ready |= READY_W
+                # assert s & ready
+                s = gen.send(ready)
+                evmask = _epoll_evmasks[s]
+                epoll.modify(fileno, evmask)
+
+    except StopIteration as ex:
+        rv: RV = ex.args[0] if ex.args else None
+        return rv
+
+
+if hasattr(selectors, "PollSelector"):
+    _poll_evmasks = {
+        WAIT_R: select.POLLIN,
+        WAIT_W: select.POLLOUT,
+        WAIT_RW: select.POLLIN | select.POLLOUT,
+    }
+else:
+    _poll_evmasks = {}
+
+
+def wait_poll(gen: PQGen[RV], fileno: int, timeout: Optional[float] = None) -> RV:
+    """
+    Wait for a generator using poll where supported.
+
+    Parameters are like for `wait()`.
+    """
+    try:
+        s = next(gen)
+
+        if timeout is None or timeout < 0:
+            timeout = 0
+        else:
+            timeout = int(timeout * 1000.0)
+
+        poll = select.poll()
+        evmask = _poll_evmasks[s]
+        poll.register(fileno, evmask)
+        while True:
+            fileevs = None
+            while not fileevs:
+                fileevs = poll.poll(timeout)
+            ev = fileevs[0][1]
+            ready = 0
+            if ev & ~select.POLLOUT:
+                ready = READY_R
+            if ev & ~select.POLLIN:
+                ready |= READY_W
+            # assert s & ready
+            s = gen.send(ready)
+            evmask = _poll_evmasks[s]
+            poll.modify(fileno, evmask)
+
+    except StopIteration as ex:
+        rv: RV = ex.args[0] if ex.args else None
+        return rv
+
+
+if _psycopg:
+    wait_c = _psycopg.wait_c
+
+
+# Choose the best wait strategy for the platform.
+#
+# the selectors objects have a generic interface but come with some overhead,
+# so we also offer more finely tuned implementations.
+
+wait: WaitFunc
+
+# Allow the user to choose a specific function for testing
+if "PSYCOPG_WAIT_FUNC" in os.environ:
+    fname = os.environ["PSYCOPG_WAIT_FUNC"]
+    if not fname.startswith("wait_") or fname not in globals():
+        raise ImportError(
+            "PSYCOPG_WAIT_FUNC should be the name of an available wait function;"
+            f" got {fname!r}"
+        )
+    wait = globals()[fname]
+
+# On Windows, for the moment, avoid using wait_c, because it was reported to
+# use excessive CPU (see #645).
+# TODO: investigate why.
+elif _psycopg and sys.platform != "win32":
+    wait = wait_c
+
+elif selectors.DefaultSelector is getattr(selectors, "SelectSelector", None):
+    # On Windows, SelectSelector should be the default.
+    wait = wait_select
+
+elif hasattr(selectors, "PollSelector"):
+    # On linux, EpollSelector is the default. However, it hangs if the fd is
+    # closed while polling.
+    wait = wait_poll
+
+else:
+    wait = wait_selector

pgsql/pgAdmin 4/python/Lib/site-packages/psycopg_c-3.1.12.dist-info/INSTALLER

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

pgsql/pgAdmin 4/python/Lib/site-packages/psycopg_c-3.1.12.dist-info/LICENSE.txt

@@ -0,0 +1,165 @@
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.