Add files using upload-large-folder tool

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

@@ -0,0 +1,37 @@
+#-------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+#--------------------------------------------------------------------------
+from ._version import VERSION as _VERSION
+
+__author__ = 'Microsoft Corp. <azpysdkhelp@microsoft.com>'
+__version__ = _VERSION
+
+
+class AzureException(Exception):
+    pass
+
+
+class AzureHttpError(AzureException):
+    def __init__(self, message, status_code):
+        super(AzureHttpError, self).__init__(message)
+        self.status_code = status_code
+
+    def __new__(cls, message, status_code, *args, **kwargs):
+        if cls is AzureHttpError:
+            if status_code == 404:
+                cls = AzureMissingResourceHttpError
+            elif status_code == 409:
+                cls = AzureConflictHttpError
+        return AzureException.__new__(cls, message, status_code, *args, **kwargs)
+
+
+class AzureConflictHttpError(AzureHttpError):
+    def __init__(self, message, status_code):
+        super(AzureConflictHttpError, self).__init__(message, status_code)
+
+
+class AzureMissingResourceHttpError(AzureHttpError):
+    def __init__(self, message, status_code):
+        super(AzureMissingResourceHttpError, self).__init__(message, status_code)

pgsql/pgAdmin 4/python/Lib/site-packages/azure/common/_version.py

@@ -0,0 +1,7 @@
+#-------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+#--------------------------------------------------------------------------
+
+VERSION = "1.1.28"

pgsql/pgAdmin 4/python/Lib/site-packages/azure/common/client_factory.py

@@ -0,0 +1,295 @@
+#-------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+#--------------------------------------------------------------------------
+
+import io
+import json
+import os
+import re
+import sys
+import warnings
+try:
+    from inspect import getfullargspec as get_arg_spec
+except ImportError:
+    from inspect import getargspec as get_arg_spec
+
+from .credentials import get_azure_cli_credentials
+from .cloud import get_cli_active_cloud
+
+
+def _instantiate_client(client_class, **kwargs):
+    """Instantiate a client from kwargs, filtering kwargs to match client signature.
+    """
+    args = get_arg_spec(client_class.__init__).args
+    for key in ['subscription_id', 'tenant_id', 'base_url', 'credential', 'credentials']:
+        if key not in kwargs:
+            continue
+        if key not in args:
+            del kwargs[key]
+        elif sys.version_info < (3, 0) and isinstance(kwargs[key], unicode):
+            kwargs[key] = kwargs[key].encode('utf-8')
+    return client_class(**kwargs)
+
+
+def _client_resource(client_class, cloud):
+    """Return a tuple of the resource (used to get the right access token), and the base URL for the client.
+    Either or both can be None to signify that the default value should be used.
+    """
+    if client_class.__name__ == 'GraphRbacManagementClient':
+        return cloud.endpoints.active_directory_graph_resource_id, cloud.endpoints.active_directory_graph_resource_id
+    if client_class.__name__ == 'ApplicationInsightsDataClient':
+        return cloud.endpoints.app_insights_resource_id, cloud.endpoints.app_insights_resource_id+"/v1"
+    if client_class.__name__ == 'KeyVaultClient':
+        vault_host = cloud.suffixes.keyvault_dns[1:]
+        vault_url = 'https://{}'.format(vault_host)
+        return vault_url, None
+    return None, None
+
+
+def get_client_from_cli_profile(client_class, **kwargs):
+    """Return a SDK client initialized with current CLI credentials, CLI default subscription and CLI default cloud.
+
+    *Disclaimer*: This is NOT the recommended approach to authenticate with CLI login, this method is deprecated.
+    use https://pypi.org/project/azure-identity/ and AzureCliCredential instead. See example code below:
+
+    .. code:: python
+
+        from azure.identity import AzureCliCredential
+        from azure.mgmt.compute import ComputeManagementClient
+        client = ComputeManagementClient(AzureCliCredential(), subscription_id)
+
+    This method is not working for azure-cli-core>=2.21.0 (released in March 2021).
+
+    For compatible azure-cli-core (< 2.20.0), This method will automatically fill the following client parameters:
+    - credentials/credential
+    - subscription_id
+    - base_url
+
+    Parameters provided in kwargs will override CLI parameters and be passed directly to the client.
+
+    :Example:
+
+    .. code:: python
+
+        from azure.common.client_factory import get_client_from_cli_profile
+        from azure.mgmt.compute import ComputeManagementClient
+        client = get_client_from_cli_profile(ComputeManagementClient)
+
+    .. versionadded:: 1.1.6
+
+    .. deprecated:: 1.1.28
+
+    .. seealso:: https://aka.ms/azsdk/python/identity/migration
+
+    :param client_class: A SDK client class
+    :return: An instantiated client
+    :raises: ImportError if azure-cli-core package is not available
+    """
+    warnings.warn(
+        "get_client_from_cli_profile is deprecated, please use azure-identity and AzureCliCredential instead. "+
+        "See also https://aka.ms/azsdk/python/identity/migration.",
+        DeprecationWarning
+    )
+
+    cloud = get_cli_active_cloud()
+    parameters = {}
+    no_credential_sentinel = object()
+    kwarg_cred = kwargs.pop('credentials', no_credential_sentinel)
+    if kwarg_cred is no_credential_sentinel:
+        kwarg_cred = kwargs.pop('credential', no_credential_sentinel)
+
+    if kwarg_cred is no_credential_sentinel or 'subscription_id' not in kwargs:
+        resource, _ = _client_resource(client_class, cloud)
+        credentials, subscription_id, tenant_id = get_azure_cli_credentials(
+            resource=resource,
+            with_tenant=True,
+        )
+        # Provide both syntax of cred, we have an "inspect" filter later
+        credential_to_pass = credentials if kwarg_cred is no_credential_sentinel else kwarg_cred
+        parameters.update({
+            'credentials': credential_to_pass,
+            'credential': credential_to_pass,
+            'subscription_id': kwargs.get('subscription_id', subscription_id)
+        })
+
+    args = get_arg_spec(client_class.__init__).args
+    if 'adla_job_dns_suffix' in args and 'adla_job_dns_suffix' not in kwargs:  # Datalake
+        # Let it raise here with AttributeError at worst, this would mean this cloud does not define
+        # ADL endpoint and no manual suffix was given
+        parameters['adla_job_dns_suffix'] = cloud.suffixes.azure_datalake_analytics_catalog_and_job_endpoint
+    elif 'base_url' in args and 'base_url' not in kwargs:
+        _, base_url = _client_resource(client_class, cloud)
+        if base_url:
+            parameters['base_url'] = base_url
+        else:
+            parameters['base_url'] = cloud.endpoints.resource_manager
+    if 'tenant_id' in args and 'tenant_id' not in kwargs:
+        parameters['tenant_id'] = tenant_id
+    parameters.update(kwargs)
+    return _instantiate_client(client_class, **parameters)
+
+
+def _is_autorest_v3(client_class):
+    """Is this client a autorestv3/track2 one?.
+    Could be refined later if necessary.
+    """
+    args = get_arg_spec(client_class.__init__).args
+    return "credential" in args
+
+
+def get_client_from_json_dict(client_class, config_dict, **kwargs):
+    """Return a SDK client initialized with a JSON auth dict.
+
+    *Disclaimer*: This is NOT the recommended approach, see https://aka.ms/azsdk/python/identity/migration for guidance.
+
+    This method will fill automatically the following client parameters:
+    - credentials
+    - subscription_id
+    - base_url
+    - tenant_id
+
+    Parameters provided in kwargs will override parameters and be passed directly to the client.
+
+    :Example:
+
+    .. code:: python
+
+        from azure.common.client_factory import get_client_from_auth_file
+        from azure.mgmt.compute import ComputeManagementClient
+        config_dict = {
+            "clientId": "ad735158-65ca-11e7-ba4d-ecb1d756380e",
+            "clientSecret": "b70bb224-65ca-11e7-810c-ecb1d756380e",
+            "subscriptionId": "bfc42d3a-65ca-11e7-95cf-ecb1d756380e",
+            "tenantId": "c81da1d8-65ca-11e7-b1d1-ecb1d756380e",
+            "activeDirectoryEndpointUrl": "https://login.microsoftonline.com",
+            "resourceManagerEndpointUrl": "https://management.azure.com/",
+            "activeDirectoryGraphResourceId": "https://graph.windows.net/",
+            "sqlManagementEndpointUrl": "https://management.core.windows.net:8443/",
+            "galleryEndpointUrl": "https://gallery.azure.com/",
+            "managementEndpointUrl": "https://management.core.windows.net/"
+        }
+        client = get_client_from_json_dict(ComputeManagementClient, config_dict)
+
+    .. versionadded:: 1.1.7
+
+    .. deprecated:: 1.1.28
+
+    .. seealso:: https://aka.ms/azsdk/python/identity/migration
+
+    :param client_class: A SDK client class
+    :param dict config_dict: A config dict.
+    :return: An instantiated client
+    """
+    if _is_autorest_v3(client_class):
+        raise ValueError(
+            "Auth file or JSON dict are deprecated auth approach and are not supported anymore. "
+            "See also https://aka.ms/azsdk/python/identity/migration."
+        )
+
+    import adal
+    from msrestazure.azure_active_directory import AdalAuthentication
+
+    is_graphrbac = client_class.__name__ == 'GraphRbacManagementClient'
+    is_keyvault = client_class.__name__ == 'KeyVaultClient'
+    parameters = {
+        'subscription_id': config_dict.get('subscriptionId'),
+        'base_url': config_dict.get('resourceManagerEndpointUrl'),
+        'tenant_id': config_dict.get('tenantId')  # GraphRbac
+    }
+    if is_graphrbac:
+        parameters['base_url'] = config_dict['activeDirectoryGraphResourceId']
+
+    if 'credentials' not in kwargs:
+        # Get the right resource for Credentials
+        if is_graphrbac:
+            resource = config_dict['activeDirectoryGraphResourceId']
+        elif is_keyvault:
+            resource = "https://vault.azure.net"
+        else:
+            if "activeDirectoryResourceId" not in config_dict and 'resourceManagerEndpointUrl' not in config_dict:
+                raise ValueError("Need activeDirectoryResourceId or resourceManagerEndpointUrl key")
+            resource = config_dict.get('activeDirectoryResourceId', config_dict['resourceManagerEndpointUrl'])
+
+        authority_url = config_dict['activeDirectoryEndpointUrl']
+        is_adfs = bool(re.match('.+(/adfs|/adfs/)$', authority_url, re.I))
+        if is_adfs:
+            authority_url = authority_url.rstrip('/')  # workaround: ADAL is known to reject auth urls with trailing /
+        else:
+            authority_url = authority_url + '/' + config_dict['tenantId']
+
+        context = adal.AuthenticationContext(
+            authority_url,
+            api_version=None,
+            validate_authority=not is_adfs
+        )
+        parameters['credentials'] = AdalAuthentication(
+            context.acquire_token_with_client_credentials,
+            resource,
+            config_dict['clientId'],
+            config_dict['clientSecret']
+        )
+
+    parameters.update(kwargs)
+    return _instantiate_client(client_class, **parameters)
+
+def get_client_from_auth_file(client_class, auth_path=None, **kwargs):
+    """Return a SDK client initialized with auth file.
+
+    *Disclaimer*: This is NOT the recommended approach, see https://aka.ms/azsdk/python/identity/migration for guidance.
+
+    You can specific the file path directly, or fill the environment variable AZURE_AUTH_LOCATION.
+    File must be UTF-8.
+
+    This method will fill automatically the following client parameters:
+    - credentials
+    - subscription_id
+    - base_url
+
+    Parameters provided in kwargs will override parameters and be passed directly to the client.
+
+    :Example:
+
+    .. code:: python
+
+        from azure.common.client_factory import get_client_from_auth_file
+        from azure.mgmt.compute import ComputeManagementClient
+        client = get_client_from_auth_file(ComputeManagementClient)
+
+    Example of file:
+
+    .. code:: json
+
+        {
+            "clientId": "ad735158-65ca-11e7-ba4d-ecb1d756380e",
+            "clientSecret": "b70bb224-65ca-11e7-810c-ecb1d756380e",
+            "subscriptionId": "bfc42d3a-65ca-11e7-95cf-ecb1d756380e",
+            "tenantId": "c81da1d8-65ca-11e7-b1d1-ecb1d756380e",
+            "activeDirectoryEndpointUrl": "https://login.microsoftonline.com",
+            "resourceManagerEndpointUrl": "https://management.azure.com/",
+            "activeDirectoryGraphResourceId": "https://graph.windows.net/",
+            "sqlManagementEndpointUrl": "https://management.core.windows.net:8443/",
+            "galleryEndpointUrl": "https://gallery.azure.com/",
+            "managementEndpointUrl": "https://management.core.windows.net/"
+        }
+
+    .. versionadded:: 1.1.7
+
+    .. deprecated:: 1.1.28
+
+    .. seealso:: https://aka.ms/azsdk/python/identity/migration
+
+    :param client_class: A SDK client class
+    :param str auth_path: Path to the file.
+    :return: An instantiated client
+    :raises: KeyError if AZURE_AUTH_LOCATION is not an environment variable and no path is provided
+    :raises: FileNotFoundError if provided file path does not exists
+    :raises: json.JSONDecodeError if provided file is not JSON valid
+    :raises: UnicodeDecodeError if file is not UTF8 compliant
+    """
+    auth_path = auth_path or os.environ['AZURE_AUTH_LOCATION']
+
+    with io.open(auth_path, 'r', encoding='utf-8-sig') as auth_fd:
+        config_dict = json.load(auth_fd)
+    return get_client_from_json_dict(client_class, config_dict, **kwargs)

pgsql/pgAdmin 4/python/Lib/site-packages/azure/common/cloud.py

@@ -0,0 +1,30 @@
+#-------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+#--------------------------------------------------------------------------
+
+def get_cli_active_cloud():
+    """Return a CLI active cloud.
+
+    *Disclaimer*: This method is not working for azure-cli-core>=2.21.0 (released in March 2021).
+
+    .. versionadded:: 1.1.6
+
+    .. deprecated:: 1.1.28
+
+    :return: A CLI Cloud
+    :rtype: azure.cli.core.cloud.Cloud
+    :raises: ImportError if azure-cli-core package is not available
+    """
+
+    try:
+        from azure.cli.core.cloud import get_active_cloud
+    except ImportError:
+        raise ImportError(
+            "The public API of azure-cli-core has been deprecated starting 2.21.0, " +
+            "and this method no longer can return a cloud instance. " +
+            "If you want to use this method, you need to install 'azure-cli-core<2.21.0'. " +
+            "You may corrupt data if you use current CLI and old azure-cli-core."
+        )
+    return get_active_cloud()

pgsql/pgAdmin 4/python/Lib/site-packages/azure/common/credentials.py

@@ -0,0 +1,171 @@
+#-------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+#--------------------------------------------------------------------------
+
+import os.path
+import time
+import warnings
+try:
+    from azure.core.credentials import AccessToken as _AccessToken
+except ImportError:
+    _AccessToken = None
+
+
+def get_cli_profile():
+    """Return a CLI profile class.
+
+    *Disclaimer*: This method is not working for azure-cli-core>=2.21.0 (released in March 2021).
+
+    .. versionadded:: 1.1.6
+
+    .. deprecated:: 1.1.28
+
+    :return: A CLI Profile
+    :rtype: azure.cli.core._profile.Profile
+    :raises: ImportError if azure-cli-core package is not available
+    """
+
+    try:
+        from azure.cli.core._profile import Profile
+        from azure.cli.core._session import ACCOUNT
+        from azure.cli.core._environment import get_config_dir
+    except ImportError:
+        raise ImportError(
+            "The public API of azure-cli-core has been deprecated starting 2.21.0, " +
+            "and this method can no longer return a profile. " +
+            "If you need to load CLI profile using this method, you need to install 'azure-cli-core<2.21.0'. " +
+            "You may corrupt data if you use current CLI and old azure-cli-core."
+        )
+
+    azure_folder = get_config_dir()
+    ACCOUNT.load(os.path.join(azure_folder, 'azureProfile.json'))
+    return Profile(storage=ACCOUNT)
+
+
+class _CliCredentials(object):
+    """A wrapper of CLI credentials type that implements the azure-core credential protocol AND
+    the msrestazure protocol.
+
+    :param cli_profile: The CLI profile instance
+    :param resource: The resource to use in "msrestazure" mode (ignored otherwise)
+    """
+
+    _DEFAULT_PREFIX = "/.default"
+
+    def __init__(self, cli_profile, resource):
+        self._profile = cli_profile
+        self._resource = resource
+        self._cred_dict = {}
+
+    def _get_cred(self, resource):
+        if not resource in self._cred_dict:
+            credentials, _, _ = self._profile.get_login_credentials(resource=resource)
+            self._cred_dict[resource] = credentials
+        return self._cred_dict[resource]
+
+    def get_token(self, *scopes, **kwargs):  # pylint:disable=unused-argument
+        if _AccessToken is None:  # import failed
+            raise ImportError("You need to install 'azure-core' to use CLI credentials in this context")
+
+        if len(scopes) != 1:
+            raise ValueError("Multiple scopes are not supported: {}".format(scopes))
+        scope = scopes[0]
+        if scope.endswith(self._DEFAULT_PREFIX):
+            resource = scope[:-len(self._DEFAULT_PREFIX)]
+        else:
+            resource = scope
+
+        credentials = self._get_cred(resource)
+        # _token_retriever() not accessible after azure-cli-core 2.21.0
+        _, token, fulltoken = credentials._token_retriever()  # pylint:disable=protected-access
+
+        return _AccessToken(token, int(fulltoken['expiresIn'] + time.time()))
+
+    def signed_session(self, session=None):
+        credentials = self._get_cred(self._resource)
+        return credentials.signed_session(session)
+
+
+def get_azure_cli_credentials(resource=None, with_tenant=False):
+    """Return Credentials and default SubscriptionID of current loaded profile of the CLI.
+
+    *Disclaimer*: This method is not working for azure-cli-core>=2.21.0 (released in March 2021).
+    It is now recommended to authenticate using https://pypi.org/project/azure-identity/ and AzureCliCredential.
+    See example code below:
+
+    .. code:: python
+
+        from azure.identity import AzureCliCredential
+        from azure.mgmt.compute import ComputeManagementClient
+        client = ComputeManagementClient(AzureCliCredential(), subscription_id)
+
+
+    For compatible azure-cli-core version (< 2.20.0), credentials will be the "az login" command:
+    https://docs.microsoft.com/cli/azure/authenticate-azure-cli
+
+    Default subscription ID is either the only one you have, or you can define it:
+    https://docs.microsoft.com/cli/azure/manage-azure-subscriptions-azure-cli
+
+    .. versionadded:: 1.1.6
+
+    .. deprecated:: 1.1.28
+
+    .. seealso:: https://aka.ms/azsdk/python/identity/migration
+
+    :param str resource: The alternative resource for credentials if not ARM (GraphRBac, etc.)
+    :param bool with_tenant: If True, return a three-tuple with last as tenant ID
+    :return: tuple of Credentials and SubscriptionID (and tenant ID if with_tenant)
+    :rtype: tuple
+    """
+    warnings.warn(
+        "get_client_from_cli_profile is deprecated, please use azure-identity and AzureCliCredential instead. " +
+        "https://aka.ms/azsdk/python/identity/migration.",
+        DeprecationWarning
+    )
+
+    azure_cli_core_check_failed = False
+    try:
+        import azure.cli.core
+        minor_version = int(azure.cli.core.__version__.split(".")[1])
+        if minor_version >= 21:
+            azure_cli_core_check_failed = True
+    except Exception:
+        azure_cli_core_check_failed = True
+
+    if azure_cli_core_check_failed:
+        raise NotImplementedError(
+            "The public API of azure-cli-core has been deprecated starting 2.21.0, " +
+            "and this method can no longer return a valid credential. " +
+            "If you need to still use this method, you need to install 'azure-cli-core<2.21.0'. " +
+            "You may corrupt data if you use current CLI and old azure-cli-core. " +
+            "See also: https://aka.ms/azsdk/python/identity/migration"
+        )
+
+    profile = get_cli_profile()
+    cred, subscription_id, tenant_id = profile.get_login_credentials(resource=resource)
+    cred = _CliCredentials(profile, resource)
+    if with_tenant:
+        return cred, subscription_id, tenant_id
+    else:
+        return cred, subscription_id
+
+
+try:
+    from msrest.authentication import (
+        BasicAuthentication,
+        BasicTokenAuthentication,
+        OAuthTokenAuthentication
+    )
+except ImportError:
+    raise ImportError("You need to install 'msrest' to use this feature")
+
+try:
+    from msrestazure.azure_active_directory import (
+        InteractiveCredentials,
+        ServicePrincipalCredentials,
+        UserPassCredentials
+    )
+except ImportError:
+    raise ImportError("You need to install 'msrestazure' to use this feature")

pgsql/pgAdmin 4/python/Lib/site-packages/azure/common/exceptions.py

@@ -0,0 +1,22 @@
+#-------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+#--------------------------------------------------------------------------
+try:
+    from msrest.exceptions import (
+        ClientException,
+        SerializationError,
+        DeserializationError,
+        TokenExpiredError,
+        ClientRequestError,
+        AuthenticationError,
+        HttpOperationError,
+    )
+except ImportError:
+    raise ImportError("You need to install 'msrest' to use this feature")
+
+try:
+    from msrestazure.azure_exceptions import CloudError
+except ImportError:
+    raise ImportError("You need to install 'msrestazure' to use this feature")

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

@@ -0,0 +1,41 @@
+# --------------------------------------------------------------------------
+#
+# Copyright (c) Microsoft Corporation. All rights reserved.
+#
+# The MIT License (MIT)
+#
+# 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.
+#
+# --------------------------------------------------------------------------
+
+from ._version import VERSION
+
+__version__ = VERSION
+
+from ._pipeline_client import PipelineClient
+from ._match_conditions import MatchConditions
+from ._enum_meta import CaseInsensitiveEnumMeta
+from ._pipeline_client_async import AsyncPipelineClient
+
+__all__ = [
+    "PipelineClient",
+    "MatchConditions",
+    "CaseInsensitiveEnumMeta",
+    "AsyncPipelineClient",
+]

pgsql/pgAdmin 4/python/Lib/site-packages/azure/core/_enum_meta.py

@@ -0,0 +1,66 @@
+# --------------------------------------------------------------------------
+#
+# Copyright (c) Microsoft Corporation. All rights reserved.
+#
+# The MIT License (MIT)
+#
+# 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.
+#
+# --------------------------------------------------------------------------
+from typing import Any
+from enum import EnumMeta, Enum
+
+
+class CaseInsensitiveEnumMeta(EnumMeta):
+    """Enum metaclass to allow for interoperability with case-insensitive strings.
+
+    Consuming this metaclass in an SDK should be done in the following manner:
+
+    .. code-block:: python
+
+        from enum import Enum
+        from azure.core import CaseInsensitiveEnumMeta
+
+        class MyCustomEnum(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+            FOO = 'foo'
+            BAR = 'bar'
+
+    """
+
+    def __getitem__(cls, name: str) -> Any:
+        # disabling pylint bc of pylint bug https://github.com/PyCQA/astroid/issues/713
+        return super(CaseInsensitiveEnumMeta, cls).__getitem__(name.upper())  # pylint: disable=no-value-for-parameter
+
+    def __getattr__(cls, name: str) -> Enum:
+        """Return the enum member matching `name`.
+
+        We use __getattr__ instead of descriptors or inserting into the enum
+        class' __dict__ in order to support `name` and `value` being both
+        properties for enum members (which live in the class' __dict__) and
+        enum members themselves.
+
+        :param str name: The name of the enum member to retrieve.
+        :rtype: ~azure.core.CaseInsensitiveEnumMeta
+        :return: The enum member matching `name`.
+        :raises AttributeError: If `name` is not a valid enum member.
+        """
+        try:
+            return cls._member_map_[name.upper()]
+        except KeyError as err:
+            raise AttributeError(name) from err

pgsql/pgAdmin 4/python/Lib/site-packages/azure/core/_match_conditions.py

@@ -0,0 +1,46 @@
+# --------------------------------------------------------------------------
+#
+# Copyright (c) Microsoft Corporation. All rights reserved.
+#
+# The MIT License (MIT)
+#
+# 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.
+#
+# --------------------------------------------------------------------------
+
+from enum import Enum
+
+
+class MatchConditions(Enum):
+    """An enum to describe match conditions."""
+
+    Unconditionally = 1
+    """Matches any condition"""
+
+    IfNotModified = 2
+    """If the target object is not modified. Usually it maps to etag=<specific etag>"""
+
+    IfModified = 3
+    """Only if the target object is modified. Usually it maps to etag!=<specific etag>"""
+
+    IfPresent = 4
+    """If the target object exists. Usually it maps to etag='*'"""
+
+    IfMissing = 5
+    """If the target object does not exist. Usually it maps to etag!='*'"""

pgsql/pgAdmin 4/python/Lib/site-packages/azure/core/_pipeline_client.py

@@ -0,0 +1,201 @@
+# --------------------------------------------------------------------------
+#
+# Copyright (c) Microsoft Corporation. All rights reserved.
+#
+# The MIT License (MIT)
+#
+# 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.
+#
+# --------------------------------------------------------------------------
+from __future__ import annotations
+import logging
+from collections.abc import Iterable
+from typing import TypeVar, Generic, Optional, Any
+from .configuration import Configuration
+from .pipeline import Pipeline
+from .pipeline.transport._base import PipelineClientBase
+from .pipeline.transport import HttpTransport
+from .pipeline.policies import (
+    ContentDecodePolicy,
+    DistributedTracingPolicy,
+    HttpLoggingPolicy,
+    RequestIdPolicy,
+    RetryPolicy,
+    SensitiveHeaderCleanupPolicy,
+)
+
+HTTPResponseType = TypeVar("HTTPResponseType")
+HTTPRequestType = TypeVar("HTTPRequestType")
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class PipelineClient(PipelineClientBase, Generic[HTTPRequestType, HTTPResponseType]):
+    """Service client core methods.
+
+    Builds a Pipeline client.
+
+    :param str base_url: URL for the request.
+    :keyword ~azure.core.configuration.Configuration config: If omitted, the standard configuration is used.
+    :keyword Pipeline pipeline: If omitted, a Pipeline object is created and returned.
+    :keyword list[HTTPPolicy] policies: If omitted, the standard policies of the configuration object is used.
+    :keyword per_call_policies: If specified, the policies will be added into the policy list before RetryPolicy
+    :paramtype per_call_policies: Union[HTTPPolicy, SansIOHTTPPolicy, list[HTTPPolicy], list[SansIOHTTPPolicy]]
+    :keyword per_retry_policies: If specified, the policies will be added into the policy list after RetryPolicy
+    :paramtype per_retry_policies: Union[HTTPPolicy, SansIOHTTPPolicy, list[HTTPPolicy], list[SansIOHTTPPolicy]]
+    :keyword HttpTransport transport: If omitted, RequestsTransport is used for synchronous transport.
+    :return: A pipeline object.
+    :rtype: ~azure.core.pipeline.Pipeline
+
+    .. admonition:: Example:
+
+        .. literalinclude:: ../samples/test_example_sync.py
+            :start-after: [START build_pipeline_client]
+            :end-before: [END build_pipeline_client]
+            :language: python
+            :dedent: 4
+            :caption: Builds the pipeline client.
+    """
+
+    def __init__(
+        self,
+        base_url: str,
+        *,
+        pipeline: Optional[Pipeline[HTTPRequestType, HTTPResponseType]] = None,
+        config: Optional[Configuration[HTTPRequestType, HTTPResponseType]] = None,
+        **kwargs: Any,
+    ):
+        super(PipelineClient, self).__init__(base_url)
+        self._config: Configuration[HTTPRequestType, HTTPResponseType] = config or Configuration(**kwargs)
+        self._base_url = base_url
+
+        self._pipeline = pipeline or self._build_pipeline(self._config, **kwargs)
+
+    def __enter__(self) -> PipelineClient[HTTPRequestType, HTTPResponseType]:
+        self._pipeline.__enter__()
+        return self
+
+    def __exit__(self, *exc_details: Any) -> None:
+        self._pipeline.__exit__(*exc_details)
+
+    def close(self) -> None:
+        self.__exit__()
+
+    def _build_pipeline(
+        self,
+        config: Configuration[HTTPRequestType, HTTPResponseType],
+        *,
+        transport: Optional[HttpTransport[HTTPRequestType, HTTPResponseType]] = None,
+        policies=None,
+        per_call_policies=None,
+        per_retry_policies=None,
+        **kwargs,
+    ) -> Pipeline[HTTPRequestType, HTTPResponseType]:
+        per_call_policies = per_call_policies or []
+        per_retry_policies = per_retry_policies or []
+
+        if policies is None:  # [] is a valid policy list
+            policies = [
+                config.request_id_policy or RequestIdPolicy(**kwargs),
+                config.headers_policy,
+                config.user_agent_policy,
+                config.proxy_policy,
+                ContentDecodePolicy(**kwargs),
+            ]
+            if isinstance(per_call_policies, Iterable):
+                policies.extend(per_call_policies)
+            else:
+                policies.append(per_call_policies)
+
+            policies.extend(
+                [
+                    config.redirect_policy,
+                    config.retry_policy,
+                    config.authentication_policy,
+                    config.custom_hook_policy,
+                ]
+            )
+            if isinstance(per_retry_policies, Iterable):
+                policies.extend(per_retry_policies)
+            else:
+                policies.append(per_retry_policies)
+
+            policies.extend(
+                [
+                    config.logging_policy,
+                    DistributedTracingPolicy(**kwargs),
+                    SensitiveHeaderCleanupPolicy(**kwargs) if config.redirect_policy else None,
+                    config.http_logging_policy or HttpLoggingPolicy(**kwargs),
+                ]
+            )
+        else:
+            if isinstance(per_call_policies, Iterable):
+                per_call_policies_list = list(per_call_policies)
+            else:
+                per_call_policies_list = [per_call_policies]
+            per_call_policies_list.extend(policies)
+            policies = per_call_policies_list
+
+            if isinstance(per_retry_policies, Iterable):
+                per_retry_policies_list = list(per_retry_policies)
+            else:
+                per_retry_policies_list = [per_retry_policies]
+            if len(per_retry_policies_list) > 0:
+                index_of_retry = -1
+                for index, policy in enumerate(policies):
+                    if isinstance(policy, RetryPolicy):
+                        index_of_retry = index
+                if index_of_retry == -1:
+                    raise ValueError(
+                        "Failed to add per_retry_policies; no RetryPolicy found in the supplied list of policies. "
+                    )
+                policies_1 = policies[: index_of_retry + 1]
+                policies_2 = policies[index_of_retry + 1 :]
+                policies_1.extend(per_retry_policies_list)
+                policies_1.extend(policies_2)
+                policies = policies_1
+
+        if transport is None:
+            # Use private import for better typing, mypy and pyright don't like PEP562
+            from .pipeline.transport._requests_basic import RequestsTransport
+
+            transport = RequestsTransport(**kwargs)
+
+        return Pipeline(transport, policies)
+
+    def send_request(self, request: HTTPRequestType, *, stream: bool = False, **kwargs: Any) -> HTTPResponseType:
+        """Method that runs the network request through the client's chained policies.
+
+        >>> from azure.core.rest import HttpRequest
+        >>> request = HttpRequest('GET', 'http://www.example.com')
+        <HttpRequest [GET], url: 'http://www.example.com'>
+        >>> response = client.send_request(request)
+        <HttpResponse: 200 OK>
+
+        :param request: The network request you want to make. Required.
+        :type request: ~azure.core.rest.HttpRequest
+        :keyword bool stream: Whether the response payload will be streamed. Defaults to False.
+        :return: The response of your network call. Does not do error handling on your response.
+        :rtype: ~azure.core.rest.HttpResponse
+        """
+        return_pipeline_response = kwargs.pop("_return_pipeline_response", False)
+        pipeline_response = self._pipeline.run(request, stream=stream, **kwargs)  # pylint: disable=protected-access
+        if return_pipeline_response:
+            return pipeline_response  # type: ignore  # This is a private API we don't want to type in signature
+        return pipeline_response.http_response

pgsql/pgAdmin 4/python/Lib/site-packages/azure/core/_pipeline_client_async.py

@@ -0,0 +1,289 @@
+# --------------------------------------------------------------------------
+#
+# Copyright (c) Microsoft Corporation. All rights reserved.
+#
+# The MIT License (MIT)
+#
+# 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.
+#
+# --------------------------------------------------------------------------
+from __future__ import annotations
+import logging
+import collections.abc
+from typing import (
+    Any,
+    Awaitable,
+    TypeVar,
+    AsyncContextManager,
+    Generator,
+    Generic,
+    Optional,
+    Type,
+    cast,
+)
+from types import TracebackType
+from .configuration import Configuration
+from .pipeline import AsyncPipeline
+from .pipeline.transport._base import PipelineClientBase
+from .pipeline.policies import (
+    ContentDecodePolicy,
+    DistributedTracingPolicy,
+    HttpLoggingPolicy,
+    RequestIdPolicy,
+    AsyncRetryPolicy,
+    SensitiveHeaderCleanupPolicy,
+)
+
+
+HTTPRequestType = TypeVar("HTTPRequestType")
+AsyncHTTPResponseType = TypeVar("AsyncHTTPResponseType", bound="AsyncContextManager")
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class _Coroutine(Awaitable[AsyncHTTPResponseType]):
+    """Wrapper to get both context manager and awaitable in place.
+
+    Naming it "_Coroutine" because if you don't await it makes the error message easier:
+    >>> result = client.send_request(request)
+    >>> result.text()
+    AttributeError: '_Coroutine' object has no attribute 'text'
+
+    Indeed, the message for calling a coroutine without waiting would be:
+    AttributeError: 'coroutine' object has no attribute 'text'
+
+    This allows the dev to either use the "async with" syntax, or simply the object directly.
+    It's also why "send_request" is not declared as async, since it couldn't be both easily.
+
+    "wrapped" must be an awaitable object that returns an object implements the async context manager protocol.
+
+    This permits this code to work for both following requests.
+
+    ```python
+    from azure.core import AsyncPipelineClient
+    from azure.core.rest import HttpRequest
+
+    async def main():
+
+        request = HttpRequest("GET", "https://httpbin.org/user-agent")
+        async with AsyncPipelineClient("https://httpbin.org/") as client:
+            # Can be used directly
+            result = await client.send_request(request)
+            print(result.text())
+
+            # Can be used as an async context manager
+            async with client.send_request(request) as result:
+                print(result.text())
+    ```
+
+    :param wrapped: Must be an awaitable the returns an async context manager that supports async "close()"
+    :type wrapped: awaitable[AsyncHTTPResponseType]
+    """
+
+    def __init__(self, wrapped: Awaitable[AsyncHTTPResponseType]) -> None:
+        super().__init__()
+        self._wrapped = wrapped
+        # If someone tries to use the object without awaiting, they will get a
+        # AttributeError: '_Coroutine' object has no attribute 'text'
+        self._response: AsyncHTTPResponseType = cast(AsyncHTTPResponseType, None)
+
+    def __await__(self) -> Generator[Any, None, AsyncHTTPResponseType]:
+        return self._wrapped.__await__()
+
+    async def __aenter__(self) -> AsyncHTTPResponseType:
+        self._response = await self
+        return self._response
+
+    async def __aexit__(
+        self,
+        exc_type: Optional[Type[BaseException]] = None,
+        exc_value: Optional[BaseException] = None,
+        traceback: Optional[TracebackType] = None,
+    ) -> None:
+        await self._response.__aexit__(exc_type, exc_value, traceback)
+
+
+class AsyncPipelineClient(
+    PipelineClientBase,
+    AsyncContextManager["AsyncPipelineClient"],
+    Generic[HTTPRequestType, AsyncHTTPResponseType],
+):
+    """Service client core methods.
+
+    Builds an AsyncPipeline client.
+
+    :param str base_url: URL for the request.
+    :keyword ~azure.core.configuration.Configuration config: If omitted, the standard configuration is used.
+    :keyword Pipeline pipeline: If omitted, a Pipeline object is created and returned.
+    :keyword list[AsyncHTTPPolicy] policies: If omitted, the standard policies of the configuration object is used.
+    :keyword per_call_policies: If specified, the policies will be added into the policy list before RetryPolicy
+    :paramtype per_call_policies: Union[AsyncHTTPPolicy, SansIOHTTPPolicy,
+        list[AsyncHTTPPolicy], list[SansIOHTTPPolicy]]
+    :keyword per_retry_policies: If specified, the policies will be added into the policy list after RetryPolicy
+    :paramtype per_retry_policies: Union[AsyncHTTPPolicy, SansIOHTTPPolicy,
+        list[AsyncHTTPPolicy], list[SansIOHTTPPolicy]]
+    :keyword AsyncHttpTransport transport: If omitted, AioHttpTransport is used for asynchronous transport.
+    :return: An async pipeline object.
+    :rtype: ~azure.core.pipeline.AsyncPipeline
+
+    .. admonition:: Example:
+
+        .. literalinclude:: ../samples/test_example_async.py
+            :start-after: [START build_async_pipeline_client]
+            :end-before: [END build_async_pipeline_client]
+            :language: python
+            :dedent: 4
+            :caption: Builds the async pipeline client.
+    """
+
+    def __init__(
+        self,
+        base_url: str,
+        *,
+        pipeline: Optional[AsyncPipeline[HTTPRequestType, AsyncHTTPResponseType]] = None,
+        config: Optional[Configuration[HTTPRequestType, AsyncHTTPResponseType]] = None,
+        **kwargs: Any,
+    ):
+        super(AsyncPipelineClient, self).__init__(base_url)
+        self._config: Configuration[HTTPRequestType, AsyncHTTPResponseType] = config or Configuration(**kwargs)
+        self._base_url = base_url
+        self._pipeline = pipeline or self._build_pipeline(self._config, **kwargs)
+
+    async def __aenter__(self) -> AsyncPipelineClient[HTTPRequestType, AsyncHTTPResponseType]:
+        await self._pipeline.__aenter__()
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: Optional[Type[BaseException]] = None,
+        exc_value: Optional[BaseException] = None,
+        traceback: Optional[TracebackType] = None,
+    ) -> None:
+        await self._pipeline.__aexit__(exc_type, exc_value, traceback)
+
+    async def close(self) -> None:
+        await self.__aexit__()
+
+    def _build_pipeline(
+        self,
+        config: Configuration[HTTPRequestType, AsyncHTTPResponseType],
+        *,
+        policies=None,
+        per_call_policies=None,
+        per_retry_policies=None,
+        **kwargs,
+    ) -> AsyncPipeline[HTTPRequestType, AsyncHTTPResponseType]:
+        transport = kwargs.get("transport")
+        per_call_policies = per_call_policies or []
+        per_retry_policies = per_retry_policies or []
+
+        if policies is None:  # [] is a valid policy list
+            policies = [
+                config.request_id_policy or RequestIdPolicy(**kwargs),
+                config.headers_policy,
+                config.user_agent_policy,
+                config.proxy_policy,
+                ContentDecodePolicy(**kwargs),
+            ]
+            if isinstance(per_call_policies, collections.abc.Iterable):
+                policies.extend(per_call_policies)
+            else:
+                policies.append(per_call_policies)
+
+            policies.extend(
+                [
+                    config.redirect_policy,
+                    config.retry_policy,
+                    config.authentication_policy,
+                    config.custom_hook_policy,
+                ]
+            )
+            if isinstance(per_retry_policies, collections.abc.Iterable):
+                policies.extend(per_retry_policies)
+            else:
+                policies.append(per_retry_policies)
+
+            policies.extend(
+                [
+                    config.logging_policy,
+                    DistributedTracingPolicy(**kwargs),
+                    SensitiveHeaderCleanupPolicy(**kwargs) if config.redirect_policy else None,
+                    config.http_logging_policy or HttpLoggingPolicy(**kwargs),
+                ]
+            )
+        else:
+            if isinstance(per_call_policies, collections.abc.Iterable):
+                per_call_policies_list = list(per_call_policies)
+            else:
+                per_call_policies_list = [per_call_policies]
+            per_call_policies_list.extend(policies)
+            policies = per_call_policies_list
+            if isinstance(per_retry_policies, collections.abc.Iterable):
+                per_retry_policies_list = list(per_retry_policies)
+            else:
+                per_retry_policies_list = [per_retry_policies]
+            if len(per_retry_policies_list) > 0:
+                index_of_retry = -1
+                for index, policy in enumerate(policies):
+                    if isinstance(policy, AsyncRetryPolicy):
+                        index_of_retry = index
+                if index_of_retry == -1:
+                    raise ValueError(
+                        "Failed to add per_retry_policies; no RetryPolicy found in the supplied list of policies. "
+                    )
+                policies_1 = policies[: index_of_retry + 1]
+                policies_2 = policies[index_of_retry + 1 :]
+                policies_1.extend(per_retry_policies_list)
+                policies_1.extend(policies_2)
+                policies = policies_1
+
+        if not transport:
+            # Use private import for better typing, mypy and pyright don't like PEP562
+            from .pipeline.transport._aiohttp import AioHttpTransport
+
+            transport = AioHttpTransport(**kwargs)
+
+        return AsyncPipeline[HTTPRequestType, AsyncHTTPResponseType](transport, policies)
+
+    async def _make_pipeline_call(self, request: HTTPRequestType, **kwargs) -> AsyncHTTPResponseType:
+        return_pipeline_response = kwargs.pop("_return_pipeline_response", False)
+        pipeline_response = await self._pipeline.run(request, **kwargs)  # pylint: disable=protected-access
+        if return_pipeline_response:
+            return pipeline_response  # type: ignore  # This is a private API we don't want to type in signature
+        return pipeline_response.http_response
+
+    def send_request(
+        self, request: HTTPRequestType, *, stream: bool = False, **kwargs: Any
+    ) -> Awaitable[AsyncHTTPResponseType]:
+        """Method that runs the network request through the client's chained policies.
+
+        >>> from azure.core.rest import HttpRequest
+        >>> request = HttpRequest('GET', 'http://www.example.com')
+        <HttpRequest [GET], url: 'http://www.example.com'>
+        >>> response = await client.send_request(request)
+        <AsyncHttpResponse: 200 OK>
+
+        :param request: The network request you want to make. Required.
+        :type request: ~azure.core.rest.HttpRequest
+        :keyword bool stream: Whether the response payload will be streamed. Defaults to False.
+        :return: The response of your network call. Does not do error handling on your response.
+        :rtype: ~azure.core.rest.AsyncHttpResponse
+        """
+        wrapped = self._make_pipeline_call(request, stream=stream, **kwargs)
+        return _Coroutine(wrapped=wrapped)

pgsql/pgAdmin 4/python/Lib/site-packages/azure/core/_version.py

@@ -0,0 +1,12 @@
+# coding=utf-8
+# --------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+#
+# Code generated by Microsoft (R) AutoRest Code Generator.
+# Changes may cause incorrect behavior and will be lost if the code is
+# regenerated.
+# --------------------------------------------------------------------------
+
+VERSION = "1.30.1"

pgsql/pgAdmin 4/python/Lib/site-packages/azure/core/async_paging.py

@@ -0,0 +1,151 @@
+# --------------------------------------------------------------------------
+#
+# Copyright (c) Microsoft Corporation. All rights reserved.
+#
+# The MIT License (MIT)
+#
+# 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.
+#
+# --------------------------------------------------------------------------
+import collections.abc
+import logging
+from typing import (
+    Iterable,
+    AsyncIterator,
+    TypeVar,
+    Callable,
+    Tuple,
+    Optional,
+    Awaitable,
+    Any,
+)
+
+from .exceptions import AzureError
+
+
+_LOGGER = logging.getLogger(__name__)
+
+ReturnType = TypeVar("ReturnType")
+ResponseType = TypeVar("ResponseType")
+
+__all__ = ["AsyncPageIterator", "AsyncItemPaged"]
+
+
+class AsyncList(AsyncIterator[ReturnType]):
+    def __init__(self, iterable: Iterable[ReturnType]) -> None:
+        """Change an iterable into a fake async iterator.
+
+        Could be useful to fill the async iterator contract when you get a list.
+
+        :param iterable: A sync iterable of T
+        """
+        # Technically, if it's a real iterator, I don't need "iter"
+        # but that will cover iterable and list as well with no troubles created.
+        self._iterator = iter(iterable)
+
+    async def __anext__(self) -> ReturnType:
+        try:
+            return next(self._iterator)
+        except StopIteration as err:
+            raise StopAsyncIteration() from err
+
+
+class AsyncPageIterator(AsyncIterator[AsyncIterator[ReturnType]]):
+    def __init__(
+        self,
+        get_next: Callable[[Optional[str]], Awaitable[ResponseType]],
+        extract_data: Callable[[ResponseType], Awaitable[Tuple[str, AsyncIterator[ReturnType]]]],
+        continuation_token: Optional[str] = None,
+    ) -> None:
+        """Return an async iterator of pages.
+
+        :param get_next: Callable that take the continuation token and return a HTTP response
+        :param extract_data: Callable that take an HTTP response and return a tuple continuation token,
+         list of ReturnType
+        :param str continuation_token: The continuation token needed by get_next
+        """
+        self._get_next = get_next
+        self._extract_data = extract_data
+        self.continuation_token = continuation_token
+        self._did_a_call_already = False
+        self._response: Optional[ResponseType] = None
+        self._current_page: Optional[AsyncIterator[ReturnType]] = None
+
+    async def __anext__(self) -> AsyncIterator[ReturnType]:
+        if self.continuation_token is None and self._did_a_call_already:
+            raise StopAsyncIteration("End of paging")
+        try:
+            self._response = await self._get_next(self.continuation_token)
+        except AzureError as error:
+            if not error.continuation_token:
+                error.continuation_token = self.continuation_token
+            raise
+
+        self._did_a_call_already = True
+
+        self.continuation_token, self._current_page = await self._extract_data(self._response)
+
+        # If current_page was a sync list, wrap it async-like
+        if isinstance(self._current_page, collections.abc.Iterable):
+            self._current_page = AsyncList(self._current_page)
+
+        return self._current_page
+
+
+class AsyncItemPaged(AsyncIterator[ReturnType]):
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        """Return an async iterator of items.
+
+        args and kwargs will be passed to the AsyncPageIterator constructor directly,
+        except page_iterator_class
+        """
+        self._args = args
+        self._kwargs = kwargs
+        self._page_iterator: Optional[AsyncIterator[AsyncIterator[ReturnType]]] = None
+        self._page: Optional[AsyncIterator[ReturnType]] = None
+        self._page_iterator_class = self._kwargs.pop("page_iterator_class", AsyncPageIterator)
+
+    def by_page(
+        self,
+        continuation_token: Optional[str] = None,
+    ) -> AsyncIterator[AsyncIterator[ReturnType]]:
+        """Get an async iterator of pages of objects, instead of an async iterator of objects.
+
+        :param str continuation_token:
+            An opaque continuation token. This value can be retrieved from the
+            continuation_token field of a previous generator object. If specified,
+            this generator will begin returning results from this point.
+        :returns: An async iterator of pages (themselves async iterator of objects)
+        :rtype: AsyncIterator[AsyncIterator[ReturnType]]
+        """
+        return self._page_iterator_class(*self._args, **self._kwargs, continuation_token=continuation_token)
+
+    async def __anext__(self) -> ReturnType:
+        if self._page_iterator is None:
+            self._page_iterator = self.by_page()
+            return await self.__anext__()
+        if self._page is None:
+            # Let it raise StopAsyncIteration
+            self._page = await self._page_iterator.__anext__()
+            return await self.__anext__()
+        try:
+            return await self._page.__anext__()
+        except StopAsyncIteration:
+            self._page = None
+            return await self.__anext__()

pgsql/pgAdmin 4/python/Lib/site-packages/azure/core/configuration.py

@@ -0,0 +1,148 @@
+# --------------------------------------------------------------------------
+#
+# Copyright (c) Microsoft Corporation. All rights reserved.
+#
+# The MIT License (MIT)
+#
+# 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.
+#
+# --------------------------------------------------------------------------
+from __future__ import annotations
+from typing import Union, Optional, Any, Generic, TypeVar, TYPE_CHECKING
+
+HTTPResponseType = TypeVar("HTTPResponseType")
+HTTPRequestType = TypeVar("HTTPRequestType")
+
+if TYPE_CHECKING:
+    from .pipeline.policies import HTTPPolicy, AsyncHTTPPolicy, SansIOHTTPPolicy
+
+    AnyPolicy = Union[
+        HTTPPolicy[HTTPRequestType, HTTPResponseType],
+        AsyncHTTPPolicy[HTTPRequestType, HTTPResponseType],
+        SansIOHTTPPolicy[HTTPRequestType, HTTPResponseType],
+    ]
+
+
+class Configuration(Generic[HTTPRequestType, HTTPResponseType]):  # pylint: disable=too-many-instance-attributes
+    """Provides the home for all of the configurable policies in the pipeline.
+
+    A new Configuration object provides no default policies and does not specify in what
+    order the policies will be added to the pipeline. The SDK developer must specify each
+    of the policy defaults as required by the service and use the policies in the
+    Configuration to construct the pipeline correctly, as well as inserting any
+    unexposed/non-configurable policies.
+
+    :ivar headers_policy: Provides parameters for custom or additional headers to be sent with the request.
+    :ivar proxy_policy: Provides configuration parameters for proxy.
+    :ivar redirect_policy: Provides configuration parameters for redirects.
+    :ivar retry_policy: Provides configuration parameters for retries in the pipeline.
+    :ivar custom_hook_policy: Provides configuration parameters for a custom hook.
+    :ivar logging_policy: Provides configuration parameters for logging.
+    :ivar http_logging_policy: Provides configuration parameters for HTTP specific logging.
+    :ivar user_agent_policy: Provides configuration parameters to append custom values to the
+     User-Agent header.
+    :ivar authentication_policy: Provides configuration parameters for adding a bearer token Authorization
+     header to requests.
+    :ivar request_id_policy: Provides configuration parameters for adding a request id to requests.
+    :keyword polling_interval: Polling interval while doing LRO operations, if Retry-After is not set.
+
+    .. admonition:: Example:
+
+        .. literalinclude:: ../samples/test_example_config.py
+            :start-after: [START configuration]
+            :end-before: [END configuration]
+            :language: python
+            :caption: Creates the service configuration and adds policies.
+    """
+
+    def __init__(self, **kwargs: Any) -> None:
+        # Headers (sent with every request)
+        self.headers_policy: Optional[AnyPolicy[HTTPRequestType, HTTPResponseType]] = None
+
+        # Proxy settings (Currently used to configure transport, could be pipeline policy instead)
+        self.proxy_policy: Optional[AnyPolicy[HTTPRequestType, HTTPResponseType]] = None
+
+        # Redirect configuration
+        self.redirect_policy: Optional[AnyPolicy[HTTPRequestType, HTTPResponseType]] = None
+
+        # Retry configuration
+        self.retry_policy: Optional[AnyPolicy[HTTPRequestType, HTTPResponseType]] = None
+
+        # Custom hook configuration
+        self.custom_hook_policy: Optional[AnyPolicy[HTTPRequestType, HTTPResponseType]] = None
+
+        # Logger configuration
+        self.logging_policy: Optional[AnyPolicy[HTTPRequestType, HTTPResponseType]] = None
+
+        # Http logger configuration
+        self.http_logging_policy: Optional[AnyPolicy[HTTPRequestType, HTTPResponseType]] = None
+
+        # User Agent configuration
+        self.user_agent_policy: Optional[AnyPolicy[HTTPRequestType, HTTPResponseType]] = None
+
+        # Authentication configuration
+        self.authentication_policy: Optional[AnyPolicy[HTTPRequestType, HTTPResponseType]] = None
+
+        # Request ID policy
+        self.request_id_policy: Optional[AnyPolicy[HTTPRequestType, HTTPResponseType]] = None
+
+        # Polling interval if no retry-after in polling calls results
+        self.polling_interval: float = kwargs.get("polling_interval", 30)
+
+
+class ConnectionConfiguration:
+    """HTTP transport connection configuration settings.
+
+    Common properties that can be configured on all transports. Found in the
+    Configuration object.
+
+    :keyword float connection_timeout: A single float in seconds for the connection timeout. Defaults to 300 seconds.
+    :keyword float read_timeout: A single float in seconds for the read timeout. Defaults to 300 seconds.
+    :keyword connection_verify: SSL certificate verification. Enabled by default. Set to False to disable,
+     alternatively can be set to the path to a CA_BUNDLE file or directory with certificates of trusted CAs.
+    :paramtype connection_verify: bool or str
+    :keyword str connection_cert: Client-side certificates. You can specify a local cert to use as client side
+     certificate, as a single file (containing the private key and the certificate) or as a tuple of both files' paths.
+    :keyword int connection_data_block_size: The block size of data sent over the connection. Defaults to 4096 bytes.
+
+    .. admonition:: Example:
+
+        .. literalinclude:: ../samples/test_example_config.py
+            :start-after: [START connection_configuration]
+            :end-before: [END connection_configuration]
+            :language: python
+            :dedent: 4
+            :caption: Configuring transport connection settings.
+    """
+
+    def __init__(
+        self,  # pylint: disable=unused-argument
+        *,
+        connection_timeout: float = 300,
+        read_timeout: float = 300,
+        connection_verify: Union[bool, str] = True,
+        connection_cert: Optional[str] = None,
+        connection_data_block_size: int = 4096,
+        **kwargs: Any,
+    ) -> None:
+        self.timeout = connection_timeout
+        self.read_timeout = read_timeout
+        self.verify = connection_verify
+        self.cert = connection_cert
+        self.data_block_size = connection_data_block_size

pgsql/pgAdmin 4/python/Lib/site-packages/azure/core/credentials.py

@@ -0,0 +1,175 @@
+# -------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See LICENSE.txt in the project root for
+# license information.
+# -------------------------------------------------------------------------
+from typing import Any, NamedTuple, Optional
+from typing_extensions import Protocol, runtime_checkable
+
+
+class AccessToken(NamedTuple):
+    """Represents an OAuth access token."""
+
+    token: str
+    expires_on: int
+
+
+AccessToken.token.__doc__ = """The token string."""
+AccessToken.expires_on.__doc__ = """The token's expiration time in Unix time."""
+
+
+@runtime_checkable
+class TokenCredential(Protocol):
+    """Protocol for classes able to provide OAuth tokens."""
+
+    def get_token(
+        self,
+        *scopes: str,
+        claims: Optional[str] = None,
+        tenant_id: Optional[str] = None,
+        enable_cae: bool = False,
+        **kwargs: Any
+    ) -> AccessToken:
+        """Request an access token for `scopes`.
+
+        :param str scopes: The type of access needed.
+
+        :keyword str claims: Additional claims required in the token, such as those returned in a resource
+            provider's claims challenge following an authorization failure.
+        :keyword str tenant_id: Optional tenant to include in the token request.
+        :keyword bool enable_cae: Indicates whether to enable Continuous Access Evaluation (CAE) for the requested
+            token. Defaults to False.
+
+        :rtype: AccessToken
+        :return: An AccessToken instance containing the token string and its expiration time in Unix time.
+        """
+        ...
+
+
+class AzureNamedKey(NamedTuple):
+    """Represents a name and key pair."""
+
+    name: str
+    key: str
+
+
+__all__ = [
+    "AzureKeyCredential",
+    "AzureSasCredential",
+    "AccessToken",
+    "AzureNamedKeyCredential",
+    "TokenCredential",
+]
+
+
+class AzureKeyCredential:
+    """Credential type used for authenticating to an Azure service.
+    It provides the ability to update the key without creating a new client.
+
+    :param str key: The key used to authenticate to an Azure service
+    :raises: TypeError
+    """
+
+    def __init__(self, key: str) -> None:
+        if not isinstance(key, str):
+            raise TypeError("key must be a string.")
+        self._key = key
+
+    @property
+    def key(self) -> str:
+        """The value of the configured key.
+
+        :rtype: str
+        :return: The value of the configured key.
+        """
+        return self._key
+
+    def update(self, key: str) -> None:
+        """Update the key.
+
+        This can be used when you've regenerated your service key and want
+        to update long-lived clients.
+
+        :param str key: The key used to authenticate to an Azure service
+        :raises: ValueError or TypeError
+        """
+        if not key:
+            raise ValueError("The key used for updating can not be None or empty")
+        if not isinstance(key, str):
+            raise TypeError("The key used for updating must be a string.")
+        self._key = key
+
+
+class AzureSasCredential:
+    """Credential type used for authenticating to an Azure service.
+    It provides the ability to update the shared access signature without creating a new client.
+
+    :param str signature: The shared access signature used to authenticate to an Azure service
+    :raises: TypeError
+    """
+
+    def __init__(self, signature: str) -> None:
+        if not isinstance(signature, str):
+            raise TypeError("signature must be a string.")
+        self._signature = signature
+
+    @property
+    def signature(self) -> str:
+        """The value of the configured shared access signature.
+
+        :rtype: str
+        :return: The value of the configured shared access signature.
+        """
+        return self._signature
+
+    def update(self, signature: str) -> None:
+        """Update the shared access signature.
+
+        This can be used when you've regenerated your shared access signature and want
+        to update long-lived clients.
+
+        :param str signature: The shared access signature used to authenticate to an Azure service
+        :raises: ValueError or TypeError
+        """
+        if not signature:
+            raise ValueError("The signature used for updating can not be None or empty")
+        if not isinstance(signature, str):
+            raise TypeError("The signature used for updating must be a string.")
+        self._signature = signature
+
+
+class AzureNamedKeyCredential:
+    """Credential type used for working with any service needing a named key that follows patterns
+    established by the other credential types.
+
+    :param str name: The name of the credential used to authenticate to an Azure service.
+    :param str key: The key used to authenticate to an Azure service.
+    :raises: TypeError
+    """
+
+    def __init__(self, name: str, key: str) -> None:
+        if not isinstance(name, str) or not isinstance(key, str):
+            raise TypeError("Both name and key must be strings.")
+        self._credential = AzureNamedKey(name, key)
+
+    @property
+    def named_key(self) -> AzureNamedKey:
+        """The value of the configured name.
+
+        :rtype: AzureNamedKey
+        :return: The value of the configured name.
+        """
+        return self._credential
+
+    def update(self, name: str, key: str) -> None:
+        """Update the named key credential.
+
+        Both name and key must be provided in order to update the named key credential.
+        Individual attributes cannot be updated.
+
+        :param str name: The name of the credential used to authenticate to an Azure service.
+        :param str key: The key used to authenticate to an Azure service.
+        """
+        if not isinstance(name, str) or not isinstance(key, str):
+            raise TypeError("Both name and key must be strings.")
+        self._credential = AzureNamedKey(name, key)

pgsql/pgAdmin 4/python/Lib/site-packages/azure/core/credentials_async.py

@@ -0,0 +1,48 @@
+# ------------------------------------
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+# ------------------------------------
+from __future__ import annotations
+from types import TracebackType
+from typing import Any, Optional, AsyncContextManager, Type
+from typing_extensions import Protocol, runtime_checkable
+from .credentials import AccessToken as _AccessToken
+
+
+@runtime_checkable
+class AsyncTokenCredential(Protocol, AsyncContextManager["AsyncTokenCredential"]):
+    """Protocol for classes able to provide OAuth tokens."""
+
+    async def get_token(
+        self,
+        *scopes: str,
+        claims: Optional[str] = None,
+        tenant_id: Optional[str] = None,
+        enable_cae: bool = False,
+        **kwargs: Any,
+    ) -> _AccessToken:
+        """Request an access token for `scopes`.
+
+        :param str scopes: The type of access needed.
+
+        :keyword str claims: Additional claims required in the token, such as those returned in a resource
+            provider's claims challenge following an authorization failure.
+        :keyword str tenant_id: Optional tenant to include in the token request.
+        :keyword bool enable_cae: Indicates whether to enable Continuous Access Evaluation (CAE) for the requested
+            token. Defaults to False.
+
+        :rtype: AccessToken
+        :return: An AccessToken instance containing the token string and its expiration time in Unix time.
+        """
+        ...
+
+    async def close(self) -> None:
+        pass
+
+    async def __aexit__(
+        self,
+        exc_type: Optional[Type[BaseException]] = None,
+        exc_value: Optional[BaseException] = None,
+        traceback: Optional[TracebackType] = None,
+    ) -> None:
+        pass

pgsql/pgAdmin 4/python/Lib/site-packages/azure/core/exceptions.py

@@ -0,0 +1,582 @@
+# --------------------------------------------------------------------------
+#
+# Copyright (c) Microsoft Corporation. All rights reserved.
+#
+# The MIT License (MIT)
+#
+# 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.
+#
+# --------------------------------------------------------------------------
+from __future__ import annotations
+import json
+import logging
+import sys
+
+from types import TracebackType
+from typing import (
+    Callable,
+    Any,
+    Optional,
+    Union,
+    Type,
+    List,
+    Mapping,
+    TypeVar,
+    Generic,
+    Dict,
+    NoReturn,
+    TYPE_CHECKING,
+)
+from typing_extensions import Protocol, runtime_checkable
+
+_LOGGER = logging.getLogger(__name__)
+
+if TYPE_CHECKING:
+    from azure.core.pipeline.policies import RequestHistory
+
+HTTPResponseType = TypeVar("HTTPResponseType")
+HTTPRequestType = TypeVar("HTTPRequestType")
+KeyType = TypeVar("KeyType")
+ValueType = TypeVar("ValueType")
+# To replace when typing.Self is available in our baseline
+SelfODataV4Format = TypeVar("SelfODataV4Format", bound="ODataV4Format")
+
+
+__all__ = [
+    "AzureError",
+    "ServiceRequestError",
+    "ServiceResponseError",
+    "HttpResponseError",
+    "DecodeError",
+    "ResourceExistsError",
+    "ResourceNotFoundError",
+    "ClientAuthenticationError",
+    "ResourceModifiedError",
+    "ResourceNotModifiedError",
+    "TooManyRedirectsError",
+    "ODataV4Format",
+    "ODataV4Error",
+    "StreamConsumedError",
+    "StreamClosedError",
+    "ResponseNotReadError",
+    "SerializationError",
+    "DeserializationError",
+]
+
+
+def raise_with_traceback(exception: Callable, *args: Any, message: str = "", **kwargs: Any) -> NoReturn:
+    """Raise exception with a specified traceback.
+    This MUST be called inside a "except" clause.
+
+    .. note:: This method is deprecated since we don't support Python 2 anymore. Use raise/from instead.
+
+    :param Exception exception: Error type to be raised.
+    :param any args: Any additional args to be included with exception.
+    :keyword str message: Message to be associated with the exception. If omitted, defaults to an empty string.
+    """
+    exc_type, exc_value, exc_traceback = sys.exc_info()
+    # If not called inside an "except", exc_type will be None. Assume it will not happen
+    if exc_type is None:
+        raise ValueError("raise_with_traceback can only be used in except clauses")
+    exc_msg = "{}, {}: {}".format(message, exc_type.__name__, exc_value)
+    error = exception(exc_msg, *args, **kwargs)
+    try:
+        raise error.with_traceback(exc_traceback)  # pylint: disable=raise-missing-from
+    except AttributeError:  # Python 2
+        error.__traceback__ = exc_traceback
+        raise error  # pylint: disable=raise-missing-from
+
+
+@runtime_checkable
+class _HttpResponseCommonAPI(Protocol):
+    """Protocol used by exceptions for HTTP response.
+
+    As HttpResponseError uses very few properties of HttpResponse, a protocol
+    is faster and simpler than import all the possible types (at least 6).
+    """
+
+    @property
+    def reason(self) -> Optional[str]:
+        ...
+
+    @property
+    def status_code(self) -> Optional[int]:
+        ...
+
+    def text(self) -> str:
+        ...
+
+    @property
+    def request(self) -> object:  # object as type, since all we need is str() on it
+        ...
+
+
+class ErrorMap(Generic[KeyType, ValueType]):
+    """Error Map class. To be used in map_error method, behaves like a dictionary.
+    It returns the error type if it is found in custom_error_map. Or return default_error
+
+    :param dict custom_error_map: User-defined error map, it is used to map status codes to error types.
+    :keyword error default_error: Default error type. It is returned if the status code is not found in custom_error_map
+    """
+
+    def __init__(
+        self,  # pylint: disable=unused-argument
+        custom_error_map: Optional[Mapping[KeyType, ValueType]] = None,
+        *,
+        default_error: Optional[ValueType] = None,
+        **kwargs: Any,
+    ) -> None:
+        self._custom_error_map = custom_error_map or {}
+        self._default_error = default_error
+
+    def get(self, key: KeyType) -> Optional[ValueType]:
+        ret = self._custom_error_map.get(key)
+        if ret:
+            return ret
+        return self._default_error
+
+
+def map_error(
+    status_code: int, response: _HttpResponseCommonAPI, error_map: Mapping[int, Type[HttpResponseError]]
+) -> None:
+    if not error_map:
+        return
+    error_type = error_map.get(status_code)
+    if not error_type:
+        return
+    error = error_type(response=response)
+    raise error
+
+
+class ODataV4Format:
+    """Class to describe OData V4 error format.
+
+    http://docs.oasis-open.org/odata/odata-json-format/v4.0/os/odata-json-format-v4.0-os.html#_Toc372793091
+
+    Example of JSON:
+
+    .. code-block:: json
+
+        {
+            "error": {
+                "code": "ValidationError",
+                "message": "One or more fields contain incorrect values: ",
+                "details": [
+                    {
+                        "code": "ValidationError",
+                        "target": "representation",
+                        "message": "Parsing error(s): String '' does not match regex pattern '^[^{}/ :]+(?: :\\\\d+)?$'.
+                        Path 'host', line 1, position 297."
+                    },
+                    {
+                        "code": "ValidationError",
+                        "target": "representation",
+                        "message": "Parsing error(s): The input OpenAPI file is not valid for the OpenAPI specificate
+                        https: //github.com/OAI/OpenAPI-Specification/blob/master/versions/2.0.md
+                        (schema https://github.com/OAI/OpenAPI-Specification/blob/master/schemas/v2.0/schema.json)."
+                    }
+                ]
+            }
+        }
+
+    :param dict json_object: A Python dict representing a ODataV4 JSON
+    :ivar str ~.code: Its value is a service-defined error code.
+     This code serves as a sub-status for the HTTP error code specified in the response.
+    :ivar str message: Human-readable, language-dependent representation of the error.
+    :ivar str target: The target of the particular error (for example, the name of the property in error).
+     This field is optional and may be None.
+    :ivar list[ODataV4Format] details: Array of ODataV4Format instances that MUST contain name/value pairs
+     for code and message, and MAY contain a name/value pair for target, as described above.
+    :ivar dict innererror: An object. The contents of this object are service-defined.
+     Usually this object contains information that will help debug the service.
+    """
+
+    CODE_LABEL = "code"
+    MESSAGE_LABEL = "message"
+    TARGET_LABEL = "target"
+    DETAILS_LABEL = "details"
+    INNERERROR_LABEL = "innererror"
+
+    def __init__(self, json_object: Mapping[str, Any]) -> None:
+        if "error" in json_object:
+            json_object = json_object["error"]
+        cls: Type[ODataV4Format] = self.__class__
+
+        # Required fields, but assume they could be missing still to be robust
+        self.code: Optional[str] = json_object.get(cls.CODE_LABEL)
+        self.message: Optional[str] = json_object.get(cls.MESSAGE_LABEL)
+
+        if not (self.code or self.message):
+            raise ValueError("Impossible to extract code/message from received JSON:\n" + json.dumps(json_object))
+
+        # Optional fields
+        self.target: Optional[str] = json_object.get(cls.TARGET_LABEL)
+
+        # details is recursive of this very format
+        self.details: List[ODataV4Format] = []
+        for detail_node in json_object.get(cls.DETAILS_LABEL) or []:
+            try:
+                self.details.append(self.__class__(detail_node))
+            except Exception:  # pylint: disable=broad-except
+                pass
+
+        self.innererror: Mapping[str, Any] = json_object.get(cls.INNERERROR_LABEL, {})
+
+    @property
+    def error(self: SelfODataV4Format) -> SelfODataV4Format:
+        import warnings
+
+        warnings.warn(
+            "error.error from azure exceptions is deprecated, just simply use 'error' once",
+            DeprecationWarning,
+        )
+        return self
+
+    def __str__(self) -> str:
+        return "({}) {}\n{}".format(self.code, self.message, self.message_details())
+
+    def message_details(self) -> str:
+        """Return a detailed string of the error.
+
+        :return: A string with the details of the error.
+        :rtype: str
+        """
+        error_str = "Code: {}".format(self.code)
+        error_str += "\nMessage: {}".format(self.message)
+        if self.target:
+            error_str += "\nTarget: {}".format(self.target)
+
+        if self.details:
+            error_str += "\nException Details:"
+            for error_obj in self.details:
+                # Indent for visibility
+                error_str += "\n".join("\t" + s for s in str(error_obj).splitlines())
+
+        if self.innererror:
+            error_str += "\nInner error: {}".format(json.dumps(self.innererror, indent=4))
+        return error_str
+
+
+class AzureError(Exception):
+    """Base exception for all errors.
+
+    :param object message: The message object stringified as 'message' attribute
+    :keyword error: The original exception if any
+    :paramtype error: Exception
+
+    :ivar inner_exception: The exception passed with the 'error' kwarg
+    :vartype inner_exception: Exception
+    :ivar exc_type: The exc_type from sys.exc_info()
+    :ivar exc_value: The exc_value from sys.exc_info()
+    :ivar exc_traceback: The exc_traceback from sys.exc_info()
+    :ivar exc_msg: A string formatting of message parameter, exc_type and exc_value
+    :ivar str message: A stringified version of the message parameter
+    :ivar str continuation_token: A token reference to continue an incomplete operation. This value is optional
+     and will be `None` where continuation is either unavailable or not applicable.
+    """
+
+    def __init__(self, message: Optional[object], *args: Any, **kwargs: Any) -> None:
+        self.inner_exception: Optional[BaseException] = kwargs.get("error")
+
+        exc_info = sys.exc_info()
+        self.exc_type: Optional[Type[Any]] = exc_info[0]
+        self.exc_value: Optional[BaseException] = exc_info[1]
+        self.exc_traceback: Optional[TracebackType] = exc_info[2]
+
+        self.exc_type = self.exc_type if self.exc_type else type(self.inner_exception)
+        self.exc_msg: str = "{}, {}: {}".format(message, self.exc_type.__name__, self.exc_value)
+        self.message: str = str(message)
+        self.continuation_token: Optional[str] = kwargs.get("continuation_token")
+        super(AzureError, self).__init__(self.message, *args)
+
+    def raise_with_traceback(self) -> None:
+        """Raise the exception with the existing traceback.
+
+        .. deprecated:: 1.22.0
+           This method is deprecated as we don't support Python 2 anymore. Use raise/from instead.
+        """
+        try:
+            raise super(AzureError, self).with_traceback(self.exc_traceback)  # pylint: disable=raise-missing-from
+        except AttributeError:
+            self.__traceback__: Optional[TracebackType] = self.exc_traceback
+            raise self  # pylint: disable=raise-missing-from
+
+
+class ServiceRequestError(AzureError):
+    """An error occurred while attempt to make a request to the service.
+    No request was sent.
+    """
+
+
+class ServiceResponseError(AzureError):
+    """The request was sent, but the client failed to understand the response.
+    The connection may have timed out. These errors can be retried for idempotent or
+    safe operations"""
+
+
+class ServiceRequestTimeoutError(ServiceRequestError):
+    """Error raised when timeout happens"""
+
+
+class ServiceResponseTimeoutError(ServiceResponseError):
+    """Error raised when timeout happens"""
+
+
+class HttpResponseError(AzureError):
+    """A request was made, and a non-success status code was received from the service.
+
+    :param object message: The message object stringified as 'message' attribute
+    :param response: The response that triggered the exception.
+    :type response: ~azure.core.pipeline.transport.HttpResponse or ~azure.core.pipeline.transport.AsyncHttpResponse
+
+    :ivar reason: The HTTP response reason
+    :vartype reason: str
+    :ivar status_code: HttpResponse's status code
+    :vartype status_code: int
+    :ivar response: The response that triggered the exception.
+    :vartype response: ~azure.core.pipeline.transport.HttpResponse or ~azure.core.pipeline.transport.AsyncHttpResponse
+    :ivar model: The request body/response body model
+    :vartype model: ~msrest.serialization.Model
+    :ivar error: The formatted error
+    :vartype error: ODataV4Format
+    """
+
+    def __init__(
+        self, message: Optional[object] = None, response: Optional[_HttpResponseCommonAPI] = None, **kwargs: Any
+    ) -> None:
+        # Don't want to document this one yet.
+        error_format = kwargs.get("error_format", ODataV4Format)
+
+        self.reason: Optional[str] = None
+        self.status_code: Optional[int] = None
+        self.response: Optional[_HttpResponseCommonAPI] = response
+        if response:
+            self.reason = response.reason
+            self.status_code = response.status_code
+
+        # old autorest are setting "error" before calling __init__, so it might be there already
+        # transferring into self.model
+        model: Optional[Any] = kwargs.pop("model", None)
+        self.model: Optional[Any]
+        if model is not None:  # autorest v5
+            self.model = model
+        else:  # autorest azure-core, for KV 1.0, Storage 12.0, etc.
+            self.model = getattr(self, "error", None)
+        self.error: Optional[ODataV4Format] = self._parse_odata_body(error_format, response)
+
+        # By priority, message is:
+        # - odatav4 message, OR
+        # - parameter "message", OR
+        # - generic meassage using "reason"
+        if self.error:
+            message = str(self.error)
+        else:
+            message = message or "Operation returned an invalid status '{}'".format(self.reason)
+
+        super(HttpResponseError, self).__init__(message=message, **kwargs)
+
+    @staticmethod
+    def _parse_odata_body(
+        error_format: Type[ODataV4Format], response: Optional[_HttpResponseCommonAPI]
+    ) -> Optional[ODataV4Format]:
+        try:
+            # https://github.com/python/mypy/issues/14743#issuecomment-1664725053
+            odata_json = json.loads(response.text())  # type: ignore
+            return error_format(odata_json)
+        except Exception:  # pylint: disable=broad-except
+            # If the body is not JSON valid, just stop now
+            pass
+        return None
+
+    def __str__(self) -> str:
+        retval = super(HttpResponseError, self).__str__()
+        try:
+            # https://github.com/python/mypy/issues/14743#issuecomment-1664725053
+            body = self.response.text()  # type: ignore
+            if body and not self.error:
+                return "{}\nContent: {}".format(retval, body)[:2048]
+        except Exception:  # pylint: disable=broad-except
+            pass
+        return retval
+
+
+class DecodeError(HttpResponseError):
+    """Error raised during response deserialization."""
+
+
+class IncompleteReadError(DecodeError):
+    """Error raised if peer closes the connection before we have received the complete message body."""
+
+
+class ResourceExistsError(HttpResponseError):
+    """An error response with status code 4xx.
+    This will not be raised directly by the Azure core pipeline."""
+
+
+class ResourceNotFoundError(HttpResponseError):
+    """An error response, typically triggered by a 412 response (for update) or 404 (for get/post)"""
+
+
+class ClientAuthenticationError(HttpResponseError):
+    """An error response with status code 4xx.
+    This will not be raised directly by the Azure core pipeline."""
+
+
+class ResourceModifiedError(HttpResponseError):
+    """An error response with status code 4xx, typically 412 Conflict.
+    This will not be raised directly by the Azure core pipeline."""
+
+
+class ResourceNotModifiedError(HttpResponseError):
+    """An error response with status code 304.
+    This will not be raised directly by the Azure core pipeline."""
+
+
+class TooManyRedirectsError(HttpResponseError, Generic[HTTPRequestType, HTTPResponseType]):
+    """Reached the maximum number of redirect attempts.
+
+    :param history: The history of requests made while trying to fulfill the request.
+    :type history: list[~azure.core.pipeline.policies.RequestHistory]
+    """
+
+    def __init__(
+        self, history: "List[RequestHistory[HTTPRequestType, HTTPResponseType]]", *args: Any, **kwargs: Any
+    ) -> None:
+        self.history = history
+        message = "Reached maximum redirect attempts."
+        super(TooManyRedirectsError, self).__init__(message, *args, **kwargs)
+
+
+class ODataV4Error(HttpResponseError):
+    """An HTTP response error where the JSON is decoded as OData V4 error format.
+
+    http://docs.oasis-open.org/odata/odata-json-format/v4.0/os/odata-json-format-v4.0-os.html#_Toc372793091
+
+    :param ~azure.core.rest.HttpResponse response: The response object.
+    :ivar dict odata_json: The parsed JSON body as attribute for convenience.
+    :ivar str ~.code: Its value is a service-defined error code.
+     This code serves as a sub-status for the HTTP error code specified in the response.
+    :ivar str message: Human-readable, language-dependent representation of the error.
+    :ivar str target: The target of the particular error (for example, the name of the property in error).
+     This field is optional and may be None.
+    :ivar list[ODataV4Format] details: Array of ODataV4Format instances that MUST contain name/value pairs
+     for code and message, and MAY contain a name/value pair for target, as described above.
+    :ivar dict innererror: An object. The contents of this object are service-defined.
+     Usually this object contains information that will help debug the service.
+    """
+
+    _ERROR_FORMAT = ODataV4Format
+
+    def __init__(self, response: _HttpResponseCommonAPI, **kwargs: Any) -> None:
+        # Ensure field are declared, whatever can happen afterwards
+        self.odata_json: Optional[Dict[str, Any]] = None
+        try:
+            self.odata_json = json.loads(response.text())
+            odata_message = self.odata_json.setdefault("error", {}).get("message")
+        except Exception:  # pylint: disable=broad-except
+            # If the body is not JSON valid, just stop now
+            odata_message = None
+
+        self.code: Optional[str] = None
+        message: Optional[str] = kwargs.get("message", odata_message)
+        self.target: Optional[str] = None
+        self.details: Optional[List[Any]] = []
+        self.innererror: Optional[Mapping[str, Any]] = {}
+
+        if message and "message" not in kwargs:
+            kwargs["message"] = message
+
+        super(ODataV4Error, self).__init__(response=response, **kwargs)
+
+        self._error_format: Optional[Union[str, ODataV4Format]] = None
+        if self.odata_json:
+            try:
+                error_node = self.odata_json["error"]
+                self._error_format = self._ERROR_FORMAT(error_node)
+                self.__dict__.update({k: v for k, v in self._error_format.__dict__.items() if v is not None})
+            except Exception:  # pylint: disable=broad-except
+                _LOGGER.info("Received error message was not valid OdataV4 format.")
+                self._error_format = "JSON was invalid for format " + str(self._ERROR_FORMAT)
+
+    def __str__(self) -> str:
+        if self._error_format:
+            return str(self._error_format)
+        return super(ODataV4Error, self).__str__()
+
+
+class StreamConsumedError(AzureError):
+    """Error thrown if you try to access the stream of a response once consumed.
+
+    It is thrown if you try to read / stream an ~azure.core.rest.HttpResponse or
+    ~azure.core.rest.AsyncHttpResponse once the response's stream has been consumed.
+
+    :param response: The response that triggered the exception.
+    :type response: ~azure.core.rest.HttpResponse or ~azure.core.rest.AsyncHttpResponse
+    """
+
+    def __init__(self, response: _HttpResponseCommonAPI) -> None:
+        message = (
+            "You are attempting to read or stream the content from request {}. "
+            "You have likely already consumed this stream, so it can not be accessed anymore.".format(response.request)
+        )
+        super(StreamConsumedError, self).__init__(message)
+
+
+class StreamClosedError(AzureError):
+    """Error thrown if you try to access the stream of a response once closed.
+
+    It is thrown if you try to read / stream an ~azure.core.rest.HttpResponse or
+    ~azure.core.rest.AsyncHttpResponse once the response's stream has been closed.
+
+    :param response: The response that triggered the exception.
+    :type response: ~azure.core.rest.HttpResponse or ~azure.core.rest.AsyncHttpResponse
+    """
+
+    def __init__(self, response: _HttpResponseCommonAPI) -> None:
+        message = (
+            "The content for response from request {} can no longer be read or streamed, since the "
+            "response has already been closed.".format(response.request)
+        )
+        super(StreamClosedError, self).__init__(message)
+
+
+class ResponseNotReadError(AzureError):
+    """Error thrown if you try to access a response's content without reading first.
+
+    It is thrown if you try to access an ~azure.core.rest.HttpResponse or
+    ~azure.core.rest.AsyncHttpResponse's content without first reading the response's bytes in first.
+
+    :param response: The response that triggered the exception.
+    :type response: ~azure.core.rest.HttpResponse or ~azure.core.rest.AsyncHttpResponse
+    """
+
+    def __init__(self, response: _HttpResponseCommonAPI) -> None:
+        message = (
+            "You have not read in the bytes for the response from request {}. "
+            "Call .read() on the response first.".format(response.request)
+        )
+        super(ResponseNotReadError, self).__init__(message)
+
+
+class SerializationError(ValueError):
+    """Raised if an error is encountered during serialization."""
+
+
+class DeserializationError(ValueError):
+    """Raised if an error is encountered during deserialization."""

pgsql/pgAdmin 4/python/Lib/site-packages/azure/core/messaging.py

@@ -0,0 +1,229 @@
+# coding=utf-8
+# --------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+# --------------------------------------------------------------------------
+from __future__ import annotations
+import uuid
+from base64 import b64decode
+from datetime import datetime
+from typing import cast, Union, Any, Optional, Dict, TypeVar, Generic
+from .utils._utils import _convert_to_isoformat, TZ_UTC
+from .utils._messaging_shared import _get_json_content
+from .serialization import NULL
+
+
+__all__ = ["CloudEvent"]
+
+
+_Unset: Any = object()
+
+DataType = TypeVar("DataType")
+
+
+class CloudEvent(Generic[DataType]):  # pylint:disable=too-many-instance-attributes
+    """Properties of the CloudEvent 1.0 Schema.
+    All required parameters must be populated in order to send to Azure.
+
+    :param source: Required. Identifies the context in which an event happened. The combination of id and source must
+     be unique for each distinct event. If publishing to a domain topic, source must be the domain topic name.
+    :type source: str
+    :param type: Required. Type of event related to the originating occurrence.
+    :type type: str
+    :keyword specversion: Optional. The version of the CloudEvent spec. Defaults to "1.0"
+    :paramtype specversion: str
+    :keyword data: Optional. Event data specific to the event type.
+    :paramtype data: object
+    :keyword time: Optional. The time (in UTC) the event was generated.
+    :paramtype time: ~datetime.datetime
+    :keyword dataschema: Optional. Identifies the schema that data adheres to.
+    :paramtype dataschema: str
+    :keyword datacontenttype: Optional. Content type of data value.
+    :paramtype datacontenttype: str
+    :keyword subject: Optional. This describes the subject of the event in the context of the event producer
+     (identified by source).
+    :paramtype subject: str
+    :keyword id: Optional. An identifier for the event. The combination of id and source must be
+     unique for each distinct event. If not provided, a random UUID will be generated and used.
+    :paramtype id: Optional[str]
+    :keyword extensions: Optional. A CloudEvent MAY include any number of additional context attributes
+     with distinct names represented as key - value pairs. Each extension must be alphanumeric, lower cased
+     and must not exceed the length of 20 characters.
+    :paramtype extensions: Optional[dict]
+    """
+
+    source: str
+    """Identifies the context in which an event happened. The combination of id and source must
+       be unique for each distinct event. If publishing to a domain topic, source must be the domain topic name."""
+
+    type: str  # pylint: disable=redefined-builtin
+    """Type of event related to the originating occurrence."""
+
+    specversion: str = "1.0"
+    """The version of the CloudEvent spec. Defaults to "1.0" """
+
+    id: str  # pylint: disable=redefined-builtin
+    """An identifier for the event. The combination of id and source must be
+       unique for each distinct event. If not provided, a random UUID will be generated and used."""
+
+    data: Optional[DataType]
+    """Event data specific to the event type."""
+
+    time: Optional[datetime]
+    """The time (in UTC) the event was generated."""
+
+    dataschema: Optional[str]
+    """Identifies the schema that data adheres to."""
+
+    datacontenttype: Optional[str]
+    """Content type of data value."""
+
+    subject: Optional[str]
+    """This describes the subject of the event in the context of the event producer
+       (identified by source)"""
+
+    extensions: Optional[Dict[str, Any]]
+    """A CloudEvent MAY include any number of additional context attributes
+       with distinct names represented as key - value pairs. Each extension must be alphanumeric, lower cased
+       and must not exceed the length of 20 characters."""
+
+    def __init__(
+        self,
+        source: str,
+        type: str,  # pylint: disable=redefined-builtin
+        *,
+        specversion: Optional[str] = None,
+        id: Optional[str] = None,  # pylint: disable=redefined-builtin
+        time: Optional[datetime] = _Unset,
+        datacontenttype: Optional[str] = None,
+        dataschema: Optional[str] = None,
+        subject: Optional[str] = None,
+        data: Optional[DataType] = None,
+        extensions: Optional[Dict[str, Any]] = None,
+        **kwargs: Any,
+    ) -> None:
+        self.source: str = source
+        self.type: str = type
+
+        if specversion:
+            self.specversion: str = specversion
+        self.id: str = id if id else str(uuid.uuid4())
+
+        self.time: Optional[datetime]
+        if time is _Unset:
+            self.time = datetime.now(TZ_UTC)
+        else:
+            self.time = time
+
+        self.datacontenttype: Optional[str] = datacontenttype
+        self.dataschema: Optional[str] = dataschema
+        self.subject: Optional[str] = subject
+        self.data: Optional[DataType] = data
+
+        self.extensions: Optional[Dict[str, Any]] = extensions
+        if self.extensions:
+            for key in self.extensions.keys():
+                if not key.islower() or not key.isalnum():
+                    raise ValueError("Extension attributes should be lower cased and alphanumeric.")
+
+        if kwargs:
+            remaining = ", ".join(kwargs.keys())
+            raise ValueError(
+                f"Unexpected keyword arguments {remaining}. "
+                + "Any extension attributes must be passed explicitly using extensions."
+            )
+
+    def __repr__(self) -> str:
+        return "CloudEvent(source={}, type={}, specversion={}, id={}, time={})".format(
+            self.source, self.type, self.specversion, self.id, self.time
+        )[:1024]
+
+    @classmethod
+    def from_dict(cls, event: Dict[str, Any]) -> CloudEvent[DataType]:
+        """Returns the deserialized CloudEvent object when a dict is provided.
+
+        :param event: The dict representation of the event which needs to be deserialized.
+        :type event: dict
+        :rtype: CloudEvent
+        :return: The deserialized CloudEvent object.
+        """
+        kwargs: Dict[str, Any] = {}
+        reserved_attr = [
+            "data",
+            "data_base64",
+            "id",
+            "source",
+            "type",
+            "specversion",
+            "time",
+            "dataschema",
+            "datacontenttype",
+            "subject",
+        ]
+
+        if "data" in event and "data_base64" in event:
+            raise ValueError("Invalid input. Only one of data and data_base64 must be present.")
+
+        if "data" in event:
+            data = event.get("data")
+            kwargs["data"] = data if data is not None else NULL
+        elif "data_base64" in event:
+            kwargs["data"] = b64decode(cast(Union[str, bytes], event.get("data_base64")))
+
+        for item in ["datacontenttype", "dataschema", "subject"]:
+            if item in event:
+                val = event.get(item)
+                kwargs[item] = val if val is not None else NULL
+
+        extensions = {k: v for k, v in event.items() if k not in reserved_attr}
+        if extensions:
+            kwargs["extensions"] = extensions
+
+        try:
+            event_obj = cls(
+                id=event.get("id"),
+                source=event["source"],
+                type=event["type"],
+                specversion=event.get("specversion"),
+                time=_convert_to_isoformat(event.get("time")),
+                **kwargs,
+            )
+        except KeyError as err:
+            # https://github.com/cloudevents/spec Cloud event spec requires source, type,
+            # specversion. We autopopulate everything other than source, type.
+            # So we will assume the KeyError is coming from source/type access.
+            if all(
+                key in event
+                for key in (
+                    "subject",
+                    "eventType",
+                    "data",
+                    "dataVersion",
+                    "id",
+                    "eventTime",
+                )
+            ):
+                raise ValueError(
+                    "The event you are trying to parse follows the Eventgrid Schema. You can parse"
+                    + " EventGrid events using EventGridEvent.from_dict method in the azure-eventgrid library."
+                ) from err
+            raise ValueError(
+                "The event does not conform to the cloud event spec https://github.com/cloudevents/spec."
+                + " The `source` and `type` params are required."
+            ) from err
+        return event_obj
+
+    @classmethod
+    def from_json(cls, event: Any) -> CloudEvent[DataType]:
+        """Returns the deserialized CloudEvent object when a json payload is provided.
+
+        :param event: The json string that should be converted into a CloudEvent. This can also be
+         a storage QueueMessage, eventhub's EventData or ServiceBusMessage
+        :type event: object
+        :rtype: CloudEvent
+        :return: The deserialized CloudEvent object.
+        :raises ValueError: If the provided JSON is invalid.
+        """
+        dict_event = _get_json_content(event)
+        return CloudEvent.from_dict(dict_event)

pgsql/pgAdmin 4/python/Lib/site-packages/azure/core/paging.py

@@ -0,0 +1,125 @@
+# --------------------------------------------------------------------------
+#
+# Copyright (c) Microsoft Corporation. All rights reserved.
+#
+# The MIT License (MIT)
+#
+# 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.
+#
+# --------------------------------------------------------------------------
+import itertools
+from typing import (  # pylint: disable=unused-import
+    Callable,
+    Optional,
+    TypeVar,
+    Iterator,
+    Iterable,
+    Tuple,
+    Any,
+)
+import logging
+
+from .exceptions import AzureError
+
+
+_LOGGER = logging.getLogger(__name__)
+
+ReturnType = TypeVar("ReturnType")
+ResponseType = TypeVar("ResponseType")
+
+
+class PageIterator(Iterator[Iterator[ReturnType]]):
+    def __init__(
+        self,
+        get_next: Callable[[Optional[str]], ResponseType],
+        extract_data: Callable[[ResponseType], Tuple[str, Iterable[ReturnType]]],
+        continuation_token: Optional[str] = None,
+    ):
+        """Return an iterator of pages.
+
+        :param get_next: Callable that take the continuation token and return a HTTP response
+        :param extract_data: Callable that take an HTTP response and return a tuple continuation token,
+         list of ReturnType
+        :param str continuation_token: The continuation token needed by get_next
+        """
+        self._get_next = get_next
+        self._extract_data = extract_data
+        self.continuation_token = continuation_token
+        self._did_a_call_already = False
+        self._response: Optional[ResponseType] = None
+        self._current_page: Optional[Iterable[ReturnType]] = None
+
+    def __iter__(self) -> Iterator[Iterator[ReturnType]]:
+        return self
+
+    def __next__(self) -> Iterator[ReturnType]:
+        if self.continuation_token is None and self._did_a_call_already:
+            raise StopIteration("End of paging")
+        try:
+            self._response = self._get_next(self.continuation_token)
+        except AzureError as error:
+            if not error.continuation_token:
+                error.continuation_token = self.continuation_token
+            raise
+
+        self._did_a_call_already = True
+
+        self.continuation_token, self._current_page = self._extract_data(self._response)
+
+        return iter(self._current_page)
+
+    next = __next__  # Python 2 compatibility. Can't be removed as some people are using ".next()" even in Py3
+
+
+class ItemPaged(Iterator[ReturnType]):
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        """Return an iterator of items.
+
+        args and kwargs will be passed to the PageIterator constructor directly,
+        except page_iterator_class
+        """
+        self._args = args
+        self._kwargs = kwargs
+        self._page_iterator: Optional[Iterator[ReturnType]] = None
+        self._page_iterator_class = self._kwargs.pop("page_iterator_class", PageIterator)
+
+    def by_page(self, continuation_token: Optional[str] = None) -> Iterator[Iterator[ReturnType]]:
+        """Get an iterator of pages of objects, instead of an iterator of objects.
+
+        :param str continuation_token:
+            An opaque continuation token. This value can be retrieved from the
+            continuation_token field of a previous generator object. If specified,
+            this generator will begin returning results from this point.
+        :returns: An iterator of pages (themselves iterator of objects)
+        :rtype: iterator[iterator[ReturnType]]
+        """
+        return self._page_iterator_class(continuation_token=continuation_token, *self._args, **self._kwargs)
+
+    def __repr__(self) -> str:
+        return "<iterator object azure.core.paging.ItemPaged at {}>".format(hex(id(self)))
+
+    def __iter__(self) -> Iterator[ReturnType]:
+        return self
+
+    def __next__(self) -> ReturnType:
+        if self._page_iterator is None:
+            self._page_iterator = itertools.chain.from_iterable(self.by_page())
+        return next(self._page_iterator)
+
+    next = __next__  # Python 2 compatibility. Can't be removed as some people are using ".next()" even in Py3

pgsql/pgAdmin 4/python/Lib/site-packages/azure/core/serialization.py

@@ -0,0 +1,125 @@
+# coding=utf-8
+# --------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+# --------------------------------------------------------------------------
+import base64
+from json import JSONEncoder
+from typing import Union, cast, Any
+from datetime import datetime, date, time, timedelta
+from datetime import timezone
+
+
+__all__ = ["NULL", "AzureJSONEncoder"]
+TZ_UTC = timezone.utc
+
+
+class _Null:
+    """To create a Falsy object"""
+
+    def __bool__(self) -> bool:
+        return False
+
+
+NULL = _Null()
+"""
+A falsy sentinel object which is supposed to be used to specify attributes
+with no data. This gets serialized to `null` on the wire.
+"""
+
+
+def _timedelta_as_isostr(td: timedelta) -> str:
+    """Converts a datetime.timedelta object into an ISO 8601 formatted string, e.g. 'P4DT12H30M05S'
+
+    Function adapted from the Tin Can Python project: https://github.com/RusticiSoftware/TinCanPython
+
+    :param td: The timedelta object to convert
+    :type td: datetime.timedelta
+    :return: An ISO 8601 formatted string representing the timedelta object
+    :rtype: str
+    """
+
+    # Split seconds to larger units
+    seconds = td.total_seconds()
+    minutes, seconds = divmod(seconds, 60)
+    hours, minutes = divmod(minutes, 60)
+    days, hours = divmod(hours, 24)
+
+    days, hours, minutes = list(map(int, (days, hours, minutes)))
+    seconds = round(seconds, 6)
+
+    # Build date
+    date_str = ""
+    if days:
+        date_str = "%sD" % days
+
+    # Build time
+    time_str = "T"
+
+    # Hours
+    bigger_exists = date_str or hours
+    if bigger_exists:
+        time_str += "{:02}H".format(hours)
+
+    # Minutes
+    bigger_exists = bigger_exists or minutes
+    if bigger_exists:
+        time_str += "{:02}M".format(minutes)
+
+    # Seconds
+    try:
+        if seconds.is_integer():
+            seconds_string = "{:02}".format(int(seconds))
+        else:
+            # 9 chars long w/ leading 0, 6 digits after decimal
+            seconds_string = "%09.6f" % seconds
+            # Remove trailing zeros
+            seconds_string = seconds_string.rstrip("0")
+    except AttributeError:  # int.is_integer() raises
+        seconds_string = "{:02}".format(seconds)
+
+    time_str += "{}S".format(seconds_string)
+
+    return "P" + date_str + time_str
+
+
+def _datetime_as_isostr(dt: Union[datetime, date, time, timedelta]) -> str:
+    """Converts a datetime.(datetime|date|time|timedelta) object into an ISO 8601 formatted string.
+
+    :param dt: The datetime object to convert
+    :type dt: datetime.datetime or datetime.date or datetime.time or datetime.timedelta
+    :return: An ISO 8601 formatted string representing the datetime object
+    :rtype: str
+    """
+    # First try datetime.datetime
+    if hasattr(dt, "year") and hasattr(dt, "hour"):
+        dt = cast(datetime, dt)
+        # astimezone() fails for naive times in Python 2.7, so make make sure dt is aware (tzinfo is set)
+        if not dt.tzinfo:
+            iso_formatted = dt.replace(tzinfo=TZ_UTC).isoformat()
+        else:
+            iso_formatted = dt.astimezone(TZ_UTC).isoformat()
+        # Replace the trailing "+00:00" UTC offset with "Z" (RFC 3339: https://www.ietf.org/rfc/rfc3339.txt)
+        return iso_formatted.replace("+00:00", "Z")
+    # Next try datetime.date or datetime.time
+    try:
+        dt = cast(Union[date, time], dt)
+        return dt.isoformat()
+    # Last, try datetime.timedelta
+    except AttributeError:
+        dt = cast(timedelta, dt)
+        return _timedelta_as_isostr(dt)
+
+
+class AzureJSONEncoder(JSONEncoder):
+    """A JSON encoder that's capable of serializing datetime objects and bytes."""
+
+    def default(self, o: Any) -> Any:  # pylint: disable=too-many-return-statements
+        if isinstance(o, (bytes, bytearray)):
+            return base64.b64encode(o).decode()
+        try:
+            return _datetime_as_isostr(o)
+        except AttributeError:
+            pass
+        return super(AzureJSONEncoder, self).default(o)

pgsql/pgAdmin 4/python/Lib/site-packages/azure/core/settings.py

@@ -0,0 +1,490 @@
+# --------------------------------------------------------------------------
+#
+# Copyright (c) Microsoft Corporation. All rights reserved.
+#
+# The MIT License (MIT)
+#
+# 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.
+#
+# --------------------------------------------------------------------------
+"""Provide access to settings for globally used Azure configuration values.
+"""
+from __future__ import annotations
+from collections import namedtuple
+from enum import Enum
+import logging
+import os
+import sys
+from typing import Type, Optional, Callable, Union, Dict, Any, TypeVar, Tuple, Generic, Mapping, List
+from azure.core.tracing import AbstractSpan
+
+ValidInputType = TypeVar("ValidInputType")
+ValueType = TypeVar("ValueType")
+
+
+__all__ = ("settings", "Settings")
+
+
+# https://www.python.org/dev/peps/pep-0484/#support-for-singleton-types-in-unions
+class _Unset(Enum):
+    token = 0
+
+
+_unset = _Unset.token
+
+
+def convert_bool(value: Union[str, bool]) -> bool:
+    """Convert a string to True or False
+
+    If a boolean is passed in, it is returned as-is. Otherwise the function
+    maps the following strings, ignoring case:
+
+    * "yes", "1", "on" -> True
+    " "no", "0", "off" -> False
+
+    :param value: the value to convert
+    :type value: str or bool
+    :returns: A boolean value matching the intent of the input
+    :rtype: bool
+    :raises ValueError: If conversion to bool fails
+
+    """
+    if isinstance(value, bool):
+        return value
+    val = value.lower()
+    if val in ["yes", "1", "on", "true", "True"]:
+        return True
+    if val in ["no", "0", "off", "false", "False"]:
+        return False
+    raise ValueError("Cannot convert {} to boolean value".format(value))
+
+
+_levels = {
+    "CRITICAL": logging.CRITICAL,
+    "ERROR": logging.ERROR,
+    "WARNING": logging.WARNING,
+    "INFO": logging.INFO,
+    "DEBUG": logging.DEBUG,
+}
+
+
+def convert_logging(value: Union[str, int]) -> int:
+    """Convert a string to a Python logging level
+
+    If a log level is passed in, it is returned as-is. Otherwise the function
+    understands the following strings, ignoring case:
+
+    * "critical"
+    * "error"
+    * "warning"
+    * "info"
+    * "debug"
+
+    :param value: the value to convert
+    :type value: str or int
+    :returns: A log level as an int. See the logging module for details.
+    :rtype: int
+    :raises ValueError: If conversion to log level fails
+
+    """
+    if isinstance(value, int):
+        # If it's an int, return it. We don't need to check if it's in _levels, as custom int levels are allowed.
+        # https://docs.python.org/3/library/logging.html#levels
+        return value
+    val = value.upper()
+    level = _levels.get(val)
+    if not level:
+        raise ValueError("Cannot convert {} to log level, valid values are: {}".format(value, ", ".join(_levels)))
+    return level
+
+
+def _get_opencensus_span() -> Optional[Type[AbstractSpan]]:
+    """Returns the OpenCensusSpan if the opencensus tracing plugin is installed else returns None.
+
+    :rtype: type[AbstractSpan] or None
+    :returns: OpenCensusSpan type or None
+    """
+    try:
+        from azure.core.tracing.ext.opencensus_span import (  # pylint:disable=redefined-outer-name
+            OpenCensusSpan,
+        )
+
+        return OpenCensusSpan
+    except ImportError:
+        return None
+
+
+def _get_opentelemetry_span() -> Optional[Type[AbstractSpan]]:
+    """Returns the OpenTelemetrySpan if the opentelemetry tracing plugin is installed else returns None.
+
+    :rtype: type[AbstractSpan] or None
+    :returns: OpenTelemetrySpan type or None
+    """
+    try:
+        from azure.core.tracing.ext.opentelemetry_span import (  # pylint:disable=redefined-outer-name
+            OpenTelemetrySpan,
+        )
+
+        return OpenTelemetrySpan
+    except ImportError:
+        return None
+
+
+def _get_opencensus_span_if_opencensus_is_imported() -> Optional[Type[AbstractSpan]]:
+    if "opencensus" not in sys.modules:
+        return None
+    return _get_opencensus_span()
+
+
+def _get_opentelemetry_span_if_opentelemetry_is_imported() -> Optional[Type[AbstractSpan]]:
+    if "opentelemetry" not in sys.modules:
+        return None
+    return _get_opentelemetry_span()
+
+
+_tracing_implementation_dict: Dict[str, Callable[[], Optional[Type[AbstractSpan]]]] = {
+    "opencensus": _get_opencensus_span,
+    "opentelemetry": _get_opentelemetry_span,
+}
+
+
+def convert_tracing_impl(value: Optional[Union[str, Type[AbstractSpan]]]) -> Optional[Type[AbstractSpan]]:
+    """Convert a string to AbstractSpan
+
+    If a AbstractSpan is passed in, it is returned as-is. Otherwise the function
+    understands the following strings, ignoring case:
+
+    * "opencensus"
+    * "opentelemetry"
+
+    :param value: the value to convert
+    :type value: string
+    :returns: AbstractSpan
+    :raises ValueError: If conversion to AbstractSpan fails
+
+    """
+    if value is None:
+        return (
+            _get_opencensus_span_if_opencensus_is_imported() or _get_opentelemetry_span_if_opentelemetry_is_imported()
+        )
+
+    if not isinstance(value, str):
+        return value
+
+    value = value.lower()
+    get_wrapper_class = _tracing_implementation_dict.get(value, lambda: _unset)
+    wrapper_class: Optional[Union[_Unset, Type[AbstractSpan]]] = get_wrapper_class()
+    if wrapper_class is _unset:
+        raise ValueError(
+            "Cannot convert {} to AbstractSpan, valid values are: {}".format(
+                value, ", ".join(_tracing_implementation_dict)
+            )
+        )
+    return wrapper_class
+
+
+class PrioritizedSetting(Generic[ValidInputType, ValueType]):
+    """Return a value for a global setting according to configuration precedence.
+
+    The following methods are searched in order for the setting:
+
+    4. immediate values
+    3. previously user-set value
+    2. environment variable
+    1. system setting
+    0. implicit default
+
+    If a value cannot be determined, a RuntimeError is raised.
+
+    The ``env_var`` argument specifies the name of an environment to check for
+    setting values, e.g. ``"AZURE_LOG_LEVEL"``.
+    If a ``convert`` function is provided, the result will be converted before being used.
+
+    The optional ``system_hook`` can be used to specify a function that will
+    attempt to look up a value for the setting from system-wide configurations.
+    If a ``convert`` function is provided, the hook result will be converted before being used.
+
+    The optional ``default`` argument specified an implicit default value for
+    the setting that is returned if no other methods provide a value. If a ``convert`` function is provided,
+    ``default`` will be converted before being used.
+
+    A ``convert`` argument may be provided to convert values before they are
+    returned. For instance to concert log levels in environment variables
+    to ``logging`` module values. If a ``convert`` function is provided, it must support
+    str as valid input type.
+
+    :param str name: the name of the setting
+    :param str env_var: the name of an environment variable to check for the setting
+    :param callable system_hook: a function that will attempt to look up a value for the setting
+    :param default: an implicit default value for the setting
+    :type default: any
+    :param callable convert: a function to convert values before they are returned
+    """
+
+    def __init__(
+        self,
+        name: str,
+        env_var: Optional[str] = None,
+        system_hook: Optional[Callable[[], ValidInputType]] = None,
+        default: Union[ValidInputType, _Unset] = _unset,
+        convert: Optional[Callable[[Union[ValidInputType, str]], ValueType]] = None,
+    ):
+
+        self._name = name
+        self._env_var = env_var
+        self._system_hook = system_hook
+        self._default = default
+        noop_convert: Callable[[Any], Any] = lambda x: x
+        self._convert: Callable[[Union[ValidInputType, str]], ValueType] = convert if convert else noop_convert
+        self._user_value: Union[ValidInputType, _Unset] = _unset
+
+    def __repr__(self) -> str:
+        return "PrioritizedSetting(%r)" % self._name
+
+    def __call__(self, value: Optional[ValidInputType] = None) -> ValueType:
+        """Return the setting value according to the standard precedence.
+
+        :param value: value
+        :type value: str or int or float or None
+        :returns: the value of the setting
+        :rtype: str or int or float
+        :raises: RuntimeError if no value can be determined
+        """
+
+        # 4. immediate values
+        if value is not None:
+            return self._convert(value)
+
+        # 3. previously user-set value
+        if not isinstance(self._user_value, _Unset):
+            return self._convert(self._user_value)
+
+        # 2. environment variable
+        if self._env_var and self._env_var in os.environ:
+            return self._convert(os.environ[self._env_var])
+
+        # 1. system setting
+        if self._system_hook:
+            return self._convert(self._system_hook())
+
+        # 0. implicit default
+        if not isinstance(self._default, _Unset):
+            return self._convert(self._default)
+
+        raise RuntimeError("No configured value found for setting %r" % self._name)
+
+    def __get__(self, instance: Any, owner: Optional[Any] = None) -> PrioritizedSetting[ValidInputType, ValueType]:
+        return self
+
+    def __set__(self, instance: Any, value: ValidInputType) -> None:
+        self.set_value(value)
+
+    def set_value(self, value: ValidInputType) -> None:
+        """Specify a value for this setting programmatically.
+
+        A value set this way takes precedence over all other methods except
+        immediate values.
+
+        :param value: a user-set value for this setting
+        :type value: str or int or float
+        """
+        self._user_value = value
+
+    def unset_value(self) -> None:
+        """Unset the previous user value such that the priority is reset."""
+        self._user_value = _unset
+
+    @property
+    def env_var(self) -> Optional[str]:
+        return self._env_var
+
+    @property
+    def default(self) -> Union[ValidInputType, _Unset]:
+        return self._default
+
+
+class Settings:
+    """Settings for globally used Azure configuration values.
+
+    You probably don't want to create an instance of this class, but call the singleton instance:
+
+    .. code-block:: python
+
+        from azure.core.settings import settings
+        settings.log_level = log_level = logging.DEBUG
+
+    The following methods are searched in order for a setting:
+
+    4. immediate values
+    3. previously user-set value
+    2. environment variable
+    1. system setting
+    0. implicit default
+
+    An implicit default is (optionally) defined by the setting attribute itself.
+
+    A system setting value can be obtained from registries or other OS configuration
+    for settings that support that method.
+
+    An environment variable value is obtained from ``os.environ``
+
+    User-set values many be specified by assigning to the attribute:
+
+    .. code-block:: python
+
+        settings.log_level = log_level = logging.DEBUG
+
+    Immediate values are (optionally) provided when the setting is retrieved:
+
+    .. code-block:: python
+
+        settings.log_level(logging.DEBUG())
+
+    Immediate values are most often useful to provide from optional arguments
+    to client functions. If the argument value is not None, it will be returned
+    as-is. Otherwise, the setting searches other methods according to the
+    precedence rules.
+
+    Immutable configuration snapshots can be created with the following methods:
+
+    * settings.defaults returns the base defaultsvalues , ignoring any environment or system
+      or user settings
+
+    * settings.current returns the current computation of settings including prioritization
+      of configuration sources, unless defaults_only is set to True (in which case the result
+      is identical to settings.defaults)
+
+    * settings.config can be called with specific values to override what settings.current
+      would provide
+
+    .. code-block:: python
+
+        # return current settings with log level overridden
+        settings.config(log_level=logging.DEBUG)
+
+    :cvar log_level: a log level to use across all Azure client SDKs (AZURE_LOG_LEVEL)
+    :type log_level: PrioritizedSetting
+    :cvar tracing_enabled: Whether tracing should be enabled across Azure SDKs (AZURE_TRACING_ENABLED)
+    :type tracing_enabled: PrioritizedSetting
+    :cvar tracing_implementation: The tracing implementation to use (AZURE_SDK_TRACING_IMPLEMENTATION)
+    :type tracing_implementation: PrioritizedSetting
+
+    :Example:
+
+    >>> import logging
+    >>> from azure.core.settings import settings
+    >>> settings.log_level = logging.DEBUG
+    >>> settings.log_level()
+    10
+
+    >>> settings.log_level(logging.WARN)
+    30
+
+    """
+
+    def __init__(self) -> None:
+        self._defaults_only: bool = False
+
+    @property
+    def defaults_only(self) -> bool:
+        """Whether to ignore environment and system settings and return only base default values.
+
+        :rtype: bool
+        :returns: Whether to ignore environment and system settings and return only base default values.
+        """
+        return self._defaults_only
+
+    @defaults_only.setter
+    def defaults_only(self, value: bool) -> None:
+        self._defaults_only = value
+
+    @property
+    def defaults(self) -> Tuple[Any, ...]:
+        """Return implicit default values for all settings, ignoring environment and system.
+
+        :rtype: namedtuple
+        :returns: The implicit default values for all settings
+        """
+        props = {k: v.default for (k, v) in self.__class__.__dict__.items() if isinstance(v, PrioritizedSetting)}
+        return self._config(props)
+
+    @property
+    def current(self) -> Tuple[Any, ...]:
+        """Return the current values for all settings.
+
+        :rtype: namedtuple
+        :returns: The current values for all settings
+        """
+        if self.defaults_only:
+            return self.defaults
+        return self.config()
+
+    def config(self, **kwargs: Any) -> Tuple[Any, ...]:
+        """Return the currently computed settings, with values overridden by parameter values.
+
+        :rtype: namedtuple
+        :returns: The current values for all settings, with values overridden by parameter values
+
+        Examples:
+
+        .. code-block:: python
+
+           # return current settings with log level overridden
+           settings.config(log_level=logging.DEBUG)
+
+        """
+        props = {k: v() for (k, v) in self.__class__.__dict__.items() if isinstance(v, PrioritizedSetting)}
+        props.update(kwargs)
+        return self._config(props)
+
+    def _config(self, props: Mapping[str, Any]) -> Tuple[Any, ...]:
+        keys: List[str] = list(props.keys())
+        # https://github.com/python/mypy/issues/4414
+        Config = namedtuple("Config", keys)  # type: ignore
+        return Config(**props)
+
+    log_level: PrioritizedSetting[Union[str, int], int] = PrioritizedSetting(
+        "log_level",
+        env_var="AZURE_LOG_LEVEL",
+        convert=convert_logging,
+        default=logging.INFO,
+    )
+
+    tracing_enabled: PrioritizedSetting[Union[str, bool], bool] = PrioritizedSetting(
+        "tracing_enabled",
+        env_var="AZURE_TRACING_ENABLED",
+        convert=convert_bool,
+        default=False,
+    )
+
+    tracing_implementation: PrioritizedSetting[
+        Optional[Union[str, Type[AbstractSpan]]], Optional[Type[AbstractSpan]]
+    ] = PrioritizedSetting(
+        "tracing_implementation",
+        env_var="AZURE_SDK_TRACING_IMPLEMENTATION",
+        convert=convert_tracing_impl,
+        default=None,
+    )
+
+
+settings: Settings = Settings()
+"""The settings unique instance.
+
+:type settings: Settings
+"""

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

@@ -0,0 +1,64 @@
+# ------------------------------------
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+# ------------------------------------
+"""Credentials for Azure SDK clients."""
+
+from ._auth_record import AuthenticationRecord
+from ._exceptions import AuthenticationRequiredError, CredentialUnavailableError
+from ._constants import AzureAuthorityHosts, KnownAuthorities
+from ._credentials import (
+    AuthorizationCodeCredential,
+    AzureDeveloperCliCredential,
+    AzureCliCredential,
+    AzurePowerShellCredential,
+    CertificateCredential,
+    ChainedTokenCredential,
+    ClientAssertionCredential,
+    ClientSecretCredential,
+    DefaultAzureCredential,
+    DeviceCodeCredential,
+    EnvironmentCredential,
+    InteractiveBrowserCredential,
+    ManagedIdentityCredential,
+    OnBehalfOfCredential,
+    SharedTokenCacheCredential,
+    UsernamePasswordCredential,
+    VisualStudioCodeCredential,
+    WorkloadIdentityCredential,
+)
+from ._persistent_cache import TokenCachePersistenceOptions
+from ._bearer_token_provider import get_bearer_token_provider
+
+
+__all__ = [
+    "AuthenticationRecord",
+    "AuthenticationRequiredError",
+    "AuthorizationCodeCredential",
+    "AzureAuthorityHosts",
+    "AzureCliCredential",
+    "AzureDeveloperCliCredential",
+    "AzurePowerShellCredential",
+    "CertificateCredential",
+    "ChainedTokenCredential",
+    "ClientAssertionCredential",
+    "ClientSecretCredential",
+    "CredentialUnavailableError",
+    "DefaultAzureCredential",
+    "DeviceCodeCredential",
+    "EnvironmentCredential",
+    "InteractiveBrowserCredential",
+    "KnownAuthorities",
+    "OnBehalfOfCredential",
+    "ManagedIdentityCredential",
+    "SharedTokenCacheCredential",
+    "TokenCachePersistenceOptions",
+    "UsernamePasswordCredential",
+    "VisualStudioCodeCredential",
+    "WorkloadIdentityCredential",
+    "get_bearer_token_provider",
+]
+
+from ._version import VERSION
+
+__version__ = VERSION

pgsql/pgAdmin 4/python/Lib/site-packages/azure/identity/_auth_record.py

@@ -0,0 +1,114 @@
+# ------------------------------------
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+# ------------------------------------
+import json
+
+
+SUPPORTED_VERSIONS = {"1.0"}
+
+
+class AuthenticationRecord:
+    """Non-secret account information for an authenticated user
+
+    This class enables :class:`DeviceCodeCredential` and :class:`InteractiveBrowserCredential` to access
+    previously cached authentication data. Applications shouldn't construct instances of this class. They should
+    instead acquire one from a credential's **authenticate** method, such as
+    :func:`InteractiveBrowserCredential.authenticate`. See the user_authentication sample for more details.
+
+    :param str tenant_id: The tenant the account should authenticate in.
+    :param str client_id: The client ID of the application which performed the original authentication.
+    :param str authority: The authority host used to authenticate the account.
+    :param str home_account_id: A unique identifier of the account.
+    :param str username: The user principal or service principal name of the account.
+    """
+
+    def __init__(self, tenant_id: str, client_id: str, authority: str, home_account_id: str, username: str) -> None:
+        self._authority = authority
+        self._client_id = client_id
+        self._home_account_id = home_account_id
+        self._tenant_id = tenant_id
+        self._username = username
+
+    @property
+    def authority(self) -> str:
+        """The authority host used to authenticate the account.
+
+        :rtype: str
+        """
+        return self._authority
+
+    @property
+    def client_id(self) -> str:
+        """The client ID of the application which performed the original authentication.
+
+        :rtype: str
+        """
+        return self._client_id
+
+    @property
+    def home_account_id(self) -> str:
+        """A unique identifier of the account.
+
+        :rtype: str
+        """
+        return self._home_account_id
+
+    @property
+    def tenant_id(self) -> str:
+        """The tenant the account should authenticate in.
+
+        :rtype: str
+        """
+        return self._tenant_id
+
+    @property
+    def username(self) -> str:
+        """The user principal or service principal name of the account.
+
+        :rtype: str
+        """
+        return self._username
+
+    @classmethod
+    def deserialize(cls, data: str) -> "AuthenticationRecord":
+        """Deserialize a record.
+
+        :param str data: A serialized record.
+        :return: The deserialized record.
+        :rtype: ~azure.identity.AuthenticationRecord
+        """
+
+        deserialized = json.loads(data)
+
+        version = deserialized.get("version")
+        if version not in SUPPORTED_VERSIONS:
+            raise ValueError(
+                'Unexpected version "{}". This package supports these versions: {}'.format(version, SUPPORTED_VERSIONS)
+            )
+
+        return cls(
+            authority=deserialized["authority"],
+            client_id=deserialized["clientId"],
+            home_account_id=deserialized["homeAccountId"],
+            tenant_id=deserialized["tenantId"],
+            username=deserialized["username"],
+        )
+
+    def serialize(self) -> str:
+        """Serialize the record.
+
+        :return: The serialized record.
+        :rtype: str
+        """
+
+        record = {
+            "authority": self._authority,
+            "clientId": self._client_id,
+            "homeAccountId": self._home_account_id,
+            "tenantId": self._tenant_id,
+            "username": self._username,
+            "version": "1.0",
+        }
+
+        return json.dumps(record)

pgsql/pgAdmin 4/python/Lib/site-packages/azure/identity/_bearer_token_provider.py

@@ -0,0 +1,46 @@
+# ------------------------------------
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+# ------------------------------------
+from typing import Callable
+
+from azure.core.credentials import TokenCredential
+from azure.core.pipeline.policies import BearerTokenCredentialPolicy
+from azure.core.pipeline import PipelineRequest, PipelineContext
+from azure.core.rest import HttpRequest
+
+
+def _make_request() -> PipelineRequest[HttpRequest]:
+    return PipelineRequest(HttpRequest("CredentialWrapper", "https://fakeurl"), PipelineContext(None))
+
+
+def get_bearer_token_provider(credential: TokenCredential, *scopes: str) -> Callable[[], str]:
+    """Returns a callable that provides a bearer token.
+
+    It can be used for instance to write code like:
+
+    .. code-block:: python
+
+        from azure.identity import DefaultAzureCredential, get_bearer_token_provider
+
+        credential = DefaultAzureCredential()
+        bearer_token_provider = get_bearer_token_provider(credential, "https://cognitiveservices.azure.com/.default")
+
+        # Usage
+        request.headers["Authorization"] = "Bearer " + bearer_token_provider()
+
+    :param credential: The credential used to authenticate the request.
+    :type credential: ~azure.core.credentials.TokenCredential
+    :param str scopes: The scopes required for the bearer token.
+    :rtype: callable
+    :return: A callable that returns a bearer token.
+    """
+
+    policy = BearerTokenCredentialPolicy(credential, *scopes)
+
+    def wrapper() -> str:
+        request = _make_request()
+        policy.on_request(request)
+        return request.http_request.headers["Authorization"][len("Bearer ") :]
+
+    return wrapper

pgsql/pgAdmin 4/python/Lib/site-packages/azure/identity/_constants.py

@@ -0,0 +1,55 @@
+# ------------------------------------
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+# ------------------------------------
+
+
+DEVELOPER_SIGN_ON_CLIENT_ID = "04b07795-8ddb-461a-bbee-02f9e1bf7b46"
+AZURE_VSCODE_CLIENT_ID = "aebc6443-996d-45c2-90f0-388ff96faa56"
+VSCODE_CREDENTIALS_SECTION = "VS Code Azure"
+DEFAULT_REFRESH_OFFSET = 300
+DEFAULT_TOKEN_REFRESH_RETRY_DELAY = 30
+
+CACHE_NON_CAE_SUFFIX = ".nocae"  # cspell:disable-line
+CACHE_CAE_SUFFIX = ".cae"
+
+
+class AzureAuthorityHosts:
+    AZURE_CHINA = "login.chinacloudapi.cn"
+    AZURE_GERMANY = "login.microsoftonline.de"
+    AZURE_GOVERNMENT = "login.microsoftonline.us"
+    AZURE_PUBLIC_CLOUD = "login.microsoftonline.com"
+
+
+class KnownAuthorities(AzureAuthorityHosts):
+    """Alias of :class:`AzureAuthorityHosts`"""
+
+
+class EnvironmentVariables:
+    AZURE_CLIENT_ID = "AZURE_CLIENT_ID"
+    AZURE_CLIENT_SECRET = "AZURE_CLIENT_SECRET"
+    AZURE_TENANT_ID = "AZURE_TENANT_ID"
+    CLIENT_SECRET_VARS = (AZURE_CLIENT_ID, AZURE_CLIENT_SECRET, AZURE_TENANT_ID)
+
+    AZURE_CLIENT_CERTIFICATE_PATH = "AZURE_CLIENT_CERTIFICATE_PATH"
+    AZURE_CLIENT_CERTIFICATE_PASSWORD = "AZURE_CLIENT_CERTIFICATE_PASSWORD"
+    CERT_VARS = (AZURE_CLIENT_ID, AZURE_CLIENT_CERTIFICATE_PATH, AZURE_TENANT_ID)
+
+    AZURE_USERNAME = "AZURE_USERNAME"
+    AZURE_PASSWORD = "AZURE_PASSWORD"
+    USERNAME_PASSWORD_VARS = (AZURE_CLIENT_ID, AZURE_USERNAME, AZURE_PASSWORD)
+
+    AZURE_POD_IDENTITY_AUTHORITY_HOST = "AZURE_POD_IDENTITY_AUTHORITY_HOST"
+    IDENTITY_ENDPOINT = "IDENTITY_ENDPOINT"
+    IDENTITY_HEADER = "IDENTITY_HEADER"
+    IDENTITY_SERVER_THUMBPRINT = "IDENTITY_SERVER_THUMBPRINT"
+    IMDS_ENDPOINT = "IMDS_ENDPOINT"
+    MSI_ENDPOINT = "MSI_ENDPOINT"
+    MSI_SECRET = "MSI_SECRET"
+
+    AZURE_AUTHORITY_HOST = "AZURE_AUTHORITY_HOST"
+    AZURE_IDENTITY_DISABLE_MULTITENANTAUTH = "AZURE_IDENTITY_DISABLE_MULTITENANTAUTH"
+    AZURE_REGIONAL_AUTHORITY_NAME = "AZURE_REGIONAL_AUTHORITY_NAME"
+
+    AZURE_FEDERATED_TOKEN_FILE = "AZURE_FEDERATED_TOKEN_FILE"
+    WORKLOAD_IDENTITY_VARS = (AZURE_AUTHORITY_HOST, AZURE_TENANT_ID, AZURE_FEDERATED_TOKEN_FILE)

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

@@ -0,0 +1,67 @@
+# ------------------------------------
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+# ------------------------------------
+from enum import Enum
+from azure.core import CaseInsensitiveEnumMeta
+
+
+class RegionalAuthority(str, Enum, metaclass=CaseInsensitiveEnumMeta):
+    """Identifies a regional authority for authentication"""
+
+    #: Attempt to discover the appropriate authority. This works on some Azure hosts, such as VMs and
+    #: Azure Functions. The non-regional authority is used when discovery fails.
+    AUTO_DISCOVER_REGION = "tryautodetect"
+
+    ASIA_EAST = "eastasia"
+    ASIA_SOUTHEAST = "southeastasia"
+    AUSTRALIA_CENTRAL = "australiacentral"
+    AUSTRALIA_CENTRAL_2 = "australiacentral2"
+    AUSTRALIA_EAST = "australiaeast"
+    AUSTRALIA_SOUTHEAST = "australiasoutheast"
+    BRAZIL_SOUTH = "brazilsouth"
+    CANADA_CENTRAL = "canadacentral"
+    CANADA_EAST = "canadaeast"
+    CHINA_EAST = "chinaeast"
+    CHINA_EAST_2 = "chinaeast2"
+    CHINA_NORTH = "chinanorth"
+    CHINA_NORTH_2 = "chinanorth2"
+    EUROPE_NORTH = "northeurope"
+    EUROPE_WEST = "westeurope"
+    FRANCE_CENTRAL = "francecentral"
+    FRANCE_SOUTH = "francesouth"
+    GERMANY_CENTRAL = "germanycentral"
+    GERMANY_NORTH = "germanynorth"
+    GERMANY_NORTHEAST = "germanynortheast"
+    GERMANY_WEST_CENTRAL = "germanywestcentral"
+    GOVERNMENT_US_ARIZONA = "usgovarizona"
+    GOVERNMENT_US_DOD_CENTRAL = "usdodcentral"
+    GOVERNMENT_US_DOD_EAST = "usdodeast"
+    GOVERNMENT_US_IOWA = "usgoviowa"
+    GOVERNMENT_US_TEXAS = "usgovtexas"
+    GOVERNMENT_US_VIRGINIA = "usgovvirginia"
+    INDIA_CENTRAL = "centralindia"
+    INDIA_SOUTH = "southindia"
+    INDIA_WEST = "westindia"
+    JAPAN_EAST = "japaneast"
+    JAPAN_WEST = "japanwest"
+    KOREA_CENTRAL = "koreacentral"
+    KOREA_SOUTH = "koreasouth"
+    NORWAY_EAST = "norwayeast"
+    NORWAY_WEST = "norwaywest"
+    SOUTH_AFRICA_NORTH = "southafricanorth"
+    SOUTH_AFRICA_WEST = "southafricawest"
+    SWITZERLAND_NORTH = "switzerlandnorth"
+    SWITZERLAND_WEST = "switzerlandwest"
+    UAE_CENTRAL = "uaecentral"
+    UAE_NORTH = "uaenorth"
+    UK_SOUTH = "uksouth"
+    UK_WEST = "ukwest"
+    US_CENTRAL = "centralus"
+    US_EAST = "eastus"
+    US_EAST_2 = "eastus2"
+    US_NORTH_CENTRAL = "northcentralus"
+    US_SOUTH_CENTRAL = "southcentralus"
+    US_WEST = "westus"
+    US_WEST_2 = "westus2"
+    US_WEST_CENTRAL = "westcentralus"

pgsql/pgAdmin 4/python/Lib/site-packages/azure/identity/_exceptions.py

@@ -0,0 +1,50 @@
+# ------------------------------------
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+# ------------------------------------
+from typing import Any, Iterable, Optional
+
+from azure.core.exceptions import ClientAuthenticationError
+
+
+class CredentialUnavailableError(ClientAuthenticationError):
+    """The credential did not attempt to authenticate because required data or state is unavailable."""
+
+
+class AuthenticationRequiredError(CredentialUnavailableError):
+    """Interactive authentication is required to acquire a token.
+
+    This error is raised only by interactive user credentials configured not to automatically prompt for user
+    interaction as needed. Its properties provide additional information that may be required to authenticate. The
+    control_interactive_prompts sample demonstrates handling this error by calling a credential's "authenticate"
+    method.
+
+    :param str scopes: Scopes requested during the failed authentication
+    :param str message: An error message explaining the reason for the exception.
+    :param str claims: Additional claims required in the next authentication.
+    """
+
+    def __init__(
+        self, scopes: Iterable[str], message: Optional[str] = None, claims: Optional[str] = None, **kwargs: Any
+    ) -> None:
+        self._claims = claims
+        self._scopes = scopes
+        if not message:
+            message = "Interactive authentication is required to get a token. Call 'authenticate' to begin."
+        super(AuthenticationRequiredError, self).__init__(message=message, **kwargs)
+
+    @property
+    def scopes(self) -> Iterable[str]:
+        """Scopes requested during the failed authentication.
+
+        :rtype: ~typing.Iterable[str]
+        """
+        return self._scopes
+
+    @property
+    def claims(self) -> Optional[str]:
+        """Additional claims required in the next authentication.
+
+        :rtype: str or None
+        """
+        return self._claims

pgsql/pgAdmin 4/python/Lib/site-packages/azure/identity/_persistent_cache.py

@@ -0,0 +1,116 @@
+# ------------------------------------
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+# ------------------------------------
+import logging
+import os
+import sys
+from typing import TYPE_CHECKING, Any
+
+from ._constants import CACHE_CAE_SUFFIX, CACHE_NON_CAE_SUFFIX
+
+if TYPE_CHECKING:
+    import msal_extensions
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class TokenCachePersistenceOptions:
+    """Options for persistent token caching.
+
+    Most credentials accept an instance of this class to configure persistent token caching. The default values
+    configure a credential to use a cache shared with Microsoft developer tools and
+    :class:`~azure.identity.SharedTokenCacheCredential`. To isolate a credential's data from other applications,
+    specify a `name` for the cache.
+
+    By default, the cache is encrypted with the current platform's user data protection API, and will raise an error
+    when this is not available. To configure the cache to fall back to an unencrypted file instead of raising an
+    error, specify `allow_unencrypted_storage=True`.
+
+    .. warning:: The cache contains authentication secrets. If the cache is not encrypted, protecting it is the
+       application's responsibility. A breach of its contents will fully compromise accounts.
+
+    .. admonition:: Example:
+
+        .. literalinclude:: ../tests/test_persistent_cache.py
+            :start-after: [START snippet]
+            :end-before: [END snippet]
+            :language: python
+            :caption: Configuring a credential for persistent caching
+            :dedent: 8
+
+    :keyword str name: prefix name of the cache, used to isolate its data from other applications. Defaults to the
+        name of the cache shared by Microsoft dev tools and :class:`~azure.identity.SharedTokenCacheCredential`.
+        Additional strings may be appended to the name for further isolation.
+    :keyword bool allow_unencrypted_storage: whether the cache should fall back to storing its data in plain text when
+        encryption isn't possible. False by default. Setting this to True does not disable encryption. The cache will
+        always try to encrypt its data.
+    """
+
+    def __init__(self, *, allow_unencrypted_storage: bool = False, name: str = "msal.cache", **kwargs: Any) -> None:
+        # pylint:disable=unused-argument
+        self.allow_unencrypted_storage = allow_unencrypted_storage
+        self.name = name
+
+
+def _load_persistent_cache(
+    options: TokenCachePersistenceOptions, is_cae: bool = False
+) -> "msal_extensions.PersistedTokenCache":
+    import msal_extensions
+
+    cache_suffix = CACHE_CAE_SUFFIX if is_cae else CACHE_NON_CAE_SUFFIX
+    persistence = _get_persistence(
+        allow_unencrypted=options.allow_unencrypted_storage,
+        account_name="MSALCache",
+        cache_name=options.name + cache_suffix,
+    )
+    return msal_extensions.PersistedTokenCache(persistence)
+
+
+def _get_persistence(allow_unencrypted, account_name, cache_name):
+    # type: (bool, str, str) -> msal_extensions.persistence.BasePersistence
+    """Get an msal_extensions persistence instance for the current platform.
+
+    On Windows the cache is a file protected by the Data Protection API. On Linux and macOS the cache is stored by
+    libsecret and Keychain, respectively. On those platforms the cache uses the modified timestamp of a file on disk to
+    decide whether to reload the cache.
+
+    :param bool allow_unencrypted: when True, the cache will be kept in plaintext should encryption be impossible in the
+        current environment
+    :param str account_name: the name of the account for which the cache is storing tokens
+    :param str cache_name: the name of the cache
+    :return: an msal_extensions persistence instance
+    :rtype: ~msal_extensions.persistence.BasePersistence
+    """
+    import msal_extensions
+
+    if sys.platform.startswith("win") and "LOCALAPPDATA" in os.environ:
+        cache_location = os.path.join(os.environ["LOCALAPPDATA"], ".IdentityService", cache_name)
+        return msal_extensions.FilePersistenceWithDataProtection(cache_location)
+
+    if sys.platform.startswith("darwin"):
+        # the cache uses this file's modified timestamp to decide whether to reload
+        file_path = os.path.expanduser(os.path.join("~", ".IdentityService", cache_name))
+        return msal_extensions.KeychainPersistence(file_path, "Microsoft.Developer.IdentityService", account_name)
+
+    if sys.platform.startswith("linux"):
+        # The cache uses this file's modified timestamp to decide whether to reload. Note this path is the same
+        # as that of the plaintext fallback: a new encrypted cache will stomp an unencrypted cache.
+        file_path = os.path.expanduser(os.path.join("~", ".IdentityService", cache_name))
+        try:
+            return msal_extensions.LibsecretPersistence(
+                file_path, cache_name, {"MsalClientID": "Microsoft.Developer.IdentityService"}, label=account_name
+            )
+        except Exception as ex:  # pylint:disable=broad-except
+            _LOGGER.debug('msal-extensions is unable to encrypt a persistent cache: "%s"', ex, exc_info=True)
+            if not allow_unencrypted:
+                error = ValueError(
+                    "Cache encryption is impossible because libsecret dependencies are not installed or are unusable,"
+                    + " for example because no display is available (as in an SSH session). The chained exception has"
+                    + ' more information. Specify "allow_unencrypted_storage=True" to store the cache unencrypted'
+                    + " instead of raising this exception."
+                )
+                raise error from ex
+        return msal_extensions.FilePersistence(file_path)
+
+    raise NotImplementedError("A persistent cache is not available in this environment.")

pgsql/pgAdmin 4/python/Lib/site-packages/azure/identity/_version.py

@@ -0,0 +1,5 @@
+# ------------------------------------
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+# ------------------------------------
+VERSION = "1.15.0"

pgsql/pgAdmin 4/python/Lib/site-packages/azure/mgmt/core/__init__.py

@@ -0,0 +1,33 @@
+# --------------------------------------------------------------------------
+#
+# Copyright (c) Microsoft Corporation. All rights reserved.
+#
+# The MIT License (MIT)
+#
+# 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.
+#
+# --------------------------------------------------------------------------
+
+
+from ._version import VERSION
+from ._pipeline_client import ARMPipelineClient
+from ._async_pipeline_client import AsyncARMPipelineClient
+
+__all__ = ["ARMPipelineClient", "AsyncARMPipelineClient"]
+__version__ = VERSION

pgsql/pgAdmin 4/python/Lib/site-packages/azure/mgmt/core/_async_pipeline_client.py

@@ -0,0 +1,66 @@
+# --------------------------------------------------------------------------
+#
+# Copyright (c) Microsoft Corporation. All rights reserved.
+#
+# The MIT License (MIT)
+#
+# 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.
+#
+# --------------------------------------------------------------------------
+from collections.abc import Iterable
+from azure.core import AsyncPipelineClient
+from .policies import (
+    AsyncARMAutoResourceProviderRegistrationPolicy,
+    ARMHttpLoggingPolicy,
+)
+
+
+class AsyncARMPipelineClient(AsyncPipelineClient):
+    """A pipeline client designed for ARM explicitly.
+
+    :param str base_url: URL for the request.
+    :keyword AsyncPipeline pipeline: If omitted, a Pipeline object is created and returned.
+    :keyword list[AsyncHTTPPolicy] policies: If omitted, the standard policies of the configuration object is used.
+    :keyword per_call_policies: If specified, the policies will be added into the policy list before RetryPolicy
+    :paramtype per_call_policies: Union[AsyncHTTPPolicy, SansIOHTTPPolicy,
+        list[AsyncHTTPPolicy], list[SansIOHTTPPolicy]]
+    :keyword per_retry_policies: If specified, the policies will be added into the policy list after RetryPolicy
+    :paramtype per_retry_policies: Union[AsyncHTTPPolicy, SansIOHTTPPolicy,
+        list[AsyncHTTPPolicy], list[SansIOHTTPPolicy]]
+    :keyword AsyncHttpTransport transport: If omitted, AioHttpTransport is used for asynchronous transport.
+    """
+
+    def __init__(self, base_url, **kwargs):
+        if "policies" not in kwargs:
+            if "config" not in kwargs:
+                raise ValueError("Current implementation requires to pass 'config' if you don't pass 'policies'")
+            per_call_policies = kwargs.get("per_call_policies", [])
+            if isinstance(per_call_policies, Iterable):
+                per_call_policies.append(AsyncARMAutoResourceProviderRegistrationPolicy())
+            else:
+                per_call_policies = [
+                    per_call_policies,
+                    AsyncARMAutoResourceProviderRegistrationPolicy(),
+                ]
+            kwargs["per_call_policies"] = per_call_policies
+            config = kwargs.get("config")
+            if not config.http_logging_policy:
+                config.http_logging_policy = kwargs.get("http_logging_policy", ARMHttpLoggingPolicy(**kwargs))
+            kwargs["config"] = config
+        super(AsyncARMPipelineClient, self).__init__(base_url, **kwargs)

pgsql/pgAdmin 4/python/Lib/site-packages/azure/mgmt/core/_pipeline_client.py

@@ -0,0 +1,61 @@
+# --------------------------------------------------------------------------
+#
+# Copyright (c) Microsoft Corporation. All rights reserved.
+#
+# The MIT License (MIT)
+#
+# 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.
+#
+# --------------------------------------------------------------------------
+from collections.abc import Iterable
+from azure.core import PipelineClient
+from .policies import ARMAutoResourceProviderRegistrationPolicy, ARMHttpLoggingPolicy
+
+
+class ARMPipelineClient(PipelineClient):
+    """A pipeline client designed for ARM explicitly.
+
+    :param str base_url: URL for the request.
+    :keyword Pipeline pipeline: If omitted, a Pipeline object is created and returned.
+    :keyword list[HTTPPolicy] policies: If omitted, the standard policies of the configuration object is used.
+    :keyword per_call_policies: If specified, the policies will be added into the policy list before RetryPolicy
+    :paramtype per_call_policies: Union[HTTPPolicy, SansIOHTTPPolicy, list[HTTPPolicy], list[SansIOHTTPPolicy]]
+    :keyword per_retry_policies: If specified, the policies will be added into the policy list after RetryPolicy
+    :paramtype per_retry_policies: Union[HTTPPolicy, SansIOHTTPPolicy, list[HTTPPolicy], list[SansIOHTTPPolicy]]
+    :keyword HttpTransport transport: If omitted, RequestsTransport is used for synchronous transport.
+    """
+
+    def __init__(self, base_url, **kwargs):
+        if "policies" not in kwargs:
+            if "config" not in kwargs:
+                raise ValueError("Current implementation requires to pass 'config' if you don't pass 'policies'")
+            per_call_policies = kwargs.get("per_call_policies", [])
+            if isinstance(per_call_policies, Iterable):
+                per_call_policies.append(ARMAutoResourceProviderRegistrationPolicy())
+            else:
+                per_call_policies = [
+                    per_call_policies,
+                    ARMAutoResourceProviderRegistrationPolicy(),
+                ]
+            kwargs["per_call_policies"] = per_call_policies
+            config = kwargs.get("config")
+            if not config.http_logging_policy:
+                config.http_logging_policy = kwargs.get("http_logging_policy", ARMHttpLoggingPolicy(**kwargs))
+            kwargs["config"] = config
+        super(ARMPipelineClient, self).__init__(base_url, **kwargs)

pgsql/pgAdmin 4/python/Lib/site-packages/azure/mgmt/core/_version.py

@@ -0,0 +1,12 @@
+# coding=utf-8
+# --------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+#
+# Code generated by Microsoft (R) AutoRest Code Generator.
+# Changes may cause incorrect behavior and will be lost if the code is
+# regenerated.
+# --------------------------------------------------------------------------
+
+VERSION = "1.4.0"

pgsql/pgAdmin 4/python/Lib/site-packages/azure/mgmt/core/exceptions.py

@@ -0,0 +1,81 @@
+# --------------------------------------------------------------------------
+#
+# Copyright (c) Microsoft Corporation. All rights reserved.
+#
+# The MIT License (MIT)
+#
+# 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.
+#
+# --------------------------------------------------------------------------
+
+import json
+import logging
+
+
+from azure.core.exceptions import ODataV4Format
+
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class TypedErrorInfo:
+    """Additional info class defined in ARM specification.
+
+    https://github.com/Azure/azure-resource-manager-rpc/blob/master/v1.0/common-api-details.md#error-response-content
+    """
+
+    def __init__(self, type, info):  # pylint: disable=redefined-builtin
+        self.type = type
+        self.info = info
+
+    def __str__(self):
+        """Cloud error message."""
+        error_str = "Type: {}".format(self.type)
+        error_str += "\nInfo: {}".format(json.dumps(self.info, indent=4))
+        return error_str
+
+
+class ARMErrorFormat(ODataV4Format):
+    """Describe error format from ARM, used at the base or inside "details" node.
+
+    This format is compatible with ODataV4 format.
+    https://github.com/Azure/azure-resource-manager-rpc/blob/master/v1.0/common-api-details.md#error-response-content
+    """
+
+    def __init__(self, json_object):
+        # Parse the ODatav4 part
+        super(ARMErrorFormat, self).__init__(json_object)
+        if "error" in json_object:
+            json_object = json_object["error"]
+
+        # ARM specific annotations
+        self.additional_info = [
+            TypedErrorInfo(additional_info["type"], additional_info["info"])
+            for additional_info in json_object.get("additionalInfo", [])
+        ]
+
+    def __str__(self):
+        error_str = super(ARMErrorFormat, self).__str__()
+
+        if self.additional_info:
+            error_str += "\nAdditional Information:"
+            for error_info in self.additional_info:
+                error_str += str(error_info)
+
+        return error_str

pgsql/pgAdmin 4/python/Lib/site-packages/azure/mgmt/core/tools.py

@@ -0,0 +1,209 @@
+# --------------------------------------------------------------------------
+#
+# Copyright (c) Microsoft Corporation. All rights reserved.
+#
+# The MIT License (MIT)
+#
+# 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.
+#
+# --------------------------------------------------------------------------
+
+import re
+import logging
+
+
+_LOGGER = logging.getLogger(__name__)
+_ARMID_RE = re.compile(
+    "(?i)/subscriptions/(?P<subscription>[^/]+)(/resourceGroups/(?P<resource_group>[^/]+))?"
+    "(/providers/(?P<namespace>[^/]+)/(?P<type>[^/]*)/(?P<name>[^/]+)(?P<children>.*))?"
+)
+
+_CHILDREN_RE = re.compile("(?i)(/providers/(?P<child_namespace>[^/]+))?/" "(?P<child_type>[^/]*)/(?P<child_name>[^/]+)")
+
+_ARMNAME_RE = re.compile("^[^<>%&:\\?/]{1,260}$")
+
+
+__all__ = [
+    "parse_resource_id",
+    "resource_id",
+    "is_valid_resource_id",
+    "is_valid_resource_name",
+]
+
+
+def parse_resource_id(rid):
+    """Parses a resource_id into its various parts.
+
+    Returns a dictionary with a single key-value pair, 'name': rid, if invalid resource id.
+
+    :param rid: The resource id being parsed
+    :type rid: str
+    :returns: A dictionary with with following key/value pairs (if found):
+
+        - subscription:            Subscription id
+        - resource_group:          Name of resource group
+        - namespace:               Namespace for the resource provider (i.e. Microsoft.Compute)
+        - type:                    Type of the root resource (i.e. virtualMachines)
+        - name:                    Name of the root resource
+        - child_namespace_{level}: Namespace for the child resource of that level
+        - child_type_{level}:      Type of the child resource of that level
+        - child_name_{level}:      Name of the child resource of that level
+        - last_child_num:          Level of the last child
+        - resource_parent:         Computed parent in the following pattern: providers/{namespace}\
+        /{parent}/{type}/{name}
+        - resource_namespace:      Same as namespace. Note that this may be different than the \
+        target resource's namespace.
+        - resource_type:           Type of the target resource (not the parent)
+        - resource_name:           Name of the target resource (not the parent)
+
+    :rtype: dict[str,str]
+    """
+    if not rid:
+        return {}
+    match = _ARMID_RE.match(rid)
+    if match:
+        result = match.groupdict()
+        children = _CHILDREN_RE.finditer(result["children"] or "")
+        count = None
+        for count, child in enumerate(children):
+            result.update({key + "_%d" % (count + 1): group for key, group in child.groupdict().items()})
+        result["last_child_num"] = count + 1 if isinstance(count, int) else None
+        result = _populate_alternate_kwargs(result)
+    else:
+        result = dict(name=rid)
+    return {key: value for key, value in result.items() if value is not None}
+
+
+def _populate_alternate_kwargs(kwargs):
+    """Translates the parsed arguments into a format used by generic ARM commands
+    such as the resource and lock commands.
+    """
+
+    resource_namespace = kwargs["namespace"]
+    resource_type = kwargs.get("child_type_{}".format(kwargs["last_child_num"])) or kwargs["type"]
+    resource_name = kwargs.get("child_name_{}".format(kwargs["last_child_num"])) or kwargs["name"]
+
+    _get_parents_from_parts(kwargs)
+    kwargs["resource_namespace"] = resource_namespace
+    kwargs["resource_type"] = resource_type
+    kwargs["resource_name"] = resource_name
+    return kwargs
+
+
+def _get_parents_from_parts(kwargs):
+    """Get the parents given all the children parameters."""
+    parent_builder = []
+    if kwargs["last_child_num"] is not None:
+        parent_builder.append("{type}/{name}/".format(**kwargs))
+        for index in range(1, kwargs["last_child_num"]):
+            child_namespace = kwargs.get("child_namespace_{}".format(index))
+            if child_namespace is not None:
+                parent_builder.append("providers/{}/".format(child_namespace))
+            kwargs["child_parent_{}".format(index)] = "".join(parent_builder)
+            parent_builder.append("{{child_type_{0}}}/{{child_name_{0}}}/".format(index).format(**kwargs))
+        child_namespace = kwargs.get("child_namespace_{}".format(kwargs["last_child_num"]))
+        if child_namespace is not None:
+            parent_builder.append("providers/{}/".format(child_namespace))
+        kwargs["child_parent_{}".format(kwargs["last_child_num"])] = "".join(parent_builder)
+    kwargs["resource_parent"] = "".join(parent_builder) if kwargs["name"] else None
+    return kwargs
+
+
+def resource_id(**kwargs):
+    """Create a valid resource id string from the given parts.
+
+    This method builds the resource id from the left until the next required id parameter
+    to be appended is not found. It then returns the built up id.
+
+    :param dict kwargs: The keyword arguments that will make up the id.
+
+        The method accepts the following keyword arguments:
+            - subscription (required): Subscription id
+            - resource_group:          Name of resource group
+            - namespace:               Namespace for the resource provider (i.e. Microsoft.Compute)
+            - type:                    Type of the resource (i.e. virtualMachines)
+            - name:                    Name of the resource (or parent if child_name is also \
+            specified)
+            - child_namespace_{level}: Namespace for the child resource of that level (optional)
+            - child_type_{level}:      Type of the child resource of that level
+            - child_name_{level}:      Name of the child resource of that level
+
+    :returns: A resource id built from the given arguments.
+    :rtype: str
+    """
+    kwargs = {k: v for k, v in kwargs.items() if v is not None}
+    rid_builder = ["/subscriptions/{subscription}".format(**kwargs)]
+    try:
+        try:
+            rid_builder.append("resourceGroups/{resource_group}".format(**kwargs))
+        except KeyError:
+            pass
+        rid_builder.append("providers/{namespace}".format(**kwargs))
+        rid_builder.append("{type}/{name}".format(**kwargs))
+        count = 1
+        while True:
+            try:
+                rid_builder.append("providers/{{child_namespace_{}}}".format(count).format(**kwargs))
+            except KeyError:
+                pass
+            rid_builder.append("{{child_type_{0}}}/{{child_name_{0}}}".format(count).format(**kwargs))
+            count += 1
+    except KeyError:
+        pass
+    return "/".join(rid_builder)
+
+
+def is_valid_resource_id(rid, exception_type=None):
+    """Validates the given resource id.
+
+    :param rid: The resource id being validated.
+    :type rid: str
+    :param exception_type: Raises this Exception if invalid.
+    :type exception_type: :class:`Exception`
+    :returns: A boolean describing whether the id is valid.
+    :rtype: bool
+    """
+    is_valid = False
+    try:
+        is_valid = rid and resource_id(**parse_resource_id(rid)).lower() == rid.lower()
+    except KeyError:
+        pass
+    if not is_valid and exception_type:
+        raise exception_type()
+    return is_valid
+
+
+def is_valid_resource_name(rname, exception_type=None):
+    """Validates the given resource name to ARM guidelines, individual services may be more restrictive.
+
+    :param rname: The resource name being validated.
+    :type rname: str
+    :param exception_type: Raises this Exception if invalid.
+    :type exception_type: :class:`Exception`
+    :returns: A boolean describing whether the name is valid.
+    :rtype: bool
+    """
+
+    match = _ARMNAME_RE.match(rname)
+
+    if match:
+        return True
+    if exception_type:
+        raise exception_type()
+    return False

pgsql/pgAdmin 4/python/Lib/site-packages/azure/mgmt/rdbms/__init__.py

@@ -0,0 +1 @@
+__version__="0.0.1"

pgsql/pgAdmin 4/python/Lib/site-packages/azure/mgmt/rdbms/_version.py

@@ -0,0 +1,8 @@
+# coding=utf-8
+# --------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+# --------------------------------------------------------------------------
+
+VERSION = "10.1.0"

pgsql/pgAdmin 4/python/Lib/site-packages/azure/mgmt/resource/__init__.py

@@ -0,0 +1,24 @@
+# coding=utf-8
+# --------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for license information.
+# Code generated by Microsoft (R) AutoRest Code Generator.
+# Changes may cause incorrect behavior and will be lost if the code is regenerated.
+# --------------------------------------------------------------------------
+
+from .managedapplications import ApplicationClient
+from .deploymentscripts import DeploymentScriptsClient
+from .features import FeatureClient
+from .links import ManagementLinkClient
+from .locks import ManagementLockClient
+from .policy import PolicyClient
+from .resources import ResourceManagementClient
+from .subscriptions import SubscriptionClient
+__all__ = ['ApplicationClient',
+           'DeploymentScriptsClient',
+           'FeatureClient',
+           'PolicyClient',
+           'ManagementLinkClient',
+           'ManagementLockClient',
+           'ResourceManagementClient',
+           'SubscriptionClient']

pgsql/pgAdmin 4/python/Lib/site-packages/azure/mgmt/resource/_version.py

@@ -0,0 +1,8 @@
+# coding=utf-8
+# --------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+# --------------------------------------------------------------------------
+
+VERSION = "23.0.1"

pgsql/pgAdmin 4/python/Lib/site-packages/azure/mgmt/resource/changes/__init__.py

@@ -0,0 +1,20 @@
+# coding=utf-8
+# --------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for license information.
+# Code generated by Microsoft (R) AutoRest Code Generator.
+# Changes may cause incorrect behavior and will be lost if the code is regenerated.
+# --------------------------------------------------------------------------
+
+from ._changes_client import ChangesClient
+__all__ = ['ChangesClient']
+
+try:
+    from ._patch import patch_sdk  # type: ignore
+    patch_sdk()
+except ImportError:
+    pass
+
+from ._version import VERSION
+
+__version__ = VERSION

pgsql/pgAdmin 4/python/Lib/site-packages/azure/mgmt/resource/changes/_changes_client.py

@@ -0,0 +1,115 @@
+# coding=utf-8
+# --------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+#
+# Code generated by Microsoft (R) AutoRest Code Generator.
+# Changes may cause incorrect behavior and will be lost if the code is
+# regenerated.
+# --------------------------------------------------------------------------
+
+from typing import Any, Optional, TYPE_CHECKING
+
+from azure.mgmt.core import ARMPipelineClient
+from azure.profiles import KnownProfiles, ProfileDefinition
+from azure.profiles.multiapiclient import MultiApiClientMixin
+
+from ._configuration import ChangesClientConfiguration
+from ._serialization import Deserializer, Serializer
+
+if TYPE_CHECKING:
+    # pylint: disable=unused-import,ungrouped-imports
+    from azure.core.credentials import TokenCredential
+
+class _SDKClient(object):
+    def __init__(self, *args, **kwargs):
+        """This is a fake class to support current implemetation of MultiApiClientMixin."
+        Will be removed in final version of multiapi azure-core based client
+        """
+        pass
+
+class ChangesClient(MultiApiClientMixin, _SDKClient):
+    """The Resource Changes Client.
+
+    This ready contains multiple API versions, to help you deal with all of the Azure clouds
+    (Azure Stack, Azure Government, Azure China, etc.).
+    By default, it uses the latest API version available on public Azure.
+    For production, you should stick to a particular api-version and/or profile.
+    The profile sets a mapping between an operation group and its API version.
+    The api-version parameter sets the default API version if the operation
+    group is not described in the profile.
+
+    :param credential: Credential needed for the client to connect to Azure. Required.
+    :type credential: ~azure.core.credentials.TokenCredential
+    :param subscription_id: The Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000). Required.
+    :type subscription_id: str
+    :param api_version: API version to use if no profile is provided, or if missing in profile.
+    :type api_version: str
+    :param base_url: Service URL
+    :type base_url: str
+    :param profile: A profile definition, from KnownProfiles to dict.
+    :type profile: azure.profiles.KnownProfiles
+    """
+
+    DEFAULT_API_VERSION = '2022-05-01'
+    _PROFILE_TAG = "azure.mgmt.resource.changes.ChangesClient"
+    LATEST_PROFILE = ProfileDefinition({
+        _PROFILE_TAG: {
+            None: DEFAULT_API_VERSION,
+        }},
+        _PROFILE_TAG + " latest"
+    )
+
+    def __init__(
+        self,
+        credential: "TokenCredential",
+        subscription_id: str,
+        api_version: Optional[str]=None,
+        base_url: str = "https://management.azure.com",
+        profile: KnownProfiles=KnownProfiles.default,
+        **kwargs: Any
+    ):
+        self._config = ChangesClientConfiguration(credential, subscription_id, **kwargs)
+        self._client = ARMPipelineClient(base_url=base_url, config=self._config, **kwargs)
+        super(ChangesClient, self).__init__(
+            api_version=api_version,
+            profile=profile
+        )
+
+    @classmethod
+    def _models_dict(cls, api_version):
+        return {k: v for k, v in cls.models(api_version).__dict__.items() if isinstance(v, type)}
+
+    @classmethod
+    def models(cls, api_version=DEFAULT_API_VERSION):
+        """Module depends on the API version:
+
+           * 2022-05-01: :mod:`v2022_05_01.models<azure.mgmt.resource.changes.v2022_05_01.models>`
+        """
+        if api_version == '2022-05-01':
+            from .v2022_05_01 import models
+            return models
+        raise ValueError("API version {} is not available".format(api_version))
+
+    @property
+    def changes(self):
+        """Instance depends on the API version:
+
+           * 2022-05-01: :class:`ChangesOperations<azure.mgmt.resource.changes.v2022_05_01.operations.ChangesOperations>`
+        """
+        api_version = self._get_api_version('changes')
+        if api_version == '2022-05-01':
+            from .v2022_05_01.operations import ChangesOperations as OperationClass
+        else:
+            raise ValueError("API version {} does not have operation group 'changes'".format(api_version))
+        self._config.api_version = api_version
+        return OperationClass(self._client, self._config, Serializer(self._models_dict(api_version)), Deserializer(self._models_dict(api_version)))
+
+    def close(self):
+        self._client.close()
+    def __enter__(self):
+        self._client.__enter__()
+        return self
+    def __exit__(self, *exc_details):
+        self._client.__exit__(*exc_details)

pgsql/pgAdmin 4/python/Lib/site-packages/azure/mgmt/resource/changes/_configuration.py

@@ -0,0 +1,67 @@
+# coding=utf-8
+# --------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+#
+# Code generated by Microsoft (R) AutoRest Code Generator.
+# Changes may cause incorrect behavior and will be lost if the code is
+# regenerated.
+# --------------------------------------------------------------------------
+from typing import Any, TYPE_CHECKING
+
+from azure.core.configuration import Configuration
+from azure.core.pipeline import policies
+from azure.mgmt.core.policies import ARMChallengeAuthenticationPolicy, ARMHttpLoggingPolicy
+
+from ._version import VERSION
+
+if TYPE_CHECKING:
+    # pylint: disable=unused-import,ungrouped-imports
+    from azure.core.credentials import TokenCredential
+
+class ChangesClientConfiguration(Configuration):
+    """Configuration for ChangesClient.
+
+    Note that all parameters used to create this instance are saved as instance
+    attributes.
+
+    :param credential: Credential needed for the client to connect to Azure. Required.
+    :type credential: ~azure.core.credentials.TokenCredential
+    :param subscription_id: The Azure subscription ID. This is a GUID-formatted string (e.g. 00000000-0000-0000-0000-000000000000). Required.
+    :type subscription_id: str
+    """
+
+    def __init__(
+        self,
+        credential: "TokenCredential",
+        subscription_id: str,
+        **kwargs: Any
+    ):
+        if credential is None:
+            raise ValueError("Parameter 'credential' must not be None.")
+        if subscription_id is None:
+            raise ValueError("Parameter 'subscription_id' must not be None.")
+        super(ChangesClientConfiguration, self).__init__(**kwargs)
+
+        self.credential = credential
+        self.subscription_id = subscription_id
+        self.credential_scopes = kwargs.pop('credential_scopes', ['https://management.azure.com/.default'])
+        kwargs.setdefault('sdk_moniker', 'azure-mgmt-resource/{}'.format(VERSION))
+        self._configure(**kwargs)
+
+    def _configure(
+        self,
+        **kwargs: Any
+    ):
+        self.user_agent_policy = kwargs.get('user_agent_policy') or policies.UserAgentPolicy(**kwargs)
+        self.headers_policy = kwargs.get('headers_policy') or policies.HeadersPolicy(**kwargs)
+        self.proxy_policy = kwargs.get('proxy_policy') or policies.ProxyPolicy(**kwargs)
+        self.logging_policy = kwargs.get('logging_policy') or policies.NetworkTraceLoggingPolicy(**kwargs)
+        self.http_logging_policy = kwargs.get('http_logging_policy') or ARMHttpLoggingPolicy(**kwargs)
+        self.retry_policy = kwargs.get('retry_policy') or policies.RetryPolicy(**kwargs)
+        self.custom_hook_policy = kwargs.get('custom_hook_policy') or policies.CustomHookPolicy(**kwargs)
+        self.redirect_policy = kwargs.get('redirect_policy') or policies.RedirectPolicy(**kwargs)
+        self.authentication_policy = kwargs.get('authentication_policy')
+        if self.credential and not self.authentication_policy:
+            self.authentication_policy = ARMChallengeAuthenticationPolicy(self.credential, *self.credential_scopes, **kwargs)

pgsql/pgAdmin 4/python/Lib/site-packages/azure/mgmt/resource/changes/_serialization.py

@@ -0,0 +1,1998 @@
+# --------------------------------------------------------------------------
+#
+# Copyright (c) Microsoft Corporation. All rights reserved.
+#
+# The MIT License (MIT)
+#
+# 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.
+#
+# --------------------------------------------------------------------------
+
+# pylint: skip-file
+# pyright: reportUnnecessaryTypeIgnoreComment=false
+
+from base64 import b64decode, b64encode
+import calendar
+import datetime
+import decimal
+import email
+from enum import Enum
+import json
+import logging
+import re
+import sys
+import codecs
+from typing import (
+    Dict,
+    Any,
+    cast,
+    Optional,
+    Union,
+    AnyStr,
+    IO,
+    Mapping,
+    Callable,
+    TypeVar,
+    MutableMapping,
+    Type,
+    List,
+    Mapping,
+)
+
+try:
+    from urllib import quote  # type: ignore
+except ImportError:
+    from urllib.parse import quote
+import xml.etree.ElementTree as ET
+
+import isodate  # type: ignore
+
+from azure.core.exceptions import DeserializationError, SerializationError, raise_with_traceback
+from azure.core.serialization import NULL as AzureCoreNull
+
+_BOM = codecs.BOM_UTF8.decode(encoding="utf-8")
+
+ModelType = TypeVar("ModelType", bound="Model")
+JSON = MutableMapping[str, Any]
+
+
+class RawDeserializer:
+
+    # Accept "text" because we're open minded people...
+    JSON_REGEXP = re.compile(r"^(application|text)/([a-z+.]+\+)?json$")
+
+    # Name used in context
+    CONTEXT_NAME = "deserialized_data"
+
+    @classmethod
+    def deserialize_from_text(cls, data: Optional[Union[AnyStr, IO]], content_type: Optional[str] = None) -> Any:
+        """Decode data according to content-type.
+
+        Accept a stream of data as well, but will be load at once in memory for now.
+
+        If no content-type, will return the string version (not bytes, not stream)
+
+        :param data: Input, could be bytes or stream (will be decoded with UTF8) or text
+        :type data: str or bytes or IO
+        :param str content_type: The content type.
+        """
+        if hasattr(data, "read"):
+            # Assume a stream
+            data = cast(IO, data).read()
+
+        if isinstance(data, bytes):
+            data_as_str = data.decode(encoding="utf-8-sig")
+        else:
+            # Explain to mypy the correct type.
+            data_as_str = cast(str, data)
+
+            # Remove Byte Order Mark if present in string
+            data_as_str = data_as_str.lstrip(_BOM)
+
+        if content_type is None:
+            return data
+
+        if cls.JSON_REGEXP.match(content_type):
+            try:
+                return json.loads(data_as_str)
+            except ValueError as err:
+                raise DeserializationError("JSON is invalid: {}".format(err), err)
+        elif "xml" in (content_type or []):
+            try:
+
+                try:
+                    if isinstance(data, unicode):  # type: ignore
+                        # If I'm Python 2.7 and unicode XML will scream if I try a "fromstring" on unicode string
+                        data_as_str = data_as_str.encode(encoding="utf-8")  # type: ignore
+                except NameError:
+                    pass
+
+                return ET.fromstring(data_as_str)  # nosec
+            except ET.ParseError:
+                # It might be because the server has an issue, and returned JSON with
+                # content-type XML....
+                # So let's try a JSON load, and if it's still broken
+                # let's flow the initial exception
+                def _json_attemp(data):
+                    try:
+                        return True, json.loads(data)
+                    except ValueError:
+                        return False, None  # Don't care about this one
+
+                success, json_result = _json_attemp(data)
+                if success:
+                    return json_result
+                # If i'm here, it's not JSON, it's not XML, let's scream
+                # and raise the last context in this block (the XML exception)
+                # The function hack is because Py2.7 messes up with exception
+                # context otherwise.
+                _LOGGER.critical("Wasn't XML not JSON, failing")
+                raise_with_traceback(DeserializationError, "XML is invalid")
+        raise DeserializationError("Cannot deserialize content-type: {}".format(content_type))
+
+    @classmethod
+    def deserialize_from_http_generics(cls, body_bytes: Optional[Union[AnyStr, IO]], headers: Mapping) -> Any:
+        """Deserialize from HTTP response.
+
+        Use bytes and headers to NOT use any requests/aiohttp or whatever
+        specific implementation.
+        Headers will tested for "content-type"
+        """
+        # Try to use content-type from headers if available
+        content_type = None
+        if "content-type" in headers:
+            content_type = headers["content-type"].split(";")[0].strip().lower()
+        # Ouch, this server did not declare what it sent...
+        # Let's guess it's JSON...
+        # Also, since Autorest was considering that an empty body was a valid JSON,
+        # need that test as well....
+        else:
+            content_type = "application/json"
+
+        if body_bytes:
+            return cls.deserialize_from_text(body_bytes, content_type)
+        return None
+
+
+try:
+    basestring  # type: ignore
+    unicode_str = unicode  # type: ignore
+except NameError:
+    basestring = str
+    unicode_str = str
+
+_LOGGER = logging.getLogger(__name__)
+
+try:
+    _long_type = long  # type: ignore
+except NameError:
+    _long_type = int
+
+
+class UTC(datetime.tzinfo):
+    """Time Zone info for handling UTC"""
+
+    def utcoffset(self, dt):
+        """UTF offset for UTC is 0."""
+        return datetime.timedelta(0)
+
+    def tzname(self, dt):
+        """Timestamp representation."""
+        return "Z"
+
+    def dst(self, dt):
+        """No daylight saving for UTC."""
+        return datetime.timedelta(hours=1)
+
+
+try:
+    from datetime import timezone as _FixedOffset  # type: ignore
+except ImportError:  # Python 2.7
+
+    class _FixedOffset(datetime.tzinfo):  # type: ignore
+        """Fixed offset in minutes east from UTC.
+        Copy/pasted from Python doc
+        :param datetime.timedelta offset: offset in timedelta format
+        """
+
+        def __init__(self, offset):
+            self.__offset = offset
+
+        def utcoffset(self, dt):
+            return self.__offset
+
+        def tzname(self, dt):
+            return str(self.__offset.total_seconds() / 3600)
+
+        def __repr__(self):
+            return "<FixedOffset {}>".format(self.tzname(None))
+
+        def dst(self, dt):
+            return datetime.timedelta(0)
+
+        def __getinitargs__(self):
+            return (self.__offset,)
+
+
+try:
+    from datetime import timezone
+
+    TZ_UTC = timezone.utc
+except ImportError:
+    TZ_UTC = UTC()  # type: ignore
+
+_FLATTEN = re.compile(r"(?<!\\)\.")
+
+
+def attribute_transformer(key, attr_desc, value):
+    """A key transformer that returns the Python attribute.
+
+    :param str key: The attribute name
+    :param dict attr_desc: The attribute metadata
+    :param object value: The value
+    :returns: A key using attribute name
+    """
+    return (key, value)
+
+
+def full_restapi_key_transformer(key, attr_desc, value):
+    """A key transformer that returns the full RestAPI key path.
+
+    :param str _: The attribute name
+    :param dict attr_desc: The attribute metadata
+    :param object value: The value
+    :returns: A list of keys using RestAPI syntax.
+    """
+    keys = _FLATTEN.split(attr_desc["key"])
+    return ([_decode_attribute_map_key(k) for k in keys], value)
+
+
+def last_restapi_key_transformer(key, attr_desc, value):
+    """A key transformer that returns the last RestAPI key.
+
+    :param str key: The attribute name
+    :param dict attr_desc: The attribute metadata
+    :param object value: The value
+    :returns: The last RestAPI key.
+    """
+    key, value = full_restapi_key_transformer(key, attr_desc, value)
+    return (key[-1], value)
+
+
+def _create_xml_node(tag, prefix=None, ns=None):
+    """Create a XML node."""
+    if prefix and ns:
+        ET.register_namespace(prefix, ns)
+    if ns:
+        return ET.Element("{" + ns + "}" + tag)
+    else:
+        return ET.Element(tag)
+
+
+class Model(object):
+    """Mixin for all client request body/response body models to support
+    serialization and deserialization.
+    """
+
+    _subtype_map: Dict[str, Dict[str, Any]] = {}
+    _attribute_map: Dict[str, Dict[str, Any]] = {}
+    _validation: Dict[str, Dict[str, Any]] = {}
+
+    def __init__(self, **kwargs: Any) -> None:
+        self.additional_properties: Dict[str, Any] = {}
+        for k in kwargs:
+            if k not in self._attribute_map:
+                _LOGGER.warning("%s is not a known attribute of class %s and will be ignored", k, self.__class__)
+            elif k in self._validation and self._validation[k].get("readonly", False):
+                _LOGGER.warning("Readonly attribute %s will be ignored in class %s", k, self.__class__)
+            else:
+                setattr(self, k, kwargs[k])
+
+    def __eq__(self, other: Any) -> bool:
+        """Compare objects by comparing all attributes."""
+        if isinstance(other, self.__class__):
+            return self.__dict__ == other.__dict__
+        return False
+
+    def __ne__(self, other: Any) -> bool:
+        """Compare objects by comparing all attributes."""
+        return not self.__eq__(other)
+
+    def __str__(self) -> str:
+        return str(self.__dict__)
+
+    @classmethod
+    def enable_additional_properties_sending(cls) -> None:
+        cls._attribute_map["additional_properties"] = {"key": "", "type": "{object}"}
+
+    @classmethod
+    def is_xml_model(cls) -> bool:
+        try:
+            cls._xml_map  # type: ignore
+        except AttributeError:
+            return False
+        return True
+
+    @classmethod
+    def _create_xml_node(cls):
+        """Create XML node."""
+        try:
+            xml_map = cls._xml_map  # type: ignore
+        except AttributeError:
+            xml_map = {}
+
+        return _create_xml_node(xml_map.get("name", cls.__name__), xml_map.get("prefix", None), xml_map.get("ns", None))
+
+    def serialize(self, keep_readonly: bool = False, **kwargs: Any) -> JSON:
+        """Return the JSON that would be sent to azure from this model.
+
+        This is an alias to `as_dict(full_restapi_key_transformer, keep_readonly=False)`.
+
+        If you want XML serialization, you can pass the kwargs is_xml=True.
+
+        :param bool keep_readonly: If you want to serialize the readonly attributes
+        :returns: A dict JSON compatible object
+        :rtype: dict
+        """
+        serializer = Serializer(self._infer_class_models())
+        return serializer._serialize(self, keep_readonly=keep_readonly, **kwargs)
+
+    def as_dict(
+        self,
+        keep_readonly: bool = True,
+        key_transformer: Callable[
+            [str, Dict[str, Any], Any], Any
+        ] = attribute_transformer,
+        **kwargs: Any
+    ) -> JSON:
+        """Return a dict that can be serialized using json.dump.
+
+        Advanced usage might optionally use a callback as parameter:
+
+        .. code::python
+
+            def my_key_transformer(key, attr_desc, value):
+                return key
+
+        Key is the attribute name used in Python. Attr_desc
+        is a dict of metadata. Currently contains 'type' with the
+        msrest type and 'key' with the RestAPI encoded key.
+        Value is the current value in this object.
+
+        The string returned will be used to serialize the key.
+        If the return type is a list, this is considered hierarchical
+        result dict.
+
+        See the three examples in this file:
+
+        - attribute_transformer
+        - full_restapi_key_transformer
+        - last_restapi_key_transformer
+
+        If you want XML serialization, you can pass the kwargs is_xml=True.
+
+        :param function key_transformer: A key transformer function.
+        :returns: A dict JSON compatible object
+        :rtype: dict
+        """
+        serializer = Serializer(self._infer_class_models())
+        return serializer._serialize(self, key_transformer=key_transformer, keep_readonly=keep_readonly, **kwargs)
+
+    @classmethod
+    def _infer_class_models(cls):
+        try:
+            str_models = cls.__module__.rsplit(".", 1)[0]
+            models = sys.modules[str_models]
+            client_models = {k: v for k, v in models.__dict__.items() if isinstance(v, type)}
+            if cls.__name__ not in client_models:
+                raise ValueError("Not Autorest generated code")
+        except Exception:
+            # Assume it's not Autorest generated (tests?). Add ourselves as dependencies.
+            client_models = {cls.__name__: cls}
+        return client_models
+
+    @classmethod
+    def deserialize(cls: Type[ModelType], data: Any, content_type: Optional[str] = None) -> ModelType:
+        """Parse a str using the RestAPI syntax and return a model.
+
+        :param str data: A str using RestAPI structure. JSON by default.
+        :param str content_type: JSON by default, set application/xml if XML.
+        :returns: An instance of this model
+        :raises: DeserializationError if something went wrong
+        """
+        deserializer = Deserializer(cls._infer_class_models())
+        return deserializer(cls.__name__, data, content_type=content_type)
+
+    @classmethod
+    def from_dict(
+        cls: Type[ModelType],
+        data: Any,
+        key_extractors: Optional[Callable[[str, Dict[str, Any], Any], Any]] = None,
+        content_type: Optional[str] = None,
+    ) -> ModelType:
+        """Parse a dict using given key extractor return a model.
+
+        By default consider key
+        extractors (rest_key_case_insensitive_extractor, attribute_key_case_insensitive_extractor
+        and last_rest_key_case_insensitive_extractor)
+
+        :param dict data: A dict using RestAPI structure
+        :param str content_type: JSON by default, set application/xml if XML.
+        :returns: An instance of this model
+        :raises: DeserializationError if something went wrong
+        """
+        deserializer = Deserializer(cls._infer_class_models())
+        deserializer.key_extractors = (  # type: ignore
+            [  # type: ignore
+                attribute_key_case_insensitive_extractor,
+                rest_key_case_insensitive_extractor,
+                last_rest_key_case_insensitive_extractor,
+            ]
+            if key_extractors is None
+            else key_extractors
+        )
+        return deserializer(cls.__name__, data, content_type=content_type)
+
+    @classmethod
+    def _flatten_subtype(cls, key, objects):
+        if "_subtype_map" not in cls.__dict__:
+            return {}
+        result = dict(cls._subtype_map[key])
+        for valuetype in cls._subtype_map[key].values():
+            result.update(objects[valuetype]._flatten_subtype(key, objects))
+        return result
+
+    @classmethod
+    def _classify(cls, response, objects):
+        """Check the class _subtype_map for any child classes.
+        We want to ignore any inherited _subtype_maps.
+        Remove the polymorphic key from the initial data.
+        """
+        for subtype_key in cls.__dict__.get("_subtype_map", {}).keys():
+            subtype_value = None
+
+            if not isinstance(response, ET.Element):
+                rest_api_response_key = cls._get_rest_key_parts(subtype_key)[-1]
+                subtype_value = response.pop(rest_api_response_key, None) or response.pop(subtype_key, None)
+            else:
+                subtype_value = xml_key_extractor(subtype_key, cls._attribute_map[subtype_key], response)
+            if subtype_value:
+                # Try to match base class. Can be class name only
+                # (bug to fix in Autorest to support x-ms-discriminator-name)
+                if cls.__name__ == subtype_value:
+                    return cls
+                flatten_mapping_type = cls._flatten_subtype(subtype_key, objects)
+                try:
+                    return objects[flatten_mapping_type[subtype_value]]  # type: ignore
+                except KeyError:
+                    _LOGGER.warning(
+                        "Subtype value %s has no mapping, use base class %s.",
+                        subtype_value,
+                        cls.__name__,
+                    )
+                    break
+            else:
+                _LOGGER.warning("Discriminator %s is absent or null, use base class %s.", subtype_key, cls.__name__)
+                break
+        return cls
+
+    @classmethod
+    def _get_rest_key_parts(cls, attr_key):
+        """Get the RestAPI key of this attr, split it and decode part
+        :param str attr_key: Attribute key must be in attribute_map.
+        :returns: A list of RestAPI part
+        :rtype: list
+        """
+        rest_split_key = _FLATTEN.split(cls._attribute_map[attr_key]["key"])
+        return [_decode_attribute_map_key(key_part) for key_part in rest_split_key]
+
+
+def _decode_attribute_map_key(key):
+    """This decode a key in an _attribute_map to the actual key we want to look at
+    inside the received data.
+
+    :param str key: A key string from the generated code
+    """
+    return key.replace("\\.", ".")
+
+
+class Serializer(object):
+    """Request object model serializer."""
+
+    basic_types = {str: "str", int: "int", bool: "bool", float: "float"}
+
+    _xml_basic_types_serializers = {"bool": lambda x: str(x).lower()}
+    days = {0: "Mon", 1: "Tue", 2: "Wed", 3: "Thu", 4: "Fri", 5: "Sat", 6: "Sun"}
+    months = {
+        1: "Jan",
+        2: "Feb",
+        3: "Mar",
+        4: "Apr",
+        5: "May",
+        6: "Jun",
+        7: "Jul",
+        8: "Aug",
+        9: "Sep",
+        10: "Oct",
+        11: "Nov",
+        12: "Dec",
+    }
+    validation = {
+        "min_length": lambda x, y: len(x) < y,
+        "max_length": lambda x, y: len(x) > y,
+        "minimum": lambda x, y: x < y,
+        "maximum": lambda x, y: x > y,
+        "minimum_ex": lambda x, y: x <= y,
+        "maximum_ex": lambda x, y: x >= y,
+        "min_items": lambda x, y: len(x) < y,
+        "max_items": lambda x, y: len(x) > y,
+        "pattern": lambda x, y: not re.match(y, x, re.UNICODE),
+        "unique": lambda x, y: len(x) != len(set(x)),
+        "multiple": lambda x, y: x % y != 0,
+    }
+
+    def __init__(self, classes: Optional[Mapping[str, Type[ModelType]]]=None):
+        self.serialize_type = {
+            "iso-8601": Serializer.serialize_iso,
+            "rfc-1123": Serializer.serialize_rfc,
+            "unix-time": Serializer.serialize_unix,
+            "duration": Serializer.serialize_duration,
+            "date": Serializer.serialize_date,
+            "time": Serializer.serialize_time,
+            "decimal": Serializer.serialize_decimal,
+            "long": Serializer.serialize_long,
+            "bytearray": Serializer.serialize_bytearray,
+            "base64": Serializer.serialize_base64,
+            "object": self.serialize_object,
+            "[]": self.serialize_iter,
+            "{}": self.serialize_dict,
+        }
+        self.dependencies: Dict[str, Type[ModelType]] = dict(classes) if classes else {}
+        self.key_transformer = full_restapi_key_transformer
+        self.client_side_validation = True
+
+    def _serialize(self, target_obj, data_type=None, **kwargs):
+        """Serialize data into a string according to type.
+
+        :param target_obj: The data to be serialized.
+        :param str data_type: The type to be serialized from.
+        :rtype: str, dict
+        :raises: SerializationError if serialization fails.
+        """
+        key_transformer = kwargs.get("key_transformer", self.key_transformer)
+        keep_readonly = kwargs.get("keep_readonly", False)
+        if target_obj is None:
+            return None
+
+        attr_name = None
+        class_name = target_obj.__class__.__name__
+
+        if data_type:
+            return self.serialize_data(target_obj, data_type, **kwargs)
+
+        if not hasattr(target_obj, "_attribute_map"):
+            data_type = type(target_obj).__name__
+            if data_type in self.basic_types.values():
+                return self.serialize_data(target_obj, data_type, **kwargs)
+
+        # Force "is_xml" kwargs if we detect a XML model
+        try:
+            is_xml_model_serialization = kwargs["is_xml"]
+        except KeyError:
+            is_xml_model_serialization = kwargs.setdefault("is_xml", target_obj.is_xml_model())
+
+        serialized = {}
+        if is_xml_model_serialization:
+            serialized = target_obj._create_xml_node()
+        try:
+            attributes = target_obj._attribute_map
+            for attr, attr_desc in attributes.items():
+                attr_name = attr
+                if not keep_readonly and target_obj._validation.get(attr_name, {}).get("readonly", False):
+                    continue
+
+                if attr_name == "additional_properties" and attr_desc["key"] == "":
+                    if target_obj.additional_properties is not None:
+                        serialized.update(target_obj.additional_properties)
+                    continue
+                try:
+
+                    orig_attr = getattr(target_obj, attr)
+                    if is_xml_model_serialization:
+                        pass  # Don't provide "transformer" for XML for now. Keep "orig_attr"
+                    else:  # JSON
+                        keys, orig_attr = key_transformer(attr, attr_desc.copy(), orig_attr)
+                        keys = keys if isinstance(keys, list) else [keys]
+
+                    kwargs["serialization_ctxt"] = attr_desc
+                    new_attr = self.serialize_data(orig_attr, attr_desc["type"], **kwargs)
+
+                    if is_xml_model_serialization:
+                        xml_desc = attr_desc.get("xml", {})
+                        xml_name = xml_desc.get("name", attr_desc["key"])
+                        xml_prefix = xml_desc.get("prefix", None)
+                        xml_ns = xml_desc.get("ns", None)
+                        if xml_desc.get("attr", False):
+                            if xml_ns:
+                                ET.register_namespace(xml_prefix, xml_ns)
+                                xml_name = "{}{}".format(xml_ns, xml_name)
+                            serialized.set(xml_name, new_attr)  # type: ignore
+                            continue
+                        if xml_desc.get("text", False):
+                            serialized.text = new_attr  # type: ignore
+                            continue
+                        if isinstance(new_attr, list):
+                            serialized.extend(new_attr)  # type: ignore
+                        elif isinstance(new_attr, ET.Element):
+                            # If the down XML has no XML/Name, we MUST replace the tag with the local tag. But keeping the namespaces.
+                            if "name" not in getattr(orig_attr, "_xml_map", {}):
+                                splitted_tag = new_attr.tag.split("}")
+                                if len(splitted_tag) == 2:  # Namespace
+                                    new_attr.tag = "}".join([splitted_tag[0], xml_name])
+                                else:
+                                    new_attr.tag = xml_name
+                            serialized.append(new_attr)  # type: ignore
+                        else:  # That's a basic type
+                            # Integrate namespace if necessary
+                            local_node = _create_xml_node(xml_name, xml_prefix, xml_ns)
+                            local_node.text = unicode_str(new_attr)
+                            serialized.append(local_node)  # type: ignore
+                    else:  # JSON
+                        for k in reversed(keys):  # type: ignore
+                            new_attr = {k: new_attr}
+
+                        _new_attr = new_attr
+                        _serialized = serialized
+                        for k in keys:  # type: ignore
+                            if k not in _serialized:
+                                _serialized.update(_new_attr)  # type: ignore
+                            _new_attr = _new_attr[k]  # type: ignore
+                            _serialized = _serialized[k]
+                except ValueError:
+                    continue
+
+        except (AttributeError, KeyError, TypeError) as err:
+            msg = "Attribute {} in object {} cannot be serialized.\n{}".format(attr_name, class_name, str(target_obj))
+            raise_with_traceback(SerializationError, msg, err)
+        else:
+            return serialized
+
+    def body(self, data, data_type, **kwargs):
+        """Serialize data intended for a request body.
+
+        :param data: The data to be serialized.
+        :param str data_type: The type to be serialized from.
+        :rtype: dict
+        :raises: SerializationError if serialization fails.
+        :raises: ValueError if data is None
+        """
+
+        # Just in case this is a dict
+        internal_data_type_str = data_type.strip("[]{}")
+        internal_data_type = self.dependencies.get(internal_data_type_str, None)
+        try:
+            is_xml_model_serialization = kwargs["is_xml"]
+        except KeyError:
+            if internal_data_type and issubclass(internal_data_type, Model):
+                is_xml_model_serialization = kwargs.setdefault("is_xml", internal_data_type.is_xml_model())
+            else:
+                is_xml_model_serialization = False
+        if internal_data_type and not isinstance(internal_data_type, Enum):
+            try:
+                deserializer = Deserializer(self.dependencies)
+                # Since it's on serialization, it's almost sure that format is not JSON REST
+                # We're not able to deal with additional properties for now.
+                deserializer.additional_properties_detection = False
+                if is_xml_model_serialization:
+                    deserializer.key_extractors = [  # type: ignore
+                        attribute_key_case_insensitive_extractor,
+                    ]
+                else:
+                    deserializer.key_extractors = [
+                        rest_key_case_insensitive_extractor,
+                        attribute_key_case_insensitive_extractor,
+                        last_rest_key_case_insensitive_extractor,
+                    ]
+                data = deserializer._deserialize(data_type, data)
+            except DeserializationError as err:
+                raise_with_traceback(SerializationError, "Unable to build a model: " + str(err), err)
+
+        return self._serialize(data, data_type, **kwargs)
+
+    def url(self, name, data, data_type, **kwargs):
+        """Serialize data intended for a URL path.
+
+        :param data: The data to be serialized.
+        :param str data_type: The type to be serialized from.
+        :rtype: str
+        :raises: TypeError if serialization fails.
+        :raises: ValueError if data is None
+        """
+        try:
+            output = self.serialize_data(data, data_type, **kwargs)
+            if data_type == "bool":
+                output = json.dumps(output)
+
+            if kwargs.get("skip_quote") is True:
+                output = str(output)
+            else:
+                output = quote(str(output), safe="")
+        except SerializationError:
+            raise TypeError("{} must be type {}.".format(name, data_type))
+        else:
+            return output
+
+    def query(self, name, data, data_type, **kwargs):
+        """Serialize data intended for a URL query.
+
+        :param data: The data to be serialized.
+        :param str data_type: The type to be serialized from.
+        :rtype: str
+        :raises: TypeError if serialization fails.
+        :raises: ValueError if data is None
+        """
+        try:
+            # Treat the list aside, since we don't want to encode the div separator
+            if data_type.startswith("["):
+                internal_data_type = data_type[1:-1]
+                data = [self.serialize_data(d, internal_data_type, **kwargs) if d is not None else "" for d in data]
+                if not kwargs.get("skip_quote", False):
+                    data = [quote(str(d), safe="") for d in data]
+                return str(self.serialize_iter(data, internal_data_type, **kwargs))
+
+            # Not a list, regular serialization
+            output = self.serialize_data(data, data_type, **kwargs)
+            if data_type == "bool":
+                output = json.dumps(output)
+            if kwargs.get("skip_quote") is True:
+                output = str(output)
+            else:
+                output = quote(str(output), safe="")
+        except SerializationError:
+            raise TypeError("{} must be type {}.".format(name, data_type))
+        else:
+            return str(output)
+
+    def header(self, name, data, data_type, **kwargs):
+        """Serialize data intended for a request header.
+
+        :param data: The data to be serialized.
+        :param str data_type: The type to be serialized from.
+        :rtype: str
+        :raises: TypeError if serialization fails.
+        :raises: ValueError if data is None
+        """
+        try:
+            if data_type in ["[str]"]:
+                data = ["" if d is None else d for d in data]
+
+            output = self.serialize_data(data, data_type, **kwargs)
+            if data_type == "bool":
+                output = json.dumps(output)
+        except SerializationError:
+            raise TypeError("{} must be type {}.".format(name, data_type))
+        else:
+            return str(output)
+
+    def serialize_data(self, data, data_type, **kwargs):
+        """Serialize generic data according to supplied data type.
+
+        :param data: The data to be serialized.
+        :param str data_type: The type to be serialized from.
+        :param bool required: Whether it's essential that the data not be
+         empty or None
+        :raises: AttributeError if required data is None.
+        :raises: ValueError if data is None
+        :raises: SerializationError if serialization fails.
+        """
+        if data is None:
+            raise ValueError("No value for given attribute")
+
+        try:
+            if data is AzureCoreNull:
+                return None
+            if data_type in self.basic_types.values():
+                return self.serialize_basic(data, data_type, **kwargs)
+
+            elif data_type in self.serialize_type:
+                return self.serialize_type[data_type](data, **kwargs)
+
+            # If dependencies is empty, try with current data class
+            # It has to be a subclass of Enum anyway
+            enum_type = self.dependencies.get(data_type, data.__class__)
+            if issubclass(enum_type, Enum):
+                return Serializer.serialize_enum(data, enum_obj=enum_type)
+
+            iter_type = data_type[0] + data_type[-1]
+            if iter_type in self.serialize_type:
+                return self.serialize_type[iter_type](data, data_type[1:-1], **kwargs)
+
+        except (ValueError, TypeError) as err:
+            msg = "Unable to serialize value: {!r} as type: {!r}."
+            raise_with_traceback(SerializationError, msg.format(data, data_type), err)
+        else:
+            return self._serialize(data, **kwargs)
+
+    @classmethod
+    def _get_custom_serializers(cls, data_type, **kwargs):
+        custom_serializer = kwargs.get("basic_types_serializers", {}).get(data_type)
+        if custom_serializer:
+            return custom_serializer
+        if kwargs.get("is_xml", False):
+            return cls._xml_basic_types_serializers.get(data_type)
+
+    @classmethod
+    def serialize_basic(cls, data, data_type, **kwargs):
+        """Serialize basic builting data type.
+        Serializes objects to str, int, float or bool.
+
+        Possible kwargs:
+        - basic_types_serializers dict[str, callable] : If set, use the callable as serializer
+        - is_xml bool : If set, use xml_basic_types_serializers
+
+        :param data: Object to be serialized.
+        :param str data_type: Type of object in the iterable.
+        """
+        custom_serializer = cls._get_custom_serializers(data_type, **kwargs)
+        if custom_serializer:
+            return custom_serializer(data)
+        if data_type == "str":
+            return cls.serialize_unicode(data)
+        return eval(data_type)(data)  # nosec
+
+    @classmethod
+    def serialize_unicode(cls, data):
+        """Special handling for serializing unicode strings in Py2.
+        Encode to UTF-8 if unicode, otherwise handle as a str.
+
+        :param data: Object to be serialized.
+        :rtype: str
+        """
+        try:  # If I received an enum, return its value
+            return data.value
+        except AttributeError:
+            pass
+
+        try:
+            if isinstance(data, unicode):  # type: ignore
+                # Don't change it, JSON and XML ElementTree are totally able
+                # to serialize correctly u'' strings
+                return data
+        except NameError:
+            return str(data)
+        else:
+            return str(data)
+
+    def serialize_iter(self, data, iter_type, div=None, **kwargs):
+        """Serialize iterable.
+
+        Supported kwargs:
+        - serialization_ctxt dict : The current entry of _attribute_map, or same format.
+          serialization_ctxt['type'] should be same as data_type.
+        - is_xml bool : If set, serialize as XML
+
+        :param list attr: Object to be serialized.
+        :param str iter_type: Type of object in the iterable.
+        :param bool required: Whether the objects in the iterable must
+         not be None or empty.
+        :param str div: If set, this str will be used to combine the elements
+         in the iterable into a combined string. Default is 'None'.
+        :rtype: list, str
+        """
+        if isinstance(data, str):
+            raise SerializationError("Refuse str type as a valid iter type.")
+
+        serialization_ctxt = kwargs.get("serialization_ctxt", {})
+        is_xml = kwargs.get("is_xml", False)
+
+        serialized = []
+        for d in data:
+            try:
+                serialized.append(self.serialize_data(d, iter_type, **kwargs))
+            except ValueError:
+                serialized.append(None)
+
+        if div:
+            serialized = ["" if s is None else str(s) for s in serialized]
+            serialized = div.join(serialized)
+
+        if "xml" in serialization_ctxt or is_xml:
+            # XML serialization is more complicated
+            xml_desc = serialization_ctxt.get("xml", {})
+            xml_name = xml_desc.get("name")
+            if not xml_name:
+                xml_name = serialization_ctxt["key"]
+
+            # Create a wrap node if necessary (use the fact that Element and list have "append")
+            is_wrapped = xml_desc.get("wrapped", False)
+            node_name = xml_desc.get("itemsName", xml_name)
+            if is_wrapped:
+                final_result = _create_xml_node(xml_name, xml_desc.get("prefix", None), xml_desc.get("ns", None))
+            else:
+                final_result = []
+            # All list elements to "local_node"
+            for el in serialized:
+                if isinstance(el, ET.Element):
+                    el_node = el
+                else:
+                    el_node = _create_xml_node(node_name, xml_desc.get("prefix", None), xml_desc.get("ns", None))
+                    if el is not None:  # Otherwise it writes "None" :-p
+                        el_node.text = str(el)
+                final_result.append(el_node)
+            return final_result
+        return serialized
+
+    def serialize_dict(self, attr, dict_type, **kwargs):
+        """Serialize a dictionary of objects.
+
+        :param dict attr: Object to be serialized.
+        :param str dict_type: Type of object in the dictionary.
+        :param bool required: Whether the objects in the dictionary must
+         not be None or empty.
+        :rtype: dict
+        """
+        serialization_ctxt = kwargs.get("serialization_ctxt", {})
+        serialized = {}
+        for key, value in attr.items():
+            try:
+                serialized[self.serialize_unicode(key)] = self.serialize_data(value, dict_type, **kwargs)
+            except ValueError:
+                serialized[self.serialize_unicode(key)] = None
+
+        if "xml" in serialization_ctxt:
+            # XML serialization is more complicated
+            xml_desc = serialization_ctxt["xml"]
+            xml_name = xml_desc["name"]
+
+            final_result = _create_xml_node(xml_name, xml_desc.get("prefix", None), xml_desc.get("ns", None))
+            for key, value in serialized.items():
+                ET.SubElement(final_result, key).text = value
+            return final_result
+
+        return serialized
+
+    def serialize_object(self, attr, **kwargs):
+        """Serialize a generic object.
+        This will be handled as a dictionary. If object passed in is not
+        a basic type (str, int, float, dict, list) it will simply be
+        cast to str.
+
+        :param dict attr: Object to be serialized.
+        :rtype: dict or str
+        """
+        if attr is None:
+            return None
+        if isinstance(attr, ET.Element):
+            return attr
+        obj_type = type(attr)
+        if obj_type in self.basic_types:
+            return self.serialize_basic(attr, self.basic_types[obj_type], **kwargs)
+        if obj_type is _long_type:
+            return self.serialize_long(attr)
+        if obj_type is unicode_str:
+            return self.serialize_unicode(attr)
+        if obj_type is datetime.datetime:
+            return self.serialize_iso(attr)
+        if obj_type is datetime.date:
+            return self.serialize_date(attr)
+        if obj_type is datetime.time:
+            return self.serialize_time(attr)
+        if obj_type is datetime.timedelta:
+            return self.serialize_duration(attr)
+        if obj_type is decimal.Decimal:
+            return self.serialize_decimal(attr)
+
+        # If it's a model or I know this dependency, serialize as a Model
+        elif obj_type in self.dependencies.values() or isinstance(attr, Model):
+            return self._serialize(attr)
+
+        if obj_type == dict:
+            serialized = {}
+            for key, value in attr.items():
+                try:
+                    serialized[self.serialize_unicode(key)] = self.serialize_object(value, **kwargs)
+                except ValueError:
+                    serialized[self.serialize_unicode(key)] = None
+            return serialized
+
+        if obj_type == list:
+            serialized = []
+            for obj in attr:
+                try:
+                    serialized.append(self.serialize_object(obj, **kwargs))
+                except ValueError:
+                    pass
+            return serialized
+        return str(attr)
+
+    @staticmethod
+    def serialize_enum(attr, enum_obj=None):
+        try:
+            result = attr.value
+        except AttributeError:
+            result = attr
+        try:
+            enum_obj(result)  # type: ignore
+            return result
+        except ValueError:
+            for enum_value in enum_obj:  # type: ignore
+                if enum_value.value.lower() == str(attr).lower():
+                    return enum_value.value
+            error = "{!r} is not valid value for enum {!r}"
+            raise SerializationError(error.format(attr, enum_obj))
+
+    @staticmethod
+    def serialize_bytearray(attr, **kwargs):
+        """Serialize bytearray into base-64 string.
+
+        :param attr: Object to be serialized.
+        :rtype: str
+        """
+        return b64encode(attr).decode()
+
+    @staticmethod
+    def serialize_base64(attr, **kwargs):
+        """Serialize str into base-64 string.
+
+        :param attr: Object to be serialized.
+        :rtype: str
+        """
+        encoded = b64encode(attr).decode("ascii")
+        return encoded.strip("=").replace("+", "-").replace("/", "_")
+
+    @staticmethod
+    def serialize_decimal(attr, **kwargs):
+        """Serialize Decimal object to float.
+
+        :param attr: Object to be serialized.
+        :rtype: float
+        """
+        return float(attr)
+
+    @staticmethod
+    def serialize_long(attr, **kwargs):
+        """Serialize long (Py2) or int (Py3).
+
+        :param attr: Object to be serialized.
+        :rtype: int/long
+        """
+        return _long_type(attr)
+
+    @staticmethod
+    def serialize_date(attr, **kwargs):
+        """Serialize Date object into ISO-8601 formatted string.
+
+        :param Date attr: Object to be serialized.
+        :rtype: str
+        """
+        if isinstance(attr, str):
+            attr = isodate.parse_date(attr)
+        t = "{:04}-{:02}-{:02}".format(attr.year, attr.month, attr.day)
+        return t
+
+    @staticmethod
+    def serialize_time(attr, **kwargs):
+        """Serialize Time object into ISO-8601 formatted string.
+
+        :param datetime.time attr: Object to be serialized.
+        :rtype: str
+        """
+        if isinstance(attr, str):
+            attr = isodate.parse_time(attr)
+        t = "{:02}:{:02}:{:02}".format(attr.hour, attr.minute, attr.second)
+        if attr.microsecond:
+            t += ".{:02}".format(attr.microsecond)
+        return t
+
+    @staticmethod
+    def serialize_duration(attr, **kwargs):
+        """Serialize TimeDelta object into ISO-8601 formatted string.
+
+        :param TimeDelta attr: Object to be serialized.
+        :rtype: str
+        """
+        if isinstance(attr, str):
+            attr = isodate.parse_duration(attr)
+        return isodate.duration_isoformat(attr)
+
+    @staticmethod
+    def serialize_rfc(attr, **kwargs):
+        """Serialize Datetime object into RFC-1123 formatted string.
+
+        :param Datetime attr: Object to be serialized.
+        :rtype: str
+        :raises: TypeError if format invalid.
+        """
+        try:
+            if not attr.tzinfo:
+                _LOGGER.warning("Datetime with no tzinfo will be considered UTC.")
+            utc = attr.utctimetuple()
+        except AttributeError:
+            raise TypeError("RFC1123 object must be valid Datetime object.")
+
+        return "{}, {:02} {} {:04} {:02}:{:02}:{:02} GMT".format(
+            Serializer.days[utc.tm_wday],
+            utc.tm_mday,
+            Serializer.months[utc.tm_mon],
+            utc.tm_year,
+            utc.tm_hour,
+            utc.tm_min,
+            utc.tm_sec,
+        )
+
+    @staticmethod
+    def serialize_iso(attr, **kwargs):
+        """Serialize Datetime object into ISO-8601 formatted string.
+
+        :param Datetime attr: Object to be serialized.
+        :rtype: str
+        :raises: SerializationError if format invalid.
+        """
+        if isinstance(attr, str):
+            attr = isodate.parse_datetime(attr)
+        try:
+            if not attr.tzinfo:
+                _LOGGER.warning("Datetime with no tzinfo will be considered UTC.")
+            utc = attr.utctimetuple()
+            if utc.tm_year > 9999 or utc.tm_year < 1:
+                raise OverflowError("Hit max or min date")
+
+            microseconds = str(attr.microsecond).rjust(6, "0").rstrip("0").ljust(3, "0")
+            if microseconds:
+                microseconds = "." + microseconds
+            date = "{:04}-{:02}-{:02}T{:02}:{:02}:{:02}".format(
+                utc.tm_year, utc.tm_mon, utc.tm_mday, utc.tm_hour, utc.tm_min, utc.tm_sec
+            )
+            return date + microseconds + "Z"
+        except (ValueError, OverflowError) as err:
+            msg = "Unable to serialize datetime object."
+            raise_with_traceback(SerializationError, msg, err)
+        except AttributeError as err:
+            msg = "ISO-8601 object must be valid Datetime object."
+            raise_with_traceback(TypeError, msg, err)
+
+    @staticmethod
+    def serialize_unix(attr, **kwargs):
+        """Serialize Datetime object into IntTime format.
+        This is represented as seconds.
+
+        :param Datetime attr: Object to be serialized.
+        :rtype: int
+        :raises: SerializationError if format invalid
+        """
+        if isinstance(attr, int):
+            return attr
+        try:
+            if not attr.tzinfo:
+                _LOGGER.warning("Datetime with no tzinfo will be considered UTC.")
+            return int(calendar.timegm(attr.utctimetuple()))
+        except AttributeError:
+            raise TypeError("Unix time object must be valid Datetime object.")
+
+
+def rest_key_extractor(attr, attr_desc, data):
+    key = attr_desc["key"]
+    working_data = data
+
+    while "." in key:
+        # Need the cast, as for some reasons "split" is typed as list[str | Any]
+        dict_keys = cast(List[str], _FLATTEN.split(key))
+        if len(dict_keys) == 1:
+            key = _decode_attribute_map_key(dict_keys[0])
+            break
+        working_key = _decode_attribute_map_key(dict_keys[0])
+        working_data = working_data.get(working_key, data)
+        if working_data is None:
+            # If at any point while following flatten JSON path see None, it means
+            # that all properties under are None as well
+            # https://github.com/Azure/msrest-for-python/issues/197
+            return None
+        key = ".".join(dict_keys[1:])
+
+    return working_data.get(key)
+
+
+def rest_key_case_insensitive_extractor(attr, attr_desc, data):
+    key = attr_desc["key"]
+    working_data = data
+
+    while "." in key:
+        dict_keys = _FLATTEN.split(key)
+        if len(dict_keys) == 1:
+            key = _decode_attribute_map_key(dict_keys[0])
+            break
+        working_key = _decode_attribute_map_key(dict_keys[0])
+        working_data = attribute_key_case_insensitive_extractor(working_key, None, working_data)
+        if working_data is None:
+            # If at any point while following flatten JSON path see None, it means
+            # that all properties under are None as well
+            # https://github.com/Azure/msrest-for-python/issues/197
+            return None
+        key = ".".join(dict_keys[1:])
+
+    if working_data:
+        return attribute_key_case_insensitive_extractor(key, None, working_data)
+
+
+def last_rest_key_extractor(attr, attr_desc, data):
+    """Extract the attribute in "data" based on the last part of the JSON path key."""
+    key = attr_desc["key"]
+    dict_keys = _FLATTEN.split(key)
+    return attribute_key_extractor(dict_keys[-1], None, data)
+
+
+def last_rest_key_case_insensitive_extractor(attr, attr_desc, data):
+    """Extract the attribute in "data" based on the last part of the JSON path key.
+
+    This is the case insensitive version of "last_rest_key_extractor"
+    """
+    key = attr_desc["key"]
+    dict_keys = _FLATTEN.split(key)
+    return attribute_key_case_insensitive_extractor(dict_keys[-1], None, data)
+
+
+def attribute_key_extractor(attr, _, data):
+    return data.get(attr)
+
+
+def attribute_key_case_insensitive_extractor(attr, _, data):
+    found_key = None
+    lower_attr = attr.lower()
+    for key in data:
+        if lower_attr == key.lower():
+            found_key = key
+            break
+
+    return data.get(found_key)
+
+
+def _extract_name_from_internal_type(internal_type):
+    """Given an internal type XML description, extract correct XML name with namespace.
+
+    :param dict internal_type: An model type
+    :rtype: tuple
+    :returns: A tuple XML name + namespace dict
+    """
+    internal_type_xml_map = getattr(internal_type, "_xml_map", {})
+    xml_name = internal_type_xml_map.get("name", internal_type.__name__)
+    xml_ns = internal_type_xml_map.get("ns", None)
+    if xml_ns:
+        xml_name = "{}{}".format(xml_ns, xml_name)
+    return xml_name
+
+
+def xml_key_extractor(attr, attr_desc, data):
+    if isinstance(data, dict):
+        return None
+
+    # Test if this model is XML ready first
+    if not isinstance(data, ET.Element):
+        return None
+
+    xml_desc = attr_desc.get("xml", {})
+    xml_name = xml_desc.get("name", attr_desc["key"])
+
+    # Look for a children
+    is_iter_type = attr_desc["type"].startswith("[")
+    is_wrapped = xml_desc.get("wrapped", False)
+    internal_type = attr_desc.get("internalType", None)
+    internal_type_xml_map = getattr(internal_type, "_xml_map", {})
+
+    # Integrate namespace if necessary
+    xml_ns = xml_desc.get("ns", internal_type_xml_map.get("ns", None))
+    if xml_ns:
+        xml_name = "{}{}".format(xml_ns, xml_name)
+
+    # If it's an attribute, that's simple
+    if xml_desc.get("attr", False):
+        return data.get(xml_name)
+
+    # If it's x-ms-text, that's simple too
+    if xml_desc.get("text", False):
+        return data.text
+
+    # Scenario where I take the local name:
+    # - Wrapped node
+    # - Internal type is an enum (considered basic types)
+    # - Internal type has no XML/Name node
+    if is_wrapped or (internal_type and (issubclass(internal_type, Enum) or "name" not in internal_type_xml_map)):
+        children = data.findall(xml_name)
+    # If internal type has a local name and it's not a list, I use that name
+    elif not is_iter_type and internal_type and "name" in internal_type_xml_map:
+        xml_name = _extract_name_from_internal_type(internal_type)
+        children = data.findall(xml_name)
+    # That's an array
+    else:
+        if internal_type:  # Complex type, ignore itemsName and use the complex type name
+            items_name = _extract_name_from_internal_type(internal_type)
+        else:
+            items_name = xml_desc.get("itemsName", xml_name)
+        children = data.findall(items_name)
+
+    if len(children) == 0:
+        if is_iter_type:
+            if is_wrapped:
+                return None  # is_wrapped no node, we want None
+            else:
+                return []  # not wrapped, assume empty list
+        return None  # Assume it's not there, maybe an optional node.
+
+    # If is_iter_type and not wrapped, return all found children
+    if is_iter_type:
+        if not is_wrapped:
+            return children
+        else:  # Iter and wrapped, should have found one node only (the wrap one)
+            if len(children) != 1:
+                raise DeserializationError(
+                    "Tried to deserialize an array not wrapped, and found several nodes '{}'. Maybe you should declare this array as wrapped?".format(
+                        xml_name
+                    )
+                )
+            return list(children[0])  # Might be empty list and that's ok.
+
+    # Here it's not a itertype, we should have found one element only or empty
+    if len(children) > 1:
+        raise DeserializationError("Find several XML '{}' where it was not expected".format(xml_name))
+    return children[0]
+
+
+class Deserializer(object):
+    """Response object model deserializer.
+
+    :param dict classes: Class type dictionary for deserializing complex types.
+    :ivar list key_extractors: Ordered list of extractors to be used by this deserializer.
+    """
+
+    basic_types = {str: "str", int: "int", bool: "bool", float: "float"}
+
+    valid_date = re.compile(r"\d{4}[-]\d{2}[-]\d{2}T\d{2}:\d{2}:\d{2}" r"\.?\d*Z?[-+]?[\d{2}]?:?[\d{2}]?")
+
+    def __init__(self, classes: Optional[Mapping[str, Type[ModelType]]]=None):
+        self.deserialize_type = {
+            "iso-8601": Deserializer.deserialize_iso,
+            "rfc-1123": Deserializer.deserialize_rfc,
+            "unix-time": Deserializer.deserialize_unix,
+            "duration": Deserializer.deserialize_duration,
+            "date": Deserializer.deserialize_date,
+            "time": Deserializer.deserialize_time,
+            "decimal": Deserializer.deserialize_decimal,
+            "long": Deserializer.deserialize_long,
+            "bytearray": Deserializer.deserialize_bytearray,
+            "base64": Deserializer.deserialize_base64,
+            "object": self.deserialize_object,
+            "[]": self.deserialize_iter,
+            "{}": self.deserialize_dict,
+        }
+        self.deserialize_expected_types = {
+            "duration": (isodate.Duration, datetime.timedelta),
+            "iso-8601": (datetime.datetime),
+        }
+        self.dependencies: Dict[str, Type[ModelType]] = dict(classes) if classes else {}
+        self.key_extractors = [rest_key_extractor, xml_key_extractor]
+        # Additional properties only works if the "rest_key_extractor" is used to
+        # extract the keys. Making it to work whatever the key extractor is too much
+        # complicated, with no real scenario for now.
+        # So adding a flag to disable additional properties detection. This flag should be
+        # used if your expect the deserialization to NOT come from a JSON REST syntax.
+        # Otherwise, result are unexpected
+        self.additional_properties_detection = True
+
+    def __call__(self, target_obj, response_data, content_type=None):
+        """Call the deserializer to process a REST response.
+
+        :param str target_obj: Target data type to deserialize to.
+        :param requests.Response response_data: REST response object.
+        :param str content_type: Swagger "produces" if available.
+        :raises: DeserializationError if deserialization fails.
+        :return: Deserialized object.
+        """
+        data = self._unpack_content(response_data, content_type)
+        return self._deserialize(target_obj, data)
+
+    def _deserialize(self, target_obj, data):
+        """Call the deserializer on a model.
+
+        Data needs to be already deserialized as JSON or XML ElementTree
+
+        :param str target_obj: Target data type to deserialize to.
+        :param object data: Object to deserialize.
+        :raises: DeserializationError if deserialization fails.
+        :return: Deserialized object.
+        """
+        # This is already a model, go recursive just in case
+        if hasattr(data, "_attribute_map"):
+            constants = [name for name, config in getattr(data, "_validation", {}).items() if config.get("constant")]
+            try:
+                for attr, mapconfig in data._attribute_map.items():
+                    if attr in constants:
+                        continue
+                    value = getattr(data, attr)
+                    if value is None:
+                        continue
+                    local_type = mapconfig["type"]
+                    internal_data_type = local_type.strip("[]{}")
+                    if internal_data_type not in self.dependencies or isinstance(internal_data_type, Enum):
+                        continue
+                    setattr(data, attr, self._deserialize(local_type, value))
+                return data
+            except AttributeError:
+                return
+
+        response, class_name = self._classify_target(target_obj, data)
+
+        if isinstance(response, basestring):
+            return self.deserialize_data(data, response)
+        elif isinstance(response, type) and issubclass(response, Enum):
+            return self.deserialize_enum(data, response)
+
+        if data is None:
+            return data
+        try:
+            attributes = response._attribute_map  # type: ignore
+            d_attrs = {}
+            for attr, attr_desc in attributes.items():
+                # Check empty string. If it's not empty, someone has a real "additionalProperties"...
+                if attr == "additional_properties" and attr_desc["key"] == "":
+                    continue
+                raw_value = None
+                # Enhance attr_desc with some dynamic data
+                attr_desc = attr_desc.copy()  # Do a copy, do not change the real one
+                internal_data_type = attr_desc["type"].strip("[]{}")
+                if internal_data_type in self.dependencies:
+                    attr_desc["internalType"] = self.dependencies[internal_data_type]
+
+                for key_extractor in self.key_extractors:
+                    found_value = key_extractor(attr, attr_desc, data)
+                    if found_value is not None:
+                        if raw_value is not None and raw_value != found_value:
+                            msg = (
+                                "Ignoring extracted value '%s' from %s for key '%s'"
+                                " (duplicate extraction, follow extractors order)"
+                            )
+                            _LOGGER.warning(msg, found_value, key_extractor, attr)
+                            continue
+                        raw_value = found_value
+
+                value = self.deserialize_data(raw_value, attr_desc["type"])
+                d_attrs[attr] = value
+        except (AttributeError, TypeError, KeyError) as err:
+            msg = "Unable to deserialize to object: " + class_name  # type: ignore
+            raise_with_traceback(DeserializationError, msg, err)
+        else:
+            additional_properties = self._build_additional_properties(attributes, data)
+            return self._instantiate_model(response, d_attrs, additional_properties)
+
+    def _build_additional_properties(self, attribute_map, data):
+        if not self.additional_properties_detection:
+            return None
+        if "additional_properties" in attribute_map and attribute_map.get("additional_properties", {}).get("key") != "":
+            # Check empty string. If it's not empty, someone has a real "additionalProperties"
+            return None
+        if isinstance(data, ET.Element):
+            data = {el.tag: el.text for el in data}
+
+        known_keys = {
+            _decode_attribute_map_key(_FLATTEN.split(desc["key"])[0])
+            for desc in attribute_map.values()
+            if desc["key"] != ""
+        }
+        present_keys = set(data.keys())
+        missing_keys = present_keys - known_keys
+        return {key: data[key] for key in missing_keys}
+
+    def _classify_target(self, target, data):
+        """Check to see whether the deserialization target object can
+        be classified into a subclass.
+        Once classification has been determined, initialize object.
+
+        :param str target: The target object type to deserialize to.
+        :param str/dict data: The response data to deserialize.
+        """
+        if target is None:
+            return None, None
+
+        if isinstance(target, basestring):
+            try:
+                target = self.dependencies[target]
+            except KeyError:
+                return target, target
+
+        try:
+            target = target._classify(data, self.dependencies)
+        except AttributeError:
+            pass  # Target is not a Model, no classify
+        return target, target.__class__.__name__  # type: ignore
+
+    def failsafe_deserialize(self, target_obj, data, content_type=None):
+        """Ignores any errors encountered in deserialization,
+        and falls back to not deserializing the object. Recommended
+        for use in error deserialization, as we want to return the
+        HttpResponseError to users, and not have them deal with
+        a deserialization error.
+
+        :param str target_obj: The target object type to deserialize to.
+        :param str/dict data: The response data to deserialize.
+        :param str content_type: Swagger "produces" if available.
+        """
+        try:
+            return self(target_obj, data, content_type=content_type)
+        except:
+            _LOGGER.debug(
+                "Ran into a deserialization error. Ignoring since this is failsafe deserialization", exc_info=True
+            )
+            return None
+
+    @staticmethod
+    def _unpack_content(raw_data, content_type=None):
+        """Extract the correct structure for deserialization.
+
+        If raw_data is a PipelineResponse, try to extract the result of RawDeserializer.
+        if we can't, raise. Your Pipeline should have a RawDeserializer.
+
+        If not a pipeline response and raw_data is bytes or string, use content-type
+        to decode it. If no content-type, try JSON.
+
+        If raw_data is something else, bypass all logic and return it directly.
+
+        :param raw_data: Data to be processed.
+        :param content_type: How to parse if raw_data is a string/bytes.
+        :raises JSONDecodeError: If JSON is requested and parsing is impossible.
+        :raises UnicodeDecodeError: If bytes is not UTF8
+        """
+        # Assume this is enough to detect a Pipeline Response without importing it
+        context = getattr(raw_data, "context", {})
+        if context:
+            if RawDeserializer.CONTEXT_NAME in context:
+                return context[RawDeserializer.CONTEXT_NAME]
+            raise ValueError("This pipeline didn't have the RawDeserializer policy; can't deserialize")
+
+        # Assume this is enough to recognize universal_http.ClientResponse without importing it
+        if hasattr(raw_data, "body"):
+            return RawDeserializer.deserialize_from_http_generics(raw_data.text(), raw_data.headers)
+
+        # Assume this enough to recognize requests.Response without importing it.
+        if hasattr(raw_data, "_content_consumed"):
+            return RawDeserializer.deserialize_from_http_generics(raw_data.text, raw_data.headers)
+
+        if isinstance(raw_data, (basestring, bytes)) or hasattr(raw_data, "read"):
+            return RawDeserializer.deserialize_from_text(raw_data, content_type)  # type: ignore
+        return raw_data
+
+    def _instantiate_model(self, response, attrs, additional_properties=None):
+        """Instantiate a response model passing in deserialized args.
+
+        :param response: The response model class.
+        :param d_attrs: The deserialized response attributes.
+        """
+        if callable(response):
+            subtype = getattr(response, "_subtype_map", {})
+            try:
+                readonly = [k for k, v in response._validation.items() if v.get("readonly")]
+                const = [k for k, v in response._validation.items() if v.get("constant")]
+                kwargs = {k: v for k, v in attrs.items() if k not in subtype and k not in readonly + const}
+                response_obj = response(**kwargs)
+                for attr in readonly:
+                    setattr(response_obj, attr, attrs.get(attr))
+                if additional_properties:
+                    response_obj.additional_properties = additional_properties
+                return response_obj
+            except TypeError as err:
+                msg = "Unable to deserialize {} into model {}. ".format(kwargs, response)  # type: ignore
+                raise DeserializationError(msg + str(err))
+        else:
+            try:
+                for attr, value in attrs.items():
+                    setattr(response, attr, value)
+                return response
+            except Exception as exp:
+                msg = "Unable to populate response model. "
+                msg += "Type: {}, Error: {}".format(type(response), exp)
+                raise DeserializationError(msg)
+
+    def deserialize_data(self, data, data_type):
+        """Process data for deserialization according to data type.
+
+        :param str data: The response string to be deserialized.
+        :param str data_type: The type to deserialize to.
+        :raises: DeserializationError if deserialization fails.
+        :return: Deserialized object.
+        """
+        if data is None:
+            return data
+
+        try:
+            if not data_type:
+                return data
+            if data_type in self.basic_types.values():
+                return self.deserialize_basic(data, data_type)
+            if data_type in self.deserialize_type:
+                if isinstance(data, self.deserialize_expected_types.get(data_type, tuple())):
+                    return data
+
+                is_a_text_parsing_type = lambda x: x not in ["object", "[]", r"{}"]
+                if isinstance(data, ET.Element) and is_a_text_parsing_type(data_type) and not data.text:
+                    return None
+                data_val = self.deserialize_type[data_type](data)
+                return data_val
+
+            iter_type = data_type[0] + data_type[-1]
+            if iter_type in self.deserialize_type:
+                return self.deserialize_type[iter_type](data, data_type[1:-1])
+
+            obj_type = self.dependencies[data_type]
+            if issubclass(obj_type, Enum):
+                if isinstance(data, ET.Element):
+                    data = data.text
+                return self.deserialize_enum(data, obj_type)
+
+        except (ValueError, TypeError, AttributeError) as err:
+            msg = "Unable to deserialize response data."
+            msg += " Data: {}, {}".format(data, data_type)
+            raise_with_traceback(DeserializationError, msg, err)
+        else:
+            return self._deserialize(obj_type, data)
+
+    def deserialize_iter(self, attr, iter_type):
+        """Deserialize an iterable.
+
+        :param list attr: Iterable to be deserialized.
+        :param str iter_type: The type of object in the iterable.
+        :rtype: list
+        """
+        if attr is None:
+            return None
+        if isinstance(attr, ET.Element):  # If I receive an element here, get the children
+            attr = list(attr)
+        if not isinstance(attr, (list, set)):
+            raise DeserializationError("Cannot deserialize as [{}] an object of type {}".format(iter_type, type(attr)))
+        return [self.deserialize_data(a, iter_type) for a in attr]
+
+    def deserialize_dict(self, attr, dict_type):
+        """Deserialize a dictionary.
+
+        :param dict/list attr: Dictionary to be deserialized. Also accepts
+         a list of key, value pairs.
+        :param str dict_type: The object type of the items in the dictionary.
+        :rtype: dict
+        """
+        if isinstance(attr, list):
+            return {x["key"]: self.deserialize_data(x["value"], dict_type) for x in attr}
+
+        if isinstance(attr, ET.Element):
+            # Transform <Key>value</Key> into {"Key": "value"}
+            attr = {el.tag: el.text for el in attr}
+        return {k: self.deserialize_data(v, dict_type) for k, v in attr.items()}
+
+    def deserialize_object(self, attr, **kwargs):
+        """Deserialize a generic object.
+        This will be handled as a dictionary.
+
+        :param dict attr: Dictionary to be deserialized.
+        :rtype: dict
+        :raises: TypeError if non-builtin datatype encountered.
+        """
+        if attr is None:
+            return None
+        if isinstance(attr, ET.Element):
+            # Do no recurse on XML, just return the tree as-is
+            return attr
+        if isinstance(attr, basestring):
+            return self.deserialize_basic(attr, "str")
+        obj_type = type(attr)
+        if obj_type in self.basic_types:
+            return self.deserialize_basic(attr, self.basic_types[obj_type])
+        if obj_type is _long_type:
+            return self.deserialize_long(attr)
+
+        if obj_type == dict:
+            deserialized = {}
+            for key, value in attr.items():
+                try:
+                    deserialized[key] = self.deserialize_object(value, **kwargs)
+                except ValueError:
+                    deserialized[key] = None
+            return deserialized
+
+        if obj_type == list:
+            deserialized = []
+            for obj in attr:
+                try:
+                    deserialized.append(self.deserialize_object(obj, **kwargs))
+                except ValueError:
+                    pass
+            return deserialized
+
+        else:
+            error = "Cannot deserialize generic object with type: "
+            raise TypeError(error + str(obj_type))
+
+    def deserialize_basic(self, attr, data_type):
+        """Deserialize basic builtin data type from string.
+        Will attempt to convert to str, int, float and bool.
+        This function will also accept '1', '0', 'true' and 'false' as
+        valid bool values.
+
+        :param str attr: response string to be deserialized.
+        :param str data_type: deserialization data type.
+        :rtype: str, int, float or bool
+        :raises: TypeError if string format is not valid.
+        """
+        # If we're here, data is supposed to be a basic type.
+        # If it's still an XML node, take the text
+        if isinstance(attr, ET.Element):
+            attr = attr.text
+            if not attr:
+                if data_type == "str":
+                    # None or '', node <a/> is empty string.
+                    return ""
+                else:
+                    # None or '', node <a/> with a strong type is None.
+                    # Don't try to model "empty bool" or "empty int"
+                    return None
+
+        if data_type == "bool":
+            if attr in [True, False, 1, 0]:
+                return bool(attr)
+            elif isinstance(attr, basestring):
+                if attr.lower() in ["true", "1"]:
+                    return True
+                elif attr.lower() in ["false", "0"]:
+                    return False
+            raise TypeError("Invalid boolean value: {}".format(attr))
+
+        if data_type == "str":
+            return self.deserialize_unicode(attr)
+        return eval(data_type)(attr)  # nosec
+
+    @staticmethod
+    def deserialize_unicode(data):
+        """Preserve unicode objects in Python 2, otherwise return data
+        as a string.
+
+        :param str data: response string to be deserialized.
+        :rtype: str or unicode
+        """
+        # We might be here because we have an enum modeled as string,
+        # and we try to deserialize a partial dict with enum inside
+        if isinstance(data, Enum):
+            return data
+
+        # Consider this is real string
+        try:
+            if isinstance(data, unicode):  # type: ignore
+                return data
+        except NameError:
+            return str(data)
+        else:
+            return str(data)
+
+    @staticmethod
+    def deserialize_enum(data, enum_obj):
+        """Deserialize string into enum object.
+
+        If the string is not a valid enum value it will be returned as-is
+        and a warning will be logged.
+
+        :param str data: Response string to be deserialized. If this value is
+         None or invalid it will be returned as-is.
+        :param Enum enum_obj: Enum object to deserialize to.
+        :rtype: Enum
+        """
+        if isinstance(data, enum_obj) or data is None:
+            return data
+        if isinstance(data, Enum):
+            data = data.value
+        if isinstance(data, int):
+            # Workaround. We might consider remove it in the future.
+            # https://github.com/Azure/azure-rest-api-specs/issues/141
+            try:
+                return list(enum_obj.__members__.values())[data]
+            except IndexError:
+                error = "{!r} is not a valid index for enum {!r}"
+                raise DeserializationError(error.format(data, enum_obj))
+        try:
+            return enum_obj(str(data))
+        except ValueError:
+            for enum_value in enum_obj:
+                if enum_value.value.lower() == str(data).lower():
+                    return enum_value
+            # We don't fail anymore for unknown value, we deserialize as a string
+            _LOGGER.warning("Deserializer is not able to find %s as valid enum in %s", data, enum_obj)
+            return Deserializer.deserialize_unicode(data)
+
+    @staticmethod
+    def deserialize_bytearray(attr):
+        """Deserialize string into bytearray.
+
+        :param str attr: response string to be deserialized.
+        :rtype: bytearray
+        :raises: TypeError if string format invalid.
+        """
+        if isinstance(attr, ET.Element):
+            attr = attr.text
+        return bytearray(b64decode(attr))  # type: ignore
+
+    @staticmethod
+    def deserialize_base64(attr):
+        """Deserialize base64 encoded string into string.
+
+        :param str attr: response string to be deserialized.
+        :rtype: bytearray
+        :raises: TypeError if string format invalid.
+        """
+        if isinstance(attr, ET.Element):
+            attr = attr.text
+        padding = "=" * (3 - (len(attr) + 3) % 4)  # type: ignore
+        attr = attr + padding  # type: ignore
+        encoded = attr.replace("-", "+").replace("_", "/")
+        return b64decode(encoded)
+
+    @staticmethod
+    def deserialize_decimal(attr):
+        """Deserialize string into Decimal object.
+
+        :param str attr: response string to be deserialized.
+        :rtype: Decimal
+        :raises: DeserializationError if string format invalid.
+        """
+        if isinstance(attr, ET.Element):
+            attr = attr.text
+        try:
+            return decimal.Decimal(attr)  # type: ignore
+        except decimal.DecimalException as err:
+            msg = "Invalid decimal {}".format(attr)
+            raise_with_traceback(DeserializationError, msg, err)
+
+    @staticmethod
+    def deserialize_long(attr):
+        """Deserialize string into long (Py2) or int (Py3).
+
+        :param str attr: response string to be deserialized.
+        :rtype: long or int
+        :raises: ValueError if string format invalid.
+        """
+        if isinstance(attr, ET.Element):
+            attr = attr.text
+        return _long_type(attr)  # type: ignore
+
+    @staticmethod
+    def deserialize_duration(attr):
+        """Deserialize ISO-8601 formatted string into TimeDelta object.
+
+        :param str attr: response string to be deserialized.
+        :rtype: TimeDelta
+        :raises: DeserializationError if string format invalid.
+        """
+        if isinstance(attr, ET.Element):
+            attr = attr.text
+        try:
+            duration = isodate.parse_duration(attr)
+        except (ValueError, OverflowError, AttributeError) as err:
+            msg = "Cannot deserialize duration object."
+            raise_with_traceback(DeserializationError, msg, err)
+        else:
+            return duration
+
+    @staticmethod
+    def deserialize_date(attr):
+        """Deserialize ISO-8601 formatted string into Date object.
+
+        :param str attr: response string to be deserialized.
+        :rtype: Date
+        :raises: DeserializationError if string format invalid.
+        """
+        if isinstance(attr, ET.Element):
+            attr = attr.text
+        if re.search(r"[^\W\d_]", attr, re.I + re.U):  # type: ignore
+            raise DeserializationError("Date must have only digits and -. Received: %s" % attr)
+        # This must NOT use defaultmonth/defaultday. Using None ensure this raises an exception.
+        return isodate.parse_date(attr, defaultmonth=None, defaultday=None)
+
+    @staticmethod
+    def deserialize_time(attr):
+        """Deserialize ISO-8601 formatted string into time object.
+
+        :param str attr: response string to be deserialized.
+        :rtype: datetime.time
+        :raises: DeserializationError if string format invalid.
+        """
+        if isinstance(attr, ET.Element):
+            attr = attr.text
+        if re.search(r"[^\W\d_]", attr, re.I + re.U):  # type: ignore
+            raise DeserializationError("Date must have only digits and -. Received: %s" % attr)
+        return isodate.parse_time(attr)
+
+    @staticmethod
+    def deserialize_rfc(attr):
+        """Deserialize RFC-1123 formatted string into Datetime object.
+
+        :param str attr: response string to be deserialized.
+        :rtype: Datetime
+        :raises: DeserializationError if string format invalid.
+        """
+        if isinstance(attr, ET.Element):
+            attr = attr.text
+        try:
+            parsed_date = email.utils.parsedate_tz(attr)  # type: ignore
+            date_obj = datetime.datetime(
+                *parsed_date[:6], tzinfo=_FixedOffset(datetime.timedelta(minutes=(parsed_date[9] or 0) / 60))
+            )
+            if not date_obj.tzinfo:
+                date_obj = date_obj.astimezone(tz=TZ_UTC)
+        except ValueError as err:
+            msg = "Cannot deserialize to rfc datetime object."
+            raise_with_traceback(DeserializationError, msg, err)
+        else:
+            return date_obj
+
+    @staticmethod
+    def deserialize_iso(attr):
+        """Deserialize ISO-8601 formatted string into Datetime object.
+
+        :param str attr: response string to be deserialized.
+        :rtype: Datetime
+        :raises: DeserializationError if string format invalid.
+        """
+        if isinstance(attr, ET.Element):
+            attr = attr.text
+        try:
+            attr = attr.upper()  # type: ignore
+            match = Deserializer.valid_date.match(attr)
+            if not match:
+                raise ValueError("Invalid datetime string: " + attr)
+
+            check_decimal = attr.split(".")
+            if len(check_decimal) > 1:
+                decimal_str = ""
+                for digit in check_decimal[1]:
+                    if digit.isdigit():
+                        decimal_str += digit
+                    else:
+                        break
+                if len(decimal_str) > 6:
+                    attr = attr.replace(decimal_str, decimal_str[0:6])
+
+            date_obj = isodate.parse_datetime(attr)
+            test_utc = date_obj.utctimetuple()
+            if test_utc.tm_year > 9999 or test_utc.tm_year < 1:
+                raise OverflowError("Hit max or min date")
+        except (ValueError, OverflowError, AttributeError) as err:
+            msg = "Cannot deserialize datetime object."
+            raise_with_traceback(DeserializationError, msg, err)
+        else:
+            return date_obj
+
+    @staticmethod
+    def deserialize_unix(attr):
+        """Serialize Datetime object into IntTime format.
+        This is represented as seconds.
+
+        :param int attr: Object to be serialized.
+        :rtype: Datetime
+        :raises: DeserializationError if format invalid
+        """
+        if isinstance(attr, ET.Element):
+            attr = int(attr.text)  # type: ignore
+        try:
+            date_obj = datetime.datetime.fromtimestamp(attr, TZ_UTC)
+        except ValueError as err:
+            msg = "Cannot deserialize to unix datetime object."
+            raise_with_traceback(DeserializationError, msg, err)
+        else:
+            return date_obj

pgsql/pgAdmin 4/python/Lib/site-packages/azure/mgmt/resource/changes/_version.py

@@ -0,0 +1,8 @@
+# coding=utf-8
+# --------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+# --------------------------------------------------------------------------
+
+VERSION = "23.0.1"

pgsql/pgAdmin 4/python/Lib/site-packages/azure/mgmt/resource/changes/models.py

@@ -0,0 +1,7 @@
+# coding=utf-8
+# --------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+# --------------------------------------------------------------------------
+from .v2022_05_01.models import *

pgsql/pgAdmin 4/python/Lib/site-packages/azure/mgmt/resource/deploymentscripts/__init__.py

@@ -0,0 +1,20 @@
+# coding=utf-8
+# --------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for license information.
+# Code generated by Microsoft (R) AutoRest Code Generator.
+# Changes may cause incorrect behavior and will be lost if the code is regenerated.
+# --------------------------------------------------------------------------
+
+from ._deployment_scripts_client import DeploymentScriptsClient
+__all__ = ['DeploymentScriptsClient']
+
+try:
+    from ._patch import patch_sdk  # type: ignore
+    patch_sdk()
+except ImportError:
+    pass
+
+from ._version import VERSION
+
+__version__ = VERSION

pgsql/pgAdmin 4/python/Lib/site-packages/azure/mgmt/resource/deploymentscripts/_configuration.py

@@ -0,0 +1,67 @@
+# coding=utf-8
+# --------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+#
+# Code generated by Microsoft (R) AutoRest Code Generator.
+# Changes may cause incorrect behavior and will be lost if the code is
+# regenerated.
+# --------------------------------------------------------------------------
+from typing import Any, TYPE_CHECKING
+
+from azure.core.configuration import Configuration
+from azure.core.pipeline import policies
+from azure.mgmt.core.policies import ARMChallengeAuthenticationPolicy, ARMHttpLoggingPolicy
+
+from ._version import VERSION
+
+if TYPE_CHECKING:
+    # pylint: disable=unused-import,ungrouped-imports
+    from azure.core.credentials import TokenCredential
+
+class DeploymentScriptsClientConfiguration(Configuration):
+    """Configuration for DeploymentScriptsClient.
+
+    Note that all parameters used to create this instance are saved as instance
+    attributes.
+
+    :param credential: Credential needed for the client to connect to Azure. Required.
+    :type credential: ~azure.core.credentials.TokenCredential
+    :param subscription_id: Subscription Id which forms part of the URI for every service call. Required.
+    :type subscription_id: str
+    """
+
+    def __init__(
+        self,
+        credential: "TokenCredential",
+        subscription_id: str,
+        **kwargs: Any
+    ):
+        if credential is None:
+            raise ValueError("Parameter 'credential' must not be None.")
+        if subscription_id is None:
+            raise ValueError("Parameter 'subscription_id' must not be None.")
+        super(DeploymentScriptsClientConfiguration, self).__init__(**kwargs)
+
+        self.credential = credential
+        self.subscription_id = subscription_id
+        self.credential_scopes = kwargs.pop('credential_scopes', ['https://management.azure.com/.default'])
+        kwargs.setdefault('sdk_moniker', 'azure-mgmt-resource/{}'.format(VERSION))
+        self._configure(**kwargs)
+
+    def _configure(
+        self,
+        **kwargs: Any
+    ):
+        self.user_agent_policy = kwargs.get('user_agent_policy') or policies.UserAgentPolicy(**kwargs)
+        self.headers_policy = kwargs.get('headers_policy') or policies.HeadersPolicy(**kwargs)
+        self.proxy_policy = kwargs.get('proxy_policy') or policies.ProxyPolicy(**kwargs)
+        self.logging_policy = kwargs.get('logging_policy') or policies.NetworkTraceLoggingPolicy(**kwargs)
+        self.http_logging_policy = kwargs.get('http_logging_policy') or ARMHttpLoggingPolicy(**kwargs)
+        self.retry_policy = kwargs.get('retry_policy') or policies.RetryPolicy(**kwargs)
+        self.custom_hook_policy = kwargs.get('custom_hook_policy') or policies.CustomHookPolicy(**kwargs)
+        self.redirect_policy = kwargs.get('redirect_policy') or policies.RedirectPolicy(**kwargs)
+        self.authentication_policy = kwargs.get('authentication_policy')
+        if self.credential and not self.authentication_policy:
+            self.authentication_policy = ARMChallengeAuthenticationPolicy(self.credential, *self.credential_scopes, **kwargs)