From 7a84f54a917eea9935d7a4df367ea559a12bff7a Mon Sep 17 00:00:00 2001 From: Olena Stoliarova Date: Fri, 16 Sep 2022 11:02:56 +0300 Subject: [PATCH 01/19] fixing lint issues --- .../azure/communication/email/_api_versions.py | 14 ++++++++++++++ .../azure/communication/email/_email_client.py | 10 +++++++++- .../communication/email/aio/_email_client_async.py | 7 +++++++ .../azure/communication/identity/_api_versions.py | 2 +- .../identity/_communication_identity_client.py | 5 ++++- .../aio/_communication_identity_client_async.py | 5 ++++- .../networktraversal/_api_versions.py | 14 ++++++++++++++ .../_communication_relay_client.py | 9 +++++++-- .../aio/_communication_relay_client_async.py | 8 +++++++- .../communication/phonenumbers/_api_versions.py | 14 ++++++++++++++ .../phonenumbers/_phone_numbers_client.py | 8 +++++++- .../aio/_phone_numbers_client_async.py | 8 +++++++- .../azure/communication/rooms/_api_versions.py | 7 +++---- .../azure/communication/rooms/_rooms_client.py | 7 +++++-- .../communication/rooms/aio/_rooms_client_async.py | 5 ++++- 15 files changed, 107 insertions(+), 16 deletions(-) create mode 100644 sdk/communication/azure-communication-email/azure/communication/email/_api_versions.py create mode 100644 sdk/communication/azure-communication-networktraversal/azure/communication/networktraversal/_api_versions.py create mode 100644 sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_api_versions.py diff --git a/sdk/communication/azure-communication-email/azure/communication/email/_api_versions.py b/sdk/communication/azure-communication-email/azure/communication/email/_api_versions.py new file mode 100644 index 000000000000..68194166f4df --- /dev/null +++ b/sdk/communication/azure-communication-email/azure/communication/email/_api_versions.py @@ -0,0 +1,14 @@ +# ------------------------------------ +# Copyright (c) Microsoft Corporation. +# Licensed under the MIT License. +# ------------------------------------ + +from enum import Enum +from azure.core import CaseInsensitiveEnumMeta + + +class ApiVersion(str, Enum, metaclass=CaseInsensitiveEnumMeta): + V2021_10_01_PREVIEW = "2021-10-01-preview" + + +DEFAULT_VERSION = ApiVersion.V2021_10_01_PREVIEW diff --git a/sdk/communication/azure-communication-email/azure/communication/email/_email_client.py b/sdk/communication/azure-communication-email/azure/communication/email/_email_client.py index 34c419729b60..df9ac66455c0 100644 --- a/sdk/communication/azure-communication-email/azure/communication/email/_email_client.py +++ b/sdk/communication/azure-communication-email/azure/communication/email/_email_client.py @@ -14,8 +14,10 @@ from ._generated._azure_communication_email_service import AzureCommunicationEmailService from ._version import SDK_MONIKER from ._generated.models import SendEmailResult, SendStatusResult, EmailMessage +from ._api_versions import DEFAULT_VERSION -class EmailClient(object): # pylint: disable=client-accepts-api-version-keyword + +class EmailClient(object): """A client to interact with the AzureCommunicationService Email gateway. This client provides operations to send an email and monitor its status. @@ -24,6 +26,9 @@ class EmailClient(object): # pylint: disable=client-accepts-api-version-keyword The endpoint url for Azure Communication Service resource. :param Union[TokenCredential, AzureKeyCredential] credential: The credential we use to authenticate against the service. + :keyword api_version: Api Version. Default value is "2021-10-01-preview". Note that overriding + this default value may result in unsupported behavior. + :paramtype api_version: str """ def __init__( self, @@ -40,10 +45,13 @@ def __init__( if endpoint.endswith("/"): endpoint = endpoint[:-1] + self._api_version = kwargs.pop("api_version", DEFAULT_VERSION) + authentication_policy = HMACCredentialsPolicy(endpoint, credential) self._generated_client = AzureCommunicationEmailService( endpoint, + api_version=self._api_version, authentication_policy=authentication_policy, sdk_moniker=SDK_MONIKER, **kwargs diff --git a/sdk/communication/azure-communication-email/azure/communication/email/aio/_email_client_async.py b/sdk/communication/azure-communication-email/azure/communication/email/aio/_email_client_async.py index 10c297f50580..5844d2a64f76 100644 --- a/sdk/communication/azure-communication-email/azure/communication/email/aio/_email_client_async.py +++ b/sdk/communication/azure-communication-email/azure/communication/email/aio/_email_client_async.py @@ -14,6 +14,7 @@ from .._generated.aio._azure_communication_email_service import AzureCommunicationEmailService from .._version import SDK_MONIKER from .._generated.models import SendEmailResult, SendStatusResult, EmailMessage +from .._api_versions import DEFAULT_VERSION class EmailClient(object): # pylint: disable=client-accepts-api-version-keyword """A client to interact with the AzureCommunicationService Email gateway asynchronously. @@ -24,6 +25,9 @@ class EmailClient(object): # pylint: disable=client-accepts-api-version-keyword The endpoint url for Azure Communication Service resource. :param Union[AsyncTokenCredential, AzureKeyCredential] credential: The credential we use to authenticate against the service. + :keyword api_version: Api Version. Default value is "2021-10-01-preview". Note that overriding + this default value may result in unsupported behavior. + :paramtype api_version: str """ def __init__( self, @@ -40,10 +44,13 @@ def __init__( if endpoint.endswith("/"): endpoint = endpoint[:-1] + self._api_version = kwargs.pop("api_version", DEFAULT_VERSION) + authentication_policy = HMACCredentialsPolicy(endpoint, credential) self._generated_client = AzureCommunicationEmailService( endpoint, + api_version=self._api_version, authentication_policy=authentication_policy, sdk_moniker=SDK_MONIKER, **kwargs diff --git a/sdk/communication/azure-communication-identity/azure/communication/identity/_api_versions.py b/sdk/communication/azure-communication-identity/azure/communication/identity/_api_versions.py index 5322934198a1..a9bbb0b2e614 100644 --- a/sdk/communication/azure-communication-identity/azure/communication/identity/_api_versions.py +++ b/sdk/communication/azure-communication-identity/azure/communication/identity/_api_versions.py @@ -6,7 +6,7 @@ from enum import Enum from azure.core import CaseInsensitiveEnumMeta -# pylint: disable=enum-must-be-uppercase + class ApiVersion(str, Enum, metaclass=CaseInsensitiveEnumMeta): V2021_03_07 = "2021-03-07" V2022_06_01 = "2022-06-01" diff --git a/sdk/communication/azure-communication-identity/azure/communication/identity/_communication_identity_client.py b/sdk/communication/azure-communication-identity/azure/communication/identity/_communication_identity_client.py index ce2fd3244576..2551334ba94b 100644 --- a/sdk/communication/azure-communication-identity/azure/communication/identity/_communication_identity_client.py +++ b/sdk/communication/azure-communication-identity/azure/communication/identity/_communication_identity_client.py @@ -21,13 +21,16 @@ from ._generated.models import CommunicationTokenScope -class CommunicationIdentityClient(object): # pylint: disable=client-accepts-api-version-keyword +class CommunicationIdentityClient(object): """Azure Communication Services Identity client. :param str endpoint: The endpoint url for Azure Communication Service resource. :param TokenCredential credential: The TokenCredential we use to authenticate against the service. + :keyword api_version: Api Version. Default value is "2022-06-01". Note that overriding this + default value may result in unsupported behavior. + :paramtype api_version: str .. admonition:: Example: diff --git a/sdk/communication/azure-communication-identity/azure/communication/identity/aio/_communication_identity_client_async.py b/sdk/communication/azure-communication-identity/azure/communication/identity/aio/_communication_identity_client_async.py index 5bb83d184ec3..d36a465b7e8a 100644 --- a/sdk/communication/azure-communication-identity/azure/communication/identity/aio/_communication_identity_client_async.py +++ b/sdk/communication/azure-communication-identity/azure/communication/identity/aio/_communication_identity_client_async.py @@ -20,13 +20,16 @@ from .._generated.models import CommunicationTokenScope -class CommunicationIdentityClient: # pylint: disable=client-accepts-api-version-keyword +class CommunicationIdentityClient: """Azure Communication Services Identity client. :param str endpoint: The endpoint url for Azure Communication Service resource. :param AsyncTokenCredential credential: The AsyncTokenCredential we use to authenticate against the service. + :keyword api_version: Api Version. Default value is "2022-06-01". Note that overriding this + default value may result in unsupported behavior. + :paramtype api_version: str .. admonition:: Example: diff --git a/sdk/communication/azure-communication-networktraversal/azure/communication/networktraversal/_api_versions.py b/sdk/communication/azure-communication-networktraversal/azure/communication/networktraversal/_api_versions.py new file mode 100644 index 000000000000..a7033cdec2a7 --- /dev/null +++ b/sdk/communication/azure-communication-networktraversal/azure/communication/networktraversal/_api_versions.py @@ -0,0 +1,14 @@ +# ------------------------------------ +# Copyright (c) Microsoft Corporation. +# Licensed under the MIT License. +# ------------------------------------ + +from enum import Enum +from azure.core import CaseInsensitiveEnumMeta + + +class ApiVersion(str, Enum, metaclass=CaseInsensitiveEnumMeta): + V2022_03_01_PREVIEW = "2022-03-01-preview" + + +DEFAULT_VERSION = ApiVersion.V2022_03_01_PREVIEW diff --git a/sdk/communication/azure-communication-networktraversal/azure/communication/networktraversal/_communication_relay_client.py b/sdk/communication/azure-communication-networktraversal/azure/communication/networktraversal/_communication_relay_client.py index 022f48208bf2..dc5ad8587cdc 100644 --- a/sdk/communication/azure-communication-networktraversal/azure/communication/networktraversal/_communication_relay_client.py +++ b/sdk/communication/azure-communication-networktraversal/azure/communication/networktraversal/_communication_relay_client.py @@ -14,20 +14,23 @@ from ._shared.utils import parse_connection_str, get_authentication_policy from ._version import SDK_MONIKER from ._generated.models import CommunicationRelayConfiguration +from ._api_versions import DEFAULT_VERSION if TYPE_CHECKING: from azure.core.credentials import TokenCredential from azure.communication.identity import CommunicationUserIdentifier from azure.communication.networktraversal import RouteType -class CommunicationRelayClient(object): # pylint: disable=client-accepts-api-version-keyword +class CommunicationRelayClient(object): """Azure Communication Services Relay client. :param str endpoint: The endpoint url for Azure Communication Service resource. :param TokenCredential credential: The TokenCredential we use to authenticate against the service. - + :keyword api_version: Api Version. Default value is "2022-03-01-preview". Note that overriding + this default value may result in unsupported behavior. + :paramtype api_version: str .. admonition:: Example: .. literalinclude:: ../samples/network_traversal_samples.py @@ -53,8 +56,10 @@ def __init__( "You need to provide account shared key to authenticate.") self._endpoint = endpoint + self._api_version = kwargs.pop("api_version", DEFAULT_VERSION) self._network_traversal_service_client = CommunicationNetworkTraversalClientGen( self._endpoint, + api_version=self._api_version, authentication_policy=get_authentication_policy(endpoint, credential), sdk_moniker=SDK_MONIKER, **kwargs) diff --git a/sdk/communication/azure-communication-networktraversal/azure/communication/networktraversal/aio/_communication_relay_client_async.py b/sdk/communication/azure-communication-networktraversal/azure/communication/networktraversal/aio/_communication_relay_client_async.py index 0b7c6c9848b1..c4c94fb1ede7 100644 --- a/sdk/communication/azure-communication-networktraversal/azure/communication/networktraversal/aio/_communication_relay_client_async.py +++ b/sdk/communication/azure-communication-networktraversal/azure/communication/networktraversal/aio/_communication_relay_client_async.py @@ -11,6 +11,7 @@ import CommunicationNetworkTraversalClient as CommunicationNetworkTraversalClientGen from .._shared.utils import parse_connection_str, get_authentication_policy from .._version import SDK_MONIKER +from .._api_versions import DEFAULT_VERSION if TYPE_CHECKING: from azure.core.credentials_async import AsyncTokenCredential @@ -19,13 +20,16 @@ from azure.communication.networktraversal import RouteType -class CommunicationRelayClient: # pylint: disable=client-accepts-api-version-keyword +class CommunicationRelayClient: """Azure Communication Services Network Traversal client. :param str endpoint: The endpoint url for Azure Communication Service resource. :param AsyncTokenCredential credential: The AsyncTokenCredential we use to authenticate against the service. + :keyword api_version: Api Version. Default value is "2022-03-01-preview". Note that overriding + this default value may result in unsupported behavior. + :paramtype api_version: str .. admonition:: Example: @@ -51,8 +55,10 @@ def __init__( "You need to provide account shared key to authenticate.") self._endpoint = endpoint + self._api_version = kwargs.pop("api_version", DEFAULT_VERSION) self._network_traversal_service_client = CommunicationNetworkTraversalClientGen( self._endpoint, + api_version=self._api_version, authentication_policy=get_authentication_policy(endpoint, credential, decode_url=True, is_async=True), sdk_moniker=SDK_MONIKER, **kwargs) diff --git a/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_api_versions.py b/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_api_versions.py new file mode 100644 index 000000000000..f82fc9055e4f --- /dev/null +++ b/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_api_versions.py @@ -0,0 +1,14 @@ +# ------------------------------------ +# Copyright (c) Microsoft Corporation. +# Licensed under the MIT License. +# ------------------------------------ + +from enum import Enum +from azure.core import CaseInsensitiveEnumMeta + + +class ApiVersion(str, Enum, metaclass=CaseInsensitiveEnumMeta): + V2022_01_11_PREVIEW2 = "2022-01-11-preview2" + + +DEFAULT_VERSION = ApiVersion.V2022_01_11_PREVIEW2 diff --git a/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_phone_numbers_client.py b/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_phone_numbers_client.py index 527a624df292..dbaea9b37c29 100644 --- a/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_phone_numbers_client.py +++ b/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_phone_numbers_client.py @@ -18,9 +18,10 @@ from azure.core.paging import ItemPaged from azure.core.polling import LROPoller from ._generated.models import PhoneNumberSearchResult, PurchasedPhoneNumber, PhoneNumberCapabilities + from ._api_versions import DEFAULT_VERSION -class PhoneNumbersClient(object): # pylint: disable=client-accepts-api-version-keyword +class PhoneNumbersClient(object): """A client to interact with the AzureCommunicationService Phone Numbers gateway. This client provides operations to interact with the phone numbers service @@ -28,6 +29,9 @@ class PhoneNumbersClient(object): # pylint: disable=client-accepts-api-version-k The endpoint url for Azure Communication Service resource. :param TokenCredential credential: The credentials with which to authenticate. + :keyword api_version: Api Version. The default value is "2022-01-11-preview2". Note that + overriding this default value may result in unsupported behavior. + :paramtype api_version: str """ def __init__( self, @@ -47,8 +51,10 @@ def __init__( "You need to provide account shared key to authenticate.") self._endpoint = endpoint + self._api_version = kwargs.pop("api_version", DEFAULT_VERSION) self._phone_number_client = PhoneNumbersClientGen( self._endpoint, + api_version=self._api_version, authentication_policy=get_authentication_policy(endpoint, credential), sdk_moniker=SDK_MONIKER, **kwargs) diff --git a/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/aio/_phone_numbers_client_async.py b/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/aio/_phone_numbers_client_async.py index 0f8d1ae6786d..b30a6c86a306 100644 --- a/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/aio/_phone_numbers_client_async.py +++ b/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/aio/_phone_numbers_client_async.py @@ -20,8 +20,9 @@ from azure.core.async_paging import AsyncItemPaged from azure.core.polling import AsyncLROPoller from .._generated.models import PhoneNumberSearchResult, PurchasedPhoneNumber, PhoneNumberCapabilities + from .._api_versions import DEFAULT_VERSION -class PhoneNumbersClient(object): # pylint: disable=client-accepts-api-version-keyword +class PhoneNumbersClient(object): """A client to interact with the AzureCommunicationService Phone Numbers gateway. This client provides operations to interact with the phone numbers service @@ -29,6 +30,9 @@ class PhoneNumbersClient(object): # pylint: disable=client-accepts-api-version-k The endpoint url for Azure Communication Service resource. :param AsyncTokenCredential credential: The credentials with which to authenticate. + :keyword api_version: Api Version. The default value is "2022-01-11-preview2". Note that + overriding this default value may result in unsupported behavior. + :paramtype api_version: str """ def __init__( self, @@ -48,8 +52,10 @@ def __init__( "You need to provide account shared key to authenticate.") self._endpoint = endpoint + self._api_version = kwargs.pop("api_version", DEFAULT_VERSION) self._phone_number_client = PhoneNumbersClientGen( self._endpoint, + api_version=self._api_version, authentication_policy=get_authentication_policy(endpoint, credential, is_async=True), sdk_moniker=SDK_MONIKER, **kwargs) diff --git a/sdk/communication/azure-communication-rooms/azure/communication/rooms/_api_versions.py b/sdk/communication/azure-communication-rooms/azure/communication/rooms/_api_versions.py index 7626ed9a9ef5..785104ecf928 100644 --- a/sdk/communication/azure-communication-rooms/azure/communication/rooms/_api_versions.py +++ b/sdk/communication/azure-communication-rooms/azure/communication/rooms/_api_versions.py @@ -6,9 +6,8 @@ from enum import Enum from azure.core import CaseInsensitiveEnumMeta -# pylint: disable=enum-must-be-uppercase class ApiVersion(str, Enum, metaclass=CaseInsensitiveEnumMeta): - V2021_04_07_preview = "2021-04-07" - V2022_02_01_preview = "2022-02-01" + V2021_04_07_PREVIEW = "2021-04-07" + V2022_02_01_PREVIEW = "2022-02-01" -DEFAULT_VERSION = ApiVersion.V2022_02_01_preview +DEFAULT_VERSION = ApiVersion.V2022_02_01_PREVIEW diff --git a/sdk/communication/azure-communication-rooms/azure/communication/rooms/_rooms_client.py b/sdk/communication/azure-communication-rooms/azure/communication/rooms/_rooms_client.py index 74c60e5ccb26..5c20276d32a2 100644 --- a/sdk/communication/azure-communication-rooms/azure/communication/rooms/_rooms_client.py +++ b/sdk/communication/azure-communication-rooms/azure/communication/rooms/_rooms_client.py @@ -29,7 +29,7 @@ from ._version import SDK_MONIKER from ._api_versions import DEFAULT_VERSION -class RoomsClient(object): # pylint: disable=client-accepts-api-version-keyword +class RoomsClient(object): """A client to interact with the AzureCommunicationService Rooms gateway. This client provides operations to manage rooms. @@ -38,6 +38,9 @@ class RoomsClient(object): # pylint: disable=client-accepts-api-version-keyword The endpoint url for Azure Communication Service resource. :param ~azure.core.credentials.AzureKeyCredential credential: The access key we use to authenticate against the service. + :keyword api_version: Api Version. Default value is "2022-02-01". Note that overriding this + default value may result in unsupported behavior. + :paramtype api_version: str """ def __init__( self, endpoint: str, @@ -64,7 +67,7 @@ def __init__( self._authentication_policy = HMACCredentialsPolicy(endpoint, credential.key) self._rooms_service_client = AzureCommunicationRoomsService( self._endpoint, - api_version = self._api_version, + api_version=self._api_version, authentication_policy=self._authentication_policy, sdk_moniker=SDK_MONIKER, **kwargs) diff --git a/sdk/communication/azure-communication-rooms/azure/communication/rooms/aio/_rooms_client_async.py b/sdk/communication/azure-communication-rooms/azure/communication/rooms/aio/_rooms_client_async.py index 2bc1f0303703..63a6db9b4c52 100644 --- a/sdk/communication/azure-communication-rooms/azure/communication/rooms/aio/_rooms_client_async.py +++ b/sdk/communication/azure-communication-rooms/azure/communication/rooms/aio/_rooms_client_async.py @@ -25,7 +25,7 @@ UpdateParticipantsRequest ) -class RoomsClient(object): # pylint: disable=client-accepts-api-version-keyword +class RoomsClient(object): """A client to interact with the AzureCommunicationService Rooms gateway. This client provides operations to manage rooms. @@ -34,6 +34,9 @@ class RoomsClient(object): # pylint: disable=client-accepts-api-version-keyword The endpoint url for Azure Communication Service resource. :param ~azure.core.credentials.AzureKeyCredential credential: The access key we use to authenticate against the service. + :keyword api_version: Api Version. Default value is "2022-02-01". Note that overriding this + default value may result in unsupported behavior. + :paramtype api_version: str """ def __init__( self, endpoint: str, From 0fb4e0727c83bdd3f16884fd43169f66572fdacd Mon Sep 17 00:00:00 2001 From: Olena Stoliarova Date: Fri, 16 Sep 2022 13:45:07 +0300 Subject: [PATCH 02/19] fixing imports for phone numbers clients --- .../azure/communication/phonenumbers/_phone_numbers_client.py | 2 +- .../phonenumbers/aio/_phone_numbers_client_async.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_phone_numbers_client.py b/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_phone_numbers_client.py index dbaea9b37c29..a879371d9d27 100644 --- a/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_phone_numbers_client.py +++ b/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_phone_numbers_client.py @@ -11,6 +11,7 @@ from ._generated.models import PhoneNumberSearchRequest from ._shared.utils import parse_connection_str, get_authentication_policy from ._version import SDK_MONIKER +from ._api_versions import DEFAULT_VERSION if TYPE_CHECKING: from typing import Any @@ -18,7 +19,6 @@ from azure.core.paging import ItemPaged from azure.core.polling import LROPoller from ._generated.models import PhoneNumberSearchResult, PurchasedPhoneNumber, PhoneNumberCapabilities - from ._api_versions import DEFAULT_VERSION class PhoneNumbersClient(object): diff --git a/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/aio/_phone_numbers_client_async.py b/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/aio/_phone_numbers_client_async.py index b30a6c86a306..27759f64c8cd 100644 --- a/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/aio/_phone_numbers_client_async.py +++ b/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/aio/_phone_numbers_client_async.py @@ -13,6 +13,7 @@ from .._generated.models import PhoneNumberSearchRequest from .._shared.utils import parse_connection_str, get_authentication_policy from .._version import SDK_MONIKER +from .._api_versions import DEFAULT_VERSION if TYPE_CHECKING: from typing import Any @@ -20,7 +21,6 @@ from azure.core.async_paging import AsyncItemPaged from azure.core.polling import AsyncLROPoller from .._generated.models import PhoneNumberSearchResult, PurchasedPhoneNumber, PhoneNumberCapabilities - from .._api_versions import DEFAULT_VERSION class PhoneNumbersClient(object): """A client to interact with the AzureCommunicationService Phone Numbers gateway. From a2b2897e1ccf3969f01d3ffed908e2b9581b288b Mon Sep 17 00:00:00 2001 From: Olena Stoliarova Date: Tue, 27 Sep 2022 12:49:13 +0300 Subject: [PATCH 03/19] regenerating sms and chat clients --- .../azure/communication/chat/_api_versions.py | 14 + .../azure/communication/chat/_chat_client.py | 9 +- .../communication/chat/_chat_thread_client.py | 9 +- .../communication/chat/_generated/__init__.py | 13 +- .../_azure_communication_chat_service.py | 79 +- .../chat/_generated/_configuration.py | 58 +- .../communication/chat/_generated/_patch.py | 20 + .../chat/_generated/_serialization.py | 1970 ++++++++++++++++ .../communication/chat/_generated/_vendor.py | 27 + .../chat/_generated/aio/__init__.py | 13 +- .../aio/_azure_communication_chat_service.py | 72 +- .../chat/_generated/aio/_configuration.py | 53 +- .../chat/_generated/aio/_patch.py | 20 + .../_generated/aio/operations/__init__.py | 10 +- .../aio/operations/_chat_operations.py | 401 ++-- .../aio/operations/_chat_thread_operations.py | 1689 ++++++++----- .../chat/_generated/aio/operations/_patch.py | 20 + .../chat/_generated/models/__init__.py | 147 +- ..._azure_communication_chat_service_enums.py | 31 +- .../chat/_generated/models/_models.py | 875 ------- .../chat/_generated/models/_models_py3.py | 978 ++++---- .../chat/_generated/models/_patch.py | 20 + .../chat/_generated/operations/__init__.py | 10 +- .../_generated/operations/_chat_operations.py | 486 ++-- .../operations/_chat_thread_operations.py | 2100 ++++++++++++----- .../chat/_generated/operations/_patch.py | 20 + .../chat/aio/_chat_client_async.py | 10 +- .../chat/aio/_chat_thread_client_async.py | 9 +- .../azure/communication/sms/_api_versions.py | 14 + .../communication/sms/_generated/__init__.py | 13 +- .../_azure_communication_sms_service.py | 73 +- .../sms/_generated/_configuration.py | 51 +- .../communication/sms/_generated/_patch.py | 20 + .../sms/_generated/_serialization.py | 1970 ++++++++++++++++ .../communication/sms/_generated/_vendor.py | 16 + .../sms/_generated/aio/__init__.py | 13 +- .../aio/_azure_communication_sms_service.py | 64 +- .../sms/_generated/aio/_configuration.py | 46 +- .../sms/_generated/aio/_patch.py | 20 + .../sms/_generated/aio/operations/__init__.py | 8 +- .../sms/_generated/aio/operations/_patch.py | 20 + .../aio/operations/_sms_operations.py | 176 +- .../sms/_generated/models/__init__.py | 38 +- .../_azure_communication_sms_service_enums.py | 22 +- .../sms/_generated/models/_models.py | 197 -- .../sms/_generated/models/_models_py3.py | 231 +- .../sms/_generated/models/_patch.py | 20 + .../sms/_generated/operations/__init__.py | 8 +- .../sms/_generated/operations/_patch.py | 20 + .../_generated/operations/_sms_operations.py | 206 +- .../azure/communication/sms/_sms_client.py | 8 +- .../sms/aio/_sms_client_async.py | 10 +- 52 files changed, 8945 insertions(+), 3482 deletions(-) create mode 100644 sdk/communication/azure-communication-chat/azure/communication/chat/_api_versions.py create mode 100644 sdk/communication/azure-communication-chat/azure/communication/chat/_generated/_patch.py create mode 100644 sdk/communication/azure-communication-chat/azure/communication/chat/_generated/_serialization.py create mode 100644 sdk/communication/azure-communication-chat/azure/communication/chat/_generated/_vendor.py create mode 100644 sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/_patch.py create mode 100644 sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/operations/_patch.py delete mode 100644 sdk/communication/azure-communication-chat/azure/communication/chat/_generated/models/_models.py create mode 100644 sdk/communication/azure-communication-chat/azure/communication/chat/_generated/models/_patch.py create mode 100644 sdk/communication/azure-communication-chat/azure/communication/chat/_generated/operations/_patch.py create mode 100644 sdk/communication/azure-communication-sms/azure/communication/sms/_api_versions.py create mode 100644 sdk/communication/azure-communication-sms/azure/communication/sms/_generated/_patch.py create mode 100644 sdk/communication/azure-communication-sms/azure/communication/sms/_generated/_serialization.py create mode 100644 sdk/communication/azure-communication-sms/azure/communication/sms/_generated/_vendor.py create mode 100644 sdk/communication/azure-communication-sms/azure/communication/sms/_generated/aio/_patch.py create mode 100644 sdk/communication/azure-communication-sms/azure/communication/sms/_generated/aio/operations/_patch.py delete mode 100644 sdk/communication/azure-communication-sms/azure/communication/sms/_generated/models/_models.py create mode 100644 sdk/communication/azure-communication-sms/azure/communication/sms/_generated/models/_patch.py create mode 100644 sdk/communication/azure-communication-sms/azure/communication/sms/_generated/operations/_patch.py diff --git a/sdk/communication/azure-communication-chat/azure/communication/chat/_api_versions.py b/sdk/communication/azure-communication-chat/azure/communication/chat/_api_versions.py new file mode 100644 index 000000000000..707620078403 --- /dev/null +++ b/sdk/communication/azure-communication-chat/azure/communication/chat/_api_versions.py @@ -0,0 +1,14 @@ +# ------------------------------------ +# Copyright (c) Microsoft Corporation. +# Licensed under the MIT License. +# ------------------------------------ + +from enum import Enum +from azure.core import CaseInsensitiveEnumMeta + + +class ApiVersion(str, Enum, metaclass=CaseInsensitiveEnumMeta): + V2021_09_07 = "2021-09-07" + + +DEFAULT_VERSION = ApiVersion.V2021_09_07 diff --git a/sdk/communication/azure-communication-chat/azure/communication/chat/_chat_client.py b/sdk/communication/azure-communication-chat/azure/communication/chat/_chat_client.py index 0c334008cd71..801348cbbee2 100644 --- a/sdk/communication/azure-communication-chat/azure/communication/chat/_chat_client.py +++ b/sdk/communication/azure-communication-chat/azure/communication/chat/_chat_client.py @@ -24,6 +24,7 @@ CommunicationErrorResponseConverter ) from ._version import SDK_MONIKER +from ._api_versions import DEFAULT_VERSION if TYPE_CHECKING: # pylint: disable=unused-import,ungrouped-imports @@ -32,7 +33,7 @@ from azure.core.paging import ItemPaged -class ChatClient(object): # pylint: disable=client-accepts-api-version-keyword +class ChatClient(object): """A client to interact with the AzureCommunicationService Chat gateway. This client provides operations to create chat thread, delete chat thread, @@ -43,6 +44,10 @@ class ChatClient(object): # pylint: disable=client-accepts-api-version-keyword :param CommunicationTokenCredential credential: The credentials with which to authenticate. + :keyword api_version: Api Version. Default value is "2021-09-07". Note that overriding this + default value may result in unsupported behavior. + :paramtype api_version: str + .. admonition:: Example: .. literalinclude:: ../samples/chat_client_sample.py @@ -74,10 +79,12 @@ def __init__( raise ValueError("Invalid URL: {}".format(endpoint)) self._endpoint = endpoint + self._api_version = kwargs.pop("api_version", DEFAULT_VERSION) self._credential = credential self._client = AzureCommunicationChatService( self._endpoint, + api_version=self._api_version, authentication_policy=BearerTokenCredentialPolicy(self._credential), sdk_moniker=SDK_MONIKER, **kwargs diff --git a/sdk/communication/azure-communication-chat/azure/communication/chat/_chat_thread_client.py b/sdk/communication/azure-communication-chat/azure/communication/chat/_chat_thread_client.py index 0a206322b31b..b8ecc112b55e 100644 --- a/sdk/communication/azure-communication-chat/azure/communication/chat/_chat_thread_client.py +++ b/sdk/communication/azure-communication-chat/azure/communication/chat/_chat_thread_client.py @@ -33,6 +33,7 @@ from ._communication_identifier_serializer import serialize_identifier from ._utils import CommunicationErrorResponseConverter from ._version import SDK_MONIKER +from ._api_versions import DEFAULT_VERSION if TYPE_CHECKING: # pylint: disable=unused-import,ungrouped-imports @@ -41,7 +42,7 @@ from azure.core.paging import ItemPaged -class ChatThreadClient(object): # pylint: disable=client-accepts-api-version-keyword +class ChatThreadClient(object): """A client to interact with the AzureCommunicationService Chat gateway. Instances of this class is normally retrieved by ChatClient.get_chat_thread_client() @@ -60,6 +61,10 @@ class ChatThreadClient(object): # pylint: disable=client-accepts-api-version-key :param str thread_id: The unique thread id. + :keyword api_version: Api Version. Default value is "2021-09-07". Note that overriding this + default value may result in unsupported behavior. + :paramtype api_version: str + .. admonition:: Example: .. literalinclude:: ../samples/chat_thread_client_sample.py @@ -96,10 +101,12 @@ def __init__( self._thread_id = thread_id self._endpoint = endpoint + self._api_version = kwargs.pop("api_version", DEFAULT_VERSION) self._credential = credential self._client = AzureCommunicationChatService( endpoint, + api_version=self._api_version, authentication_policy=BearerTokenCredentialPolicy(self._credential), sdk_moniker=SDK_MONIKER, **kwargs diff --git a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/__init__.py b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/__init__.py index 8dc4fad2a1ac..9de5d6d8f3d2 100644 --- a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/__init__.py +++ b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/__init__.py @@ -7,10 +7,15 @@ # -------------------------------------------------------------------------- from ._azure_communication_chat_service import AzureCommunicationChatService -__all__ = ['AzureCommunicationChatService'] try: - from ._patch import patch_sdk # type: ignore - patch_sdk() + from ._patch import __all__ as _patch_all + from ._patch import * # type: ignore # pylint: disable=unused-wildcard-import except ImportError: - pass + _patch_all = [] +from ._patch import patch_sdk as _patch_sdk + +__all__ = ["AzureCommunicationChatService"] +__all__.extend([p for p in _patch_all if p not in __all__]) + +_patch_sdk() diff --git a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/_azure_communication_chat_service.py b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/_azure_communication_chat_service.py index 78780c4d9d5d..3d5ddb26a688 100644 --- a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/_azure_communication_chat_service.py +++ b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/_azure_communication_chat_service.py @@ -6,71 +6,72 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import TYPE_CHECKING +from copy import deepcopy +from typing import Any from azure.core import PipelineClient -from msrest import Deserializer, Serializer +from azure.core.credentials import AzureKeyCredential +from azure.core.rest import HttpRequest, HttpResponse -if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports - from typing import Any - - from azure.core.pipeline.transport import HttpRequest, HttpResponse - -from ._configuration import AzureCommunicationChatServiceConfiguration -from .operations import ChatThreadOperations -from .operations import ChatOperations from . import models +from ._configuration import AzureCommunicationChatServiceConfiguration +from ._serialization import Deserializer, Serializer +from .operations import ChatOperations, ChatThreadOperations -class AzureCommunicationChatService(object): +class AzureCommunicationChatService: # pylint: disable=client-accepts-api-version-keyword """Azure Communication Chat Service. :ivar chat_thread: ChatThreadOperations operations :vartype chat_thread: azure.communication.chat.operations.ChatThreadOperations :ivar chat: ChatOperations operations :vartype chat: azure.communication.chat.operations.ChatOperations - :param endpoint: The endpoint of the Azure Communication resource. + :param credential: Credential needed for the client to connect to Azure. Required. + :type credential: ~azure.core.credentials.AzureKeyCredential + :param endpoint: The endpoint of the Azure Communication resource. Required. :type endpoint: str + :keyword api_version: Api Version. Default value is "2021-09-07". Note that overriding this + default value may result in unsupported behavior. + :paramtype api_version: str """ - def __init__( - self, - endpoint, # type: str - **kwargs # type: Any - ): - # type: (...) -> None - base_url = '{endpoint}' - self._config = AzureCommunicationChatServiceConfiguration(endpoint, **kwargs) - self._client = PipelineClient(base_url=base_url, config=self._config, **kwargs) + def __init__(self, credential: AzureKeyCredential, endpoint: str, **kwargs: Any) -> None: + _endpoint = "{endpoint}" + self._config = AzureCommunicationChatServiceConfiguration(credential=credential, endpoint=endpoint, **kwargs) + self._client = PipelineClient(base_url=_endpoint, config=self._config, **kwargs) client_models = {k: v for k, v in models.__dict__.items() if isinstance(v, type)} self._serialize = Serializer(client_models) - self._serialize.client_side_validation = False self._deserialize = Deserializer(client_models) + self._serialize.client_side_validation = False + self.chat_thread = ChatThreadOperations(self._client, self._config, self._serialize, self._deserialize) + self.chat = ChatOperations(self._client, self._config, self._serialize, self._deserialize) - self.chat_thread = ChatThreadOperations( - self._client, self._config, self._serialize, self._deserialize) - self.chat = ChatOperations( - self._client, self._config, self._serialize, self._deserialize) - - def _send_request(self, http_request, **kwargs): - # type: (HttpRequest, Any) -> HttpResponse + def _send_request(self, request: HttpRequest, **kwargs: Any) -> HttpResponse: """Runs the network request through the client's chained policies. - :param http_request: The network request you want to make. Required. - :type http_request: ~azure.core.pipeline.transport.HttpRequest - :keyword bool stream: Whether the response payload will be streamed. Defaults to True. + >>> from azure.core.rest import HttpRequest + >>> request = HttpRequest("GET", "https://www.example.org/") + + >>> response = client._send_request(request) + + + For more information on this code flow, see https://aka.ms/azsdk/dpcodegen/python/send_request + + :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.pipeline.transport.HttpResponse + :rtype: ~azure.core.rest.HttpResponse """ + + request_copy = deepcopy(request) path_format_arguments = { - 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), + "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), } - http_request.url = self._client.format_url(http_request.url, **path_format_arguments) - stream = kwargs.pop("stream", True) - pipeline_response = self._client._pipeline.run(http_request, stream=stream, **kwargs) - return pipeline_response.http_response + + request_copy.url = self._client.format_url(request_copy.url, **path_format_arguments) + return self._client.send_request(request_copy, **kwargs) def close(self): # type: () -> None diff --git a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/_configuration.py b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/_configuration.py index 5b58f12b9f2e..779b2fca3569 100644 --- a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/_configuration.py +++ b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/_configuration.py @@ -6,53 +6,57 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import TYPE_CHECKING +from typing import Any from azure.core.configuration import Configuration +from azure.core.credentials import AzureKeyCredential from azure.core.pipeline import policies -if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports - from typing import Any - VERSION = "unknown" -class AzureCommunicationChatServiceConfiguration(Configuration): + +class AzureCommunicationChatServiceConfiguration(Configuration): # pylint: disable=too-many-instance-attributes """Configuration for AzureCommunicationChatService. Note that all parameters used to create this instance are saved as instance attributes. - :param endpoint: The endpoint of the Azure Communication resource. + :param credential: Credential needed for the client to connect to Azure. Required. + :type credential: ~azure.core.credentials.AzureKeyCredential + :param endpoint: The endpoint of the Azure Communication resource. Required. :type endpoint: str + :keyword api_version: Api Version. Default value is "2021-09-07". Note that overriding this + default value may result in unsupported behavior. + :paramtype api_version: str """ - def __init__( - self, - endpoint, # type: str - **kwargs # type: Any - ): - # type: (...) -> None + def __init__(self, credential: AzureKeyCredential, endpoint: str, **kwargs: Any) -> None: + super(AzureCommunicationChatServiceConfiguration, self).__init__(**kwargs) + api_version = kwargs.pop("api_version", "2021-09-07") # type: str + + if credential is None: + raise ValueError("Parameter 'credential' must not be None.") if endpoint is None: raise ValueError("Parameter 'endpoint' must not be None.") - super(AzureCommunicationChatServiceConfiguration, self).__init__(**kwargs) + self.credential = credential self.endpoint = endpoint - self.api_version = "2021-09-07" - kwargs.setdefault('sdk_moniker', 'azurecommunicationchatservice/{}'.format(VERSION)) + self.api_version = api_version + kwargs.setdefault("sdk_moniker", "azurecommunicationchatservice/{}".format(VERSION)) self._configure(**kwargs) def _configure( - self, - **kwargs # type: Any + self, **kwargs # type: Any ): # type: (...) -> None - 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 policies.HttpLoggingPolicy(**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') + 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 policies.HttpLoggingPolicy(**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 = policies.AzureKeyCredentialPolicy(self.credential, "Authorization", **kwargs) diff --git a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/_patch.py b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/_patch.py new file mode 100644 index 000000000000..f7dd32510333 --- /dev/null +++ b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/_patch.py @@ -0,0 +1,20 @@ +# ------------------------------------ +# Copyright (c) Microsoft Corporation. +# Licensed under the MIT License. +# ------------------------------------ +"""Customize generated code here. + +Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize +""" +from typing import List + +__all__: List[str] = [] # Add all objects you want publicly available to users at this package level + + +def patch_sdk(): + """Do not remove from this file. + + `patch_sdk` is a last resort escape hatch that allows you to do customizations + you can't accomplish using the techniques described in + https://aka.ms/azsdk/python/dpcodegen/python/customize + """ diff --git a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/_serialization.py b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/_serialization.py new file mode 100644 index 000000000000..7c1dedb5133d --- /dev/null +++ b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/_serialization.py @@ -0,0 +1,1970 @@ +# -------------------------------------------------------------------------- +# +# 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 + +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 + +try: + from urllib import quote # type: ignore +except ImportError: + from urllib.parse import quote # type: ignore +import xml.etree.ElementTree as ET + +import isodate + +from typing import Dict, Any, cast, TYPE_CHECKING + +from azure.core.exceptions import DeserializationError, SerializationError, raise_with_traceback + +_BOM = codecs.BOM_UTF8.decode(encoding="utf-8") + +if TYPE_CHECKING: + from typing import Optional, Union, AnyStr, IO, Mapping + + +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, content_type=None): + # type: (Optional[Union[AnyStr, IO]], Optional[str]) -> 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, headers): + # type: (Optional[Union[AnyStr, IO]], 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 # type: ignore + unicode_str = str # type: ignore + +_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 +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 "".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 # type: ignore +except ImportError: + TZ_UTC = UTC() # type: ignore + +_FLATTEN = re.compile(r"(? 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=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(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) + continue + if xml_desc.get("text", False): + serialized.text = new_attr + continue + if isinstance(new_attr, list): + serialized.extend(new_attr) + 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) + 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) + else: # JSON + for k in reversed(keys): + unflattened = {k: new_attr} + new_attr = unflattened + + _new_attr = new_attr + _serialized = serialized + for k in keys: + if k not in _serialized: + _serialized.update(_new_attr) + _new_attr = _new_attr[k] + _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 = data_type.strip("[]{}") + internal_data_type = self.dependencies.get(internal_data_type, 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 = [ + 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_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): + # 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) + return result + except ValueError: + for enum_value in enum_obj: + 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: + 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 = 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=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(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 + 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 + 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 deseralize. + """ + 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__ + + 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 deseralize. + :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) + 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) + 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 value 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 is empty string. + return "" + else: + # None or '', node 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): + 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)) + + @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) + attr = attr + padding + 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) + 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) + + @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): + 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): + 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) + 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() + 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) + 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 diff --git a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/_vendor.py b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/_vendor.py new file mode 100644 index 000000000000..9aad73fc743e --- /dev/null +++ b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/_vendor.py @@ -0,0 +1,27 @@ +# -------------------------------------------------------------------------- +# 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 azure.core.pipeline.transport import HttpRequest + + +def _convert_request(request, files=None): + data = request.content if not files else None + request = HttpRequest(method=request.method, url=request.url, headers=request.headers, data=data) + if files: + request.set_formdata_body(files) + return request + + +def _format_url_section(template, **kwargs): + components = template.split("/") + while components: + try: + return template.format(**kwargs) + except KeyError as key: + formatted_components = template.split("/") + components = [c for c in formatted_components if "{}".format(key.args[0]) not in c] + template = "/".join(components) diff --git a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/__init__.py b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/__init__.py index 70f222baebdc..9de5d6d8f3d2 100644 --- a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/__init__.py +++ b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/__init__.py @@ -7,4 +7,15 @@ # -------------------------------------------------------------------------- from ._azure_communication_chat_service import AzureCommunicationChatService -__all__ = ['AzureCommunicationChatService'] + +try: + from ._patch import __all__ as _patch_all + from ._patch import * # type: ignore # pylint: disable=unused-wildcard-import +except ImportError: + _patch_all = [] +from ._patch import patch_sdk as _patch_sdk + +__all__ = ["AzureCommunicationChatService"] +__all__.extend([p for p in _patch_all if p not in __all__]) + +_patch_sdk() diff --git a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/_azure_communication_chat_service.py b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/_azure_communication_chat_service.py index 97865a75beaf..4aee3f9f4649 100644 --- a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/_azure_communication_chat_service.py +++ b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/_azure_communication_chat_service.py @@ -6,64 +6,72 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any +from copy import deepcopy +from typing import Any, Awaitable from azure.core import AsyncPipelineClient -from azure.core.pipeline.transport import AsyncHttpResponse, HttpRequest -from msrest import Deserializer, Serializer +from azure.core.credentials import AzureKeyCredential +from azure.core.rest import AsyncHttpResponse, HttpRequest -from ._configuration import AzureCommunicationChatServiceConfiguration -from .operations import ChatThreadOperations -from .operations import ChatOperations from .. import models +from .._serialization import Deserializer, Serializer +from ._configuration import AzureCommunicationChatServiceConfiguration +from .operations import ChatOperations, ChatThreadOperations -class AzureCommunicationChatService(object): +class AzureCommunicationChatService: # pylint: disable=client-accepts-api-version-keyword """Azure Communication Chat Service. :ivar chat_thread: ChatThreadOperations operations :vartype chat_thread: azure.communication.chat.aio.operations.ChatThreadOperations :ivar chat: ChatOperations operations :vartype chat: azure.communication.chat.aio.operations.ChatOperations - :param endpoint: The endpoint of the Azure Communication resource. + :param credential: Credential needed for the client to connect to Azure. Required. + :type credential: ~azure.core.credentials.AzureKeyCredential + :param endpoint: The endpoint of the Azure Communication resource. Required. :type endpoint: str + :keyword api_version: Api Version. Default value is "2021-09-07". Note that overriding this + default value may result in unsupported behavior. + :paramtype api_version: str """ - def __init__( - self, - endpoint: str, - **kwargs: Any - ) -> None: - base_url = '{endpoint}' - self._config = AzureCommunicationChatServiceConfiguration(endpoint, **kwargs) - self._client = AsyncPipelineClient(base_url=base_url, config=self._config, **kwargs) + def __init__(self, credential: AzureKeyCredential, endpoint: str, **kwargs: Any) -> None: + _endpoint = "{endpoint}" + self._config = AzureCommunicationChatServiceConfiguration(credential=credential, endpoint=endpoint, **kwargs) + self._client = AsyncPipelineClient(base_url=_endpoint, config=self._config, **kwargs) client_models = {k: v for k, v in models.__dict__.items() if isinstance(v, type)} self._serialize = Serializer(client_models) - self._serialize.client_side_validation = False self._deserialize = Deserializer(client_models) + self._serialize.client_side_validation = False + self.chat_thread = ChatThreadOperations(self._client, self._config, self._serialize, self._deserialize) + self.chat = ChatOperations(self._client, self._config, self._serialize, self._deserialize) - self.chat_thread = ChatThreadOperations( - self._client, self._config, self._serialize, self._deserialize) - self.chat = ChatOperations( - self._client, self._config, self._serialize, self._deserialize) - - async def _send_request(self, http_request: HttpRequest, **kwargs: Any) -> AsyncHttpResponse: + def _send_request(self, request: HttpRequest, **kwargs: Any) -> Awaitable[AsyncHttpResponse]: """Runs the network request through the client's chained policies. - :param http_request: The network request you want to make. Required. - :type http_request: ~azure.core.pipeline.transport.HttpRequest - :keyword bool stream: Whether the response payload will be streamed. Defaults to True. + >>> from azure.core.rest import HttpRequest + >>> request = HttpRequest("GET", "https://www.example.org/") + + >>> response = await client._send_request(request) + + + For more information on this code flow, see https://aka.ms/azsdk/dpcodegen/python/send_request + + :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.pipeline.transport.AsyncHttpResponse + :rtype: ~azure.core.rest.AsyncHttpResponse """ + + request_copy = deepcopy(request) path_format_arguments = { - 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), + "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), } - http_request.url = self._client.format_url(http_request.url, **path_format_arguments) - stream = kwargs.pop("stream", True) - pipeline_response = await self._client._pipeline.run(http_request, stream=stream, **kwargs) - return pipeline_response.http_response + + request_copy.url = self._client.format_url(request_copy.url, **path_format_arguments) + return self._client.send_request(request_copy, **kwargs) async def close(self) -> None: await self._client.close() diff --git a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/_configuration.py b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/_configuration.py index 00cb6d19b824..77a2651ff4db 100644 --- a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/_configuration.py +++ b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/_configuration.py @@ -9,44 +9,51 @@ from typing import Any from azure.core.configuration import Configuration +from azure.core.credentials import AzureKeyCredential from azure.core.pipeline import policies VERSION = "unknown" -class AzureCommunicationChatServiceConfiguration(Configuration): + +class AzureCommunicationChatServiceConfiguration(Configuration): # pylint: disable=too-many-instance-attributes """Configuration for AzureCommunicationChatService. Note that all parameters used to create this instance are saved as instance attributes. - :param endpoint: The endpoint of the Azure Communication resource. + :param credential: Credential needed for the client to connect to Azure. Required. + :type credential: ~azure.core.credentials.AzureKeyCredential + :param endpoint: The endpoint of the Azure Communication resource. Required. :type endpoint: str + :keyword api_version: Api Version. Default value is "2021-09-07". Note that overriding this + default value may result in unsupported behavior. + :paramtype api_version: str """ - def __init__( - self, - endpoint: str, - **kwargs: Any - ) -> None: + def __init__(self, credential: AzureKeyCredential, endpoint: str, **kwargs: Any) -> None: + super(AzureCommunicationChatServiceConfiguration, self).__init__(**kwargs) + api_version = kwargs.pop("api_version", "2021-09-07") # type: str + + if credential is None: + raise ValueError("Parameter 'credential' must not be None.") if endpoint is None: raise ValueError("Parameter 'endpoint' must not be None.") - super(AzureCommunicationChatServiceConfiguration, self).__init__(**kwargs) + self.credential = credential self.endpoint = endpoint - self.api_version = "2021-09-07" - kwargs.setdefault('sdk_moniker', 'azurecommunicationchatservice/{}'.format(VERSION)) + self.api_version = api_version + kwargs.setdefault("sdk_moniker", "azurecommunicationchatservice/{}".format(VERSION)) self._configure(**kwargs) - def _configure( - self, - **kwargs: Any - ) -> None: - 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 policies.HttpLoggingPolicy(**kwargs) - self.retry_policy = kwargs.get('retry_policy') or policies.AsyncRetryPolicy(**kwargs) - self.custom_hook_policy = kwargs.get('custom_hook_policy') or policies.CustomHookPolicy(**kwargs) - self.redirect_policy = kwargs.get('redirect_policy') or policies.AsyncRedirectPolicy(**kwargs) - self.authentication_policy = kwargs.get('authentication_policy') + def _configure(self, **kwargs: Any) -> None: + 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 policies.HttpLoggingPolicy(**kwargs) + self.retry_policy = kwargs.get("retry_policy") or policies.AsyncRetryPolicy(**kwargs) + self.custom_hook_policy = kwargs.get("custom_hook_policy") or policies.CustomHookPolicy(**kwargs) + self.redirect_policy = kwargs.get("redirect_policy") or policies.AsyncRedirectPolicy(**kwargs) + self.authentication_policy = kwargs.get("authentication_policy") + if self.credential and not self.authentication_policy: + self.authentication_policy = policies.AzureKeyCredentialPolicy(self.credential, "Authorization", **kwargs) diff --git a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/_patch.py b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/_patch.py new file mode 100644 index 000000000000..f7dd32510333 --- /dev/null +++ b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/_patch.py @@ -0,0 +1,20 @@ +# ------------------------------------ +# Copyright (c) Microsoft Corporation. +# Licensed under the MIT License. +# ------------------------------------ +"""Customize generated code here. + +Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize +""" +from typing import List + +__all__: List[str] = [] # Add all objects you want publicly available to users at this package level + + +def patch_sdk(): + """Do not remove from this file. + + `patch_sdk` is a last resort escape hatch that allows you to do customizations + you can't accomplish using the techniques described in + https://aka.ms/azsdk/python/dpcodegen/python/customize + """ diff --git a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/operations/__init__.py b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/operations/__init__.py index ca0d822356d7..dbe389acb5e7 100644 --- a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/operations/__init__.py +++ b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/operations/__init__.py @@ -9,7 +9,13 @@ from ._chat_thread_operations import ChatThreadOperations from ._chat_operations import ChatOperations +from ._patch import __all__ as _patch_all +from ._patch import * # type: ignore # pylint: disable=unused-wildcard-import +from ._patch import patch_sdk as _patch_sdk + __all__ = [ - 'ChatThreadOperations', - 'ChatOperations', + "ChatThreadOperations", + "ChatOperations", ] +__all__.extend([p for p in _patch_all if p not in __all__]) +_patch_sdk() diff --git a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/operations/_chat_operations.py b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/operations/_chat_operations.py index 0295ca765368..24b14a75da33 100644 --- a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/operations/_chat_operations.py +++ b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/operations/_chat_operations.py @@ -1,3 +1,4 @@ +# pylint: disable=too-many-lines # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -6,182 +7,299 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- import datetime -from typing import Any, AsyncIterable, Callable, Dict, Generic, Optional, TypeVar -import warnings +from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, TypeVar, Union, overload +from urllib.parse import parse_qs, urljoin, urlparse from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + map_error, +) from azure.core.pipeline import PipelineResponse -from azure.core.pipeline.transport import AsyncHttpResponse, HttpRequest +from azure.core.pipeline.transport import AsyncHttpResponse +from azure.core.rest import HttpRequest +from azure.core.tracing.decorator import distributed_trace +from azure.core.tracing.decorator_async import distributed_trace_async +from azure.core.utils import case_insensitive_dict from ... import models as _models - -T = TypeVar('T') +from ..._vendor import _convert_request +from ...operations._chat_operations import ( + build_create_chat_thread_request, + build_delete_chat_thread_request, + build_list_chat_threads_request, +) + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] -class ChatOperations: - """ChatOperations async operations. - You should not instantiate this class directly. Instead, you should create a Client instance that - instantiates it for you and attaches it as an attribute. +class ChatOperations: + """ + .. warning:: + **DO NOT** instantiate this class directly. - :ivar models: Alias to model classes used in this operation group. - :type models: ~azure.communication.chat.models - :param client: Client for service requests. - :param config: Configuration of service client. - :param serializer: An object model serializer. - :param deserializer: An object model deserializer. + Instead, you should access the following operations through + :class:`~azure.communication.chat.aio.AzureCommunicationChatService`'s + :attr:`chat` attribute. """ models = _models - def __init__(self, client, config, serializer, deserializer) -> None: - self._client = client - self._serialize = serializer - self._deserialize = deserializer - self._config = config + def __init__(self, *args, **kwargs) -> None: + input_args = list(args) + self._client = input_args.pop(0) if input_args else kwargs.pop("client") + self._config = input_args.pop(0) if input_args else kwargs.pop("config") + self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") + self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") + @overload async def create_chat_thread( self, - create_chat_thread_request: "_models.CreateChatThreadRequest", + create_chat_thread_request: _models.CreateChatThreadRequest, repeatability_request_id: Optional[str] = None, + *, + content_type: str = "application/json", **kwargs: Any - ) -> "_models.CreateChatThreadResult": + ) -> _models.CreateChatThreadResult: """Creates a chat thread. Creates a chat thread. - :param create_chat_thread_request: Request payload for creating a chat thread. + :param create_chat_thread_request: Request payload for creating a chat thread. Required. :type create_chat_thread_request: ~azure.communication.chat.models.CreateChatThreadRequest :param repeatability_request_id: If specified, the client directs that the request is repeatable; that is, that the client can make the request multiple times with the same Repeatability-Request-Id and get back an appropriate response without the server executing the request multiple times. The value of the Repeatability-Request-Id is an opaque string representing a client-generated, globally unique for all time, identifier for the request. It - is recommended to use version 4 (random) UUIDs. + is recommended to use version 4 (random) UUIDs. Default value is None. + :type repeatability_request_id: str + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: CreateChatThreadResult or the result of cls(response) + :rtype: ~azure.communication.chat.models.CreateChatThreadResult + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + async def create_chat_thread( + self, + create_chat_thread_request: IO, + repeatability_request_id: Optional[str] = None, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.CreateChatThreadResult: + """Creates a chat thread. + + Creates a chat thread. + + :param create_chat_thread_request: Request payload for creating a chat thread. Required. + :type create_chat_thread_request: IO + :param repeatability_request_id: If specified, the client directs that the request is + repeatable; that is, that the client can make the request multiple times with the same + Repeatability-Request-Id and get back an appropriate response without the server executing the + request multiple times. The value of the Repeatability-Request-Id is an opaque string + representing a client-generated, globally unique for all time, identifier for the request. It + is recommended to use version 4 (random) UUIDs. Default value is None. + :type repeatability_request_id: str + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: CreateChatThreadResult or the result of cls(response) + :rtype: ~azure.communication.chat.models.CreateChatThreadResult + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace_async + async def create_chat_thread( + self, + create_chat_thread_request: Union[_models.CreateChatThreadRequest, IO], + repeatability_request_id: Optional[str] = None, + **kwargs: Any + ) -> _models.CreateChatThreadResult: + """Creates a chat thread. + + Creates a chat thread. + + :param create_chat_thread_request: Request payload for creating a chat thread. Is either a + model type or a IO type. Required. + :type create_chat_thread_request: ~azure.communication.chat.models.CreateChatThreadRequest or + IO + :param repeatability_request_id: If specified, the client directs that the request is + repeatable; that is, that the client can make the request multiple times with the same + Repeatability-Request-Id and get back an appropriate response without the server executing the + request multiple times. The value of the Repeatability-Request-Id is an opaque string + representing a client-generated, globally unique for all time, identifier for the request. It + is recommended to use version 4 (random) UUIDs. Default value is None. :type repeatability_request_id: str + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: CreateChatThreadResult, or the result of cls(response) + :return: CreateChatThreadResult or the result of cls(response) :rtype: ~azure.communication.chat.models.CreateChatThreadResult - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - cls = kwargs.pop('cls', None) # type: ClsType["_models.CreateChatThreadResult"] error_map = { 404: ResourceNotFoundError, 409: ResourceExistsError, - 401: lambda response: ClientAuthenticationError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 403: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 429: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 503: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 304: ResourceNotModifiedError, + 401: lambda response: ClientAuthenticationError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 403: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 429: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 503: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), } - error_map.update(kwargs.pop('error_map', {})) - api_version = "2021-09-07" - content_type = kwargs.pop("content_type", "application/json") - accept = "application/json" - - # Construct URL - url = self.create_chat_thread.metadata['url'] # type: ignore + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.CreateChatThreadResult] + + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(create_chat_thread_request, (IO, bytes)): + _content = create_chat_thread_request + else: + _json = self._serialize.body(create_chat_thread_request, "CreateChatThreadRequest") + + request = build_create_chat_thread_request( + repeatability_request_id=repeatability_request_id, + api_version=api_version, + content_type=content_type, + json=_json, + content=_content, + template_url=self.create_chat_thread.metadata["url"], + headers=_headers, + params=_params, + ) + request = _convert_request(request) path_format_arguments = { - 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), + "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), } - url = self._client.format_url(url, **path_format_arguments) - - # Construct parameters - query_parameters = {} # type: Dict[str, Any] - query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') - - # Construct headers - header_parameters = {} # type: Dict[str, Any] - if repeatability_request_id is not None: - header_parameters['repeatability-request-id'] = self._serialize.header("repeatability_request_id", repeatability_request_id, 'str') - header_parameters['Content-Type'] = self._serialize.header("content_type", content_type, 'str') - header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') - - body_content_kwargs = {} # type: Dict[str, Any] - body_content = self._serialize.body(create_chat_thread_request, 'CreateChatThreadRequest') - body_content_kwargs['content'] = body_content - request = self._client.post(url, query_parameters, header_parameters, **body_content_kwargs) - pipeline_response = await self._client._pipeline.run(request, stream=False, **kwargs) + request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore + + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) + response = pipeline_response.http_response if response.status_code not in [201]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response) - deserialized = self._deserialize('CreateChatThreadResult', pipeline_response) + deserialized = self._deserialize("CreateChatThreadResult", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - create_chat_thread.metadata = {'url': '/chat/threads'} # type: ignore + create_chat_thread.metadata = {"url": "/chat/threads"} # type: ignore + + @distributed_trace def list_chat_threads( - self, - max_page_size: Optional[int] = None, - start_time: Optional[datetime.datetime] = None, - **kwargs: Any - ) -> AsyncIterable["_models.ChatThreadsItemCollection"]: + self, max_page_size: Optional[int] = None, start_time: Optional[datetime.datetime] = None, **kwargs: Any + ) -> AsyncIterable["_models.ChatThreadItem"]: """Gets the list of chat threads of a user. Gets the list of chat threads of a user. - :param max_page_size: The maximum number of chat threads returned per page. + :param max_page_size: The maximum number of chat threads returned per page. Default value is + None. :type max_page_size: int :param start_time: The earliest point in time to get chat threads up to. The timestamp should - be in RFC3339 format: ``yyyy-MM-ddTHH:mm:ssZ``. + be in RFC3339 format: ``yyyy-MM-ddTHH:mm:ssZ``. Default value is None. :type start_time: ~datetime.datetime :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either ChatThreadsItemCollection or the result of cls(response) - :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.communication.chat.models.ChatThreadsItemCollection] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either ChatThreadItem or the result of cls(response) + :rtype: + ~azure.core.async_paging.AsyncItemPaged[~azure.communication.chat.models.ChatThreadItem] + :raises ~azure.core.exceptions.HttpResponseError: """ - cls = kwargs.pop('cls', None) # type: ClsType["_models.ChatThreadsItemCollection"] + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.ChatThreadsItemCollection] + error_map = { 404: ResourceNotFoundError, 409: ResourceExistsError, - 401: lambda response: ClientAuthenticationError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 403: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 429: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 503: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 304: ResourceNotModifiedError, + 401: lambda response: ClientAuthenticationError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 403: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 429: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 503: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), } - error_map.update(kwargs.pop('error_map', {})) - api_version = "2021-09-07" - accept = "application/json" + error_map.update(kwargs.pop("error_map", {}) or {}) def prepare_request(next_link=None): - # Construct headers - header_parameters = {} # type: Dict[str, Any] - header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') - if not next_link: - # Construct URL - url = self.list_chat_threads.metadata['url'] # type: ignore + + request = build_list_chat_threads_request( + max_page_size=max_page_size, + start_time=start_time, + api_version=api_version, + template_url=self.list_chat_threads.metadata["url"], + headers=_headers, + params=_params, + ) + request = _convert_request(request) path_format_arguments = { - 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), + "endpoint": self._serialize.url( + "self._config.endpoint", self._config.endpoint, "str", skip_quote=True + ), } - url = self._client.format_url(url, **path_format_arguments) - # Construct parameters - query_parameters = {} # type: Dict[str, Any] - if max_page_size is not None: - query_parameters['maxPageSize'] = self._serialize.query("max_page_size", max_page_size, 'int') - if start_time is not None: - query_parameters['startTime'] = self._serialize.query("start_time", start_time, 'iso-8601') - query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') - - request = self._client.get(url, query_parameters, header_parameters) + request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore + else: - url = next_link - query_parameters = {} # type: Dict[str, Any] + # make call to next link with the client's api-version + _parsed_next_link = urlparse(next_link) + _next_request_params = case_insensitive_dict(parse_qs(_parsed_next_link.query)) + _next_request_params["api-version"] = self._config.api_version + request = HttpRequest("GET", urljoin(next_link, _parsed_next_link.path), params=_next_request_params) + request = _convert_request(request) path_format_arguments = { - 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), + "endpoint": self._serialize.url( + "self._config.endpoint", self._config.endpoint, "str", skip_quote=True + ), } - url = self._client.format_url(url, **path_format_arguments) - request = self._client.get(url, query_parameters, header_parameters) + request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore + request.method = "GET" return request async def extract_data(pipeline_response): - deserialized = self._deserialize('ChatThreadsItemCollection', pipeline_response) + deserialized = self._deserialize("ChatThreadsItemCollection", pipeline_response) list_of_elem = deserialized.value if cls: list_of_elem = cls(list_of_elem) @@ -190,7 +308,9 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request, stream=False, **kwargs) + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) response = pipeline_response.http_response if response.status_code not in [200]: @@ -199,58 +319,67 @@ async def get_next(next_link=None): return pipeline_response - return AsyncItemPaged( - get_next, extract_data - ) - list_chat_threads.metadata = {'url': '/chat/threads'} # type: ignore + return AsyncItemPaged(get_next, extract_data) - async def delete_chat_thread( - self, - chat_thread_id: str, - **kwargs: Any + list_chat_threads.metadata = {"url": "/chat/threads"} # type: ignore + + @distributed_trace_async + async def delete_chat_thread( # pylint: disable=inconsistent-return-statements + self, chat_thread_id: str, **kwargs: Any ) -> None: """Deletes a thread. Deletes a thread. - :param chat_thread_id: Id of the thread to be deleted. + :param chat_thread_id: Id of the thread to be deleted. Required. :type chat_thread_id: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - cls = kwargs.pop('cls', None) # type: ClsType[None] error_map = { 404: ResourceNotFoundError, 409: ResourceExistsError, - 401: lambda response: ClientAuthenticationError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 403: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 429: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 503: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 304: ResourceNotModifiedError, + 401: lambda response: ClientAuthenticationError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 403: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 429: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 503: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), } - error_map.update(kwargs.pop('error_map', {})) - api_version = "2021-09-07" - accept = "application/json" + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - # Construct URL - url = self.delete_chat_thread.metadata['url'] # type: ignore + request = build_delete_chat_thread_request( + chat_thread_id=chat_thread_id, + api_version=api_version, + template_url=self.delete_chat_thread.metadata["url"], + headers=_headers, + params=_params, + ) + request = _convert_request(request) path_format_arguments = { - 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), - 'chatThreadId': self._serialize.url("chat_thread_id", chat_thread_id, 'str'), + "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), } - url = self._client.format_url(url, **path_format_arguments) - - # Construct parameters - query_parameters = {} # type: Dict[str, Any] - query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') + request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore - # Construct headers - header_parameters = {} # type: Dict[str, Any] - header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) - request = self._client.delete(url, query_parameters, header_parameters) - pipeline_response = await self._client._pipeline.run(request, stream=False, **kwargs) response = pipeline_response.http_response if response.status_code not in [204]: @@ -260,4 +389,4 @@ async def delete_chat_thread( if cls: return cls(pipeline_response, None, {}) - delete_chat_thread.metadata = {'url': '/chat/threads/{chatThreadId}'} # type: ignore + delete_chat_thread.metadata = {"url": "/chat/threads/{chatThreadId}"} # type: ignore diff --git a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/operations/_chat_thread_operations.py b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/operations/_chat_thread_operations.py index c045d32f074c..defd7abcd008 100644 --- a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/operations/_chat_thread_operations.py +++ b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/operations/_chat_thread_operations.py @@ -1,3 +1,4 @@ +# pylint: disable=too-many-lines # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -6,111 +7,152 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- import datetime -from typing import Any, AsyncIterable, Callable, Dict, Generic, Optional, TypeVar -import warnings +from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, TypeVar, Union, overload +from urllib.parse import parse_qs, urljoin, urlparse from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + map_error, +) from azure.core.pipeline import PipelineResponse -from azure.core.pipeline.transport import AsyncHttpResponse, HttpRequest +from azure.core.pipeline.transport import AsyncHttpResponse +from azure.core.rest import HttpRequest +from azure.core.tracing.decorator import distributed_trace +from azure.core.tracing.decorator_async import distributed_trace_async +from azure.core.utils import case_insensitive_dict from ... import models as _models - -T = TypeVar('T') +from ..._vendor import _convert_request +from ...operations._chat_thread_operations import ( + build_add_chat_participants_request, + build_delete_chat_message_request, + build_get_chat_message_request, + build_get_chat_thread_properties_request, + build_list_chat_messages_request, + build_list_chat_participants_request, + build_list_chat_read_receipts_request, + build_remove_chat_participant_request, + build_send_chat_message_request, + build_send_chat_read_receipt_request, + build_send_typing_notification_request, + build_update_chat_message_request, + build_update_chat_thread_properties_request, +) + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] -class ChatThreadOperations: - """ChatThreadOperations async operations. - You should not instantiate this class directly. Instead, you should create a Client instance that - instantiates it for you and attaches it as an attribute. +class ChatThreadOperations: + """ + .. warning:: + **DO NOT** instantiate this class directly. - :ivar models: Alias to model classes used in this operation group. - :type models: ~azure.communication.chat.models - :param client: Client for service requests. - :param config: Configuration of service client. - :param serializer: An object model serializer. - :param deserializer: An object model deserializer. + Instead, you should access the following operations through + :class:`~azure.communication.chat.aio.AzureCommunicationChatService`'s + :attr:`chat_thread` attribute. """ models = _models - def __init__(self, client, config, serializer, deserializer) -> None: - self._client = client - self._serialize = serializer - self._deserialize = deserializer - self._config = config + def __init__(self, *args, **kwargs) -> None: + input_args = list(args) + self._client = input_args.pop(0) if input_args else kwargs.pop("client") + self._config = input_args.pop(0) if input_args else kwargs.pop("config") + self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") + self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") + @distributed_trace def list_chat_read_receipts( - self, - chat_thread_id: str, - max_page_size: Optional[int] = None, - skip: Optional[int] = None, - **kwargs: Any - ) -> AsyncIterable["_models.ChatMessageReadReceiptsCollection"]: + self, chat_thread_id: str, max_page_size: Optional[int] = None, skip: Optional[int] = None, **kwargs: Any + ) -> AsyncIterable["_models.ChatMessageReadReceipt"]: """Gets chat message read receipts for a thread. Gets chat message read receipts for a thread. - :param chat_thread_id: Thread id to get the chat message read receipts for. + :param chat_thread_id: Thread id to get the chat message read receipts for. Required. :type chat_thread_id: str :param max_page_size: The maximum number of chat message read receipts to be returned per page. + Default value is None. :type max_page_size: int - :param skip: Skips chat message read receipts up to a specified position in response. + :param skip: Skips chat message read receipts up to a specified position in response. Default + value is None. :type skip: int :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either ChatMessageReadReceiptsCollection or the result of cls(response) - :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.communication.chat.models.ChatMessageReadReceiptsCollection] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either ChatMessageReadReceipt or the result of + cls(response) + :rtype: + ~azure.core.async_paging.AsyncItemPaged[~azure.communication.chat.models.ChatMessageReadReceipt] + :raises ~azure.core.exceptions.HttpResponseError: """ - cls = kwargs.pop('cls', None) # type: ClsType["_models.ChatMessageReadReceiptsCollection"] + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.ChatMessageReadReceiptsCollection] + error_map = { 404: ResourceNotFoundError, 409: ResourceExistsError, - 401: lambda response: ClientAuthenticationError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 403: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 429: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 503: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 304: ResourceNotModifiedError, + 401: lambda response: ClientAuthenticationError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 403: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 429: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 503: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), } - error_map.update(kwargs.pop('error_map', {})) - api_version = "2021-09-07" - accept = "application/json" + error_map.update(kwargs.pop("error_map", {}) or {}) def prepare_request(next_link=None): - # Construct headers - header_parameters = {} # type: Dict[str, Any] - header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') - if not next_link: - # Construct URL - url = self.list_chat_read_receipts.metadata['url'] # type: ignore + + request = build_list_chat_read_receipts_request( + chat_thread_id=chat_thread_id, + max_page_size=max_page_size, + skip=skip, + api_version=api_version, + template_url=self.list_chat_read_receipts.metadata["url"], + headers=_headers, + params=_params, + ) + request = _convert_request(request) path_format_arguments = { - 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), - 'chatThreadId': self._serialize.url("chat_thread_id", chat_thread_id, 'str'), + "endpoint": self._serialize.url( + "self._config.endpoint", self._config.endpoint, "str", skip_quote=True + ), } - url = self._client.format_url(url, **path_format_arguments) - # Construct parameters - query_parameters = {} # type: Dict[str, Any] - if max_page_size is not None: - query_parameters['maxPageSize'] = self._serialize.query("max_page_size", max_page_size, 'int') - if skip is not None: - query_parameters['skip'] = self._serialize.query("skip", skip, 'int') - query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') - - request = self._client.get(url, query_parameters, header_parameters) + request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore + else: - url = next_link - query_parameters = {} # type: Dict[str, Any] + # make call to next link with the client's api-version + _parsed_next_link = urlparse(next_link) + _next_request_params = case_insensitive_dict(parse_qs(_parsed_next_link.query)) + _next_request_params["api-version"] = self._config.api_version + request = HttpRequest("GET", urljoin(next_link, _parsed_next_link.path), params=_next_request_params) + request = _convert_request(request) path_format_arguments = { - 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), - 'chatThreadId': self._serialize.url("chat_thread_id", chat_thread_id, 'str'), + "endpoint": self._serialize.url( + "self._config.endpoint", self._config.endpoint, "str", skip_quote=True + ), } - url = self._client.format_url(url, **path_format_arguments) - request = self._client.get(url, query_parameters, header_parameters) + request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore + request.method = "GET" return request async def extract_data(pipeline_response): - deserialized = self._deserialize('ChatMessageReadReceiptsCollection', pipeline_response) + deserialized = self._deserialize("ChatMessageReadReceiptsCollection", pipeline_response) list_of_elem = deserialized.value if cls: list_of_elem = cls(list_of_elem) @@ -119,7 +161,9 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request, stream=False, **kwargs) + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) response = pipeline_response.http_response if response.status_code not in [200]: @@ -128,66 +172,137 @@ async def get_next(next_link=None): return pipeline_response - return AsyncItemPaged( - get_next, extract_data - ) - list_chat_read_receipts.metadata = {'url': '/chat/threads/{chatThreadId}/readReceipts'} # type: ignore + return AsyncItemPaged(get_next, extract_data) + + list_chat_read_receipts.metadata = {"url": "/chat/threads/{chatThreadId}/readReceipts"} # type: ignore - async def send_chat_read_receipt( + @overload + async def send_chat_read_receipt( # pylint: disable=inconsistent-return-statements self, chat_thread_id: str, - send_read_receipt_request: "_models.SendReadReceiptRequest", + send_read_receipt_request: _models.SendReadReceiptRequest, + *, + content_type: str = "application/json", **kwargs: Any ) -> None: """Sends a read receipt event to a thread, on behalf of a user. Sends a read receipt event to a thread, on behalf of a user. - :param chat_thread_id: Thread id to send the read receipt event to. + :param chat_thread_id: Thread id to send the read receipt event to. Required. :type chat_thread_id: str - :param send_read_receipt_request: Read receipt details. + :param send_read_receipt_request: Read receipt details. Required. :type send_read_receipt_request: ~azure.communication.chat.models.SendReadReceiptRequest + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + async def send_chat_read_receipt( # pylint: disable=inconsistent-return-statements + self, + chat_thread_id: str, + send_read_receipt_request: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> None: + """Sends a read receipt event to a thread, on behalf of a user. + + Sends a read receipt event to a thread, on behalf of a user. + + :param chat_thread_id: Thread id to send the read receipt event to. Required. + :type chat_thread_id: str + :param send_read_receipt_request: Read receipt details. Required. + :type send_read_receipt_request: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: None or the result of cls(response) + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace_async + async def send_chat_read_receipt( # pylint: disable=inconsistent-return-statements + self, chat_thread_id: str, send_read_receipt_request: Union[_models.SendReadReceiptRequest, IO], **kwargs: Any + ) -> None: + """Sends a read receipt event to a thread, on behalf of a user. + + Sends a read receipt event to a thread, on behalf of a user. + + :param chat_thread_id: Thread id to send the read receipt event to. Required. + :type chat_thread_id: str + :param send_read_receipt_request: Read receipt details. Is either a model type or a IO type. + Required. + :type send_read_receipt_request: ~azure.communication.chat.models.SendReadReceiptRequest or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: None or the result of cls(response) + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: """ - cls = kwargs.pop('cls', None) # type: ClsType[None] error_map = { 404: ResourceNotFoundError, 409: ResourceExistsError, - 401: lambda response: ClientAuthenticationError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 403: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 429: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 503: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 304: ResourceNotModifiedError, + 401: lambda response: ClientAuthenticationError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 403: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 429: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 503: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), } - error_map.update(kwargs.pop('error_map', {})) - api_version = "2021-09-07" - content_type = kwargs.pop("content_type", "application/json") - accept = "application/json" + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[None] - # Construct URL - url = self.send_chat_read_receipt.metadata['url'] # type: ignore + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(send_read_receipt_request, (IO, bytes)): + _content = send_read_receipt_request + else: + _json = self._serialize.body(send_read_receipt_request, "SendReadReceiptRequest") + + request = build_send_chat_read_receipt_request( + chat_thread_id=chat_thread_id, + api_version=api_version, + content_type=content_type, + json=_json, + content=_content, + template_url=self.send_chat_read_receipt.metadata["url"], + headers=_headers, + params=_params, + ) + request = _convert_request(request) path_format_arguments = { - 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), - 'chatThreadId': self._serialize.url("chat_thread_id", chat_thread_id, 'str'), + "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), } - url = self._client.format_url(url, **path_format_arguments) - - # Construct parameters - query_parameters = {} # type: Dict[str, Any] - query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') - - # Construct headers - header_parameters = {} # type: Dict[str, Any] - header_parameters['Content-Type'] = self._serialize.header("content_type", content_type, 'str') - header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') - - body_content_kwargs = {} # type: Dict[str, Any] - body_content = self._serialize.body(send_read_receipt_request, 'SendReadReceiptRequest') - body_content_kwargs['content'] = body_content - request = self._client.post(url, query_parameters, header_parameters, **body_content_kwargs) - pipeline_response = await self._client._pipeline.run(request, stream=False, **kwargs) + request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore + + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -197,148 +312,238 @@ async def send_chat_read_receipt( if cls: return cls(pipeline_response, None, {}) - send_chat_read_receipt.metadata = {'url': '/chat/threads/{chatThreadId}/readReceipts'} # type: ignore + send_chat_read_receipt.metadata = {"url": "/chat/threads/{chatThreadId}/readReceipts"} # type: ignore + @overload async def send_chat_message( self, chat_thread_id: str, - send_chat_message_request: "_models.SendChatMessageRequest", + send_chat_message_request: _models.SendChatMessageRequest, + *, + content_type: str = "application/json", **kwargs: Any - ) -> "_models.SendChatMessageResult": + ) -> _models.SendChatMessageResult: """Sends a message to a thread. Sends a message to a thread. - :param chat_thread_id: The thread id to send the message to. + :param chat_thread_id: The thread id to send the message to. Required. :type chat_thread_id: str - :param send_chat_message_request: Details of the message to send. + :param send_chat_message_request: Details of the message to send. Required. :type send_chat_message_request: ~azure.communication.chat.models.SendChatMessageRequest + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: SendChatMessageResult or the result of cls(response) + :rtype: ~azure.communication.chat.models.SendChatMessageResult + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + async def send_chat_message( + self, + chat_thread_id: str, + send_chat_message_request: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.SendChatMessageResult: + """Sends a message to a thread. + + Sends a message to a thread. + + :param chat_thread_id: The thread id to send the message to. Required. + :type chat_thread_id: str + :param send_chat_message_request: Details of the message to send. Required. + :type send_chat_message_request: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: SendChatMessageResult or the result of cls(response) + :rtype: ~azure.communication.chat.models.SendChatMessageResult + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace_async + async def send_chat_message( + self, chat_thread_id: str, send_chat_message_request: Union[_models.SendChatMessageRequest, IO], **kwargs: Any + ) -> _models.SendChatMessageResult: + """Sends a message to a thread. + + Sends a message to a thread. + + :param chat_thread_id: The thread id to send the message to. Required. + :type chat_thread_id: str + :param send_chat_message_request: Details of the message to send. Is either a model type or a + IO type. Required. + :type send_chat_message_request: ~azure.communication.chat.models.SendChatMessageRequest or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: SendChatMessageResult, or the result of cls(response) + :return: SendChatMessageResult or the result of cls(response) :rtype: ~azure.communication.chat.models.SendChatMessageResult - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - cls = kwargs.pop('cls', None) # type: ClsType["_models.SendChatMessageResult"] error_map = { 404: ResourceNotFoundError, 409: ResourceExistsError, - 401: lambda response: ClientAuthenticationError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 403: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 429: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 503: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 304: ResourceNotModifiedError, + 401: lambda response: ClientAuthenticationError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 403: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 429: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 503: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), } - error_map.update(kwargs.pop('error_map', {})) - api_version = "2021-09-07" - content_type = kwargs.pop("content_type", "application/json") - accept = "application/json" + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - # Construct URL - url = self.send_chat_message.metadata['url'] # type: ignore + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.SendChatMessageResult] + + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(send_chat_message_request, (IO, bytes)): + _content = send_chat_message_request + else: + _json = self._serialize.body(send_chat_message_request, "SendChatMessageRequest") + + request = build_send_chat_message_request( + chat_thread_id=chat_thread_id, + api_version=api_version, + content_type=content_type, + json=_json, + content=_content, + template_url=self.send_chat_message.metadata["url"], + headers=_headers, + params=_params, + ) + request = _convert_request(request) path_format_arguments = { - 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), - 'chatThreadId': self._serialize.url("chat_thread_id", chat_thread_id, 'str'), + "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), } - url = self._client.format_url(url, **path_format_arguments) - - # Construct parameters - query_parameters = {} # type: Dict[str, Any] - query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') - - # Construct headers - header_parameters = {} # type: Dict[str, Any] - header_parameters['Content-Type'] = self._serialize.header("content_type", content_type, 'str') - header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') - - body_content_kwargs = {} # type: Dict[str, Any] - body_content = self._serialize.body(send_chat_message_request, 'SendChatMessageRequest') - body_content_kwargs['content'] = body_content - request = self._client.post(url, query_parameters, header_parameters, **body_content_kwargs) - pipeline_response = await self._client._pipeline.run(request, stream=False, **kwargs) + request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore + + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) + response = pipeline_response.http_response if response.status_code not in [201]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response) - deserialized = self._deserialize('SendChatMessageResult', pipeline_response) + deserialized = self._deserialize("SendChatMessageResult", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - send_chat_message.metadata = {'url': '/chat/threads/{chatThreadId}/messages'} # type: ignore + send_chat_message.metadata = {"url": "/chat/threads/{chatThreadId}/messages"} # type: ignore + + @distributed_trace def list_chat_messages( self, chat_thread_id: str, max_page_size: Optional[int] = None, start_time: Optional[datetime.datetime] = None, **kwargs: Any - ) -> AsyncIterable["_models.ChatMessagesCollection"]: + ) -> AsyncIterable["_models.ChatMessage"]: """Gets a list of messages from a thread. Gets a list of messages from a thread. - :param chat_thread_id: The thread id of the message. + :param chat_thread_id: The thread id of the message. Required. :type chat_thread_id: str - :param max_page_size: The maximum number of messages to be returned per page. + :param max_page_size: The maximum number of messages to be returned per page. Default value is + None. :type max_page_size: int :param start_time: The earliest point in time to get messages up to. The timestamp should be in - RFC3339 format: ``yyyy-MM-ddTHH:mm:ssZ``. + RFC3339 format: ``yyyy-MM-ddTHH:mm:ssZ``. Default value is None. :type start_time: ~datetime.datetime :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either ChatMessagesCollection or the result of cls(response) - :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.communication.chat.models.ChatMessagesCollection] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either ChatMessage or the result of cls(response) + :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.communication.chat.models.ChatMessage] + :raises ~azure.core.exceptions.HttpResponseError: """ - cls = kwargs.pop('cls', None) # type: ClsType["_models.ChatMessagesCollection"] + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.ChatMessagesCollection] + error_map = { 404: ResourceNotFoundError, 409: ResourceExistsError, - 401: lambda response: ClientAuthenticationError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 403: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 429: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 503: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 304: ResourceNotModifiedError, + 401: lambda response: ClientAuthenticationError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 403: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 429: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 503: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), } - error_map.update(kwargs.pop('error_map', {})) - api_version = "2021-09-07" - accept = "application/json" + error_map.update(kwargs.pop("error_map", {}) or {}) def prepare_request(next_link=None): - # Construct headers - header_parameters = {} # type: Dict[str, Any] - header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') - if not next_link: - # Construct URL - url = self.list_chat_messages.metadata['url'] # type: ignore + + request = build_list_chat_messages_request( + chat_thread_id=chat_thread_id, + max_page_size=max_page_size, + start_time=start_time, + api_version=api_version, + template_url=self.list_chat_messages.metadata["url"], + headers=_headers, + params=_params, + ) + request = _convert_request(request) path_format_arguments = { - 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), - 'chatThreadId': self._serialize.url("chat_thread_id", chat_thread_id, 'str'), + "endpoint": self._serialize.url( + "self._config.endpoint", self._config.endpoint, "str", skip_quote=True + ), } - url = self._client.format_url(url, **path_format_arguments) - # Construct parameters - query_parameters = {} # type: Dict[str, Any] - if max_page_size is not None: - query_parameters['maxPageSize'] = self._serialize.query("max_page_size", max_page_size, 'int') - if start_time is not None: - query_parameters['startTime'] = self._serialize.query("start_time", start_time, 'iso-8601') - query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') - - request = self._client.get(url, query_parameters, header_parameters) + request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore + else: - url = next_link - query_parameters = {} # type: Dict[str, Any] + # make call to next link with the client's api-version + _parsed_next_link = urlparse(next_link) + _next_request_params = case_insensitive_dict(parse_qs(_parsed_next_link.query)) + _next_request_params["api-version"] = self._config.api_version + request = HttpRequest("GET", urljoin(next_link, _parsed_next_link.path), params=_next_request_params) + request = _convert_request(request) path_format_arguments = { - 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), - 'chatThreadId': self._serialize.url("chat_thread_id", chat_thread_id, 'str'), + "endpoint": self._serialize.url( + "self._config.endpoint", self._config.endpoint, "str", skip_quote=True + ), } - url = self._client.format_url(url, **path_format_arguments) - request = self._client.get(url, query_parameters, header_parameters) + request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore + request.method = "GET" return request async def extract_data(pipeline_response): - deserialized = self._deserialize('ChatMessagesCollection', pipeline_response) + deserialized = self._deserialize("ChatMessagesCollection", pipeline_response) list_of_elem = deserialized.value if cls: list_of_elem = cls(list_of_elem) @@ -347,7 +552,9 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request, stream=False, **kwargs) + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) response = pipeline_response.http_response if response.status_code not in [200]: @@ -356,135 +563,224 @@ async def get_next(next_link=None): return pipeline_response - return AsyncItemPaged( - get_next, extract_data - ) - list_chat_messages.metadata = {'url': '/chat/threads/{chatThreadId}/messages'} # type: ignore + return AsyncItemPaged(get_next, extract_data) - async def get_chat_message( - self, - chat_thread_id: str, - chat_message_id: str, - **kwargs: Any - ) -> "_models.ChatMessage": + list_chat_messages.metadata = {"url": "/chat/threads/{chatThreadId}/messages"} # type: ignore + + @distributed_trace_async + async def get_chat_message(self, chat_thread_id: str, chat_message_id: str, **kwargs: Any) -> _models.ChatMessage: """Gets a message by id. Gets a message by id. - :param chat_thread_id: The thread id to which the message was sent. + :param chat_thread_id: The thread id to which the message was sent. Required. :type chat_thread_id: str - :param chat_message_id: The message id. + :param chat_message_id: The message id. Required. :type chat_message_id: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: ChatMessage, or the result of cls(response) + :return: ChatMessage or the result of cls(response) :rtype: ~azure.communication.chat.models.ChatMessage - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - cls = kwargs.pop('cls', None) # type: ClsType["_models.ChatMessage"] error_map = { 404: ResourceNotFoundError, 409: ResourceExistsError, - 401: lambda response: ClientAuthenticationError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 403: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 429: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 503: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 304: ResourceNotModifiedError, + 401: lambda response: ClientAuthenticationError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 403: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 429: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 503: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), } - error_map.update(kwargs.pop('error_map', {})) - api_version = "2021-09-07" - accept = "application/json" + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - # Construct URL - url = self.get_chat_message.metadata['url'] # type: ignore + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.ChatMessage] + + request = build_get_chat_message_request( + chat_thread_id=chat_thread_id, + chat_message_id=chat_message_id, + api_version=api_version, + template_url=self.get_chat_message.metadata["url"], + headers=_headers, + params=_params, + ) + request = _convert_request(request) path_format_arguments = { - 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), - 'chatThreadId': self._serialize.url("chat_thread_id", chat_thread_id, 'str'), - 'chatMessageId': self._serialize.url("chat_message_id", chat_message_id, 'str'), + "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), } - url = self._client.format_url(url, **path_format_arguments) + request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore - # Construct parameters - query_parameters = {} # type: Dict[str, Any] - query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') - - # Construct headers - header_parameters = {} # type: Dict[str, Any] - header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) - request = self._client.get(url, query_parameters, header_parameters) - pipeline_response = await self._client._pipeline.run(request, stream=False, **kwargs) response = pipeline_response.http_response if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response) - deserialized = self._deserialize('ChatMessage', pipeline_response) + deserialized = self._deserialize("ChatMessage", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get_chat_message.metadata = {'url': '/chat/threads/{chatThreadId}/messages/{chatMessageId}'} # type: ignore - async def update_chat_message( + get_chat_message.metadata = {"url": "/chat/threads/{chatThreadId}/messages/{chatMessageId}"} # type: ignore + + @overload + async def update_chat_message( # pylint: disable=inconsistent-return-statements self, chat_thread_id: str, chat_message_id: str, - update_chat_message_request: "_models.UpdateChatMessageRequest", + update_chat_message_request: _models.UpdateChatMessageRequest, + *, + content_type: str = "application/merge-patch+json", **kwargs: Any ) -> None: """Updates a message. Updates a message. - :param chat_thread_id: The thread id to which the message was sent. + :param chat_thread_id: The thread id to which the message was sent. Required. :type chat_thread_id: str - :param chat_message_id: The message id. + :param chat_message_id: The message id. Required. :type chat_message_id: str - :param update_chat_message_request: Details of the request to update the message. + :param update_chat_message_request: Details of the request to update the message. Required. :type update_chat_message_request: ~azure.communication.chat.models.UpdateChatMessageRequest + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/merge-patch+json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: None or the result of cls(response) + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + async def update_chat_message( # pylint: disable=inconsistent-return-statements + self, + chat_thread_id: str, + chat_message_id: str, + update_chat_message_request: IO, + *, + content_type: str = "application/merge-patch+json", + **kwargs: Any + ) -> None: + """Updates a message. + + Updates a message. + + :param chat_thread_id: The thread id to which the message was sent. Required. + :type chat_thread_id: str + :param chat_message_id: The message id. Required. + :type chat_message_id: str + :param update_chat_message_request: Details of the request to update the message. Required. + :type update_chat_message_request: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/merge-patch+json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace_async + async def update_chat_message( # pylint: disable=inconsistent-return-statements + self, + chat_thread_id: str, + chat_message_id: str, + update_chat_message_request: Union[_models.UpdateChatMessageRequest, IO], + **kwargs: Any + ) -> None: + """Updates a message. + + Updates a message. + + :param chat_thread_id: The thread id to which the message was sent. Required. + :type chat_thread_id: str + :param chat_message_id: The message id. Required. + :type chat_message_id: str + :param update_chat_message_request: Details of the request to update the message. Is either a + model type or a IO type. Required. + :type update_chat_message_request: ~azure.communication.chat.models.UpdateChatMessageRequest or + IO + :keyword content_type: Body Parameter content-type. Known values are: + 'application/merge-patch+json'. Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: None or the result of cls(response) + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: """ - cls = kwargs.pop('cls', None) # type: ClsType[None] error_map = { 404: ResourceNotFoundError, 409: ResourceExistsError, - 401: lambda response: ClientAuthenticationError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 403: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 429: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 503: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 304: ResourceNotModifiedError, + 401: lambda response: ClientAuthenticationError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 403: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 429: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 503: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), } - error_map.update(kwargs.pop('error_map', {})) - api_version = "2021-09-07" - content_type = kwargs.pop("content_type", "application/merge-patch+json") - accept = "application/json" + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - # Construct URL - url = self.update_chat_message.metadata['url'] # type: ignore + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[None] + + content_type = content_type or "application/merge-patch+json" + _json = None + _content = None + if isinstance(update_chat_message_request, (IO, bytes)): + _content = update_chat_message_request + else: + _json = self._serialize.body(update_chat_message_request, "UpdateChatMessageRequest") + + request = build_update_chat_message_request( + chat_thread_id=chat_thread_id, + chat_message_id=chat_message_id, + api_version=api_version, + content_type=content_type, + json=_json, + content=_content, + template_url=self.update_chat_message.metadata["url"], + headers=_headers, + params=_params, + ) + request = _convert_request(request) path_format_arguments = { - 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), - 'chatThreadId': self._serialize.url("chat_thread_id", chat_thread_id, 'str'), - 'chatMessageId': self._serialize.url("chat_message_id", chat_message_id, 'str'), + "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), } - url = self._client.format_url(url, **path_format_arguments) - - # Construct parameters - query_parameters = {} # type: Dict[str, Any] - query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') - - # Construct headers - header_parameters = {} # type: Dict[str, Any] - header_parameters['Content-Type'] = self._serialize.header("content_type", content_type, 'str') - header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') - - body_content_kwargs = {} # type: Dict[str, Any] - body_content = self._serialize.body(update_chat_message_request, 'UpdateChatMessageRequest') - body_content_kwargs['content'] = body_content - request = self._client.patch(url, query_parameters, header_parameters, **body_content_kwargs) - pipeline_response = await self._client._pipeline.run(request, stream=False, **kwargs) + request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore + + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) + response = pipeline_response.http_response if response.status_code not in [204]: @@ -494,59 +790,68 @@ async def update_chat_message( if cls: return cls(pipeline_response, None, {}) - update_chat_message.metadata = {'url': '/chat/threads/{chatThreadId}/messages/{chatMessageId}'} # type: ignore + update_chat_message.metadata = {"url": "/chat/threads/{chatThreadId}/messages/{chatMessageId}"} # type: ignore - async def delete_chat_message( - self, - chat_thread_id: str, - chat_message_id: str, - **kwargs: Any + @distributed_trace_async + async def delete_chat_message( # pylint: disable=inconsistent-return-statements + self, chat_thread_id: str, chat_message_id: str, **kwargs: Any ) -> None: """Deletes a message. Deletes a message. - :param chat_thread_id: The thread id to which the message was sent. + :param chat_thread_id: The thread id to which the message was sent. Required. :type chat_thread_id: str - :param chat_message_id: The message id. + :param chat_message_id: The message id. Required. :type chat_message_id: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - cls = kwargs.pop('cls', None) # type: ClsType[None] error_map = { 404: ResourceNotFoundError, 409: ResourceExistsError, - 401: lambda response: ClientAuthenticationError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 403: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 429: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 503: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 304: ResourceNotModifiedError, + 401: lambda response: ClientAuthenticationError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 403: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 429: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 503: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), } - error_map.update(kwargs.pop('error_map', {})) - api_version = "2021-09-07" - accept = "application/json" + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - # Construct URL - url = self.delete_chat_message.metadata['url'] # type: ignore + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] + + request = build_delete_chat_message_request( + chat_thread_id=chat_thread_id, + chat_message_id=chat_message_id, + api_version=api_version, + template_url=self.delete_chat_message.metadata["url"], + headers=_headers, + params=_params, + ) + request = _convert_request(request) path_format_arguments = { - 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), - 'chatThreadId': self._serialize.url("chat_thread_id", chat_thread_id, 'str'), - 'chatMessageId': self._serialize.url("chat_message_id", chat_message_id, 'str'), + "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), } - url = self._client.format_url(url, **path_format_arguments) + request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore - # Construct parameters - query_parameters = {} # type: Dict[str, Any] - query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') - - # Construct headers - header_parameters = {} # type: Dict[str, Any] - header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) - request = self._client.delete(url, query_parameters, header_parameters) - pipeline_response = await self._client._pipeline.run(request, stream=False, **kwargs) response = pipeline_response.http_response if response.status_code not in [204]: @@ -556,78 +861,92 @@ async def delete_chat_message( if cls: return cls(pipeline_response, None, {}) - delete_chat_message.metadata = {'url': '/chat/threads/{chatThreadId}/messages/{chatMessageId}'} # type: ignore + delete_chat_message.metadata = {"url": "/chat/threads/{chatThreadId}/messages/{chatMessageId}"} # type: ignore + @distributed_trace def list_chat_participants( - self, - chat_thread_id: str, - max_page_size: Optional[int] = None, - skip: Optional[int] = None, - **kwargs: Any - ) -> AsyncIterable["_models.ChatParticipantsCollection"]: + self, chat_thread_id: str, max_page_size: Optional[int] = None, skip: Optional[int] = None, **kwargs: Any + ) -> AsyncIterable["_models.ChatParticipant"]: """Gets the participants of a thread. Gets the participants of a thread. - :param chat_thread_id: Thread id to get participants for. + :param chat_thread_id: Thread id to get participants for. Required. :type chat_thread_id: str - :param max_page_size: The maximum number of participants to be returned per page. + :param max_page_size: The maximum number of participants to be returned per page. Default value + is None. :type max_page_size: int - :param skip: Skips participants up to a specified position in response. + :param skip: Skips participants up to a specified position in response. Default value is None. :type skip: int :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either ChatParticipantsCollection or the result of cls(response) - :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.communication.chat.models.ChatParticipantsCollection] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either ChatParticipant or the result of cls(response) + :rtype: + ~azure.core.async_paging.AsyncItemPaged[~azure.communication.chat.models.ChatParticipant] + :raises ~azure.core.exceptions.HttpResponseError: """ - cls = kwargs.pop('cls', None) # type: ClsType["_models.ChatParticipantsCollection"] + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.ChatParticipantsCollection] + error_map = { 404: ResourceNotFoundError, 409: ResourceExistsError, - 401: lambda response: ClientAuthenticationError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 403: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 429: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 503: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 304: ResourceNotModifiedError, + 401: lambda response: ClientAuthenticationError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 403: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 429: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 503: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), } - error_map.update(kwargs.pop('error_map', {})) - api_version = "2021-09-07" - accept = "application/json" + error_map.update(kwargs.pop("error_map", {}) or {}) def prepare_request(next_link=None): - # Construct headers - header_parameters = {} # type: Dict[str, Any] - header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') - if not next_link: - # Construct URL - url = self.list_chat_participants.metadata['url'] # type: ignore + + request = build_list_chat_participants_request( + chat_thread_id=chat_thread_id, + max_page_size=max_page_size, + skip=skip, + api_version=api_version, + template_url=self.list_chat_participants.metadata["url"], + headers=_headers, + params=_params, + ) + request = _convert_request(request) path_format_arguments = { - 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), - 'chatThreadId': self._serialize.url("chat_thread_id", chat_thread_id, 'str'), + "endpoint": self._serialize.url( + "self._config.endpoint", self._config.endpoint, "str", skip_quote=True + ), } - url = self._client.format_url(url, **path_format_arguments) - # Construct parameters - query_parameters = {} # type: Dict[str, Any] - if max_page_size is not None: - query_parameters['maxPageSize'] = self._serialize.query("max_page_size", max_page_size, 'int') - if skip is not None: - query_parameters['skip'] = self._serialize.query("skip", skip, 'int') - query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') - - request = self._client.get(url, query_parameters, header_parameters) + request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore + else: - url = next_link - query_parameters = {} # type: Dict[str, Any] + # make call to next link with the client's api-version + _parsed_next_link = urlparse(next_link) + _next_request_params = case_insensitive_dict(parse_qs(_parsed_next_link.query)) + _next_request_params["api-version"] = self._config.api_version + request = HttpRequest("GET", urljoin(next_link, _parsed_next_link.path), params=_next_request_params) + request = _convert_request(request) path_format_arguments = { - 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), - 'chatThreadId': self._serialize.url("chat_thread_id", chat_thread_id, 'str'), + "endpoint": self._serialize.url( + "self._config.endpoint", self._config.endpoint, "str", skip_quote=True + ), } - url = self._client.format_url(url, **path_format_arguments) - request = self._client.get(url, query_parameters, header_parameters) + request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore + request.method = "GET" return request async def extract_data(pipeline_response): - deserialized = self._deserialize('ChatParticipantsCollection', pipeline_response) + deserialized = self._deserialize("ChatParticipantsCollection", pipeline_response) list_of_elem = deserialized.value if cls: list_of_elem = cls(list_of_elem) @@ -636,7 +955,9 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request, stream=False, **kwargs) + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) response = pipeline_response.http_response if response.status_code not in [200]: @@ -645,67 +966,145 @@ async def get_next(next_link=None): return pipeline_response - return AsyncItemPaged( - get_next, extract_data - ) - list_chat_participants.metadata = {'url': '/chat/threads/{chatThreadId}/participants'} # type: ignore + return AsyncItemPaged(get_next, extract_data) - async def remove_chat_participant( + list_chat_participants.metadata = {"url": "/chat/threads/{chatThreadId}/participants"} # type: ignore + + @overload + async def remove_chat_participant( # pylint: disable=inconsistent-return-statements self, chat_thread_id: str, - participant_communication_identifier: "_models.CommunicationIdentifierModel", + participant_communication_identifier: _models.CommunicationIdentifierModel, + *, + content_type: str = "application/json", **kwargs: Any ) -> None: """Remove a participant from a thread. Remove a participant from a thread. - :param chat_thread_id: Thread id to remove the participant from. + :param chat_thread_id: Thread id to remove the participant from. Required. :type chat_thread_id: str :param participant_communication_identifier: Id of the thread participant to remove from the - thread. - :type participant_communication_identifier: ~azure.communication.chat.models.CommunicationIdentifierModel + thread. Required. + :type participant_communication_identifier: + ~azure.communication.chat.models.CommunicationIdentifierModel + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + async def remove_chat_participant( # pylint: disable=inconsistent-return-statements + self, + chat_thread_id: str, + participant_communication_identifier: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> None: + """Remove a participant from a thread. + + Remove a participant from a thread. + + :param chat_thread_id: Thread id to remove the participant from. Required. + :type chat_thread_id: str + :param participant_communication_identifier: Id of the thread participant to remove from the + thread. Required. + :type participant_communication_identifier: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Known values are: 'application/json', 'application/merge-patch+json'. Default value is + "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: None or the result of cls(response) + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace_async + async def remove_chat_participant( # pylint: disable=inconsistent-return-statements + self, + chat_thread_id: str, + participant_communication_identifier: Union[_models.CommunicationIdentifierModel, IO], + **kwargs: Any + ) -> None: + """Remove a participant from a thread. + + Remove a participant from a thread. + + :param chat_thread_id: Thread id to remove the participant from. Required. + :type chat_thread_id: str + :param participant_communication_identifier: Id of the thread participant to remove from the + thread. Is either a model type or a IO type. Required. + :type participant_communication_identifier: + ~azure.communication.chat.models.CommunicationIdentifierModel or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json', + 'application/merge-patch+json'. Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: None or the result of cls(response) + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: """ - cls = kwargs.pop('cls', None) # type: ClsType[None] error_map = { 404: ResourceNotFoundError, 409: ResourceExistsError, - 401: lambda response: ClientAuthenticationError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 403: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 429: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 503: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 304: ResourceNotModifiedError, + 401: lambda response: ClientAuthenticationError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 403: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 429: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 503: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), } - error_map.update(kwargs.pop('error_map', {})) - api_version = "2021-09-07" - content_type = kwargs.pop("content_type", "application/json") - accept = "application/json" + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - # Construct URL - url = self.remove_chat_participant.metadata['url'] # type: ignore + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[None] + + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(participant_communication_identifier, (IO, bytes)): + _content = participant_communication_identifier + else: + _json = self._serialize.body(participant_communication_identifier, "CommunicationIdentifierModel") + + request = build_remove_chat_participant_request( + chat_thread_id=chat_thread_id, + api_version=api_version, + content_type=content_type, + json=_json, + content=_content, + template_url=self.remove_chat_participant.metadata["url"], + headers=_headers, + params=_params, + ) + request = _convert_request(request) path_format_arguments = { - 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), - 'chatThreadId': self._serialize.url("chat_thread_id", chat_thread_id, 'str'), + "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), } - url = self._client.format_url(url, **path_format_arguments) - - # Construct parameters - query_parameters = {} # type: Dict[str, Any] - query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') - - # Construct headers - header_parameters = {} # type: Dict[str, Any] - header_parameters['Content-Type'] = self._serialize.header("content_type", content_type, 'str') - header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') - - body_content_kwargs = {} # type: Dict[str, Any] - body_content = self._serialize.body(participant_communication_identifier, 'CommunicationIdentifierModel') - body_content_kwargs['content'] = body_content - request = self._client.post(url, query_parameters, header_parameters, **body_content_kwargs) - pipeline_response = await self._client._pipeline.run(request, stream=False, **kwargs) + request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore + + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) + response = pipeline_response.http_response if response.status_code not in [204]: @@ -715,132 +1114,283 @@ async def remove_chat_participant( if cls: return cls(pipeline_response, None, {}) - remove_chat_participant.metadata = {'url': '/chat/threads/{chatThreadId}/participants/:remove'} # type: ignore + remove_chat_participant.metadata = {"url": "/chat/threads/{chatThreadId}/participants/:remove"} # type: ignore + + @overload + async def add_chat_participants( + self, + chat_thread_id: str, + add_chat_participants_request: _models.AddChatParticipantsRequest, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.AddChatParticipantsResult: + """Adds thread participants to a thread. If participants already exist, no change occurs. + + Adds thread participants to a thread. If participants already exist, no change occurs. + + :param chat_thread_id: Id of the thread to add participants to. Required. + :type chat_thread_id: str + :param add_chat_participants_request: Thread participants to be added to the thread. Required. + :type add_chat_participants_request: + ~azure.communication.chat.models.AddChatParticipantsRequest + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: AddChatParticipantsResult or the result of cls(response) + :rtype: ~azure.communication.chat.models.AddChatParticipantsResult + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + async def add_chat_participants( + self, + chat_thread_id: str, + add_chat_participants_request: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.AddChatParticipantsResult: + """Adds thread participants to a thread. If participants already exist, no change occurs. + + Adds thread participants to a thread. If participants already exist, no change occurs. + + :param chat_thread_id: Id of the thread to add participants to. Required. + :type chat_thread_id: str + :param add_chat_participants_request: Thread participants to be added to the thread. Required. + :type add_chat_participants_request: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: AddChatParticipantsResult or the result of cls(response) + :rtype: ~azure.communication.chat.models.AddChatParticipantsResult + :raises ~azure.core.exceptions.HttpResponseError: + """ + @distributed_trace_async async def add_chat_participants( self, chat_thread_id: str, - add_chat_participants_request: "_models.AddChatParticipantsRequest", + add_chat_participants_request: Union[_models.AddChatParticipantsRequest, IO], **kwargs: Any - ) -> "_models.AddChatParticipantsResult": + ) -> _models.AddChatParticipantsResult: """Adds thread participants to a thread. If participants already exist, no change occurs. Adds thread participants to a thread. If participants already exist, no change occurs. - :param chat_thread_id: Id of the thread to add participants to. + :param chat_thread_id: Id of the thread to add participants to. Required. :type chat_thread_id: str - :param add_chat_participants_request: Thread participants to be added to the thread. - :type add_chat_participants_request: ~azure.communication.chat.models.AddChatParticipantsRequest + :param add_chat_participants_request: Thread participants to be added to the thread. Is either + a model type or a IO type. Required. + :type add_chat_participants_request: + ~azure.communication.chat.models.AddChatParticipantsRequest or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: AddChatParticipantsResult, or the result of cls(response) + :return: AddChatParticipantsResult or the result of cls(response) :rtype: ~azure.communication.chat.models.AddChatParticipantsResult - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - cls = kwargs.pop('cls', None) # type: ClsType["_models.AddChatParticipantsResult"] error_map = { 404: ResourceNotFoundError, 409: ResourceExistsError, - 401: lambda response: ClientAuthenticationError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 403: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 429: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 503: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 304: ResourceNotModifiedError, + 401: lambda response: ClientAuthenticationError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 403: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 429: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 503: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), } - error_map.update(kwargs.pop('error_map', {})) - api_version = "2021-09-07" - content_type = kwargs.pop("content_type", "application/json") - accept = "application/json" + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.AddChatParticipantsResult] - # Construct URL - url = self.add_chat_participants.metadata['url'] # type: ignore + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(add_chat_participants_request, (IO, bytes)): + _content = add_chat_participants_request + else: + _json = self._serialize.body(add_chat_participants_request, "AddChatParticipantsRequest") + + request = build_add_chat_participants_request( + chat_thread_id=chat_thread_id, + api_version=api_version, + content_type=content_type, + json=_json, + content=_content, + template_url=self.add_chat_participants.metadata["url"], + headers=_headers, + params=_params, + ) + request = _convert_request(request) path_format_arguments = { - 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), - 'chatThreadId': self._serialize.url("chat_thread_id", chat_thread_id, 'str'), + "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), } - url = self._client.format_url(url, **path_format_arguments) - - # Construct parameters - query_parameters = {} # type: Dict[str, Any] - query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') - - # Construct headers - header_parameters = {} # type: Dict[str, Any] - header_parameters['Content-Type'] = self._serialize.header("content_type", content_type, 'str') - header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') - - body_content_kwargs = {} # type: Dict[str, Any] - body_content = self._serialize.body(add_chat_participants_request, 'AddChatParticipantsRequest') - body_content_kwargs['content'] = body_content - request = self._client.post(url, query_parameters, header_parameters, **body_content_kwargs) - pipeline_response = await self._client._pipeline.run(request, stream=False, **kwargs) + request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore + + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) + response = pipeline_response.http_response if response.status_code not in [201]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response) - deserialized = self._deserialize('AddChatParticipantsResult', pipeline_response) + deserialized = self._deserialize("AddChatParticipantsResult", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - add_chat_participants.metadata = {'url': '/chat/threads/{chatThreadId}/participants/:add'} # type: ignore - async def update_chat_thread_properties( + add_chat_participants.metadata = {"url": "/chat/threads/{chatThreadId}/participants/:add"} # type: ignore + + @overload + async def update_chat_thread_properties( # pylint: disable=inconsistent-return-statements self, chat_thread_id: str, - update_chat_thread_request: "_models.UpdateChatThreadRequest", + update_chat_thread_request: _models.UpdateChatThreadRequest, + *, + content_type: str = "application/merge-patch+json", **kwargs: Any ) -> None: """Updates a thread's properties. Updates a thread's properties. - :param chat_thread_id: The id of the thread to update. + :param chat_thread_id: The id of the thread to update. Required. :type chat_thread_id: str - :param update_chat_thread_request: Request payload for updating a chat thread. + :param update_chat_thread_request: Request payload for updating a chat thread. Required. :type update_chat_thread_request: ~azure.communication.chat.models.UpdateChatThreadRequest + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/merge-patch+json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + async def update_chat_thread_properties( # pylint: disable=inconsistent-return-statements + self, + chat_thread_id: str, + update_chat_thread_request: IO, + *, + content_type: str = "application/merge-patch+json", + **kwargs: Any + ) -> None: + """Updates a thread's properties. + + Updates a thread's properties. + + :param chat_thread_id: The id of the thread to update. Required. + :type chat_thread_id: str + :param update_chat_thread_request: Request payload for updating a chat thread. Required. + :type update_chat_thread_request: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/merge-patch+json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: None or the result of cls(response) + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace_async + async def update_chat_thread_properties( # pylint: disable=inconsistent-return-statements + self, chat_thread_id: str, update_chat_thread_request: Union[_models.UpdateChatThreadRequest, IO], **kwargs: Any + ) -> None: + """Updates a thread's properties. + + Updates a thread's properties. + + :param chat_thread_id: The id of the thread to update. Required. + :type chat_thread_id: str + :param update_chat_thread_request: Request payload for updating a chat thread. Is either a + model type or a IO type. Required. + :type update_chat_thread_request: ~azure.communication.chat.models.UpdateChatThreadRequest or + IO + :keyword content_type: Body Parameter content-type. Known values are: + 'application/merge-patch+json'. Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: None or the result of cls(response) + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: """ - cls = kwargs.pop('cls', None) # type: ClsType[None] error_map = { 404: ResourceNotFoundError, 409: ResourceExistsError, - 401: lambda response: ClientAuthenticationError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 403: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 429: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 503: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 304: ResourceNotModifiedError, + 401: lambda response: ClientAuthenticationError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 403: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 429: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 503: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), } - error_map.update(kwargs.pop('error_map', {})) - api_version = "2021-09-07" - content_type = kwargs.pop("content_type", "application/merge-patch+json") - accept = "application/json" + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - # Construct URL - url = self.update_chat_thread_properties.metadata['url'] # type: ignore + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[None] + + content_type = content_type or "application/merge-patch+json" + _json = None + _content = None + if isinstance(update_chat_thread_request, (IO, bytes)): + _content = update_chat_thread_request + else: + _json = self._serialize.body(update_chat_thread_request, "UpdateChatThreadRequest") + + request = build_update_chat_thread_properties_request( + chat_thread_id=chat_thread_id, + api_version=api_version, + content_type=content_type, + json=_json, + content=_content, + template_url=self.update_chat_thread_properties.metadata["url"], + headers=_headers, + params=_params, + ) + request = _convert_request(request) path_format_arguments = { - 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), - 'chatThreadId': self._serialize.url("chat_thread_id", chat_thread_id, 'str'), + "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), } - url = self._client.format_url(url, **path_format_arguments) - - # Construct parameters - query_parameters = {} # type: Dict[str, Any] - query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') - - # Construct headers - header_parameters = {} # type: Dict[str, Any] - header_parameters['Content-Type'] = self._serialize.header("content_type", content_type, 'str') - header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') - - body_content_kwargs = {} # type: Dict[str, Any] - body_content = self._serialize.body(update_chat_thread_request, 'UpdateChatThreadRequest') - body_content_kwargs['content'] = body_content - request = self._client.patch(url, query_parameters, header_parameters, **body_content_kwargs) - pipeline_response = await self._client._pipeline.run(request, stream=False, **kwargs) + request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore + + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) + response = pipeline_response.http_response if response.status_code not in [204]: @@ -850,127 +1400,216 @@ async def update_chat_thread_properties( if cls: return cls(pipeline_response, None, {}) - update_chat_thread_properties.metadata = {'url': '/chat/threads/{chatThreadId}'} # type: ignore + update_chat_thread_properties.metadata = {"url": "/chat/threads/{chatThreadId}"} # type: ignore - async def get_chat_thread_properties( - self, - chat_thread_id: str, - **kwargs: Any - ) -> "_models.ChatThreadProperties": + @distributed_trace_async + async def get_chat_thread_properties(self, chat_thread_id: str, **kwargs: Any) -> _models.ChatThreadProperties: """Gets a chat thread's properties. Gets a chat thread's properties. - :param chat_thread_id: Id of the thread. + :param chat_thread_id: Id of the thread. Required. :type chat_thread_id: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: ChatThreadProperties, or the result of cls(response) + :return: ChatThreadProperties or the result of cls(response) :rtype: ~azure.communication.chat.models.ChatThreadProperties - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - cls = kwargs.pop('cls', None) # type: ClsType["_models.ChatThreadProperties"] error_map = { 404: ResourceNotFoundError, 409: ResourceExistsError, - 401: lambda response: ClientAuthenticationError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 403: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 429: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 503: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 304: ResourceNotModifiedError, + 401: lambda response: ClientAuthenticationError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 403: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 429: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 503: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), } - error_map.update(kwargs.pop('error_map', {})) - api_version = "2021-09-07" - accept = "application/json" + error_map.update(kwargs.pop("error_map", {}) or {}) - # Construct URL - url = self.get_chat_thread_properties.metadata['url'] # type: ignore + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.ChatThreadProperties] + + request = build_get_chat_thread_properties_request( + chat_thread_id=chat_thread_id, + api_version=api_version, + template_url=self.get_chat_thread_properties.metadata["url"], + headers=_headers, + params=_params, + ) + request = _convert_request(request) path_format_arguments = { - 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), - 'chatThreadId': self._serialize.url("chat_thread_id", chat_thread_id, 'str'), + "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), } - url = self._client.format_url(url, **path_format_arguments) - - # Construct parameters - query_parameters = {} # type: Dict[str, Any] - query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') + request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore - # Construct headers - header_parameters = {} # type: Dict[str, Any] - header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) - request = self._client.get(url, query_parameters, header_parameters) - pipeline_response = await self._client._pipeline.run(request, stream=False, **kwargs) response = pipeline_response.http_response if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response) - deserialized = self._deserialize('ChatThreadProperties', pipeline_response) + deserialized = self._deserialize("ChatThreadProperties", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get_chat_thread_properties.metadata = {'url': '/chat/threads/{chatThreadId}'} # type: ignore - async def send_typing_notification( + get_chat_thread_properties.metadata = {"url": "/chat/threads/{chatThreadId}"} # type: ignore + + @overload + async def send_typing_notification( # pylint: disable=inconsistent-return-statements + self, + chat_thread_id: str, + send_typing_notification_request: Optional[_models.SendTypingNotificationRequest] = None, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> None: + """Posts a typing event to a thread, on behalf of a user. + + Posts a typing event to a thread, on behalf of a user. + + :param chat_thread_id: Id of the thread. Required. + :type chat_thread_id: str + :param send_typing_notification_request: Details of the typing notification request. Default + value is None. + :type send_typing_notification_request: + ~azure.communication.chat.models.SendTypingNotificationRequest + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: None or the result of cls(response) + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + async def send_typing_notification( # pylint: disable=inconsistent-return-statements + self, + chat_thread_id: str, + send_typing_notification_request: Optional[IO] = None, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> None: + """Posts a typing event to a thread, on behalf of a user. + + Posts a typing event to a thread, on behalf of a user. + + :param chat_thread_id: Id of the thread. Required. + :type chat_thread_id: str + :param send_typing_notification_request: Details of the typing notification request. Default + value is None. + :type send_typing_notification_request: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Known values are: 'application/json', 'application/merge-patch+json'. Default value is + "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: None or the result of cls(response) + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace_async + async def send_typing_notification( # pylint: disable=inconsistent-return-statements self, chat_thread_id: str, - send_typing_notification_request: Optional["_models.SendTypingNotificationRequest"] = None, + send_typing_notification_request: Optional[Union[_models.SendTypingNotificationRequest, IO]] = None, **kwargs: Any ) -> None: """Posts a typing event to a thread, on behalf of a user. Posts a typing event to a thread, on behalf of a user. - :param chat_thread_id: Id of the thread. + :param chat_thread_id: Id of the thread. Required. :type chat_thread_id: str - :param send_typing_notification_request: Details of the typing notification request. - :type send_typing_notification_request: ~azure.communication.chat.models.SendTypingNotificationRequest + :param send_typing_notification_request: Details of the typing notification request. Is either + a model type or a IO type. Default value is None. + :type send_typing_notification_request: + ~azure.communication.chat.models.SendTypingNotificationRequest or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json', + 'application/merge-patch+json'. Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - cls = kwargs.pop('cls', None) # type: ClsType[None] error_map = { 404: ResourceNotFoundError, 409: ResourceExistsError, - 401: lambda response: ClientAuthenticationError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 403: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 429: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 503: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 304: ResourceNotModifiedError, + 401: lambda response: ClientAuthenticationError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 403: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 429: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 503: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), } - error_map.update(kwargs.pop('error_map', {})) - api_version = "2021-09-07" - content_type = kwargs.pop("content_type", "application/json") - accept = "application/json" + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[None] - # Construct URL - url = self.send_typing_notification.metadata['url'] # type: ignore + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(send_typing_notification_request, (IO, bytes)): + _content = send_typing_notification_request + else: + if send_typing_notification_request is not None: + _json = self._serialize.body(send_typing_notification_request, "SendTypingNotificationRequest") + else: + _json = None + + request = build_send_typing_notification_request( + chat_thread_id=chat_thread_id, + api_version=api_version, + content_type=content_type, + json=_json, + content=_content, + template_url=self.send_typing_notification.metadata["url"], + headers=_headers, + params=_params, + ) + request = _convert_request(request) path_format_arguments = { - 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), - 'chatThreadId': self._serialize.url("chat_thread_id", chat_thread_id, 'str'), + "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), } - url = self._client.format_url(url, **path_format_arguments) - - # Construct parameters - query_parameters = {} # type: Dict[str, Any] - query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') + request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore - # Construct headers - header_parameters = {} # type: Dict[str, Any] - header_parameters['Content-Type'] = self._serialize.header("content_type", content_type, 'str') - header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) - body_content_kwargs = {} # type: Dict[str, Any] - if send_typing_notification_request is not None: - body_content = self._serialize.body(send_typing_notification_request, 'SendTypingNotificationRequest') - else: - body_content = None - body_content_kwargs['content'] = body_content - request = self._client.post(url, query_parameters, header_parameters, **body_content_kwargs) - pipeline_response = await self._client._pipeline.run(request, stream=False, **kwargs) response = pipeline_response.http_response if response.status_code not in [200]: @@ -980,4 +1619,4 @@ async def send_typing_notification( if cls: return cls(pipeline_response, None, {}) - send_typing_notification.metadata = {'url': '/chat/threads/{chatThreadId}/typing'} # type: ignore + send_typing_notification.metadata = {"url": "/chat/threads/{chatThreadId}/typing"} # type: ignore diff --git a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/operations/_patch.py b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/operations/_patch.py new file mode 100644 index 000000000000..f7dd32510333 --- /dev/null +++ b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/operations/_patch.py @@ -0,0 +1,20 @@ +# ------------------------------------ +# Copyright (c) Microsoft Corporation. +# Licensed under the MIT License. +# ------------------------------------ +"""Customize generated code here. + +Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize +""" +from typing import List + +__all__: List[str] = [] # Add all objects you want publicly available to users at this package level + + +def patch_sdk(): + """Do not remove from this file. + + `patch_sdk` is a last resort escape hatch that allows you to do customizations + you can't accomplish using the techniques described in + https://aka.ms/azsdk/python/dpcodegen/python/customize + """ diff --git a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/models/__init__.py b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/models/__init__.py index f7749b38d83e..9ed9d984c521 100644 --- a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/models/__init__.py +++ b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/models/__init__.py @@ -6,93 +6,68 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -try: - from ._models_py3 import AddChatParticipantsRequest - from ._models_py3 import AddChatParticipantsResult - from ._models_py3 import ChatError - from ._models_py3 import ChatMessage - from ._models_py3 import ChatMessageContent - from ._models_py3 import ChatMessageReadReceipt - from ._models_py3 import ChatMessageReadReceiptsCollection - from ._models_py3 import ChatMessagesCollection - from ._models_py3 import ChatParticipant - from ._models_py3 import ChatParticipantsCollection - from ._models_py3 import ChatThreadItem - from ._models_py3 import ChatThreadProperties - from ._models_py3 import ChatThreadsItemCollection - from ._models_py3 import CommunicationErrorResponse - from ._models_py3 import CommunicationIdentifierModel - from ._models_py3 import CommunicationUserIdentifierModel - from ._models_py3 import CreateChatThreadRequest - from ._models_py3 import CreateChatThreadResult - from ._models_py3 import MicrosoftTeamsUserIdentifierModel - from ._models_py3 import PhoneNumberIdentifierModel - from ._models_py3 import SendChatMessageRequest - from ._models_py3 import SendChatMessageResult - from ._models_py3 import SendReadReceiptRequest - from ._models_py3 import SendTypingNotificationRequest - from ._models_py3 import UpdateChatMessageRequest - from ._models_py3 import UpdateChatThreadRequest -except (SyntaxError, ImportError): - from ._models import AddChatParticipantsRequest # type: ignore - from ._models import AddChatParticipantsResult # type: ignore - from ._models import ChatError # type: ignore - from ._models import ChatMessage # type: ignore - from ._models import ChatMessageContent # type: ignore - from ._models import ChatMessageReadReceipt # type: ignore - from ._models import ChatMessageReadReceiptsCollection # type: ignore - from ._models import ChatMessagesCollection # type: ignore - from ._models import ChatParticipant # type: ignore - from ._models import ChatParticipantsCollection # type: ignore - from ._models import ChatThreadItem # type: ignore - from ._models import ChatThreadProperties # type: ignore - from ._models import ChatThreadsItemCollection # type: ignore - from ._models import CommunicationErrorResponse # type: ignore - from ._models import CommunicationIdentifierModel # type: ignore - from ._models import CommunicationUserIdentifierModel # type: ignore - from ._models import CreateChatThreadRequest # type: ignore - from ._models import CreateChatThreadResult # type: ignore - from ._models import MicrosoftTeamsUserIdentifierModel # type: ignore - from ._models import PhoneNumberIdentifierModel # type: ignore - from ._models import SendChatMessageRequest # type: ignore - from ._models import SendChatMessageResult # type: ignore - from ._models import SendReadReceiptRequest # type: ignore - from ._models import SendTypingNotificationRequest # type: ignore - from ._models import UpdateChatMessageRequest # type: ignore - from ._models import UpdateChatThreadRequest # type: ignore +from ._models_py3 import AddChatParticipantsRequest +from ._models_py3 import AddChatParticipantsResult +from ._models_py3 import ChatError +from ._models_py3 import ChatMessage +from ._models_py3 import ChatMessageContent +from ._models_py3 import ChatMessageReadReceipt +from ._models_py3 import ChatMessageReadReceiptsCollection +from ._models_py3 import ChatMessagesCollection +from ._models_py3 import ChatParticipant +from ._models_py3 import ChatParticipantsCollection +from ._models_py3 import ChatThreadItem +from ._models_py3 import ChatThreadProperties +from ._models_py3 import ChatThreadsItemCollection +from ._models_py3 import CommunicationErrorResponse +from ._models_py3 import CommunicationIdentifierModel +from ._models_py3 import CommunicationUserIdentifierModel +from ._models_py3 import CreateChatThreadRequest +from ._models_py3 import CreateChatThreadResult +from ._models_py3 import MicrosoftTeamsUserIdentifierModel +from ._models_py3 import PhoneNumberIdentifierModel +from ._models_py3 import SendChatMessageRequest +from ._models_py3 import SendChatMessageResult +from ._models_py3 import SendReadReceiptRequest +from ._models_py3 import SendTypingNotificationRequest +from ._models_py3 import UpdateChatMessageRequest +from ._models_py3 import UpdateChatThreadRequest -from ._azure_communication_chat_service_enums import ( - ChatMessageType, - CommunicationCloudEnvironmentModel, -) +from ._azure_communication_chat_service_enums import ChatMessageType +from ._azure_communication_chat_service_enums import CommunicationCloudEnvironmentModel +from ._patch import __all__ as _patch_all +from ._patch import * # type: ignore # pylint: disable=unused-wildcard-import +from ._patch import patch_sdk as _patch_sdk __all__ = [ - 'AddChatParticipantsRequest', - 'AddChatParticipantsResult', - 'ChatError', - 'ChatMessage', - 'ChatMessageContent', - 'ChatMessageReadReceipt', - 'ChatMessageReadReceiptsCollection', - 'ChatMessagesCollection', - 'ChatParticipant', - 'ChatParticipantsCollection', - 'ChatThreadItem', - 'ChatThreadProperties', - 'ChatThreadsItemCollection', - 'CommunicationErrorResponse', - 'CommunicationIdentifierModel', - 'CommunicationUserIdentifierModel', - 'CreateChatThreadRequest', - 'CreateChatThreadResult', - 'MicrosoftTeamsUserIdentifierModel', - 'PhoneNumberIdentifierModel', - 'SendChatMessageRequest', - 'SendChatMessageResult', - 'SendReadReceiptRequest', - 'SendTypingNotificationRequest', - 'UpdateChatMessageRequest', - 'UpdateChatThreadRequest', - 'ChatMessageType', - 'CommunicationCloudEnvironmentModel', + "AddChatParticipantsRequest", + "AddChatParticipantsResult", + "ChatError", + "ChatMessage", + "ChatMessageContent", + "ChatMessageReadReceipt", + "ChatMessageReadReceiptsCollection", + "ChatMessagesCollection", + "ChatParticipant", + "ChatParticipantsCollection", + "ChatThreadItem", + "ChatThreadProperties", + "ChatThreadsItemCollection", + "CommunicationErrorResponse", + "CommunicationIdentifierModel", + "CommunicationUserIdentifierModel", + "CreateChatThreadRequest", + "CreateChatThreadResult", + "MicrosoftTeamsUserIdentifierModel", + "PhoneNumberIdentifierModel", + "SendChatMessageRequest", + "SendChatMessageResult", + "SendReadReceiptRequest", + "SendTypingNotificationRequest", + "UpdateChatMessageRequest", + "UpdateChatThreadRequest", + "ChatMessageType", + "CommunicationCloudEnvironmentModel", ] +__all__.extend([p for p in _patch_all if p not in __all__]) +_patch_sdk() diff --git a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/models/_azure_communication_chat_service_enums.py b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/models/_azure_communication_chat_service_enums.py index 0a32c53074ba..1413d4e6d606 100644 --- a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/models/_azure_communication_chat_service_enums.py +++ b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/models/_azure_communication_chat_service_enums.py @@ -6,29 +6,12 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from enum import Enum, EnumMeta -from six import with_metaclass +from enum import Enum +from azure.core import CaseInsensitiveEnumMeta -class _CaseInsensitiveEnumMeta(EnumMeta): - def __getitem__(self, name): - return super().__getitem__(name.upper()) - def __getattr__(cls, name): - """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. - """ - try: - return cls._member_map_[name.upper()] - except KeyError: - raise AttributeError(name) - - -class ChatMessageType(with_metaclass(_CaseInsensitiveEnumMeta, str, Enum)): - """The chat message type. - """ +class ChatMessageType(str, Enum, metaclass=CaseInsensitiveEnumMeta): + """The chat message type.""" TEXT = "text" HTML = "html" @@ -36,9 +19,9 @@ class ChatMessageType(with_metaclass(_CaseInsensitiveEnumMeta, str, Enum)): PARTICIPANT_ADDED = "participantAdded" PARTICIPANT_REMOVED = "participantRemoved" -class CommunicationCloudEnvironmentModel(with_metaclass(_CaseInsensitiveEnumMeta, str, Enum)): - """The cloud that the identifier belongs to. - """ + +class CommunicationCloudEnvironmentModel(str, Enum, metaclass=CaseInsensitiveEnumMeta): + """The cloud that the identifier belongs to.""" PUBLIC = "public" DOD = "dod" diff --git a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/models/_models.py b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/models/_models.py deleted file mode 100644 index 2e1e946d3b86..000000000000 --- a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/models/_models.py +++ /dev/null @@ -1,875 +0,0 @@ -# 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 azure.core.exceptions import HttpResponseError -import msrest.serialization - - -class AddChatParticipantsRequest(msrest.serialization.Model): - """Participants to be added to the thread. - - All required parameters must be populated in order to send to Azure. - - :param participants: Required. Participants to add to a chat thread. - :type participants: list[~azure.communication.chat.models.ChatParticipant] - """ - - _validation = { - 'participants': {'required': True}, - } - - _attribute_map = { - 'participants': {'key': 'participants', 'type': '[ChatParticipant]'}, - } - - def __init__( - self, - **kwargs - ): - super(AddChatParticipantsRequest, self).__init__(**kwargs) - self.participants = kwargs['participants'] - - -class AddChatParticipantsResult(msrest.serialization.Model): - """Result of the add chat participants operation. - - Variables are only populated by the server, and will be ignored when sending a request. - - :ivar invalid_participants: The participants that failed to be added to the chat thread. - :vartype invalid_participants: list[~azure.communication.chat.models.ChatError] - """ - - _validation = { - 'invalid_participants': {'readonly': True}, - } - - _attribute_map = { - 'invalid_participants': {'key': 'invalidParticipants', 'type': '[ChatError]'}, - } - - def __init__( - self, - **kwargs - ): - super(AddChatParticipantsResult, self).__init__(**kwargs) - self.invalid_participants = None - - -class ChatError(msrest.serialization.Model): - """The Communication Services error. - - Variables are only populated by the server, and will be ignored when sending a request. - - All required parameters must be populated in order to send to Azure. - - :param code: Required. The error code. - :type code: str - :param message: Required. The error message. - :type message: str - :ivar target: The error target. - :vartype target: str - :ivar details: Further details about specific errors that led to this error. - :vartype details: list[~azure.communication.chat.models.ChatError] - :ivar inner_error: The inner error if any. - :vartype inner_error: ~azure.communication.chat.models.ChatError - """ - - _validation = { - 'code': {'required': True}, - 'message': {'required': True}, - 'target': {'readonly': True}, - 'details': {'readonly': True}, - 'inner_error': {'readonly': True}, - } - - _attribute_map = { - 'code': {'key': 'code', 'type': 'str'}, - 'message': {'key': 'message', 'type': 'str'}, - 'target': {'key': 'target', 'type': 'str'}, - 'details': {'key': 'details', 'type': '[ChatError]'}, - 'inner_error': {'key': 'innererror', 'type': 'ChatError'}, - } - - def __init__( - self, - **kwargs - ): - super(ChatError, self).__init__(**kwargs) - self.code = kwargs['code'] - self.message = kwargs['message'] - self.target = None - self.details = None - self.inner_error = None - - -class ChatMessage(msrest.serialization.Model): - """Chat message. - - All required parameters must be populated in order to send to Azure. - - :param id: Required. The id of the chat message. This id is server generated. - :type id: str - :param type: Required. The chat message type. Possible values include: "text", "html", - "topicUpdated", "participantAdded", "participantRemoved". - :type type: str or ~azure.communication.chat.models.ChatMessageType - :param sequence_id: Required. Sequence of the chat message in the conversation. - :type sequence_id: str - :param version: Required. Version of the chat message. - :type version: str - :param content: Content of a chat message. - :type content: ~azure.communication.chat.models.ChatMessageContent - :param sender_display_name: The display name of the chat message sender. This property is used - to populate sender name for push notifications. - :type sender_display_name: str - :param created_on: Required. The timestamp when the chat message arrived at the server. The - timestamp is in RFC3339 format: ``yyyy-MM-ddTHH:mm:ssZ``. - :type created_on: ~datetime.datetime - :param sender_communication_identifier: Identifies a participant in Azure Communication - services. A participant is, for example, a phone number or an Azure communication user. This - model must be interpreted as a union: Apart from rawId, at most one further property may be - set. - :type sender_communication_identifier: - ~azure.communication.chat.models.CommunicationIdentifierModel - :param deleted_on: The timestamp (if applicable) when the message was deleted. The timestamp is - in RFC3339 format: ``yyyy-MM-ddTHH:mm:ssZ``. - :type deleted_on: ~datetime.datetime - :param edited_on: The last timestamp (if applicable) when the message was edited. The timestamp - is in RFC3339 format: ``yyyy-MM-ddTHH:mm:ssZ``. - :type edited_on: ~datetime.datetime - :param metadata: Message metadata. - :type metadata: dict[str, str] - """ - - _validation = { - 'id': {'required': True}, - 'type': {'required': True}, - 'sequence_id': {'required': True}, - 'version': {'required': True}, - 'created_on': {'required': True}, - } - - _attribute_map = { - 'id': {'key': 'id', 'type': 'str'}, - 'type': {'key': 'type', 'type': 'str'}, - 'sequence_id': {'key': 'sequenceId', 'type': 'str'}, - 'version': {'key': 'version', 'type': 'str'}, - 'content': {'key': 'content', 'type': 'ChatMessageContent'}, - 'sender_display_name': {'key': 'senderDisplayName', 'type': 'str'}, - 'created_on': {'key': 'createdOn', 'type': 'iso-8601'}, - 'sender_communication_identifier': {'key': 'senderCommunicationIdentifier', 'type': 'CommunicationIdentifierModel'}, - 'deleted_on': {'key': 'deletedOn', 'type': 'iso-8601'}, - 'edited_on': {'key': 'editedOn', 'type': 'iso-8601'}, - 'metadata': {'key': 'metadata', 'type': '{str}'}, - } - - def __init__( - self, - **kwargs - ): - super(ChatMessage, self).__init__(**kwargs) - self.id = kwargs['id'] - self.type = kwargs['type'] - self.sequence_id = kwargs['sequence_id'] - self.version = kwargs['version'] - self.content = kwargs.get('content', None) - self.sender_display_name = kwargs.get('sender_display_name', None) - self.created_on = kwargs['created_on'] - self.sender_communication_identifier = kwargs.get('sender_communication_identifier', None) - self.deleted_on = kwargs.get('deleted_on', None) - self.edited_on = kwargs.get('edited_on', None) - self.metadata = kwargs.get('metadata', None) - - -class ChatMessageContent(msrest.serialization.Model): - """Content of a chat message. - - :param message: Chat message content for messages of types text or html. - :type message: str - :param topic: Chat message content for messages of type topicUpdated. - :type topic: str - :param participants: Chat message content for messages of types participantAdded or - participantRemoved. - :type participants: list[~azure.communication.chat.models.ChatParticipant] - :param initiator_communication_identifier: Identifies a participant in Azure Communication - services. A participant is, for example, a phone number or an Azure communication user. This - model must be interpreted as a union: Apart from rawId, at most one further property may be - set. - :type initiator_communication_identifier: - ~azure.communication.chat.models.CommunicationIdentifierModel - """ - - _attribute_map = { - 'message': {'key': 'message', 'type': 'str'}, - 'topic': {'key': 'topic', 'type': 'str'}, - 'participants': {'key': 'participants', 'type': '[ChatParticipant]'}, - 'initiator_communication_identifier': {'key': 'initiatorCommunicationIdentifier', 'type': 'CommunicationIdentifierModel'}, - } - - def __init__( - self, - **kwargs - ): - super(ChatMessageContent, self).__init__(**kwargs) - self.message = kwargs.get('message', None) - self.topic = kwargs.get('topic', None) - self.participants = kwargs.get('participants', None) - self.initiator_communication_identifier = kwargs.get('initiator_communication_identifier', None) - - -class ChatMessageReadReceipt(msrest.serialization.Model): - """A chat message read receipt indicates the time a chat message was read by a recipient. - - All required parameters must be populated in order to send to Azure. - - :param sender_communication_identifier: Required. Identifies a participant in Azure - Communication services. A participant is, for example, a phone number or an Azure communication - user. This model must be interpreted as a union: Apart from rawId, at most one further property - may be set. - :type sender_communication_identifier: - ~azure.communication.chat.models.CommunicationIdentifierModel - :param chat_message_id: Required. Id of the chat message that has been read. This id is - generated by the server. - :type chat_message_id: str - :param read_on: Required. The time at which the message was read. The timestamp is in RFC3339 - format: ``yyyy-MM-ddTHH:mm:ssZ``. - :type read_on: ~datetime.datetime - """ - - _validation = { - 'sender_communication_identifier': {'required': True}, - 'chat_message_id': {'required': True}, - 'read_on': {'required': True}, - } - - _attribute_map = { - 'sender_communication_identifier': {'key': 'senderCommunicationIdentifier', 'type': 'CommunicationIdentifierModel'}, - 'chat_message_id': {'key': 'chatMessageId', 'type': 'str'}, - 'read_on': {'key': 'readOn', 'type': 'iso-8601'}, - } - - def __init__( - self, - **kwargs - ): - super(ChatMessageReadReceipt, self).__init__(**kwargs) - self.sender_communication_identifier = kwargs['sender_communication_identifier'] - self.chat_message_id = kwargs['chat_message_id'] - self.read_on = kwargs['read_on'] - - -class ChatMessageReadReceiptsCollection(msrest.serialization.Model): - """A paged collection of chat message read receipts. - - Variables are only populated by the server, and will be ignored when sending a request. - - All required parameters must be populated in order to send to Azure. - - :param value: Required. Collection of chat message read receipts. - :type value: list[~azure.communication.chat.models.ChatMessageReadReceipt] - :ivar next_link: If there are more chat message read receipts that can be retrieved, the next - link will be populated. - :vartype next_link: str - """ - - _validation = { - 'value': {'required': True}, - 'next_link': {'readonly': True}, - } - - _attribute_map = { - 'value': {'key': 'value', 'type': '[ChatMessageReadReceipt]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, - } - - def __init__( - self, - **kwargs - ): - super(ChatMessageReadReceiptsCollection, self).__init__(**kwargs) - self.value = kwargs['value'] - self.next_link = None - - -class ChatMessagesCollection(msrest.serialization.Model): - """Collection of chat messages for a particular chat thread. - - Variables are only populated by the server, and will be ignored when sending a request. - - All required parameters must be populated in order to send to Azure. - - :param value: Required. Collection of chat messages. - :type value: list[~azure.communication.chat.models.ChatMessage] - :ivar next_link: If there are more chat messages that can be retrieved, the next link will be - populated. - :vartype next_link: str - """ - - _validation = { - 'value': {'required': True}, - 'next_link': {'readonly': True}, - } - - _attribute_map = { - 'value': {'key': 'value', 'type': '[ChatMessage]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, - } - - def __init__( - self, - **kwargs - ): - super(ChatMessagesCollection, self).__init__(**kwargs) - self.value = kwargs['value'] - self.next_link = None - - -class ChatParticipant(msrest.serialization.Model): - """A participant of the chat thread. - - All required parameters must be populated in order to send to Azure. - - :param communication_identifier: Required. Identifies a participant in Azure Communication - services. A participant is, for example, a phone number or an Azure communication user. This - model must be interpreted as a union: Apart from rawId, at most one further property may be - set. - :type communication_identifier: ~azure.communication.chat.models.CommunicationIdentifierModel - :param display_name: Display name for the chat participant. - :type display_name: str - :param share_history_time: Time from which the chat history is shared with the participant. The - timestamp is in RFC3339 format: ``yyyy-MM-ddTHH:mm:ssZ``. - :type share_history_time: ~datetime.datetime - """ - - _validation = { - 'communication_identifier': {'required': True}, - } - - _attribute_map = { - 'communication_identifier': {'key': 'communicationIdentifier', 'type': 'CommunicationIdentifierModel'}, - 'display_name': {'key': 'displayName', 'type': 'str'}, - 'share_history_time': {'key': 'shareHistoryTime', 'type': 'iso-8601'}, - } - - def __init__( - self, - **kwargs - ): - super(ChatParticipant, self).__init__(**kwargs) - self.communication_identifier = kwargs['communication_identifier'] - self.display_name = kwargs.get('display_name', None) - self.share_history_time = kwargs.get('share_history_time', None) - - -class ChatParticipantsCollection(msrest.serialization.Model): - """Collection of participants belong to a particular thread. - - Variables are only populated by the server, and will be ignored when sending a request. - - All required parameters must be populated in order to send to Azure. - - :param value: Required. Chat participants. - :type value: list[~azure.communication.chat.models.ChatParticipant] - :ivar next_link: If there are more chat participants that can be retrieved, the next link will - be populated. - :vartype next_link: str - """ - - _validation = { - 'value': {'required': True}, - 'next_link': {'readonly': True}, - } - - _attribute_map = { - 'value': {'key': 'value', 'type': '[ChatParticipant]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, - } - - def __init__( - self, - **kwargs - ): - super(ChatParticipantsCollection, self).__init__(**kwargs) - self.value = kwargs['value'] - self.next_link = None - - -class ChatThreadItem(msrest.serialization.Model): - """Summary information of a chat thread. - - Variables are only populated by the server, and will be ignored when sending a request. - - All required parameters must be populated in order to send to Azure. - - :param id: Required. Chat thread id. - :type id: str - :param topic: Required. Chat thread topic. - :type topic: str - :param deleted_on: The timestamp when the chat thread was deleted. The timestamp is in RFC3339 - format: ``yyyy-MM-ddTHH:mm:ssZ``. - :type deleted_on: ~datetime.datetime - :ivar last_message_received_on: The timestamp when the last message arrived at the server. The - timestamp is in RFC3339 format: ``yyyy-MM-ddTHH:mm:ssZ``. - :vartype last_message_received_on: ~datetime.datetime - """ - - _validation = { - 'id': {'required': True}, - 'topic': {'required': True}, - 'last_message_received_on': {'readonly': True}, - } - - _attribute_map = { - 'id': {'key': 'id', 'type': 'str'}, - 'topic': {'key': 'topic', 'type': 'str'}, - 'deleted_on': {'key': 'deletedOn', 'type': 'iso-8601'}, - 'last_message_received_on': {'key': 'lastMessageReceivedOn', 'type': 'iso-8601'}, - } - - def __init__( - self, - **kwargs - ): - super(ChatThreadItem, self).__init__(**kwargs) - self.id = kwargs['id'] - self.topic = kwargs['topic'] - self.deleted_on = kwargs.get('deleted_on', None) - self.last_message_received_on = None - - -class ChatThreadProperties(msrest.serialization.Model): - """Chat thread. - - All required parameters must be populated in order to send to Azure. - - :param id: Required. Chat thread id. - :type id: str - :param topic: Required. Chat thread topic. - :type topic: str - :param created_on: Required. The timestamp when the chat thread was created. The timestamp is - in RFC3339 format: ``yyyy-MM-ddTHH:mm:ssZ``. - :type created_on: ~datetime.datetime - :param created_by_communication_identifier: Required. Identifies a participant in Azure - Communication services. A participant is, for example, a phone number or an Azure communication - user. This model must be interpreted as a union: Apart from rawId, at most one further property - may be set. - :type created_by_communication_identifier: - ~azure.communication.chat.models.CommunicationIdentifierModel - :param deleted_on: The timestamp when the chat thread was deleted. The timestamp is in RFC3339 - format: ``yyyy-MM-ddTHH:mm:ssZ``. - :type deleted_on: ~datetime.datetime - """ - - _validation = { - 'id': {'required': True}, - 'topic': {'required': True}, - 'created_on': {'required': True}, - 'created_by_communication_identifier': {'required': True}, - } - - _attribute_map = { - 'id': {'key': 'id', 'type': 'str'}, - 'topic': {'key': 'topic', 'type': 'str'}, - 'created_on': {'key': 'createdOn', 'type': 'iso-8601'}, - 'created_by_communication_identifier': {'key': 'createdByCommunicationIdentifier', 'type': 'CommunicationIdentifierModel'}, - 'deleted_on': {'key': 'deletedOn', 'type': 'iso-8601'}, - } - - def __init__( - self, - **kwargs - ): - super(ChatThreadProperties, self).__init__(**kwargs) - self.id = kwargs['id'] - self.topic = kwargs['topic'] - self.created_on = kwargs['created_on'] - self.created_by_communication_identifier = kwargs['created_by_communication_identifier'] - self.deleted_on = kwargs.get('deleted_on', None) - - -class ChatThreadsItemCollection(msrest.serialization.Model): - """Collection of chat threads. - - Variables are only populated by the server, and will be ignored when sending a request. - - All required parameters must be populated in order to send to Azure. - - :param value: Required. Collection of chat threads. - :type value: list[~azure.communication.chat.models.ChatThreadItem] - :ivar next_link: If there are more chat threads that can be retrieved, the next link will be - populated. - :vartype next_link: str - """ - - _validation = { - 'value': {'required': True}, - 'next_link': {'readonly': True}, - } - - _attribute_map = { - 'value': {'key': 'value', 'type': '[ChatThreadItem]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, - } - - def __init__( - self, - **kwargs - ): - super(ChatThreadsItemCollection, self).__init__(**kwargs) - self.value = kwargs['value'] - self.next_link = None - - -class CommunicationErrorResponse(msrest.serialization.Model): - """The Communication Services error. - - All required parameters must be populated in order to send to Azure. - - :param error: Required. The Communication Services error. - :type error: ~azure.communication.chat.models.ChatError - """ - - _validation = { - 'error': {'required': True}, - } - - _attribute_map = { - 'error': {'key': 'error', 'type': 'ChatError'}, - } - - def __init__( - self, - **kwargs - ): - super(CommunicationErrorResponse, self).__init__(**kwargs) - self.error = kwargs['error'] - - -class CommunicationIdentifierModel(msrest.serialization.Model): - """Identifies a participant in Azure Communication services. A participant is, for example, a phone number or an Azure communication user. This model must be interpreted as a union: Apart from rawId, at most one further property may be set. - - :param raw_id: Raw Id of the identifier. Optional in requests, required in responses. - :type raw_id: str - :param communication_user: The communication user. - :type communication_user: ~azure.communication.chat.models.CommunicationUserIdentifierModel - :param phone_number: The phone number. - :type phone_number: ~azure.communication.chat.models.PhoneNumberIdentifierModel - :param microsoft_teams_user: The Microsoft Teams user. - :type microsoft_teams_user: ~azure.communication.chat.models.MicrosoftTeamsUserIdentifierModel - """ - - _attribute_map = { - 'raw_id': {'key': 'rawId', 'type': 'str'}, - 'communication_user': {'key': 'communicationUser', 'type': 'CommunicationUserIdentifierModel'}, - 'phone_number': {'key': 'phoneNumber', 'type': 'PhoneNumberIdentifierModel'}, - 'microsoft_teams_user': {'key': 'microsoftTeamsUser', 'type': 'MicrosoftTeamsUserIdentifierModel'}, - } - - def __init__( - self, - **kwargs - ): - super(CommunicationIdentifierModel, self).__init__(**kwargs) - self.raw_id = kwargs.get('raw_id', None) - self.communication_user = kwargs.get('communication_user', None) - self.phone_number = kwargs.get('phone_number', None) - self.microsoft_teams_user = kwargs.get('microsoft_teams_user', None) - - -class CommunicationUserIdentifierModel(msrest.serialization.Model): - """A user that got created with an Azure Communication Services resource. - - All required parameters must be populated in order to send to Azure. - - :param id: Required. The Id of the communication user. - :type id: str - """ - - _validation = { - 'id': {'required': True}, - } - - _attribute_map = { - 'id': {'key': 'id', 'type': 'str'}, - } - - def __init__( - self, - **kwargs - ): - super(CommunicationUserIdentifierModel, self).__init__(**kwargs) - self.id = kwargs['id'] - - -class CreateChatThreadRequest(msrest.serialization.Model): - """Request payload for creating a chat thread. - - All required parameters must be populated in order to send to Azure. - - :param topic: Required. The chat thread topic. - :type topic: str - :param participants: Participants to be added to the chat thread. - :type participants: list[~azure.communication.chat.models.ChatParticipant] - """ - - _validation = { - 'topic': {'required': True}, - } - - _attribute_map = { - 'topic': {'key': 'topic', 'type': 'str'}, - 'participants': {'key': 'participants', 'type': '[ChatParticipant]'}, - } - - def __init__( - self, - **kwargs - ): - super(CreateChatThreadRequest, self).__init__(**kwargs) - self.topic = kwargs['topic'] - self.participants = kwargs.get('participants', None) - - -class CreateChatThreadResult(msrest.serialization.Model): - """Result of the create chat thread operation. - - Variables are only populated by the server, and will be ignored when sending a request. - - :param chat_thread: Chat thread. - :type chat_thread: ~azure.communication.chat.models.ChatThreadProperties - :ivar invalid_participants: The participants that failed to be added to the chat thread. - :vartype invalid_participants: list[~azure.communication.chat.models.ChatError] - """ - - _validation = { - 'invalid_participants': {'readonly': True}, - } - - _attribute_map = { - 'chat_thread': {'key': 'chatThread', 'type': 'ChatThreadProperties'}, - 'invalid_participants': {'key': 'invalidParticipants', 'type': '[ChatError]'}, - } - - def __init__( - self, - **kwargs - ): - super(CreateChatThreadResult, self).__init__(**kwargs) - self.chat_thread = kwargs.get('chat_thread', None) - self.invalid_participants = None - - -class MicrosoftTeamsUserIdentifierModel(msrest.serialization.Model): - """A Microsoft Teams user. - - All required parameters must be populated in order to send to Azure. - - :param user_id: Required. The Id of the Microsoft Teams user. If not anonymous, this is the AAD - object Id of the user. - :type user_id: str - :param is_anonymous: True if the Microsoft Teams user is anonymous. By default false if - missing. - :type is_anonymous: bool - :param cloud: The cloud that the Microsoft Teams user belongs to. By default 'public' if - missing. Possible values include: "public", "dod", "gcch". - :type cloud: str or ~azure.communication.chat.models.CommunicationCloudEnvironmentModel - """ - - _validation = { - 'user_id': {'required': True}, - } - - _attribute_map = { - 'user_id': {'key': 'userId', 'type': 'str'}, - 'is_anonymous': {'key': 'isAnonymous', 'type': 'bool'}, - 'cloud': {'key': 'cloud', 'type': 'str'}, - } - - def __init__( - self, - **kwargs - ): - super(MicrosoftTeamsUserIdentifierModel, self).__init__(**kwargs) - self.user_id = kwargs['user_id'] - self.is_anonymous = kwargs.get('is_anonymous', None) - self.cloud = kwargs.get('cloud', None) - - -class PhoneNumberIdentifierModel(msrest.serialization.Model): - """A phone number. - - All required parameters must be populated in order to send to Azure. - - :param value: Required. The phone number in E.164 format. - :type value: str - """ - - _validation = { - 'value': {'required': True}, - } - - _attribute_map = { - 'value': {'key': 'value', 'type': 'str'}, - } - - def __init__( - self, - **kwargs - ): - super(PhoneNumberIdentifierModel, self).__init__(**kwargs) - self.value = kwargs['value'] - - -class SendChatMessageRequest(msrest.serialization.Model): - """Details of the message to send. - - All required parameters must be populated in order to send to Azure. - - :param content: Required. Chat message content. - :type content: str - :param sender_display_name: The display name of the chat message sender. This property is used - to populate sender name for push notifications. - :type sender_display_name: str - :param type: The chat message type. Possible values include: "text", "html", "topicUpdated", - "participantAdded", "participantRemoved". - :type type: str or ~azure.communication.chat.models.ChatMessageType - :param metadata: Message metadata. - :type metadata: dict[str, str] - """ - - _validation = { - 'content': {'required': True}, - } - - _attribute_map = { - 'content': {'key': 'content', 'type': 'str'}, - 'sender_display_name': {'key': 'senderDisplayName', 'type': 'str'}, - 'type': {'key': 'type', 'type': 'str'}, - 'metadata': {'key': 'metadata', 'type': '{str}'}, - } - - def __init__( - self, - **kwargs - ): - super(SendChatMessageRequest, self).__init__(**kwargs) - self.content = kwargs['content'] - self.sender_display_name = kwargs.get('sender_display_name', None) - self.type = kwargs.get('type', None) - self.metadata = kwargs.get('metadata', None) - - -class SendChatMessageResult(msrest.serialization.Model): - """Result of the send message operation. - - All required parameters must be populated in order to send to Azure. - - :param id: Required. A server-generated message id. - :type id: str - """ - - _validation = { - 'id': {'required': True}, - } - - _attribute_map = { - 'id': {'key': 'id', 'type': 'str'}, - } - - def __init__( - self, - **kwargs - ): - super(SendChatMessageResult, self).__init__(**kwargs) - self.id = kwargs['id'] - - -class SendReadReceiptRequest(msrest.serialization.Model): - """Request payload for sending a read receipt. - - All required parameters must be populated in order to send to Azure. - - :param chat_message_id: Required. Id of the latest chat message read by the user. - :type chat_message_id: str - """ - - _validation = { - 'chat_message_id': {'required': True}, - } - - _attribute_map = { - 'chat_message_id': {'key': 'chatMessageId', 'type': 'str'}, - } - - def __init__( - self, - **kwargs - ): - super(SendReadReceiptRequest, self).__init__(**kwargs) - self.chat_message_id = kwargs['chat_message_id'] - - -class SendTypingNotificationRequest(msrest.serialization.Model): - """Request payload for typing notifications. - - :param sender_display_name: The display name of the typing notification sender. This property - is used to populate sender name for push notifications. - :type sender_display_name: str - """ - - _attribute_map = { - 'sender_display_name': {'key': 'senderDisplayName', 'type': 'str'}, - } - - def __init__( - self, - **kwargs - ): - super(SendTypingNotificationRequest, self).__init__(**kwargs) - self.sender_display_name = kwargs.get('sender_display_name', None) - - -class UpdateChatMessageRequest(msrest.serialization.Model): - """Request payload for updating a chat message. - - :param content: Chat message content. - :type content: str - :param metadata: Message metadata. - :type metadata: dict[str, str] - """ - - _attribute_map = { - 'content': {'key': 'content', 'type': 'str'}, - 'metadata': {'key': 'metadata', 'type': '{str}'}, - } - - def __init__( - self, - **kwargs - ): - super(UpdateChatMessageRequest, self).__init__(**kwargs) - self.content = kwargs.get('content', None) - self.metadata = kwargs.get('metadata', None) - - -class UpdateChatThreadRequest(msrest.serialization.Model): - """Request payload for updating a chat thread. - - :param topic: Chat thread topic. - :type topic: str - """ - - _attribute_map = { - 'topic': {'key': 'topic', 'type': 'str'}, - } - - def __init__( - self, - **kwargs - ): - super(UpdateChatThreadRequest, self).__init__(**kwargs) - self.topic = kwargs.get('topic', None) diff --git a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/models/_models_py3.py b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/models/_models_py3.py index aeed862eed73..10a46d69b197 100644 --- a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/models/_models_py3.py +++ b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/models/_models_py3.py @@ -1,4 +1,5 @@ # coding=utf-8 +# pylint: disable=too-many-lines # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for license information. @@ -7,42 +8,42 @@ # -------------------------------------------------------------------------- import datetime -from typing import Dict, List, Optional, Union +from typing import Dict, List, Optional, TYPE_CHECKING, Union -from azure.core.exceptions import HttpResponseError -import msrest.serialization +from .. import _serialization -from ._azure_communication_chat_service_enums import * +if TYPE_CHECKING: + # pylint: disable=unused-import,ungrouped-imports + from .. import models as _models -class AddChatParticipantsRequest(msrest.serialization.Model): +class AddChatParticipantsRequest(_serialization.Model): """Participants to be added to the thread. All required parameters must be populated in order to send to Azure. - :param participants: Required. Participants to add to a chat thread. - :type participants: list[~azure.communication.chat.models.ChatParticipant] + :ivar participants: Participants to add to a chat thread. Required. + :vartype participants: list[~azure.communication.chat.models.ChatParticipant] """ _validation = { - 'participants': {'required': True}, + "participants": {"required": True}, } _attribute_map = { - 'participants': {'key': 'participants', 'type': '[ChatParticipant]'}, + "participants": {"key": "participants", "type": "[ChatParticipant]"}, } - def __init__( - self, - *, - participants: List["ChatParticipant"], - **kwargs - ): - super(AddChatParticipantsRequest, self).__init__(**kwargs) + def __init__(self, *, participants: List["_models.ChatParticipant"], **kwargs): + """ + :keyword participants: Participants to add to a chat thread. Required. + :paramtype participants: list[~azure.communication.chat.models.ChatParticipant] + """ + super().__init__(**kwargs) self.participants = participants -class AddChatParticipantsResult(msrest.serialization.Model): +class AddChatParticipantsResult(_serialization.Model): """Result of the add chat participants operation. Variables are only populated by the server, and will be ignored when sending a request. @@ -52,32 +53,30 @@ class AddChatParticipantsResult(msrest.serialization.Model): """ _validation = { - 'invalid_participants': {'readonly': True}, + "invalid_participants": {"readonly": True}, } _attribute_map = { - 'invalid_participants': {'key': 'invalidParticipants', 'type': '[ChatError]'}, + "invalid_participants": {"key": "invalidParticipants", "type": "[ChatError]"}, } - def __init__( - self, - **kwargs - ): - super(AddChatParticipantsResult, self).__init__(**kwargs) + def __init__(self, **kwargs): + """ """ + super().__init__(**kwargs) self.invalid_participants = None -class ChatError(msrest.serialization.Model): +class ChatError(_serialization.Model): """The Communication Services error. Variables are only populated by the server, and will be ignored when sending a request. All required parameters must be populated in order to send to Azure. - :param code: Required. The error code. - :type code: str - :param message: Required. The error message. - :type message: str + :ivar code: The error code. Required. + :vartype code: str + :ivar message: The error message. Required. + :vartype message: str :ivar target: The error target. :vartype target: str :ivar details: Further details about specific errors that led to this error. @@ -87,29 +86,29 @@ class ChatError(msrest.serialization.Model): """ _validation = { - 'code': {'required': True}, - 'message': {'required': True}, - 'target': {'readonly': True}, - 'details': {'readonly': True}, - 'inner_error': {'readonly': True}, + "code": {"required": True}, + "message": {"required": True}, + "target": {"readonly": True}, + "details": {"readonly": True}, + "inner_error": {"readonly": True}, } _attribute_map = { - 'code': {'key': 'code', 'type': 'str'}, - 'message': {'key': 'message', 'type': 'str'}, - 'target': {'key': 'target', 'type': 'str'}, - 'details': {'key': 'details', 'type': '[ChatError]'}, - 'inner_error': {'key': 'innererror', 'type': 'ChatError'}, + "code": {"key": "code", "type": "str"}, + "message": {"key": "message", "type": "str"}, + "target": {"key": "target", "type": "str"}, + "details": {"key": "details", "type": "[ChatError]"}, + "inner_error": {"key": "innererror", "type": "ChatError"}, } - def __init__( - self, - *, - code: str, - message: str, - **kwargs - ): - super(ChatError, self).__init__(**kwargs) + def __init__(self, *, code: str, message: str, **kwargs): + """ + :keyword code: The error code. Required. + :paramtype code: str + :keyword message: The error message. Required. + :paramtype message: str + """ + super().__init__(**kwargs) self.code = code self.message = message self.target = None @@ -117,83 +116,119 @@ def __init__( self.inner_error = None -class ChatMessage(msrest.serialization.Model): +class ChatMessage(_serialization.Model): # pylint: disable=too-many-instance-attributes """Chat message. All required parameters must be populated in order to send to Azure. - :param id: Required. The id of the chat message. This id is server generated. - :type id: str - :param type: Required. The chat message type. Possible values include: "text", "html", - "topicUpdated", "participantAdded", "participantRemoved". - :type type: str or ~azure.communication.chat.models.ChatMessageType - :param sequence_id: Required. Sequence of the chat message in the conversation. - :type sequence_id: str - :param version: Required. Version of the chat message. - :type version: str - :param content: Content of a chat message. - :type content: ~azure.communication.chat.models.ChatMessageContent - :param sender_display_name: The display name of the chat message sender. This property is used + :ivar id: The id of the chat message. This id is server generated. Required. + :vartype id: str + :ivar type: The chat message type. Required. Known values are: "text", "html", "topicUpdated", + "participantAdded", and "participantRemoved". + :vartype type: str or ~azure.communication.chat.models.ChatMessageType + :ivar sequence_id: Sequence of the chat message in the conversation. Required. + :vartype sequence_id: str + :ivar version: Version of the chat message. Required. + :vartype version: str + :ivar content: Content of a chat message. + :vartype content: ~azure.communication.chat.models.ChatMessageContent + :ivar sender_display_name: The display name of the chat message sender. This property is used to populate sender name for push notifications. - :type sender_display_name: str - :param created_on: Required. The timestamp when the chat message arrived at the server. The - timestamp is in RFC3339 format: ``yyyy-MM-ddTHH:mm:ssZ``. - :type created_on: ~datetime.datetime - :param sender_communication_identifier: Identifies a participant in Azure Communication + :vartype sender_display_name: str + :ivar created_on: The timestamp when the chat message arrived at the server. The timestamp is + in RFC3339 format: ``yyyy-MM-ddTHH:mm:ssZ``. Required. + :vartype created_on: ~datetime.datetime + :ivar sender_communication_identifier: Identifies a participant in Azure Communication services. A participant is, for example, a phone number or an Azure communication user. This model must be interpreted as a union: Apart from rawId, at most one further property may be set. - :type sender_communication_identifier: + :vartype sender_communication_identifier: ~azure.communication.chat.models.CommunicationIdentifierModel - :param deleted_on: The timestamp (if applicable) when the message was deleted. The timestamp is + :ivar deleted_on: The timestamp (if applicable) when the message was deleted. The timestamp is in RFC3339 format: ``yyyy-MM-ddTHH:mm:ssZ``. - :type deleted_on: ~datetime.datetime - :param edited_on: The last timestamp (if applicable) when the message was edited. The timestamp + :vartype deleted_on: ~datetime.datetime + :ivar edited_on: The last timestamp (if applicable) when the message was edited. The timestamp is in RFC3339 format: ``yyyy-MM-ddTHH:mm:ssZ``. - :type edited_on: ~datetime.datetime - :param metadata: Message metadata. - :type metadata: dict[str, str] + :vartype edited_on: ~datetime.datetime + :ivar metadata: Message metadata. + :vartype metadata: dict[str, str] """ _validation = { - 'id': {'required': True}, - 'type': {'required': True}, - 'sequence_id': {'required': True}, - 'version': {'required': True}, - 'created_on': {'required': True}, + "id": {"required": True}, + "type": {"required": True}, + "sequence_id": {"required": True}, + "version": {"required": True}, + "created_on": {"required": True}, } _attribute_map = { - 'id': {'key': 'id', 'type': 'str'}, - 'type': {'key': 'type', 'type': 'str'}, - 'sequence_id': {'key': 'sequenceId', 'type': 'str'}, - 'version': {'key': 'version', 'type': 'str'}, - 'content': {'key': 'content', 'type': 'ChatMessageContent'}, - 'sender_display_name': {'key': 'senderDisplayName', 'type': 'str'}, - 'created_on': {'key': 'createdOn', 'type': 'iso-8601'}, - 'sender_communication_identifier': {'key': 'senderCommunicationIdentifier', 'type': 'CommunicationIdentifierModel'}, - 'deleted_on': {'key': 'deletedOn', 'type': 'iso-8601'}, - 'edited_on': {'key': 'editedOn', 'type': 'iso-8601'}, - 'metadata': {'key': 'metadata', 'type': '{str}'}, + "id": {"key": "id", "type": "str"}, + "type": {"key": "type", "type": "str"}, + "sequence_id": {"key": "sequenceId", "type": "str"}, + "version": {"key": "version", "type": "str"}, + "content": {"key": "content", "type": "ChatMessageContent"}, + "sender_display_name": {"key": "senderDisplayName", "type": "str"}, + "created_on": {"key": "createdOn", "type": "iso-8601"}, + "sender_communication_identifier": { + "key": "senderCommunicationIdentifier", + "type": "CommunicationIdentifierModel", + }, + "deleted_on": {"key": "deletedOn", "type": "iso-8601"}, + "edited_on": {"key": "editedOn", "type": "iso-8601"}, + "metadata": {"key": "metadata", "type": "{str}"}, } def __init__( self, *, - id: str, - type: Union[str, "ChatMessageType"], + id: str, # pylint: disable=redefined-builtin + type: Union[str, "_models.ChatMessageType"], sequence_id: str, version: str, created_on: datetime.datetime, - content: Optional["ChatMessageContent"] = None, + content: Optional["_models.ChatMessageContent"] = None, sender_display_name: Optional[str] = None, - sender_communication_identifier: Optional["CommunicationIdentifierModel"] = None, + sender_communication_identifier: Optional["_models.CommunicationIdentifierModel"] = None, deleted_on: Optional[datetime.datetime] = None, edited_on: Optional[datetime.datetime] = None, metadata: Optional[Dict[str, str]] = None, **kwargs ): - super(ChatMessage, self).__init__(**kwargs) + """ + :keyword id: The id of the chat message. This id is server generated. Required. + :paramtype id: str + :keyword type: The chat message type. Required. Known values are: "text", "html", + "topicUpdated", "participantAdded", and "participantRemoved". + :paramtype type: str or ~azure.communication.chat.models.ChatMessageType + :keyword sequence_id: Sequence of the chat message in the conversation. Required. + :paramtype sequence_id: str + :keyword version: Version of the chat message. Required. + :paramtype version: str + :keyword content: Content of a chat message. + :paramtype content: ~azure.communication.chat.models.ChatMessageContent + :keyword sender_display_name: The display name of the chat message sender. This property is + used to populate sender name for push notifications. + :paramtype sender_display_name: str + :keyword created_on: The timestamp when the chat message arrived at the server. The timestamp + is in RFC3339 format: ``yyyy-MM-ddTHH:mm:ssZ``. Required. + :paramtype created_on: ~datetime.datetime + :keyword sender_communication_identifier: Identifies a participant in Azure Communication + services. A participant is, for example, a phone number or an Azure communication user. This + model must be interpreted as a union: Apart from rawId, at most one further property may be + set. + :paramtype sender_communication_identifier: + ~azure.communication.chat.models.CommunicationIdentifierModel + :keyword deleted_on: The timestamp (if applicable) when the message was deleted. The timestamp + is in RFC3339 format: ``yyyy-MM-ddTHH:mm:ssZ``. + :paramtype deleted_on: ~datetime.datetime + :keyword edited_on: The last timestamp (if applicable) when the message was edited. The + timestamp is in RFC3339 format: ``yyyy-MM-ddTHH:mm:ssZ``. + :paramtype edited_on: ~datetime.datetime + :keyword metadata: Message metadata. + :paramtype metadata: dict[str, str] + """ + super().__init__(**kwargs) self.id = id self.type = type self.sequence_id = sequence_id @@ -207,29 +242,32 @@ def __init__( self.metadata = metadata -class ChatMessageContent(msrest.serialization.Model): +class ChatMessageContent(_serialization.Model): """Content of a chat message. - :param message: Chat message content for messages of types text or html. - :type message: str - :param topic: Chat message content for messages of type topicUpdated. - :type topic: str - :param participants: Chat message content for messages of types participantAdded or + :ivar message: Chat message content for messages of types text or html. + :vartype message: str + :ivar topic: Chat message content for messages of type topicUpdated. + :vartype topic: str + :ivar participants: Chat message content for messages of types participantAdded or participantRemoved. - :type participants: list[~azure.communication.chat.models.ChatParticipant] - :param initiator_communication_identifier: Identifies a participant in Azure Communication + :vartype participants: list[~azure.communication.chat.models.ChatParticipant] + :ivar initiator_communication_identifier: Identifies a participant in Azure Communication services. A participant is, for example, a phone number or an Azure communication user. This model must be interpreted as a union: Apart from rawId, at most one further property may be set. - :type initiator_communication_identifier: + :vartype initiator_communication_identifier: ~azure.communication.chat.models.CommunicationIdentifierModel """ _attribute_map = { - 'message': {'key': 'message', 'type': 'str'}, - 'topic': {'key': 'topic', 'type': 'str'}, - 'participants': {'key': 'participants', 'type': '[ChatParticipant]'}, - 'initiator_communication_identifier': {'key': 'initiatorCommunicationIdentifier', 'type': 'CommunicationIdentifierModel'}, + "message": {"key": "message", "type": "str"}, + "topic": {"key": "topic", "type": "str"}, + "participants": {"key": "participants", "type": "[ChatParticipant]"}, + "initiator_communication_identifier": { + "key": "initiatorCommunicationIdentifier", + "type": "CommunicationIdentifierModel", + }, } def __init__( @@ -237,304 +275,375 @@ def __init__( *, message: Optional[str] = None, topic: Optional[str] = None, - participants: Optional[List["ChatParticipant"]] = None, - initiator_communication_identifier: Optional["CommunicationIdentifierModel"] = None, + participants: Optional[List["_models.ChatParticipant"]] = None, + initiator_communication_identifier: Optional["_models.CommunicationIdentifierModel"] = None, **kwargs ): - super(ChatMessageContent, self).__init__(**kwargs) + """ + :keyword message: Chat message content for messages of types text or html. + :paramtype message: str + :keyword topic: Chat message content for messages of type topicUpdated. + :paramtype topic: str + :keyword participants: Chat message content for messages of types participantAdded or + participantRemoved. + :paramtype participants: list[~azure.communication.chat.models.ChatParticipant] + :keyword initiator_communication_identifier: Identifies a participant in Azure Communication + services. A participant is, for example, a phone number or an Azure communication user. This + model must be interpreted as a union: Apart from rawId, at most one further property may be + set. + :paramtype initiator_communication_identifier: + ~azure.communication.chat.models.CommunicationIdentifierModel + """ + super().__init__(**kwargs) self.message = message self.topic = topic self.participants = participants self.initiator_communication_identifier = initiator_communication_identifier -class ChatMessageReadReceipt(msrest.serialization.Model): +class ChatMessageReadReceipt(_serialization.Model): """A chat message read receipt indicates the time a chat message was read by a recipient. All required parameters must be populated in order to send to Azure. - :param sender_communication_identifier: Required. Identifies a participant in Azure - Communication services. A participant is, for example, a phone number or an Azure communication - user. This model must be interpreted as a union: Apart from rawId, at most one further property - may be set. - :type sender_communication_identifier: + :ivar sender_communication_identifier: Identifies a participant in Azure Communication + services. A participant is, for example, a phone number or an Azure communication user. This + model must be interpreted as a union: Apart from rawId, at most one further property may be + set. Required. + :vartype sender_communication_identifier: ~azure.communication.chat.models.CommunicationIdentifierModel - :param chat_message_id: Required. Id of the chat message that has been read. This id is - generated by the server. - :type chat_message_id: str - :param read_on: Required. The time at which the message was read. The timestamp is in RFC3339 - format: ``yyyy-MM-ddTHH:mm:ssZ``. - :type read_on: ~datetime.datetime + :ivar chat_message_id: Id of the chat message that has been read. This id is generated by the + server. Required. + :vartype chat_message_id: str + :ivar read_on: The time at which the message was read. The timestamp is in RFC3339 format: + ``yyyy-MM-ddTHH:mm:ssZ``. Required. + :vartype read_on: ~datetime.datetime """ _validation = { - 'sender_communication_identifier': {'required': True}, - 'chat_message_id': {'required': True}, - 'read_on': {'required': True}, + "sender_communication_identifier": {"required": True}, + "chat_message_id": {"required": True}, + "read_on": {"required": True}, } _attribute_map = { - 'sender_communication_identifier': {'key': 'senderCommunicationIdentifier', 'type': 'CommunicationIdentifierModel'}, - 'chat_message_id': {'key': 'chatMessageId', 'type': 'str'}, - 'read_on': {'key': 'readOn', 'type': 'iso-8601'}, + "sender_communication_identifier": { + "key": "senderCommunicationIdentifier", + "type": "CommunicationIdentifierModel", + }, + "chat_message_id": {"key": "chatMessageId", "type": "str"}, + "read_on": {"key": "readOn", "type": "iso-8601"}, } def __init__( self, *, - sender_communication_identifier: "CommunicationIdentifierModel", + sender_communication_identifier: "_models.CommunicationIdentifierModel", chat_message_id: str, read_on: datetime.datetime, **kwargs ): - super(ChatMessageReadReceipt, self).__init__(**kwargs) + """ + :keyword sender_communication_identifier: Identifies a participant in Azure Communication + services. A participant is, for example, a phone number or an Azure communication user. This + model must be interpreted as a union: Apart from rawId, at most one further property may be + set. Required. + :paramtype sender_communication_identifier: + ~azure.communication.chat.models.CommunicationIdentifierModel + :keyword chat_message_id: Id of the chat message that has been read. This id is generated by + the server. Required. + :paramtype chat_message_id: str + :keyword read_on: The time at which the message was read. The timestamp is in RFC3339 format: + ``yyyy-MM-ddTHH:mm:ssZ``. Required. + :paramtype read_on: ~datetime.datetime + """ + super().__init__(**kwargs) self.sender_communication_identifier = sender_communication_identifier self.chat_message_id = chat_message_id self.read_on = read_on -class ChatMessageReadReceiptsCollection(msrest.serialization.Model): +class ChatMessageReadReceiptsCollection(_serialization.Model): """A paged collection of chat message read receipts. Variables are only populated by the server, and will be ignored when sending a request. All required parameters must be populated in order to send to Azure. - :param value: Required. Collection of chat message read receipts. - :type value: list[~azure.communication.chat.models.ChatMessageReadReceipt] + :ivar value: Collection of chat message read receipts. Required. + :vartype value: list[~azure.communication.chat.models.ChatMessageReadReceipt] :ivar next_link: If there are more chat message read receipts that can be retrieved, the next link will be populated. :vartype next_link: str """ _validation = { - 'value': {'required': True}, - 'next_link': {'readonly': True}, + "value": {"required": True}, + "next_link": {"readonly": True}, } _attribute_map = { - 'value': {'key': 'value', 'type': '[ChatMessageReadReceipt]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "value": {"key": "value", "type": "[ChatMessageReadReceipt]"}, + "next_link": {"key": "nextLink", "type": "str"}, } - def __init__( - self, - *, - value: List["ChatMessageReadReceipt"], - **kwargs - ): - super(ChatMessageReadReceiptsCollection, self).__init__(**kwargs) + def __init__(self, *, value: List["_models.ChatMessageReadReceipt"], **kwargs): + """ + :keyword value: Collection of chat message read receipts. Required. + :paramtype value: list[~azure.communication.chat.models.ChatMessageReadReceipt] + """ + super().__init__(**kwargs) self.value = value self.next_link = None -class ChatMessagesCollection(msrest.serialization.Model): +class ChatMessagesCollection(_serialization.Model): """Collection of chat messages for a particular chat thread. Variables are only populated by the server, and will be ignored when sending a request. All required parameters must be populated in order to send to Azure. - :param value: Required. Collection of chat messages. - :type value: list[~azure.communication.chat.models.ChatMessage] + :ivar value: Collection of chat messages. Required. + :vartype value: list[~azure.communication.chat.models.ChatMessage] :ivar next_link: If there are more chat messages that can be retrieved, the next link will be populated. :vartype next_link: str """ _validation = { - 'value': {'required': True}, - 'next_link': {'readonly': True}, + "value": {"required": True}, + "next_link": {"readonly": True}, } _attribute_map = { - 'value': {'key': 'value', 'type': '[ChatMessage]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "value": {"key": "value", "type": "[ChatMessage]"}, + "next_link": {"key": "nextLink", "type": "str"}, } - def __init__( - self, - *, - value: List["ChatMessage"], - **kwargs - ): - super(ChatMessagesCollection, self).__init__(**kwargs) + def __init__(self, *, value: List["_models.ChatMessage"], **kwargs): + """ + :keyword value: Collection of chat messages. Required. + :paramtype value: list[~azure.communication.chat.models.ChatMessage] + """ + super().__init__(**kwargs) self.value = value self.next_link = None -class ChatParticipant(msrest.serialization.Model): +class ChatParticipant(_serialization.Model): """A participant of the chat thread. All required parameters must be populated in order to send to Azure. - :param communication_identifier: Required. Identifies a participant in Azure Communication - services. A participant is, for example, a phone number or an Azure communication user. This - model must be interpreted as a union: Apart from rawId, at most one further property may be - set. - :type communication_identifier: ~azure.communication.chat.models.CommunicationIdentifierModel - :param display_name: Display name for the chat participant. - :type display_name: str - :param share_history_time: Time from which the chat history is shared with the participant. The + :ivar communication_identifier: Identifies a participant in Azure Communication services. A + participant is, for example, a phone number or an Azure communication user. This model must be + interpreted as a union: Apart from rawId, at most one further property may be set. Required. + :vartype communication_identifier: + ~azure.communication.chat.models.CommunicationIdentifierModel + :ivar display_name: Display name for the chat participant. + :vartype display_name: str + :ivar share_history_time: Time from which the chat history is shared with the participant. The timestamp is in RFC3339 format: ``yyyy-MM-ddTHH:mm:ssZ``. - :type share_history_time: ~datetime.datetime + :vartype share_history_time: ~datetime.datetime """ _validation = { - 'communication_identifier': {'required': True}, + "communication_identifier": {"required": True}, } _attribute_map = { - 'communication_identifier': {'key': 'communicationIdentifier', 'type': 'CommunicationIdentifierModel'}, - 'display_name': {'key': 'displayName', 'type': 'str'}, - 'share_history_time': {'key': 'shareHistoryTime', 'type': 'iso-8601'}, + "communication_identifier": {"key": "communicationIdentifier", "type": "CommunicationIdentifierModel"}, + "display_name": {"key": "displayName", "type": "str"}, + "share_history_time": {"key": "shareHistoryTime", "type": "iso-8601"}, } def __init__( self, *, - communication_identifier: "CommunicationIdentifierModel", + communication_identifier: "_models.CommunicationIdentifierModel", display_name: Optional[str] = None, share_history_time: Optional[datetime.datetime] = None, **kwargs ): - super(ChatParticipant, self).__init__(**kwargs) + """ + :keyword communication_identifier: Identifies a participant in Azure Communication services. A + participant is, for example, a phone number or an Azure communication user. This model must be + interpreted as a union: Apart from rawId, at most one further property may be set. Required. + :paramtype communication_identifier: + ~azure.communication.chat.models.CommunicationIdentifierModel + :keyword display_name: Display name for the chat participant. + :paramtype display_name: str + :keyword share_history_time: Time from which the chat history is shared with the participant. + The timestamp is in RFC3339 format: ``yyyy-MM-ddTHH:mm:ssZ``. + :paramtype share_history_time: ~datetime.datetime + """ + super().__init__(**kwargs) self.communication_identifier = communication_identifier self.display_name = display_name self.share_history_time = share_history_time -class ChatParticipantsCollection(msrest.serialization.Model): +class ChatParticipantsCollection(_serialization.Model): """Collection of participants belong to a particular thread. Variables are only populated by the server, and will be ignored when sending a request. All required parameters must be populated in order to send to Azure. - :param value: Required. Chat participants. - :type value: list[~azure.communication.chat.models.ChatParticipant] + :ivar value: Chat participants. Required. + :vartype value: list[~azure.communication.chat.models.ChatParticipant] :ivar next_link: If there are more chat participants that can be retrieved, the next link will be populated. :vartype next_link: str """ _validation = { - 'value': {'required': True}, - 'next_link': {'readonly': True}, + "value": {"required": True}, + "next_link": {"readonly": True}, } _attribute_map = { - 'value': {'key': 'value', 'type': '[ChatParticipant]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "value": {"key": "value", "type": "[ChatParticipant]"}, + "next_link": {"key": "nextLink", "type": "str"}, } - def __init__( - self, - *, - value: List["ChatParticipant"], - **kwargs - ): - super(ChatParticipantsCollection, self).__init__(**kwargs) + def __init__(self, *, value: List["_models.ChatParticipant"], **kwargs): + """ + :keyword value: Chat participants. Required. + :paramtype value: list[~azure.communication.chat.models.ChatParticipant] + """ + super().__init__(**kwargs) self.value = value self.next_link = None -class ChatThreadItem(msrest.serialization.Model): +class ChatThreadItem(_serialization.Model): """Summary information of a chat thread. Variables are only populated by the server, and will be ignored when sending a request. All required parameters must be populated in order to send to Azure. - :param id: Required. Chat thread id. - :type id: str - :param topic: Required. Chat thread topic. - :type topic: str - :param deleted_on: The timestamp when the chat thread was deleted. The timestamp is in RFC3339 + :ivar id: Chat thread id. Required. + :vartype id: str + :ivar topic: Chat thread topic. Required. + :vartype topic: str + :ivar deleted_on: The timestamp when the chat thread was deleted. The timestamp is in RFC3339 format: ``yyyy-MM-ddTHH:mm:ssZ``. - :type deleted_on: ~datetime.datetime + :vartype deleted_on: ~datetime.datetime :ivar last_message_received_on: The timestamp when the last message arrived at the server. The timestamp is in RFC3339 format: ``yyyy-MM-ddTHH:mm:ssZ``. :vartype last_message_received_on: ~datetime.datetime """ _validation = { - 'id': {'required': True}, - 'topic': {'required': True}, - 'last_message_received_on': {'readonly': True}, + "id": {"required": True}, + "topic": {"required": True}, + "last_message_received_on": {"readonly": True}, } _attribute_map = { - 'id': {'key': 'id', 'type': 'str'}, - 'topic': {'key': 'topic', 'type': 'str'}, - 'deleted_on': {'key': 'deletedOn', 'type': 'iso-8601'}, - 'last_message_received_on': {'key': 'lastMessageReceivedOn', 'type': 'iso-8601'}, + "id": {"key": "id", "type": "str"}, + "topic": {"key": "topic", "type": "str"}, + "deleted_on": {"key": "deletedOn", "type": "iso-8601"}, + "last_message_received_on": {"key": "lastMessageReceivedOn", "type": "iso-8601"}, } def __init__( self, *, - id: str, + id: str, # pylint: disable=redefined-builtin topic: str, deleted_on: Optional[datetime.datetime] = None, **kwargs ): - super(ChatThreadItem, self).__init__(**kwargs) + """ + :keyword id: Chat thread id. Required. + :paramtype id: str + :keyword topic: Chat thread topic. Required. + :paramtype topic: str + :keyword deleted_on: The timestamp when the chat thread was deleted. The timestamp is in + RFC3339 format: ``yyyy-MM-ddTHH:mm:ssZ``. + :paramtype deleted_on: ~datetime.datetime + """ + super().__init__(**kwargs) self.id = id self.topic = topic self.deleted_on = deleted_on self.last_message_received_on = None -class ChatThreadProperties(msrest.serialization.Model): +class ChatThreadProperties(_serialization.Model): """Chat thread. All required parameters must be populated in order to send to Azure. - :param id: Required. Chat thread id. - :type id: str - :param topic: Required. Chat thread topic. - :type topic: str - :param created_on: Required. The timestamp when the chat thread was created. The timestamp is - in RFC3339 format: ``yyyy-MM-ddTHH:mm:ssZ``. - :type created_on: ~datetime.datetime - :param created_by_communication_identifier: Required. Identifies a participant in Azure - Communication services. A participant is, for example, a phone number or an Azure communication - user. This model must be interpreted as a union: Apart from rawId, at most one further property - may be set. - :type created_by_communication_identifier: + :ivar id: Chat thread id. Required. + :vartype id: str + :ivar topic: Chat thread topic. Required. + :vartype topic: str + :ivar created_on: The timestamp when the chat thread was created. The timestamp is in RFC3339 + format: ``yyyy-MM-ddTHH:mm:ssZ``. Required. + :vartype created_on: ~datetime.datetime + :ivar created_by_communication_identifier: Identifies a participant in Azure Communication + services. A participant is, for example, a phone number or an Azure communication user. This + model must be interpreted as a union: Apart from rawId, at most one further property may be + set. Required. + :vartype created_by_communication_identifier: ~azure.communication.chat.models.CommunicationIdentifierModel - :param deleted_on: The timestamp when the chat thread was deleted. The timestamp is in RFC3339 + :ivar deleted_on: The timestamp when the chat thread was deleted. The timestamp is in RFC3339 format: ``yyyy-MM-ddTHH:mm:ssZ``. - :type deleted_on: ~datetime.datetime + :vartype deleted_on: ~datetime.datetime """ _validation = { - 'id': {'required': True}, - 'topic': {'required': True}, - 'created_on': {'required': True}, - 'created_by_communication_identifier': {'required': True}, + "id": {"required": True}, + "topic": {"required": True}, + "created_on": {"required": True}, + "created_by_communication_identifier": {"required": True}, } _attribute_map = { - 'id': {'key': 'id', 'type': 'str'}, - 'topic': {'key': 'topic', 'type': 'str'}, - 'created_on': {'key': 'createdOn', 'type': 'iso-8601'}, - 'created_by_communication_identifier': {'key': 'createdByCommunicationIdentifier', 'type': 'CommunicationIdentifierModel'}, - 'deleted_on': {'key': 'deletedOn', 'type': 'iso-8601'}, + "id": {"key": "id", "type": "str"}, + "topic": {"key": "topic", "type": "str"}, + "created_on": {"key": "createdOn", "type": "iso-8601"}, + "created_by_communication_identifier": { + "key": "createdByCommunicationIdentifier", + "type": "CommunicationIdentifierModel", + }, + "deleted_on": {"key": "deletedOn", "type": "iso-8601"}, } def __init__( self, *, - id: str, + id: str, # pylint: disable=redefined-builtin topic: str, created_on: datetime.datetime, - created_by_communication_identifier: "CommunicationIdentifierModel", + created_by_communication_identifier: "_models.CommunicationIdentifierModel", deleted_on: Optional[datetime.datetime] = None, **kwargs ): - super(ChatThreadProperties, self).__init__(**kwargs) + """ + :keyword id: Chat thread id. Required. + :paramtype id: str + :keyword topic: Chat thread topic. Required. + :paramtype topic: str + :keyword created_on: The timestamp when the chat thread was created. The timestamp is in + RFC3339 format: ``yyyy-MM-ddTHH:mm:ssZ``. Required. + :paramtype created_on: ~datetime.datetime + :keyword created_by_communication_identifier: Identifies a participant in Azure Communication + services. A participant is, for example, a phone number or an Azure communication user. This + model must be interpreted as a union: Apart from rawId, at most one further property may be + set. Required. + :paramtype created_by_communication_identifier: + ~azure.communication.chat.models.CommunicationIdentifierModel + :keyword deleted_on: The timestamp when the chat thread was deleted. The timestamp is in + RFC3339 format: ``yyyy-MM-ddTHH:mm:ssZ``. + :paramtype deleted_on: ~datetime.datetime + """ + super().__init__(**kwargs) self.id = id self.topic = topic self.created_on = created_on @@ -542,218 +651,226 @@ def __init__( self.deleted_on = deleted_on -class ChatThreadsItemCollection(msrest.serialization.Model): +class ChatThreadsItemCollection(_serialization.Model): """Collection of chat threads. Variables are only populated by the server, and will be ignored when sending a request. All required parameters must be populated in order to send to Azure. - :param value: Required. Collection of chat threads. - :type value: list[~azure.communication.chat.models.ChatThreadItem] + :ivar value: Collection of chat threads. Required. + :vartype value: list[~azure.communication.chat.models.ChatThreadItem] :ivar next_link: If there are more chat threads that can be retrieved, the next link will be populated. :vartype next_link: str """ _validation = { - 'value': {'required': True}, - 'next_link': {'readonly': True}, + "value": {"required": True}, + "next_link": {"readonly": True}, } _attribute_map = { - 'value': {'key': 'value', 'type': '[ChatThreadItem]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "value": {"key": "value", "type": "[ChatThreadItem]"}, + "next_link": {"key": "nextLink", "type": "str"}, } - def __init__( - self, - *, - value: List["ChatThreadItem"], - **kwargs - ): - super(ChatThreadsItemCollection, self).__init__(**kwargs) + def __init__(self, *, value: List["_models.ChatThreadItem"], **kwargs): + """ + :keyword value: Collection of chat threads. Required. + :paramtype value: list[~azure.communication.chat.models.ChatThreadItem] + """ + super().__init__(**kwargs) self.value = value self.next_link = None -class CommunicationErrorResponse(msrest.serialization.Model): +class CommunicationErrorResponse(_serialization.Model): """The Communication Services error. All required parameters must be populated in order to send to Azure. - :param error: Required. The Communication Services error. - :type error: ~azure.communication.chat.models.ChatError + :ivar error: The Communication Services error. Required. + :vartype error: ~azure.communication.chat.models.ChatError """ _validation = { - 'error': {'required': True}, + "error": {"required": True}, } _attribute_map = { - 'error': {'key': 'error', 'type': 'ChatError'}, + "error": {"key": "error", "type": "ChatError"}, } - def __init__( - self, - *, - error: "ChatError", - **kwargs - ): - super(CommunicationErrorResponse, self).__init__(**kwargs) + def __init__(self, *, error: "_models.ChatError", **kwargs): + """ + :keyword error: The Communication Services error. Required. + :paramtype error: ~azure.communication.chat.models.ChatError + """ + super().__init__(**kwargs) self.error = error -class CommunicationIdentifierModel(msrest.serialization.Model): +class CommunicationIdentifierModel(_serialization.Model): """Identifies a participant in Azure Communication services. A participant is, for example, a phone number or an Azure communication user. This model must be interpreted as a union: Apart from rawId, at most one further property may be set. - :param raw_id: Raw Id of the identifier. Optional in requests, required in responses. - :type raw_id: str - :param communication_user: The communication user. - :type communication_user: ~azure.communication.chat.models.CommunicationUserIdentifierModel - :param phone_number: The phone number. - :type phone_number: ~azure.communication.chat.models.PhoneNumberIdentifierModel - :param microsoft_teams_user: The Microsoft Teams user. - :type microsoft_teams_user: ~azure.communication.chat.models.MicrosoftTeamsUserIdentifierModel + :ivar raw_id: Raw Id of the identifier. Optional in requests, required in responses. + :vartype raw_id: str + :ivar communication_user: The communication user. + :vartype communication_user: ~azure.communication.chat.models.CommunicationUserIdentifierModel + :ivar phone_number: The phone number. + :vartype phone_number: ~azure.communication.chat.models.PhoneNumberIdentifierModel + :ivar microsoft_teams_user: The Microsoft Teams user. + :vartype microsoft_teams_user: + ~azure.communication.chat.models.MicrosoftTeamsUserIdentifierModel """ _attribute_map = { - 'raw_id': {'key': 'rawId', 'type': 'str'}, - 'communication_user': {'key': 'communicationUser', 'type': 'CommunicationUserIdentifierModel'}, - 'phone_number': {'key': 'phoneNumber', 'type': 'PhoneNumberIdentifierModel'}, - 'microsoft_teams_user': {'key': 'microsoftTeamsUser', 'type': 'MicrosoftTeamsUserIdentifierModel'}, + "raw_id": {"key": "rawId", "type": "str"}, + "communication_user": {"key": "communicationUser", "type": "CommunicationUserIdentifierModel"}, + "phone_number": {"key": "phoneNumber", "type": "PhoneNumberIdentifierModel"}, + "microsoft_teams_user": {"key": "microsoftTeamsUser", "type": "MicrosoftTeamsUserIdentifierModel"}, } def __init__( self, *, raw_id: Optional[str] = None, - communication_user: Optional["CommunicationUserIdentifierModel"] = None, - phone_number: Optional["PhoneNumberIdentifierModel"] = None, - microsoft_teams_user: Optional["MicrosoftTeamsUserIdentifierModel"] = None, + communication_user: Optional["_models.CommunicationUserIdentifierModel"] = None, + phone_number: Optional["_models.PhoneNumberIdentifierModel"] = None, + microsoft_teams_user: Optional["_models.MicrosoftTeamsUserIdentifierModel"] = None, **kwargs ): - super(CommunicationIdentifierModel, self).__init__(**kwargs) + """ + :keyword raw_id: Raw Id of the identifier. Optional in requests, required in responses. + :paramtype raw_id: str + :keyword communication_user: The communication user. + :paramtype communication_user: + ~azure.communication.chat.models.CommunicationUserIdentifierModel + :keyword phone_number: The phone number. + :paramtype phone_number: ~azure.communication.chat.models.PhoneNumberIdentifierModel + :keyword microsoft_teams_user: The Microsoft Teams user. + :paramtype microsoft_teams_user: + ~azure.communication.chat.models.MicrosoftTeamsUserIdentifierModel + """ + super().__init__(**kwargs) self.raw_id = raw_id self.communication_user = communication_user self.phone_number = phone_number self.microsoft_teams_user = microsoft_teams_user -class CommunicationUserIdentifierModel(msrest.serialization.Model): +class CommunicationUserIdentifierModel(_serialization.Model): """A user that got created with an Azure Communication Services resource. All required parameters must be populated in order to send to Azure. - :param id: Required. The Id of the communication user. - :type id: str + :ivar id: The Id of the communication user. Required. + :vartype id: str """ _validation = { - 'id': {'required': True}, + "id": {"required": True}, } _attribute_map = { - 'id': {'key': 'id', 'type': 'str'}, + "id": {"key": "id", "type": "str"}, } - def __init__( - self, - *, - id: str, - **kwargs - ): - super(CommunicationUserIdentifierModel, self).__init__(**kwargs) + def __init__(self, *, id: str, **kwargs): # pylint: disable=redefined-builtin + """ + :keyword id: The Id of the communication user. Required. + :paramtype id: str + """ + super().__init__(**kwargs) self.id = id -class CreateChatThreadRequest(msrest.serialization.Model): +class CreateChatThreadRequest(_serialization.Model): """Request payload for creating a chat thread. All required parameters must be populated in order to send to Azure. - :param topic: Required. The chat thread topic. - :type topic: str - :param participants: Participants to be added to the chat thread. - :type participants: list[~azure.communication.chat.models.ChatParticipant] + :ivar topic: The chat thread topic. Required. + :vartype topic: str + :ivar participants: Participants to be added to the chat thread. + :vartype participants: list[~azure.communication.chat.models.ChatParticipant] """ _validation = { - 'topic': {'required': True}, + "topic": {"required": True}, } _attribute_map = { - 'topic': {'key': 'topic', 'type': 'str'}, - 'participants': {'key': 'participants', 'type': '[ChatParticipant]'}, + "topic": {"key": "topic", "type": "str"}, + "participants": {"key": "participants", "type": "[ChatParticipant]"}, } - def __init__( - self, - *, - topic: str, - participants: Optional[List["ChatParticipant"]] = None, - **kwargs - ): - super(CreateChatThreadRequest, self).__init__(**kwargs) + def __init__(self, *, topic: str, participants: Optional[List["_models.ChatParticipant"]] = None, **kwargs): + """ + :keyword topic: The chat thread topic. Required. + :paramtype topic: str + :keyword participants: Participants to be added to the chat thread. + :paramtype participants: list[~azure.communication.chat.models.ChatParticipant] + """ + super().__init__(**kwargs) self.topic = topic self.participants = participants -class CreateChatThreadResult(msrest.serialization.Model): +class CreateChatThreadResult(_serialization.Model): """Result of the create chat thread operation. Variables are only populated by the server, and will be ignored when sending a request. - :param chat_thread: Chat thread. - :type chat_thread: ~azure.communication.chat.models.ChatThreadProperties + :ivar chat_thread: Chat thread. + :vartype chat_thread: ~azure.communication.chat.models.ChatThreadProperties :ivar invalid_participants: The participants that failed to be added to the chat thread. :vartype invalid_participants: list[~azure.communication.chat.models.ChatError] """ _validation = { - 'invalid_participants': {'readonly': True}, + "invalid_participants": {"readonly": True}, } _attribute_map = { - 'chat_thread': {'key': 'chatThread', 'type': 'ChatThreadProperties'}, - 'invalid_participants': {'key': 'invalidParticipants', 'type': '[ChatError]'}, + "chat_thread": {"key": "chatThread", "type": "ChatThreadProperties"}, + "invalid_participants": {"key": "invalidParticipants", "type": "[ChatError]"}, } - def __init__( - self, - *, - chat_thread: Optional["ChatThreadProperties"] = None, - **kwargs - ): - super(CreateChatThreadResult, self).__init__(**kwargs) + def __init__(self, *, chat_thread: Optional["_models.ChatThreadProperties"] = None, **kwargs): + """ + :keyword chat_thread: Chat thread. + :paramtype chat_thread: ~azure.communication.chat.models.ChatThreadProperties + """ + super().__init__(**kwargs) self.chat_thread = chat_thread self.invalid_participants = None -class MicrosoftTeamsUserIdentifierModel(msrest.serialization.Model): +class MicrosoftTeamsUserIdentifierModel(_serialization.Model): """A Microsoft Teams user. All required parameters must be populated in order to send to Azure. - :param user_id: Required. The Id of the Microsoft Teams user. If not anonymous, this is the AAD - object Id of the user. - :type user_id: str - :param is_anonymous: True if the Microsoft Teams user is anonymous. By default false if - missing. - :type is_anonymous: bool - :param cloud: The cloud that the Microsoft Teams user belongs to. By default 'public' if - missing. Possible values include: "public", "dod", "gcch". - :type cloud: str or ~azure.communication.chat.models.CommunicationCloudEnvironmentModel + :ivar user_id: The Id of the Microsoft Teams user. If not anonymous, this is the AAD object Id + of the user. Required. + :vartype user_id: str + :ivar is_anonymous: True if the Microsoft Teams user is anonymous. By default false if missing. + :vartype is_anonymous: bool + :ivar cloud: The cloud that the Microsoft Teams user belongs to. By default 'public' if + missing. Known values are: "public", "dod", and "gcch". + :vartype cloud: str or ~azure.communication.chat.models.CommunicationCloudEnvironmentModel """ _validation = { - 'user_id': {'required': True}, + "user_id": {"required": True}, } _attribute_map = { - 'user_id': {'key': 'userId', 'type': 'str'}, - 'is_anonymous': {'key': 'isAnonymous', 'type': 'bool'}, - 'cloud': {'key': 'cloud', 'type': 'str'}, + "user_id": {"key": "userId", "type": "str"}, + "is_anonymous": {"key": "isAnonymous", "type": "bool"}, + "cloud": {"key": "cloud", "type": "str"}, } def __init__( @@ -761,68 +878,78 @@ def __init__( *, user_id: str, is_anonymous: Optional[bool] = None, - cloud: Optional[Union[str, "CommunicationCloudEnvironmentModel"]] = None, + cloud: Optional[Union[str, "_models.CommunicationCloudEnvironmentModel"]] = None, **kwargs ): - super(MicrosoftTeamsUserIdentifierModel, self).__init__(**kwargs) + """ + :keyword user_id: The Id of the Microsoft Teams user. If not anonymous, this is the AAD object + Id of the user. Required. + :paramtype user_id: str + :keyword is_anonymous: True if the Microsoft Teams user is anonymous. By default false if + missing. + :paramtype is_anonymous: bool + :keyword cloud: The cloud that the Microsoft Teams user belongs to. By default 'public' if + missing. Known values are: "public", "dod", and "gcch". + :paramtype cloud: str or ~azure.communication.chat.models.CommunicationCloudEnvironmentModel + """ + super().__init__(**kwargs) self.user_id = user_id self.is_anonymous = is_anonymous self.cloud = cloud -class PhoneNumberIdentifierModel(msrest.serialization.Model): +class PhoneNumberIdentifierModel(_serialization.Model): """A phone number. All required parameters must be populated in order to send to Azure. - :param value: Required. The phone number in E.164 format. - :type value: str + :ivar value: The phone number in E.164 format. Required. + :vartype value: str """ _validation = { - 'value': {'required': True}, + "value": {"required": True}, } _attribute_map = { - 'value': {'key': 'value', 'type': 'str'}, + "value": {"key": "value", "type": "str"}, } - def __init__( - self, - *, - value: str, - **kwargs - ): - super(PhoneNumberIdentifierModel, self).__init__(**kwargs) + def __init__(self, *, value: str, **kwargs): + """ + :keyword value: The phone number in E.164 format. Required. + :paramtype value: str + """ + super().__init__(**kwargs) self.value = value -class SendChatMessageRequest(msrest.serialization.Model): +class SendChatMessageRequest(_serialization.Model): """Details of the message to send. All required parameters must be populated in order to send to Azure. - :param content: Required. Chat message content. - :type content: str - :param sender_display_name: The display name of the chat message sender. This property is used + :ivar content: Chat message content. Required. + :vartype content: str + :ivar sender_display_name: The display name of the chat message sender. This property is used to populate sender name for push notifications. - :type sender_display_name: str - :param type: The chat message type. Possible values include: "text", "html", "topicUpdated", - "participantAdded", "participantRemoved". - :type type: str or ~azure.communication.chat.models.ChatMessageType - :param metadata: Message metadata. - :type metadata: dict[str, str] + :vartype sender_display_name: str + :ivar type: The chat message type. Known values are: "text", "html", "topicUpdated", + "participantAdded", and "participantRemoved". + :vartype type: str or ~azure.communication.chat.models.ChatMessageType + :ivar metadata: Message metadata. + :vartype metadata: dict[str, str] """ _validation = { - 'content': {'required': True}, + "content": {"required": True}, } _attribute_map = { - 'content': {'key': 'content', 'type': 'str'}, - 'sender_display_name': {'key': 'senderDisplayName', 'type': 'str'}, - 'type': {'key': 'type', 'type': 'str'}, - 'metadata': {'key': 'metadata', 'type': '{str}'}, + "content": {"key": "content", "type": "str"}, + "sender_display_name": {"key": "senderDisplayName", "type": "str"}, + "type": {"key": "type", "type": "str"}, + "metadata": {"key": "metadata", "type": "{str}"}, } def __init__( @@ -830,135 +957,144 @@ def __init__( *, content: str, sender_display_name: Optional[str] = None, - type: Optional[Union[str, "ChatMessageType"]] = None, + type: Optional[Union[str, "_models.ChatMessageType"]] = None, metadata: Optional[Dict[str, str]] = None, **kwargs ): - super(SendChatMessageRequest, self).__init__(**kwargs) + """ + :keyword content: Chat message content. Required. + :paramtype content: str + :keyword sender_display_name: The display name of the chat message sender. This property is + used to populate sender name for push notifications. + :paramtype sender_display_name: str + :keyword type: The chat message type. Known values are: "text", "html", "topicUpdated", + "participantAdded", and "participantRemoved". + :paramtype type: str or ~azure.communication.chat.models.ChatMessageType + :keyword metadata: Message metadata. + :paramtype metadata: dict[str, str] + """ + super().__init__(**kwargs) self.content = content self.sender_display_name = sender_display_name self.type = type self.metadata = metadata -class SendChatMessageResult(msrest.serialization.Model): +class SendChatMessageResult(_serialization.Model): """Result of the send message operation. All required parameters must be populated in order to send to Azure. - :param id: Required. A server-generated message id. - :type id: str + :ivar id: A server-generated message id. Required. + :vartype id: str """ _validation = { - 'id': {'required': True}, + "id": {"required": True}, } _attribute_map = { - 'id': {'key': 'id', 'type': 'str'}, + "id": {"key": "id", "type": "str"}, } - def __init__( - self, - *, - id: str, - **kwargs - ): - super(SendChatMessageResult, self).__init__(**kwargs) + def __init__(self, *, id: str, **kwargs): # pylint: disable=redefined-builtin + """ + :keyword id: A server-generated message id. Required. + :paramtype id: str + """ + super().__init__(**kwargs) self.id = id -class SendReadReceiptRequest(msrest.serialization.Model): +class SendReadReceiptRequest(_serialization.Model): """Request payload for sending a read receipt. All required parameters must be populated in order to send to Azure. - :param chat_message_id: Required. Id of the latest chat message read by the user. - :type chat_message_id: str + :ivar chat_message_id: Id of the latest chat message read by the user. Required. + :vartype chat_message_id: str """ _validation = { - 'chat_message_id': {'required': True}, + "chat_message_id": {"required": True}, } _attribute_map = { - 'chat_message_id': {'key': 'chatMessageId', 'type': 'str'}, + "chat_message_id": {"key": "chatMessageId", "type": "str"}, } - def __init__( - self, - *, - chat_message_id: str, - **kwargs - ): - super(SendReadReceiptRequest, self).__init__(**kwargs) + def __init__(self, *, chat_message_id: str, **kwargs): + """ + :keyword chat_message_id: Id of the latest chat message read by the user. Required. + :paramtype chat_message_id: str + """ + super().__init__(**kwargs) self.chat_message_id = chat_message_id -class SendTypingNotificationRequest(msrest.serialization.Model): +class SendTypingNotificationRequest(_serialization.Model): """Request payload for typing notifications. - :param sender_display_name: The display name of the typing notification sender. This property - is used to populate sender name for push notifications. - :type sender_display_name: str + :ivar sender_display_name: The display name of the typing notification sender. This property is + used to populate sender name for push notifications. + :vartype sender_display_name: str """ _attribute_map = { - 'sender_display_name': {'key': 'senderDisplayName', 'type': 'str'}, + "sender_display_name": {"key": "senderDisplayName", "type": "str"}, } - def __init__( - self, - *, - sender_display_name: Optional[str] = None, - **kwargs - ): - super(SendTypingNotificationRequest, self).__init__(**kwargs) + def __init__(self, *, sender_display_name: Optional[str] = None, **kwargs): + """ + :keyword sender_display_name: The display name of the typing notification sender. This property + is used to populate sender name for push notifications. + :paramtype sender_display_name: str + """ + super().__init__(**kwargs) self.sender_display_name = sender_display_name -class UpdateChatMessageRequest(msrest.serialization.Model): +class UpdateChatMessageRequest(_serialization.Model): """Request payload for updating a chat message. - :param content: Chat message content. - :type content: str - :param metadata: Message metadata. - :type metadata: dict[str, str] + :ivar content: Chat message content. + :vartype content: str + :ivar metadata: Message metadata. + :vartype metadata: dict[str, str] """ _attribute_map = { - 'content': {'key': 'content', 'type': 'str'}, - 'metadata': {'key': 'metadata', 'type': '{str}'}, + "content": {"key": "content", "type": "str"}, + "metadata": {"key": "metadata", "type": "{str}"}, } - def __init__( - self, - *, - content: Optional[str] = None, - metadata: Optional[Dict[str, str]] = None, - **kwargs - ): - super(UpdateChatMessageRequest, self).__init__(**kwargs) + def __init__(self, *, content: Optional[str] = None, metadata: Optional[Dict[str, str]] = None, **kwargs): + """ + :keyword content: Chat message content. + :paramtype content: str + :keyword metadata: Message metadata. + :paramtype metadata: dict[str, str] + """ + super().__init__(**kwargs) self.content = content self.metadata = metadata -class UpdateChatThreadRequest(msrest.serialization.Model): +class UpdateChatThreadRequest(_serialization.Model): """Request payload for updating a chat thread. - :param topic: Chat thread topic. - :type topic: str + :ivar topic: Chat thread topic. + :vartype topic: str """ _attribute_map = { - 'topic': {'key': 'topic', 'type': 'str'}, + "topic": {"key": "topic", "type": "str"}, } - def __init__( - self, - *, - topic: Optional[str] = None, - **kwargs - ): - super(UpdateChatThreadRequest, self).__init__(**kwargs) + def __init__(self, *, topic: Optional[str] = None, **kwargs): + """ + :keyword topic: Chat thread topic. + :paramtype topic: str + """ + super().__init__(**kwargs) self.topic = topic diff --git a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/models/_patch.py b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/models/_patch.py new file mode 100644 index 000000000000..f7dd32510333 --- /dev/null +++ b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/models/_patch.py @@ -0,0 +1,20 @@ +# ------------------------------------ +# Copyright (c) Microsoft Corporation. +# Licensed under the MIT License. +# ------------------------------------ +"""Customize generated code here. + +Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize +""" +from typing import List + +__all__: List[str] = [] # Add all objects you want publicly available to users at this package level + + +def patch_sdk(): + """Do not remove from this file. + + `patch_sdk` is a last resort escape hatch that allows you to do customizations + you can't accomplish using the techniques described in + https://aka.ms/azsdk/python/dpcodegen/python/customize + """ diff --git a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/operations/__init__.py b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/operations/__init__.py index ca0d822356d7..dbe389acb5e7 100644 --- a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/operations/__init__.py +++ b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/operations/__init__.py @@ -9,7 +9,13 @@ from ._chat_thread_operations import ChatThreadOperations from ._chat_operations import ChatOperations +from ._patch import __all__ as _patch_all +from ._patch import * # type: ignore # pylint: disable=unused-wildcard-import +from ._patch import patch_sdk as _patch_sdk + __all__ = [ - 'ChatThreadOperations', - 'ChatOperations', + "ChatThreadOperations", + "ChatOperations", ] +__all__.extend([p for p in _patch_all if p not in __all__]) +_patch_sdk() diff --git a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/operations/_chat_operations.py b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/operations/_chat_operations.py index 915d1dbfa95a..ae95ff2ca2af 100644 --- a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/operations/_chat_operations.py +++ b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/operations/_chat_operations.py @@ -1,3 +1,4 @@ +# pylint: disable=too-many-lines # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -6,188 +7,371 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- import datetime -from typing import TYPE_CHECKING -import warnings - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from typing import Any, Callable, Dict, IO, Iterable, Optional, TypeVar, Union, overload +from urllib.parse import parse_qs, urljoin, urlparse + +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + map_error, +) from azure.core.paging import ItemPaged from azure.core.pipeline import PipelineResponse -from azure.core.pipeline.transport import HttpRequest, HttpResponse +from azure.core.pipeline.transport import HttpResponse +from azure.core.rest import HttpRequest +from azure.core.tracing.decorator import distributed_trace +from azure.core.utils import case_insensitive_dict from .. import models as _models +from .._serialization import Serializer +from .._vendor import _convert_request, _format_url_section + +T = TypeVar("T") +ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] + +_SERIALIZER = Serializer() +_SERIALIZER.client_side_validation = False + + +def build_create_chat_thread_request(*, repeatability_request_id: Optional[str] = None, **kwargs: Any) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-09-07")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + accept = _headers.pop("Accept", "application/json") + + # Construct URL + _url = kwargs.pop("template_url", "/chat/threads") + + # Construct parameters + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") + + # Construct headers + if repeatability_request_id is not None: + _headers["repeatability-request-id"] = _SERIALIZER.header( + "repeatability_request_id", repeatability_request_id, "str" + ) + if content_type is not None: + _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_list_chat_threads_request( + *, max_page_size: Optional[int] = None, start_time: Optional[datetime.datetime] = None, **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-09-07")) # type: str + accept = _headers.pop("Accept", "application/json") + + # Construct URL + _url = kwargs.pop("template_url", "/chat/threads") + + # Construct parameters + if max_page_size is not None: + _params["maxPageSize"] = _SERIALIZER.query("max_page_size", max_page_size, "int") + if start_time is not None: + _params["startTime"] = _SERIALIZER.query("start_time", start_time, "iso-8601") + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") + + # Construct headers + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_delete_chat_thread_request(chat_thread_id: str, **kwargs: Any) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) -if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports - from typing import Any, Callable, Dict, Generic, Iterable, Optional, TypeVar + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-09-07")) # type: str + accept = _headers.pop("Accept", "application/json") - T = TypeVar('T') - ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] + # Construct URL + _url = kwargs.pop("template_url", "/chat/threads/{chatThreadId}") + path_format_arguments = { + "chatThreadId": _SERIALIZER.url("chat_thread_id", chat_thread_id, "str"), + } -class ChatOperations(object): - """ChatOperations operations. + _url = _format_url_section(_url, **path_format_arguments) - You should not instantiate this class directly. Instead, you should create a Client instance that - instantiates it for you and attaches it as an attribute. + # Construct parameters + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - :ivar models: Alias to model classes used in this operation group. - :type models: ~azure.communication.chat.models - :param client: Client for service requests. - :param config: Configuration of service client. - :param serializer: An object model serializer. - :param deserializer: An object model deserializer. + # Construct headers + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs) + + +class ChatOperations: + """ + .. warning:: + **DO NOT** instantiate this class directly. + + Instead, you should access the following operations through + :class:`~azure.communication.chat.AzureCommunicationChatService`'s + :attr:`chat` attribute. """ models = _models - def __init__(self, client, config, serializer, deserializer): - self._client = client - self._serialize = serializer - self._deserialize = deserializer - self._config = config + def __init__(self, *args, **kwargs): + input_args = list(args) + self._client = input_args.pop(0) if input_args else kwargs.pop("client") + self._config = input_args.pop(0) if input_args else kwargs.pop("config") + self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") + self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") + @overload def create_chat_thread( self, - create_chat_thread_request, # type: "_models.CreateChatThreadRequest" - repeatability_request_id=None, # type: Optional[str] - **kwargs # type: Any - ): - # type: (...) -> "_models.CreateChatThreadResult" + create_chat_thread_request: _models.CreateChatThreadRequest, + repeatability_request_id: Optional[str] = None, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.CreateChatThreadResult: """Creates a chat thread. Creates a chat thread. - :param create_chat_thread_request: Request payload for creating a chat thread. + :param create_chat_thread_request: Request payload for creating a chat thread. Required. :type create_chat_thread_request: ~azure.communication.chat.models.CreateChatThreadRequest :param repeatability_request_id: If specified, the client directs that the request is repeatable; that is, that the client can make the request multiple times with the same Repeatability-Request-Id and get back an appropriate response without the server executing the request multiple times. The value of the Repeatability-Request-Id is an opaque string representing a client-generated, globally unique for all time, identifier for the request. It - is recommended to use version 4 (random) UUIDs. + is recommended to use version 4 (random) UUIDs. Default value is None. :type repeatability_request_id: str + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: CreateChatThreadResult, or the result of cls(response) + :return: CreateChatThreadResult or the result of cls(response) :rtype: ~azure.communication.chat.models.CreateChatThreadResult - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def create_chat_thread( + self, + create_chat_thread_request: IO, + repeatability_request_id: Optional[str] = None, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.CreateChatThreadResult: + """Creates a chat thread. + + Creates a chat thread. + + :param create_chat_thread_request: Request payload for creating a chat thread. Required. + :type create_chat_thread_request: IO + :param repeatability_request_id: If specified, the client directs that the request is + repeatable; that is, that the client can make the request multiple times with the same + Repeatability-Request-Id and get back an appropriate response without the server executing the + request multiple times. The value of the Repeatability-Request-Id is an opaque string + representing a client-generated, globally unique for all time, identifier for the request. It + is recommended to use version 4 (random) UUIDs. Default value is None. + :type repeatability_request_id: str + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: CreateChatThreadResult or the result of cls(response) + :rtype: ~azure.communication.chat.models.CreateChatThreadResult + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace + def create_chat_thread( + self, + create_chat_thread_request: Union[_models.CreateChatThreadRequest, IO], + repeatability_request_id: Optional[str] = None, + **kwargs: Any + ) -> _models.CreateChatThreadResult: + """Creates a chat thread. + + Creates a chat thread. + + :param create_chat_thread_request: Request payload for creating a chat thread. Is either a + model type or a IO type. Required. + :type create_chat_thread_request: ~azure.communication.chat.models.CreateChatThreadRequest or + IO + :param repeatability_request_id: If specified, the client directs that the request is + repeatable; that is, that the client can make the request multiple times with the same + Repeatability-Request-Id and get back an appropriate response without the server executing the + request multiple times. The value of the Repeatability-Request-Id is an opaque string + representing a client-generated, globally unique for all time, identifier for the request. It + is recommended to use version 4 (random) UUIDs. Default value is None. + :type repeatability_request_id: str + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: CreateChatThreadResult or the result of cls(response) + :rtype: ~azure.communication.chat.models.CreateChatThreadResult + :raises ~azure.core.exceptions.HttpResponseError: """ - cls = kwargs.pop('cls', None) # type: ClsType["_models.CreateChatThreadResult"] error_map = { 404: ResourceNotFoundError, 409: ResourceExistsError, - 401: lambda response: ClientAuthenticationError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 403: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 429: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 503: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 304: ResourceNotModifiedError, + 401: lambda response: ClientAuthenticationError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 403: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 429: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 503: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), } - error_map.update(kwargs.pop('error_map', {})) - api_version = "2021-09-07" - content_type = kwargs.pop("content_type", "application/json") - accept = "application/json" - - # Construct URL - url = self.create_chat_thread.metadata['url'] # type: ignore + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.CreateChatThreadResult] + + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(create_chat_thread_request, (IO, bytes)): + _content = create_chat_thread_request + else: + _json = self._serialize.body(create_chat_thread_request, "CreateChatThreadRequest") + + request = build_create_chat_thread_request( + repeatability_request_id=repeatability_request_id, + api_version=api_version, + content_type=content_type, + json=_json, + content=_content, + template_url=self.create_chat_thread.metadata["url"], + headers=_headers, + params=_params, + ) + request = _convert_request(request) path_format_arguments = { - 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), + "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), } - url = self._client.format_url(url, **path_format_arguments) - - # Construct parameters - query_parameters = {} # type: Dict[str, Any] - query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') - - # Construct headers - header_parameters = {} # type: Dict[str, Any] - if repeatability_request_id is not None: - header_parameters['repeatability-request-id'] = self._serialize.header("repeatability_request_id", repeatability_request_id, 'str') - header_parameters['Content-Type'] = self._serialize.header("content_type", content_type, 'str') - header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') - - body_content_kwargs = {} # type: Dict[str, Any] - body_content = self._serialize.body(create_chat_thread_request, 'CreateChatThreadRequest') - body_content_kwargs['content'] = body_content - request = self._client.post(url, query_parameters, header_parameters, **body_content_kwargs) - pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs) + request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore + + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) + response = pipeline_response.http_response if response.status_code not in [201]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response) - deserialized = self._deserialize('CreateChatThreadResult', pipeline_response) + deserialized = self._deserialize("CreateChatThreadResult", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - create_chat_thread.metadata = {'url': '/chat/threads'} # type: ignore + create_chat_thread.metadata = {"url": "/chat/threads"} # type: ignore + + @distributed_trace def list_chat_threads( - self, - max_page_size=None, # type: Optional[int] - start_time=None, # type: Optional[datetime.datetime] - **kwargs # type: Any - ): - # type: (...) -> Iterable["_models.ChatThreadsItemCollection"] + self, max_page_size: Optional[int] = None, start_time: Optional[datetime.datetime] = None, **kwargs: Any + ) -> Iterable["_models.ChatThreadItem"]: """Gets the list of chat threads of a user. Gets the list of chat threads of a user. - :param max_page_size: The maximum number of chat threads returned per page. + :param max_page_size: The maximum number of chat threads returned per page. Default value is + None. :type max_page_size: int :param start_time: The earliest point in time to get chat threads up to. The timestamp should - be in RFC3339 format: ``yyyy-MM-ddTHH:mm:ssZ``. + be in RFC3339 format: ``yyyy-MM-ddTHH:mm:ssZ``. Default value is None. :type start_time: ~datetime.datetime :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either ChatThreadsItemCollection or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.communication.chat.models.ChatThreadsItemCollection] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either ChatThreadItem or the result of cls(response) + :rtype: ~azure.core.paging.ItemPaged[~azure.communication.chat.models.ChatThreadItem] + :raises ~azure.core.exceptions.HttpResponseError: """ - cls = kwargs.pop('cls', None) # type: ClsType["_models.ChatThreadsItemCollection"] + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.ChatThreadsItemCollection] + error_map = { 404: ResourceNotFoundError, 409: ResourceExistsError, - 401: lambda response: ClientAuthenticationError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 403: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 429: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 503: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 304: ResourceNotModifiedError, + 401: lambda response: ClientAuthenticationError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 403: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 429: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 503: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), } - error_map.update(kwargs.pop('error_map', {})) - api_version = "2021-09-07" - accept = "application/json" + error_map.update(kwargs.pop("error_map", {}) or {}) def prepare_request(next_link=None): - # Construct headers - header_parameters = {} # type: Dict[str, Any] - header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') - if not next_link: - # Construct URL - url = self.list_chat_threads.metadata['url'] # type: ignore + + request = build_list_chat_threads_request( + max_page_size=max_page_size, + start_time=start_time, + api_version=api_version, + template_url=self.list_chat_threads.metadata["url"], + headers=_headers, + params=_params, + ) + request = _convert_request(request) path_format_arguments = { - 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), + "endpoint": self._serialize.url( + "self._config.endpoint", self._config.endpoint, "str", skip_quote=True + ), } - url = self._client.format_url(url, **path_format_arguments) - # Construct parameters - query_parameters = {} # type: Dict[str, Any] - if max_page_size is not None: - query_parameters['maxPageSize'] = self._serialize.query("max_page_size", max_page_size, 'int') - if start_time is not None: - query_parameters['startTime'] = self._serialize.query("start_time", start_time, 'iso-8601') - query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') - - request = self._client.get(url, query_parameters, header_parameters) + request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore + else: - url = next_link - query_parameters = {} # type: Dict[str, Any] + # make call to next link with the client's api-version + _parsed_next_link = urlparse(next_link) + _next_request_params = case_insensitive_dict(parse_qs(_parsed_next_link.query)) + _next_request_params["api-version"] = self._config.api_version + request = HttpRequest("GET", urljoin(next_link, _parsed_next_link.path), params=_next_request_params) + request = _convert_request(request) path_format_arguments = { - 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), + "endpoint": self._serialize.url( + "self._config.endpoint", self._config.endpoint, "str", skip_quote=True + ), } - url = self._client.format_url(url, **path_format_arguments) - request = self._client.get(url, query_parameters, header_parameters) + request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore + request.method = "GET" return request def extract_data(pipeline_response): - deserialized = self._deserialize('ChatThreadsItemCollection', pipeline_response) + deserialized = self._deserialize("ChatThreadsItemCollection", pipeline_response) list_of_elem = deserialized.value if cls: list_of_elem = cls(list_of_elem) @@ -196,7 +380,9 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs) + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) response = pipeline_response.http_response if response.status_code not in [200]: @@ -205,59 +391,67 @@ def get_next(next_link=None): return pipeline_response - return ItemPaged( - get_next, extract_data - ) - list_chat_threads.metadata = {'url': '/chat/threads'} # type: ignore + return ItemPaged(get_next, extract_data) - def delete_chat_thread( - self, - chat_thread_id, # type: str - **kwargs # type: Any - ): - # type: (...) -> None + list_chat_threads.metadata = {"url": "/chat/threads"} # type: ignore + + @distributed_trace + def delete_chat_thread( # pylint: disable=inconsistent-return-statements + self, chat_thread_id: str, **kwargs: Any + ) -> None: """Deletes a thread. Deletes a thread. - :param chat_thread_id: Id of the thread to be deleted. + :param chat_thread_id: Id of the thread to be deleted. Required. :type chat_thread_id: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - cls = kwargs.pop('cls', None) # type: ClsType[None] error_map = { 404: ResourceNotFoundError, 409: ResourceExistsError, - 401: lambda response: ClientAuthenticationError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 403: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 429: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 503: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 304: ResourceNotModifiedError, + 401: lambda response: ClientAuthenticationError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 403: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 429: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 503: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), } - error_map.update(kwargs.pop('error_map', {})) - api_version = "2021-09-07" - accept = "application/json" + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - # Construct URL - url = self.delete_chat_thread.metadata['url'] # type: ignore + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] + + request = build_delete_chat_thread_request( + chat_thread_id=chat_thread_id, + api_version=api_version, + template_url=self.delete_chat_thread.metadata["url"], + headers=_headers, + params=_params, + ) + request = _convert_request(request) path_format_arguments = { - 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), - 'chatThreadId': self._serialize.url("chat_thread_id", chat_thread_id, 'str'), + "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), } - url = self._client.format_url(url, **path_format_arguments) + request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore - # Construct parameters - query_parameters = {} # type: Dict[str, Any] - query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') - - # Construct headers - header_parameters = {} # type: Dict[str, Any] - header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) - request = self._client.delete(url, query_parameters, header_parameters) - pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs) response = pipeline_response.http_response if response.status_code not in [204]: @@ -267,4 +461,4 @@ def delete_chat_thread( if cls: return cls(pipeline_response, None, {}) - delete_chat_thread.metadata = {'url': '/chat/threads/{chatThreadId}'} # type: ignore + delete_chat_thread.metadata = {"url": "/chat/threads/{chatThreadId}"} # type: ignore diff --git a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/operations/_chat_thread_operations.py b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/operations/_chat_thread_operations.py index a9e049d59f73..16619fb265d1 100644 --- a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/operations/_chat_thread_operations.py +++ b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/operations/_chat_thread_operations.py @@ -1,3 +1,4 @@ +# pylint: disable=too-many-lines # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -6,116 +7,497 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- import datetime -from typing import TYPE_CHECKING -import warnings - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from typing import Any, Callable, Dict, IO, Iterable, Optional, TypeVar, Union, overload +from urllib.parse import parse_qs, urljoin, urlparse + +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + map_error, +) from azure.core.paging import ItemPaged from azure.core.pipeline import PipelineResponse -from azure.core.pipeline.transport import HttpRequest, HttpResponse +from azure.core.pipeline.transport import HttpResponse +from azure.core.rest import HttpRequest +from azure.core.tracing.decorator import distributed_trace +from azure.core.utils import case_insensitive_dict from .. import models as _models +from .._serialization import Serializer +from .._vendor import _convert_request, _format_url_section + +T = TypeVar("T") +ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] + +_SERIALIZER = Serializer() +_SERIALIZER.client_side_validation = False + + +def build_list_chat_read_receipts_request( + chat_thread_id: str, *, max_page_size: Optional[int] = None, skip: Optional[int] = None, **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-09-07")) # type: str + accept = _headers.pop("Accept", "application/json") + + # Construct URL + _url = kwargs.pop("template_url", "/chat/threads/{chatThreadId}/readReceipts") + path_format_arguments = { + "chatThreadId": _SERIALIZER.url("chat_thread_id", chat_thread_id, "str"), + } + + _url = _format_url_section(_url, **path_format_arguments) + + # Construct parameters + if max_page_size is not None: + _params["maxPageSize"] = _SERIALIZER.query("max_page_size", max_page_size, "int") + if skip is not None: + _params["skip"] = _SERIALIZER.query("skip", skip, "int") + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") + + # Construct headers + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_send_chat_read_receipt_request(chat_thread_id: str, **kwargs: Any) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-09-07")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + accept = _headers.pop("Accept", "application/json") + + # Construct URL + _url = kwargs.pop("template_url", "/chat/threads/{chatThreadId}/readReceipts") + path_format_arguments = { + "chatThreadId": _SERIALIZER.url("chat_thread_id", chat_thread_id, "str"), + } + + _url = _format_url_section(_url, **path_format_arguments) + + # Construct parameters + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") + + # Construct headers + if content_type is not None: + _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_send_chat_message_request(chat_thread_id: str, **kwargs: Any) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-09-07")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + accept = _headers.pop("Accept", "application/json") + + # Construct URL + _url = kwargs.pop("template_url", "/chat/threads/{chatThreadId}/messages") + path_format_arguments = { + "chatThreadId": _SERIALIZER.url("chat_thread_id", chat_thread_id, "str"), + } + + _url = _format_url_section(_url, **path_format_arguments) + + # Construct parameters + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") + + # Construct headers + if content_type is not None: + _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_list_chat_messages_request( + chat_thread_id: str, + *, + max_page_size: Optional[int] = None, + start_time: Optional[datetime.datetime] = None, + **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-09-07")) # type: str + accept = _headers.pop("Accept", "application/json") + + # Construct URL + _url = kwargs.pop("template_url", "/chat/threads/{chatThreadId}/messages") + path_format_arguments = { + "chatThreadId": _SERIALIZER.url("chat_thread_id", chat_thread_id, "str"), + } + + _url = _format_url_section(_url, **path_format_arguments) + + # Construct parameters + if max_page_size is not None: + _params["maxPageSize"] = _SERIALIZER.query("max_page_size", max_page_size, "int") + if start_time is not None: + _params["startTime"] = _SERIALIZER.query("start_time", start_time, "iso-8601") + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") + + # Construct headers + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_get_chat_message_request(chat_thread_id: str, chat_message_id: str, **kwargs: Any) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-09-07")) # type: str + accept = _headers.pop("Accept", "application/json") + + # Construct URL + _url = kwargs.pop("template_url", "/chat/threads/{chatThreadId}/messages/{chatMessageId}") + path_format_arguments = { + "chatThreadId": _SERIALIZER.url("chat_thread_id", chat_thread_id, "str"), + "chatMessageId": _SERIALIZER.url("chat_message_id", chat_message_id, "str"), + } + + _url = _format_url_section(_url, **path_format_arguments) + + # Construct parameters + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") + + # Construct headers + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_update_chat_message_request(chat_thread_id: str, chat_message_id: str, **kwargs: Any) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-09-07")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + accept = _headers.pop("Accept", "application/json") + + # Construct URL + _url = kwargs.pop("template_url", "/chat/threads/{chatThreadId}/messages/{chatMessageId}") + path_format_arguments = { + "chatThreadId": _SERIALIZER.url("chat_thread_id", chat_thread_id, "str"), + "chatMessageId": _SERIALIZER.url("chat_message_id", chat_message_id, "str"), + } + + _url = _format_url_section(_url, **path_format_arguments) + + # Construct parameters + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") + + # Construct headers + if content_type is not None: + _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="PATCH", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_delete_chat_message_request(chat_thread_id: str, chat_message_id: str, **kwargs: Any) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-09-07")) # type: str + accept = _headers.pop("Accept", "application/json") + + # Construct URL + _url = kwargs.pop("template_url", "/chat/threads/{chatThreadId}/messages/{chatMessageId}") + path_format_arguments = { + "chatThreadId": _SERIALIZER.url("chat_thread_id", chat_thread_id, "str"), + "chatMessageId": _SERIALIZER.url("chat_message_id", chat_message_id, "str"), + } + + _url = _format_url_section(_url, **path_format_arguments) + + # Construct parameters + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") + + # Construct headers + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_list_chat_participants_request( + chat_thread_id: str, *, max_page_size: Optional[int] = None, skip: Optional[int] = None, **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-09-07")) # type: str + accept = _headers.pop("Accept", "application/json") + + # Construct URL + _url = kwargs.pop("template_url", "/chat/threads/{chatThreadId}/participants") + path_format_arguments = { + "chatThreadId": _SERIALIZER.url("chat_thread_id", chat_thread_id, "str"), + } + + _url = _format_url_section(_url, **path_format_arguments) + + # Construct parameters + if max_page_size is not None: + _params["maxPageSize"] = _SERIALIZER.query("max_page_size", max_page_size, "int") + if skip is not None: + _params["skip"] = _SERIALIZER.query("skip", skip, "int") + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") + + # Construct headers + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_remove_chat_participant_request(chat_thread_id: str, **kwargs: Any) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-09-07")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + accept = _headers.pop("Accept", "application/json") + + # Construct URL + _url = kwargs.pop("template_url", "/chat/threads/{chatThreadId}/participants/:remove") + path_format_arguments = { + "chatThreadId": _SERIALIZER.url("chat_thread_id", chat_thread_id, "str"), + } + + _url = _format_url_section(_url, **path_format_arguments) + + # Construct parameters + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") + + # Construct headers + if content_type is not None: + _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_add_chat_participants_request(chat_thread_id: str, **kwargs: Any) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-09-07")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + accept = _headers.pop("Accept", "application/json") + + # Construct URL + _url = kwargs.pop("template_url", "/chat/threads/{chatThreadId}/participants/:add") + path_format_arguments = { + "chatThreadId": _SERIALIZER.url("chat_thread_id", chat_thread_id, "str"), + } + + _url = _format_url_section(_url, **path_format_arguments) + + # Construct parameters + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") + + # Construct headers + if content_type is not None: + _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_update_chat_thread_properties_request(chat_thread_id: str, **kwargs: Any) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-09-07")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + accept = _headers.pop("Accept", "application/json") + + # Construct URL + _url = kwargs.pop("template_url", "/chat/threads/{chatThreadId}") + path_format_arguments = { + "chatThreadId": _SERIALIZER.url("chat_thread_id", chat_thread_id, "str"), + } -if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports - from typing import Any, Callable, Dict, Generic, Iterable, Optional, TypeVar + _url = _format_url_section(_url, **path_format_arguments) - T = TypeVar('T') - ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] + # Construct parameters + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") -class ChatThreadOperations(object): - """ChatThreadOperations operations. + # Construct headers + if content_type is not None: + _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - You should not instantiate this class directly. Instead, you should create a Client instance that - instantiates it for you and attaches it as an attribute. + return HttpRequest(method="PATCH", url=_url, params=_params, headers=_headers, **kwargs) - :ivar models: Alias to model classes used in this operation group. - :type models: ~azure.communication.chat.models - :param client: Client for service requests. - :param config: Configuration of service client. - :param serializer: An object model serializer. - :param deserializer: An object model deserializer. + +def build_get_chat_thread_properties_request(chat_thread_id: str, **kwargs: Any) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-09-07")) # type: str + accept = _headers.pop("Accept", "application/json") + + # Construct URL + _url = kwargs.pop("template_url", "/chat/threads/{chatThreadId}") + path_format_arguments = { + "chatThreadId": _SERIALIZER.url("chat_thread_id", chat_thread_id, "str"), + } + + _url = _format_url_section(_url, **path_format_arguments) + + # Construct parameters + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") + + # Construct headers + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_send_typing_notification_request(chat_thread_id: str, **kwargs: Any) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-09-07")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + accept = _headers.pop("Accept", "application/json") + + # Construct URL + _url = kwargs.pop("template_url", "/chat/threads/{chatThreadId}/typing") + path_format_arguments = { + "chatThreadId": _SERIALIZER.url("chat_thread_id", chat_thread_id, "str"), + } + + _url = _format_url_section(_url, **path_format_arguments) + + # Construct parameters + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") + + # Construct headers + if content_type is not None: + _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs) + + +class ChatThreadOperations: + """ + .. warning:: + **DO NOT** instantiate this class directly. + + Instead, you should access the following operations through + :class:`~azure.communication.chat.AzureCommunicationChatService`'s + :attr:`chat_thread` attribute. """ models = _models - def __init__(self, client, config, serializer, deserializer): - self._client = client - self._serialize = serializer - self._deserialize = deserializer - self._config = config + def __init__(self, *args, **kwargs): + input_args = list(args) + self._client = input_args.pop(0) if input_args else kwargs.pop("client") + self._config = input_args.pop(0) if input_args else kwargs.pop("config") + self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") + self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") + @distributed_trace def list_chat_read_receipts( - self, - chat_thread_id, # type: str - max_page_size=None, # type: Optional[int] - skip=None, # type: Optional[int] - **kwargs # type: Any - ): - # type: (...) -> Iterable["_models.ChatMessageReadReceiptsCollection"] + self, chat_thread_id: str, max_page_size: Optional[int] = None, skip: Optional[int] = None, **kwargs: Any + ) -> Iterable["_models.ChatMessageReadReceipt"]: """Gets chat message read receipts for a thread. Gets chat message read receipts for a thread. - :param chat_thread_id: Thread id to get the chat message read receipts for. + :param chat_thread_id: Thread id to get the chat message read receipts for. Required. :type chat_thread_id: str :param max_page_size: The maximum number of chat message read receipts to be returned per page. + Default value is None. :type max_page_size: int - :param skip: Skips chat message read receipts up to a specified position in response. + :param skip: Skips chat message read receipts up to a specified position in response. Default + value is None. :type skip: int :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either ChatMessageReadReceiptsCollection or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.communication.chat.models.ChatMessageReadReceiptsCollection] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either ChatMessageReadReceipt or the result of + cls(response) + :rtype: ~azure.core.paging.ItemPaged[~azure.communication.chat.models.ChatMessageReadReceipt] + :raises ~azure.core.exceptions.HttpResponseError: """ - cls = kwargs.pop('cls', None) # type: ClsType["_models.ChatMessageReadReceiptsCollection"] + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.ChatMessageReadReceiptsCollection] + error_map = { 404: ResourceNotFoundError, 409: ResourceExistsError, - 401: lambda response: ClientAuthenticationError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 403: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 429: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 503: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 304: ResourceNotModifiedError, + 401: lambda response: ClientAuthenticationError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 403: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 429: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 503: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), } - error_map.update(kwargs.pop('error_map', {})) - api_version = "2021-09-07" - accept = "application/json" + error_map.update(kwargs.pop("error_map", {}) or {}) def prepare_request(next_link=None): - # Construct headers - header_parameters = {} # type: Dict[str, Any] - header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') - if not next_link: - # Construct URL - url = self.list_chat_read_receipts.metadata['url'] # type: ignore + + request = build_list_chat_read_receipts_request( + chat_thread_id=chat_thread_id, + max_page_size=max_page_size, + skip=skip, + api_version=api_version, + template_url=self.list_chat_read_receipts.metadata["url"], + headers=_headers, + params=_params, + ) + request = _convert_request(request) path_format_arguments = { - 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), - 'chatThreadId': self._serialize.url("chat_thread_id", chat_thread_id, 'str'), + "endpoint": self._serialize.url( + "self._config.endpoint", self._config.endpoint, "str", skip_quote=True + ), } - url = self._client.format_url(url, **path_format_arguments) - # Construct parameters - query_parameters = {} # type: Dict[str, Any] - if max_page_size is not None: - query_parameters['maxPageSize'] = self._serialize.query("max_page_size", max_page_size, 'int') - if skip is not None: - query_parameters['skip'] = self._serialize.query("skip", skip, 'int') - query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') - - request = self._client.get(url, query_parameters, header_parameters) + request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore + else: - url = next_link - query_parameters = {} # type: Dict[str, Any] + # make call to next link with the client's api-version + _parsed_next_link = urlparse(next_link) + _next_request_params = case_insensitive_dict(parse_qs(_parsed_next_link.query)) + _next_request_params["api-version"] = self._config.api_version + request = HttpRequest("GET", urljoin(next_link, _parsed_next_link.path), params=_next_request_params) + request = _convert_request(request) path_format_arguments = { - 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), - 'chatThreadId': self._serialize.url("chat_thread_id", chat_thread_id, 'str'), + "endpoint": self._serialize.url( + "self._config.endpoint", self._config.endpoint, "str", skip_quote=True + ), } - url = self._client.format_url(url, **path_format_arguments) - request = self._client.get(url, query_parameters, header_parameters) + request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore + request.method = "GET" return request def extract_data(pipeline_response): - deserialized = self._deserialize('ChatMessageReadReceiptsCollection', pipeline_response) + deserialized = self._deserialize("ChatMessageReadReceiptsCollection", pipeline_response) list_of_elem = deserialized.value if cls: list_of_elem = cls(list_of_elem) @@ -124,7 +506,9 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs) + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) response = pipeline_response.http_response if response.status_code not in [200]: @@ -133,67 +517,137 @@ def get_next(next_link=None): return pipeline_response - return ItemPaged( - get_next, extract_data - ) - list_chat_read_receipts.metadata = {'url': '/chat/threads/{chatThreadId}/readReceipts'} # type: ignore + return ItemPaged(get_next, extract_data) + + list_chat_read_receipts.metadata = {"url": "/chat/threads/{chatThreadId}/readReceipts"} # type: ignore - def send_chat_read_receipt( + @overload + def send_chat_read_receipt( # pylint: disable=inconsistent-return-statements self, - chat_thread_id, # type: str - send_read_receipt_request, # type: "_models.SendReadReceiptRequest" - **kwargs # type: Any - ): - # type: (...) -> None + chat_thread_id: str, + send_read_receipt_request: _models.SendReadReceiptRequest, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> None: """Sends a read receipt event to a thread, on behalf of a user. Sends a read receipt event to a thread, on behalf of a user. - :param chat_thread_id: Thread id to send the read receipt event to. + :param chat_thread_id: Thread id to send the read receipt event to. Required. :type chat_thread_id: str - :param send_read_receipt_request: Read receipt details. + :param send_read_receipt_request: Read receipt details. Required. :type send_read_receipt_request: ~azure.communication.chat.models.SendReadReceiptRequest + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: None or the result of cls(response) + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def send_chat_read_receipt( # pylint: disable=inconsistent-return-statements + self, + chat_thread_id: str, + send_read_receipt_request: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> None: + """Sends a read receipt event to a thread, on behalf of a user. + + Sends a read receipt event to a thread, on behalf of a user. + + :param chat_thread_id: Thread id to send the read receipt event to. Required. + :type chat_thread_id: str + :param send_read_receipt_request: Read receipt details. Required. + :type send_read_receipt_request: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: None or the result of cls(response) + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace + def send_chat_read_receipt( # pylint: disable=inconsistent-return-statements + self, chat_thread_id: str, send_read_receipt_request: Union[_models.SendReadReceiptRequest, IO], **kwargs: Any + ) -> None: + """Sends a read receipt event to a thread, on behalf of a user. + + Sends a read receipt event to a thread, on behalf of a user. + + :param chat_thread_id: Thread id to send the read receipt event to. Required. + :type chat_thread_id: str + :param send_read_receipt_request: Read receipt details. Is either a model type or a IO type. + Required. + :type send_read_receipt_request: ~azure.communication.chat.models.SendReadReceiptRequest or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - cls = kwargs.pop('cls', None) # type: ClsType[None] error_map = { 404: ResourceNotFoundError, 409: ResourceExistsError, - 401: lambda response: ClientAuthenticationError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 403: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 429: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 503: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 304: ResourceNotModifiedError, + 401: lambda response: ClientAuthenticationError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 403: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 429: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 503: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), } - error_map.update(kwargs.pop('error_map', {})) - api_version = "2021-09-07" - content_type = kwargs.pop("content_type", "application/json") - accept = "application/json" + error_map.update(kwargs.pop("error_map", {}) or {}) - # Construct URL - url = self.send_chat_read_receipt.metadata['url'] # type: ignore + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[None] + + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(send_read_receipt_request, (IO, bytes)): + _content = send_read_receipt_request + else: + _json = self._serialize.body(send_read_receipt_request, "SendReadReceiptRequest") + + request = build_send_chat_read_receipt_request( + chat_thread_id=chat_thread_id, + api_version=api_version, + content_type=content_type, + json=_json, + content=_content, + template_url=self.send_chat_read_receipt.metadata["url"], + headers=_headers, + params=_params, + ) + request = _convert_request(request) path_format_arguments = { - 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), - 'chatThreadId': self._serialize.url("chat_thread_id", chat_thread_id, 'str'), + "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), } - url = self._client.format_url(url, **path_format_arguments) - - # Construct parameters - query_parameters = {} # type: Dict[str, Any] - query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') - - # Construct headers - header_parameters = {} # type: Dict[str, Any] - header_parameters['Content-Type'] = self._serialize.header("content_type", content_type, 'str') - header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') - - body_content_kwargs = {} # type: Dict[str, Any] - body_content = self._serialize.body(send_read_receipt_request, 'SendReadReceiptRequest') - body_content_kwargs['content'] = body_content - request = self._client.post(url, query_parameters, header_parameters, **body_content_kwargs) - pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs) + request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore + + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) + response = pipeline_response.http_response if response.status_code not in [200]: @@ -203,150 +657,238 @@ def send_chat_read_receipt( if cls: return cls(pipeline_response, None, {}) - send_chat_read_receipt.metadata = {'url': '/chat/threads/{chatThreadId}/readReceipts'} # type: ignore + send_chat_read_receipt.metadata = {"url": "/chat/threads/{chatThreadId}/readReceipts"} # type: ignore + @overload def send_chat_message( self, - chat_thread_id, # type: str - send_chat_message_request, # type: "_models.SendChatMessageRequest" - **kwargs # type: Any - ): - # type: (...) -> "_models.SendChatMessageResult" + chat_thread_id: str, + send_chat_message_request: _models.SendChatMessageRequest, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.SendChatMessageResult: """Sends a message to a thread. Sends a message to a thread. - :param chat_thread_id: The thread id to send the message to. + :param chat_thread_id: The thread id to send the message to. Required. :type chat_thread_id: str - :param send_chat_message_request: Details of the message to send. + :param send_chat_message_request: Details of the message to send. Required. :type send_chat_message_request: ~azure.communication.chat.models.SendChatMessageRequest + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: SendChatMessageResult or the result of cls(response) + :rtype: ~azure.communication.chat.models.SendChatMessageResult + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def send_chat_message( + self, + chat_thread_id: str, + send_chat_message_request: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.SendChatMessageResult: + """Sends a message to a thread. + + Sends a message to a thread. + + :param chat_thread_id: The thread id to send the message to. Required. + :type chat_thread_id: str + :param send_chat_message_request: Details of the message to send. Required. + :type send_chat_message_request: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: SendChatMessageResult, or the result of cls(response) + :return: SendChatMessageResult or the result of cls(response) :rtype: ~azure.communication.chat.models.SendChatMessageResult - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace + def send_chat_message( + self, chat_thread_id: str, send_chat_message_request: Union[_models.SendChatMessageRequest, IO], **kwargs: Any + ) -> _models.SendChatMessageResult: + """Sends a message to a thread. + + Sends a message to a thread. + + :param chat_thread_id: The thread id to send the message to. Required. + :type chat_thread_id: str + :param send_chat_message_request: Details of the message to send. Is either a model type or a + IO type. Required. + :type send_chat_message_request: ~azure.communication.chat.models.SendChatMessageRequest or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: SendChatMessageResult or the result of cls(response) + :rtype: ~azure.communication.chat.models.SendChatMessageResult + :raises ~azure.core.exceptions.HttpResponseError: """ - cls = kwargs.pop('cls', None) # type: ClsType["_models.SendChatMessageResult"] error_map = { 404: ResourceNotFoundError, 409: ResourceExistsError, - 401: lambda response: ClientAuthenticationError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 403: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 429: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 503: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 304: ResourceNotModifiedError, + 401: lambda response: ClientAuthenticationError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 403: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 429: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 503: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), } - error_map.update(kwargs.pop('error_map', {})) - api_version = "2021-09-07" - content_type = kwargs.pop("content_type", "application/json") - accept = "application/json" + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.SendChatMessageResult] - # Construct URL - url = self.send_chat_message.metadata['url'] # type: ignore + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(send_chat_message_request, (IO, bytes)): + _content = send_chat_message_request + else: + _json = self._serialize.body(send_chat_message_request, "SendChatMessageRequest") + + request = build_send_chat_message_request( + chat_thread_id=chat_thread_id, + api_version=api_version, + content_type=content_type, + json=_json, + content=_content, + template_url=self.send_chat_message.metadata["url"], + headers=_headers, + params=_params, + ) + request = _convert_request(request) path_format_arguments = { - 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), - 'chatThreadId': self._serialize.url("chat_thread_id", chat_thread_id, 'str'), + "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), } - url = self._client.format_url(url, **path_format_arguments) - - # Construct parameters - query_parameters = {} # type: Dict[str, Any] - query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') - - # Construct headers - header_parameters = {} # type: Dict[str, Any] - header_parameters['Content-Type'] = self._serialize.header("content_type", content_type, 'str') - header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') - - body_content_kwargs = {} # type: Dict[str, Any] - body_content = self._serialize.body(send_chat_message_request, 'SendChatMessageRequest') - body_content_kwargs['content'] = body_content - request = self._client.post(url, query_parameters, header_parameters, **body_content_kwargs) - pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs) + request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore + + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) + response = pipeline_response.http_response if response.status_code not in [201]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response) - deserialized = self._deserialize('SendChatMessageResult', pipeline_response) + deserialized = self._deserialize("SendChatMessageResult", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - send_chat_message.metadata = {'url': '/chat/threads/{chatThreadId}/messages'} # type: ignore + send_chat_message.metadata = {"url": "/chat/threads/{chatThreadId}/messages"} # type: ignore + + @distributed_trace def list_chat_messages( self, - chat_thread_id, # type: str - max_page_size=None, # type: Optional[int] - start_time=None, # type: Optional[datetime.datetime] - **kwargs # type: Any - ): - # type: (...) -> Iterable["_models.ChatMessagesCollection"] + chat_thread_id: str, + max_page_size: Optional[int] = None, + start_time: Optional[datetime.datetime] = None, + **kwargs: Any + ) -> Iterable["_models.ChatMessage"]: """Gets a list of messages from a thread. Gets a list of messages from a thread. - :param chat_thread_id: The thread id of the message. + :param chat_thread_id: The thread id of the message. Required. :type chat_thread_id: str - :param max_page_size: The maximum number of messages to be returned per page. + :param max_page_size: The maximum number of messages to be returned per page. Default value is + None. :type max_page_size: int :param start_time: The earliest point in time to get messages up to. The timestamp should be in - RFC3339 format: ``yyyy-MM-ddTHH:mm:ssZ``. + RFC3339 format: ``yyyy-MM-ddTHH:mm:ssZ``. Default value is None. :type start_time: ~datetime.datetime :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either ChatMessagesCollection or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.communication.chat.models.ChatMessagesCollection] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either ChatMessage or the result of cls(response) + :rtype: ~azure.core.paging.ItemPaged[~azure.communication.chat.models.ChatMessage] + :raises ~azure.core.exceptions.HttpResponseError: """ - cls = kwargs.pop('cls', None) # type: ClsType["_models.ChatMessagesCollection"] + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.ChatMessagesCollection] + error_map = { 404: ResourceNotFoundError, 409: ResourceExistsError, - 401: lambda response: ClientAuthenticationError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 403: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 429: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 503: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 304: ResourceNotModifiedError, + 401: lambda response: ClientAuthenticationError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 403: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 429: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 503: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), } - error_map.update(kwargs.pop('error_map', {})) - api_version = "2021-09-07" - accept = "application/json" + error_map.update(kwargs.pop("error_map", {}) or {}) def prepare_request(next_link=None): - # Construct headers - header_parameters = {} # type: Dict[str, Any] - header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') - if not next_link: - # Construct URL - url = self.list_chat_messages.metadata['url'] # type: ignore + + request = build_list_chat_messages_request( + chat_thread_id=chat_thread_id, + max_page_size=max_page_size, + start_time=start_time, + api_version=api_version, + template_url=self.list_chat_messages.metadata["url"], + headers=_headers, + params=_params, + ) + request = _convert_request(request) path_format_arguments = { - 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), - 'chatThreadId': self._serialize.url("chat_thread_id", chat_thread_id, 'str'), + "endpoint": self._serialize.url( + "self._config.endpoint", self._config.endpoint, "str", skip_quote=True + ), } - url = self._client.format_url(url, **path_format_arguments) - # Construct parameters - query_parameters = {} # type: Dict[str, Any] - if max_page_size is not None: - query_parameters['maxPageSize'] = self._serialize.query("max_page_size", max_page_size, 'int') - if start_time is not None: - query_parameters['startTime'] = self._serialize.query("start_time", start_time, 'iso-8601') - query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') - - request = self._client.get(url, query_parameters, header_parameters) + request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore + else: - url = next_link - query_parameters = {} # type: Dict[str, Any] + # make call to next link with the client's api-version + _parsed_next_link = urlparse(next_link) + _next_request_params = case_insensitive_dict(parse_qs(_parsed_next_link.query)) + _next_request_params["api-version"] = self._config.api_version + request = HttpRequest("GET", urljoin(next_link, _parsed_next_link.path), params=_next_request_params) + request = _convert_request(request) path_format_arguments = { - 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), - 'chatThreadId': self._serialize.url("chat_thread_id", chat_thread_id, 'str'), + "endpoint": self._serialize.url( + "self._config.endpoint", self._config.endpoint, "str", skip_quote=True + ), } - url = self._client.format_url(url, **path_format_arguments) - request = self._client.get(url, query_parameters, header_parameters) + request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore + request.method = "GET" return request def extract_data(pipeline_response): - deserialized = self._deserialize('ChatMessagesCollection', pipeline_response) + deserialized = self._deserialize("ChatMessagesCollection", pipeline_response) list_of_elem = deserialized.value if cls: list_of_elem = cls(list_of_elem) @@ -355,7 +897,9 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs) + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) response = pipeline_response.http_response if response.status_code not in [200]: @@ -364,137 +908,224 @@ def get_next(next_link=None): return pipeline_response - return ItemPaged( - get_next, extract_data - ) - list_chat_messages.metadata = {'url': '/chat/threads/{chatThreadId}/messages'} # type: ignore + return ItemPaged(get_next, extract_data) - def get_chat_message( - self, - chat_thread_id, # type: str - chat_message_id, # type: str - **kwargs # type: Any - ): - # type: (...) -> "_models.ChatMessage" + list_chat_messages.metadata = {"url": "/chat/threads/{chatThreadId}/messages"} # type: ignore + + @distributed_trace + def get_chat_message(self, chat_thread_id: str, chat_message_id: str, **kwargs: Any) -> _models.ChatMessage: """Gets a message by id. Gets a message by id. - :param chat_thread_id: The thread id to which the message was sent. + :param chat_thread_id: The thread id to which the message was sent. Required. :type chat_thread_id: str - :param chat_message_id: The message id. + :param chat_message_id: The message id. Required. :type chat_message_id: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: ChatMessage, or the result of cls(response) + :return: ChatMessage or the result of cls(response) :rtype: ~azure.communication.chat.models.ChatMessage - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - cls = kwargs.pop('cls', None) # type: ClsType["_models.ChatMessage"] error_map = { 404: ResourceNotFoundError, 409: ResourceExistsError, - 401: lambda response: ClientAuthenticationError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 403: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 429: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 503: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 304: ResourceNotModifiedError, + 401: lambda response: ClientAuthenticationError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 403: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 429: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 503: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), } - error_map.update(kwargs.pop('error_map', {})) - api_version = "2021-09-07" - accept = "application/json" + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.ChatMessage] - # Construct URL - url = self.get_chat_message.metadata['url'] # type: ignore + request = build_get_chat_message_request( + chat_thread_id=chat_thread_id, + chat_message_id=chat_message_id, + api_version=api_version, + template_url=self.get_chat_message.metadata["url"], + headers=_headers, + params=_params, + ) + request = _convert_request(request) path_format_arguments = { - 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), - 'chatThreadId': self._serialize.url("chat_thread_id", chat_thread_id, 'str'), - 'chatMessageId': self._serialize.url("chat_message_id", chat_message_id, 'str'), + "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), } - url = self._client.format_url(url, **path_format_arguments) - - # Construct parameters - query_parameters = {} # type: Dict[str, Any] - query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') + request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore - # Construct headers - header_parameters = {} # type: Dict[str, Any] - header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) - request = self._client.get(url, query_parameters, header_parameters) - pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs) response = pipeline_response.http_response if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response) - deserialized = self._deserialize('ChatMessage', pipeline_response) + deserialized = self._deserialize("ChatMessage", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get_chat_message.metadata = {'url': '/chat/threads/{chatThreadId}/messages/{chatMessageId}'} # type: ignore - def update_chat_message( + get_chat_message.metadata = {"url": "/chat/threads/{chatThreadId}/messages/{chatMessageId}"} # type: ignore + + @overload + def update_chat_message( # pylint: disable=inconsistent-return-statements self, - chat_thread_id, # type: str - chat_message_id, # type: str - update_chat_message_request, # type: "_models.UpdateChatMessageRequest" - **kwargs # type: Any - ): - # type: (...) -> None + chat_thread_id: str, + chat_message_id: str, + update_chat_message_request: _models.UpdateChatMessageRequest, + *, + content_type: str = "application/merge-patch+json", + **kwargs: Any + ) -> None: """Updates a message. Updates a message. - :param chat_thread_id: The thread id to which the message was sent. + :param chat_thread_id: The thread id to which the message was sent. Required. :type chat_thread_id: str - :param chat_message_id: The message id. + :param chat_message_id: The message id. Required. :type chat_message_id: str - :param update_chat_message_request: Details of the request to update the message. + :param update_chat_message_request: Details of the request to update the message. Required. :type update_chat_message_request: ~azure.communication.chat.models.UpdateChatMessageRequest + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/merge-patch+json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: None or the result of cls(response) + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def update_chat_message( # pylint: disable=inconsistent-return-statements + self, + chat_thread_id: str, + chat_message_id: str, + update_chat_message_request: IO, + *, + content_type: str = "application/merge-patch+json", + **kwargs: Any + ) -> None: + """Updates a message. + + Updates a message. + + :param chat_thread_id: The thread id to which the message was sent. Required. + :type chat_thread_id: str + :param chat_message_id: The message id. Required. + :type chat_message_id: str + :param update_chat_message_request: Details of the request to update the message. Required. + :type update_chat_message_request: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/merge-patch+json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: None or the result of cls(response) + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace + def update_chat_message( # pylint: disable=inconsistent-return-statements + self, + chat_thread_id: str, + chat_message_id: str, + update_chat_message_request: Union[_models.UpdateChatMessageRequest, IO], + **kwargs: Any + ) -> None: + """Updates a message. + + Updates a message. + + :param chat_thread_id: The thread id to which the message was sent. Required. + :type chat_thread_id: str + :param chat_message_id: The message id. Required. + :type chat_message_id: str + :param update_chat_message_request: Details of the request to update the message. Is either a + model type or a IO type. Required. + :type update_chat_message_request: ~azure.communication.chat.models.UpdateChatMessageRequest or + IO + :keyword content_type: Body Parameter content-type. Known values are: + 'application/merge-patch+json'. Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - cls = kwargs.pop('cls', None) # type: ClsType[None] error_map = { 404: ResourceNotFoundError, 409: ResourceExistsError, - 401: lambda response: ClientAuthenticationError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 403: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 429: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 503: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 304: ResourceNotModifiedError, + 401: lambda response: ClientAuthenticationError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 403: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 429: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 503: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), } - error_map.update(kwargs.pop('error_map', {})) - api_version = "2021-09-07" - content_type = kwargs.pop("content_type", "application/merge-patch+json") - accept = "application/json" + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - # Construct URL - url = self.update_chat_message.metadata['url'] # type: ignore + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[None] + + content_type = content_type or "application/merge-patch+json" + _json = None + _content = None + if isinstance(update_chat_message_request, (IO, bytes)): + _content = update_chat_message_request + else: + _json = self._serialize.body(update_chat_message_request, "UpdateChatMessageRequest") + + request = build_update_chat_message_request( + chat_thread_id=chat_thread_id, + chat_message_id=chat_message_id, + api_version=api_version, + content_type=content_type, + json=_json, + content=_content, + template_url=self.update_chat_message.metadata["url"], + headers=_headers, + params=_params, + ) + request = _convert_request(request) path_format_arguments = { - 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), - 'chatThreadId': self._serialize.url("chat_thread_id", chat_thread_id, 'str'), - 'chatMessageId': self._serialize.url("chat_message_id", chat_message_id, 'str'), + "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), } - url = self._client.format_url(url, **path_format_arguments) - - # Construct parameters - query_parameters = {} # type: Dict[str, Any] - query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') - - # Construct headers - header_parameters = {} # type: Dict[str, Any] - header_parameters['Content-Type'] = self._serialize.header("content_type", content_type, 'str') - header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') - - body_content_kwargs = {} # type: Dict[str, Any] - body_content = self._serialize.body(update_chat_message_request, 'UpdateChatMessageRequest') - body_content_kwargs['content'] = body_content - request = self._client.patch(url, query_parameters, header_parameters, **body_content_kwargs) - pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs) + request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore + + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) + response = pipeline_response.http_response if response.status_code not in [204]: @@ -504,60 +1135,68 @@ def update_chat_message( if cls: return cls(pipeline_response, None, {}) - update_chat_message.metadata = {'url': '/chat/threads/{chatThreadId}/messages/{chatMessageId}'} # type: ignore + update_chat_message.metadata = {"url": "/chat/threads/{chatThreadId}/messages/{chatMessageId}"} # type: ignore - def delete_chat_message( - self, - chat_thread_id, # type: str - chat_message_id, # type: str - **kwargs # type: Any - ): - # type: (...) -> None + @distributed_trace + def delete_chat_message( # pylint: disable=inconsistent-return-statements + self, chat_thread_id: str, chat_message_id: str, **kwargs: Any + ) -> None: """Deletes a message. Deletes a message. - :param chat_thread_id: The thread id to which the message was sent. + :param chat_thread_id: The thread id to which the message was sent. Required. :type chat_thread_id: str - :param chat_message_id: The message id. + :param chat_message_id: The message id. Required. :type chat_message_id: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - cls = kwargs.pop('cls', None) # type: ClsType[None] error_map = { 404: ResourceNotFoundError, 409: ResourceExistsError, - 401: lambda response: ClientAuthenticationError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 403: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 429: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 503: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 304: ResourceNotModifiedError, + 401: lambda response: ClientAuthenticationError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 403: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 429: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 503: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), } - error_map.update(kwargs.pop('error_map', {})) - api_version = "2021-09-07" - accept = "application/json" + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - # Construct URL - url = self.delete_chat_message.metadata['url'] # type: ignore + request = build_delete_chat_message_request( + chat_thread_id=chat_thread_id, + chat_message_id=chat_message_id, + api_version=api_version, + template_url=self.delete_chat_message.metadata["url"], + headers=_headers, + params=_params, + ) + request = _convert_request(request) path_format_arguments = { - 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), - 'chatThreadId': self._serialize.url("chat_thread_id", chat_thread_id, 'str'), - 'chatMessageId': self._serialize.url("chat_message_id", chat_message_id, 'str'), + "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), } - url = self._client.format_url(url, **path_format_arguments) - - # Construct parameters - query_parameters = {} # type: Dict[str, Any] - query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') + request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore - # Construct headers - header_parameters = {} # type: Dict[str, Any] - header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) - request = self._client.delete(url, query_parameters, header_parameters) - pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs) response = pipeline_response.http_response if response.status_code not in [204]: @@ -567,79 +1206,91 @@ def delete_chat_message( if cls: return cls(pipeline_response, None, {}) - delete_chat_message.metadata = {'url': '/chat/threads/{chatThreadId}/messages/{chatMessageId}'} # type: ignore + delete_chat_message.metadata = {"url": "/chat/threads/{chatThreadId}/messages/{chatMessageId}"} # type: ignore + @distributed_trace def list_chat_participants( - self, - chat_thread_id, # type: str - max_page_size=None, # type: Optional[int] - skip=None, # type: Optional[int] - **kwargs # type: Any - ): - # type: (...) -> Iterable["_models.ChatParticipantsCollection"] + self, chat_thread_id: str, max_page_size: Optional[int] = None, skip: Optional[int] = None, **kwargs: Any + ) -> Iterable["_models.ChatParticipant"]: """Gets the participants of a thread. Gets the participants of a thread. - :param chat_thread_id: Thread id to get participants for. + :param chat_thread_id: Thread id to get participants for. Required. :type chat_thread_id: str - :param max_page_size: The maximum number of participants to be returned per page. + :param max_page_size: The maximum number of participants to be returned per page. Default value + is None. :type max_page_size: int - :param skip: Skips participants up to a specified position in response. + :param skip: Skips participants up to a specified position in response. Default value is None. :type skip: int :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either ChatParticipantsCollection or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.communication.chat.models.ChatParticipantsCollection] - :raises: ~azure.core.exceptions.HttpResponseError + :return: An iterator like instance of either ChatParticipant or the result of cls(response) + :rtype: ~azure.core.paging.ItemPaged[~azure.communication.chat.models.ChatParticipant] + :raises ~azure.core.exceptions.HttpResponseError: """ - cls = kwargs.pop('cls', None) # type: ClsType["_models.ChatParticipantsCollection"] + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.ChatParticipantsCollection] + error_map = { 404: ResourceNotFoundError, 409: ResourceExistsError, - 401: lambda response: ClientAuthenticationError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 403: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 429: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 503: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 304: ResourceNotModifiedError, + 401: lambda response: ClientAuthenticationError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 403: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 429: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 503: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), } - error_map.update(kwargs.pop('error_map', {})) - api_version = "2021-09-07" - accept = "application/json" + error_map.update(kwargs.pop("error_map", {}) or {}) def prepare_request(next_link=None): - # Construct headers - header_parameters = {} # type: Dict[str, Any] - header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') - if not next_link: - # Construct URL - url = self.list_chat_participants.metadata['url'] # type: ignore + + request = build_list_chat_participants_request( + chat_thread_id=chat_thread_id, + max_page_size=max_page_size, + skip=skip, + api_version=api_version, + template_url=self.list_chat_participants.metadata["url"], + headers=_headers, + params=_params, + ) + request = _convert_request(request) path_format_arguments = { - 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), - 'chatThreadId': self._serialize.url("chat_thread_id", chat_thread_id, 'str'), + "endpoint": self._serialize.url( + "self._config.endpoint", self._config.endpoint, "str", skip_quote=True + ), } - url = self._client.format_url(url, **path_format_arguments) - # Construct parameters - query_parameters = {} # type: Dict[str, Any] - if max_page_size is not None: - query_parameters['maxPageSize'] = self._serialize.query("max_page_size", max_page_size, 'int') - if skip is not None: - query_parameters['skip'] = self._serialize.query("skip", skip, 'int') - query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') - - request = self._client.get(url, query_parameters, header_parameters) + request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore + else: - url = next_link - query_parameters = {} # type: Dict[str, Any] + # make call to next link with the client's api-version + _parsed_next_link = urlparse(next_link) + _next_request_params = case_insensitive_dict(parse_qs(_parsed_next_link.query)) + _next_request_params["api-version"] = self._config.api_version + request = HttpRequest("GET", urljoin(next_link, _parsed_next_link.path), params=_next_request_params) + request = _convert_request(request) path_format_arguments = { - 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), - 'chatThreadId': self._serialize.url("chat_thread_id", chat_thread_id, 'str'), + "endpoint": self._serialize.url( + "self._config.endpoint", self._config.endpoint, "str", skip_quote=True + ), } - url = self._client.format_url(url, **path_format_arguments) - request = self._client.get(url, query_parameters, header_parameters) + request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore + request.method = "GET" return request def extract_data(pipeline_response): - deserialized = self._deserialize('ChatParticipantsCollection', pipeline_response) + deserialized = self._deserialize("ChatParticipantsCollection", pipeline_response) list_of_elem = deserialized.value if cls: list_of_elem = cls(list_of_elem) @@ -648,7 +1299,9 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs) + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) response = pipeline_response.http_response if response.status_code not in [200]: @@ -657,68 +1310,145 @@ def get_next(next_link=None): return pipeline_response - return ItemPaged( - get_next, extract_data - ) - list_chat_participants.metadata = {'url': '/chat/threads/{chatThreadId}/participants'} # type: ignore + return ItemPaged(get_next, extract_data) + + list_chat_participants.metadata = {"url": "/chat/threads/{chatThreadId}/participants"} # type: ignore + + @overload + def remove_chat_participant( # pylint: disable=inconsistent-return-statements + self, + chat_thread_id: str, + participant_communication_identifier: _models.CommunicationIdentifierModel, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> None: + """Remove a participant from a thread. + + Remove a participant from a thread. - def remove_chat_participant( + :param chat_thread_id: Thread id to remove the participant from. Required. + :type chat_thread_id: str + :param participant_communication_identifier: Id of the thread participant to remove from the + thread. Required. + :type participant_communication_identifier: + ~azure.communication.chat.models.CommunicationIdentifierModel + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: None or the result of cls(response) + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def remove_chat_participant( # pylint: disable=inconsistent-return-statements self, - chat_thread_id, # type: str - participant_communication_identifier, # type: "_models.CommunicationIdentifierModel" - **kwargs # type: Any - ): - # type: (...) -> None + chat_thread_id: str, + participant_communication_identifier: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> None: """Remove a participant from a thread. Remove a participant from a thread. - :param chat_thread_id: Thread id to remove the participant from. + :param chat_thread_id: Thread id to remove the participant from. Required. :type chat_thread_id: str :param participant_communication_identifier: Id of the thread participant to remove from the - thread. - :type participant_communication_identifier: ~azure.communication.chat.models.CommunicationIdentifierModel + thread. Required. + :type participant_communication_identifier: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Known values are: 'application/json', 'application/merge-patch+json'. Default value is + "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace + def remove_chat_participant( # pylint: disable=inconsistent-return-statements + self, + chat_thread_id: str, + participant_communication_identifier: Union[_models.CommunicationIdentifierModel, IO], + **kwargs: Any + ) -> None: + """Remove a participant from a thread. + + Remove a participant from a thread. + + :param chat_thread_id: Thread id to remove the participant from. Required. + :type chat_thread_id: str + :param participant_communication_identifier: Id of the thread participant to remove from the + thread. Is either a model type or a IO type. Required. + :type participant_communication_identifier: + ~azure.communication.chat.models.CommunicationIdentifierModel or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json', + 'application/merge-patch+json'. Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: None or the result of cls(response) + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: """ - cls = kwargs.pop('cls', None) # type: ClsType[None] error_map = { 404: ResourceNotFoundError, 409: ResourceExistsError, - 401: lambda response: ClientAuthenticationError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 403: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 429: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 503: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 304: ResourceNotModifiedError, + 401: lambda response: ClientAuthenticationError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 403: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 429: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 503: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), } - error_map.update(kwargs.pop('error_map', {})) - api_version = "2021-09-07" - content_type = kwargs.pop("content_type", "application/json") - accept = "application/json" + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[None] - # Construct URL - url = self.remove_chat_participant.metadata['url'] # type: ignore + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(participant_communication_identifier, (IO, bytes)): + _content = participant_communication_identifier + else: + _json = self._serialize.body(participant_communication_identifier, "CommunicationIdentifierModel") + + request = build_remove_chat_participant_request( + chat_thread_id=chat_thread_id, + api_version=api_version, + content_type=content_type, + json=_json, + content=_content, + template_url=self.remove_chat_participant.metadata["url"], + headers=_headers, + params=_params, + ) + request = _convert_request(request) path_format_arguments = { - 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), - 'chatThreadId': self._serialize.url("chat_thread_id", chat_thread_id, 'str'), + "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), } - url = self._client.format_url(url, **path_format_arguments) - - # Construct parameters - query_parameters = {} # type: Dict[str, Any] - query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') - - # Construct headers - header_parameters = {} # type: Dict[str, Any] - header_parameters['Content-Type'] = self._serialize.header("content_type", content_type, 'str') - header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') - - body_content_kwargs = {} # type: Dict[str, Any] - body_content = self._serialize.body(participant_communication_identifier, 'CommunicationIdentifierModel') - body_content_kwargs['content'] = body_content - request = self._client.post(url, query_parameters, header_parameters, **body_content_kwargs) - pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs) + request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore + + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) + response = pipeline_response.http_response if response.status_code not in [204]: @@ -728,134 +1458,283 @@ def remove_chat_participant( if cls: return cls(pipeline_response, None, {}) - remove_chat_participant.metadata = {'url': '/chat/threads/{chatThreadId}/participants/:remove'} # type: ignore + remove_chat_participant.metadata = {"url": "/chat/threads/{chatThreadId}/participants/:remove"} # type: ignore + @overload def add_chat_participants( self, - chat_thread_id, # type: str - add_chat_participants_request, # type: "_models.AddChatParticipantsRequest" - **kwargs # type: Any - ): - # type: (...) -> "_models.AddChatParticipantsResult" + chat_thread_id: str, + add_chat_participants_request: _models.AddChatParticipantsRequest, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.AddChatParticipantsResult: """Adds thread participants to a thread. If participants already exist, no change occurs. Adds thread participants to a thread. If participants already exist, no change occurs. - :param chat_thread_id: Id of the thread to add participants to. + :param chat_thread_id: Id of the thread to add participants to. Required. :type chat_thread_id: str - :param add_chat_participants_request: Thread participants to be added to the thread. - :type add_chat_participants_request: ~azure.communication.chat.models.AddChatParticipantsRequest + :param add_chat_participants_request: Thread participants to be added to the thread. Required. + :type add_chat_participants_request: + ~azure.communication.chat.models.AddChatParticipantsRequest + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: AddChatParticipantsResult, or the result of cls(response) + :return: AddChatParticipantsResult or the result of cls(response) :rtype: ~azure.communication.chat.models.AddChatParticipantsResult - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def add_chat_participants( + self, + chat_thread_id: str, + add_chat_participants_request: IO, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> _models.AddChatParticipantsResult: + """Adds thread participants to a thread. If participants already exist, no change occurs. + + Adds thread participants to a thread. If participants already exist, no change occurs. + + :param chat_thread_id: Id of the thread to add participants to. Required. + :type chat_thread_id: str + :param add_chat_participants_request: Thread participants to be added to the thread. Required. + :type add_chat_participants_request: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: AddChatParticipantsResult or the result of cls(response) + :rtype: ~azure.communication.chat.models.AddChatParticipantsResult + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace + def add_chat_participants( + self, + chat_thread_id: str, + add_chat_participants_request: Union[_models.AddChatParticipantsRequest, IO], + **kwargs: Any + ) -> _models.AddChatParticipantsResult: + """Adds thread participants to a thread. If participants already exist, no change occurs. + + Adds thread participants to a thread. If participants already exist, no change occurs. + + :param chat_thread_id: Id of the thread to add participants to. Required. + :type chat_thread_id: str + :param add_chat_participants_request: Thread participants to be added to the thread. Is either + a model type or a IO type. Required. + :type add_chat_participants_request: + ~azure.communication.chat.models.AddChatParticipantsRequest or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: AddChatParticipantsResult or the result of cls(response) + :rtype: ~azure.communication.chat.models.AddChatParticipantsResult + :raises ~azure.core.exceptions.HttpResponseError: """ - cls = kwargs.pop('cls', None) # type: ClsType["_models.AddChatParticipantsResult"] error_map = { 404: ResourceNotFoundError, 409: ResourceExistsError, - 401: lambda response: ClientAuthenticationError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 403: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 429: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 503: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 304: ResourceNotModifiedError, + 401: lambda response: ClientAuthenticationError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 403: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 429: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 503: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), } - error_map.update(kwargs.pop('error_map', {})) - api_version = "2021-09-07" - content_type = kwargs.pop("content_type", "application/json") - accept = "application/json" + error_map.update(kwargs.pop("error_map", {}) or {}) - # Construct URL - url = self.add_chat_participants.metadata['url'] # type: ignore + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.AddChatParticipantsResult] + + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(add_chat_participants_request, (IO, bytes)): + _content = add_chat_participants_request + else: + _json = self._serialize.body(add_chat_participants_request, "AddChatParticipantsRequest") + + request = build_add_chat_participants_request( + chat_thread_id=chat_thread_id, + api_version=api_version, + content_type=content_type, + json=_json, + content=_content, + template_url=self.add_chat_participants.metadata["url"], + headers=_headers, + params=_params, + ) + request = _convert_request(request) path_format_arguments = { - 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), - 'chatThreadId': self._serialize.url("chat_thread_id", chat_thread_id, 'str'), + "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), } - url = self._client.format_url(url, **path_format_arguments) - - # Construct parameters - query_parameters = {} # type: Dict[str, Any] - query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') - - # Construct headers - header_parameters = {} # type: Dict[str, Any] - header_parameters['Content-Type'] = self._serialize.header("content_type", content_type, 'str') - header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') - - body_content_kwargs = {} # type: Dict[str, Any] - body_content = self._serialize.body(add_chat_participants_request, 'AddChatParticipantsRequest') - body_content_kwargs['content'] = body_content - request = self._client.post(url, query_parameters, header_parameters, **body_content_kwargs) - pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs) + request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore + + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) + response = pipeline_response.http_response if response.status_code not in [201]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response) - deserialized = self._deserialize('AddChatParticipantsResult', pipeline_response) + deserialized = self._deserialize("AddChatParticipantsResult", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - add_chat_participants.metadata = {'url': '/chat/threads/{chatThreadId}/participants/:add'} # type: ignore - def update_chat_thread_properties( + add_chat_participants.metadata = {"url": "/chat/threads/{chatThreadId}/participants/:add"} # type: ignore + + @overload + def update_chat_thread_properties( # pylint: disable=inconsistent-return-statements self, - chat_thread_id, # type: str - update_chat_thread_request, # type: "_models.UpdateChatThreadRequest" - **kwargs # type: Any - ): - # type: (...) -> None + chat_thread_id: str, + update_chat_thread_request: _models.UpdateChatThreadRequest, + *, + content_type: str = "application/merge-patch+json", + **kwargs: Any + ) -> None: """Updates a thread's properties. Updates a thread's properties. - :param chat_thread_id: The id of the thread to update. + :param chat_thread_id: The id of the thread to update. Required. :type chat_thread_id: str - :param update_chat_thread_request: Request payload for updating a chat thread. + :param update_chat_thread_request: Request payload for updating a chat thread. Required. :type update_chat_thread_request: ~azure.communication.chat.models.UpdateChatThreadRequest + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/merge-patch+json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: None or the result of cls(response) + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def update_chat_thread_properties( # pylint: disable=inconsistent-return-statements + self, + chat_thread_id: str, + update_chat_thread_request: IO, + *, + content_type: str = "application/merge-patch+json", + **kwargs: Any + ) -> None: + """Updates a thread's properties. + + Updates a thread's properties. + + :param chat_thread_id: The id of the thread to update. Required. + :type chat_thread_id: str + :param update_chat_thread_request: Request payload for updating a chat thread. Required. + :type update_chat_thread_request: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/merge-patch+json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: None or the result of cls(response) + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace + def update_chat_thread_properties( # pylint: disable=inconsistent-return-statements + self, chat_thread_id: str, update_chat_thread_request: Union[_models.UpdateChatThreadRequest, IO], **kwargs: Any + ) -> None: + """Updates a thread's properties. + + Updates a thread's properties. + + :param chat_thread_id: The id of the thread to update. Required. + :type chat_thread_id: str + :param update_chat_thread_request: Request payload for updating a chat thread. Is either a + model type or a IO type. Required. + :type update_chat_thread_request: ~azure.communication.chat.models.UpdateChatThreadRequest or + IO + :keyword content_type: Body Parameter content-type. Known values are: + 'application/merge-patch+json'. Default value is None. + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - cls = kwargs.pop('cls', None) # type: ClsType[None] error_map = { 404: ResourceNotFoundError, 409: ResourceExistsError, - 401: lambda response: ClientAuthenticationError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 403: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 429: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 503: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 304: ResourceNotModifiedError, + 401: lambda response: ClientAuthenticationError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 403: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 429: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 503: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), } - error_map.update(kwargs.pop('error_map', {})) - api_version = "2021-09-07" - content_type = kwargs.pop("content_type", "application/merge-patch+json") - accept = "application/json" + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[None] - # Construct URL - url = self.update_chat_thread_properties.metadata['url'] # type: ignore + content_type = content_type or "application/merge-patch+json" + _json = None + _content = None + if isinstance(update_chat_thread_request, (IO, bytes)): + _content = update_chat_thread_request + else: + _json = self._serialize.body(update_chat_thread_request, "UpdateChatThreadRequest") + + request = build_update_chat_thread_properties_request( + chat_thread_id=chat_thread_id, + api_version=api_version, + content_type=content_type, + json=_json, + content=_content, + template_url=self.update_chat_thread_properties.metadata["url"], + headers=_headers, + params=_params, + ) + request = _convert_request(request) path_format_arguments = { - 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), - 'chatThreadId': self._serialize.url("chat_thread_id", chat_thread_id, 'str'), + "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), } - url = self._client.format_url(url, **path_format_arguments) - - # Construct parameters - query_parameters = {} # type: Dict[str, Any] - query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') - - # Construct headers - header_parameters = {} # type: Dict[str, Any] - header_parameters['Content-Type'] = self._serialize.header("content_type", content_type, 'str') - header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') - - body_content_kwargs = {} # type: Dict[str, Any] - body_content = self._serialize.body(update_chat_thread_request, 'UpdateChatThreadRequest') - body_content_kwargs['content'] = body_content - request = self._client.patch(url, query_parameters, header_parameters, **body_content_kwargs) - pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs) + request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore + + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) + response = pipeline_response.http_response if response.status_code not in [204]: @@ -865,129 +1744,216 @@ def update_chat_thread_properties( if cls: return cls(pipeline_response, None, {}) - update_chat_thread_properties.metadata = {'url': '/chat/threads/{chatThreadId}'} # type: ignore + update_chat_thread_properties.metadata = {"url": "/chat/threads/{chatThreadId}"} # type: ignore - def get_chat_thread_properties( - self, - chat_thread_id, # type: str - **kwargs # type: Any - ): - # type: (...) -> "_models.ChatThreadProperties" + @distributed_trace + def get_chat_thread_properties(self, chat_thread_id: str, **kwargs: Any) -> _models.ChatThreadProperties: """Gets a chat thread's properties. Gets a chat thread's properties. - :param chat_thread_id: Id of the thread. + :param chat_thread_id: Id of the thread. Required. :type chat_thread_id: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: ChatThreadProperties, or the result of cls(response) + :return: ChatThreadProperties or the result of cls(response) :rtype: ~azure.communication.chat.models.ChatThreadProperties - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - cls = kwargs.pop('cls', None) # type: ClsType["_models.ChatThreadProperties"] error_map = { 404: ResourceNotFoundError, 409: ResourceExistsError, - 401: lambda response: ClientAuthenticationError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 403: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 429: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 503: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 304: ResourceNotModifiedError, + 401: lambda response: ClientAuthenticationError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 403: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 429: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 503: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), } - error_map.update(kwargs.pop('error_map', {})) - api_version = "2021-09-07" - accept = "application/json" + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.ChatThreadProperties] - # Construct URL - url = self.get_chat_thread_properties.metadata['url'] # type: ignore + request = build_get_chat_thread_properties_request( + chat_thread_id=chat_thread_id, + api_version=api_version, + template_url=self.get_chat_thread_properties.metadata["url"], + headers=_headers, + params=_params, + ) + request = _convert_request(request) path_format_arguments = { - 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), - 'chatThreadId': self._serialize.url("chat_thread_id", chat_thread_id, 'str'), + "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), } - url = self._client.format_url(url, **path_format_arguments) - - # Construct parameters - query_parameters = {} # type: Dict[str, Any] - query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') + request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore - # Construct headers - header_parameters = {} # type: Dict[str, Any] - header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) - request = self._client.get(url, query_parameters, header_parameters) - pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs) response = pipeline_response.http_response if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response) - deserialized = self._deserialize('ChatThreadProperties', pipeline_response) + deserialized = self._deserialize("ChatThreadProperties", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get_chat_thread_properties.metadata = {'url': '/chat/threads/{chatThreadId}'} # type: ignore - def send_typing_notification( + get_chat_thread_properties.metadata = {"url": "/chat/threads/{chatThreadId}"} # type: ignore + + @overload + def send_typing_notification( # pylint: disable=inconsistent-return-statements self, - chat_thread_id, # type: str - send_typing_notification_request=None, # type: Optional["_models.SendTypingNotificationRequest"] - **kwargs # type: Any - ): - # type: (...) -> None + chat_thread_id: str, + send_typing_notification_request: Optional[_models.SendTypingNotificationRequest] = None, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> None: """Posts a typing event to a thread, on behalf of a user. Posts a typing event to a thread, on behalf of a user. - :param chat_thread_id: Id of the thread. + :param chat_thread_id: Id of the thread. Required. :type chat_thread_id: str - :param send_typing_notification_request: Details of the typing notification request. - :type send_typing_notification_request: ~azure.communication.chat.models.SendTypingNotificationRequest + :param send_typing_notification_request: Details of the typing notification request. Default + value is None. + :type send_typing_notification_request: + ~azure.communication.chat.models.SendTypingNotificationRequest + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def send_typing_notification( # pylint: disable=inconsistent-return-statements + self, + chat_thread_id: str, + send_typing_notification_request: Optional[IO] = None, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> None: + """Posts a typing event to a thread, on behalf of a user. + + Posts a typing event to a thread, on behalf of a user. + + :param chat_thread_id: Id of the thread. Required. + :type chat_thread_id: str + :param send_typing_notification_request: Details of the typing notification request. Default + value is None. + :type send_typing_notification_request: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Known values are: 'application/json', 'application/merge-patch+json'. Default value is + "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: None or the result of cls(response) + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace + def send_typing_notification( # pylint: disable=inconsistent-return-statements + self, + chat_thread_id: str, + send_typing_notification_request: Optional[Union[_models.SendTypingNotificationRequest, IO]] = None, + **kwargs: Any + ) -> None: + """Posts a typing event to a thread, on behalf of a user. + + Posts a typing event to a thread, on behalf of a user. + + :param chat_thread_id: Id of the thread. Required. + :type chat_thread_id: str + :param send_typing_notification_request: Details of the typing notification request. Is either + a model type or a IO type. Default value is None. + :type send_typing_notification_request: + ~azure.communication.chat.models.SendTypingNotificationRequest or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json', + 'application/merge-patch+json'. Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: None or the result of cls(response) + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: """ - cls = kwargs.pop('cls', None) # type: ClsType[None] error_map = { 404: ResourceNotFoundError, 409: ResourceExistsError, - 401: lambda response: ClientAuthenticationError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 403: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 429: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), - 503: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 304: ResourceNotModifiedError, + 401: lambda response: ClientAuthenticationError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 403: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 429: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), + 503: lambda response: HttpResponseError( + response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) + ), } - error_map.update(kwargs.pop('error_map', {})) - api_version = "2021-09-07" - content_type = kwargs.pop("content_type", "application/json") - accept = "application/json" + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - # Construct URL - url = self.send_typing_notification.metadata['url'] # type: ignore + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[None] + + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(send_typing_notification_request, (IO, bytes)): + _content = send_typing_notification_request + else: + if send_typing_notification_request is not None: + _json = self._serialize.body(send_typing_notification_request, "SendTypingNotificationRequest") + else: + _json = None + + request = build_send_typing_notification_request( + chat_thread_id=chat_thread_id, + api_version=api_version, + content_type=content_type, + json=_json, + content=_content, + template_url=self.send_typing_notification.metadata["url"], + headers=_headers, + params=_params, + ) + request = _convert_request(request) path_format_arguments = { - 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), - 'chatThreadId': self._serialize.url("chat_thread_id", chat_thread_id, 'str'), + "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), } - url = self._client.format_url(url, **path_format_arguments) - - # Construct parameters - query_parameters = {} # type: Dict[str, Any] - query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') + request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore - # Construct headers - header_parameters = {} # type: Dict[str, Any] - header_parameters['Content-Type'] = self._serialize.header("content_type", content_type, 'str') - header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) - body_content_kwargs = {} # type: Dict[str, Any] - if send_typing_notification_request is not None: - body_content = self._serialize.body(send_typing_notification_request, 'SendTypingNotificationRequest') - else: - body_content = None - body_content_kwargs['content'] = body_content - request = self._client.post(url, query_parameters, header_parameters, **body_content_kwargs) - pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs) response = pipeline_response.http_response if response.status_code not in [200]: @@ -997,4 +1963,4 @@ def send_typing_notification( if cls: return cls(pipeline_response, None, {}) - send_typing_notification.metadata = {'url': '/chat/threads/{chatThreadId}/typing'} # type: ignore + send_typing_notification.metadata = {"url": "/chat/threads/{chatThreadId}/typing"} # type: ignore diff --git a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/operations/_patch.py b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/operations/_patch.py new file mode 100644 index 000000000000..f7dd32510333 --- /dev/null +++ b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/operations/_patch.py @@ -0,0 +1,20 @@ +# ------------------------------------ +# Copyright (c) Microsoft Corporation. +# Licensed under the MIT License. +# ------------------------------------ +"""Customize generated code here. + +Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize +""" +from typing import List + +__all__: List[str] = [] # Add all objects you want publicly available to users at this package level + + +def patch_sdk(): + """Do not remove from this file. + + `patch_sdk` is a last resort escape hatch that allows you to do customizations + you can't accomplish using the techniques described in + https://aka.ms/azsdk/python/dpcodegen/python/customize + """ diff --git a/sdk/communication/azure-communication-chat/azure/communication/chat/aio/_chat_client_async.py b/sdk/communication/azure-communication-chat/azure/communication/chat/aio/_chat_client_async.py index 3c6c7822ac55..3a46f77e6377 100644 --- a/sdk/communication/azure-communication-chat/azure/communication/chat/aio/_chat_client_async.py +++ b/sdk/communication/azure-communication-chat/azure/communication/chat/aio/_chat_client_async.py @@ -35,9 +35,9 @@ CommunicationErrorResponseConverter ) from .._version import SDK_MONIKER +from .._api_versions import DEFAULT_VERSION - -class ChatClient(object): # pylint: disable=client-accepts-api-version-keyword +class ChatClient(object): """A client to interact with the AzureCommunicationService Chat gateway. This client provides operations to create chat thread, delete chat thread, @@ -48,6 +48,10 @@ class ChatClient(object): # pylint: disable=client-accepts-api-version-keyword :param CommunicationTokenCredential credential: The credentials with which to authenticate. + :keyword api_version: Api Version. Default value is "2021-09-07". Note that overriding this + default value may result in unsupported behavior. + :paramtype api_version: str + .. admonition:: Example: .. literalinclude:: ../samples/chat_client_sample_async.py @@ -79,10 +83,12 @@ def __init__( raise ValueError("Invalid URL: {}".format(endpoint)) self._endpoint = endpoint + self._api_version = kwargs.pop("api_version", DEFAULT_VERSION) self._credential = credential self._client = AzureCommunicationChatService( self._endpoint, + api_version=self._api_version, authentication_policy=AsyncBearerTokenCredentialPolicy(self._credential), sdk_moniker=SDK_MONIKER, **kwargs) diff --git a/sdk/communication/azure-communication-chat/azure/communication/chat/aio/_chat_thread_client_async.py b/sdk/communication/azure-communication-chat/azure/communication/chat/aio/_chat_thread_client_async.py index 1ca7d2f9f395..c5e7285307d3 100644 --- a/sdk/communication/azure-communication-chat/azure/communication/chat/aio/_chat_thread_client_async.py +++ b/sdk/communication/azure-communication-chat/azure/communication/chat/aio/_chat_thread_client_async.py @@ -38,9 +38,10 @@ from .._communication_identifier_serializer import serialize_identifier from .._utils import CommunicationErrorResponseConverter from .._version import SDK_MONIKER +from .._api_versions import DEFAULT_VERSION -class ChatThreadClient(object): # pylint: disable=client-accepts-api-version-keyword +class ChatThreadClient(object): """A client to interact with the AzureCommunicationService Chat gateway. Instances of this class is normally retrieved by ChatClient.get_chat_thread_client() @@ -59,6 +60,10 @@ class ChatThreadClient(object): # pylint: disable=client-accepts-api-version-key :param str thread_id: The unique thread id. + :keyword api_version: Api Version. Default value is "2021-09-07". Note that overriding this + default value may result in unsupported behavior. + :paramtype api_version: str + .. admonition:: Example: .. literalinclude:: ../samples/chat_thread_client_sample_async.py @@ -94,10 +99,12 @@ def __init__( self._thread_id = thread_id self._endpoint = endpoint + self._api_version = kwargs.pop("api_version", DEFAULT_VERSION) self._credential = credential self._client = AzureCommunicationChatService( endpoint, + api_version=self._api_version, authentication_policy=AsyncBearerTokenCredentialPolicy(self._credential), sdk_moniker=SDK_MONIKER, **kwargs) diff --git a/sdk/communication/azure-communication-sms/azure/communication/sms/_api_versions.py b/sdk/communication/azure-communication-sms/azure/communication/sms/_api_versions.py new file mode 100644 index 000000000000..ce0c5eba7d43 --- /dev/null +++ b/sdk/communication/azure-communication-sms/azure/communication/sms/_api_versions.py @@ -0,0 +1,14 @@ +# ------------------------------------ +# Copyright (c) Microsoft Corporation. +# Licensed under the MIT License. +# ------------------------------------ + +from enum import Enum +from azure.core import CaseInsensitiveEnumMeta + + +class ApiVersion(str, Enum, metaclass=CaseInsensitiveEnumMeta): + V2021_03_07 = "2021-03-07" + + +DEFAULT_VERSION = ApiVersion.V2021_03_07 diff --git a/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/__init__.py b/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/__init__.py index 9b98a0a107d8..77b0df28d3c0 100644 --- a/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/__init__.py +++ b/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/__init__.py @@ -7,10 +7,15 @@ # -------------------------------------------------------------------------- from ._azure_communication_sms_service import AzureCommunicationSMSService -__all__ = ['AzureCommunicationSMSService'] try: - from ._patch import patch_sdk # type: ignore - patch_sdk() + from ._patch import __all__ as _patch_all + from ._patch import * # type: ignore # pylint: disable=unused-wildcard-import except ImportError: - pass + _patch_all = [] +from ._patch import patch_sdk as _patch_sdk + +__all__ = ["AzureCommunicationSMSService"] +__all__.extend([p for p in _patch_all if p not in __all__]) + +_patch_sdk() diff --git a/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/_azure_communication_sms_service.py b/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/_azure_communication_sms_service.py index 0fee0dbd6f58..2bd018ac2c23 100644 --- a/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/_azure_communication_sms_service.py +++ b/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/_azure_communication_sms_service.py @@ -6,66 +6,69 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import TYPE_CHECKING +from copy import deepcopy +from typing import Any from azure.core import PipelineClient -from msrest import Deserializer, Serializer - -if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports - from typing import Any - - from azure.core.pipeline.transport import HttpRequest, HttpResponse +from azure.core.rest import HttpRequest, HttpResponse +from . import models from ._configuration import AzureCommunicationSMSServiceConfiguration +from ._serialization import Deserializer, Serializer from .operations import SmsOperations -from . import models -class AzureCommunicationSMSService(object): +class AzureCommunicationSMSService: # pylint: disable=client-accepts-api-version-keyword """Azure Communication SMS Service. :ivar sms: SmsOperations operations :vartype sms: azure.communication.sms.operations.SmsOperations - :param endpoint: The communication resource, for example https://my-resource.communication.azure.com. + :param endpoint: The communication resource, for example + https://my-resource.communication.azure.com. Required. :type endpoint: str + :keyword api_version: Api Version. Default value is "2021-03-07". Note that overriding this + default value may result in unsupported behavior. + :paramtype api_version: str """ - def __init__( - self, - endpoint, # type: str - **kwargs # type: Any - ): - # type: (...) -> None - base_url = '{endpoint}' - self._config = AzureCommunicationSMSServiceConfiguration(endpoint, **kwargs) - self._client = PipelineClient(base_url=base_url, config=self._config, **kwargs) + def __init__( # pylint: disable=missing-client-constructor-parameter-credential + self, endpoint: str, **kwargs: Any + ) -> None: + _endpoint = "{endpoint}" + self._config = AzureCommunicationSMSServiceConfiguration(endpoint=endpoint, **kwargs) + self._client = PipelineClient(base_url=_endpoint, config=self._config, **kwargs) client_models = {k: v for k, v in models.__dict__.items() if isinstance(v, type)} self._serialize = Serializer(client_models) - self._serialize.client_side_validation = False self._deserialize = Deserializer(client_models) + self._serialize.client_side_validation = False + self.sms = SmsOperations(self._client, self._config, self._serialize, self._deserialize) - self.sms = SmsOperations( - self._client, self._config, self._serialize, self._deserialize) - - def _send_request(self, http_request, **kwargs): - # type: (HttpRequest, Any) -> HttpResponse + def _send_request(self, request: HttpRequest, **kwargs: Any) -> HttpResponse: """Runs the network request through the client's chained policies. - :param http_request: The network request you want to make. Required. - :type http_request: ~azure.core.pipeline.transport.HttpRequest - :keyword bool stream: Whether the response payload will be streamed. Defaults to True. + >>> from azure.core.rest import HttpRequest + >>> request = HttpRequest("GET", "https://www.example.org/") + + >>> response = client._send_request(request) + + + For more information on this code flow, see https://aka.ms/azsdk/dpcodegen/python/send_request + + :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.pipeline.transport.HttpResponse + :rtype: ~azure.core.rest.HttpResponse """ + + request_copy = deepcopy(request) path_format_arguments = { - 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), + "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), } - http_request.url = self._client.format_url(http_request.url, **path_format_arguments) - stream = kwargs.pop("stream", True) - pipeline_response = self._client._pipeline.run(http_request, stream=stream, **kwargs) - return pipeline_response.http_response + + request_copy.url = self._client.format_url(request_copy.url, **path_format_arguments) + return self._client.send_request(request_copy, **kwargs) def close(self): # type: () -> None diff --git a/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/_configuration.py b/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/_configuration.py index 9d3154a1fa3b..58cd247d5df5 100644 --- a/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/_configuration.py +++ b/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/_configuration.py @@ -6,53 +6,50 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import TYPE_CHECKING +from typing import Any from azure.core.configuration import Configuration from azure.core.pipeline import policies -if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports - from typing import Any - VERSION = "unknown" -class AzureCommunicationSMSServiceConfiguration(Configuration): + +class AzureCommunicationSMSServiceConfiguration(Configuration): # pylint: disable=too-many-instance-attributes """Configuration for AzureCommunicationSMSService. Note that all parameters used to create this instance are saved as instance attributes. - :param endpoint: The communication resource, for example https://my-resource.communication.azure.com. + :param endpoint: The communication resource, for example + https://my-resource.communication.azure.com. Required. :type endpoint: str + :keyword api_version: Api Version. Default value is "2021-03-07". Note that overriding this + default value may result in unsupported behavior. + :paramtype api_version: str """ - def __init__( - self, - endpoint, # type: str - **kwargs # type: Any - ): - # type: (...) -> None + def __init__(self, endpoint: str, **kwargs: Any) -> None: + super(AzureCommunicationSMSServiceConfiguration, self).__init__(**kwargs) + api_version = kwargs.pop("api_version", "2021-03-07") # type: str + if endpoint is None: raise ValueError("Parameter 'endpoint' must not be None.") - super(AzureCommunicationSMSServiceConfiguration, self).__init__(**kwargs) self.endpoint = endpoint - self.api_version = "2021-03-07" - kwargs.setdefault('sdk_moniker', 'azurecommunicationsmsservice/{}'.format(VERSION)) + self.api_version = api_version + kwargs.setdefault("sdk_moniker", "azurecommunicationsmsservice/{}".format(VERSION)) self._configure(**kwargs) def _configure( - self, - **kwargs # type: Any + self, **kwargs # type: Any ): # type: (...) -> None - 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 policies.HttpLoggingPolicy(**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') + 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 policies.HttpLoggingPolicy(**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") diff --git a/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/_patch.py b/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/_patch.py new file mode 100644 index 000000000000..f7dd32510333 --- /dev/null +++ b/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/_patch.py @@ -0,0 +1,20 @@ +# ------------------------------------ +# Copyright (c) Microsoft Corporation. +# Licensed under the MIT License. +# ------------------------------------ +"""Customize generated code here. + +Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize +""" +from typing import List + +__all__: List[str] = [] # Add all objects you want publicly available to users at this package level + + +def patch_sdk(): + """Do not remove from this file. + + `patch_sdk` is a last resort escape hatch that allows you to do customizations + you can't accomplish using the techniques described in + https://aka.ms/azsdk/python/dpcodegen/python/customize + """ diff --git a/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/_serialization.py b/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/_serialization.py new file mode 100644 index 000000000000..7c1dedb5133d --- /dev/null +++ b/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/_serialization.py @@ -0,0 +1,1970 @@ +# -------------------------------------------------------------------------- +# +# 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 + +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 + +try: + from urllib import quote # type: ignore +except ImportError: + from urllib.parse import quote # type: ignore +import xml.etree.ElementTree as ET + +import isodate + +from typing import Dict, Any, cast, TYPE_CHECKING + +from azure.core.exceptions import DeserializationError, SerializationError, raise_with_traceback + +_BOM = codecs.BOM_UTF8.decode(encoding="utf-8") + +if TYPE_CHECKING: + from typing import Optional, Union, AnyStr, IO, Mapping + + +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, content_type=None): + # type: (Optional[Union[AnyStr, IO]], Optional[str]) -> 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, headers): + # type: (Optional[Union[AnyStr, IO]], 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 # type: ignore + unicode_str = str # type: ignore + +_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 +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 "".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 # type: ignore +except ImportError: + TZ_UTC = UTC() # type: ignore + +_FLATTEN = re.compile(r"(? 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=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(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) + continue + if xml_desc.get("text", False): + serialized.text = new_attr + continue + if isinstance(new_attr, list): + serialized.extend(new_attr) + 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) + 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) + else: # JSON + for k in reversed(keys): + unflattened = {k: new_attr} + new_attr = unflattened + + _new_attr = new_attr + _serialized = serialized + for k in keys: + if k not in _serialized: + _serialized.update(_new_attr) + _new_attr = _new_attr[k] + _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 = data_type.strip("[]{}") + internal_data_type = self.dependencies.get(internal_data_type, 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 = [ + 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_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): + # 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) + return result + except ValueError: + for enum_value in enum_obj: + 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: + 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 = 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=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(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 + 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 + 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 deseralize. + """ + 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__ + + 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 deseralize. + :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) + 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) + 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 value 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 is empty string. + return "" + else: + # None or '', node 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): + 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)) + + @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) + attr = attr + padding + 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) + 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) + + @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): + 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): + 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) + 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() + 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) + 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 diff --git a/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/_vendor.py b/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/_vendor.py new file mode 100644 index 000000000000..0dafe0e287ff --- /dev/null +++ b/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/_vendor.py @@ -0,0 +1,16 @@ +# -------------------------------------------------------------------------- +# 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 azure.core.pipeline.transport import HttpRequest + + +def _convert_request(request, files=None): + data = request.content if not files else None + request = HttpRequest(method=request.method, url=request.url, headers=request.headers, data=data) + if files: + request.set_formdata_body(files) + return request diff --git a/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/aio/__init__.py b/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/aio/__init__.py index 1149dd8315fb..77b0df28d3c0 100644 --- a/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/aio/__init__.py +++ b/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/aio/__init__.py @@ -7,4 +7,15 @@ # -------------------------------------------------------------------------- from ._azure_communication_sms_service import AzureCommunicationSMSService -__all__ = ['AzureCommunicationSMSService'] + +try: + from ._patch import __all__ as _patch_all + from ._patch import * # type: ignore # pylint: disable=unused-wildcard-import +except ImportError: + _patch_all = [] +from ._patch import patch_sdk as _patch_sdk + +__all__ = ["AzureCommunicationSMSService"] +__all__.extend([p for p in _patch_all if p not in __all__]) + +_patch_sdk() diff --git a/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/aio/_azure_communication_sms_service.py b/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/aio/_azure_communication_sms_service.py index 9df4a63dd70e..0866e920e7ec 100644 --- a/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/aio/_azure_communication_sms_service.py +++ b/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/aio/_azure_communication_sms_service.py @@ -6,59 +6,69 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any +from copy import deepcopy +from typing import Any, Awaitable from azure.core import AsyncPipelineClient -from azure.core.pipeline.transport import AsyncHttpResponse, HttpRequest -from msrest import Deserializer, Serializer +from azure.core.rest import AsyncHttpResponse, HttpRequest +from .. import models +from .._serialization import Deserializer, Serializer from ._configuration import AzureCommunicationSMSServiceConfiguration from .operations import SmsOperations -from .. import models -class AzureCommunicationSMSService(object): +class AzureCommunicationSMSService: # pylint: disable=client-accepts-api-version-keyword """Azure Communication SMS Service. :ivar sms: SmsOperations operations :vartype sms: azure.communication.sms.aio.operations.SmsOperations - :param endpoint: The communication resource, for example https://my-resource.communication.azure.com. + :param endpoint: The communication resource, for example + https://my-resource.communication.azure.com. Required. :type endpoint: str + :keyword api_version: Api Version. Default value is "2021-03-07". Note that overriding this + default value may result in unsupported behavior. + :paramtype api_version: str """ - def __init__( - self, - endpoint: str, - **kwargs: Any + def __init__( # pylint: disable=missing-client-constructor-parameter-credential + self, endpoint: str, **kwargs: Any ) -> None: - base_url = '{endpoint}' - self._config = AzureCommunicationSMSServiceConfiguration(endpoint, **kwargs) - self._client = AsyncPipelineClient(base_url=base_url, config=self._config, **kwargs) + _endpoint = "{endpoint}" + self._config = AzureCommunicationSMSServiceConfiguration(endpoint=endpoint, **kwargs) + self._client = AsyncPipelineClient(base_url=_endpoint, config=self._config, **kwargs) client_models = {k: v for k, v in models.__dict__.items() if isinstance(v, type)} self._serialize = Serializer(client_models) - self._serialize.client_side_validation = False self._deserialize = Deserializer(client_models) + self._serialize.client_side_validation = False + self.sms = SmsOperations(self._client, self._config, self._serialize, self._deserialize) - self.sms = SmsOperations( - self._client, self._config, self._serialize, self._deserialize) - - async def _send_request(self, http_request: HttpRequest, **kwargs: Any) -> AsyncHttpResponse: + def _send_request(self, request: HttpRequest, **kwargs: Any) -> Awaitable[AsyncHttpResponse]: """Runs the network request through the client's chained policies. - :param http_request: The network request you want to make. Required. - :type http_request: ~azure.core.pipeline.transport.HttpRequest - :keyword bool stream: Whether the response payload will be streamed. Defaults to True. + >>> from azure.core.rest import HttpRequest + >>> request = HttpRequest("GET", "https://www.example.org/") + + >>> response = await client._send_request(request) + + + For more information on this code flow, see https://aka.ms/azsdk/dpcodegen/python/send_request + + :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.pipeline.transport.AsyncHttpResponse + :rtype: ~azure.core.rest.AsyncHttpResponse """ + + request_copy = deepcopy(request) path_format_arguments = { - 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), + "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), } - http_request.url = self._client.format_url(http_request.url, **path_format_arguments) - stream = kwargs.pop("stream", True) - pipeline_response = await self._client._pipeline.run(http_request, stream=stream, **kwargs) - return pipeline_response.http_response + + request_copy.url = self._client.format_url(request_copy.url, **path_format_arguments) + return self._client.send_request(request_copy, **kwargs) async def close(self) -> None: await self._client.close() diff --git a/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/aio/_configuration.py b/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/aio/_configuration.py index 77033099353f..5a8070bc430a 100644 --- a/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/aio/_configuration.py +++ b/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/aio/_configuration.py @@ -13,40 +13,40 @@ VERSION = "unknown" -class AzureCommunicationSMSServiceConfiguration(Configuration): + +class AzureCommunicationSMSServiceConfiguration(Configuration): # pylint: disable=too-many-instance-attributes """Configuration for AzureCommunicationSMSService. Note that all parameters used to create this instance are saved as instance attributes. - :param endpoint: The communication resource, for example https://my-resource.communication.azure.com. + :param endpoint: The communication resource, for example + https://my-resource.communication.azure.com. Required. :type endpoint: str + :keyword api_version: Api Version. Default value is "2021-03-07". Note that overriding this + default value may result in unsupported behavior. + :paramtype api_version: str """ - def __init__( - self, - endpoint: str, - **kwargs: Any - ) -> None: + def __init__(self, endpoint: str, **kwargs: Any) -> None: + super(AzureCommunicationSMSServiceConfiguration, self).__init__(**kwargs) + api_version = kwargs.pop("api_version", "2021-03-07") # type: str + if endpoint is None: raise ValueError("Parameter 'endpoint' must not be None.") - super(AzureCommunicationSMSServiceConfiguration, self).__init__(**kwargs) self.endpoint = endpoint - self.api_version = "2021-03-07" - kwargs.setdefault('sdk_moniker', 'azurecommunicationsmsservice/{}'.format(VERSION)) + self.api_version = api_version + kwargs.setdefault("sdk_moniker", "azurecommunicationsmsservice/{}".format(VERSION)) self._configure(**kwargs) - def _configure( - self, - **kwargs: Any - ) -> None: - 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 policies.HttpLoggingPolicy(**kwargs) - self.retry_policy = kwargs.get('retry_policy') or policies.AsyncRetryPolicy(**kwargs) - self.custom_hook_policy = kwargs.get('custom_hook_policy') or policies.CustomHookPolicy(**kwargs) - self.redirect_policy = kwargs.get('redirect_policy') or policies.AsyncRedirectPolicy(**kwargs) - self.authentication_policy = kwargs.get('authentication_policy') + def _configure(self, **kwargs: Any) -> None: + 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 policies.HttpLoggingPolicy(**kwargs) + self.retry_policy = kwargs.get("retry_policy") or policies.AsyncRetryPolicy(**kwargs) + self.custom_hook_policy = kwargs.get("custom_hook_policy") or policies.CustomHookPolicy(**kwargs) + self.redirect_policy = kwargs.get("redirect_policy") or policies.AsyncRedirectPolicy(**kwargs) + self.authentication_policy = kwargs.get("authentication_policy") diff --git a/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/aio/_patch.py b/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/aio/_patch.py new file mode 100644 index 000000000000..f7dd32510333 --- /dev/null +++ b/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/aio/_patch.py @@ -0,0 +1,20 @@ +# ------------------------------------ +# Copyright (c) Microsoft Corporation. +# Licensed under the MIT License. +# ------------------------------------ +"""Customize generated code here. + +Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize +""" +from typing import List + +__all__: List[str] = [] # Add all objects you want publicly available to users at this package level + + +def patch_sdk(): + """Do not remove from this file. + + `patch_sdk` is a last resort escape hatch that allows you to do customizations + you can't accomplish using the techniques described in + https://aka.ms/azsdk/python/dpcodegen/python/customize + """ diff --git a/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/aio/operations/__init__.py b/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/aio/operations/__init__.py index f9ce203e2885..96d0f1292ecb 100644 --- a/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/aio/operations/__init__.py +++ b/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/aio/operations/__init__.py @@ -8,6 +8,12 @@ from ._sms_operations import SmsOperations +from ._patch import __all__ as _patch_all +from ._patch import * # type: ignore # pylint: disable=unused-wildcard-import +from ._patch import patch_sdk as _patch_sdk + __all__ = [ - 'SmsOperations', + "SmsOperations", ] +__all__.extend([p for p in _patch_all if p not in __all__]) +_patch_sdk() diff --git a/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/aio/operations/_patch.py b/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/aio/operations/_patch.py new file mode 100644 index 000000000000..f7dd32510333 --- /dev/null +++ b/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/aio/operations/_patch.py @@ -0,0 +1,20 @@ +# ------------------------------------ +# Copyright (c) Microsoft Corporation. +# Licensed under the MIT License. +# ------------------------------------ +"""Customize generated code here. + +Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize +""" +from typing import List + +__all__: List[str] = [] # Add all objects you want publicly available to users at this package level + + +def patch_sdk(): + """Do not remove from this file. + + `patch_sdk` is a last resort escape hatch that allows you to do customizations + you can't accomplish using the techniques described in + https://aka.ms/azsdk/python/dpcodegen/python/customize + """ diff --git a/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/aio/operations/_sms_operations.py b/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/aio/operations/_sms_operations.py index 7ec83da71f2e..5bafac3025b9 100644 --- a/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/aio/operations/_sms_operations.py +++ b/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/aio/operations/_sms_operations.py @@ -1,3 +1,4 @@ +# pylint: disable=too-many-lines # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -5,96 +6,159 @@ # 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, Callable, Dict, Generic, Optional, TypeVar -import warnings - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from typing import Any, Callable, Dict, IO, Optional, TypeVar, Union, overload + +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + map_error, +) from azure.core.pipeline import PipelineResponse -from azure.core.pipeline.transport import AsyncHttpResponse, HttpRequest +from azure.core.pipeline.transport import AsyncHttpResponse +from azure.core.rest import HttpRequest +from azure.core.tracing.decorator_async import distributed_trace_async +from azure.core.utils import case_insensitive_dict from ... import models as _models +from ..._vendor import _convert_request +from ...operations._sms_operations import build_send_request -T = TypeVar('T') +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] -class SmsOperations: - """SmsOperations async operations. - You should not instantiate this class directly. Instead, you should create a Client instance that - instantiates it for you and attaches it as an attribute. +class SmsOperations: + """ + .. warning:: + **DO NOT** instantiate this class directly. - :ivar models: Alias to model classes used in this operation group. - :type models: ~azure.communication.sms.models - :param client: Client for service requests. - :param config: Configuration of service client. - :param serializer: An object model serializer. - :param deserializer: An object model deserializer. + Instead, you should access the following operations through + :class:`~azure.communication.sms.aio.AzureCommunicationSMSService`'s + :attr:`sms` attribute. """ models = _models - def __init__(self, client, config, serializer, deserializer) -> None: - self._client = client - self._serialize = serializer - self._deserialize = deserializer - self._config = config + def __init__(self, *args, **kwargs) -> None: + input_args = list(args) + self._client = input_args.pop(0) if input_args else kwargs.pop("client") + self._config = input_args.pop(0) if input_args else kwargs.pop("config") + self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") + self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") + @overload async def send( - self, - send_message_request: "_models.SendMessageRequest", - **kwargs: Any - ) -> "_models.SmsSendResponse": + self, send_message_request: _models.SendMessageRequest, *, content_type: str = "application/json", **kwargs: Any + ) -> _models.SmsSendResponse: """Sends a SMS message from a phone number that belongs to the authenticated account. Sends a SMS message from a phone number that belongs to the authenticated account. - :param send_message_request: Represents the body of the send message request. + :param send_message_request: Represents the body of the send message request. Required. :type send_message_request: ~azure.communication.sms.models.SendMessageRequest + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: SmsSendResponse or the result of cls(response) + :rtype: ~azure.communication.sms.models.SmsSendResponse + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + async def send( + self, send_message_request: IO, *, content_type: str = "application/json", **kwargs: Any + ) -> _models.SmsSendResponse: + """Sends a SMS message from a phone number that belongs to the authenticated account. + + Sends a SMS message from a phone number that belongs to the authenticated account. + + :param send_message_request: Represents the body of the send message request. Required. + :type send_message_request: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: SmsSendResponse, or the result of cls(response) + :return: SmsSendResponse or the result of cls(response) :rtype: ~azure.communication.sms.models.SmsSendResponse - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace_async + async def send( + self, send_message_request: Union[_models.SendMessageRequest, IO], **kwargs: Any + ) -> _models.SmsSendResponse: + """Sends a SMS message from a phone number that belongs to the authenticated account. + + Sends a SMS message from a phone number that belongs to the authenticated account. + + :param send_message_request: Represents the body of the send message request. Is either a model + type or a IO type. Required. + :type send_message_request: ~azure.communication.sms.models.SendMessageRequest or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: SmsSendResponse or the result of cls(response) + :rtype: ~azure.communication.sms.models.SmsSendResponse + :raises ~azure.core.exceptions.HttpResponseError: """ - cls = kwargs.pop('cls', None) # type: ClsType["_models.SmsSendResponse"] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {})) - api_version = "2021-03-07" - content_type = kwargs.pop("content_type", "application/json") - accept = "application/json" - - # Construct URL - url = self.send.metadata['url'] # type: ignore + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.SmsSendResponse] + + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(send_message_request, (IO, bytes)): + _content = send_message_request + else: + _json = self._serialize.body(send_message_request, "SendMessageRequest") + + request = build_send_request( + api_version=api_version, + content_type=content_type, + json=_json, + content=_content, + template_url=self.send.metadata["url"], + headers=_headers, + params=_params, + ) + request = _convert_request(request) path_format_arguments = { - 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), + "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), } - url = self._client.format_url(url, **path_format_arguments) - - # Construct parameters - query_parameters = {} # type: Dict[str, Any] - query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') - - # Construct headers - header_parameters = {} # type: Dict[str, Any] - header_parameters['Content-Type'] = self._serialize.header("content_type", content_type, 'str') - header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') - - body_content_kwargs = {} # type: Dict[str, Any] - body_content = self._serialize.body(send_message_request, 'SendMessageRequest') - body_content_kwargs['content'] = body_content - request = self._client.post(url, query_parameters, header_parameters, **body_content_kwargs) - pipeline_response = await self._client._pipeline.run(request, stream=False, **kwargs) + request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore + + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) + response = pipeline_response.http_response if response.status_code not in [202]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response) - deserialized = self._deserialize('SmsSendResponse', pipeline_response) + deserialized = self._deserialize("SmsSendResponse", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - send.metadata = {'url': '/sms'} # type: ignore + + send.metadata = {"url": "/sms"} # type: ignore diff --git a/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/models/__init__.py b/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/models/__init__.py index 74b2447dbed0..c1a416fd6af8 100644 --- a/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/models/__init__.py +++ b/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/models/__init__.py @@ -6,28 +6,24 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -try: - from ._models_py3 import SendMessageRequest - from ._models_py3 import SmsRecipient - from ._models_py3 import SmsSendOptions - from ._models_py3 import SmsSendResponse - from ._models_py3 import SmsSendResponseItem -except (SyntaxError, ImportError): - from ._models import SendMessageRequest # type: ignore - from ._models import SmsRecipient # type: ignore - from ._models import SmsSendOptions # type: ignore - from ._models import SmsSendResponse # type: ignore - from ._models import SmsSendResponseItem # type: ignore +from ._models_py3 import SendMessageRequest +from ._models_py3 import SmsRecipient +from ._models_py3 import SmsSendOptions +from ._models_py3 import SmsSendResponse +from ._models_py3 import SmsSendResponseItem -from ._azure_communication_sms_service_enums import ( - SmsSendResponseItemRepeatabilityResult, -) +from ._azure_communication_sms_service_enums import SmsSendResponseItemRepeatabilityResult +from ._patch import __all__ as _patch_all +from ._patch import * # type: ignore # pylint: disable=unused-wildcard-import +from ._patch import patch_sdk as _patch_sdk __all__ = [ - 'SendMessageRequest', - 'SmsRecipient', - 'SmsSendOptions', - 'SmsSendResponse', - 'SmsSendResponseItem', - 'SmsSendResponseItemRepeatabilityResult', + "SendMessageRequest", + "SmsRecipient", + "SmsSendOptions", + "SmsSendResponse", + "SmsSendResponseItem", + "SmsSendResponseItemRepeatabilityResult", ] +__all__.extend([p for p in _patch_all if p not in __all__]) +_patch_sdk() diff --git a/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/models/_azure_communication_sms_service_enums.py b/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/models/_azure_communication_sms_service_enums.py index 635ce86194d5..eea2580b1f0b 100644 --- a/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/models/_azure_communication_sms_service_enums.py +++ b/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/models/_azure_communication_sms_service_enums.py @@ -6,27 +6,11 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from enum import Enum, EnumMeta -from six import with_metaclass +from enum import Enum +from azure.core import CaseInsensitiveEnumMeta -class _CaseInsensitiveEnumMeta(EnumMeta): - def __getitem__(self, name): - return super().__getitem__(name.upper()) - def __getattr__(cls, name): - """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. - """ - try: - return cls._member_map_[name.upper()] - except KeyError: - raise AttributeError(name) - - -class SmsSendResponseItemRepeatabilityResult(with_metaclass(_CaseInsensitiveEnumMeta, str, Enum)): +class SmsSendResponseItemRepeatabilityResult(str, Enum, metaclass=CaseInsensitiveEnumMeta): """The result of a repeatable request with one of the case-insensitive values accepted or rejected. """ diff --git a/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/models/_models.py b/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/models/_models.py deleted file mode 100644 index 3dd8dab3bef2..000000000000 --- a/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/models/_models.py +++ /dev/null @@ -1,197 +0,0 @@ -# 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. -# -------------------------------------------------------------------------- - -import msrest.serialization - - -class SendMessageRequest(msrest.serialization.Model): - """Represents the properties of a send message request. - - All required parameters must be populated in order to send to Azure. - - :param from_property: Required. The sender's phone number in E.164 format that is owned by the - authenticated account. - :type from_property: str - :param sms_recipients: Required. The recipient's phone number in E.164 format. In this version, - a minimum of 1 and upto 100 recipients in the list are supported. - :type sms_recipients: list[~azure.communication.sms.models.SmsRecipient] - :param message: Required. The contents of the message that will be sent to the recipient. The - allowable content is defined by RFC 5724. - :type message: str - :param sms_send_options: Optional configuration for sending SMS messages. - :type sms_send_options: ~azure.communication.sms.models.SmsSendOptions - """ - - _validation = { - 'from_property': {'required': True}, - 'sms_recipients': {'required': True}, - 'message': {'required': True, 'max_length': 2048, 'min_length': 0}, - } - - _attribute_map = { - 'from_property': {'key': 'from', 'type': 'str'}, - 'sms_recipients': {'key': 'smsRecipients', 'type': '[SmsRecipient]'}, - 'message': {'key': 'message', 'type': 'str'}, - 'sms_send_options': {'key': 'smsSendOptions', 'type': 'SmsSendOptions'}, - } - - def __init__( - self, - **kwargs - ): - super(SendMessageRequest, self).__init__(**kwargs) - self.from_property = kwargs['from_property'] - self.sms_recipients = kwargs['sms_recipients'] - self.message = kwargs['message'] - self.sms_send_options = kwargs.get('sms_send_options', None) - - -class SmsRecipient(msrest.serialization.Model): - """Recipient details for sending SMS messages. - - All required parameters must be populated in order to send to Azure. - - :param to: Required. The recipient's phone number in E.164 format. - :type to: str - :param repeatability_request_id: If specified, the client directs that the request is - repeatable; that is, the client can make the request multiple times with the same - Repeatability-Request-ID and get back an appropriate response without the server executing the - request multiple times. The value of the Repeatability-Request-ID is an opaque string - representing a client-generated, 36-character hexadecimal case-insensitive encoding of a UUID - (GUID), identifier for the request. - :type repeatability_request_id: str - :param repeatability_first_sent: MUST be sent by clients to specify that a request is - repeatable. Repeatability-First-Sent is used to specify the date and time at which the request - was first created.eg- Tue, 26 Mar 2019 16:06:51 GMT. - :type repeatability_first_sent: str - """ - - _validation = { - 'to': {'required': True}, - } - - _attribute_map = { - 'to': {'key': 'to', 'type': 'str'}, - 'repeatability_request_id': {'key': 'repeatabilityRequestId', 'type': 'str'}, - 'repeatability_first_sent': {'key': 'repeatabilityFirstSent', 'type': 'str'}, - } - - def __init__( - self, - **kwargs - ): - super(SmsRecipient, self).__init__(**kwargs) - self.to = kwargs['to'] - self.repeatability_request_id = kwargs.get('repeatability_request_id', None) - self.repeatability_first_sent = kwargs.get('repeatability_first_sent', None) - - -class SmsSendOptions(msrest.serialization.Model): - """Optional configuration for sending SMS messages. - - All required parameters must be populated in order to send to Azure. - - :param enable_delivery_report: Required. Enable this flag to receive a delivery report for this - message on the Azure Resource EventGrid. - :type enable_delivery_report: bool - :param tag: Use this field to provide metadata that will then be sent back in the corresponding - Delivery Report. - :type tag: str - """ - - _validation = { - 'enable_delivery_report': {'required': True}, - } - - _attribute_map = { - 'enable_delivery_report': {'key': 'enableDeliveryReport', 'type': 'bool'}, - 'tag': {'key': 'tag', 'type': 'str'}, - } - - def __init__( - self, - **kwargs - ): - super(SmsSendOptions, self).__init__(**kwargs) - self.enable_delivery_report = kwargs['enable_delivery_report'] - self.tag = kwargs.get('tag', None) - - -class SmsSendResponse(msrest.serialization.Model): - """Response for a successful or multi status send Sms request. - - All required parameters must be populated in order to send to Azure. - - :param value: Required. - :type value: list[~azure.communication.sms.models.SmsSendResponseItem] - """ - - _validation = { - 'value': {'required': True}, - } - - _attribute_map = { - 'value': {'key': 'value', 'type': '[SmsSendResponseItem]'}, - } - - def __init__( - self, - **kwargs - ): - super(SmsSendResponse, self).__init__(**kwargs) - self.value = kwargs['value'] - - -class SmsSendResponseItem(msrest.serialization.Model): - """Response for a single recipient. - - All required parameters must be populated in order to send to Azure. - - :param to: Required. The recipient's phone number in E.164 format. - :type to: str - :param message_id: The identifier of the outgoing Sms message. Only present if message - processed. - :type message_id: str - :param http_status_code: Required. HTTP Status code. - :type http_status_code: int - :param repeatability_result: The result of a repeatable request with one of the - case-insensitive values accepted or rejected. Possible values include: "accepted", "rejected". - :type repeatability_result: str or - ~azure.communication.sms.models.SmsSendResponseItemRepeatabilityResult - :param successful: Required. Indicates if the message is processed successfully or not. - :type successful: bool - :param error_message: Optional error message in case of 4xx/5xx/repeatable errors. - :type error_message: str - """ - - _validation = { - 'to': {'required': True}, - 'http_status_code': {'required': True}, - 'successful': {'required': True}, - } - - _attribute_map = { - 'to': {'key': 'to', 'type': 'str'}, - 'message_id': {'key': 'messageId', 'type': 'str'}, - 'http_status_code': {'key': 'httpStatusCode', 'type': 'int'}, - 'repeatability_result': {'key': 'repeatabilityResult', 'type': 'str'}, - 'successful': {'key': 'successful', 'type': 'bool'}, - 'error_message': {'key': 'errorMessage', 'type': 'str'}, - } - - def __init__( - self, - **kwargs - ): - super(SmsSendResponseItem, self).__init__(**kwargs) - self.to = kwargs['to'] - self.message_id = kwargs.get('message_id', None) - self.http_status_code = kwargs['http_status_code'] - self.repeatability_result = kwargs.get('repeatability_result', None) - self.successful = kwargs['successful'] - self.error_message = kwargs.get('error_message', None) diff --git a/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/models/_models_py3.py b/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/models/_models_py3.py index 7934352a7708..2dff456ae996 100644 --- a/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/models/_models_py3.py +++ b/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/models/_models_py3.py @@ -1,4 +1,5 @@ # coding=utf-8 +# pylint: disable=too-many-lines # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for license information. @@ -6,88 +7,103 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import List, Optional, Union +from typing import List, Optional, TYPE_CHECKING, Union -import msrest.serialization +from .. import _serialization -from ._azure_communication_sms_service_enums import * +if TYPE_CHECKING: + # pylint: disable=unused-import,ungrouped-imports + from .. import models as _models -class SendMessageRequest(msrest.serialization.Model): +class SendMessageRequest(_serialization.Model): """Represents the properties of a send message request. All required parameters must be populated in order to send to Azure. - :param from_property: Required. The sender's phone number in E.164 format that is owned by the - authenticated account. - :type from_property: str - :param sms_recipients: Required. The recipient's phone number in E.164 format. In this version, - a minimum of 1 and upto 100 recipients in the list are supported. - :type sms_recipients: list[~azure.communication.sms.models.SmsRecipient] - :param message: Required. The contents of the message that will be sent to the recipient. The - allowable content is defined by RFC 5724. - :type message: str - :param sms_send_options: Optional configuration for sending SMS messages. - :type sms_send_options: ~azure.communication.sms.models.SmsSendOptions + :ivar from_property: The sender's phone number in E.164 format that is owned by the + authenticated account. Required. + :vartype from_property: str + :ivar sms_recipients: The recipient's phone number in E.164 format. In this version, a minimum + of 1 and upto 100 recipients in the list are supported. Required. + :vartype sms_recipients: list[~azure.communication.sms.models.SmsRecipient] + :ivar message: The contents of the message that will be sent to the recipient. The allowable + content is defined by RFC 5724. Required. + :vartype message: str + :ivar sms_send_options: Optional configuration for sending SMS messages. + :vartype sms_send_options: ~azure.communication.sms.models.SmsSendOptions """ _validation = { - 'from_property': {'required': True}, - 'sms_recipients': {'required': True}, - 'message': {'required': True, 'max_length': 2048, 'min_length': 0}, + "from_property": {"required": True}, + "sms_recipients": {"required": True}, + "message": {"required": True, "max_length": 2048}, } _attribute_map = { - 'from_property': {'key': 'from', 'type': 'str'}, - 'sms_recipients': {'key': 'smsRecipients', 'type': '[SmsRecipient]'}, - 'message': {'key': 'message', 'type': 'str'}, - 'sms_send_options': {'key': 'smsSendOptions', 'type': 'SmsSendOptions'}, + "from_property": {"key": "from", "type": "str"}, + "sms_recipients": {"key": "smsRecipients", "type": "[SmsRecipient]"}, + "message": {"key": "message", "type": "str"}, + "sms_send_options": {"key": "smsSendOptions", "type": "SmsSendOptions"}, } def __init__( self, *, from_property: str, - sms_recipients: List["SmsRecipient"], + sms_recipients: List["_models.SmsRecipient"], message: str, - sms_send_options: Optional["SmsSendOptions"] = None, + sms_send_options: Optional["_models.SmsSendOptions"] = None, **kwargs ): - super(SendMessageRequest, self).__init__(**kwargs) + """ + :keyword from_property: The sender's phone number in E.164 format that is owned by the + authenticated account. Required. + :paramtype from_property: str + :keyword sms_recipients: The recipient's phone number in E.164 format. In this version, a + minimum of 1 and upto 100 recipients in the list are supported. Required. + :paramtype sms_recipients: list[~azure.communication.sms.models.SmsRecipient] + :keyword message: The contents of the message that will be sent to the recipient. The allowable + content is defined by RFC 5724. Required. + :paramtype message: str + :keyword sms_send_options: Optional configuration for sending SMS messages. + :paramtype sms_send_options: ~azure.communication.sms.models.SmsSendOptions + """ + super().__init__(**kwargs) self.from_property = from_property self.sms_recipients = sms_recipients self.message = message self.sms_send_options = sms_send_options -class SmsRecipient(msrest.serialization.Model): +class SmsRecipient(_serialization.Model): """Recipient details for sending SMS messages. All required parameters must be populated in order to send to Azure. - :param to: Required. The recipient's phone number in E.164 format. - :type to: str - :param repeatability_request_id: If specified, the client directs that the request is + :ivar to: The recipient's phone number in E.164 format. Required. + :vartype to: str + :ivar repeatability_request_id: If specified, the client directs that the request is repeatable; that is, the client can make the request multiple times with the same Repeatability-Request-ID and get back an appropriate response without the server executing the request multiple times. The value of the Repeatability-Request-ID is an opaque string representing a client-generated, 36-character hexadecimal case-insensitive encoding of a UUID (GUID), identifier for the request. - :type repeatability_request_id: str - :param repeatability_first_sent: MUST be sent by clients to specify that a request is + :vartype repeatability_request_id: str + :ivar repeatability_first_sent: MUST be sent by clients to specify that a request is repeatable. Repeatability-First-Sent is used to specify the date and time at which the request was first created.eg- Tue, 26 Mar 2019 16:06:51 GMT. - :type repeatability_first_sent: str + :vartype repeatability_first_sent: str """ _validation = { - 'to': {'required': True}, + "to": {"required": True}, } _attribute_map = { - 'to': {'key': 'to', 'type': 'str'}, - 'repeatability_request_id': {'key': 'repeatabilityRequestId', 'type': 'str'}, - 'repeatability_first_sent': {'key': 'repeatabilityFirstSent', 'type': 'str'}, + "to": {"key": "to", "type": "str"}, + "repeatability_request_id": {"key": "repeatabilityRequestId", "type": "str"}, + "repeatability_first_sent": {"key": "repeatabilityFirstSent", "type": "str"}, } def __init__( @@ -98,108 +114,124 @@ def __init__( repeatability_first_sent: Optional[str] = None, **kwargs ): - super(SmsRecipient, self).__init__(**kwargs) + """ + :keyword to: The recipient's phone number in E.164 format. Required. + :paramtype to: str + :keyword repeatability_request_id: If specified, the client directs that the request is + repeatable; that is, the client can make the request multiple times with the same + Repeatability-Request-ID and get back an appropriate response without the server executing the + request multiple times. The value of the Repeatability-Request-ID is an opaque string + representing a client-generated, 36-character hexadecimal case-insensitive encoding of a UUID + (GUID), identifier for the request. + :paramtype repeatability_request_id: str + :keyword repeatability_first_sent: MUST be sent by clients to specify that a request is + repeatable. Repeatability-First-Sent is used to specify the date and time at which the request + was first created.eg- Tue, 26 Mar 2019 16:06:51 GMT. + :paramtype repeatability_first_sent: str + """ + super().__init__(**kwargs) self.to = to self.repeatability_request_id = repeatability_request_id self.repeatability_first_sent = repeatability_first_sent -class SmsSendOptions(msrest.serialization.Model): +class SmsSendOptions(_serialization.Model): """Optional configuration for sending SMS messages. All required parameters must be populated in order to send to Azure. - :param enable_delivery_report: Required. Enable this flag to receive a delivery report for this - message on the Azure Resource EventGrid. - :type enable_delivery_report: bool - :param tag: Use this field to provide metadata that will then be sent back in the corresponding + :ivar enable_delivery_report: Enable this flag to receive a delivery report for this message on + the Azure Resource EventGrid. Required. + :vartype enable_delivery_report: bool + :ivar tag: Use this field to provide metadata that will then be sent back in the corresponding Delivery Report. - :type tag: str + :vartype tag: str """ _validation = { - 'enable_delivery_report': {'required': True}, + "enable_delivery_report": {"required": True}, } _attribute_map = { - 'enable_delivery_report': {'key': 'enableDeliveryReport', 'type': 'bool'}, - 'tag': {'key': 'tag', 'type': 'str'}, + "enable_delivery_report": {"key": "enableDeliveryReport", "type": "bool"}, + "tag": {"key": "tag", "type": "str"}, } - def __init__( - self, - *, - enable_delivery_report: bool, - tag: Optional[str] = None, - **kwargs - ): - super(SmsSendOptions, self).__init__(**kwargs) + def __init__(self, *, enable_delivery_report: bool, tag: Optional[str] = None, **kwargs): + """ + :keyword enable_delivery_report: Enable this flag to receive a delivery report for this message + on the Azure Resource EventGrid. Required. + :paramtype enable_delivery_report: bool + :keyword tag: Use this field to provide metadata that will then be sent back in the + corresponding Delivery Report. + :paramtype tag: str + """ + super().__init__(**kwargs) self.enable_delivery_report = enable_delivery_report self.tag = tag -class SmsSendResponse(msrest.serialization.Model): +class SmsSendResponse(_serialization.Model): """Response for a successful or multi status send Sms request. All required parameters must be populated in order to send to Azure. - :param value: Required. - :type value: list[~azure.communication.sms.models.SmsSendResponseItem] + :ivar value: Required. + :vartype value: list[~azure.communication.sms.models.SmsSendResponseItem] """ _validation = { - 'value': {'required': True}, + "value": {"required": True}, } _attribute_map = { - 'value': {'key': 'value', 'type': '[SmsSendResponseItem]'}, + "value": {"key": "value", "type": "[SmsSendResponseItem]"}, } - def __init__( - self, - *, - value: List["SmsSendResponseItem"], - **kwargs - ): - super(SmsSendResponse, self).__init__(**kwargs) + def __init__(self, *, value: List["_models.SmsSendResponseItem"], **kwargs): + """ + :keyword value: Required. + :paramtype value: list[~azure.communication.sms.models.SmsSendResponseItem] + """ + super().__init__(**kwargs) self.value = value -class SmsSendResponseItem(msrest.serialization.Model): +class SmsSendResponseItem(_serialization.Model): """Response for a single recipient. All required parameters must be populated in order to send to Azure. - :param to: Required. The recipient's phone number in E.164 format. - :type to: str - :param message_id: The identifier of the outgoing Sms message. Only present if message + :ivar to: The recipient's phone number in E.164 format. Required. + :vartype to: str + :ivar message_id: The identifier of the outgoing Sms message. Only present if message processed. - :type message_id: str - :param http_status_code: Required. HTTP Status code. - :type http_status_code: int - :param repeatability_result: The result of a repeatable request with one of the - case-insensitive values accepted or rejected. Possible values include: "accepted", "rejected". - :type repeatability_result: str or + :vartype message_id: str + :ivar http_status_code: HTTP Status code. Required. + :vartype http_status_code: int + :ivar repeatability_result: The result of a repeatable request with one of the case-insensitive + values accepted or rejected. Known values are: "accepted" and "rejected". + :vartype repeatability_result: str or ~azure.communication.sms.models.SmsSendResponseItemRepeatabilityResult - :param successful: Required. Indicates if the message is processed successfully or not. - :type successful: bool - :param error_message: Optional error message in case of 4xx/5xx/repeatable errors. - :type error_message: str + :ivar successful: Indicates if the message is processed successfully or not. Required. + :vartype successful: bool + :ivar error_message: Optional error message in case of 4xx/5xx/repeatable errors. + :vartype error_message: str """ _validation = { - 'to': {'required': True}, - 'http_status_code': {'required': True}, - 'successful': {'required': True}, + "to": {"required": True}, + "http_status_code": {"required": True}, + "successful": {"required": True}, } _attribute_map = { - 'to': {'key': 'to', 'type': 'str'}, - 'message_id': {'key': 'messageId', 'type': 'str'}, - 'http_status_code': {'key': 'httpStatusCode', 'type': 'int'}, - 'repeatability_result': {'key': 'repeatabilityResult', 'type': 'str'}, - 'successful': {'key': 'successful', 'type': 'bool'}, - 'error_message': {'key': 'errorMessage', 'type': 'str'}, + "to": {"key": "to", "type": "str"}, + "message_id": {"key": "messageId", "type": "str"}, + "http_status_code": {"key": "httpStatusCode", "type": "int"}, + "repeatability_result": {"key": "repeatabilityResult", "type": "str"}, + "successful": {"key": "successful", "type": "bool"}, + "error_message": {"key": "errorMessage", "type": "str"}, } def __init__( @@ -209,11 +241,28 @@ def __init__( http_status_code: int, successful: bool, message_id: Optional[str] = None, - repeatability_result: Optional[Union[str, "SmsSendResponseItemRepeatabilityResult"]] = None, + repeatability_result: Optional[Union[str, "_models.SmsSendResponseItemRepeatabilityResult"]] = None, error_message: Optional[str] = None, **kwargs ): - super(SmsSendResponseItem, self).__init__(**kwargs) + """ + :keyword to: The recipient's phone number in E.164 format. Required. + :paramtype to: str + :keyword message_id: The identifier of the outgoing Sms message. Only present if message + processed. + :paramtype message_id: str + :keyword http_status_code: HTTP Status code. Required. + :paramtype http_status_code: int + :keyword repeatability_result: The result of a repeatable request with one of the + case-insensitive values accepted or rejected. Known values are: "accepted" and "rejected". + :paramtype repeatability_result: str or + ~azure.communication.sms.models.SmsSendResponseItemRepeatabilityResult + :keyword successful: Indicates if the message is processed successfully or not. Required. + :paramtype successful: bool + :keyword error_message: Optional error message in case of 4xx/5xx/repeatable errors. + :paramtype error_message: str + """ + super().__init__(**kwargs) self.to = to self.message_id = message_id self.http_status_code = http_status_code diff --git a/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/models/_patch.py b/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/models/_patch.py new file mode 100644 index 000000000000..f7dd32510333 --- /dev/null +++ b/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/models/_patch.py @@ -0,0 +1,20 @@ +# ------------------------------------ +# Copyright (c) Microsoft Corporation. +# Licensed under the MIT License. +# ------------------------------------ +"""Customize generated code here. + +Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize +""" +from typing import List + +__all__: List[str] = [] # Add all objects you want publicly available to users at this package level + + +def patch_sdk(): + """Do not remove from this file. + + `patch_sdk` is a last resort escape hatch that allows you to do customizations + you can't accomplish using the techniques described in + https://aka.ms/azsdk/python/dpcodegen/python/customize + """ diff --git a/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/operations/__init__.py b/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/operations/__init__.py index f9ce203e2885..96d0f1292ecb 100644 --- a/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/operations/__init__.py +++ b/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/operations/__init__.py @@ -8,6 +8,12 @@ from ._sms_operations import SmsOperations +from ._patch import __all__ as _patch_all +from ._patch import * # type: ignore # pylint: disable=unused-wildcard-import +from ._patch import patch_sdk as _patch_sdk + __all__ = [ - 'SmsOperations', + "SmsOperations", ] +__all__.extend([p for p in _patch_all if p not in __all__]) +_patch_sdk() diff --git a/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/operations/_patch.py b/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/operations/_patch.py new file mode 100644 index 000000000000..f7dd32510333 --- /dev/null +++ b/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/operations/_patch.py @@ -0,0 +1,20 @@ +# ------------------------------------ +# Copyright (c) Microsoft Corporation. +# Licensed under the MIT License. +# ------------------------------------ +"""Customize generated code here. + +Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize +""" +from typing import List + +__all__: List[str] = [] # Add all objects you want publicly available to users at this package level + + +def patch_sdk(): + """Do not remove from this file. + + `patch_sdk` is a last resort escape hatch that allows you to do customizations + you can't accomplish using the techniques described in + https://aka.ms/azsdk/python/dpcodegen/python/customize + """ diff --git a/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/operations/_sms_operations.py b/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/operations/_sms_operations.py index 1f0d0640e125..9248c59115e9 100644 --- a/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/operations/_sms_operations.py +++ b/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/operations/_sms_operations.py @@ -1,3 +1,4 @@ +# pylint: disable=too-many-lines # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -5,101 +6,184 @@ # 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 TYPE_CHECKING -import warnings - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from typing import Any, Callable, Dict, IO, Optional, TypeVar, Union, overload + +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + map_error, +) from azure.core.pipeline import PipelineResponse -from azure.core.pipeline.transport import HttpRequest, HttpResponse +from azure.core.pipeline.transport import HttpResponse +from azure.core.rest import HttpRequest +from azure.core.tracing.decorator import distributed_trace +from azure.core.utils import case_insensitive_dict from .. import models as _models +from .._serialization import Serializer +from .._vendor import _convert_request + +T = TypeVar("T") +ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] + +_SERIALIZER = Serializer() +_SERIALIZER.client_side_validation = False + + +def build_send_request(**kwargs: Any) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-03-07")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + accept = _headers.pop("Accept", "application/json") + + # Construct URL + _url = kwargs.pop("template_url", "/sms") + + # Construct parameters + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") -if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports - from typing import Any, Callable, Dict, Generic, Optional, TypeVar + # Construct headers + if content_type is not None: + _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - T = TypeVar('T') - ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] + return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs) -class SmsOperations(object): - """SmsOperations operations. - You should not instantiate this class directly. Instead, you should create a Client instance that - instantiates it for you and attaches it as an attribute. +class SmsOperations: + """ + .. warning:: + **DO NOT** instantiate this class directly. - :ivar models: Alias to model classes used in this operation group. - :type models: ~azure.communication.sms.models - :param client: Client for service requests. - :param config: Configuration of service client. - :param serializer: An object model serializer. - :param deserializer: An object model deserializer. + Instead, you should access the following operations through + :class:`~azure.communication.sms.AzureCommunicationSMSService`'s + :attr:`sms` attribute. """ models = _models - def __init__(self, client, config, serializer, deserializer): - self._client = client - self._serialize = serializer - self._deserialize = deserializer - self._config = config + def __init__(self, *args, **kwargs): + input_args = list(args) + self._client = input_args.pop(0) if input_args else kwargs.pop("client") + self._config = input_args.pop(0) if input_args else kwargs.pop("config") + self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") + self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") + @overload def send( - self, - send_message_request, # type: "_models.SendMessageRequest" - **kwargs # type: Any - ): - # type: (...) -> "_models.SmsSendResponse" + self, send_message_request: _models.SendMessageRequest, *, content_type: str = "application/json", **kwargs: Any + ) -> _models.SmsSendResponse: """Sends a SMS message from a phone number that belongs to the authenticated account. Sends a SMS message from a phone number that belongs to the authenticated account. - :param send_message_request: Represents the body of the send message request. + :param send_message_request: Represents the body of the send message request. Required. :type send_message_request: ~azure.communication.sms.models.SendMessageRequest + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: SmsSendResponse, or the result of cls(response) + :return: SmsSendResponse or the result of cls(response) :rtype: ~azure.communication.sms.models.SmsSendResponse - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def send( + self, send_message_request: IO, *, content_type: str = "application/json", **kwargs: Any + ) -> _models.SmsSendResponse: + """Sends a SMS message from a phone number that belongs to the authenticated account. + + Sends a SMS message from a phone number that belongs to the authenticated account. + + :param send_message_request: Represents the body of the send message request. Required. + :type send_message_request: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: SmsSendResponse or the result of cls(response) + :rtype: ~azure.communication.sms.models.SmsSendResponse + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace + def send( + self, send_message_request: Union[_models.SendMessageRequest, IO], **kwargs: Any + ) -> _models.SmsSendResponse: + """Sends a SMS message from a phone number that belongs to the authenticated account. + + Sends a SMS message from a phone number that belongs to the authenticated account. + + :param send_message_request: Represents the body of the send message request. Is either a model + type or a IO type. Required. + :type send_message_request: ~azure.communication.sms.models.SendMessageRequest or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :return: SmsSendResponse or the result of cls(response) + :rtype: ~azure.communication.sms.models.SmsSendResponse + :raises ~azure.core.exceptions.HttpResponseError: """ - cls = kwargs.pop('cls', None) # type: ClsType["_models.SmsSendResponse"] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {})) - api_version = "2021-03-07" - content_type = kwargs.pop("content_type", "application/json") - accept = "application/json" - - # Construct URL - url = self.send.metadata['url'] # type: ignore + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.SmsSendResponse] + + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(send_message_request, (IO, bytes)): + _content = send_message_request + else: + _json = self._serialize.body(send_message_request, "SendMessageRequest") + + request = build_send_request( + api_version=api_version, + content_type=content_type, + json=_json, + content=_content, + template_url=self.send.metadata["url"], + headers=_headers, + params=_params, + ) + request = _convert_request(request) path_format_arguments = { - 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), + "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), } - url = self._client.format_url(url, **path_format_arguments) - - # Construct parameters - query_parameters = {} # type: Dict[str, Any] - query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') - - # Construct headers - header_parameters = {} # type: Dict[str, Any] - header_parameters['Content-Type'] = self._serialize.header("content_type", content_type, 'str') - header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') - - body_content_kwargs = {} # type: Dict[str, Any] - body_content = self._serialize.body(send_message_request, 'SendMessageRequest') - body_content_kwargs['content'] = body_content - request = self._client.post(url, query_parameters, header_parameters, **body_content_kwargs) - pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs) + request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore + + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) + response = pipeline_response.http_response if response.status_code not in [202]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response) - deserialized = self._deserialize('SmsSendResponse', pipeline_response) + deserialized = self._deserialize("SmsSendResponse", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - send.metadata = {'url': '/sms'} # type: ignore + + send.metadata = {"url": "/sms"} # type: ignore diff --git a/sdk/communication/azure-communication-sms/azure/communication/sms/_sms_client.py b/sdk/communication/azure-communication-sms/azure/communication/sms/_sms_client.py index 05f244208467..b9a10ce1d396 100644 --- a/sdk/communication/azure-communication-sms/azure/communication/sms/_sms_client.py +++ b/sdk/communication/azure-communication-sms/azure/communication/sms/_sms_client.py @@ -16,8 +16,9 @@ from ._generated._azure_communication_sms_service import AzureCommunicationSMSService from ._shared.utils import parse_connection_str, get_authentication_policy, get_current_utc_time from ._version import SDK_MONIKER +from ._api_versions import DEFAULT_VERSION -class SmsClient(object): # pylint: disable=client-accepts-api-version-keyword +class SmsClient(object): """A client to interact with the AzureCommunicationService Sms gateway. This client provides operations to send an SMS via a phone number. @@ -26,6 +27,9 @@ class SmsClient(object): # pylint: disable=client-accepts-api-version-keyword The endpoint url for Azure Communication Service resource. :param TokenCredential credential: The TokenCredential we use to authenticate against the service. + :keyword api_version: Api Version. The default value is "2021-03-07". Note that + overriding this default value may result in unsupported behavior. + :paramtype api_version: str """ def __init__( self, endpoint, # type: str @@ -44,9 +48,11 @@ def __init__( "invalid credential from connection string.") self._endpoint = endpoint + self._api_version = kwargs.pop("api_version", DEFAULT_VERSION) self._authentication_policy = get_authentication_policy(endpoint, credential) self._sms_service_client = AzureCommunicationSMSService( self._endpoint, + api_version=self._api_version, authentication_policy=self._authentication_policy, sdk_moniker=SDK_MONIKER, **kwargs) diff --git a/sdk/communication/azure-communication-sms/azure/communication/sms/aio/_sms_client_async.py b/sdk/communication/azure-communication-sms/azure/communication/sms/aio/_sms_client_async.py index 1d78278fb9be..50e9aec785ac 100644 --- a/sdk/communication/azure-communication-sms/azure/communication/sms/aio/_sms_client_async.py +++ b/sdk/communication/azure-communication-sms/azure/communication/sms/aio/_sms_client_async.py @@ -11,13 +11,14 @@ SmsRecipient, SmsSendOptions, ) -from azure.communication.sms._models import SmsSendResult +from .._models import SmsSendResult from .._generated.aio._azure_communication_sms_service import AzureCommunicationSMSService from .._shared.utils import parse_connection_str, get_authentication_policy, get_current_utc_time from .._version import SDK_MONIKER +from .._api_versions import DEFAULT_VERSION -class SmsClient(object): # pylint: disable=client-accepts-api-version-keyword +class SmsClient(object): """A client to interact with the AzureCommunicationService Sms gateway asynchronously. This client provides operations to send an SMS via a phone number. @@ -26,6 +27,9 @@ class SmsClient(object): # pylint: disable=client-accepts-api-version-keyword The endpoint url for Azure Communication Service resource. :param AsyncTokenCredential credential: The AsyncTokenCredential we use to authenticate against the service. + :keyword api_version: Api Version. The default value is "2021-03-07". Note that + overriding this default value may result in unsupported behavior. + :paramtype api_version: str """ def __init__( self, endpoint, # type: str @@ -44,10 +48,12 @@ def __init__( "invalid credential from connection string.") self._endpoint = endpoint + self._api_version = kwargs.pop("api_version", DEFAULT_VERSION) self._authentication_policy = get_authentication_policy(endpoint, credential, decode_url=True, is_async=True) self._sms_service_client = AzureCommunicationSMSService( self._endpoint, + api_version=self._api_version, authentication_policy=self._authentication_policy, sdk_moniker=SDK_MONIKER, **kwargs) From b969f150f66c8485436c58dd44d72a1d618abb5b Mon Sep 17 00:00:00 2001 From: Olena Stoliarova Date: Tue, 27 Sep 2022 15:49:43 +0300 Subject: [PATCH 04/19] fixing failing tests --- .../azure/communication/chat/_chat_client.py | 13 +++++++------ .../communication/chat/_chat_thread_client.py | 16 ++++++++-------- .../communication/chat/aio/_chat_client_async.py | 8 +++++--- .../chat/aio/_chat_thread_client_async.py | 11 ++++++----- 4 files changed, 26 insertions(+), 22 deletions(-) diff --git a/sdk/communication/azure-communication-chat/azure/communication/chat/_chat_client.py b/sdk/communication/azure-communication-chat/azure/communication/chat/_chat_client.py index 801348cbbee2..65bf5d15854e 100644 --- a/sdk/communication/azure-communication-chat/azure/communication/chat/_chat_client.py +++ b/sdk/communication/azure-communication-chat/azure/communication/chat/_chat_client.py @@ -3,15 +3,15 @@ # Licensed under the MIT License. See License.txt in the project root for # license information. # -------------------------------------------------------------------------- -from typing import TYPE_CHECKING +from typing import TYPE_CHECKING, Union from uuid import uuid4 from urllib.parse import urlparse +from azure.core.credentials import TokenCredential, AzureKeyCredential from azure.core.tracing.decorator import distributed_trace from azure.core.pipeline.policies import BearerTokenCredentialPolicy from ._chat_thread_client import ChatThreadClient -from ._shared.user_credential import CommunicationTokenCredential from ._generated import AzureCommunicationChatService from ._generated.models import CreateChatThreadRequest from ._models import ( @@ -28,7 +28,7 @@ if TYPE_CHECKING: # pylint: disable=unused-import,ungrouped-imports - from typing import Any, Callable, Dict, Generic, List, Optional, TypeVar, Union + from typing import Any, Callable, Dict, Generic, List, Optional, TypeVar from datetime import datetime from azure.core.paging import ItemPaged @@ -41,8 +41,8 @@ class ChatClient(object): :param str endpoint: The endpoint of the Azure Communication resource. - :param CommunicationTokenCredential credential: - The credentials with which to authenticate. + :param Union[TokenCredential, AzureKeyCredential] credential: + The credential we use to authenticate against the service. :keyword api_version: Api Version. Default value is "2021-09-07". Note that overriding this default value may result in unsupported behavior. @@ -61,7 +61,7 @@ class ChatClient(object): def __init__( self, endpoint, # type: str - credential, # type: CommunicationTokenCredential + credential: Union[TokenCredential, AzureKeyCredential], **kwargs # type: Any ): # type: (...) -> None @@ -83,6 +83,7 @@ def __init__( self._credential = credential self._client = AzureCommunicationChatService( + self._credential, self._endpoint, api_version=self._api_version, authentication_policy=BearerTokenCredentialPolicy(self._credential), diff --git a/sdk/communication/azure-communication-chat/azure/communication/chat/_chat_thread_client.py b/sdk/communication/azure-communication-chat/azure/communication/chat/_chat_thread_client.py index b8ecc112b55e..6efc1d11ac81 100644 --- a/sdk/communication/azure-communication-chat/azure/communication/chat/_chat_thread_client.py +++ b/sdk/communication/azure-communication-chat/azure/communication/chat/_chat_thread_client.py @@ -3,14 +3,14 @@ # Licensed under the MIT License. See License.txt in the project root for # license information. # -------------------------------------------------------------------------- -from typing import TYPE_CHECKING +from typing import TYPE_CHECKING, Union from urllib.parse import urlparse +from azure.core.credentials import TokenCredential, AzureKeyCredential from azure.core.tracing.decorator import distributed_trace from azure.core.pipeline.policies import BearerTokenCredentialPolicy -from ._shared.user_credential import CommunicationTokenCredential from ._shared.models import CommunicationIdentifier from ._generated import AzureCommunicationChatService from ._generated.models import ( @@ -37,7 +37,7 @@ if TYPE_CHECKING: # pylint: disable=unused-import,ungrouped-imports - from typing import Any, Callable, Dict, Generic, List, Optional, TypeVar, Union, Tuple + from typing import Any, Callable, Dict, Generic, List, Optional, TypeVar, Tuple from datetime import datetime from azure.core.paging import ItemPaged @@ -55,9 +55,8 @@ class ChatThreadClient(object): :param str endpoint: The endpoint of the Azure Communication resource. - :param CommunicationTokenCredential credential: - The credentials with which to authenticate. The value contains a User - Access Token + :param Union[TokenCredential, AzureKeyCredential] credential: + The credential we use to authenticate against the service. :param str thread_id: The unique thread id. @@ -78,7 +77,7 @@ class ChatThreadClient(object): def __init__( self, endpoint, # type: str - credential, # type: CommunicationTokenCredential + credential: Union[TokenCredential, AzureKeyCredential], thread_id, # type: str **kwargs # type: Any ): @@ -105,7 +104,8 @@ def __init__( self._credential = credential self._client = AzureCommunicationChatService( - endpoint, + self._credential, + self._endpoint, api_version=self._api_version, authentication_policy=BearerTokenCredentialPolicy(self._credential), sdk_moniker=SDK_MONIKER, diff --git a/sdk/communication/azure-communication-chat/azure/communication/chat/aio/_chat_client_async.py b/sdk/communication/azure-communication-chat/azure/communication/chat/aio/_chat_client_async.py index 3a46f77e6377..4efe6085a889 100644 --- a/sdk/communication/azure-communication-chat/azure/communication/chat/aio/_chat_client_async.py +++ b/sdk/communication/azure-communication-chat/azure/communication/chat/aio/_chat_client_async.py @@ -11,6 +11,7 @@ from uuid import uuid4 import six +from azure.core.credentials import TokenCredential, AzureKeyCredential from azure.core.tracing.decorator import distributed_trace from azure.core.tracing.decorator_async import distributed_trace_async from azure.core.pipeline.policies import AsyncBearerTokenCredentialPolicy @@ -45,8 +46,8 @@ class ChatClient(object): :param str endpoint: The endpoint of the Azure Communication resource. - :param CommunicationTokenCredential credential: - The credentials with which to authenticate. + :param Union[TokenCredential, AzureKeyCredential] credential: + The credential we use to authenticate against the service. :keyword api_version: Api Version. Default value is "2021-09-07". Note that overriding this default value may result in unsupported behavior. @@ -64,7 +65,7 @@ class ChatClient(object): def __init__( self, endpoint: str, - credential: CommunicationTokenCredential, + credential: Union[TokenCredential, AzureKeyCredential], **kwargs: Any ) -> None: # type: (...) -> None @@ -87,6 +88,7 @@ def __init__( self._credential = credential self._client = AzureCommunicationChatService( + self._credential, self._endpoint, api_version=self._api_version, authentication_policy=AsyncBearerTokenCredentialPolicy(self._credential), diff --git a/sdk/communication/azure-communication-chat/azure/communication/chat/aio/_chat_thread_client_async.py b/sdk/communication/azure-communication-chat/azure/communication/chat/aio/_chat_thread_client_async.py index c5e7285307d3..1d8ad1942895 100644 --- a/sdk/communication/azure-communication-chat/azure/communication/chat/aio/_chat_thread_client_async.py +++ b/sdk/communication/azure-communication-chat/azure/communication/chat/aio/_chat_thread_client_async.py @@ -10,6 +10,7 @@ from datetime import datetime import six +from azure.core.credentials import TokenCredential, AzureKeyCredential from azure.core.tracing.decorator import distributed_trace from azure.core.tracing.decorator_async import distributed_trace_async from azure.core.pipeline.policies import AsyncBearerTokenCredentialPolicy @@ -54,9 +55,8 @@ class ChatThreadClient(object): :param str endpoint: The endpoint of the Azure Communication resource. - :param CommunicationTokenCredential credential: - The credentials with which to authenticate. The value contains a User - Access Token + :param Union[TokenCredential, AzureKeyCredential] credential: + The credential we use to authenticate against the service. :param str thread_id: The unique thread id. @@ -77,7 +77,7 @@ class ChatThreadClient(object): def __init__( self, endpoint: str, - credential: CommunicationTokenCredential, + credential: Union[TokenCredential, AzureKeyCredential], thread_id: str, **kwargs: Any ): # type: (...) -> None @@ -103,7 +103,8 @@ def __init__( self._credential = credential self._client = AzureCommunicationChatService( - endpoint, + self._credential, + self._endpoint, api_version=self._api_version, authentication_policy=AsyncBearerTokenCredentialPolicy(self._credential), sdk_moniker=SDK_MONIKER, From b0f3aa7d44d8ddfb7fc0e23efe3847ce4d70c862 Mon Sep 17 00:00:00 2001 From: Olena Stoliarova Date: Tue, 27 Sep 2022 16:47:03 +0300 Subject: [PATCH 05/19] specifying exact commit for chat swagger --- sdk/communication/azure-communication-chat/swagger/SWAGGER.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sdk/communication/azure-communication-chat/swagger/SWAGGER.md b/sdk/communication/azure-communication-chat/swagger/SWAGGER.md index 5631017f096c..093f2c29b6a1 100644 --- a/sdk/communication/azure-communication-chat/swagger/SWAGGER.md +++ b/sdk/communication/azure-communication-chat/swagger/SWAGGER.md @@ -17,7 +17,7 @@ autorest SWAGGER.md ```yaml tag: package-chat-2021-09-07 -require: https://raw.githubusercontent.com/Azure/azure-rest-api-specs/main/specification/communication/data-plane/Chat/readme.md +require: https://raw.githubusercontent.com/Azure/azure-rest-api-specs/8dbeba81f3a838cd4b7efd70234f29cc1cdc7374/specification/communication/data-plane/Chat/readme.md output-folder: ../azure/communication/chat/_generated namespace: azure.communication.chat no-namespace-folders: true From e8f1fc350b57c35c780ffa183c06f5ea00d10083 Mon Sep 17 00:00:00 2001 From: Olena Stoliarova Date: Fri, 30 Sep 2022 14:29:33 +0300 Subject: [PATCH 06/19] making comments more precise and fixing pylint warnings for jobrouter --- .../azure/communication/chat/_chat_client.py | 2 +- .../azure/communication/chat/_chat_thread_client.py | 2 +- .../communication/chat/aio/_chat_client_async.py | 2 +- .../chat/aio/_chat_thread_client_async.py | 2 +- .../azure/communication/email/_email_client.py | 2 +- .../communication/email/aio/_email_client_async.py | 2 +- .../identity/_communication_identity_client.py | 2 +- .../aio/_communication_identity_client_async.py | 2 +- .../azure/communication/jobrouter/_api_versions.py | 5 ++--- .../jobrouter/_router_administration_client.py | 12 ++++++++---- .../aio/_router_administration_client_async.py | 7 +++++-- .../networktraversal/_communication_relay_client.py | 2 +- .../aio/_communication_relay_client_async.py | 2 +- .../phonenumbers/_phone_numbers_client.py | 2 +- .../phonenumbers/aio/_phone_numbers_client_async.py | 2 +- .../azure/communication/rooms/_rooms_client.py | 2 +- .../communication/rooms/aio/_rooms_client_async.py | 2 +- .../azure/communication/sms/_sms_client.py | 2 +- .../azure/communication/sms/aio/_sms_client_async.py | 2 +- 19 files changed, 31 insertions(+), 25 deletions(-) diff --git a/sdk/communication/azure-communication-chat/azure/communication/chat/_chat_client.py b/sdk/communication/azure-communication-chat/azure/communication/chat/_chat_client.py index 65bf5d15854e..c7591bbff88c 100644 --- a/sdk/communication/azure-communication-chat/azure/communication/chat/_chat_client.py +++ b/sdk/communication/azure-communication-chat/azure/communication/chat/_chat_client.py @@ -44,7 +44,7 @@ class ChatClient(object): :param Union[TokenCredential, AzureKeyCredential] credential: The credential we use to authenticate against the service. - :keyword api_version: Api Version. Default value is "2021-09-07". Note that overriding this + :keyword api_version: Azure Communication Chat API version. Default value is "2021-09-07". Note that overriding this default value may result in unsupported behavior. :paramtype api_version: str diff --git a/sdk/communication/azure-communication-chat/azure/communication/chat/_chat_thread_client.py b/sdk/communication/azure-communication-chat/azure/communication/chat/_chat_thread_client.py index 6efc1d11ac81..ce3c643fad86 100644 --- a/sdk/communication/azure-communication-chat/azure/communication/chat/_chat_thread_client.py +++ b/sdk/communication/azure-communication-chat/azure/communication/chat/_chat_thread_client.py @@ -60,7 +60,7 @@ class ChatThreadClient(object): :param str thread_id: The unique thread id. - :keyword api_version: Api Version. Default value is "2021-09-07". Note that overriding this + :keyword api_version: Azure Communication Chat API version. Default value is "2021-09-07". Note that overriding this default value may result in unsupported behavior. :paramtype api_version: str diff --git a/sdk/communication/azure-communication-chat/azure/communication/chat/aio/_chat_client_async.py b/sdk/communication/azure-communication-chat/azure/communication/chat/aio/_chat_client_async.py index 4efe6085a889..15e640156bfc 100644 --- a/sdk/communication/azure-communication-chat/azure/communication/chat/aio/_chat_client_async.py +++ b/sdk/communication/azure-communication-chat/azure/communication/chat/aio/_chat_client_async.py @@ -49,7 +49,7 @@ class ChatClient(object): :param Union[TokenCredential, AzureKeyCredential] credential: The credential we use to authenticate against the service. - :keyword api_version: Api Version. Default value is "2021-09-07". Note that overriding this + :keyword api_version: Azure Communication Chat API version. Default value is "2021-09-07". Note that overriding this default value may result in unsupported behavior. :paramtype api_version: str diff --git a/sdk/communication/azure-communication-chat/azure/communication/chat/aio/_chat_thread_client_async.py b/sdk/communication/azure-communication-chat/azure/communication/chat/aio/_chat_thread_client_async.py index 1d8ad1942895..046861de6c93 100644 --- a/sdk/communication/azure-communication-chat/azure/communication/chat/aio/_chat_thread_client_async.py +++ b/sdk/communication/azure-communication-chat/azure/communication/chat/aio/_chat_thread_client_async.py @@ -60,7 +60,7 @@ class ChatThreadClient(object): :param str thread_id: The unique thread id. - :keyword api_version: Api Version. Default value is "2021-09-07". Note that overriding this + :keyword api_version: Azure Communication Chat API version. Default value is "2021-09-07". Note that overriding this default value may result in unsupported behavior. :paramtype api_version: str diff --git a/sdk/communication/azure-communication-email/azure/communication/email/_email_client.py b/sdk/communication/azure-communication-email/azure/communication/email/_email_client.py index df9ac66455c0..5793aa9afce6 100644 --- a/sdk/communication/azure-communication-email/azure/communication/email/_email_client.py +++ b/sdk/communication/azure-communication-email/azure/communication/email/_email_client.py @@ -26,7 +26,7 @@ class EmailClient(object): The endpoint url for Azure Communication Service resource. :param Union[TokenCredential, AzureKeyCredential] credential: The credential we use to authenticate against the service. - :keyword api_version: Api Version. Default value is "2021-10-01-preview". Note that overriding + :keyword api_version: Azure Communication Email API version. Default value is "2021-10-01-preview". Note that overriding this default value may result in unsupported behavior. :paramtype api_version: str """ diff --git a/sdk/communication/azure-communication-email/azure/communication/email/aio/_email_client_async.py b/sdk/communication/azure-communication-email/azure/communication/email/aio/_email_client_async.py index 5844d2a64f76..b9c4219c90ca 100644 --- a/sdk/communication/azure-communication-email/azure/communication/email/aio/_email_client_async.py +++ b/sdk/communication/azure-communication-email/azure/communication/email/aio/_email_client_async.py @@ -25,7 +25,7 @@ class EmailClient(object): # pylint: disable=client-accepts-api-version-keyword The endpoint url for Azure Communication Service resource. :param Union[AsyncTokenCredential, AzureKeyCredential] credential: The credential we use to authenticate against the service. - :keyword api_version: Api Version. Default value is "2021-10-01-preview". Note that overriding + :keyword api_version: Azure Communication Email API version. Default value is "2021-10-01-preview". Note that overriding this default value may result in unsupported behavior. :paramtype api_version: str """ diff --git a/sdk/communication/azure-communication-identity/azure/communication/identity/_communication_identity_client.py b/sdk/communication/azure-communication-identity/azure/communication/identity/_communication_identity_client.py index 2551334ba94b..387057f8d4ac 100644 --- a/sdk/communication/azure-communication-identity/azure/communication/identity/_communication_identity_client.py +++ b/sdk/communication/azure-communication-identity/azure/communication/identity/_communication_identity_client.py @@ -28,7 +28,7 @@ class CommunicationIdentityClient(object): The endpoint url for Azure Communication Service resource. :param TokenCredential credential: The TokenCredential we use to authenticate against the service. - :keyword api_version: Api Version. Default value is "2022-06-01". Note that overriding this + :keyword api_version: Azure Communication Identity API version. Default value is "2022-06-01". Note that overriding this default value may result in unsupported behavior. :paramtype api_version: str diff --git a/sdk/communication/azure-communication-identity/azure/communication/identity/aio/_communication_identity_client_async.py b/sdk/communication/azure-communication-identity/azure/communication/identity/aio/_communication_identity_client_async.py index d36a465b7e8a..3795f9eea3e8 100644 --- a/sdk/communication/azure-communication-identity/azure/communication/identity/aio/_communication_identity_client_async.py +++ b/sdk/communication/azure-communication-identity/azure/communication/identity/aio/_communication_identity_client_async.py @@ -27,7 +27,7 @@ class CommunicationIdentityClient: The endpoint url for Azure Communication Service resource. :param AsyncTokenCredential credential: The AsyncTokenCredential we use to authenticate against the service. - :keyword api_version: Api Version. Default value is "2022-06-01". Note that overriding this + :keyword api_version: Azure Communication Identity API version. Default value is "2022-06-01". Note that overriding this default value may result in unsupported behavior. :paramtype api_version: str diff --git a/sdk/communication/azure-communication-jobrouter/azure/communication/jobrouter/_api_versions.py b/sdk/communication/azure-communication-jobrouter/azure/communication/jobrouter/_api_versions.py index df5a010c8cf9..bd24469d5bf8 100644 --- a/sdk/communication/azure-communication-jobrouter/azure/communication/jobrouter/_api_versions.py +++ b/sdk/communication/azure-communication-jobrouter/azure/communication/jobrouter/_api_versions.py @@ -7,9 +7,8 @@ from azure.core import CaseInsensitiveEnumMeta -# pylint: disable=enum-must-be-uppercase class ApiVersion(str, Enum, metaclass=CaseInsensitiveEnumMeta): - V2022_07_18_preview = "2022-07-18-preview" + V2022_07_18_PREVIEW = "2022-07-18-preview" -DEFAULT_VERSION = ApiVersion.V2022_07_18_preview +DEFAULT_VERSION = ApiVersion.V2022_07_18_PREVIEW diff --git a/sdk/communication/azure-communication-jobrouter/azure/communication/jobrouter/_router_administration_client.py b/sdk/communication/azure-communication-jobrouter/azure/communication/jobrouter/_router_administration_client.py index 6b2f313474a2..42d9669d9e33 100644 --- a/sdk/communication/azure-communication-jobrouter/azure/communication/jobrouter/_router_administration_client.py +++ b/sdk/communication/azure-communication-jobrouter/azure/communication/jobrouter/_router_administration_client.py @@ -57,7 +57,7 @@ _SERIALIZER = Serializer() -class RouterAdministrationClient(object): # pylint: disable=client-accepts-api-version-keyword,too-many-public-methods,too-many-lines +class RouterAdministrationClient(object): # pylint:disable=too-many-public-methods,too-many-lines """A client to interact with the AzureCommunicationService JobRouter service. This client provides operations to create, update, list and delete the following entities: classification policy, @@ -67,6 +67,10 @@ class RouterAdministrationClient(object): # pylint: disable=client-accepts-api- The endpoint of the Azure Communication resource. :param ~azure.core.credentials.AzureKeyCredential credential: The credentials with which to authenticate + + :keyword api_version: Azure Communication Job Router API version. Default value is "2022-07-18-preview". Note that overriding this + default value may result in unsupported behavior. + :paramtype api_version: str """ def __init__( @@ -98,9 +102,9 @@ def __init__( self._authentication_policy = HMACCredentialsPolicy(endpoint, credential.key) self._client = AzureCommunicationJobRouterService( self._endpoint, - api_version = self._api_version, - authentication_policy = self._authentication_policy, - sdk_moniker = SDK_MONIKER, + api_version=self._api_version, + authentication_policy=self._authentication_policy, + sdk_moniker=SDK_MONIKER, **kwargs) @classmethod diff --git a/sdk/communication/azure-communication-jobrouter/azure/communication/jobrouter/aio/_router_administration_client_async.py b/sdk/communication/azure-communication-jobrouter/azure/communication/jobrouter/aio/_router_administration_client_async.py index 8e6b8a02c082..f56db8e99e92 100644 --- a/sdk/communication/azure-communication-jobrouter/azure/communication/jobrouter/aio/_router_administration_client_async.py +++ b/sdk/communication/azure-communication-jobrouter/azure/communication/jobrouter/aio/_router_administration_client_async.py @@ -59,7 +59,7 @@ _SERIALIZER = Serializer() -class RouterAdministrationClient(object): # pylint: disable=client-accepts-api-version-keyword,too-many-public-methods,too-many-lines +class RouterAdministrationClient(object): # pylint:disable=too-many-public-methods,too-many-lines """A client to interact with the AzureCommunicationService JobRouter service. This client provides operations to create, update, list and delete the following entities: classification policy, @@ -69,6 +69,9 @@ class RouterAdministrationClient(object): # pylint: disable=client-accepts-api- The endpoint of the Azure Communication resource. :param ~azure.core.credentials.AzureKeyCredential credential: The credentials with which to authenticate + + :keyword api_version: Azure Communication Job Router API version. Default value is "2022-07-18-preview". Note that overriding this + default value may result in unsupported behavior. """ def __init__( @@ -100,7 +103,7 @@ def __init__( self._authentication_policy = HMACCredentialsPolicy(endpoint, credential.key, decode_url=True) self._client = AzureCommunicationJobRouterService( self._endpoint, - api_version = self._api_version, + api_version=self._api_version, authentication_policy=self._authentication_policy, sdk_moniker=SDK_MONIKER, **kwargs) diff --git a/sdk/communication/azure-communication-networktraversal/azure/communication/networktraversal/_communication_relay_client.py b/sdk/communication/azure-communication-networktraversal/azure/communication/networktraversal/_communication_relay_client.py index dc5ad8587cdc..7da3d6ea1afa 100644 --- a/sdk/communication/azure-communication-networktraversal/azure/communication/networktraversal/_communication_relay_client.py +++ b/sdk/communication/azure-communication-networktraversal/azure/communication/networktraversal/_communication_relay_client.py @@ -28,7 +28,7 @@ class CommunicationRelayClient(object): The endpoint url for Azure Communication Service resource. :param TokenCredential credential: The TokenCredential we use to authenticate against the service. - :keyword api_version: Api Version. Default value is "2022-03-01-preview". Note that overriding + :keyword api_version: Azure Communication Network Traversal API version. Default value is "2022-03-01-preview". Note that overriding this default value may result in unsupported behavior. :paramtype api_version: str .. admonition:: Example: diff --git a/sdk/communication/azure-communication-networktraversal/azure/communication/networktraversal/aio/_communication_relay_client_async.py b/sdk/communication/azure-communication-networktraversal/azure/communication/networktraversal/aio/_communication_relay_client_async.py index c4c94fb1ede7..ec29e7f0894f 100644 --- a/sdk/communication/azure-communication-networktraversal/azure/communication/networktraversal/aio/_communication_relay_client_async.py +++ b/sdk/communication/azure-communication-networktraversal/azure/communication/networktraversal/aio/_communication_relay_client_async.py @@ -27,7 +27,7 @@ class CommunicationRelayClient: The endpoint url for Azure Communication Service resource. :param AsyncTokenCredential credential: The AsyncTokenCredential we use to authenticate against the service. - :keyword api_version: Api Version. Default value is "2022-03-01-preview". Note that overriding + :keyword api_version: Azure Communication Network Traversal API version. Default value is "2022-03-01-preview". Note that overriding this default value may result in unsupported behavior. :paramtype api_version: str diff --git a/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_phone_numbers_client.py b/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_phone_numbers_client.py index a879371d9d27..505ad4ad5b5f 100644 --- a/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_phone_numbers_client.py +++ b/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_phone_numbers_client.py @@ -29,7 +29,7 @@ class PhoneNumbersClient(object): The endpoint url for Azure Communication Service resource. :param TokenCredential credential: The credentials with which to authenticate. - :keyword api_version: Api Version. The default value is "2022-01-11-preview2". Note that + :keyword api_version: Azure Communication Phone Number API version. The default value is "2022-01-11-preview2". Note that overriding this default value may result in unsupported behavior. :paramtype api_version: str """ diff --git a/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/aio/_phone_numbers_client_async.py b/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/aio/_phone_numbers_client_async.py index 27759f64c8cd..5f4ff7f6e875 100644 --- a/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/aio/_phone_numbers_client_async.py +++ b/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/aio/_phone_numbers_client_async.py @@ -30,7 +30,7 @@ class PhoneNumbersClient(object): The endpoint url for Azure Communication Service resource. :param AsyncTokenCredential credential: The credentials with which to authenticate. - :keyword api_version: Api Version. The default value is "2022-01-11-preview2". Note that + :keyword api_version: Azure Communication Phone Number API version. The default value is "2022-01-11-preview2". Note that overriding this default value may result in unsupported behavior. :paramtype api_version: str """ diff --git a/sdk/communication/azure-communication-rooms/azure/communication/rooms/_rooms_client.py b/sdk/communication/azure-communication-rooms/azure/communication/rooms/_rooms_client.py index 5c20276d32a2..44d0c256afcb 100644 --- a/sdk/communication/azure-communication-rooms/azure/communication/rooms/_rooms_client.py +++ b/sdk/communication/azure-communication-rooms/azure/communication/rooms/_rooms_client.py @@ -38,7 +38,7 @@ class RoomsClient(object): The endpoint url for Azure Communication Service resource. :param ~azure.core.credentials.AzureKeyCredential credential: The access key we use to authenticate against the service. - :keyword api_version: Api Version. Default value is "2022-02-01". Note that overriding this + :keyword api_version: Azure Communication Rooms API version. Default value is "2022-02-01". Note that overriding this default value may result in unsupported behavior. :paramtype api_version: str """ diff --git a/sdk/communication/azure-communication-rooms/azure/communication/rooms/aio/_rooms_client_async.py b/sdk/communication/azure-communication-rooms/azure/communication/rooms/aio/_rooms_client_async.py index 63a6db9b4c52..9ef9b01ae93c 100644 --- a/sdk/communication/azure-communication-rooms/azure/communication/rooms/aio/_rooms_client_async.py +++ b/sdk/communication/azure-communication-rooms/azure/communication/rooms/aio/_rooms_client_async.py @@ -34,7 +34,7 @@ class RoomsClient(object): The endpoint url for Azure Communication Service resource. :param ~azure.core.credentials.AzureKeyCredential credential: The access key we use to authenticate against the service. - :keyword api_version: Api Version. Default value is "2022-02-01". Note that overriding this + :keyword api_version: Azure Communication Rooms API version. Default value is "2022-02-01". Note that overriding this default value may result in unsupported behavior. :paramtype api_version: str """ diff --git a/sdk/communication/azure-communication-sms/azure/communication/sms/_sms_client.py b/sdk/communication/azure-communication-sms/azure/communication/sms/_sms_client.py index b9a10ce1d396..2068770df5b9 100644 --- a/sdk/communication/azure-communication-sms/azure/communication/sms/_sms_client.py +++ b/sdk/communication/azure-communication-sms/azure/communication/sms/_sms_client.py @@ -27,7 +27,7 @@ class SmsClient(object): The endpoint url for Azure Communication Service resource. :param TokenCredential credential: The TokenCredential we use to authenticate against the service. - :keyword api_version: Api Version. The default value is "2021-03-07". Note that + :keyword api_version: Azure Communication SMS API version. The default value is "2021-03-07". Note that overriding this default value may result in unsupported behavior. :paramtype api_version: str """ diff --git a/sdk/communication/azure-communication-sms/azure/communication/sms/aio/_sms_client_async.py b/sdk/communication/azure-communication-sms/azure/communication/sms/aio/_sms_client_async.py index 50e9aec785ac..1a9277fa3cde 100644 --- a/sdk/communication/azure-communication-sms/azure/communication/sms/aio/_sms_client_async.py +++ b/sdk/communication/azure-communication-sms/azure/communication/sms/aio/_sms_client_async.py @@ -27,7 +27,7 @@ class SmsClient(object): The endpoint url for Azure Communication Service resource. :param AsyncTokenCredential credential: The AsyncTokenCredential we use to authenticate against the service. - :keyword api_version: Api Version. The default value is "2021-03-07". Note that + :keyword api_version: Azure Communication SMS API version. The default value is "2021-03-07". Note that overriding this default value may result in unsupported behavior. :paramtype api_version: str """ From 69c409cbccf51ac9f6d58332ed12d178ba6ec493 Mon Sep 17 00:00:00 2001 From: Olena Stoliarova Date: Fri, 30 Sep 2022 16:19:59 +0300 Subject: [PATCH 07/19] fixing long lines in comments --- .../azure/communication/chat/_chat_client.py | 4 ++-- .../azure/communication/chat/_chat_thread_client.py | 4 ++-- .../azure/communication/chat/aio/_chat_client_async.py | 4 ++-- .../communication/chat/aio/_chat_thread_client_async.py | 4 ++-- .../azure/communication/email/_email_client.py | 5 +++-- .../azure/communication/email/aio/_email_client_async.py | 5 +++-- .../identity/_communication_identity_client.py | 4 ++-- .../identity/aio/_communication_identity_client_async.py | 4 ++-- .../jobrouter/_router_administration_client.py | 4 ++-- .../azure/communication/jobrouter/_router_client.py | 6 +++++- .../jobrouter/aio/_router_administration_client_async.py | 5 +++-- .../communication/jobrouter/aio/_router_client_async.py | 8 ++++++-- .../networktraversal/_communication_relay_client.py | 5 +++-- .../aio/_communication_relay_client_async.py | 5 +++-- .../communication/phonenumbers/_phone_numbers_client.py | 5 +++-- .../phonenumbers/aio/_phone_numbers_client_async.py | 5 +++-- .../azure/communication/rooms/_rooms_client.py | 4 ++-- .../azure/communication/rooms/aio/_rooms_client_async.py | 4 ++-- .../azure/communication/sms/_sms_client.py | 4 ++-- .../azure/communication/sms/aio/_sms_client_async.py | 4 ++-- 20 files changed, 54 insertions(+), 39 deletions(-) diff --git a/sdk/communication/azure-communication-chat/azure/communication/chat/_chat_client.py b/sdk/communication/azure-communication-chat/azure/communication/chat/_chat_client.py index c7591bbff88c..b1f54736abc9 100644 --- a/sdk/communication/azure-communication-chat/azure/communication/chat/_chat_client.py +++ b/sdk/communication/azure-communication-chat/azure/communication/chat/_chat_client.py @@ -44,8 +44,8 @@ class ChatClient(object): :param Union[TokenCredential, AzureKeyCredential] credential: The credential we use to authenticate against the service. - :keyword api_version: Azure Communication Chat API version. Default value is "2021-09-07". Note that overriding this - default value may result in unsupported behavior. + :keyword api_version: Azure Communication Chat API version. + Default value is "2021-09-07". Note that overriding this default value may result in unsupported behavior. :paramtype api_version: str .. admonition:: Example: diff --git a/sdk/communication/azure-communication-chat/azure/communication/chat/_chat_thread_client.py b/sdk/communication/azure-communication-chat/azure/communication/chat/_chat_thread_client.py index ce3c643fad86..13c89c2938b5 100644 --- a/sdk/communication/azure-communication-chat/azure/communication/chat/_chat_thread_client.py +++ b/sdk/communication/azure-communication-chat/azure/communication/chat/_chat_thread_client.py @@ -60,8 +60,8 @@ class ChatThreadClient(object): :param str thread_id: The unique thread id. - :keyword api_version: Azure Communication Chat API version. Default value is "2021-09-07". Note that overriding this - default value may result in unsupported behavior. + :keyword api_version: Azure Communication Chat API version. + Default value is "2021-09-07". Note that overriding this default value may result in unsupported behavior. :paramtype api_version: str .. admonition:: Example: diff --git a/sdk/communication/azure-communication-chat/azure/communication/chat/aio/_chat_client_async.py b/sdk/communication/azure-communication-chat/azure/communication/chat/aio/_chat_client_async.py index 15e640156bfc..d03b84e01ff1 100644 --- a/sdk/communication/azure-communication-chat/azure/communication/chat/aio/_chat_client_async.py +++ b/sdk/communication/azure-communication-chat/azure/communication/chat/aio/_chat_client_async.py @@ -49,8 +49,8 @@ class ChatClient(object): :param Union[TokenCredential, AzureKeyCredential] credential: The credential we use to authenticate against the service. - :keyword api_version: Azure Communication Chat API version. Default value is "2021-09-07". Note that overriding this - default value may result in unsupported behavior. + :keyword api_version: Azure Communication Chat API version. + Default value is "2021-09-07". Note that overriding this default value may result in unsupported behavior. :paramtype api_version: str .. admonition:: Example: diff --git a/sdk/communication/azure-communication-chat/azure/communication/chat/aio/_chat_thread_client_async.py b/sdk/communication/azure-communication-chat/azure/communication/chat/aio/_chat_thread_client_async.py index 046861de6c93..0b0b987902db 100644 --- a/sdk/communication/azure-communication-chat/azure/communication/chat/aio/_chat_thread_client_async.py +++ b/sdk/communication/azure-communication-chat/azure/communication/chat/aio/_chat_thread_client_async.py @@ -60,8 +60,8 @@ class ChatThreadClient(object): :param str thread_id: The unique thread id. - :keyword api_version: Azure Communication Chat API version. Default value is "2021-09-07". Note that overriding this - default value may result in unsupported behavior. + :keyword api_version: Azure Communication Chat API version. + Default value is "2021-09-07". Note that overriding this default value may result in unsupported behavior. :paramtype api_version: str .. admonition:: Example: diff --git a/sdk/communication/azure-communication-email/azure/communication/email/_email_client.py b/sdk/communication/azure-communication-email/azure/communication/email/_email_client.py index 5793aa9afce6..e51e70306a20 100644 --- a/sdk/communication/azure-communication-email/azure/communication/email/_email_client.py +++ b/sdk/communication/azure-communication-email/azure/communication/email/_email_client.py @@ -26,8 +26,9 @@ class EmailClient(object): The endpoint url for Azure Communication Service resource. :param Union[TokenCredential, AzureKeyCredential] credential: The credential we use to authenticate against the service. - :keyword api_version: Azure Communication Email API version. Default value is "2021-10-01-preview". Note that overriding - this default value may result in unsupported behavior. + :keyword api_version: Azure Communication Email API version. + Default value is "2021-10-01-preview". + Note that overriding this default value may result in unsupported behavior. :paramtype api_version: str """ def __init__( diff --git a/sdk/communication/azure-communication-email/azure/communication/email/aio/_email_client_async.py b/sdk/communication/azure-communication-email/azure/communication/email/aio/_email_client_async.py index b9c4219c90ca..4fd534478edf 100644 --- a/sdk/communication/azure-communication-email/azure/communication/email/aio/_email_client_async.py +++ b/sdk/communication/azure-communication-email/azure/communication/email/aio/_email_client_async.py @@ -25,8 +25,9 @@ class EmailClient(object): # pylint: disable=client-accepts-api-version-keyword The endpoint url for Azure Communication Service resource. :param Union[AsyncTokenCredential, AzureKeyCredential] credential: The credential we use to authenticate against the service. - :keyword api_version: Azure Communication Email API version. Default value is "2021-10-01-preview". Note that overriding - this default value may result in unsupported behavior. + :keyword api_version: Azure Communication Email API version. + Default value is "2021-10-01-preview". + Note that overriding this default value may result in unsupported behavior. :paramtype api_version: str """ def __init__( diff --git a/sdk/communication/azure-communication-identity/azure/communication/identity/_communication_identity_client.py b/sdk/communication/azure-communication-identity/azure/communication/identity/_communication_identity_client.py index 387057f8d4ac..4d93e612b97b 100644 --- a/sdk/communication/azure-communication-identity/azure/communication/identity/_communication_identity_client.py +++ b/sdk/communication/azure-communication-identity/azure/communication/identity/_communication_identity_client.py @@ -28,8 +28,8 @@ class CommunicationIdentityClient(object): The endpoint url for Azure Communication Service resource. :param TokenCredential credential: The TokenCredential we use to authenticate against the service. - :keyword api_version: Azure Communication Identity API version. Default value is "2022-06-01". Note that overriding this - default value may result in unsupported behavior. + :keyword api_version: Azure Communication Identity API version. + Default value is "2022-06-01". Note that overriding this default value may result in unsupported behavior. :paramtype api_version: str .. admonition:: Example: diff --git a/sdk/communication/azure-communication-identity/azure/communication/identity/aio/_communication_identity_client_async.py b/sdk/communication/azure-communication-identity/azure/communication/identity/aio/_communication_identity_client_async.py index 3795f9eea3e8..bba3c008f9ff 100644 --- a/sdk/communication/azure-communication-identity/azure/communication/identity/aio/_communication_identity_client_async.py +++ b/sdk/communication/azure-communication-identity/azure/communication/identity/aio/_communication_identity_client_async.py @@ -27,8 +27,8 @@ class CommunicationIdentityClient: The endpoint url for Azure Communication Service resource. :param AsyncTokenCredential credential: The AsyncTokenCredential we use to authenticate against the service. - :keyword api_version: Azure Communication Identity API version. Default value is "2022-06-01". Note that overriding this - default value may result in unsupported behavior. + :keyword api_version: Azure Communication Identity API version. + Default value is "2022-06-01". Note that overriding this default value may result in unsupported behavior. :paramtype api_version: str .. admonition:: Example: diff --git a/sdk/communication/azure-communication-jobrouter/azure/communication/jobrouter/_router_administration_client.py b/sdk/communication/azure-communication-jobrouter/azure/communication/jobrouter/_router_administration_client.py index 42d9669d9e33..7c2dc3545cc8 100644 --- a/sdk/communication/azure-communication-jobrouter/azure/communication/jobrouter/_router_administration_client.py +++ b/sdk/communication/azure-communication-jobrouter/azure/communication/jobrouter/_router_administration_client.py @@ -68,8 +68,8 @@ class RouterAdministrationClient(object): # pylint:disable=too-many-public-meth :param ~azure.core.credentials.AzureKeyCredential credential: The credentials with which to authenticate - :keyword api_version: Azure Communication Job Router API version. Default value is "2022-07-18-preview". Note that overriding this - default value may result in unsupported behavior. + :keyword api_version: Azure Communication Job Router API version. Default value is "2022-07-18-preview". + Note that overriding this default value may result in unsupported behavior. :paramtype api_version: str """ diff --git a/sdk/communication/azure-communication-jobrouter/azure/communication/jobrouter/_router_client.py b/sdk/communication/azure-communication-jobrouter/azure/communication/jobrouter/_router_client.py index c4a3a601dc0e..756cf0b0b5fe 100644 --- a/sdk/communication/azure-communication-jobrouter/azure/communication/jobrouter/_router_client.py +++ b/sdk/communication/azure-communication-jobrouter/azure/communication/jobrouter/_router_client.py @@ -52,7 +52,7 @@ _SERIALIZER = Serializer() -class RouterClient(object): # pylint: disable=client-accepts-api-version-keyword,too-many-public-methods,too-many-lines +class RouterClient(object): # pylint:disable=too-many-public-methods,too-many-lines """A client to interact with the AzureCommunicationService JobRouter service. This client provides operations to create and update jobs, policies and workers. @@ -61,6 +61,10 @@ class RouterClient(object): # pylint: disable=client-accepts-api-version-keywor The endpoint of the Azure Communication resource. :param ~azure.core.credentials.AzureKeyCredential credential: The credentials with which to authenticate + + :keyword api_version: Azure Communication Job Router API version. + Default value is "2022-07-18-preview". + Note that overriding this default value may result in unsupported behavior. """ def __init__( diff --git a/sdk/communication/azure-communication-jobrouter/azure/communication/jobrouter/aio/_router_administration_client_async.py b/sdk/communication/azure-communication-jobrouter/azure/communication/jobrouter/aio/_router_administration_client_async.py index f56db8e99e92..aed03021ec6f 100644 --- a/sdk/communication/azure-communication-jobrouter/azure/communication/jobrouter/aio/_router_administration_client_async.py +++ b/sdk/communication/azure-communication-jobrouter/azure/communication/jobrouter/aio/_router_administration_client_async.py @@ -70,8 +70,9 @@ class RouterAdministrationClient(object): # pylint:disable=too-many-public-meth :param ~azure.core.credentials.AzureKeyCredential credential: The credentials with which to authenticate - :keyword api_version: Azure Communication Job Router API version. Default value is "2022-07-18-preview". Note that overriding this - default value may result in unsupported behavior. + :keyword api_version: Azure Communication Job Router API version. + Default value is "2022-07-18-preview". + Note that overriding this default value may result in unsupported behavior. """ def __init__( diff --git a/sdk/communication/azure-communication-jobrouter/azure/communication/jobrouter/aio/_router_client_async.py b/sdk/communication/azure-communication-jobrouter/azure/communication/jobrouter/aio/_router_client_async.py index 1823084ff4c2..8d206fa2bf44 100644 --- a/sdk/communication/azure-communication-jobrouter/azure/communication/jobrouter/aio/_router_client_async.py +++ b/sdk/communication/azure-communication-jobrouter/azure/communication/jobrouter/aio/_router_client_async.py @@ -54,7 +54,7 @@ _SERIALIZER = Serializer() -class RouterClient(object): # pylint: disable=client-accepts-api-version-keyword,too-many-public-methods,too-many-lines +class RouterClient(object): # pylint:disable=too-many-public-methods,too-many-lines """A client to interact with the AzureCommunicationService JobRouter service. This client provides operations to create and update jobs, policies and workers. @@ -63,6 +63,10 @@ class RouterClient(object): # pylint: disable=client-accepts-api-version-keywor The endpoint of the Azure Communication resource. :param ~azure.core.credentials.AzureKeyCredential credential: The credentials with which to authenticate + + :keyword api_version: Azure Communication Job Router API version. + Default value is "2022-07-18-preview". + Note that overriding this default value may result in unsupported behavior. """ def __init__( @@ -94,7 +98,7 @@ def __init__( self._authentication_policy = HMACCredentialsPolicy(endpoint, credential.key, decode_url=True) self._client = AzureCommunicationJobRouterService( self._endpoint, - api_version = self._api_version, + api_version=self._api_version, authentication_policy=self._authentication_policy, sdk_moniker=SDK_MONIKER, **kwargs) diff --git a/sdk/communication/azure-communication-networktraversal/azure/communication/networktraversal/_communication_relay_client.py b/sdk/communication/azure-communication-networktraversal/azure/communication/networktraversal/_communication_relay_client.py index 7da3d6ea1afa..0bb78cd6e49b 100644 --- a/sdk/communication/azure-communication-networktraversal/azure/communication/networktraversal/_communication_relay_client.py +++ b/sdk/communication/azure-communication-networktraversal/azure/communication/networktraversal/_communication_relay_client.py @@ -28,8 +28,9 @@ class CommunicationRelayClient(object): The endpoint url for Azure Communication Service resource. :param TokenCredential credential: The TokenCredential we use to authenticate against the service. - :keyword api_version: Azure Communication Network Traversal API version. Default value is "2022-03-01-preview". Note that overriding - this default value may result in unsupported behavior. + :keyword api_version: Azure Communication Network Traversal API version. + Default value is "2022-03-01-preview". + Note that overriding this default value may result in unsupported behavior. :paramtype api_version: str .. admonition:: Example: diff --git a/sdk/communication/azure-communication-networktraversal/azure/communication/networktraversal/aio/_communication_relay_client_async.py b/sdk/communication/azure-communication-networktraversal/azure/communication/networktraversal/aio/_communication_relay_client_async.py index ec29e7f0894f..316bb951c7ae 100644 --- a/sdk/communication/azure-communication-networktraversal/azure/communication/networktraversal/aio/_communication_relay_client_async.py +++ b/sdk/communication/azure-communication-networktraversal/azure/communication/networktraversal/aio/_communication_relay_client_async.py @@ -27,8 +27,9 @@ class CommunicationRelayClient: The endpoint url for Azure Communication Service resource. :param AsyncTokenCredential credential: The AsyncTokenCredential we use to authenticate against the service. - :keyword api_version: Azure Communication Network Traversal API version. Default value is "2022-03-01-preview". Note that overriding - this default value may result in unsupported behavior. + :keyword api_version: Azure Communication Network Traversal API version. + Default value is "2022-03-01-preview". + Note that overriding this default value may result in unsupported behavior. :paramtype api_version: str .. admonition:: Example: diff --git a/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_phone_numbers_client.py b/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_phone_numbers_client.py index 505ad4ad5b5f..ea929e440945 100644 --- a/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_phone_numbers_client.py +++ b/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_phone_numbers_client.py @@ -29,8 +29,9 @@ class PhoneNumbersClient(object): The endpoint url for Azure Communication Service resource. :param TokenCredential credential: The credentials with which to authenticate. - :keyword api_version: Azure Communication Phone Number API version. The default value is "2022-01-11-preview2". Note that - overriding this default value may result in unsupported behavior. + :keyword api_version: Azure Communication Phone Number API version. + The default value is "2022-01-11-preview2". + Note that overriding this default value may result in unsupported behavior. :paramtype api_version: str """ def __init__( diff --git a/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/aio/_phone_numbers_client_async.py b/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/aio/_phone_numbers_client_async.py index 5f4ff7f6e875..8c6d34cb992c 100644 --- a/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/aio/_phone_numbers_client_async.py +++ b/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/aio/_phone_numbers_client_async.py @@ -30,8 +30,9 @@ class PhoneNumbersClient(object): The endpoint url for Azure Communication Service resource. :param AsyncTokenCredential credential: The credentials with which to authenticate. - :keyword api_version: Azure Communication Phone Number API version. The default value is "2022-01-11-preview2". Note that - overriding this default value may result in unsupported behavior. + :keyword api_version: Azure Communication Phone Number API version. + The default value is "2022-01-11-preview2". + Note that overriding this default value may result in unsupported behavior. :paramtype api_version: str """ def __init__( diff --git a/sdk/communication/azure-communication-rooms/azure/communication/rooms/_rooms_client.py b/sdk/communication/azure-communication-rooms/azure/communication/rooms/_rooms_client.py index 44d0c256afcb..73be1ddb2308 100644 --- a/sdk/communication/azure-communication-rooms/azure/communication/rooms/_rooms_client.py +++ b/sdk/communication/azure-communication-rooms/azure/communication/rooms/_rooms_client.py @@ -38,8 +38,8 @@ class RoomsClient(object): The endpoint url for Azure Communication Service resource. :param ~azure.core.credentials.AzureKeyCredential credential: The access key we use to authenticate against the service. - :keyword api_version: Azure Communication Rooms API version. Default value is "2022-02-01". Note that overriding this - default value may result in unsupported behavior. + :keyword api_version: Azure Communication Rooms API version. + Default value is "2022-02-01". Note that overriding this default value may result in unsupported behavior. :paramtype api_version: str """ def __init__( diff --git a/sdk/communication/azure-communication-rooms/azure/communication/rooms/aio/_rooms_client_async.py b/sdk/communication/azure-communication-rooms/azure/communication/rooms/aio/_rooms_client_async.py index 9ef9b01ae93c..42ca8dc97c53 100644 --- a/sdk/communication/azure-communication-rooms/azure/communication/rooms/aio/_rooms_client_async.py +++ b/sdk/communication/azure-communication-rooms/azure/communication/rooms/aio/_rooms_client_async.py @@ -34,8 +34,8 @@ class RoomsClient(object): The endpoint url for Azure Communication Service resource. :param ~azure.core.credentials.AzureKeyCredential credential: The access key we use to authenticate against the service. - :keyword api_version: Azure Communication Rooms API version. Default value is "2022-02-01". Note that overriding this - default value may result in unsupported behavior. + :keyword api_version: Azure Communication Rooms API version. + Default value is "2022-02-01". Note that overriding this default value may result in unsupported behavior. :paramtype api_version: str """ def __init__( diff --git a/sdk/communication/azure-communication-sms/azure/communication/sms/_sms_client.py b/sdk/communication/azure-communication-sms/azure/communication/sms/_sms_client.py index 2068770df5b9..559acc8fbea7 100644 --- a/sdk/communication/azure-communication-sms/azure/communication/sms/_sms_client.py +++ b/sdk/communication/azure-communication-sms/azure/communication/sms/_sms_client.py @@ -27,8 +27,8 @@ class SmsClient(object): The endpoint url for Azure Communication Service resource. :param TokenCredential credential: The TokenCredential we use to authenticate against the service. - :keyword api_version: Azure Communication SMS API version. The default value is "2021-03-07". Note that - overriding this default value may result in unsupported behavior. + :keyword api_version: Azure Communication SMS API version. + The default value is "2021-03-07". Note that overriding this default value may result in unsupported behavior. :paramtype api_version: str """ def __init__( diff --git a/sdk/communication/azure-communication-sms/azure/communication/sms/aio/_sms_client_async.py b/sdk/communication/azure-communication-sms/azure/communication/sms/aio/_sms_client_async.py index 1a9277fa3cde..2987e5e051d0 100644 --- a/sdk/communication/azure-communication-sms/azure/communication/sms/aio/_sms_client_async.py +++ b/sdk/communication/azure-communication-sms/azure/communication/sms/aio/_sms_client_async.py @@ -27,8 +27,8 @@ class SmsClient(object): The endpoint url for Azure Communication Service resource. :param AsyncTokenCredential credential: The AsyncTokenCredential we use to authenticate against the service. - :keyword api_version: Azure Communication SMS API version. The default value is "2021-03-07". Note that - overriding this default value may result in unsupported behavior. + :keyword api_version: Azure Communication SMS API version. + The default value is "2021-03-07". Note that overriding this default value may result in unsupported behavior. :paramtype api_version: str """ def __init__( From ceef55f9f32d212e2464f4db5872dc0904f49f26 Mon Sep 17 00:00:00 2001 From: Olena Stoliarova Date: Wed, 12 Oct 2022 09:47:16 +0300 Subject: [PATCH 08/19] regenerate chat with new autorest version --- .../aio/operations/_chat_operations.py | 15 +++++-- .../aio/operations/_chat_thread_operations.py | 41 ++++++++++++++----- .../_generated/operations/_chat_operations.py | 15 +++++-- .../operations/_chat_thread_operations.py | 41 ++++++++++++++----- 4 files changed, 84 insertions(+), 28 deletions(-) diff --git a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/operations/_chat_operations.py b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/operations/_chat_operations.py index 24b14a75da33..406d617b161e 100644 --- a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/operations/_chat_operations.py +++ b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/operations/_chat_operations.py @@ -8,7 +8,7 @@ # -------------------------------------------------------------------------- import datetime from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, TypeVar, Union, overload -from urllib.parse import parse_qs, urljoin, urlparse +import urllib.parse from azure.core.async_paging import AsyncItemPaged, AsyncList from azure.core.exceptions import ( @@ -284,10 +284,17 @@ def prepare_request(next_link=None): else: # make call to next link with the client's api-version - _parsed_next_link = urlparse(next_link) - _next_request_params = case_insensitive_dict(parse_qs(_parsed_next_link.query)) + _parsed_next_link = urllib.parse.urlparse(next_link) + _next_request_params = case_insensitive_dict( + { + key: [urllib.parse.quote(v) for v in value] + for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() + } + ) _next_request_params["api-version"] = self._config.api_version - request = HttpRequest("GET", urljoin(next_link, _parsed_next_link.path), params=_next_request_params) + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params + ) request = _convert_request(request) path_format_arguments = { "endpoint": self._serialize.url( diff --git a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/operations/_chat_thread_operations.py b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/operations/_chat_thread_operations.py index defd7abcd008..9a944dc0a036 100644 --- a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/operations/_chat_thread_operations.py +++ b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/operations/_chat_thread_operations.py @@ -8,7 +8,7 @@ # -------------------------------------------------------------------------- import datetime from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, TypeVar, Union, overload -from urllib.parse import parse_qs, urljoin, urlparse +import urllib.parse from azure.core.async_paging import AsyncItemPaged, AsyncList from azure.core.exceptions import ( @@ -137,10 +137,17 @@ def prepare_request(next_link=None): else: # make call to next link with the client's api-version - _parsed_next_link = urlparse(next_link) - _next_request_params = case_insensitive_dict(parse_qs(_parsed_next_link.query)) + _parsed_next_link = urllib.parse.urlparse(next_link) + _next_request_params = case_insensitive_dict( + { + key: [urllib.parse.quote(v) for v in value] + for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() + } + ) _next_request_params["api-version"] = self._config.api_version - request = HttpRequest("GET", urljoin(next_link, _parsed_next_link.path), params=_next_request_params) + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params + ) request = _convert_request(request) path_format_arguments = { "endpoint": self._serialize.url( @@ -528,10 +535,17 @@ def prepare_request(next_link=None): else: # make call to next link with the client's api-version - _parsed_next_link = urlparse(next_link) - _next_request_params = case_insensitive_dict(parse_qs(_parsed_next_link.query)) + _parsed_next_link = urllib.parse.urlparse(next_link) + _next_request_params = case_insensitive_dict( + { + key: [urllib.parse.quote(v) for v in value] + for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() + } + ) _next_request_params["api-version"] = self._config.api_version - request = HttpRequest("GET", urljoin(next_link, _parsed_next_link.path), params=_next_request_params) + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params + ) request = _convert_request(request) path_format_arguments = { "endpoint": self._serialize.url( @@ -931,10 +945,17 @@ def prepare_request(next_link=None): else: # make call to next link with the client's api-version - _parsed_next_link = urlparse(next_link) - _next_request_params = case_insensitive_dict(parse_qs(_parsed_next_link.query)) + _parsed_next_link = urllib.parse.urlparse(next_link) + _next_request_params = case_insensitive_dict( + { + key: [urllib.parse.quote(v) for v in value] + for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() + } + ) _next_request_params["api-version"] = self._config.api_version - request = HttpRequest("GET", urljoin(next_link, _parsed_next_link.path), params=_next_request_params) + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params + ) request = _convert_request(request) path_format_arguments = { "endpoint": self._serialize.url( diff --git a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/operations/_chat_operations.py b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/operations/_chat_operations.py index ae95ff2ca2af..4e13e83e4c75 100644 --- a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/operations/_chat_operations.py +++ b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/operations/_chat_operations.py @@ -8,7 +8,7 @@ # -------------------------------------------------------------------------- import datetime from typing import Any, Callable, Dict, IO, Iterable, Optional, TypeVar, Union, overload -from urllib.parse import parse_qs, urljoin, urlparse +import urllib.parse from azure.core.exceptions import ( ClientAuthenticationError, @@ -356,10 +356,17 @@ def prepare_request(next_link=None): else: # make call to next link with the client's api-version - _parsed_next_link = urlparse(next_link) - _next_request_params = case_insensitive_dict(parse_qs(_parsed_next_link.query)) + _parsed_next_link = urllib.parse.urlparse(next_link) + _next_request_params = case_insensitive_dict( + { + key: [urllib.parse.quote(v) for v in value] + for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() + } + ) _next_request_params["api-version"] = self._config.api_version - request = HttpRequest("GET", urljoin(next_link, _parsed_next_link.path), params=_next_request_params) + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params + ) request = _convert_request(request) path_format_arguments = { "endpoint": self._serialize.url( diff --git a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/operations/_chat_thread_operations.py b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/operations/_chat_thread_operations.py index 16619fb265d1..e99049a11bb0 100644 --- a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/operations/_chat_thread_operations.py +++ b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/operations/_chat_thread_operations.py @@ -8,7 +8,7 @@ # -------------------------------------------------------------------------- import datetime from typing import Any, Callable, Dict, IO, Iterable, Optional, TypeVar, Union, overload -from urllib.parse import parse_qs, urljoin, urlparse +import urllib.parse from azure.core.exceptions import ( ClientAuthenticationError, @@ -482,10 +482,17 @@ def prepare_request(next_link=None): else: # make call to next link with the client's api-version - _parsed_next_link = urlparse(next_link) - _next_request_params = case_insensitive_dict(parse_qs(_parsed_next_link.query)) + _parsed_next_link = urllib.parse.urlparse(next_link) + _next_request_params = case_insensitive_dict( + { + key: [urllib.parse.quote(v) for v in value] + for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() + } + ) _next_request_params["api-version"] = self._config.api_version - request = HttpRequest("GET", urljoin(next_link, _parsed_next_link.path), params=_next_request_params) + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params + ) request = _convert_request(request) path_format_arguments = { "endpoint": self._serialize.url( @@ -873,10 +880,17 @@ def prepare_request(next_link=None): else: # make call to next link with the client's api-version - _parsed_next_link = urlparse(next_link) - _next_request_params = case_insensitive_dict(parse_qs(_parsed_next_link.query)) + _parsed_next_link = urllib.parse.urlparse(next_link) + _next_request_params = case_insensitive_dict( + { + key: [urllib.parse.quote(v) for v in value] + for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() + } + ) _next_request_params["api-version"] = self._config.api_version - request = HttpRequest("GET", urljoin(next_link, _parsed_next_link.path), params=_next_request_params) + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params + ) request = _convert_request(request) path_format_arguments = { "endpoint": self._serialize.url( @@ -1275,10 +1289,17 @@ def prepare_request(next_link=None): else: # make call to next link with the client's api-version - _parsed_next_link = urlparse(next_link) - _next_request_params = case_insensitive_dict(parse_qs(_parsed_next_link.query)) + _parsed_next_link = urllib.parse.urlparse(next_link) + _next_request_params = case_insensitive_dict( + { + key: [urllib.parse.quote(v) for v in value] + for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() + } + ) _next_request_params["api-version"] = self._config.api_version - request = HttpRequest("GET", urljoin(next_link, _parsed_next_link.path), params=_next_request_params) + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params + ) request = _convert_request(request) path_format_arguments = { "endpoint": self._serialize.url( From aca2c402c3e593fed67e77ac258b0b03a202b999 Mon Sep 17 00:00:00 2001 From: Olena Stoliarova Date: Wed, 12 Oct 2022 09:53:02 +0300 Subject: [PATCH 09/19] regenerate phonenumbers code with new autorest --- .../phonenumbers/_generated/__init__.py | 16 +- .../phonenumbers/_generated/_configuration.py | 47 +- .../phonenumbers/_generated/_patch.py | 2 +- .../_generated/_phone_numbers_client.py | 46 +- .../phonenumbers/_generated/_serialization.py | 1970 +++++++++++++++++ .../phonenumbers/_generated/_vendor.py | 6 +- .../phonenumbers/_generated/aio/__init__.py | 16 +- .../_generated/aio/_configuration.py | 42 +- .../phonenumbers/_generated/aio/_patch.py | 2 +- .../_generated/aio/_phone_numbers_client.py | 35 +- .../_generated/aio/operations/__init__.py | 8 +- .../_generated/aio/operations/_patch.py | 20 + .../operations/_phone_numbers_operations.py | 888 +++++--- .../_generated/models/__init__.py | 88 +- .../phonenumbers/_generated/models/_models.py | 577 ----- .../_generated/models/_models_py3.py | 487 ++-- .../phonenumbers/_generated/models/_patch.py | 20 + .../models/_phone_numbers_client_enums.py | 33 +- .../_generated/operations/__init__.py | 8 +- .../_generated/operations/_patch.py | 20 + .../operations/_phone_numbers_operations.py | 1295 ++++++----- 21 files changed, 3657 insertions(+), 1969 deletions(-) create mode 100644 sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/_serialization.py create mode 100644 sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/aio/operations/_patch.py delete mode 100644 sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/models/_models.py create mode 100644 sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/models/_patch.py create mode 100644 sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/operations/_patch.py diff --git a/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/__init__.py b/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/__init__.py index fa48c8d3c253..962219d02796 100644 --- a/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/__init__.py +++ b/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/__init__.py @@ -7,9 +7,15 @@ # -------------------------------------------------------------------------- from ._phone_numbers_client import PhoneNumbersClient -__all__ = ['PhoneNumbersClient'] -# `._patch.py` is used for handwritten extensions to the generated code -# Example: https://github.com/Azure/azure-sdk-for-python/blob/main/doc/dev/customize_code/how-to-patch-sdk-code.md -from ._patch import patch_sdk -patch_sdk() +try: + from ._patch import __all__ as _patch_all + from ._patch import * # type: ignore # pylint: disable=unused-wildcard-import +except ImportError: + _patch_all = [] +from ._patch import patch_sdk as _patch_sdk + +__all__ = ["PhoneNumbersClient"] +__all__.extend([p for p in _patch_all if p not in __all__]) + +_patch_sdk() diff --git a/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/_configuration.py b/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/_configuration.py index 66ce611315c4..f17f69ed387c 100644 --- a/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/_configuration.py +++ b/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/_configuration.py @@ -6,57 +6,50 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import TYPE_CHECKING +from typing import Any from azure.core.configuration import Configuration from azure.core.pipeline import policies -if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports - from typing import Any - VERSION = "unknown" -class PhoneNumbersClientConfiguration(Configuration): + +class PhoneNumbersClientConfiguration(Configuration): # pylint: disable=too-many-instance-attributes """Configuration for PhoneNumbersClient. Note that all parameters used to create this instance are saved as instance attributes. - :param endpoint: The communication resource, for example https://resourcename.communication.azure.com. + :param endpoint: The communication resource, for example + https://resourcename.communication.azure.com. Required. :type endpoint: str - :keyword api_version: Api Version. The default value is "2022-01-11-preview2". Note that overriding this default value may result in unsupported behavior. + :keyword api_version: Api Version. Default value is "2022-01-11-preview2". Note that overriding + this default value may result in unsupported behavior. :paramtype api_version: str """ - def __init__( - self, - endpoint, # type: str - **kwargs # type: Any - ): - # type: (...) -> None + def __init__(self, endpoint: str, **kwargs: Any) -> None: super(PhoneNumbersClientConfiguration, self).__init__(**kwargs) - api_version = kwargs.pop('api_version', "2022-01-11-preview2") # type: str + api_version = kwargs.pop("api_version", "2022-01-11-preview2") # type: str if endpoint is None: raise ValueError("Parameter 'endpoint' must not be None.") self.endpoint = endpoint self.api_version = api_version - kwargs.setdefault('sdk_moniker', 'phonenumbersclient/{}'.format(VERSION)) + kwargs.setdefault("sdk_moniker", "phonenumbersclient/{}".format(VERSION)) self._configure(**kwargs) def _configure( - self, - **kwargs # type: Any + self, **kwargs # type: Any ): # type: (...) -> None - 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 policies.HttpLoggingPolicy(**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') + 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 policies.HttpLoggingPolicy(**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") diff --git a/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/_patch.py b/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/_patch.py index 74e48ecd07cf..f99e77fef986 100644 --- a/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/_patch.py +++ b/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/_patch.py @@ -28,4 +28,4 @@ # This file is used for handwritten extensions to the generated code. Example: # https://github.com/Azure/azure-sdk-for-python/blob/main/doc/dev/customize_code/how-to-patch-sdk-code.md def patch_sdk(): - pass \ No newline at end of file + pass diff --git a/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/_phone_numbers_client.py b/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/_phone_numbers_client.py index b6e697e472c7..c6625745d464 100644 --- a/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/_phone_numbers_client.py +++ b/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/_phone_numbers_client.py @@ -7,45 +7,39 @@ # -------------------------------------------------------------------------- from copy import deepcopy -from typing import TYPE_CHECKING +from typing import Any from azure.core import PipelineClient -from msrest import Deserializer, Serializer +from azure.core.rest import HttpRequest, HttpResponse from . import models from ._configuration import PhoneNumbersClientConfiguration +from ._serialization import Deserializer, Serializer from .operations import PhoneNumbersOperations -if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports - from typing import Any - from azure.core.rest import HttpRequest, HttpResponse - -class PhoneNumbersClient(object): - """The phone numbers client uses Azure Communication Services to purchase and manage phone numbers. +class PhoneNumbersClient: # pylint: disable=client-accepts-api-version-keyword + """The phone numbers client uses Azure Communication Services to purchase and manage phone + numbers. :ivar phone_numbers: PhoneNumbersOperations operations :vartype phone_numbers: azure.communication.phonenumbers.operations.PhoneNumbersOperations :param endpoint: The communication resource, for example - https://resourcename.communication.azure.com. + https://resourcename.communication.azure.com. Required. :type endpoint: str - :keyword api_version: Api Version. The default value is "2022-01-11-preview2". Note that - overriding this default value may result in unsupported behavior. + :keyword api_version: Api Version. Default value is "2022-01-11-preview2". Note that overriding + this default value may result in unsupported behavior. :paramtype api_version: str :keyword int polling_interval: Default waiting time between two polls for LRO operations if no Retry-After header is present. """ - def __init__( - self, - endpoint, # type: str - **kwargs # type: Any - ): - # type: (...) -> None - _base_url = '{endpoint}' + def __init__( # pylint: disable=missing-client-constructor-parameter-credential + self, endpoint: str, **kwargs: Any + ) -> None: + _endpoint = "{endpoint}" self._config = PhoneNumbersClientConfiguration(endpoint=endpoint, **kwargs) - self._client = PipelineClient(base_url=_base_url, config=self._config, **kwargs) + self._client = PipelineClient(base_url=_endpoint, config=self._config, **kwargs) client_models = {k: v for k, v in models.__dict__.items() if isinstance(v, type)} self._serialize = Serializer(client_models) @@ -53,13 +47,7 @@ def __init__( self._serialize.client_side_validation = False self.phone_numbers = PhoneNumbersOperations(self._client, self._config, self._serialize, self._deserialize) - - def _send_request( - self, - request, # type: HttpRequest - **kwargs # type: Any - ): - # type: (...) -> HttpResponse + def _send_request(self, request: HttpRequest, **kwargs: Any) -> HttpResponse: """Runs the network request through the client's chained policies. >>> from azure.core.rest import HttpRequest @@ -68,7 +56,7 @@ def _send_request( >>> response = client._send_request(request) - For more information on this code flow, see https://aka.ms/azsdk/python/protocol/quickstart + For more information on this code flow, see https://aka.ms/azsdk/dpcodegen/python/send_request :param request: The network request you want to make. Required. :type request: ~azure.core.rest.HttpRequest @@ -79,7 +67,7 @@ def _send_request( request_copy = deepcopy(request) path_format_arguments = { - "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), + "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), } request_copy.url = self._client.format_url(request_copy.url, **path_format_arguments) diff --git a/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/_serialization.py b/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/_serialization.py new file mode 100644 index 000000000000..7c1dedb5133d --- /dev/null +++ b/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/_serialization.py @@ -0,0 +1,1970 @@ +# -------------------------------------------------------------------------- +# +# 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 + +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 + +try: + from urllib import quote # type: ignore +except ImportError: + from urllib.parse import quote # type: ignore +import xml.etree.ElementTree as ET + +import isodate + +from typing import Dict, Any, cast, TYPE_CHECKING + +from azure.core.exceptions import DeserializationError, SerializationError, raise_with_traceback + +_BOM = codecs.BOM_UTF8.decode(encoding="utf-8") + +if TYPE_CHECKING: + from typing import Optional, Union, AnyStr, IO, Mapping + + +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, content_type=None): + # type: (Optional[Union[AnyStr, IO]], Optional[str]) -> 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, headers): + # type: (Optional[Union[AnyStr, IO]], 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 # type: ignore + unicode_str = str # type: ignore + +_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 +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 "".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 # type: ignore +except ImportError: + TZ_UTC = UTC() # type: ignore + +_FLATTEN = re.compile(r"(? 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=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(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) + continue + if xml_desc.get("text", False): + serialized.text = new_attr + continue + if isinstance(new_attr, list): + serialized.extend(new_attr) + 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) + 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) + else: # JSON + for k in reversed(keys): + unflattened = {k: new_attr} + new_attr = unflattened + + _new_attr = new_attr + _serialized = serialized + for k in keys: + if k not in _serialized: + _serialized.update(_new_attr) + _new_attr = _new_attr[k] + _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 = data_type.strip("[]{}") + internal_data_type = self.dependencies.get(internal_data_type, 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 = [ + 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_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): + # 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) + return result + except ValueError: + for enum_value in enum_obj: + 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: + 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 = 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=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(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 + 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 + 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 deseralize. + """ + 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__ + + 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 deseralize. + :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) + 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) + 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 value 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 is empty string. + return "" + else: + # None or '', node 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): + 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)) + + @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) + attr = attr + padding + 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) + 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) + + @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): + 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): + 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) + 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() + 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) + 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 diff --git a/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/_vendor.py b/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/_vendor.py index 138f663c53a4..9aad73fc743e 100644 --- a/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/_vendor.py +++ b/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/_vendor.py @@ -7,6 +7,7 @@ from azure.core.pipeline.transport import HttpRequest + def _convert_request(request, files=None): data = request.content if not files else None request = HttpRequest(method=request.method, url=request.url, headers=request.headers, data=data) @@ -14,6 +15,7 @@ def _convert_request(request, files=None): request.set_formdata_body(files) return request + def _format_url_section(template, **kwargs): components = template.split("/") while components: @@ -21,7 +23,5 @@ def _format_url_section(template, **kwargs): return template.format(**kwargs) except KeyError as key: formatted_components = template.split("/") - components = [ - c for c in formatted_components if "{}".format(key.args[0]) not in c - ] + components = [c for c in formatted_components if "{}".format(key.args[0]) not in c] template = "/".join(components) diff --git a/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/aio/__init__.py b/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/aio/__init__.py index fa48c8d3c253..962219d02796 100644 --- a/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/aio/__init__.py +++ b/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/aio/__init__.py @@ -7,9 +7,15 @@ # -------------------------------------------------------------------------- from ._phone_numbers_client import PhoneNumbersClient -__all__ = ['PhoneNumbersClient'] -# `._patch.py` is used for handwritten extensions to the generated code -# Example: https://github.com/Azure/azure-sdk-for-python/blob/main/doc/dev/customize_code/how-to-patch-sdk-code.md -from ._patch import patch_sdk -patch_sdk() +try: + from ._patch import __all__ as _patch_all + from ._patch import * # type: ignore # pylint: disable=unused-wildcard-import +except ImportError: + _patch_all = [] +from ._patch import patch_sdk as _patch_sdk + +__all__ = ["PhoneNumbersClient"] +__all__.extend([p for p in _patch_all if p not in __all__]) + +_patch_sdk() diff --git a/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/aio/_configuration.py b/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/aio/_configuration.py index cb41188805ef..0be20ab9b2d2 100644 --- a/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/aio/_configuration.py +++ b/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/aio/_configuration.py @@ -13,44 +13,40 @@ VERSION = "unknown" -class PhoneNumbersClientConfiguration(Configuration): + +class PhoneNumbersClientConfiguration(Configuration): # pylint: disable=too-many-instance-attributes """Configuration for PhoneNumbersClient. Note that all parameters used to create this instance are saved as instance attributes. - :param endpoint: The communication resource, for example https://resourcename.communication.azure.com. + :param endpoint: The communication resource, for example + https://resourcename.communication.azure.com. Required. :type endpoint: str - :keyword api_version: Api Version. The default value is "2022-01-11-preview2". Note that overriding this default value may result in unsupported behavior. + :keyword api_version: Api Version. Default value is "2022-01-11-preview2". Note that overriding + this default value may result in unsupported behavior. :paramtype api_version: str """ - def __init__( - self, - endpoint: str, - **kwargs: Any - ) -> None: + def __init__(self, endpoint: str, **kwargs: Any) -> None: super(PhoneNumbersClientConfiguration, self).__init__(**kwargs) - api_version = kwargs.pop('api_version', "2022-01-11-preview2") # type: str + api_version = kwargs.pop("api_version", "2022-01-11-preview2") # type: str if endpoint is None: raise ValueError("Parameter 'endpoint' must not be None.") self.endpoint = endpoint self.api_version = api_version - kwargs.setdefault('sdk_moniker', 'phonenumbersclient/{}'.format(VERSION)) + kwargs.setdefault("sdk_moniker", "phonenumbersclient/{}".format(VERSION)) self._configure(**kwargs) - def _configure( - self, - **kwargs: Any - ) -> None: - 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 policies.HttpLoggingPolicy(**kwargs) - self.retry_policy = kwargs.get('retry_policy') or policies.AsyncRetryPolicy(**kwargs) - self.custom_hook_policy = kwargs.get('custom_hook_policy') or policies.CustomHookPolicy(**kwargs) - self.redirect_policy = kwargs.get('redirect_policy') or policies.AsyncRedirectPolicy(**kwargs) - self.authentication_policy = kwargs.get('authentication_policy') + def _configure(self, **kwargs: Any) -> None: + 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 policies.HttpLoggingPolicy(**kwargs) + self.retry_policy = kwargs.get("retry_policy") or policies.AsyncRetryPolicy(**kwargs) + self.custom_hook_policy = kwargs.get("custom_hook_policy") or policies.CustomHookPolicy(**kwargs) + self.redirect_policy = kwargs.get("redirect_policy") or policies.AsyncRedirectPolicy(**kwargs) + self.authentication_policy = kwargs.get("authentication_policy") diff --git a/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/aio/_patch.py b/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/aio/_patch.py index 74e48ecd07cf..f99e77fef986 100644 --- a/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/aio/_patch.py +++ b/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/aio/_patch.py @@ -28,4 +28,4 @@ # This file is used for handwritten extensions to the generated code. Example: # https://github.com/Azure/azure-sdk-for-python/blob/main/doc/dev/customize_code/how-to-patch-sdk-code.md def patch_sdk(): - pass \ No newline at end of file + pass diff --git a/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/aio/_phone_numbers_client.py b/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/aio/_phone_numbers_client.py index 75a0c55813a0..2d425333c77e 100644 --- a/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/aio/_phone_numbers_client.py +++ b/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/aio/_phone_numbers_client.py @@ -11,35 +11,35 @@ from azure.core import AsyncPipelineClient from azure.core.rest import AsyncHttpResponse, HttpRequest -from msrest import Deserializer, Serializer from .. import models +from .._serialization import Deserializer, Serializer from ._configuration import PhoneNumbersClientConfiguration from .operations import PhoneNumbersOperations -class PhoneNumbersClient: - """The phone numbers client uses Azure Communication Services to purchase and manage phone numbers. + +class PhoneNumbersClient: # pylint: disable=client-accepts-api-version-keyword + """The phone numbers client uses Azure Communication Services to purchase and manage phone + numbers. :ivar phone_numbers: PhoneNumbersOperations operations :vartype phone_numbers: azure.communication.phonenumbers.aio.operations.PhoneNumbersOperations :param endpoint: The communication resource, for example - https://resourcename.communication.azure.com. + https://resourcename.communication.azure.com. Required. :type endpoint: str - :keyword api_version: Api Version. The default value is "2022-01-11-preview2". Note that - overriding this default value may result in unsupported behavior. + :keyword api_version: Api Version. Default value is "2022-01-11-preview2". Note that overriding + this default value may result in unsupported behavior. :paramtype api_version: str :keyword int polling_interval: Default waiting time between two polls for LRO operations if no Retry-After header is present. """ - def __init__( - self, - endpoint: str, - **kwargs: Any + def __init__( # pylint: disable=missing-client-constructor-parameter-credential + self, endpoint: str, **kwargs: Any ) -> None: - _base_url = '{endpoint}' + _endpoint = "{endpoint}" self._config = PhoneNumbersClientConfiguration(endpoint=endpoint, **kwargs) - self._client = AsyncPipelineClient(base_url=_base_url, config=self._config, **kwargs) + self._client = AsyncPipelineClient(base_url=_endpoint, config=self._config, **kwargs) client_models = {k: v for k, v in models.__dict__.items() if isinstance(v, type)} self._serialize = Serializer(client_models) @@ -47,12 +47,7 @@ def __init__( self._serialize.client_side_validation = False self.phone_numbers = PhoneNumbersOperations(self._client, self._config, self._serialize, self._deserialize) - - def _send_request( - self, - request: HttpRequest, - **kwargs: Any - ) -> Awaitable[AsyncHttpResponse]: + def _send_request(self, request: HttpRequest, **kwargs: Any) -> Awaitable[AsyncHttpResponse]: """Runs the network request through the client's chained policies. >>> from azure.core.rest import HttpRequest @@ -61,7 +56,7 @@ def _send_request( >>> response = await client._send_request(request) - For more information on this code flow, see https://aka.ms/azsdk/python/protocol/quickstart + For more information on this code flow, see https://aka.ms/azsdk/dpcodegen/python/send_request :param request: The network request you want to make. Required. :type request: ~azure.core.rest.HttpRequest @@ -72,7 +67,7 @@ def _send_request( request_copy = deepcopy(request) path_format_arguments = { - "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), + "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), } request_copy.url = self._client.format_url(request_copy.url, **path_format_arguments) diff --git a/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/aio/operations/__init__.py b/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/aio/operations/__init__.py index 3da9bcb904f3..672e6cb4743f 100644 --- a/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/aio/operations/__init__.py +++ b/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/aio/operations/__init__.py @@ -8,6 +8,12 @@ from ._phone_numbers_operations import PhoneNumbersOperations +from ._patch import __all__ as _patch_all +from ._patch import * # type: ignore # pylint: disable=unused-wildcard-import +from ._patch import patch_sdk as _patch_sdk + __all__ = [ - 'PhoneNumbersOperations', + "PhoneNumbersOperations", ] +__all__.extend([p for p in _patch_all if p not in __all__]) +_patch_sdk() diff --git a/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/aio/operations/_patch.py b/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/aio/operations/_patch.py new file mode 100644 index 000000000000..f7dd32510333 --- /dev/null +++ b/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/aio/operations/_patch.py @@ -0,0 +1,20 @@ +# ------------------------------------ +# Copyright (c) Microsoft Corporation. +# Licensed under the MIT License. +# ------------------------------------ +"""Customize generated code here. + +Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize +""" +from typing import List + +__all__: List[str] = [] # Add all objects you want publicly available to users at this package level + + +def patch_sdk(): + """Do not remove from this file. + + `patch_sdk` is a last resort escape hatch that allows you to do customizations + you can't accomplish using the techniques described in + https://aka.ms/azsdk/python/dpcodegen/python/customize + """ diff --git a/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/aio/operations/_phone_numbers_operations.py b/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/aio/operations/_phone_numbers_operations.py index d9e749ef4748..d408f01f5c53 100644 --- a/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/aio/operations/_phone_numbers_operations.py +++ b/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/aio/operations/_phone_numbers_operations.py @@ -1,3 +1,4 @@ +# pylint: disable=too-many-lines # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -5,12 +6,18 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -import functools -from typing import Any, AsyncIterable, Callable, Dict, Generic, Optional, TypeVar, Union -import warnings +from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, TypeVar, Union, cast, overload +import urllib.parse from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + map_error, +) from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import AsyncHttpResponse from azure.core.polling import AsyncLROPoller, AsyncNoPolling, AsyncPollingMethod @@ -18,103 +25,133 @@ from azure.core.rest import HttpRequest from azure.core.tracing.decorator import distributed_trace from azure.core.tracing.decorator_async import distributed_trace_async +from azure.core.utils import case_insensitive_dict from ... import models as _models from ..._vendor import _convert_request -from ...operations._phone_numbers_operations import build_cancel_operation_request, build_get_by_number_request, build_get_operation_request, build_get_search_result_request, build_list_phone_numbers_request, build_purchase_phone_numbers_request_initial, build_release_phone_number_request_initial, build_search_available_phone_numbers_request_initial, build_update_capabilities_request_initial -T = TypeVar('T') +from ...operations._phone_numbers_operations import ( + build_cancel_operation_request, + build_get_by_number_request, + build_get_operation_request, + build_get_search_result_request, + build_list_phone_numbers_request, + build_purchase_phone_numbers_request, + build_release_phone_number_request, + build_search_available_phone_numbers_request, + build_update_capabilities_request, +) + +T = TypeVar("T") ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] -class PhoneNumbersOperations: - """PhoneNumbersOperations async operations. - You should not instantiate this class directly. Instead, you should create a Client instance that - instantiates it for you and attaches it as an attribute. +class PhoneNumbersOperations: + """ + .. warning:: + **DO NOT** instantiate this class directly. - :ivar models: Alias to model classes used in this operation group. - :type models: ~azure.communication.phonenumbers.models - :param client: Client for service requests. - :param config: Configuration of service client. - :param serializer: An object model serializer. - :param deserializer: An object model deserializer. + Instead, you should access the following operations through + :class:`~azure.communication.phonenumbers.aio.PhoneNumbersClient`'s + :attr:`phone_numbers` attribute. """ models = _models - def __init__(self, client, config, serializer, deserializer) -> None: - self._client = client - self._serialize = serializer - self._deserialize = deserializer - self._config = config + def __init__(self, *args, **kwargs) -> None: + input_args = list(args) + self._client = input_args.pop(0) if input_args else kwargs.pop("client") + self._config = input_args.pop(0) if input_args else kwargs.pop("config") + self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") + self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") async def _search_available_phone_numbers_initial( - self, - country_code: str, - body: "_models.PhoneNumberSearchRequest", - **kwargs: Any - ) -> "_models.PhoneNumberSearchResult": - cls = kwargs.pop('cls', None) # type: ClsType["_models.PhoneNumberSearchResult"] + self, country_code: str, body: Union[_models.PhoneNumberSearchRequest, IO], **kwargs: Any + ) -> _models.PhoneNumberSearchResult: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {})) + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', "2022-01-11-preview2") # type: str - content_type = kwargs.pop('content_type', "application/json") # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.PhoneNumberSearchResult] - _json = self._serialize.body(body, 'PhoneNumberSearchRequest') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(body, (IO, bytes)): + _content = body + else: + _json = self._serialize.body(body, "PhoneNumberSearchRequest") - request = build_search_available_phone_numbers_request_initial( + request = build_search_available_phone_numbers_request( country_code=country_code, api_version=api_version, content_type=content_type, json=_json, - template_url=self._search_available_phone_numbers_initial.metadata['url'], + content=_content, + template_url=self._search_available_phone_numbers_initial.metadata["url"], + headers=_headers, + params=_params, ) request = _convert_request(request) path_format_arguments = { - "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), + "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), } - request.url = self._client.format_url(request.url, **path_format_arguments) + request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore + + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) - pipeline_response = await self._client._pipeline.run(request, stream=False, **kwargs) response = pipeline_response.http_response if response.status_code not in [202]: map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response) + error = self._deserialize.failsafe_deserialize(_models.CommunicationErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error) response_headers = {} - response_headers['Location']=self._deserialize('str', response.headers.get('Location')) - response_headers['Operation-Location']=self._deserialize('str', response.headers.get('Operation-Location')) - response_headers['operation-id']=self._deserialize('str', response.headers.get('operation-id')) - response_headers['search-id']=self._deserialize('str', response.headers.get('search-id')) + response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) + response_headers["Operation-Location"] = self._deserialize("str", response.headers.get("Operation-Location")) + response_headers["operation-id"] = self._deserialize("str", response.headers.get("operation-id")) + response_headers["search-id"] = self._deserialize("str", response.headers.get("search-id")) - deserialized = self._deserialize('PhoneNumberSearchResult', pipeline_response) + deserialized = self._deserialize("PhoneNumberSearchResult", pipeline_response) if cls: return cls(pipeline_response, deserialized, response_headers) return deserialized - _search_available_phone_numbers_initial.metadata = {'url': '/availablePhoneNumbers/countries/{countryCode}/:search'} # type: ignore - + _search_available_phone_numbers_initial.metadata = {"url": "/availablePhoneNumbers/countries/{countryCode}/:search"} # type: ignore - @distributed_trace_async + @overload async def begin_search_available_phone_numbers( self, country_code: str, - body: "_models.PhoneNumberSearchRequest", + body: _models.PhoneNumberSearchRequest, + *, + content_type: str = "application/json", **kwargs: Any - ) -> AsyncLROPoller["_models.PhoneNumberSearchResult"]: + ) -> AsyncLROPoller[_models.PhoneNumberSearchResult]: """Search for available phone numbers to purchase. Search for available phone numbers to purchase. - :param country_code: The ISO 3166-2 country code, e.g. US. + :param country_code: The ISO 3166-2 country code, e.g. US. Required. :type country_code: str - :param body: The phone number search request. + :param body: The phone number search request. Required. :type body: ~azure.communication.phonenumbers.models.PhoneNumberSearchRequest + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. :keyword polling: By default, your polling method will be AsyncLROBasePolling. Pass in False @@ -127,99 +164,178 @@ async def begin_search_available_phone_numbers( result of cls(response) :rtype: ~azure.core.polling.AsyncLROPoller[~azure.communication.phonenumbers.models.PhoneNumberSearchResult] - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - api_version = kwargs.pop('api_version', "2022-01-11-preview2") # type: str - content_type = kwargs.pop('content_type', "application/json") # type: Optional[str] - polling = kwargs.pop('polling', True) # type: Union[bool, azure.core.polling.AsyncPollingMethod] - cls = kwargs.pop('cls', None) # type: ClsType["_models.PhoneNumberSearchResult"] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + + @overload + async def begin_search_available_phone_numbers( + self, country_code: str, body: IO, *, content_type: str = "application/json", **kwargs: Any + ) -> AsyncLROPoller[_models.PhoneNumberSearchResult]: + """Search for available phone numbers to purchase. + + Search for available phone numbers to purchase. + + :param country_code: The ISO 3166-2 country code, e.g. US. Required. + :type country_code: str + :param body: The phone number search request. Required. + :type body: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be AsyncLROBasePolling. Pass in False + for this operation to not poll, or pass in your own initialized polling object for a personal + polling strategy. + :paramtype polling: bool or ~azure.core.polling.AsyncPollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :return: An instance of AsyncLROPoller that returns either PhoneNumberSearchResult or the + result of cls(response) + :rtype: + ~azure.core.polling.AsyncLROPoller[~azure.communication.phonenumbers.models.PhoneNumberSearchResult] + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace_async + async def begin_search_available_phone_numbers( + self, country_code: str, body: Union[_models.PhoneNumberSearchRequest, IO], **kwargs: Any + ) -> AsyncLROPoller[_models.PhoneNumberSearchResult]: + """Search for available phone numbers to purchase. + + Search for available phone numbers to purchase. + + :param country_code: The ISO 3166-2 country code, e.g. US. Required. + :type country_code: str + :param body: The phone number search request. Is either a model type or a IO type. Required. + :type body: ~azure.communication.phonenumbers.models.PhoneNumberSearchRequest or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be AsyncLROBasePolling. Pass in False + for this operation to not poll, or pass in your own initialized polling object for a personal + polling strategy. + :paramtype polling: bool or ~azure.core.polling.AsyncPollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :return: An instance of AsyncLROPoller that returns either PhoneNumberSearchResult or the + result of cls(response) + :rtype: + ~azure.core.polling.AsyncLROPoller[~azure.communication.phonenumbers.models.PhoneNumberSearchResult] + :raises ~azure.core.exceptions.HttpResponseError: + """ + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.PhoneNumberSearchResult] + polling = kwargs.pop("polling", True) # type: Union[bool, AsyncPollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: - raw_result = await self._search_available_phone_numbers_initial( + raw_result = await self._search_available_phone_numbers_initial( # type: ignore country_code=country_code, body=body, api_version=api_version, content_type=content_type, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, + headers=_headers, + params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) def get_long_running_output(pipeline_response): response_headers = {} response = pipeline_response.http_response - response_headers['Location']=self._deserialize('str', response.headers.get('Location')) - response_headers['Operation-Location']=self._deserialize('str', response.headers.get('Operation-Location')) - response_headers['operation-id']=self._deserialize('str', response.headers.get('operation-id')) - response_headers['search-id']=self._deserialize('str', response.headers.get('search-id')) - - deserialized = self._deserialize('PhoneNumberSearchResult', pipeline_response) + response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) + response_headers["Operation-Location"] = self._deserialize( + "str", response.headers.get("Operation-Location") + ) + response_headers["operation-id"] = self._deserialize("str", response.headers.get("operation-id")) + response_headers["search-id"] = self._deserialize("str", response.headers.get("search-id")) + + deserialized = self._deserialize("PhoneNumberSearchResult", pipeline_response) if cls: return cls(pipeline_response, deserialized, response_headers) return deserialized - path_format_arguments = { - "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), + "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), } - if polling is True: polling_method = AsyncLROBasePolling(lro_delay, lro_options={'final-state-via': 'location'}, path_format_arguments=path_format_arguments, **kwargs) - elif polling is False: polling_method = AsyncNoPolling() - else: polling_method = polling + if polling is True: + polling_method = cast( + AsyncPollingMethod, + AsyncLROBasePolling( + lro_delay, + lro_options={"final-state-via": "location"}, + path_format_arguments=path_format_arguments, + **kwargs + ), + ) # type: AsyncPollingMethod + elif polling is False: + polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) + else: + polling_method = polling if cont_token: return AsyncLROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) - else: - return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method) + return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_search_available_phone_numbers.metadata = {'url': '/availablePhoneNumbers/countries/{countryCode}/:search'} # type: ignore + begin_search_available_phone_numbers.metadata = {"url": "/availablePhoneNumbers/countries/{countryCode}/:search"} # type: ignore @distributed_trace_async - async def get_search_result( - self, - search_id: str, - **kwargs: Any - ) -> "_models.PhoneNumberSearchResult": + async def get_search_result(self, search_id: str, **kwargs: Any) -> _models.PhoneNumberSearchResult: """Gets a phone number search result by search id. Gets a phone number search result by search id. - :param search_id: The search Id. + :param search_id: The search Id. Required. :type search_id: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: PhoneNumberSearchResult, or the result of cls(response) + :return: PhoneNumberSearchResult or the result of cls(response) :rtype: ~azure.communication.phonenumbers.models.PhoneNumberSearchResult - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - cls = kwargs.pop('cls', None) # type: ClsType["_models.PhoneNumberSearchResult"] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {})) + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', "2022-01-11-preview2") # type: str + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.PhoneNumberSearchResult] - request = build_get_search_result_request( search_id=search_id, api_version=api_version, - template_url=self.get_search_result.metadata['url'], + template_url=self.get_search_result.metadata["url"], + headers=_headers, + params=_params, ) request = _convert_request(request) path_format_arguments = { - "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), + "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), } - request.url = self._client.format_url(request.url, **path_format_arguments) + request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore + + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) - pipeline_response = await self._client._pipeline.run(request, stream=False, **kwargs) response = pipeline_response.http_response if response.status_code not in [200]: @@ -227,75 +343,80 @@ async def get_search_result( error = self._deserialize.failsafe_deserialize(_models.CommunicationErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error) - deserialized = self._deserialize('PhoneNumberSearchResult', pipeline_response) + deserialized = self._deserialize("PhoneNumberSearchResult", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get_search_result.metadata = {'url': '/availablePhoneNumbers/searchResults/{searchId}'} # type: ignore + get_search_result.metadata = {"url": "/availablePhoneNumbers/searchResults/{searchId}"} # type: ignore - - async def _purchase_phone_numbers_initial( - self, - search_id: Optional[str] = None, - **kwargs: Any + async def _purchase_phone_numbers_initial( # pylint: disable=inconsistent-return-statements + self, search_id: Optional[str] = None, **kwargs: Any ) -> None: - cls = kwargs.pop('cls', None) # type: ClsType[None] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {})) + error_map.update(kwargs.pop("error_map", {}) or {}) - api_version = kwargs.pop('api_version', "2022-01-11-preview2") # type: str - content_type = kwargs.pop('content_type', "application/json") # type: Optional[str] + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", "application/json")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] _body = _models.PhoneNumberPurchaseRequest(search_id=search_id) - _json = self._serialize.body(_body, 'PhoneNumberPurchaseRequest') + _json = self._serialize.body(_body, "PhoneNumberPurchaseRequest") - request = build_purchase_phone_numbers_request_initial( + request = build_purchase_phone_numbers_request( api_version=api_version, content_type=content_type, json=_json, - template_url=self._purchase_phone_numbers_initial.metadata['url'], + template_url=self._purchase_phone_numbers_initial.metadata["url"], + headers=_headers, + params=_params, ) request = _convert_request(request) path_format_arguments = { - "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), + "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), } - request.url = self._client.format_url(request.url, **path_format_arguments) + request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore + + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) - pipeline_response = await self._client._pipeline.run(request, stream=False, **kwargs) response = pipeline_response.http_response if response.status_code not in [202]: map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response) + error = self._deserialize.failsafe_deserialize(_models.CommunicationErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error) response_headers = {} - response_headers['Operation-Location']=self._deserialize('str', response.headers.get('Operation-Location')) - response_headers['operation-id']=self._deserialize('str', response.headers.get('operation-id')) - response_headers['purchase-id']=self._deserialize('str', response.headers.get('purchase-id')) - + response_headers["Operation-Location"] = self._deserialize("str", response.headers.get("Operation-Location")) + response_headers["operation-id"] = self._deserialize("str", response.headers.get("operation-id")) + response_headers["purchase-id"] = self._deserialize("str", response.headers.get("purchase-id")) if cls: return cls(pipeline_response, None, response_headers) - _purchase_phone_numbers_initial.metadata = {'url': '/availablePhoneNumbers/:purchase'} # type: ignore - + _purchase_phone_numbers_initial.metadata = {"url": "/availablePhoneNumbers/:purchase"} # type: ignore @distributed_trace_async async def begin_purchase_phone_numbers( - self, - search_id: Optional[str] = None, - **kwargs: Any + self, search_id: Optional[str] = None, **kwargs: Any ) -> AsyncLROPoller[None]: """Purchases phone numbers. Purchases phone numbers. - :param search_id: The search id. + :param search_id: The search id. Default value is None. :type search_id: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. @@ -307,89 +428,101 @@ async def begin_purchase_phone_numbers( Retry-After header is present. :return: An instance of AsyncLROPoller that returns either None or the result of cls(response) :rtype: ~azure.core.polling.AsyncLROPoller[None] - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - api_version = kwargs.pop('api_version', "2022-01-11-preview2") # type: str - content_type = kwargs.pop('content_type', "application/json") # type: Optional[str] - polling = kwargs.pop('polling', True) # type: Union[bool, azure.core.polling.AsyncPollingMethod] - cls = kwargs.pop('cls', None) # type: ClsType[None] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", "application/json")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] + polling = kwargs.pop("polling", True) # type: Union[bool, AsyncPollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: - raw_result = await self._purchase_phone_numbers_initial( + raw_result = await self._purchase_phone_numbers_initial( # type: ignore search_id=search_id, api_version=api_version, content_type=content_type, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, + headers=_headers, + params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) - def get_long_running_output(pipeline_response): + def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - path_format_arguments = { - "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), + "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), } - if polling is True: polling_method = AsyncLROBasePolling(lro_delay, path_format_arguments=path_format_arguments, **kwargs) - elif polling is False: polling_method = AsyncNoPolling() - else: polling_method = polling + if polling is True: + polling_method = cast( + AsyncPollingMethod, + AsyncLROBasePolling(lro_delay, path_format_arguments=path_format_arguments, **kwargs), + ) # type: AsyncPollingMethod + elif polling is False: + polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) + else: + polling_method = polling if cont_token: return AsyncLROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) - else: - return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method) + return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_purchase_phone_numbers.metadata = {'url': '/availablePhoneNumbers/:purchase'} # type: ignore + begin_purchase_phone_numbers.metadata = {"url": "/availablePhoneNumbers/:purchase"} # type: ignore @distributed_trace_async - async def get_operation( - self, - operation_id: str, - **kwargs: Any - ) -> "_models.PhoneNumberOperation": + async def get_operation(self, operation_id: str, **kwargs: Any) -> _models.PhoneNumberOperation: """Gets an operation by its id. Gets an operation by its id. - :param operation_id: The id of the operation. + :param operation_id: The id of the operation. Required. :type operation_id: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: PhoneNumberOperation, or the result of cls(response) + :return: PhoneNumberOperation or the result of cls(response) :rtype: ~azure.communication.phonenumbers.models.PhoneNumberOperation - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - cls = kwargs.pop('cls', None) # type: ClsType["_models.PhoneNumberOperation"] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {})) + error_map.update(kwargs.pop("error_map", {}) or {}) - api_version = kwargs.pop('api_version', "2022-01-11-preview2") # type: str + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.PhoneNumberOperation] - request = build_get_operation_request( operation_id=operation_id, api_version=api_version, - template_url=self.get_operation.metadata['url'], + template_url=self.get_operation.metadata["url"], + headers=_headers, + params=_params, ) request = _convert_request(request) path_format_arguments = { - "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), + "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), } - request.url = self._client.format_url(request.url, **path_format_arguments) + request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore + + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) - pipeline_response = await self._client._pipeline.run(request, stream=False, **kwargs) response = pipeline_response.http_response if response.status_code not in [200]: @@ -398,56 +531,63 @@ async def get_operation( raise HttpResponseError(response=response, model=error) response_headers = {} - response_headers['Location']=self._deserialize('str', response.headers.get('Location')) + response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - deserialized = self._deserialize('PhoneNumberOperation', pipeline_response) + deserialized = self._deserialize("PhoneNumberOperation", pipeline_response) if cls: return cls(pipeline_response, deserialized, response_headers) return deserialized - get_operation.metadata = {'url': '/phoneNumbers/operations/{operationId}'} # type: ignore - + get_operation.metadata = {"url": "/phoneNumbers/operations/{operationId}"} # type: ignore @distributed_trace_async - async def cancel_operation( - self, - operation_id: str, - **kwargs: Any + async def cancel_operation( # pylint: disable=inconsistent-return-statements + self, operation_id: str, **kwargs: Any ) -> None: """Cancels an operation by its id. Cancels an operation by its id. - :param operation_id: The id of the operation. + :param operation_id: The id of the operation. Required. :type operation_id: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - cls = kwargs.pop('cls', None) # type: ClsType[None] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {})) + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', "2022-01-11-preview2") # type: str + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - request = build_cancel_operation_request( operation_id=operation_id, api_version=api_version, - template_url=self.cancel_operation.metadata['url'], + template_url=self.cancel_operation.metadata["url"], + headers=_headers, + params=_params, ) request = _convert_request(request) path_format_arguments = { - "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), + "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), } - request.url = self._client.format_url(request.url, **path_format_arguments) + request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore + + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) - pipeline_response = await self._client._pipeline.run(request, stream=False, **kwargs) response = pipeline_response.http_response if response.status_code not in [204]: @@ -458,85 +598,99 @@ async def cancel_operation( if cls: return cls(pipeline_response, None, {}) - cancel_operation.metadata = {'url': '/phoneNumbers/operations/{operationId}'} # type: ignore - + cancel_operation.metadata = {"url": "/phoneNumbers/operations/{operationId}"} # type: ignore async def _update_capabilities_initial( self, phone_number: str, - calling: Optional[Union[str, "_models.PhoneNumberCapabilityType"]] = None, - sms: Optional[Union[str, "_models.PhoneNumberCapabilityType"]] = None, + calling: Optional[Union[str, _models.PhoneNumberCapabilityType]] = None, + sms: Optional[Union[str, _models.PhoneNumberCapabilityType]] = None, **kwargs: Any - ) -> "_models.PurchasedPhoneNumber": - cls = kwargs.pop('cls', None) # type: ClsType["_models.PurchasedPhoneNumber"] + ) -> _models.PurchasedPhoneNumber: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {})) + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', "2022-01-11-preview2") # type: str - content_type = kwargs.pop('content_type', "application/merge-patch+json") # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop( + "content_type", _headers.pop("Content-Type", "application/merge-patch+json") + ) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.PurchasedPhoneNumber] _body = _models.PhoneNumberCapabilitiesRequest(calling=calling, sms=sms) if _body is not None: - _json = self._serialize.body(_body, 'PhoneNumberCapabilitiesRequest') + _json = self._serialize.body(_body, "PhoneNumberCapabilitiesRequest") else: _json = None - request = build_update_capabilities_request_initial( + request = build_update_capabilities_request( phone_number=phone_number, api_version=api_version, content_type=content_type, json=_json, - template_url=self._update_capabilities_initial.metadata['url'], + template_url=self._update_capabilities_initial.metadata["url"], + headers=_headers, + params=_params, ) request = _convert_request(request) path_format_arguments = { - "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), + "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), } - request.url = self._client.format_url(request.url, **path_format_arguments) + request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore + + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) - pipeline_response = await self._client._pipeline.run(request, stream=False, **kwargs) response = pipeline_response.http_response if response.status_code not in [202]: map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response) + error = self._deserialize.failsafe_deserialize(_models.CommunicationErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error) response_headers = {} - response_headers['Location']=self._deserialize('str', response.headers.get('Location')) - response_headers['Operation-Location']=self._deserialize('str', response.headers.get('Operation-Location')) - response_headers['operation-id']=self._deserialize('str', response.headers.get('operation-id')) - response_headers['capabilities-id']=self._deserialize('str', response.headers.get('capabilities-id')) + response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) + response_headers["Operation-Location"] = self._deserialize("str", response.headers.get("Operation-Location")) + response_headers["operation-id"] = self._deserialize("str", response.headers.get("operation-id")) + response_headers["capabilities-id"] = self._deserialize("str", response.headers.get("capabilities-id")) - deserialized = self._deserialize('PurchasedPhoneNumber', pipeline_response) + deserialized = self._deserialize("PurchasedPhoneNumber", pipeline_response) if cls: return cls(pipeline_response, deserialized, response_headers) return deserialized - _update_capabilities_initial.metadata = {'url': '/phoneNumbers/{phoneNumber}/capabilities'} # type: ignore - + _update_capabilities_initial.metadata = {"url": "/phoneNumbers/{phoneNumber}/capabilities"} # type: ignore @distributed_trace_async async def begin_update_capabilities( self, phone_number: str, - calling: Optional[Union[str, "_models.PhoneNumberCapabilityType"]] = None, - sms: Optional[Union[str, "_models.PhoneNumberCapabilityType"]] = None, + calling: Optional[Union[str, _models.PhoneNumberCapabilityType]] = None, + sms: Optional[Union[str, _models.PhoneNumberCapabilityType]] = None, **kwargs: Any - ) -> AsyncLROPoller["_models.PurchasedPhoneNumber"]: + ) -> AsyncLROPoller[_models.PurchasedPhoneNumber]: """Updates the capabilities of a phone number. Updates the capabilities of a phone number. :param phone_number: The phone number id in E.164 format. The leading plus can be either + or - encoded as %2B, e.g. +11234567890. + encoded as %2B, e.g. +11234567890. Required. :type phone_number: str - :param calling: Capability value for calling. + :param calling: Capability value for calling. Known values are: "none", "inbound", "outbound", + and "inbound+outbound". Default value is None. :type calling: str or ~azure.communication.phonenumbers.models.PhoneNumberCapabilityType - :param sms: Capability value for SMS. + :param sms: Capability value for SMS. Known values are: "none", "inbound", "outbound", and + "inbound+outbound". Default value is None. :type sms: str or ~azure.communication.phonenumbers.models.PhoneNumberCapabilityType :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. @@ -550,101 +704,122 @@ async def begin_update_capabilities( of cls(response) :rtype: ~azure.core.polling.AsyncLROPoller[~azure.communication.phonenumbers.models.PurchasedPhoneNumber] - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - api_version = kwargs.pop('api_version', "2022-01-11-preview2") # type: str - content_type = kwargs.pop('content_type', "application/merge-patch+json") # type: Optional[str] - polling = kwargs.pop('polling', True) # type: Union[bool, azure.core.polling.AsyncPollingMethod] - cls = kwargs.pop('cls', None) # type: ClsType["_models.PurchasedPhoneNumber"] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop( + "content_type", _headers.pop("Content-Type", "application/merge-patch+json") + ) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.PurchasedPhoneNumber] + polling = kwargs.pop("polling", True) # type: Union[bool, AsyncPollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: - raw_result = await self._update_capabilities_initial( + raw_result = await self._update_capabilities_initial( # type: ignore phone_number=phone_number, calling=calling, sms=sms, api_version=api_version, content_type=content_type, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, + headers=_headers, + params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) def get_long_running_output(pipeline_response): response_headers = {} response = pipeline_response.http_response - response_headers['Location']=self._deserialize('str', response.headers.get('Location')) - response_headers['Operation-Location']=self._deserialize('str', response.headers.get('Operation-Location')) - response_headers['operation-id']=self._deserialize('str', response.headers.get('operation-id')) - response_headers['capabilities-id']=self._deserialize('str', response.headers.get('capabilities-id')) - - deserialized = self._deserialize('PurchasedPhoneNumber', pipeline_response) + response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) + response_headers["Operation-Location"] = self._deserialize( + "str", response.headers.get("Operation-Location") + ) + response_headers["operation-id"] = self._deserialize("str", response.headers.get("operation-id")) + response_headers["capabilities-id"] = self._deserialize("str", response.headers.get("capabilities-id")) + + deserialized = self._deserialize("PurchasedPhoneNumber", pipeline_response) if cls: return cls(pipeline_response, deserialized, response_headers) return deserialized - path_format_arguments = { - "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), + "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), } - if polling is True: polling_method = AsyncLROBasePolling(lro_delay, lro_options={'final-state-via': 'location'}, path_format_arguments=path_format_arguments, **kwargs) - elif polling is False: polling_method = AsyncNoPolling() - else: polling_method = polling + if polling is True: + polling_method = cast( + AsyncPollingMethod, + AsyncLROBasePolling( + lro_delay, + lro_options={"final-state-via": "location"}, + path_format_arguments=path_format_arguments, + **kwargs + ), + ) # type: AsyncPollingMethod + elif polling is False: + polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) + else: + polling_method = polling if cont_token: return AsyncLROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) - else: - return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method) + return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_update_capabilities.metadata = {'url': '/phoneNumbers/{phoneNumber}/capabilities'} # type: ignore + begin_update_capabilities.metadata = {"url": "/phoneNumbers/{phoneNumber}/capabilities"} # type: ignore @distributed_trace_async - async def get_by_number( - self, - phone_number: str, - **kwargs: Any - ) -> "_models.PurchasedPhoneNumber": + async def get_by_number(self, phone_number: str, **kwargs: Any) -> _models.PurchasedPhoneNumber: """Gets the details of the given purchased phone number. Gets the details of the given purchased phone number. :param phone_number: The purchased phone number whose details are to be fetched in E.164 - format, e.g. +11234567890. + format, e.g. +11234567890. Required. :type phone_number: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: PurchasedPhoneNumber, or the result of cls(response) + :return: PurchasedPhoneNumber or the result of cls(response) :rtype: ~azure.communication.phonenumbers.models.PurchasedPhoneNumber - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - cls = kwargs.pop('cls', None) # type: ClsType["_models.PurchasedPhoneNumber"] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {})) + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', "2022-01-11-preview2") # type: str + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.PurchasedPhoneNumber] - request = build_get_by_number_request( phone_number=phone_number, api_version=api_version, - template_url=self.get_by_number.metadata['url'], + template_url=self.get_by_number.metadata["url"], + headers=_headers, + params=_params, ) request = _convert_request(request) path_format_arguments = { - "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), + "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), } - request.url = self._client.format_url(request.url, **path_format_arguments) + request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore + + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) - pipeline_response = await self._client._pipeline.run(request, stream=False, **kwargs) response = pipeline_response.http_response if response.status_code not in [200]: @@ -652,71 +827,73 @@ async def get_by_number( error = self._deserialize.failsafe_deserialize(_models.CommunicationErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error) - deserialized = self._deserialize('PurchasedPhoneNumber', pipeline_response) + deserialized = self._deserialize("PurchasedPhoneNumber", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get_by_number.metadata = {'url': '/phoneNumbers/{phoneNumber}'} # type: ignore + get_by_number.metadata = {"url": "/phoneNumbers/{phoneNumber}"} # type: ignore - - async def _release_phone_number_initial( - self, - phone_number: str, - **kwargs: Any + async def _release_phone_number_initial( # pylint: disable=inconsistent-return-statements + self, phone_number: str, **kwargs: Any ) -> None: - cls = kwargs.pop('cls', None) # type: ClsType[None] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {})) + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', "2022-01-11-preview2") # type: str + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - - request = build_release_phone_number_request_initial( + request = build_release_phone_number_request( phone_number=phone_number, api_version=api_version, - template_url=self._release_phone_number_initial.metadata['url'], + template_url=self._release_phone_number_initial.metadata["url"], + headers=_headers, + params=_params, ) request = _convert_request(request) path_format_arguments = { - "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), + "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), } - request.url = self._client.format_url(request.url, **path_format_arguments) + request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore + + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) - pipeline_response = await self._client._pipeline.run(request, stream=False, **kwargs) response = pipeline_response.http_response if response.status_code not in [202]: map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response) + error = self._deserialize.failsafe_deserialize(_models.CommunicationErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error) response_headers = {} - response_headers['Operation-Location']=self._deserialize('str', response.headers.get('Operation-Location')) - response_headers['operation-id']=self._deserialize('str', response.headers.get('operation-id')) - response_headers['release-id']=self._deserialize('str', response.headers.get('release-id')) - + response_headers["Operation-Location"] = self._deserialize("str", response.headers.get("Operation-Location")) + response_headers["operation-id"] = self._deserialize("str", response.headers.get("operation-id")) + response_headers["release-id"] = self._deserialize("str", response.headers.get("release-id")) if cls: return cls(pipeline_response, None, response_headers) - _release_phone_number_initial.metadata = {'url': '/phoneNumbers/{phoneNumber}'} # type: ignore - + _release_phone_number_initial.metadata = {"url": "/phoneNumbers/{phoneNumber}"} # type: ignore @distributed_trace_async - async def begin_release_phone_number( - self, - phone_number: str, - **kwargs: Any - ) -> AsyncLROPoller[None]: + async def begin_release_phone_number(self, phone_number: str, **kwargs: Any) -> AsyncLROPoller[None]: """Releases a purchased phone number. Releases a purchased phone number. - :param phone_number: Phone number to be released, e.g. +11234567890. + :param phone_number: Phone number to be released, e.g. +11234567890. Required. :type phone_number: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. @@ -728,112 +905,129 @@ async def begin_release_phone_number( Retry-After header is present. :return: An instance of AsyncLROPoller that returns either None or the result of cls(response) :rtype: ~azure.core.polling.AsyncLROPoller[None] - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - api_version = kwargs.pop('api_version', "2022-01-11-preview2") # type: str - polling = kwargs.pop('polling', True) # type: Union[bool, azure.core.polling.AsyncPollingMethod] - cls = kwargs.pop('cls', None) # type: ClsType[None] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] + polling = kwargs.pop("polling", True) # type: Union[bool, AsyncPollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: - raw_result = await self._release_phone_number_initial( + raw_result = await self._release_phone_number_initial( # type: ignore phone_number=phone_number, api_version=api_version, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, + headers=_headers, + params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) - def get_long_running_output(pipeline_response): + def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - path_format_arguments = { - "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), + "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), } - if polling is True: polling_method = AsyncLROBasePolling(lro_delay, path_format_arguments=path_format_arguments, **kwargs) - elif polling is False: polling_method = AsyncNoPolling() - else: polling_method = polling + if polling is True: + polling_method = cast( + AsyncPollingMethod, + AsyncLROBasePolling(lro_delay, path_format_arguments=path_format_arguments, **kwargs), + ) # type: AsyncPollingMethod + elif polling is False: + polling_method = cast(AsyncPollingMethod, AsyncNoPolling()) + else: + polling_method = polling if cont_token: return AsyncLROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) - else: - return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method) + return AsyncLROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_release_phone_number.metadata = {'url': '/phoneNumbers/{phoneNumber}'} # type: ignore + begin_release_phone_number.metadata = {"url": "/phoneNumbers/{phoneNumber}"} # type: ignore @distributed_trace def list_phone_numbers( - self, - skip: Optional[int] = 0, - top: Optional[int] = 100, - **kwargs: Any - ) -> AsyncIterable["_models.PurchasedPhoneNumbers"]: + self, skip: int = 0, top: int = 100, **kwargs: Any + ) -> AsyncIterable["_models.PurchasedPhoneNumber"]: """Gets the list of all purchased phone numbers. Gets the list of all purchased phone numbers. :param skip: An optional parameter for how many entries to skip, for pagination purposes. The - default value is 0. + default value is 0. Default value is 0. :type skip: int :param top: An optional parameter for how many entries to return, for pagination purposes. The - default value is 100. + default value is 100. Default value is 100. :type top: int :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either PurchasedPhoneNumbers or the result of + :return: An iterator like instance of either PurchasedPhoneNumber or the result of cls(response) :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.communication.phonenumbers.models.PurchasedPhoneNumbers] - :raises: ~azure.core.exceptions.HttpResponseError + ~azure.core.async_paging.AsyncItemPaged[~azure.communication.phonenumbers.models.PurchasedPhoneNumber] + :raises ~azure.core.exceptions.HttpResponseError: """ - api_version = kwargs.pop('api_version', "2022-01-11-preview2") # type: str + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.PurchasedPhoneNumbers] - cls = kwargs.pop('cls', None) # type: ClsType["_models.PurchasedPhoneNumbers"] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {})) + error_map.update(kwargs.pop("error_map", {}) or {}) + def prepare_request(next_link=None): if not next_link: - + request = build_list_phone_numbers_request( - api_version=api_version, skip=skip, top=top, - template_url=self.list_phone_numbers.metadata['url'], + api_version=api_version, + template_url=self.list_phone_numbers.metadata["url"], + headers=_headers, + params=_params, ) request = _convert_request(request) path_format_arguments = { - "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), + "endpoint": self._serialize.url( + "self._config.endpoint", self._config.endpoint, "str", skip_quote=True + ), } - request.url = self._client.format_url(request.url, **path_format_arguments) + request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore else: - - request = build_list_phone_numbers_request( - api_version=api_version, - skip=skip, - top=top, - template_url=next_link, + # make call to next link with the client's api-version + _parsed_next_link = urllib.parse.urlparse(next_link) + _next_request_params = case_insensitive_dict( + { + key: [urllib.parse.quote(v) for v in value] + for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() + } + ) + _next_request_params["api-version"] = self._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) path_format_arguments = { - "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), - } - request.url = self._client.format_url(request.url, **path_format_arguments) - - path_format_arguments = { - "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), + "endpoint": self._serialize.url( + "self._config.endpoint", self._config.endpoint, "str", skip_quote=True + ), } + request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore request.method = "GET" return request @@ -847,7 +1041,9 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run(request, stream=False, **kwargs) + pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) response = pipeline_response.http_response if response.status_code not in [200]: @@ -857,8 +1053,6 @@ async def get_next(next_link=None): return pipeline_response + return AsyncItemPaged(get_next, extract_data) - return AsyncItemPaged( - get_next, extract_data - ) - list_phone_numbers.metadata = {'url': '/phoneNumbers'} # type: ignore + list_phone_numbers.metadata = {"url": "/phoneNumbers"} # type: ignore diff --git a/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/models/__init__.py b/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/models/__init__.py index 78f604eeceb6..b9376da61303 100644 --- a/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/models/__init__.py +++ b/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/models/__init__.py @@ -6,56 +6,46 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -try: - from ._models_py3 import CommunicationError - from ._models_py3 import CommunicationErrorResponse - from ._models_py3 import PhoneNumberCapabilities - from ._models_py3 import PhoneNumberCapabilitiesRequest - from ._models_py3 import PhoneNumberCost - from ._models_py3 import PhoneNumberOperation - from ._models_py3 import PhoneNumberPurchaseRequest - from ._models_py3 import PhoneNumberSearchRequest - from ._models_py3 import PhoneNumberSearchResult - from ._models_py3 import PurchasedPhoneNumber - from ._models_py3 import PurchasedPhoneNumbers -except (SyntaxError, ImportError): - from ._models import CommunicationError # type: ignore - from ._models import CommunicationErrorResponse # type: ignore - from ._models import PhoneNumberCapabilities # type: ignore - from ._models import PhoneNumberCapabilitiesRequest # type: ignore - from ._models import PhoneNumberCost # type: ignore - from ._models import PhoneNumberOperation # type: ignore - from ._models import PhoneNumberPurchaseRequest # type: ignore - from ._models import PhoneNumberSearchRequest # type: ignore - from ._models import PhoneNumberSearchResult # type: ignore - from ._models import PurchasedPhoneNumber # type: ignore - from ._models import PurchasedPhoneNumbers # type: ignore +from ._models_py3 import CommunicationError +from ._models_py3 import CommunicationErrorResponse +from ._models_py3 import PhoneNumberCapabilities +from ._models_py3 import PhoneNumberCapabilitiesRequest +from ._models_py3 import PhoneNumberCost +from ._models_py3 import PhoneNumberOperation +from ._models_py3 import PhoneNumberPurchaseRequest +from ._models_py3 import PhoneNumberSearchRequest +from ._models_py3 import PhoneNumberSearchResult +from ._models_py3 import PurchasedPhoneNumber +from ._models_py3 import PurchasedPhoneNumbers -from ._phone_numbers_client_enums import ( - BillingFrequency, - PhoneNumberAssignmentType, - PhoneNumberCapabilityType, - PhoneNumberOperationStatus, - PhoneNumberOperationType, - PhoneNumberType, -) +from ._phone_numbers_client_enums import BillingFrequency +from ._phone_numbers_client_enums import PhoneNumberAssignmentType +from ._phone_numbers_client_enums import PhoneNumberCapabilityType +from ._phone_numbers_client_enums import PhoneNumberOperationStatus +from ._phone_numbers_client_enums import PhoneNumberOperationType +from ._phone_numbers_client_enums import PhoneNumberType +from ._patch import __all__ as _patch_all +from ._patch import * # type: ignore # pylint: disable=unused-wildcard-import +from ._patch import patch_sdk as _patch_sdk __all__ = [ - 'CommunicationError', - 'CommunicationErrorResponse', - 'PhoneNumberCapabilities', - 'PhoneNumberCapabilitiesRequest', - 'PhoneNumberCost', - 'PhoneNumberOperation', - 'PhoneNumberPurchaseRequest', - 'PhoneNumberSearchRequest', - 'PhoneNumberSearchResult', - 'PurchasedPhoneNumber', - 'PurchasedPhoneNumbers', - 'BillingFrequency', - 'PhoneNumberAssignmentType', - 'PhoneNumberCapabilityType', - 'PhoneNumberOperationStatus', - 'PhoneNumberOperationType', - 'PhoneNumberType', + "CommunicationError", + "CommunicationErrorResponse", + "PhoneNumberCapabilities", + "PhoneNumberCapabilitiesRequest", + "PhoneNumberCost", + "PhoneNumberOperation", + "PhoneNumberPurchaseRequest", + "PhoneNumberSearchRequest", + "PhoneNumberSearchResult", + "PurchasedPhoneNumber", + "PurchasedPhoneNumbers", + "BillingFrequency", + "PhoneNumberAssignmentType", + "PhoneNumberCapabilityType", + "PhoneNumberOperationStatus", + "PhoneNumberOperationType", + "PhoneNumberType", ] +__all__.extend([p for p in _patch_all if p not in __all__]) +_patch_sdk() diff --git a/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/models/_models.py b/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/models/_models.py deleted file mode 100644 index ade1ff69a46a..000000000000 --- a/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/models/_models.py +++ /dev/null @@ -1,577 +0,0 @@ -# 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 azure.core.exceptions import HttpResponseError -import msrest.serialization - - -class CommunicationError(msrest.serialization.Model): - """The Communication Services error. - - Variables are only populated by the server, and will be ignored when sending a request. - - All required parameters must be populated in order to send to Azure. - - :ivar code: Required. The error code. - :vartype code: str - :ivar message: Required. The error message. - :vartype message: str - :ivar target: The error target. - :vartype target: str - :ivar details: Further details about specific errors that led to this error. - :vartype details: list[~azure.communication.phonenumbers.models.CommunicationError] - :ivar inner_error: The inner error if any. - :vartype inner_error: ~azure.communication.phonenumbers.models.CommunicationError - """ - - _validation = { - 'code': {'required': True}, - 'message': {'required': True}, - 'target': {'readonly': True}, - 'details': {'readonly': True}, - 'inner_error': {'readonly': True}, - } - - _attribute_map = { - 'code': {'key': 'code', 'type': 'str'}, - 'message': {'key': 'message', 'type': 'str'}, - 'target': {'key': 'target', 'type': 'str'}, - 'details': {'key': 'details', 'type': '[CommunicationError]'}, - 'inner_error': {'key': 'innererror', 'type': 'CommunicationError'}, - } - - def __init__( - self, - **kwargs - ): - """ - :keyword code: Required. The error code. - :paramtype code: str - :keyword message: Required. The error message. - :paramtype message: str - """ - super(CommunicationError, self).__init__(**kwargs) - self.code = kwargs['code'] - self.message = kwargs['message'] - self.target = None - self.details = None - self.inner_error = None - - -class CommunicationErrorResponse(msrest.serialization.Model): - """The Communication Services error. - - All required parameters must be populated in order to send to Azure. - - :ivar error: Required. The Communication Services error. - :vartype error: ~azure.communication.phonenumbers.models.CommunicationError - """ - - _validation = { - 'error': {'required': True}, - } - - _attribute_map = { - 'error': {'key': 'error', 'type': 'CommunicationError'}, - } - - def __init__( - self, - **kwargs - ): - """ - :keyword error: Required. The Communication Services error. - :paramtype error: ~azure.communication.phonenumbers.models.CommunicationError - """ - super(CommunicationErrorResponse, self).__init__(**kwargs) - self.error = kwargs['error'] - - -class PhoneNumberCapabilities(msrest.serialization.Model): - """Capabilities of a phone number. - - All required parameters must be populated in order to send to Azure. - - :ivar calling: Required. Capability value for calling. Possible values include: "none", - "inbound", "outbound", "inbound+outbound". - :vartype calling: str or ~azure.communication.phonenumbers.models.PhoneNumberCapabilityType - :ivar sms: Required. Capability value for SMS. Possible values include: "none", "inbound", - "outbound", "inbound+outbound". - :vartype sms: str or ~azure.communication.phonenumbers.models.PhoneNumberCapabilityType - """ - - _validation = { - 'calling': {'required': True}, - 'sms': {'required': True}, - } - - _attribute_map = { - 'calling': {'key': 'calling', 'type': 'str'}, - 'sms': {'key': 'sms', 'type': 'str'}, - } - - def __init__( - self, - **kwargs - ): - """ - :keyword calling: Required. Capability value for calling. Possible values include: "none", - "inbound", "outbound", "inbound+outbound". - :paramtype calling: str or ~azure.communication.phonenumbers.models.PhoneNumberCapabilityType - :keyword sms: Required. Capability value for SMS. Possible values include: "none", "inbound", - "outbound", "inbound+outbound". - :paramtype sms: str or ~azure.communication.phonenumbers.models.PhoneNumberCapabilityType - """ - super(PhoneNumberCapabilities, self).__init__(**kwargs) - self.calling = kwargs['calling'] - self.sms = kwargs['sms'] - - -class PhoneNumberCapabilitiesRequest(msrest.serialization.Model): - """Capabilities of a phone number. - - :ivar calling: Capability value for calling. Possible values include: "none", "inbound", - "outbound", "inbound+outbound". - :vartype calling: str or ~azure.communication.phonenumbers.models.PhoneNumberCapabilityType - :ivar sms: Capability value for SMS. Possible values include: "none", "inbound", "outbound", - "inbound+outbound". - :vartype sms: str or ~azure.communication.phonenumbers.models.PhoneNumberCapabilityType - """ - - _attribute_map = { - 'calling': {'key': 'calling', 'type': 'str'}, - 'sms': {'key': 'sms', 'type': 'str'}, - } - - def __init__( - self, - **kwargs - ): - """ - :keyword calling: Capability value for calling. Possible values include: "none", "inbound", - "outbound", "inbound+outbound". - :paramtype calling: str or ~azure.communication.phonenumbers.models.PhoneNumberCapabilityType - :keyword sms: Capability value for SMS. Possible values include: "none", "inbound", "outbound", - "inbound+outbound". - :paramtype sms: str or ~azure.communication.phonenumbers.models.PhoneNumberCapabilityType - """ - super(PhoneNumberCapabilitiesRequest, self).__init__(**kwargs) - self.calling = kwargs.get('calling', None) - self.sms = kwargs.get('sms', None) - - -class PhoneNumberCost(msrest.serialization.Model): - """The incurred cost for a single phone number. - - All required parameters must be populated in order to send to Azure. - - :ivar amount: Required. The cost amount. - :vartype amount: float - :ivar currency_code: Required. The ISO 4217 currency code for the cost amount, e.g. USD. - :vartype currency_code: str - :ivar billing_frequency: Required. The frequency with which the cost gets billed. Possible - values include: "monthly". - :vartype billing_frequency: str or ~azure.communication.phonenumbers.models.BillingFrequency - """ - - _validation = { - 'amount': {'required': True}, - 'currency_code': {'required': True}, - 'billing_frequency': {'required': True}, - } - - _attribute_map = { - 'amount': {'key': 'amount', 'type': 'float'}, - 'currency_code': {'key': 'currencyCode', 'type': 'str'}, - 'billing_frequency': {'key': 'billingFrequency', 'type': 'str'}, - } - - def __init__( - self, - **kwargs - ): - """ - :keyword amount: Required. The cost amount. - :paramtype amount: float - :keyword currency_code: Required. The ISO 4217 currency code for the cost amount, e.g. USD. - :paramtype currency_code: str - :keyword billing_frequency: Required. The frequency with which the cost gets billed. Possible - values include: "monthly". - :paramtype billing_frequency: str or ~azure.communication.phonenumbers.models.BillingFrequency - """ - super(PhoneNumberCost, self).__init__(**kwargs) - self.amount = kwargs['amount'] - self.currency_code = kwargs['currency_code'] - self.billing_frequency = kwargs['billing_frequency'] - - -class PhoneNumberOperation(msrest.serialization.Model): - """Long running operation. - - Variables are only populated by the server, and will be ignored when sending a request. - - All required parameters must be populated in order to send to Azure. - - :ivar status: Required. Status of operation. Possible values include: "notStarted", "running", - "succeeded", "failed". - :vartype status: str or ~azure.communication.phonenumbers.models.PhoneNumberOperationStatus - :ivar resource_location: URL for retrieving the result of the operation, if any. - :vartype resource_location: str - :ivar created_date_time: Required. The date that the operation was created. - :vartype created_date_time: ~datetime.datetime - :ivar error: The Communication Services error. - :vartype error: ~azure.communication.phonenumbers.models.CommunicationError - :ivar id: Required. Id of operation. - :vartype id: str - :ivar operation_type: Required. The type of operation, e.g. Search. Possible values include: - "purchase", "releasePhoneNumber", "search", "updatePhoneNumberCapabilities". - :vartype operation_type: str or - ~azure.communication.phonenumbers.models.PhoneNumberOperationType - :ivar last_action_date_time: The most recent date that the operation was changed. - :vartype last_action_date_time: ~datetime.datetime - """ - - _validation = { - 'status': {'required': True}, - 'created_date_time': {'required': True}, - 'id': {'required': True}, - 'operation_type': {'required': True}, - 'last_action_date_time': {'readonly': True}, - } - - _attribute_map = { - 'status': {'key': 'status', 'type': 'str'}, - 'resource_location': {'key': 'resourceLocation', 'type': 'str'}, - 'created_date_time': {'key': 'createdDateTime', 'type': 'iso-8601'}, - 'error': {'key': 'error', 'type': 'CommunicationError'}, - 'id': {'key': 'id', 'type': 'str'}, - 'operation_type': {'key': 'operationType', 'type': 'str'}, - 'last_action_date_time': {'key': 'lastActionDateTime', 'type': 'iso-8601'}, - } - - def __init__( - self, - **kwargs - ): - """ - :keyword status: Required. Status of operation. Possible values include: "notStarted", - "running", "succeeded", "failed". - :paramtype status: str or ~azure.communication.phonenumbers.models.PhoneNumberOperationStatus - :keyword resource_location: URL for retrieving the result of the operation, if any. - :paramtype resource_location: str - :keyword created_date_time: Required. The date that the operation was created. - :paramtype created_date_time: ~datetime.datetime - :keyword error: The Communication Services error. - :paramtype error: ~azure.communication.phonenumbers.models.CommunicationError - :keyword id: Required. Id of operation. - :paramtype id: str - :keyword operation_type: Required. The type of operation, e.g. Search. Possible values include: - "purchase", "releasePhoneNumber", "search", "updatePhoneNumberCapabilities". - :paramtype operation_type: str or - ~azure.communication.phonenumbers.models.PhoneNumberOperationType - """ - super(PhoneNumberOperation, self).__init__(**kwargs) - self.status = kwargs['status'] - self.resource_location = kwargs.get('resource_location', None) - self.created_date_time = kwargs['created_date_time'] - self.error = kwargs.get('error', None) - self.id = kwargs['id'] - self.operation_type = kwargs['operation_type'] - self.last_action_date_time = None - - -class PhoneNumberPurchaseRequest(msrest.serialization.Model): - """The phone number search purchase request. - - :ivar search_id: The search id. - :vartype search_id: str - """ - - _attribute_map = { - 'search_id': {'key': 'searchId', 'type': 'str'}, - } - - def __init__( - self, - **kwargs - ): - """ - :keyword search_id: The search id. - :paramtype search_id: str - """ - super(PhoneNumberPurchaseRequest, self).__init__(**kwargs) - self.search_id = kwargs.get('search_id', None) - - -class PhoneNumberSearchRequest(msrest.serialization.Model): - """Represents a phone number search request to find phone numbers. Found phone numbers are temporarily held for a following purchase. - - All required parameters must be populated in order to send to Azure. - - :ivar phone_number_type: Required. The type of phone numbers to search for, e.g. geographic, or - tollFree. Possible values include: "geographic", "tollFree". - :vartype phone_number_type: str or ~azure.communication.phonenumbers.models.PhoneNumberType - :ivar assignment_type: Required. The assignment type of the phone numbers to search for. A - phone number can be assigned to a person, or to an application. Possible values include: - "person", "application". - :vartype assignment_type: str or - ~azure.communication.phonenumbers.models.PhoneNumberAssignmentType - :ivar capabilities: Required. Capabilities of a phone number. - :vartype capabilities: ~azure.communication.phonenumbers.models.PhoneNumberCapabilities - :ivar area_code: The area code of the desired phone number, e.g. 425. - :vartype area_code: str - :ivar quantity: The quantity of desired phone numbers. The default value is 1. - :vartype quantity: int - """ - - _validation = { - 'phone_number_type': {'required': True}, - 'assignment_type': {'required': True}, - 'capabilities': {'required': True}, - 'quantity': {'maximum': 2147483647, 'minimum': 1}, - } - - _attribute_map = { - 'phone_number_type': {'key': 'phoneNumberType', 'type': 'str'}, - 'assignment_type': {'key': 'assignmentType', 'type': 'str'}, - 'capabilities': {'key': 'capabilities', 'type': 'PhoneNumberCapabilities'}, - 'area_code': {'key': 'areaCode', 'type': 'str'}, - 'quantity': {'key': 'quantity', 'type': 'int'}, - } - - def __init__( - self, - **kwargs - ): - """ - :keyword phone_number_type: Required. The type of phone numbers to search for, e.g. geographic, - or tollFree. Possible values include: "geographic", "tollFree". - :paramtype phone_number_type: str or ~azure.communication.phonenumbers.models.PhoneNumberType - :keyword assignment_type: Required. The assignment type of the phone numbers to search for. A - phone number can be assigned to a person, or to an application. Possible values include: - "person", "application". - :paramtype assignment_type: str or - ~azure.communication.phonenumbers.models.PhoneNumberAssignmentType - :keyword capabilities: Required. Capabilities of a phone number. - :paramtype capabilities: ~azure.communication.phonenumbers.models.PhoneNumberCapabilities - :keyword area_code: The area code of the desired phone number, e.g. 425. - :paramtype area_code: str - :keyword quantity: The quantity of desired phone numbers. The default value is 1. - :paramtype quantity: int - """ - super(PhoneNumberSearchRequest, self).__init__(**kwargs) - self.phone_number_type = kwargs['phone_number_type'] - self.assignment_type = kwargs['assignment_type'] - self.capabilities = kwargs['capabilities'] - self.area_code = kwargs.get('area_code', None) - self.quantity = kwargs.get('quantity', 1) - - -class PhoneNumberSearchResult(msrest.serialization.Model): - """The result of a phone number search operation. - - All required parameters must be populated in order to send to Azure. - - :ivar search_id: Required. The search id. - :vartype search_id: str - :ivar phone_numbers: Required. The phone numbers that are available. Can be fewer than the - desired search quantity. - :vartype phone_numbers: list[str] - :ivar phone_number_type: Required. The phone number's type, e.g. geographic, or tollFree. - Possible values include: "geographic", "tollFree". - :vartype phone_number_type: str or ~azure.communication.phonenumbers.models.PhoneNumberType - :ivar assignment_type: Required. Phone number's assignment type. Possible values include: - "person", "application". - :vartype assignment_type: str or - ~azure.communication.phonenumbers.models.PhoneNumberAssignmentType - :ivar capabilities: Required. Capabilities of a phone number. - :vartype capabilities: ~azure.communication.phonenumbers.models.PhoneNumberCapabilities - :ivar cost: Required. The incurred cost for a single phone number. - :vartype cost: ~azure.communication.phonenumbers.models.PhoneNumberCost - :ivar search_expires_by: Required. The date that this search result expires and phone numbers - are no longer on hold. A search result expires in less than 15min, e.g. - 2020-11-19T16:31:49.048Z. - :vartype search_expires_by: ~datetime.datetime - """ - - _validation = { - 'search_id': {'required': True}, - 'phone_numbers': {'required': True}, - 'phone_number_type': {'required': True}, - 'assignment_type': {'required': True}, - 'capabilities': {'required': True}, - 'cost': {'required': True}, - 'search_expires_by': {'required': True}, - } - - _attribute_map = { - 'search_id': {'key': 'searchId', 'type': 'str'}, - 'phone_numbers': {'key': 'phoneNumbers', 'type': '[str]'}, - 'phone_number_type': {'key': 'phoneNumberType', 'type': 'str'}, - 'assignment_type': {'key': 'assignmentType', 'type': 'str'}, - 'capabilities': {'key': 'capabilities', 'type': 'PhoneNumberCapabilities'}, - 'cost': {'key': 'cost', 'type': 'PhoneNumberCost'}, - 'search_expires_by': {'key': 'searchExpiresBy', 'type': 'iso-8601'}, - } - - def __init__( - self, - **kwargs - ): - """ - :keyword search_id: Required. The search id. - :paramtype search_id: str - :keyword phone_numbers: Required. The phone numbers that are available. Can be fewer than the - desired search quantity. - :paramtype phone_numbers: list[str] - :keyword phone_number_type: Required. The phone number's type, e.g. geographic, or tollFree. - Possible values include: "geographic", "tollFree". - :paramtype phone_number_type: str or ~azure.communication.phonenumbers.models.PhoneNumberType - :keyword assignment_type: Required. Phone number's assignment type. Possible values include: - "person", "application". - :paramtype assignment_type: str or - ~azure.communication.phonenumbers.models.PhoneNumberAssignmentType - :keyword capabilities: Required. Capabilities of a phone number. - :paramtype capabilities: ~azure.communication.phonenumbers.models.PhoneNumberCapabilities - :keyword cost: Required. The incurred cost for a single phone number. - :paramtype cost: ~azure.communication.phonenumbers.models.PhoneNumberCost - :keyword search_expires_by: Required. The date that this search result expires and phone - numbers are no longer on hold. A search result expires in less than 15min, e.g. - 2020-11-19T16:31:49.048Z. - :paramtype search_expires_by: ~datetime.datetime - """ - super(PhoneNumberSearchResult, self).__init__(**kwargs) - self.search_id = kwargs['search_id'] - self.phone_numbers = kwargs['phone_numbers'] - self.phone_number_type = kwargs['phone_number_type'] - self.assignment_type = kwargs['assignment_type'] - self.capabilities = kwargs['capabilities'] - self.cost = kwargs['cost'] - self.search_expires_by = kwargs['search_expires_by'] - - -class PurchasedPhoneNumber(msrest.serialization.Model): - """Represents a purchased phone number. - - All required parameters must be populated in order to send to Azure. - - :ivar id: Required. The id of the phone number, e.g. 11234567890. - :vartype id: str - :ivar phone_number: Required. String of the E.164 format of the phone number, e.g. - +11234567890. - :vartype phone_number: str - :ivar country_code: Required. The ISO 3166-2 code of the phone number's country, e.g. US. - :vartype country_code: str - :ivar phone_number_type: Required. The phone number's type, e.g. Geographic, TollFree. Possible - values include: "geographic", "tollFree". - :vartype phone_number_type: str or ~azure.communication.phonenumbers.models.PhoneNumberType - :ivar capabilities: Required. Capabilities of a phone number. - :vartype capabilities: ~azure.communication.phonenumbers.models.PhoneNumberCapabilities - :ivar assignment_type: Required. The assignment type of the phone number. A phone number can be - assigned to a person, or to an application. Possible values include: "person", "application". - :vartype assignment_type: str or - ~azure.communication.phonenumbers.models.PhoneNumberAssignmentType - :ivar purchase_date: Required. The date and time that the phone number was purchased. - :vartype purchase_date: ~datetime.datetime - :ivar cost: Required. The incurred cost for a single phone number. - :vartype cost: ~azure.communication.phonenumbers.models.PhoneNumberCost - """ - - _validation = { - 'id': {'required': True}, - 'phone_number': {'required': True}, - 'country_code': {'required': True}, - 'phone_number_type': {'required': True}, - 'capabilities': {'required': True}, - 'assignment_type': {'required': True}, - 'purchase_date': {'required': True}, - 'cost': {'required': True}, - } - - _attribute_map = { - 'id': {'key': 'id', 'type': 'str'}, - 'phone_number': {'key': 'phoneNumber', 'type': 'str'}, - 'country_code': {'key': 'countryCode', 'type': 'str'}, - 'phone_number_type': {'key': 'phoneNumberType', 'type': 'str'}, - 'capabilities': {'key': 'capabilities', 'type': 'PhoneNumberCapabilities'}, - 'assignment_type': {'key': 'assignmentType', 'type': 'str'}, - 'purchase_date': {'key': 'purchaseDate', 'type': 'iso-8601'}, - 'cost': {'key': 'cost', 'type': 'PhoneNumberCost'}, - } - - def __init__( - self, - **kwargs - ): - """ - :keyword id: Required. The id of the phone number, e.g. 11234567890. - :paramtype id: str - :keyword phone_number: Required. String of the E.164 format of the phone number, e.g. - +11234567890. - :paramtype phone_number: str - :keyword country_code: Required. The ISO 3166-2 code of the phone number's country, e.g. US. - :paramtype country_code: str - :keyword phone_number_type: Required. The phone number's type, e.g. Geographic, TollFree. - Possible values include: "geographic", "tollFree". - :paramtype phone_number_type: str or ~azure.communication.phonenumbers.models.PhoneNumberType - :keyword capabilities: Required. Capabilities of a phone number. - :paramtype capabilities: ~azure.communication.phonenumbers.models.PhoneNumberCapabilities - :keyword assignment_type: Required. The assignment type of the phone number. A phone number can - be assigned to a person, or to an application. Possible values include: "person", - "application". - :paramtype assignment_type: str or - ~azure.communication.phonenumbers.models.PhoneNumberAssignmentType - :keyword purchase_date: Required. The date and time that the phone number was purchased. - :paramtype purchase_date: ~datetime.datetime - :keyword cost: Required. The incurred cost for a single phone number. - :paramtype cost: ~azure.communication.phonenumbers.models.PhoneNumberCost - """ - super(PurchasedPhoneNumber, self).__init__(**kwargs) - self.id = kwargs['id'] - self.phone_number = kwargs['phone_number'] - self.country_code = kwargs['country_code'] - self.phone_number_type = kwargs['phone_number_type'] - self.capabilities = kwargs['capabilities'] - self.assignment_type = kwargs['assignment_type'] - self.purchase_date = kwargs['purchase_date'] - self.cost = kwargs['cost'] - - -class PurchasedPhoneNumbers(msrest.serialization.Model): - """The list of purchased phone numbers. - - All required parameters must be populated in order to send to Azure. - - :ivar phone_numbers: Required. Represents a list of phone numbers. - :vartype phone_numbers: list[~azure.communication.phonenumbers.models.PurchasedPhoneNumber] - :ivar next_link: Represents the URL link to the next page of phone number results. - :vartype next_link: str - """ - - _validation = { - 'phone_numbers': {'required': True}, - } - - _attribute_map = { - 'phone_numbers': {'key': 'phoneNumbers', 'type': '[PurchasedPhoneNumber]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, - } - - def __init__( - self, - **kwargs - ): - """ - :keyword phone_numbers: Required. Represents a list of phone numbers. - :paramtype phone_numbers: list[~azure.communication.phonenumbers.models.PurchasedPhoneNumber] - :keyword next_link: Represents the URL link to the next page of phone number results. - :paramtype next_link: str - """ - super(PurchasedPhoneNumbers, self).__init__(**kwargs) - self.phone_numbers = kwargs['phone_numbers'] - self.next_link = kwargs.get('next_link', None) diff --git a/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/models/_models_py3.py b/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/models/_models_py3.py index e811d0058730..dd362386ad43 100644 --- a/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/models/_models_py3.py +++ b/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/models/_models_py3.py @@ -1,4 +1,5 @@ # coding=utf-8 +# pylint: disable=too-many-lines # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for license information. @@ -7,24 +8,25 @@ # -------------------------------------------------------------------------- import datetime -from typing import List, Optional, Union +from typing import List, Optional, TYPE_CHECKING, Union -from azure.core.exceptions import HttpResponseError -import msrest.serialization +from .. import _serialization -from ._phone_numbers_client_enums import * +if TYPE_CHECKING: + # pylint: disable=unused-import,ungrouped-imports + from .. import models as _models -class CommunicationError(msrest.serialization.Model): +class CommunicationError(_serialization.Model): """The Communication Services error. Variables are only populated by the server, and will be ignored when sending a request. All required parameters must be populated in order to send to Azure. - :ivar code: Required. The error code. + :ivar code: The error code. Required. :vartype code: str - :ivar message: Required. The error message. + :ivar message: The error message. Required. :vartype message: str :ivar target: The error target. :vartype target: str @@ -35,35 +37,29 @@ class CommunicationError(msrest.serialization.Model): """ _validation = { - 'code': {'required': True}, - 'message': {'required': True}, - 'target': {'readonly': True}, - 'details': {'readonly': True}, - 'inner_error': {'readonly': True}, + "code": {"required": True}, + "message": {"required": True}, + "target": {"readonly": True}, + "details": {"readonly": True}, + "inner_error": {"readonly": True}, } _attribute_map = { - 'code': {'key': 'code', 'type': 'str'}, - 'message': {'key': 'message', 'type': 'str'}, - 'target': {'key': 'target', 'type': 'str'}, - 'details': {'key': 'details', 'type': '[CommunicationError]'}, - 'inner_error': {'key': 'innererror', 'type': 'CommunicationError'}, + "code": {"key": "code", "type": "str"}, + "message": {"key": "message", "type": "str"}, + "target": {"key": "target", "type": "str"}, + "details": {"key": "details", "type": "[CommunicationError]"}, + "inner_error": {"key": "innererror", "type": "CommunicationError"}, } - def __init__( - self, - *, - code: str, - message: str, - **kwargs - ): + def __init__(self, *, code: str, message: str, **kwargs): """ - :keyword code: Required. The error code. + :keyword code: The error code. Required. :paramtype code: str - :keyword message: Required. The error message. + :keyword message: The error message. Required. :paramtype message: str """ - super(CommunicationError, self).__init__(**kwargs) + super().__init__(**kwargs) self.code = code self.message = message self.target = None @@ -71,185 +67,173 @@ def __init__( self.inner_error = None -class CommunicationErrorResponse(msrest.serialization.Model): +class CommunicationErrorResponse(_serialization.Model): """The Communication Services error. All required parameters must be populated in order to send to Azure. - :ivar error: Required. The Communication Services error. + :ivar error: The Communication Services error. Required. :vartype error: ~azure.communication.phonenumbers.models.CommunicationError """ _validation = { - 'error': {'required': True}, + "error": {"required": True}, } _attribute_map = { - 'error': {'key': 'error', 'type': 'CommunicationError'}, + "error": {"key": "error", "type": "CommunicationError"}, } - def __init__( - self, - *, - error: "CommunicationError", - **kwargs - ): + def __init__(self, *, error: "_models.CommunicationError", **kwargs): """ - :keyword error: Required. The Communication Services error. + :keyword error: The Communication Services error. Required. :paramtype error: ~azure.communication.phonenumbers.models.CommunicationError """ - super(CommunicationErrorResponse, self).__init__(**kwargs) + super().__init__(**kwargs) self.error = error -class PhoneNumberCapabilities(msrest.serialization.Model): +class PhoneNumberCapabilities(_serialization.Model): """Capabilities of a phone number. All required parameters must be populated in order to send to Azure. - :ivar calling: Required. Capability value for calling. Possible values include: "none", - "inbound", "outbound", "inbound+outbound". + :ivar calling: Capability value for calling. Required. Known values are: "none", "inbound", + "outbound", and "inbound+outbound". :vartype calling: str or ~azure.communication.phonenumbers.models.PhoneNumberCapabilityType - :ivar sms: Required. Capability value for SMS. Possible values include: "none", "inbound", - "outbound", "inbound+outbound". + :ivar sms: Capability value for SMS. Required. Known values are: "none", "inbound", "outbound", + and "inbound+outbound". :vartype sms: str or ~azure.communication.phonenumbers.models.PhoneNumberCapabilityType """ _validation = { - 'calling': {'required': True}, - 'sms': {'required': True}, + "calling": {"required": True}, + "sms": {"required": True}, } _attribute_map = { - 'calling': {'key': 'calling', 'type': 'str'}, - 'sms': {'key': 'sms', 'type': 'str'}, + "calling": {"key": "calling", "type": "str"}, + "sms": {"key": "sms", "type": "str"}, } def __init__( self, *, - calling: Union[str, "PhoneNumberCapabilityType"], - sms: Union[str, "PhoneNumberCapabilityType"], + calling: Union[str, "_models.PhoneNumberCapabilityType"], + sms: Union[str, "_models.PhoneNumberCapabilityType"], **kwargs ): """ - :keyword calling: Required. Capability value for calling. Possible values include: "none", - "inbound", "outbound", "inbound+outbound". + :keyword calling: Capability value for calling. Required. Known values are: "none", "inbound", + "outbound", and "inbound+outbound". :paramtype calling: str or ~azure.communication.phonenumbers.models.PhoneNumberCapabilityType - :keyword sms: Required. Capability value for SMS. Possible values include: "none", "inbound", - "outbound", "inbound+outbound". + :keyword sms: Capability value for SMS. Required. Known values are: "none", "inbound", + "outbound", and "inbound+outbound". :paramtype sms: str or ~azure.communication.phonenumbers.models.PhoneNumberCapabilityType """ - super(PhoneNumberCapabilities, self).__init__(**kwargs) + super().__init__(**kwargs) self.calling = calling self.sms = sms -class PhoneNumberCapabilitiesRequest(msrest.serialization.Model): +class PhoneNumberCapabilitiesRequest(_serialization.Model): """Capabilities of a phone number. - :ivar calling: Capability value for calling. Possible values include: "none", "inbound", - "outbound", "inbound+outbound". + :ivar calling: Capability value for calling. Known values are: "none", "inbound", "outbound", + and "inbound+outbound". :vartype calling: str or ~azure.communication.phonenumbers.models.PhoneNumberCapabilityType - :ivar sms: Capability value for SMS. Possible values include: "none", "inbound", "outbound", + :ivar sms: Capability value for SMS. Known values are: "none", "inbound", "outbound", and "inbound+outbound". :vartype sms: str or ~azure.communication.phonenumbers.models.PhoneNumberCapabilityType """ _attribute_map = { - 'calling': {'key': 'calling', 'type': 'str'}, - 'sms': {'key': 'sms', 'type': 'str'}, + "calling": {"key": "calling", "type": "str"}, + "sms": {"key": "sms", "type": "str"}, } def __init__( self, *, - calling: Optional[Union[str, "PhoneNumberCapabilityType"]] = None, - sms: Optional[Union[str, "PhoneNumberCapabilityType"]] = None, + calling: Optional[Union[str, "_models.PhoneNumberCapabilityType"]] = None, + sms: Optional[Union[str, "_models.PhoneNumberCapabilityType"]] = None, **kwargs ): """ - :keyword calling: Capability value for calling. Possible values include: "none", "inbound", - "outbound", "inbound+outbound". + :keyword calling: Capability value for calling. Known values are: "none", "inbound", + "outbound", and "inbound+outbound". :paramtype calling: str or ~azure.communication.phonenumbers.models.PhoneNumberCapabilityType - :keyword sms: Capability value for SMS. Possible values include: "none", "inbound", "outbound", + :keyword sms: Capability value for SMS. Known values are: "none", "inbound", "outbound", and "inbound+outbound". :paramtype sms: str or ~azure.communication.phonenumbers.models.PhoneNumberCapabilityType """ - super(PhoneNumberCapabilitiesRequest, self).__init__(**kwargs) + super().__init__(**kwargs) self.calling = calling self.sms = sms -class PhoneNumberCost(msrest.serialization.Model): +class PhoneNumberCost(_serialization.Model): """The incurred cost for a single phone number. All required parameters must be populated in order to send to Azure. - :ivar amount: Required. The cost amount. + :ivar amount: The cost amount. Required. :vartype amount: float - :ivar currency_code: Required. The ISO 4217 currency code for the cost amount, e.g. USD. + :ivar currency_code: The ISO 4217 currency code for the cost amount, e.g. USD. Required. :vartype currency_code: str - :ivar billing_frequency: Required. The frequency with which the cost gets billed. Possible - values include: "monthly". + :ivar billing_frequency: The frequency with which the cost gets billed. Required. "monthly" :vartype billing_frequency: str or ~azure.communication.phonenumbers.models.BillingFrequency """ _validation = { - 'amount': {'required': True}, - 'currency_code': {'required': True}, - 'billing_frequency': {'required': True}, + "amount": {"required": True}, + "currency_code": {"required": True}, + "billing_frequency": {"required": True}, } _attribute_map = { - 'amount': {'key': 'amount', 'type': 'float'}, - 'currency_code': {'key': 'currencyCode', 'type': 'str'}, - 'billing_frequency': {'key': 'billingFrequency', 'type': 'str'}, + "amount": {"key": "amount", "type": "float"}, + "currency_code": {"key": "currencyCode", "type": "str"}, + "billing_frequency": {"key": "billingFrequency", "type": "str"}, } def __init__( - self, - *, - amount: float, - currency_code: str, - billing_frequency: Union[str, "BillingFrequency"], - **kwargs + self, *, amount: float, currency_code: str, billing_frequency: Union[str, "_models.BillingFrequency"], **kwargs ): """ - :keyword amount: Required. The cost amount. + :keyword amount: The cost amount. Required. :paramtype amount: float - :keyword currency_code: Required. The ISO 4217 currency code for the cost amount, e.g. USD. + :keyword currency_code: The ISO 4217 currency code for the cost amount, e.g. USD. Required. :paramtype currency_code: str - :keyword billing_frequency: Required. The frequency with which the cost gets billed. Possible - values include: "monthly". + :keyword billing_frequency: The frequency with which the cost gets billed. Required. "monthly" :paramtype billing_frequency: str or ~azure.communication.phonenumbers.models.BillingFrequency """ - super(PhoneNumberCost, self).__init__(**kwargs) + super().__init__(**kwargs) self.amount = amount self.currency_code = currency_code self.billing_frequency = billing_frequency -class PhoneNumberOperation(msrest.serialization.Model): +class PhoneNumberOperation(_serialization.Model): """Long running operation. Variables are only populated by the server, and will be ignored when sending a request. All required parameters must be populated in order to send to Azure. - :ivar status: Required. Status of operation. Possible values include: "notStarted", "running", - "succeeded", "failed". + :ivar status: Status of operation. Required. Known values are: "notStarted", "running", + "succeeded", and "failed". :vartype status: str or ~azure.communication.phonenumbers.models.PhoneNumberOperationStatus :ivar resource_location: URL for retrieving the result of the operation, if any. :vartype resource_location: str - :ivar created_date_time: Required. The date that the operation was created. + :ivar created_date_time: The date that the operation was created. Required. :vartype created_date_time: ~datetime.datetime :ivar error: The Communication Services error. :vartype error: ~azure.communication.phonenumbers.models.CommunicationError - :ivar id: Required. Id of operation. + :ivar id: Id of operation. Required. :vartype id: str - :ivar operation_type: Required. The type of operation, e.g. Search. Possible values include: - "purchase", "releasePhoneNumber", "search", "updatePhoneNumberCapabilities". + :ivar operation_type: The type of operation, e.g. Search. Required. Known values are: + "purchase", "releasePhoneNumber", "search", and "updatePhoneNumberCapabilities". :vartype operation_type: str or ~azure.communication.phonenumbers.models.PhoneNumberOperationType :ivar last_action_date_time: The most recent date that the operation was changed. @@ -257,52 +241,52 @@ class PhoneNumberOperation(msrest.serialization.Model): """ _validation = { - 'status': {'required': True}, - 'created_date_time': {'required': True}, - 'id': {'required': True}, - 'operation_type': {'required': True}, - 'last_action_date_time': {'readonly': True}, + "status": {"required": True}, + "created_date_time": {"required": True}, + "id": {"required": True}, + "operation_type": {"required": True}, + "last_action_date_time": {"readonly": True}, } _attribute_map = { - 'status': {'key': 'status', 'type': 'str'}, - 'resource_location': {'key': 'resourceLocation', 'type': 'str'}, - 'created_date_time': {'key': 'createdDateTime', 'type': 'iso-8601'}, - 'error': {'key': 'error', 'type': 'CommunicationError'}, - 'id': {'key': 'id', 'type': 'str'}, - 'operation_type': {'key': 'operationType', 'type': 'str'}, - 'last_action_date_time': {'key': 'lastActionDateTime', 'type': 'iso-8601'}, + "status": {"key": "status", "type": "str"}, + "resource_location": {"key": "resourceLocation", "type": "str"}, + "created_date_time": {"key": "createdDateTime", "type": "iso-8601"}, + "error": {"key": "error", "type": "CommunicationError"}, + "id": {"key": "id", "type": "str"}, + "operation_type": {"key": "operationType", "type": "str"}, + "last_action_date_time": {"key": "lastActionDateTime", "type": "iso-8601"}, } def __init__( self, *, - status: Union[str, "PhoneNumberOperationStatus"], + status: Union[str, "_models.PhoneNumberOperationStatus"], created_date_time: datetime.datetime, - id: str, - operation_type: Union[str, "PhoneNumberOperationType"], + id: str, # pylint: disable=redefined-builtin + operation_type: Union[str, "_models.PhoneNumberOperationType"], resource_location: Optional[str] = None, - error: Optional["CommunicationError"] = None, + error: Optional["_models.CommunicationError"] = None, **kwargs ): """ - :keyword status: Required. Status of operation. Possible values include: "notStarted", - "running", "succeeded", "failed". + :keyword status: Status of operation. Required. Known values are: "notStarted", "running", + "succeeded", and "failed". :paramtype status: str or ~azure.communication.phonenumbers.models.PhoneNumberOperationStatus :keyword resource_location: URL for retrieving the result of the operation, if any. :paramtype resource_location: str - :keyword created_date_time: Required. The date that the operation was created. + :keyword created_date_time: The date that the operation was created. Required. :paramtype created_date_time: ~datetime.datetime :keyword error: The Communication Services error. :paramtype error: ~azure.communication.phonenumbers.models.CommunicationError - :keyword id: Required. Id of operation. + :keyword id: Id of operation. Required. :paramtype id: str - :keyword operation_type: Required. The type of operation, e.g. Search. Possible values include: - "purchase", "releasePhoneNumber", "search", "updatePhoneNumberCapabilities". + :keyword operation_type: The type of operation, e.g. Search. Required. Known values are: + "purchase", "releasePhoneNumber", "search", and "updatePhoneNumberCapabilities". :paramtype operation_type: str or ~azure.communication.phonenumbers.models.PhoneNumberOperationType """ - super(PhoneNumberOperation, self).__init__(**kwargs) + super().__init__(**kwargs) self.status = status self.resource_location = resource_location self.created_date_time = created_date_time @@ -312,7 +296,7 @@ def __init__( self.last_action_date_time = None -class PhoneNumberPurchaseRequest(msrest.serialization.Model): +class PhoneNumberPurchaseRequest(_serialization.Model): """The phone number search purchase request. :ivar search_id: The search id. @@ -320,37 +304,32 @@ class PhoneNumberPurchaseRequest(msrest.serialization.Model): """ _attribute_map = { - 'search_id': {'key': 'searchId', 'type': 'str'}, + "search_id": {"key": "searchId", "type": "str"}, } - def __init__( - self, - *, - search_id: Optional[str] = None, - **kwargs - ): + def __init__(self, *, search_id: Optional[str] = None, **kwargs): """ :keyword search_id: The search id. :paramtype search_id: str """ - super(PhoneNumberPurchaseRequest, self).__init__(**kwargs) + super().__init__(**kwargs) self.search_id = search_id -class PhoneNumberSearchRequest(msrest.serialization.Model): +class PhoneNumberSearchRequest(_serialization.Model): """Represents a phone number search request to find phone numbers. Found phone numbers are temporarily held for a following purchase. All required parameters must be populated in order to send to Azure. - :ivar phone_number_type: Required. The type of phone numbers to search for, e.g. geographic, or - tollFree. Possible values include: "geographic", "tollFree". + :ivar phone_number_type: The type of phone numbers to search for, e.g. geographic, or tollFree. + Required. Known values are: "geographic" and "tollFree". :vartype phone_number_type: str or ~azure.communication.phonenumbers.models.PhoneNumberType - :ivar assignment_type: Required. The assignment type of the phone numbers to search for. A - phone number can be assigned to a person, or to an application. Possible values include: - "person", "application". + :ivar assignment_type: The assignment type of the phone numbers to search for. A phone number + can be assigned to a person, or to an application. Required. Known values are: "person" and + "application". :vartype assignment_type: str or ~azure.communication.phonenumbers.models.PhoneNumberAssignmentType - :ivar capabilities: Required. Capabilities of a phone number. + :ivar capabilities: Capabilities of a phone number. Required. :vartype capabilities: ~azure.communication.phonenumbers.models.PhoneNumberCapabilities :ivar area_code: The area code of the desired phone number, e.g. 425. :vartype area_code: str @@ -359,47 +338,47 @@ class PhoneNumberSearchRequest(msrest.serialization.Model): """ _validation = { - 'phone_number_type': {'required': True}, - 'assignment_type': {'required': True}, - 'capabilities': {'required': True}, - 'quantity': {'maximum': 2147483647, 'minimum': 1}, + "phone_number_type": {"required": True}, + "assignment_type": {"required": True}, + "capabilities": {"required": True}, + "quantity": {"maximum": 2147483647, "minimum": 1}, } _attribute_map = { - 'phone_number_type': {'key': 'phoneNumberType', 'type': 'str'}, - 'assignment_type': {'key': 'assignmentType', 'type': 'str'}, - 'capabilities': {'key': 'capabilities', 'type': 'PhoneNumberCapabilities'}, - 'area_code': {'key': 'areaCode', 'type': 'str'}, - 'quantity': {'key': 'quantity', 'type': 'int'}, + "phone_number_type": {"key": "phoneNumberType", "type": "str"}, + "assignment_type": {"key": "assignmentType", "type": "str"}, + "capabilities": {"key": "capabilities", "type": "PhoneNumberCapabilities"}, + "area_code": {"key": "areaCode", "type": "str"}, + "quantity": {"key": "quantity", "type": "int"}, } def __init__( self, *, - phone_number_type: Union[str, "PhoneNumberType"], - assignment_type: Union[str, "PhoneNumberAssignmentType"], - capabilities: "PhoneNumberCapabilities", + phone_number_type: Union[str, "_models.PhoneNumberType"], + assignment_type: Union[str, "_models.PhoneNumberAssignmentType"], + capabilities: "_models.PhoneNumberCapabilities", area_code: Optional[str] = None, - quantity: Optional[int] = 1, + quantity: int = 1, **kwargs ): """ - :keyword phone_number_type: Required. The type of phone numbers to search for, e.g. geographic, - or tollFree. Possible values include: "geographic", "tollFree". + :keyword phone_number_type: The type of phone numbers to search for, e.g. geographic, or + tollFree. Required. Known values are: "geographic" and "tollFree". :paramtype phone_number_type: str or ~azure.communication.phonenumbers.models.PhoneNumberType - :keyword assignment_type: Required. The assignment type of the phone numbers to search for. A - phone number can be assigned to a person, or to an application. Possible values include: - "person", "application". + :keyword assignment_type: The assignment type of the phone numbers to search for. A phone + number can be assigned to a person, or to an application. Required. Known values are: "person" + and "application". :paramtype assignment_type: str or ~azure.communication.phonenumbers.models.PhoneNumberAssignmentType - :keyword capabilities: Required. Capabilities of a phone number. + :keyword capabilities: Capabilities of a phone number. Required. :paramtype capabilities: ~azure.communication.phonenumbers.models.PhoneNumberCapabilities :keyword area_code: The area code of the desired phone number, e.g. 425. :paramtype area_code: str :keyword quantity: The quantity of desired phone numbers. The default value is 1. :paramtype quantity: int """ - super(PhoneNumberSearchRequest, self).__init__(**kwargs) + super().__init__(**kwargs) self.phone_number_type = phone_number_type self.assignment_type = assignment_type self.capabilities = capabilities @@ -407,51 +386,51 @@ def __init__( self.quantity = quantity -class PhoneNumberSearchResult(msrest.serialization.Model): +class PhoneNumberSearchResult(_serialization.Model): """The result of a phone number search operation. All required parameters must be populated in order to send to Azure. - :ivar search_id: Required. The search id. + :ivar search_id: The search id. Required. :vartype search_id: str - :ivar phone_numbers: Required. The phone numbers that are available. Can be fewer than the - desired search quantity. + :ivar phone_numbers: The phone numbers that are available. Can be fewer than the desired search + quantity. Required. :vartype phone_numbers: list[str] - :ivar phone_number_type: Required. The phone number's type, e.g. geographic, or tollFree. - Possible values include: "geographic", "tollFree". + :ivar phone_number_type: The phone number's type, e.g. geographic, or tollFree. Required. Known + values are: "geographic" and "tollFree". :vartype phone_number_type: str or ~azure.communication.phonenumbers.models.PhoneNumberType - :ivar assignment_type: Required. Phone number's assignment type. Possible values include: - "person", "application". + :ivar assignment_type: Phone number's assignment type. Required. Known values are: "person" and + "application". :vartype assignment_type: str or ~azure.communication.phonenumbers.models.PhoneNumberAssignmentType - :ivar capabilities: Required. Capabilities of a phone number. + :ivar capabilities: Capabilities of a phone number. Required. :vartype capabilities: ~azure.communication.phonenumbers.models.PhoneNumberCapabilities - :ivar cost: Required. The incurred cost for a single phone number. + :ivar cost: The incurred cost for a single phone number. Required. :vartype cost: ~azure.communication.phonenumbers.models.PhoneNumberCost - :ivar search_expires_by: Required. The date that this search result expires and phone numbers - are no longer on hold. A search result expires in less than 15min, e.g. - 2020-11-19T16:31:49.048Z. + :ivar search_expires_by: The date that this search result expires and phone numbers are no + longer on hold. A search result expires in less than 15min, e.g. 2020-11-19T16:31:49.048Z. + Required. :vartype search_expires_by: ~datetime.datetime """ _validation = { - 'search_id': {'required': True}, - 'phone_numbers': {'required': True}, - 'phone_number_type': {'required': True}, - 'assignment_type': {'required': True}, - 'capabilities': {'required': True}, - 'cost': {'required': True}, - 'search_expires_by': {'required': True}, + "search_id": {"required": True}, + "phone_numbers": {"required": True}, + "phone_number_type": {"required": True}, + "assignment_type": {"required": True}, + "capabilities": {"required": True}, + "cost": {"required": True}, + "search_expires_by": {"required": True}, } _attribute_map = { - 'search_id': {'key': 'searchId', 'type': 'str'}, - 'phone_numbers': {'key': 'phoneNumbers', 'type': '[str]'}, - 'phone_number_type': {'key': 'phoneNumberType', 'type': 'str'}, - 'assignment_type': {'key': 'assignmentType', 'type': 'str'}, - 'capabilities': {'key': 'capabilities', 'type': 'PhoneNumberCapabilities'}, - 'cost': {'key': 'cost', 'type': 'PhoneNumberCost'}, - 'search_expires_by': {'key': 'searchExpiresBy', 'type': 'iso-8601'}, + "search_id": {"key": "searchId", "type": "str"}, + "phone_numbers": {"key": "phoneNumbers", "type": "[str]"}, + "phone_number_type": {"key": "phoneNumberType", "type": "str"}, + "assignment_type": {"key": "assignmentType", "type": "str"}, + "capabilities": {"key": "capabilities", "type": "PhoneNumberCapabilities"}, + "cost": {"key": "cost", "type": "PhoneNumberCost"}, + "search_expires_by": {"key": "searchExpiresBy", "type": "iso-8601"}, } def __init__( @@ -459,36 +438,36 @@ def __init__( *, search_id: str, phone_numbers: List[str], - phone_number_type: Union[str, "PhoneNumberType"], - assignment_type: Union[str, "PhoneNumberAssignmentType"], - capabilities: "PhoneNumberCapabilities", - cost: "PhoneNumberCost", + phone_number_type: Union[str, "_models.PhoneNumberType"], + assignment_type: Union[str, "_models.PhoneNumberAssignmentType"], + capabilities: "_models.PhoneNumberCapabilities", + cost: "_models.PhoneNumberCost", search_expires_by: datetime.datetime, **kwargs ): """ - :keyword search_id: Required. The search id. + :keyword search_id: The search id. Required. :paramtype search_id: str - :keyword phone_numbers: Required. The phone numbers that are available. Can be fewer than the - desired search quantity. + :keyword phone_numbers: The phone numbers that are available. Can be fewer than the desired + search quantity. Required. :paramtype phone_numbers: list[str] - :keyword phone_number_type: Required. The phone number's type, e.g. geographic, or tollFree. - Possible values include: "geographic", "tollFree". + :keyword phone_number_type: The phone number's type, e.g. geographic, or tollFree. Required. + Known values are: "geographic" and "tollFree". :paramtype phone_number_type: str or ~azure.communication.phonenumbers.models.PhoneNumberType - :keyword assignment_type: Required. Phone number's assignment type. Possible values include: - "person", "application". + :keyword assignment_type: Phone number's assignment type. Required. Known values are: "person" + and "application". :paramtype assignment_type: str or ~azure.communication.phonenumbers.models.PhoneNumberAssignmentType - :keyword capabilities: Required. Capabilities of a phone number. + :keyword capabilities: Capabilities of a phone number. Required. :paramtype capabilities: ~azure.communication.phonenumbers.models.PhoneNumberCapabilities - :keyword cost: Required. The incurred cost for a single phone number. + :keyword cost: The incurred cost for a single phone number. Required. :paramtype cost: ~azure.communication.phonenumbers.models.PhoneNumberCost - :keyword search_expires_by: Required. The date that this search result expires and phone - numbers are no longer on hold. A search result expires in less than 15min, e.g. - 2020-11-19T16:31:49.048Z. + :keyword search_expires_by: The date that this search result expires and phone numbers are no + longer on hold. A search result expires in less than 15min, e.g. 2020-11-19T16:31:49.048Z. + Required. :paramtype search_expires_by: ~datetime.datetime """ - super(PhoneNumberSearchResult, self).__init__(**kwargs) + super().__init__(**kwargs) self.search_id = search_id self.phone_numbers = phone_numbers self.phone_number_type = phone_number_type @@ -498,92 +477,92 @@ def __init__( self.search_expires_by = search_expires_by -class PurchasedPhoneNumber(msrest.serialization.Model): +class PurchasedPhoneNumber(_serialization.Model): """Represents a purchased phone number. All required parameters must be populated in order to send to Azure. - :ivar id: Required. The id of the phone number, e.g. 11234567890. + :ivar id: The id of the phone number, e.g. 11234567890. Required. :vartype id: str - :ivar phone_number: Required. String of the E.164 format of the phone number, e.g. - +11234567890. + :ivar phone_number: String of the E.164 format of the phone number, e.g. +11234567890. + Required. :vartype phone_number: str - :ivar country_code: Required. The ISO 3166-2 code of the phone number's country, e.g. US. + :ivar country_code: The ISO 3166-2 code of the phone number's country, e.g. US. Required. :vartype country_code: str - :ivar phone_number_type: Required. The phone number's type, e.g. Geographic, TollFree. Possible - values include: "geographic", "tollFree". + :ivar phone_number_type: The phone number's type, e.g. Geographic, TollFree. Required. Known + values are: "geographic" and "tollFree". :vartype phone_number_type: str or ~azure.communication.phonenumbers.models.PhoneNumberType - :ivar capabilities: Required. Capabilities of a phone number. + :ivar capabilities: Capabilities of a phone number. Required. :vartype capabilities: ~azure.communication.phonenumbers.models.PhoneNumberCapabilities - :ivar assignment_type: Required. The assignment type of the phone number. A phone number can be - assigned to a person, or to an application. Possible values include: "person", "application". + :ivar assignment_type: The assignment type of the phone number. A phone number can be assigned + to a person, or to an application. Required. Known values are: "person" and "application". :vartype assignment_type: str or ~azure.communication.phonenumbers.models.PhoneNumberAssignmentType - :ivar purchase_date: Required. The date and time that the phone number was purchased. + :ivar purchase_date: The date and time that the phone number was purchased. Required. :vartype purchase_date: ~datetime.datetime - :ivar cost: Required. The incurred cost for a single phone number. + :ivar cost: The incurred cost for a single phone number. Required. :vartype cost: ~azure.communication.phonenumbers.models.PhoneNumberCost """ _validation = { - 'id': {'required': True}, - 'phone_number': {'required': True}, - 'country_code': {'required': True}, - 'phone_number_type': {'required': True}, - 'capabilities': {'required': True}, - 'assignment_type': {'required': True}, - 'purchase_date': {'required': True}, - 'cost': {'required': True}, + "id": {"required": True}, + "phone_number": {"required": True}, + "country_code": {"required": True}, + "phone_number_type": {"required": True}, + "capabilities": {"required": True}, + "assignment_type": {"required": True}, + "purchase_date": {"required": True}, + "cost": {"required": True}, } _attribute_map = { - 'id': {'key': 'id', 'type': 'str'}, - 'phone_number': {'key': 'phoneNumber', 'type': 'str'}, - 'country_code': {'key': 'countryCode', 'type': 'str'}, - 'phone_number_type': {'key': 'phoneNumberType', 'type': 'str'}, - 'capabilities': {'key': 'capabilities', 'type': 'PhoneNumberCapabilities'}, - 'assignment_type': {'key': 'assignmentType', 'type': 'str'}, - 'purchase_date': {'key': 'purchaseDate', 'type': 'iso-8601'}, - 'cost': {'key': 'cost', 'type': 'PhoneNumberCost'}, + "id": {"key": "id", "type": "str"}, + "phone_number": {"key": "phoneNumber", "type": "str"}, + "country_code": {"key": "countryCode", "type": "str"}, + "phone_number_type": {"key": "phoneNumberType", "type": "str"}, + "capabilities": {"key": "capabilities", "type": "PhoneNumberCapabilities"}, + "assignment_type": {"key": "assignmentType", "type": "str"}, + "purchase_date": {"key": "purchaseDate", "type": "iso-8601"}, + "cost": {"key": "cost", "type": "PhoneNumberCost"}, } def __init__( self, *, - id: str, + id: str, # pylint: disable=redefined-builtin phone_number: str, country_code: str, - phone_number_type: Union[str, "PhoneNumberType"], - capabilities: "PhoneNumberCapabilities", - assignment_type: Union[str, "PhoneNumberAssignmentType"], + phone_number_type: Union[str, "_models.PhoneNumberType"], + capabilities: "_models.PhoneNumberCapabilities", + assignment_type: Union[str, "_models.PhoneNumberAssignmentType"], purchase_date: datetime.datetime, - cost: "PhoneNumberCost", + cost: "_models.PhoneNumberCost", **kwargs ): """ - :keyword id: Required. The id of the phone number, e.g. 11234567890. + :keyword id: The id of the phone number, e.g. 11234567890. Required. :paramtype id: str - :keyword phone_number: Required. String of the E.164 format of the phone number, e.g. - +11234567890. + :keyword phone_number: String of the E.164 format of the phone number, e.g. +11234567890. + Required. :paramtype phone_number: str - :keyword country_code: Required. The ISO 3166-2 code of the phone number's country, e.g. US. + :keyword country_code: The ISO 3166-2 code of the phone number's country, e.g. US. Required. :paramtype country_code: str - :keyword phone_number_type: Required. The phone number's type, e.g. Geographic, TollFree. - Possible values include: "geographic", "tollFree". + :keyword phone_number_type: The phone number's type, e.g. Geographic, TollFree. Required. Known + values are: "geographic" and "tollFree". :paramtype phone_number_type: str or ~azure.communication.phonenumbers.models.PhoneNumberType - :keyword capabilities: Required. Capabilities of a phone number. + :keyword capabilities: Capabilities of a phone number. Required. :paramtype capabilities: ~azure.communication.phonenumbers.models.PhoneNumberCapabilities - :keyword assignment_type: Required. The assignment type of the phone number. A phone number can - be assigned to a person, or to an application. Possible values include: "person", + :keyword assignment_type: The assignment type of the phone number. A phone number can be + assigned to a person, or to an application. Required. Known values are: "person" and "application". :paramtype assignment_type: str or ~azure.communication.phonenumbers.models.PhoneNumberAssignmentType - :keyword purchase_date: Required. The date and time that the phone number was purchased. + :keyword purchase_date: The date and time that the phone number was purchased. Required. :paramtype purchase_date: ~datetime.datetime - :keyword cost: Required. The incurred cost for a single phone number. + :keyword cost: The incurred cost for a single phone number. Required. :paramtype cost: ~azure.communication.phonenumbers.models.PhoneNumberCost """ - super(PurchasedPhoneNumber, self).__init__(**kwargs) + super().__init__(**kwargs) self.id = id self.phone_number = phone_number self.country_code = country_code @@ -594,39 +573,35 @@ def __init__( self.cost = cost -class PurchasedPhoneNumbers(msrest.serialization.Model): +class PurchasedPhoneNumbers(_serialization.Model): """The list of purchased phone numbers. All required parameters must be populated in order to send to Azure. - :ivar phone_numbers: Required. Represents a list of phone numbers. + :ivar phone_numbers: Represents a list of phone numbers. Required. :vartype phone_numbers: list[~azure.communication.phonenumbers.models.PurchasedPhoneNumber] :ivar next_link: Represents the URL link to the next page of phone number results. :vartype next_link: str """ _validation = { - 'phone_numbers': {'required': True}, + "phone_numbers": {"required": True}, } _attribute_map = { - 'phone_numbers': {'key': 'phoneNumbers', 'type': '[PurchasedPhoneNumber]'}, - 'next_link': {'key': 'nextLink', 'type': 'str'}, + "phone_numbers": {"key": "phoneNumbers", "type": "[PurchasedPhoneNumber]"}, + "next_link": {"key": "nextLink", "type": "str"}, } def __init__( - self, - *, - phone_numbers: List["PurchasedPhoneNumber"], - next_link: Optional[str] = None, - **kwargs + self, *, phone_numbers: List["_models.PurchasedPhoneNumber"], next_link: Optional[str] = None, **kwargs ): """ - :keyword phone_numbers: Required. Represents a list of phone numbers. + :keyword phone_numbers: Represents a list of phone numbers. Required. :paramtype phone_numbers: list[~azure.communication.phonenumbers.models.PurchasedPhoneNumber] :keyword next_link: Represents the URL link to the next page of phone number results. :paramtype next_link: str """ - super(PurchasedPhoneNumbers, self).__init__(**kwargs) + super().__init__(**kwargs) self.phone_numbers = phone_numbers self.next_link = next_link diff --git a/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/models/_patch.py b/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/models/_patch.py new file mode 100644 index 000000000000..f7dd32510333 --- /dev/null +++ b/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/models/_patch.py @@ -0,0 +1,20 @@ +# ------------------------------------ +# Copyright (c) Microsoft Corporation. +# Licensed under the MIT License. +# ------------------------------------ +"""Customize generated code here. + +Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize +""" +from typing import List + +__all__: List[str] = [] # Add all objects you want publicly available to users at this package level + + +def patch_sdk(): + """Do not remove from this file. + + `patch_sdk` is a last resort escape hatch that allows you to do customizations + you can't accomplish using the techniques described in + https://aka.ms/azsdk/python/dpcodegen/python/customize + """ diff --git a/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/models/_phone_numbers_client_enums.py b/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/models/_phone_numbers_client_enums.py index 48038605322e..5084f0131dbe 100644 --- a/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/models/_phone_numbers_client_enums.py +++ b/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/models/_phone_numbers_client_enums.py @@ -7,17 +7,16 @@ # -------------------------------------------------------------------------- from enum import Enum -from six import with_metaclass from azure.core import CaseInsensitiveEnumMeta -class BillingFrequency(with_metaclass(CaseInsensitiveEnumMeta, str, Enum)): - """The frequency with which the cost gets billed. - """ +class BillingFrequency(str, Enum, metaclass=CaseInsensitiveEnumMeta): + """The frequency with which the cost gets billed.""" MONTHLY = "monthly" -class PhoneNumberAssignmentType(with_metaclass(CaseInsensitiveEnumMeta, str, Enum)): + +class PhoneNumberAssignmentType(str, Enum, metaclass=CaseInsensitiveEnumMeta): """The assignment type of the phone numbers to search for. A phone number can be assigned to a person, or to an application. """ @@ -25,36 +24,36 @@ class PhoneNumberAssignmentType(with_metaclass(CaseInsensitiveEnumMeta, str, Enu PERSON = "person" APPLICATION = "application" -class PhoneNumberCapabilityType(with_metaclass(CaseInsensitiveEnumMeta, str, Enum)): - """Capability value for calling. - """ + +class PhoneNumberCapabilityType(str, Enum, metaclass=CaseInsensitiveEnumMeta): + """Capability value for calling.""" NONE = "none" INBOUND = "inbound" OUTBOUND = "outbound" INBOUND_OUTBOUND = "inbound+outbound" -class PhoneNumberOperationStatus(with_metaclass(CaseInsensitiveEnumMeta, str, Enum)): - """Status of operation. - """ + +class PhoneNumberOperationStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta): + """Status of operation.""" NOT_STARTED = "notStarted" RUNNING = "running" SUCCEEDED = "succeeded" FAILED = "failed" -class PhoneNumberOperationType(with_metaclass(CaseInsensitiveEnumMeta, str, Enum)): - """The type of operation, e.g. Search - """ + +class PhoneNumberOperationType(str, Enum, metaclass=CaseInsensitiveEnumMeta): + """The type of operation, e.g. Search.""" PURCHASE = "purchase" RELEASE_PHONE_NUMBER = "releasePhoneNumber" SEARCH = "search" UPDATE_PHONE_NUMBER_CAPABILITIES = "updatePhoneNumberCapabilities" -class PhoneNumberType(with_metaclass(CaseInsensitiveEnumMeta, str, Enum)): - """The type of phone numbers to search for, e.g. geographic, or tollFree. - """ + +class PhoneNumberType(str, Enum, metaclass=CaseInsensitiveEnumMeta): + """The type of phone numbers to search for, e.g. geographic, or tollFree.""" GEOGRAPHIC = "geographic" TOLL_FREE = "tollFree" diff --git a/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/operations/__init__.py b/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/operations/__init__.py index 3da9bcb904f3..672e6cb4743f 100644 --- a/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/operations/__init__.py +++ b/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/operations/__init__.py @@ -8,6 +8,12 @@ from ._phone_numbers_operations import PhoneNumbersOperations +from ._patch import __all__ as _patch_all +from ._patch import * # type: ignore # pylint: disable=unused-wildcard-import +from ._patch import patch_sdk as _patch_sdk + __all__ = [ - 'PhoneNumbersOperations', + "PhoneNumbersOperations", ] +__all__.extend([p for p in _patch_all if p not in __all__]) +_patch_sdk() diff --git a/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/operations/_patch.py b/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/operations/_patch.py new file mode 100644 index 000000000000..f7dd32510333 --- /dev/null +++ b/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/operations/_patch.py @@ -0,0 +1,20 @@ +# ------------------------------------ +# Copyright (c) Microsoft Corporation. +# Licensed under the MIT License. +# ------------------------------------ +"""Customize generated code here. + +Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize +""" +from typing import List + +__all__: List[str] = [] # Add all objects you want publicly available to users at this package level + + +def patch_sdk(): + """Do not remove from this file. + + `patch_sdk` is a last resort escape hatch that allows you to do customizations + you can't accomplish using the techniques described in + https://aka.ms/azsdk/python/dpcodegen/python/customize + """ diff --git a/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/operations/_phone_numbers_operations.py b/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/operations/_phone_numbers_operations.py index 97b1eec24332..3cee410bf23d 100644 --- a/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/operations/_phone_numbers_operations.py +++ b/sdk/communication/azure-communication-phonenumbers/azure/communication/phonenumbers/_generated/operations/_phone_numbers_operations.py @@ -1,3 +1,4 @@ +# pylint: disable=too-many-lines # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -5,11 +6,17 @@ # Code generated by Microsoft (R) AutoRest Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -import functools -from typing import TYPE_CHECKING -import warnings - -from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error +from typing import Any, Callable, Dict, IO, Iterable, Optional, TypeVar, Union, cast, overload +import urllib.parse + +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + map_error, +) from azure.core.paging import ItemPaged from azure.core.pipeline import PipelineResponse from azure.core.pipeline.transport import HttpResponse @@ -17,413 +24,345 @@ from azure.core.polling.base_polling import LROBasePolling from azure.core.rest import HttpRequest from azure.core.tracing.decorator import distributed_trace -from msrest import Serializer +from azure.core.utils import case_insensitive_dict from .. import models as _models +from .._serialization import Serializer from .._vendor import _convert_request, _format_url_section -if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports - from typing import Any, Callable, Dict, Generic, Iterable, Optional, TypeVar, Union - T = TypeVar('T') - ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] +T = TypeVar("T") +ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] _SERIALIZER = Serializer() _SERIALIZER.client_side_validation = False -# fmt: off -def build_search_available_phone_numbers_request_initial( - country_code, # type: str - **kwargs # type: Any -): - # type: (...) -> HttpRequest - api_version = kwargs.pop('api_version', "2022-01-11-preview2") # type: str - content_type = kwargs.pop('content_type', None) # type: Optional[str] - accept = "application/json" +def build_search_available_phone_numbers_request(country_code: str, **kwargs: Any) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-01-11-preview2")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + accept = _headers.pop("Accept", "application/json") + # Construct URL - url = kwargs.pop("template_url", '/availablePhoneNumbers/countries/{countryCode}/:search') + _url = kwargs.pop("template_url", "/availablePhoneNumbers/countries/{countryCode}/:search") path_format_arguments = { - "countryCode": _SERIALIZER.url("country_code", country_code, 'str'), + "countryCode": _SERIALIZER.url("country_code", country_code, "str"), } - url = _format_url_section(url, **path_format_arguments) + _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - query_parameters = kwargs.pop("params", {}) # type: Dict[str, Any] - query_parameters['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - header_parameters = kwargs.pop("headers", {}) # type: Dict[str, Any] if content_type is not None: - header_parameters['Content-Type'] = _SERIALIZER.header("content_type", content_type, 'str') - header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str') - - return HttpRequest( - method="POST", - url=url, - params=query_parameters, - headers=header_parameters, - **kwargs - ) - - -def build_get_search_result_request( - search_id, # type: str - **kwargs # type: Any -): - # type: (...) -> HttpRequest - api_version = kwargs.pop('api_version', "2022-01-11-preview2") # type: str - - accept = "application/json" + _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_get_search_result_request(search_id: str, **kwargs: Any) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-01-11-preview2")) # type: str + accept = _headers.pop("Accept", "application/json") + # Construct URL - url = kwargs.pop("template_url", '/availablePhoneNumbers/searchResults/{searchId}') + _url = kwargs.pop("template_url", "/availablePhoneNumbers/searchResults/{searchId}") path_format_arguments = { - "searchId": _SERIALIZER.url("search_id", search_id, 'str'), + "searchId": _SERIALIZER.url("search_id", search_id, "str"), } - url = _format_url_section(url, **path_format_arguments) + _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - query_parameters = kwargs.pop("params", {}) # type: Dict[str, Any] - query_parameters['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - header_parameters = kwargs.pop("headers", {}) # type: Dict[str, Any] - header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str') - - return HttpRequest( - method="GET", - url=url, - params=query_parameters, - headers=header_parameters, - **kwargs - ) - - -def build_purchase_phone_numbers_request_initial( - **kwargs # type: Any -): - # type: (...) -> HttpRequest - api_version = kwargs.pop('api_version', "2022-01-11-preview2") # type: str - content_type = kwargs.pop('content_type', None) # type: Optional[str] - - accept = "application/json" + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_purchase_phone_numbers_request(**kwargs: Any) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-01-11-preview2")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + accept = _headers.pop("Accept", "application/json") + # Construct URL - url = kwargs.pop("template_url", '/availablePhoneNumbers/:purchase') + _url = kwargs.pop("template_url", "/availablePhoneNumbers/:purchase") # Construct parameters - query_parameters = kwargs.pop("params", {}) # type: Dict[str, Any] - query_parameters['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - header_parameters = kwargs.pop("headers", {}) # type: Dict[str, Any] if content_type is not None: - header_parameters['Content-Type'] = _SERIALIZER.header("content_type", content_type, 'str') - header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str') - - return HttpRequest( - method="POST", - url=url, - params=query_parameters, - headers=header_parameters, - **kwargs - ) - - -def build_get_operation_request( - operation_id, # type: str - **kwargs # type: Any -): - # type: (...) -> HttpRequest - api_version = kwargs.pop('api_version', "2022-01-11-preview2") # type: str - - accept = "application/json" + _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_get_operation_request(operation_id: str, **kwargs: Any) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-01-11-preview2")) # type: str + accept = _headers.pop("Accept", "application/json") + # Construct URL - url = kwargs.pop("template_url", '/phoneNumbers/operations/{operationId}') + _url = kwargs.pop("template_url", "/phoneNumbers/operations/{operationId}") path_format_arguments = { - "operationId": _SERIALIZER.url("operation_id", operation_id, 'str'), + "operationId": _SERIALIZER.url("operation_id", operation_id, "str"), } - url = _format_url_section(url, **path_format_arguments) + _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - query_parameters = kwargs.pop("params", {}) # type: Dict[str, Any] - query_parameters['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - header_parameters = kwargs.pop("headers", {}) # type: Dict[str, Any] - header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str') - - return HttpRequest( - method="GET", - url=url, - params=query_parameters, - headers=header_parameters, - **kwargs - ) - - -def build_cancel_operation_request( - operation_id, # type: str - **kwargs # type: Any -): - # type: (...) -> HttpRequest - api_version = kwargs.pop('api_version', "2022-01-11-preview2") # type: str - - accept = "application/json" + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_cancel_operation_request(operation_id: str, **kwargs: Any) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-01-11-preview2")) # type: str + accept = _headers.pop("Accept", "application/json") + # Construct URL - url = kwargs.pop("template_url", '/phoneNumbers/operations/{operationId}') + _url = kwargs.pop("template_url", "/phoneNumbers/operations/{operationId}") path_format_arguments = { - "operationId": _SERIALIZER.url("operation_id", operation_id, 'str'), + "operationId": _SERIALIZER.url("operation_id", operation_id, "str"), } - url = _format_url_section(url, **path_format_arguments) + _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - query_parameters = kwargs.pop("params", {}) # type: Dict[str, Any] - query_parameters['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - header_parameters = kwargs.pop("headers", {}) # type: Dict[str, Any] - header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str') - - return HttpRequest( - method="DELETE", - url=url, - params=query_parameters, - headers=header_parameters, - **kwargs - ) - - -def build_update_capabilities_request_initial( - phone_number, # type: str - **kwargs # type: Any -): - # type: (...) -> HttpRequest - api_version = kwargs.pop('api_version', "2022-01-11-preview2") # type: str - content_type = kwargs.pop('content_type', None) # type: Optional[str] - - accept = "application/json" + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_update_capabilities_request(phone_number: str, **kwargs: Any) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-01-11-preview2")) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + accept = _headers.pop("Accept", "application/json") + # Construct URL - url = kwargs.pop("template_url", '/phoneNumbers/{phoneNumber}/capabilities') + _url = kwargs.pop("template_url", "/phoneNumbers/{phoneNumber}/capabilities") path_format_arguments = { - "phoneNumber": _SERIALIZER.url("phone_number", phone_number, 'str'), + "phoneNumber": _SERIALIZER.url("phone_number", phone_number, "str"), } - url = _format_url_section(url, **path_format_arguments) + _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - query_parameters = kwargs.pop("params", {}) # type: Dict[str, Any] - query_parameters['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - header_parameters = kwargs.pop("headers", {}) # type: Dict[str, Any] if content_type is not None: - header_parameters['Content-Type'] = _SERIALIZER.header("content_type", content_type, 'str') - header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str') - - return HttpRequest( - method="PATCH", - url=url, - params=query_parameters, - headers=header_parameters, - **kwargs - ) - - -def build_get_by_number_request( - phone_number, # type: str - **kwargs # type: Any -): - # type: (...) -> HttpRequest - api_version = kwargs.pop('api_version', "2022-01-11-preview2") # type: str - - accept = "application/json" + _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="PATCH", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_get_by_number_request(phone_number: str, **kwargs: Any) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-01-11-preview2")) # type: str + accept = _headers.pop("Accept", "application/json") + # Construct URL - url = kwargs.pop("template_url", '/phoneNumbers/{phoneNumber}') + _url = kwargs.pop("template_url", "/phoneNumbers/{phoneNumber}") path_format_arguments = { - "phoneNumber": _SERIALIZER.url("phone_number", phone_number, 'str'), + "phoneNumber": _SERIALIZER.url("phone_number", phone_number, "str"), } - url = _format_url_section(url, **path_format_arguments) + _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - query_parameters = kwargs.pop("params", {}) # type: Dict[str, Any] - query_parameters['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - header_parameters = kwargs.pop("headers", {}) # type: Dict[str, Any] - header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str') - - return HttpRequest( - method="GET", - url=url, - params=query_parameters, - headers=header_parameters, - **kwargs - ) - - -def build_release_phone_number_request_initial( - phone_number, # type: str - **kwargs # type: Any -): - # type: (...) -> HttpRequest - api_version = kwargs.pop('api_version', "2022-01-11-preview2") # type: str - - accept = "application/json" + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_release_phone_number_request(phone_number: str, **kwargs: Any) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-01-11-preview2")) # type: str + accept = _headers.pop("Accept", "application/json") + # Construct URL - url = kwargs.pop("template_url", '/phoneNumbers/{phoneNumber}') + _url = kwargs.pop("template_url", "/phoneNumbers/{phoneNumber}") path_format_arguments = { - "phoneNumber": _SERIALIZER.url("phone_number", phone_number, 'str'), + "phoneNumber": _SERIALIZER.url("phone_number", phone_number, "str"), } - url = _format_url_section(url, **path_format_arguments) + _url = _format_url_section(_url, **path_format_arguments) # Construct parameters - query_parameters = kwargs.pop("params", {}) # type: Dict[str, Any] - query_parameters['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - header_parameters = kwargs.pop("headers", {}) # type: Dict[str, Any] - header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str') - - return HttpRequest( - method="DELETE", - url=url, - params=query_parameters, - headers=header_parameters, - **kwargs - ) - - -def build_list_phone_numbers_request( - **kwargs # type: Any -): - # type: (...) -> HttpRequest - api_version = kwargs.pop('api_version', "2022-01-11-preview2") # type: str - skip = kwargs.pop('skip', 0) # type: Optional[int] - top = kwargs.pop('top', 100) # type: Optional[int] - - accept = "application/json" + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_list_phone_numbers_request(*, skip: int = 0, top: int = 100, **kwargs: Any) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", "2022-01-11-preview2")) # type: str + accept = _headers.pop("Accept", "application/json") + # Construct URL - url = kwargs.pop("template_url", '/phoneNumbers') + _url = kwargs.pop("template_url", "/phoneNumbers") # Construct parameters - query_parameters = kwargs.pop("params", {}) # type: Dict[str, Any] if skip is not None: - query_parameters['skip'] = _SERIALIZER.query("skip", skip, 'int') + _params["skip"] = _SERIALIZER.query("skip", skip, "int") if top is not None: - query_parameters['top'] = _SERIALIZER.query("top", top, 'int') - query_parameters['api-version'] = _SERIALIZER.query("api_version", api_version, 'str') + _params["top"] = _SERIALIZER.query("top", top, "int") + _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") # Construct headers - header_parameters = kwargs.pop("headers", {}) # type: Dict[str, Any] - header_parameters['Accept'] = _SERIALIZER.header("accept", accept, 'str') - - return HttpRequest( - method="GET", - url=url, - params=query_parameters, - headers=header_parameters, - **kwargs - ) - -# fmt: on -class PhoneNumbersOperations(object): - """PhoneNumbersOperations operations. - - You should not instantiate this class directly. Instead, you should create a Client instance that - instantiates it for you and attaches it as an attribute. - - :ivar models: Alias to model classes used in this operation group. - :type models: ~azure.communication.phonenumbers.models - :param client: Client for service requests. - :param config: Configuration of service client. - :param serializer: An object model serializer. - :param deserializer: An object model deserializer. + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) + + +class PhoneNumbersOperations: + """ + .. warning:: + **DO NOT** instantiate this class directly. + + Instead, you should access the following operations through + :class:`~azure.communication.phonenumbers.PhoneNumbersClient`'s + :attr:`phone_numbers` attribute. """ models = _models - def __init__(self, client, config, serializer, deserializer): - self._client = client - self._serialize = serializer - self._deserialize = deserializer - self._config = config + def __init__(self, *args, **kwargs): + input_args = list(args) + self._client = input_args.pop(0) if input_args else kwargs.pop("client") + self._config = input_args.pop(0) if input_args else kwargs.pop("config") + self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") + self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") def _search_available_phone_numbers_initial( - self, - country_code, # type: str - body, # type: "_models.PhoneNumberSearchRequest" - **kwargs # type: Any - ): - # type: (...) -> "_models.PhoneNumberSearchResult" - cls = kwargs.pop('cls', None) # type: ClsType["_models.PhoneNumberSearchResult"] + self, country_code: str, body: Union[_models.PhoneNumberSearchRequest, IO], **kwargs: Any + ) -> _models.PhoneNumberSearchResult: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {})) + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', "2022-01-11-preview2") # type: str - content_type = kwargs.pop('content_type', "application/json") # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.PhoneNumberSearchResult] - _json = self._serialize.body(body, 'PhoneNumberSearchRequest') + content_type = content_type or "application/json" + _json = None + _content = None + if isinstance(body, (IO, bytes)): + _content = body + else: + _json = self._serialize.body(body, "PhoneNumberSearchRequest") - request = build_search_available_phone_numbers_request_initial( + request = build_search_available_phone_numbers_request( country_code=country_code, api_version=api_version, content_type=content_type, json=_json, - template_url=self._search_available_phone_numbers_initial.metadata['url'], + content=_content, + template_url=self._search_available_phone_numbers_initial.metadata["url"], + headers=_headers, + params=_params, ) request = _convert_request(request) path_format_arguments = { - "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), + "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), } - request.url = self._client.format_url(request.url, **path_format_arguments) + request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore + + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) - pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs) response = pipeline_response.http_response if response.status_code not in [202]: map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response) + error = self._deserialize.failsafe_deserialize(_models.CommunicationErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error) response_headers = {} - response_headers['Location']=self._deserialize('str', response.headers.get('Location')) - response_headers['Operation-Location']=self._deserialize('str', response.headers.get('Operation-Location')) - response_headers['operation-id']=self._deserialize('str', response.headers.get('operation-id')) - response_headers['search-id']=self._deserialize('str', response.headers.get('search-id')) + response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) + response_headers["Operation-Location"] = self._deserialize("str", response.headers.get("Operation-Location")) + response_headers["operation-id"] = self._deserialize("str", response.headers.get("operation-id")) + response_headers["search-id"] = self._deserialize("str", response.headers.get("search-id")) - deserialized = self._deserialize('PhoneNumberSearchResult', pipeline_response) + deserialized = self._deserialize("PhoneNumberSearchResult", pipeline_response) if cls: return cls(pipeline_response, deserialized, response_headers) return deserialized - _search_available_phone_numbers_initial.metadata = {'url': '/availablePhoneNumbers/countries/{countryCode}/:search'} # type: ignore - + _search_available_phone_numbers_initial.metadata = {"url": "/availablePhoneNumbers/countries/{countryCode}/:search"} # type: ignore - @distributed_trace + @overload def begin_search_available_phone_numbers( self, - country_code, # type: str - body, # type: "_models.PhoneNumberSearchRequest" - **kwargs # type: Any - ): - # type: (...) -> LROPoller["_models.PhoneNumberSearchResult"] + country_code: str, + body: _models.PhoneNumberSearchRequest, + *, + content_type: str = "application/json", + **kwargs: Any + ) -> LROPoller[_models.PhoneNumberSearchResult]: """Search for available phone numbers to purchase. Search for available phone numbers to purchase. - :param country_code: The ISO 3166-2 country code, e.g. US. + :param country_code: The ISO 3166-2 country code, e.g. US. Required. :type country_code: str - :param body: The phone number search request. + :param body: The phone number search request. Required. :type body: ~azure.communication.phonenumbers.models.PhoneNumberSearchRequest + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. :keyword polling: By default, your polling method will be LROBasePolling. Pass in False for @@ -436,100 +375,178 @@ def begin_search_available_phone_numbers( cls(response) :rtype: ~azure.core.polling.LROPoller[~azure.communication.phonenumbers.models.PhoneNumberSearchResult] - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - api_version = kwargs.pop('api_version', "2022-01-11-preview2") # type: str - content_type = kwargs.pop('content_type', "application/json") # type: Optional[str] - polling = kwargs.pop('polling', True) # type: Union[bool, azure.core.polling.PollingMethod] - cls = kwargs.pop('cls', None) # type: ClsType["_models.PhoneNumberSearchResult"] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + + @overload + def begin_search_available_phone_numbers( + self, country_code: str, body: IO, *, content_type: str = "application/json", **kwargs: Any + ) -> LROPoller[_models.PhoneNumberSearchResult]: + """Search for available phone numbers to purchase. + + Search for available phone numbers to purchase. + + :param country_code: The ISO 3166-2 country code, e.g. US. Required. + :type country_code: str + :param body: The phone number search request. Required. + :type body: IO + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be LROBasePolling. Pass in False for + this operation to not poll, or pass in your own initialized polling object for a personal + polling strategy. + :paramtype polling: bool or ~azure.core.polling.PollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :return: An instance of LROPoller that returns either PhoneNumberSearchResult or the result of + cls(response) + :rtype: + ~azure.core.polling.LROPoller[~azure.communication.phonenumbers.models.PhoneNumberSearchResult] + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace + def begin_search_available_phone_numbers( + self, country_code: str, body: Union[_models.PhoneNumberSearchRequest, IO], **kwargs: Any + ) -> LROPoller[_models.PhoneNumberSearchResult]: + """Search for available phone numbers to purchase. + + Search for available phone numbers to purchase. + + :param country_code: The ISO 3166-2 country code, e.g. US. Required. + :type country_code: str + :param body: The phone number search request. Is either a model type or a IO type. Required. + :type body: ~azure.communication.phonenumbers.models.PhoneNumberSearchRequest or IO + :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. + Default value is None. + :paramtype content_type: str + :keyword callable cls: A custom type or function that will be passed the direct response + :keyword str continuation_token: A continuation token to restart a poller from a saved state. + :keyword polling: By default, your polling method will be LROBasePolling. Pass in False for + this operation to not poll, or pass in your own initialized polling object for a personal + polling strategy. + :paramtype polling: bool or ~azure.core.polling.PollingMethod + :keyword int polling_interval: Default waiting time between two polls for LRO operations if no + Retry-After header is present. + :return: An instance of LROPoller that returns either PhoneNumberSearchResult or the result of + cls(response) + :rtype: + ~azure.core.polling.LROPoller[~azure.communication.phonenumbers.models.PhoneNumberSearchResult] + :raises ~azure.core.exceptions.HttpResponseError: + """ + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] + cls = kwargs.pop("cls", None) # type: ClsType[_models.PhoneNumberSearchResult] + polling = kwargs.pop("polling", True) # type: Union[bool, PollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: - raw_result = self._search_available_phone_numbers_initial( + raw_result = self._search_available_phone_numbers_initial( # type: ignore country_code=country_code, body=body, api_version=api_version, content_type=content_type, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, + headers=_headers, + params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) def get_long_running_output(pipeline_response): response_headers = {} response = pipeline_response.http_response - response_headers['Location']=self._deserialize('str', response.headers.get('Location')) - response_headers['Operation-Location']=self._deserialize('str', response.headers.get('Operation-Location')) - response_headers['operation-id']=self._deserialize('str', response.headers.get('operation-id')) - response_headers['search-id']=self._deserialize('str', response.headers.get('search-id')) - - deserialized = self._deserialize('PhoneNumberSearchResult', pipeline_response) + response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) + response_headers["Operation-Location"] = self._deserialize( + "str", response.headers.get("Operation-Location") + ) + response_headers["operation-id"] = self._deserialize("str", response.headers.get("operation-id")) + response_headers["search-id"] = self._deserialize("str", response.headers.get("search-id")) + + deserialized = self._deserialize("PhoneNumberSearchResult", pipeline_response) if cls: return cls(pipeline_response, deserialized, response_headers) return deserialized - path_format_arguments = { - "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), + "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), } - if polling is True: polling_method = LROBasePolling(lro_delay, lro_options={'final-state-via': 'location'}, path_format_arguments=path_format_arguments, **kwargs) - elif polling is False: polling_method = NoPolling() - else: polling_method = polling + if polling is True: + polling_method = cast( + PollingMethod, + LROBasePolling( + lro_delay, + lro_options={"final-state-via": "location"}, + path_format_arguments=path_format_arguments, + **kwargs + ), + ) # type: PollingMethod + elif polling is False: + polling_method = cast(PollingMethod, NoPolling()) + else: + polling_method = polling if cont_token: return LROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) - else: - return LROPoller(self._client, raw_result, get_long_running_output, polling_method) + return LROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_search_available_phone_numbers.metadata = {'url': '/availablePhoneNumbers/countries/{countryCode}/:search'} # type: ignore + begin_search_available_phone_numbers.metadata = {"url": "/availablePhoneNumbers/countries/{countryCode}/:search"} # type: ignore @distributed_trace - def get_search_result( - self, - search_id, # type: str - **kwargs # type: Any - ): - # type: (...) -> "_models.PhoneNumberSearchResult" + def get_search_result(self, search_id: str, **kwargs: Any) -> _models.PhoneNumberSearchResult: """Gets a phone number search result by search id. Gets a phone number search result by search id. - :param search_id: The search Id. + :param search_id: The search Id. Required. :type search_id: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: PhoneNumberSearchResult, or the result of cls(response) + :return: PhoneNumberSearchResult or the result of cls(response) :rtype: ~azure.communication.phonenumbers.models.PhoneNumberSearchResult - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - cls = kwargs.pop('cls', None) # type: ClsType["_models.PhoneNumberSearchResult"] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {})) + error_map.update(kwargs.pop("error_map", {}) or {}) - api_version = kwargs.pop('api_version', "2022-01-11-preview2") # type: str + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.PhoneNumberSearchResult] - request = build_get_search_result_request( search_id=search_id, api_version=api_version, - template_url=self.get_search_result.metadata['url'], + template_url=self.get_search_result.metadata["url"], + headers=_headers, + params=_params, ) request = _convert_request(request) path_format_arguments = { - "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), + "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), } - request.url = self._client.format_url(request.url, **path_format_arguments) + request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore + + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) - pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs) response = pipeline_response.http_response if response.status_code not in [200]: @@ -537,77 +554,78 @@ def get_search_result( error = self._deserialize.failsafe_deserialize(_models.CommunicationErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error) - deserialized = self._deserialize('PhoneNumberSearchResult', pipeline_response) + deserialized = self._deserialize("PhoneNumberSearchResult", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get_search_result.metadata = {'url': '/availablePhoneNumbers/searchResults/{searchId}'} # type: ignore + get_search_result.metadata = {"url": "/availablePhoneNumbers/searchResults/{searchId}"} # type: ignore - - def _purchase_phone_numbers_initial( - self, - search_id=None, # type: Optional[str] - **kwargs # type: Any - ): - # type: (...) -> None - cls = kwargs.pop('cls', None) # type: ClsType[None] + def _purchase_phone_numbers_initial( # pylint: disable=inconsistent-return-statements + self, search_id: Optional[str] = None, **kwargs: Any + ) -> None: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {})) + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', "2022-01-11-preview2") # type: str - content_type = kwargs.pop('content_type', "application/json") # type: Optional[str] + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", "application/json")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] _body = _models.PhoneNumberPurchaseRequest(search_id=search_id) - _json = self._serialize.body(_body, 'PhoneNumberPurchaseRequest') + _json = self._serialize.body(_body, "PhoneNumberPurchaseRequest") - request = build_purchase_phone_numbers_request_initial( + request = build_purchase_phone_numbers_request( api_version=api_version, content_type=content_type, json=_json, - template_url=self._purchase_phone_numbers_initial.metadata['url'], + template_url=self._purchase_phone_numbers_initial.metadata["url"], + headers=_headers, + params=_params, ) request = _convert_request(request) path_format_arguments = { - "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), + "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), } - request.url = self._client.format_url(request.url, **path_format_arguments) + request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore + + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) - pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs) response = pipeline_response.http_response if response.status_code not in [202]: map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response) + error = self._deserialize.failsafe_deserialize(_models.CommunicationErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error) response_headers = {} - response_headers['Operation-Location']=self._deserialize('str', response.headers.get('Operation-Location')) - response_headers['operation-id']=self._deserialize('str', response.headers.get('operation-id')) - response_headers['purchase-id']=self._deserialize('str', response.headers.get('purchase-id')) - + response_headers["Operation-Location"] = self._deserialize("str", response.headers.get("Operation-Location")) + response_headers["operation-id"] = self._deserialize("str", response.headers.get("operation-id")) + response_headers["purchase-id"] = self._deserialize("str", response.headers.get("purchase-id")) if cls: return cls(pipeline_response, None, response_headers) - _purchase_phone_numbers_initial.metadata = {'url': '/availablePhoneNumbers/:purchase'} # type: ignore - + _purchase_phone_numbers_initial.metadata = {"url": "/availablePhoneNumbers/:purchase"} # type: ignore @distributed_trace - def begin_purchase_phone_numbers( - self, - search_id=None, # type: Optional[str] - **kwargs # type: Any - ): - # type: (...) -> LROPoller[None] + def begin_purchase_phone_numbers(self, search_id: Optional[str] = None, **kwargs: Any) -> LROPoller[None]: """Purchases phone numbers. Purchases phone numbers. - :param search_id: The search id. + :param search_id: The search id. Default value is None. :type search_id: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. @@ -619,90 +637,100 @@ def begin_purchase_phone_numbers( Retry-After header is present. :return: An instance of LROPoller that returns either None or the result of cls(response) :rtype: ~azure.core.polling.LROPoller[None] - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - api_version = kwargs.pop('api_version', "2022-01-11-preview2") # type: str - content_type = kwargs.pop('content_type', "application/json") # type: Optional[str] - polling = kwargs.pop('polling', True) # type: Union[bool, azure.core.polling.PollingMethod] - cls = kwargs.pop('cls', None) # type: ClsType[None] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop("content_type", _headers.pop("Content-Type", "application/json")) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] + polling = kwargs.pop("polling", True) # type: Union[bool, PollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: - raw_result = self._purchase_phone_numbers_initial( + raw_result = self._purchase_phone_numbers_initial( # type: ignore search_id=search_id, api_version=api_version, content_type=content_type, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, + headers=_headers, + params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) - def get_long_running_output(pipeline_response): + def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - path_format_arguments = { - "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), + "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), } - if polling is True: polling_method = LROBasePolling(lro_delay, path_format_arguments=path_format_arguments, **kwargs) - elif polling is False: polling_method = NoPolling() - else: polling_method = polling + if polling is True: + polling_method = cast( + PollingMethod, LROBasePolling(lro_delay, path_format_arguments=path_format_arguments, **kwargs) + ) # type: PollingMethod + elif polling is False: + polling_method = cast(PollingMethod, NoPolling()) + else: + polling_method = polling if cont_token: return LROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) - else: - return LROPoller(self._client, raw_result, get_long_running_output, polling_method) + return LROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_purchase_phone_numbers.metadata = {'url': '/availablePhoneNumbers/:purchase'} # type: ignore + begin_purchase_phone_numbers.metadata = {"url": "/availablePhoneNumbers/:purchase"} # type: ignore @distributed_trace - def get_operation( - self, - operation_id, # type: str - **kwargs # type: Any - ): - # type: (...) -> "_models.PhoneNumberOperation" + def get_operation(self, operation_id: str, **kwargs: Any) -> _models.PhoneNumberOperation: """Gets an operation by its id. Gets an operation by its id. - :param operation_id: The id of the operation. + :param operation_id: The id of the operation. Required. :type operation_id: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: PhoneNumberOperation, or the result of cls(response) + :return: PhoneNumberOperation or the result of cls(response) :rtype: ~azure.communication.phonenumbers.models.PhoneNumberOperation - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - cls = kwargs.pop('cls', None) # type: ClsType["_models.PhoneNumberOperation"] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {})) + error_map.update(kwargs.pop("error_map", {}) or {}) - api_version = kwargs.pop('api_version', "2022-01-11-preview2") # type: str + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.PhoneNumberOperation] - request = build_get_operation_request( operation_id=operation_id, api_version=api_version, - template_url=self.get_operation.metadata['url'], + template_url=self.get_operation.metadata["url"], + headers=_headers, + params=_params, ) request = _convert_request(request) path_format_arguments = { - "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), + "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), } - request.url = self._client.format_url(request.url, **path_format_arguments) + request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore + + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) - pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs) response = pipeline_response.http_response if response.status_code not in [200]: @@ -711,57 +739,63 @@ def get_operation( raise HttpResponseError(response=response, model=error) response_headers = {} - response_headers['Location']=self._deserialize('str', response.headers.get('Location')) + response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) - deserialized = self._deserialize('PhoneNumberOperation', pipeline_response) + deserialized = self._deserialize("PhoneNumberOperation", pipeline_response) if cls: return cls(pipeline_response, deserialized, response_headers) return deserialized - get_operation.metadata = {'url': '/phoneNumbers/operations/{operationId}'} # type: ignore - + get_operation.metadata = {"url": "/phoneNumbers/operations/{operationId}"} # type: ignore @distributed_trace - def cancel_operation( - self, - operation_id, # type: str - **kwargs # type: Any - ): - # type: (...) -> None + def cancel_operation( # pylint: disable=inconsistent-return-statements + self, operation_id: str, **kwargs: Any + ) -> None: """Cancels an operation by its id. Cancels an operation by its id. - :param operation_id: The id of the operation. + :param operation_id: The id of the operation. Required. :type operation_id: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None, or the result of cls(response) + :return: None or the result of cls(response) :rtype: None - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - cls = kwargs.pop('cls', None) # type: ClsType[None] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {})) + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', "2022-01-11-preview2") # type: str + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - request = build_cancel_operation_request( operation_id=operation_id, api_version=api_version, - template_url=self.cancel_operation.metadata['url'], + template_url=self.cancel_operation.metadata["url"], + headers=_headers, + params=_params, ) request = _convert_request(request) path_format_arguments = { - "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), + "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), } - request.url = self._client.format_url(request.url, **path_format_arguments) + request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore + + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) - pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs) response = pipeline_response.http_response if response.status_code not in [204]: @@ -772,87 +806,99 @@ def cancel_operation( if cls: return cls(pipeline_response, None, {}) - cancel_operation.metadata = {'url': '/phoneNumbers/operations/{operationId}'} # type: ignore - + cancel_operation.metadata = {"url": "/phoneNumbers/operations/{operationId}"} # type: ignore def _update_capabilities_initial( self, - phone_number, # type: str - calling=None, # type: Optional[Union[str, "_models.PhoneNumberCapabilityType"]] - sms=None, # type: Optional[Union[str, "_models.PhoneNumberCapabilityType"]] - **kwargs # type: Any - ): - # type: (...) -> "_models.PurchasedPhoneNumber" - cls = kwargs.pop('cls', None) # type: ClsType["_models.PurchasedPhoneNumber"] + phone_number: str, + calling: Optional[Union[str, _models.PhoneNumberCapabilityType]] = None, + sms: Optional[Union[str, _models.PhoneNumberCapabilityType]] = None, + **kwargs: Any + ) -> _models.PurchasedPhoneNumber: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {})) + error_map.update(kwargs.pop("error_map", {}) or {}) - api_version = kwargs.pop('api_version', "2022-01-11-preview2") # type: str - content_type = kwargs.pop('content_type', "application/merge-patch+json") # type: Optional[str] + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop( + "content_type", _headers.pop("Content-Type", "application/merge-patch+json") + ) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.PurchasedPhoneNumber] _body = _models.PhoneNumberCapabilitiesRequest(calling=calling, sms=sms) if _body is not None: - _json = self._serialize.body(_body, 'PhoneNumberCapabilitiesRequest') + _json = self._serialize.body(_body, "PhoneNumberCapabilitiesRequest") else: _json = None - request = build_update_capabilities_request_initial( + request = build_update_capabilities_request( phone_number=phone_number, api_version=api_version, content_type=content_type, json=_json, - template_url=self._update_capabilities_initial.metadata['url'], + template_url=self._update_capabilities_initial.metadata["url"], + headers=_headers, + params=_params, ) request = _convert_request(request) path_format_arguments = { - "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), + "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), } - request.url = self._client.format_url(request.url, **path_format_arguments) + request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore + + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) - pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs) response = pipeline_response.http_response if response.status_code not in [202]: map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response) + error = self._deserialize.failsafe_deserialize(_models.CommunicationErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error) response_headers = {} - response_headers['Location']=self._deserialize('str', response.headers.get('Location')) - response_headers['Operation-Location']=self._deserialize('str', response.headers.get('Operation-Location')) - response_headers['operation-id']=self._deserialize('str', response.headers.get('operation-id')) - response_headers['capabilities-id']=self._deserialize('str', response.headers.get('capabilities-id')) + response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) + response_headers["Operation-Location"] = self._deserialize("str", response.headers.get("Operation-Location")) + response_headers["operation-id"] = self._deserialize("str", response.headers.get("operation-id")) + response_headers["capabilities-id"] = self._deserialize("str", response.headers.get("capabilities-id")) - deserialized = self._deserialize('PurchasedPhoneNumber', pipeline_response) + deserialized = self._deserialize("PurchasedPhoneNumber", pipeline_response) if cls: return cls(pipeline_response, deserialized, response_headers) return deserialized - _update_capabilities_initial.metadata = {'url': '/phoneNumbers/{phoneNumber}/capabilities'} # type: ignore - + _update_capabilities_initial.metadata = {"url": "/phoneNumbers/{phoneNumber}/capabilities"} # type: ignore @distributed_trace def begin_update_capabilities( self, - phone_number, # type: str - calling=None, # type: Optional[Union[str, "_models.PhoneNumberCapabilityType"]] - sms=None, # type: Optional[Union[str, "_models.PhoneNumberCapabilityType"]] - **kwargs # type: Any - ): - # type: (...) -> LROPoller["_models.PurchasedPhoneNumber"] + phone_number: str, + calling: Optional[Union[str, _models.PhoneNumberCapabilityType]] = None, + sms: Optional[Union[str, _models.PhoneNumberCapabilityType]] = None, + **kwargs: Any + ) -> LROPoller[_models.PurchasedPhoneNumber]: """Updates the capabilities of a phone number. Updates the capabilities of a phone number. :param phone_number: The phone number id in E.164 format. The leading plus can be either + or - encoded as %2B, e.g. +11234567890. + encoded as %2B, e.g. +11234567890. Required. :type phone_number: str - :param calling: Capability value for calling. + :param calling: Capability value for calling. Known values are: "none", "inbound", "outbound", + and "inbound+outbound". Default value is None. :type calling: str or ~azure.communication.phonenumbers.models.PhoneNumberCapabilityType - :param sms: Capability value for SMS. + :param sms: Capability value for SMS. Known values are: "none", "inbound", "outbound", and + "inbound+outbound". Default value is None. :type sms: str or ~azure.communication.phonenumbers.models.PhoneNumberCapabilityType :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. @@ -866,102 +912,122 @@ def begin_update_capabilities( cls(response) :rtype: ~azure.core.polling.LROPoller[~azure.communication.phonenumbers.models.PurchasedPhoneNumber] - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - api_version = kwargs.pop('api_version', "2022-01-11-preview2") # type: str - content_type = kwargs.pop('content_type', "application/merge-patch+json") # type: Optional[str] - polling = kwargs.pop('polling', True) # type: Union[bool, azure.core.polling.PollingMethod] - cls = kwargs.pop('cls', None) # type: ClsType["_models.PurchasedPhoneNumber"] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + content_type = kwargs.pop( + "content_type", _headers.pop("Content-Type", "application/merge-patch+json") + ) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.PurchasedPhoneNumber] + polling = kwargs.pop("polling", True) # type: Union[bool, PollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: - raw_result = self._update_capabilities_initial( + raw_result = self._update_capabilities_initial( # type: ignore phone_number=phone_number, calling=calling, sms=sms, api_version=api_version, content_type=content_type, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, + headers=_headers, + params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) def get_long_running_output(pipeline_response): response_headers = {} response = pipeline_response.http_response - response_headers['Location']=self._deserialize('str', response.headers.get('Location')) - response_headers['Operation-Location']=self._deserialize('str', response.headers.get('Operation-Location')) - response_headers['operation-id']=self._deserialize('str', response.headers.get('operation-id')) - response_headers['capabilities-id']=self._deserialize('str', response.headers.get('capabilities-id')) - - deserialized = self._deserialize('PurchasedPhoneNumber', pipeline_response) + response_headers["Location"] = self._deserialize("str", response.headers.get("Location")) + response_headers["Operation-Location"] = self._deserialize( + "str", response.headers.get("Operation-Location") + ) + response_headers["operation-id"] = self._deserialize("str", response.headers.get("operation-id")) + response_headers["capabilities-id"] = self._deserialize("str", response.headers.get("capabilities-id")) + + deserialized = self._deserialize("PurchasedPhoneNumber", pipeline_response) if cls: return cls(pipeline_response, deserialized, response_headers) return deserialized - path_format_arguments = { - "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), + "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), } - if polling is True: polling_method = LROBasePolling(lro_delay, lro_options={'final-state-via': 'location'}, path_format_arguments=path_format_arguments, **kwargs) - elif polling is False: polling_method = NoPolling() - else: polling_method = polling + if polling is True: + polling_method = cast( + PollingMethod, + LROBasePolling( + lro_delay, + lro_options={"final-state-via": "location"}, + path_format_arguments=path_format_arguments, + **kwargs + ), + ) # type: PollingMethod + elif polling is False: + polling_method = cast(PollingMethod, NoPolling()) + else: + polling_method = polling if cont_token: return LROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) - else: - return LROPoller(self._client, raw_result, get_long_running_output, polling_method) + return LROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_update_capabilities.metadata = {'url': '/phoneNumbers/{phoneNumber}/capabilities'} # type: ignore + begin_update_capabilities.metadata = {"url": "/phoneNumbers/{phoneNumber}/capabilities"} # type: ignore @distributed_trace - def get_by_number( - self, - phone_number, # type: str - **kwargs # type: Any - ): - # type: (...) -> "_models.PurchasedPhoneNumber" + def get_by_number(self, phone_number: str, **kwargs: Any) -> _models.PurchasedPhoneNumber: """Gets the details of the given purchased phone number. Gets the details of the given purchased phone number. :param phone_number: The purchased phone number whose details are to be fetched in E.164 - format, e.g. +11234567890. + format, e.g. +11234567890. Required. :type phone_number: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: PurchasedPhoneNumber, or the result of cls(response) + :return: PurchasedPhoneNumber or the result of cls(response) :rtype: ~azure.communication.phonenumbers.models.PurchasedPhoneNumber - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - cls = kwargs.pop('cls', None) # type: ClsType["_models.PurchasedPhoneNumber"] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {})) + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', "2022-01-11-preview2") # type: str + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.PurchasedPhoneNumber] - request = build_get_by_number_request( phone_number=phone_number, api_version=api_version, - template_url=self.get_by_number.metadata['url'], + template_url=self.get_by_number.metadata["url"], + headers=_headers, + params=_params, ) request = _convert_request(request) path_format_arguments = { - "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), + "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), } - request.url = self._client.format_url(request.url, **path_format_arguments) + request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore + + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) - pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs) response = pipeline_response.http_response if response.status_code not in [200]: @@ -969,73 +1035,73 @@ def get_by_number( error = self._deserialize.failsafe_deserialize(_models.CommunicationErrorResponse, pipeline_response) raise HttpResponseError(response=response, model=error) - deserialized = self._deserialize('PurchasedPhoneNumber', pipeline_response) + deserialized = self._deserialize("PurchasedPhoneNumber", pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - get_by_number.metadata = {'url': '/phoneNumbers/{phoneNumber}'} # type: ignore - + get_by_number.metadata = {"url": "/phoneNumbers/{phoneNumber}"} # type: ignore - def _release_phone_number_initial( - self, - phone_number, # type: str - **kwargs # type: Any - ): - # type: (...) -> None - cls = kwargs.pop('cls', None) # type: ClsType[None] + def _release_phone_number_initial( # pylint: disable=inconsistent-return-statements + self, phone_number: str, **kwargs: Any + ) -> None: error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {})) + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop('api_version', "2022-01-11-preview2") # type: str + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] - - request = build_release_phone_number_request_initial( + request = build_release_phone_number_request( phone_number=phone_number, api_version=api_version, - template_url=self._release_phone_number_initial.metadata['url'], + template_url=self._release_phone_number_initial.metadata["url"], + headers=_headers, + params=_params, ) request = _convert_request(request) path_format_arguments = { - "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), + "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), } - request.url = self._client.format_url(request.url, **path_format_arguments) + request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore + + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) - pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs) response = pipeline_response.http_response if response.status_code not in [202]: map_error(status_code=response.status_code, response=response, error_map=error_map) - raise HttpResponseError(response=response) + error = self._deserialize.failsafe_deserialize(_models.CommunicationErrorResponse, pipeline_response) + raise HttpResponseError(response=response, model=error) response_headers = {} - response_headers['Operation-Location']=self._deserialize('str', response.headers.get('Operation-Location')) - response_headers['operation-id']=self._deserialize('str', response.headers.get('operation-id')) - response_headers['release-id']=self._deserialize('str', response.headers.get('release-id')) - + response_headers["Operation-Location"] = self._deserialize("str", response.headers.get("Operation-Location")) + response_headers["operation-id"] = self._deserialize("str", response.headers.get("operation-id")) + response_headers["release-id"] = self._deserialize("str", response.headers.get("release-id")) if cls: return cls(pipeline_response, None, response_headers) - _release_phone_number_initial.metadata = {'url': '/phoneNumbers/{phoneNumber}'} # type: ignore - + _release_phone_number_initial.metadata = {"url": "/phoneNumbers/{phoneNumber}"} # type: ignore @distributed_trace - def begin_release_phone_number( - self, - phone_number, # type: str - **kwargs # type: Any - ): - # type: (...) -> LROPoller[None] + def begin_release_phone_number(self, phone_number: str, **kwargs: Any) -> LROPoller[None]: """Releases a purchased phone number. Releases a purchased phone number. - :param phone_number: Phone number to be released, e.g. +11234567890. + :param phone_number: Phone number to be released, e.g. +11234567890. Required. :type phone_number: str :keyword callable cls: A custom type or function that will be passed the direct response :keyword str continuation_token: A continuation token to restart a poller from a saved state. @@ -1047,113 +1113,128 @@ def begin_release_phone_number( Retry-After header is present. :return: An instance of LROPoller that returns either None or the result of cls(response) :rtype: ~azure.core.polling.LROPoller[None] - :raises: ~azure.core.exceptions.HttpResponseError + :raises ~azure.core.exceptions.HttpResponseError: """ - api_version = kwargs.pop('api_version', "2022-01-11-preview2") # type: str - polling = kwargs.pop('polling', True) # type: Union[bool, azure.core.polling.PollingMethod] - cls = kwargs.pop('cls', None) # type: ClsType[None] - lro_delay = kwargs.pop( - 'polling_interval', - self._config.polling_interval - ) - cont_token = kwargs.pop('continuation_token', None) # type: Optional[str] + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[None] + polling = kwargs.pop("polling", True) # type: Union[bool, PollingMethod] + lro_delay = kwargs.pop("polling_interval", self._config.polling_interval) + cont_token = kwargs.pop("continuation_token", None) # type: Optional[str] if cont_token is None: - raw_result = self._release_phone_number_initial( + raw_result = self._release_phone_number_initial( # type: ignore phone_number=phone_number, api_version=api_version, - cls=lambda x,y,z: x, + cls=lambda x, y, z: x, + headers=_headers, + params=_params, **kwargs ) - kwargs.pop('error_map', None) + kwargs.pop("error_map", None) - def get_long_running_output(pipeline_response): + def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - path_format_arguments = { - "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), + "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), } - if polling is True: polling_method = LROBasePolling(lro_delay, path_format_arguments=path_format_arguments, **kwargs) - elif polling is False: polling_method = NoPolling() - else: polling_method = polling + if polling is True: + polling_method = cast( + PollingMethod, LROBasePolling(lro_delay, path_format_arguments=path_format_arguments, **kwargs) + ) # type: PollingMethod + elif polling is False: + polling_method = cast(PollingMethod, NoPolling()) + else: + polling_method = polling if cont_token: return LROPoller.from_continuation_token( polling_method=polling_method, continuation_token=cont_token, client=self._client, - deserialization_callback=get_long_running_output + deserialization_callback=get_long_running_output, ) - else: - return LROPoller(self._client, raw_result, get_long_running_output, polling_method) + return LROPoller(self._client, raw_result, get_long_running_output, polling_method) - begin_release_phone_number.metadata = {'url': '/phoneNumbers/{phoneNumber}'} # type: ignore + begin_release_phone_number.metadata = {"url": "/phoneNumbers/{phoneNumber}"} # type: ignore @distributed_trace def list_phone_numbers( - self, - skip=0, # type: Optional[int] - top=100, # type: Optional[int] - **kwargs # type: Any - ): - # type: (...) -> Iterable["_models.PurchasedPhoneNumbers"] + self, skip: int = 0, top: int = 100, **kwargs: Any + ) -> Iterable["_models.PurchasedPhoneNumber"]: """Gets the list of all purchased phone numbers. Gets the list of all purchased phone numbers. :param skip: An optional parameter for how many entries to skip, for pagination purposes. The - default value is 0. + default value is 0. Default value is 0. :type skip: int :param top: An optional parameter for how many entries to return, for pagination purposes. The - default value is 100. + default value is 100. Default value is 100. :type top: int :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either PurchasedPhoneNumbers or the result of + :return: An iterator like instance of either PurchasedPhoneNumber or the result of cls(response) :rtype: - ~azure.core.paging.ItemPaged[~azure.communication.phonenumbers.models.PurchasedPhoneNumbers] - :raises: ~azure.core.exceptions.HttpResponseError + ~azure.core.paging.ItemPaged[~azure.communication.phonenumbers.models.PurchasedPhoneNumber] + :raises ~azure.core.exceptions.HttpResponseError: """ - api_version = kwargs.pop('api_version', "2022-01-11-preview2") # type: str + _headers = kwargs.pop("headers", {}) or {} + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str + cls = kwargs.pop("cls", None) # type: ClsType[_models.PurchasedPhoneNumbers] - cls = kwargs.pop('cls', None) # type: ClsType["_models.PurchasedPhoneNumbers"] error_map = { - 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, } - error_map.update(kwargs.pop('error_map', {})) + error_map.update(kwargs.pop("error_map", {}) or {}) + def prepare_request(next_link=None): if not next_link: - + request = build_list_phone_numbers_request( - api_version=api_version, skip=skip, top=top, - template_url=self.list_phone_numbers.metadata['url'], + api_version=api_version, + template_url=self.list_phone_numbers.metadata["url"], + headers=_headers, + params=_params, ) request = _convert_request(request) path_format_arguments = { - "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), + "endpoint": self._serialize.url( + "self._config.endpoint", self._config.endpoint, "str", skip_quote=True + ), } - request.url = self._client.format_url(request.url, **path_format_arguments) + request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore else: - - request = build_list_phone_numbers_request( - api_version=api_version, - skip=skip, - top=top, - template_url=next_link, + # make call to next link with the client's api-version + _parsed_next_link = urllib.parse.urlparse(next_link) + _next_request_params = case_insensitive_dict( + { + key: [urllib.parse.quote(v) for v in value] + for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() + } + ) + _next_request_params["api-version"] = self._config.api_version + request = HttpRequest( + "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params ) request = _convert_request(request) path_format_arguments = { - "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), - } - request.url = self._client.format_url(request.url, **path_format_arguments) - - path_format_arguments = { - "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), + "endpoint": self._serialize.url( + "self._config.endpoint", self._config.endpoint, "str", skip_quote=True + ), } + request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore request.method = "GET" return request @@ -1167,7 +1248,9 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs) + pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access + request, stream=False, **kwargs + ) response = pipeline_response.http_response if response.status_code not in [200]: @@ -1177,8 +1260,6 @@ def get_next(next_link=None): return pipeline_response + return ItemPaged(get_next, extract_data) - return ItemPaged( - get_next, extract_data - ) - list_phone_numbers.metadata = {'url': '/phoneNumbers'} # type: ignore + list_phone_numbers.metadata = {"url": "/phoneNumbers"} # type: ignore From 508267f8a8e6bc694ece8e67610406876eb33b7b Mon Sep 17 00:00:00 2001 From: Olena Stoliarova Date: Mon, 17 Oct 2022 17:03:34 +0300 Subject: [PATCH 10/19] rollback changes for sms modality --- .../communication/sms/_generated/__init__.py | 13 +- .../_azure_communication_sms_service.py | 73 +++--- .../sms/_generated/_configuration.py | 51 ++-- .../sms/_generated/aio/__init__.py | 13 +- .../aio/_azure_communication_sms_service.py | 64 ++--- .../sms/_generated/aio/_configuration.py | 46 ++-- .../sms/_generated/aio/operations/__init__.py | 8 +- .../aio/operations/_sms_operations.py | 176 +++++-------- .../sms/_generated/models/__init__.py | 38 +-- .../_azure_communication_sms_service_enums.py | 22 +- .../sms/_generated/models/_models.py | 197 +++++++++++++++ .../sms/_generated/models/_models_py3.py | 231 +++++++----------- .../sms/_generated/operations/__init__.py | 8 +- .../_generated/operations/_sms_operations.py | 206 +++++----------- .../azure/communication/sms/_sms_client.py | 8 +- .../sms/aio/_sms_client_async.py | 10 +- 16 files changed, 567 insertions(+), 597 deletions(-) create mode 100644 sdk/communication/azure-communication-sms/azure/communication/sms/_generated/models/_models.py diff --git a/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/__init__.py b/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/__init__.py index 77b0df28d3c0..9b98a0a107d8 100644 --- a/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/__init__.py +++ b/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/__init__.py @@ -7,15 +7,10 @@ # -------------------------------------------------------------------------- from ._azure_communication_sms_service import AzureCommunicationSMSService +__all__ = ['AzureCommunicationSMSService'] try: - from ._patch import __all__ as _patch_all - from ._patch import * # type: ignore # pylint: disable=unused-wildcard-import + from ._patch import patch_sdk # type: ignore + patch_sdk() except ImportError: - _patch_all = [] -from ._patch import patch_sdk as _patch_sdk - -__all__ = ["AzureCommunicationSMSService"] -__all__.extend([p for p in _patch_all if p not in __all__]) - -_patch_sdk() + pass diff --git a/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/_azure_communication_sms_service.py b/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/_azure_communication_sms_service.py index 2bd018ac2c23..0fee0dbd6f58 100644 --- a/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/_azure_communication_sms_service.py +++ b/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/_azure_communication_sms_service.py @@ -6,69 +6,66 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from copy import deepcopy -from typing import Any +from typing import TYPE_CHECKING from azure.core import PipelineClient -from azure.core.rest import HttpRequest, HttpResponse +from msrest import Deserializer, Serializer + +if TYPE_CHECKING: + # pylint: disable=unused-import,ungrouped-imports + from typing import Any + + from azure.core.pipeline.transport import HttpRequest, HttpResponse -from . import models from ._configuration import AzureCommunicationSMSServiceConfiguration -from ._serialization import Deserializer, Serializer from .operations import SmsOperations +from . import models -class AzureCommunicationSMSService: # pylint: disable=client-accepts-api-version-keyword +class AzureCommunicationSMSService(object): """Azure Communication SMS Service. :ivar sms: SmsOperations operations :vartype sms: azure.communication.sms.operations.SmsOperations - :param endpoint: The communication resource, for example - https://my-resource.communication.azure.com. Required. + :param endpoint: The communication resource, for example https://my-resource.communication.azure.com. :type endpoint: str - :keyword api_version: Api Version. Default value is "2021-03-07". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str """ - def __init__( # pylint: disable=missing-client-constructor-parameter-credential - self, endpoint: str, **kwargs: Any - ) -> None: - _endpoint = "{endpoint}" - self._config = AzureCommunicationSMSServiceConfiguration(endpoint=endpoint, **kwargs) - self._client = PipelineClient(base_url=_endpoint, config=self._config, **kwargs) + def __init__( + self, + endpoint, # type: str + **kwargs # type: Any + ): + # type: (...) -> None + base_url = '{endpoint}' + self._config = AzureCommunicationSMSServiceConfiguration(endpoint, **kwargs) + self._client = PipelineClient(base_url=base_url, config=self._config, **kwargs) client_models = {k: v for k, v in models.__dict__.items() if isinstance(v, type)} self._serialize = Serializer(client_models) - self._deserialize = Deserializer(client_models) self._serialize.client_side_validation = False - self.sms = SmsOperations(self._client, self._config, self._serialize, self._deserialize) - - def _send_request(self, request: HttpRequest, **kwargs: Any) -> HttpResponse: - """Runs the network request through the client's chained policies. + self._deserialize = Deserializer(client_models) - >>> from azure.core.rest import HttpRequest - >>> request = HttpRequest("GET", "https://www.example.org/") - - >>> response = client._send_request(request) - + self.sms = SmsOperations( + self._client, self._config, self._serialize, self._deserialize) - For more information on this code flow, see https://aka.ms/azsdk/dpcodegen/python/send_request + def _send_request(self, http_request, **kwargs): + # type: (HttpRequest, Any) -> HttpResponse + """Runs the network request through the client's chained policies. - :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. + :param http_request: The network request you want to make. Required. + :type http_request: ~azure.core.pipeline.transport.HttpRequest + :keyword bool stream: Whether the response payload will be streamed. Defaults to True. :return: The response of your network call. Does not do error handling on your response. - :rtype: ~azure.core.rest.HttpResponse + :rtype: ~azure.core.pipeline.transport.HttpResponse """ - - request_copy = deepcopy(request) path_format_arguments = { - "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), + 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), } - - request_copy.url = self._client.format_url(request_copy.url, **path_format_arguments) - return self._client.send_request(request_copy, **kwargs) + http_request.url = self._client.format_url(http_request.url, **path_format_arguments) + stream = kwargs.pop("stream", True) + pipeline_response = self._client._pipeline.run(http_request, stream=stream, **kwargs) + return pipeline_response.http_response def close(self): # type: () -> None diff --git a/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/_configuration.py b/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/_configuration.py index 58cd247d5df5..9d3154a1fa3b 100644 --- a/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/_configuration.py +++ b/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/_configuration.py @@ -6,50 +6,53 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any +from typing import TYPE_CHECKING from azure.core.configuration import Configuration from azure.core.pipeline import policies -VERSION = "unknown" +if TYPE_CHECKING: + # pylint: disable=unused-import,ungrouped-imports + from typing import Any +VERSION = "unknown" -class AzureCommunicationSMSServiceConfiguration(Configuration): # pylint: disable=too-many-instance-attributes +class AzureCommunicationSMSServiceConfiguration(Configuration): """Configuration for AzureCommunicationSMSService. Note that all parameters used to create this instance are saved as instance attributes. - :param endpoint: The communication resource, for example - https://my-resource.communication.azure.com. Required. + :param endpoint: The communication resource, for example https://my-resource.communication.azure.com. :type endpoint: str - :keyword api_version: Api Version. Default value is "2021-03-07". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str """ - def __init__(self, endpoint: str, **kwargs: Any) -> None: - super(AzureCommunicationSMSServiceConfiguration, self).__init__(**kwargs) - api_version = kwargs.pop("api_version", "2021-03-07") # type: str - + def __init__( + self, + endpoint, # type: str + **kwargs # type: Any + ): + # type: (...) -> None if endpoint is None: raise ValueError("Parameter 'endpoint' must not be None.") + super(AzureCommunicationSMSServiceConfiguration, self).__init__(**kwargs) self.endpoint = endpoint - self.api_version = api_version - kwargs.setdefault("sdk_moniker", "azurecommunicationsmsservice/{}".format(VERSION)) + self.api_version = "2021-03-07" + kwargs.setdefault('sdk_moniker', 'azurecommunicationsmsservice/{}'.format(VERSION)) self._configure(**kwargs) def _configure( - self, **kwargs # type: Any + self, + **kwargs # type: Any ): # type: (...) -> None - 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 policies.HttpLoggingPolicy(**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") + 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 policies.HttpLoggingPolicy(**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') diff --git a/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/aio/__init__.py b/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/aio/__init__.py index 77b0df28d3c0..1149dd8315fb 100644 --- a/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/aio/__init__.py +++ b/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/aio/__init__.py @@ -7,15 +7,4 @@ # -------------------------------------------------------------------------- from ._azure_communication_sms_service import AzureCommunicationSMSService - -try: - from ._patch import __all__ as _patch_all - from ._patch import * # type: ignore # pylint: disable=unused-wildcard-import -except ImportError: - _patch_all = [] -from ._patch import patch_sdk as _patch_sdk - -__all__ = ["AzureCommunicationSMSService"] -__all__.extend([p for p in _patch_all if p not in __all__]) - -_patch_sdk() +__all__ = ['AzureCommunicationSMSService'] diff --git a/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/aio/_azure_communication_sms_service.py b/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/aio/_azure_communication_sms_service.py index 0866e920e7ec..9df4a63dd70e 100644 --- a/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/aio/_azure_communication_sms_service.py +++ b/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/aio/_azure_communication_sms_service.py @@ -6,69 +6,59 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from copy import deepcopy -from typing import Any, Awaitable +from typing import Any from azure.core import AsyncPipelineClient -from azure.core.rest import AsyncHttpResponse, HttpRequest +from azure.core.pipeline.transport import AsyncHttpResponse, HttpRequest +from msrest import Deserializer, Serializer -from .. import models -from .._serialization import Deserializer, Serializer from ._configuration import AzureCommunicationSMSServiceConfiguration from .operations import SmsOperations +from .. import models -class AzureCommunicationSMSService: # pylint: disable=client-accepts-api-version-keyword +class AzureCommunicationSMSService(object): """Azure Communication SMS Service. :ivar sms: SmsOperations operations :vartype sms: azure.communication.sms.aio.operations.SmsOperations - :param endpoint: The communication resource, for example - https://my-resource.communication.azure.com. Required. + :param endpoint: The communication resource, for example https://my-resource.communication.azure.com. :type endpoint: str - :keyword api_version: Api Version. Default value is "2021-03-07". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str """ - def __init__( # pylint: disable=missing-client-constructor-parameter-credential - self, endpoint: str, **kwargs: Any + def __init__( + self, + endpoint: str, + **kwargs: Any ) -> None: - _endpoint = "{endpoint}" - self._config = AzureCommunicationSMSServiceConfiguration(endpoint=endpoint, **kwargs) - self._client = AsyncPipelineClient(base_url=_endpoint, config=self._config, **kwargs) + base_url = '{endpoint}' + self._config = AzureCommunicationSMSServiceConfiguration(endpoint, **kwargs) + self._client = AsyncPipelineClient(base_url=base_url, config=self._config, **kwargs) client_models = {k: v for k, v in models.__dict__.items() if isinstance(v, type)} self._serialize = Serializer(client_models) - self._deserialize = Deserializer(client_models) self._serialize.client_side_validation = False - self.sms = SmsOperations(self._client, self._config, self._serialize, self._deserialize) - - def _send_request(self, request: HttpRequest, **kwargs: Any) -> Awaitable[AsyncHttpResponse]: - """Runs the network request through the client's chained policies. + self._deserialize = Deserializer(client_models) - >>> from azure.core.rest import HttpRequest - >>> request = HttpRequest("GET", "https://www.example.org/") - - >>> response = await client._send_request(request) - + self.sms = SmsOperations( + self._client, self._config, self._serialize, self._deserialize) - For more information on this code flow, see https://aka.ms/azsdk/dpcodegen/python/send_request + async def _send_request(self, http_request: HttpRequest, **kwargs: Any) -> AsyncHttpResponse: + """Runs the network request through the client's chained policies. - :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. + :param http_request: The network request you want to make. Required. + :type http_request: ~azure.core.pipeline.transport.HttpRequest + :keyword bool stream: Whether the response payload will be streamed. Defaults to True. :return: The response of your network call. Does not do error handling on your response. - :rtype: ~azure.core.rest.AsyncHttpResponse + :rtype: ~azure.core.pipeline.transport.AsyncHttpResponse """ - - request_copy = deepcopy(request) path_format_arguments = { - "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), + 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), } - - request_copy.url = self._client.format_url(request_copy.url, **path_format_arguments) - return self._client.send_request(request_copy, **kwargs) + http_request.url = self._client.format_url(http_request.url, **path_format_arguments) + stream = kwargs.pop("stream", True) + pipeline_response = await self._client._pipeline.run(http_request, stream=stream, **kwargs) + return pipeline_response.http_response async def close(self) -> None: await self._client.close() diff --git a/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/aio/_configuration.py b/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/aio/_configuration.py index 5a8070bc430a..77033099353f 100644 --- a/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/aio/_configuration.py +++ b/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/aio/_configuration.py @@ -13,40 +13,40 @@ VERSION = "unknown" - -class AzureCommunicationSMSServiceConfiguration(Configuration): # pylint: disable=too-many-instance-attributes +class AzureCommunicationSMSServiceConfiguration(Configuration): """Configuration for AzureCommunicationSMSService. Note that all parameters used to create this instance are saved as instance attributes. - :param endpoint: The communication resource, for example - https://my-resource.communication.azure.com. Required. + :param endpoint: The communication resource, for example https://my-resource.communication.azure.com. :type endpoint: str - :keyword api_version: Api Version. Default value is "2021-03-07". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str """ - def __init__(self, endpoint: str, **kwargs: Any) -> None: - super(AzureCommunicationSMSServiceConfiguration, self).__init__(**kwargs) - api_version = kwargs.pop("api_version", "2021-03-07") # type: str - + def __init__( + self, + endpoint: str, + **kwargs: Any + ) -> None: if endpoint is None: raise ValueError("Parameter 'endpoint' must not be None.") + super(AzureCommunicationSMSServiceConfiguration, self).__init__(**kwargs) self.endpoint = endpoint - self.api_version = api_version - kwargs.setdefault("sdk_moniker", "azurecommunicationsmsservice/{}".format(VERSION)) + self.api_version = "2021-03-07" + kwargs.setdefault('sdk_moniker', 'azurecommunicationsmsservice/{}'.format(VERSION)) self._configure(**kwargs) - def _configure(self, **kwargs: Any) -> None: - 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 policies.HttpLoggingPolicy(**kwargs) - self.retry_policy = kwargs.get("retry_policy") or policies.AsyncRetryPolicy(**kwargs) - self.custom_hook_policy = kwargs.get("custom_hook_policy") or policies.CustomHookPolicy(**kwargs) - self.redirect_policy = kwargs.get("redirect_policy") or policies.AsyncRedirectPolicy(**kwargs) - self.authentication_policy = kwargs.get("authentication_policy") + def _configure( + self, + **kwargs: Any + ) -> None: + 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 policies.HttpLoggingPolicy(**kwargs) + self.retry_policy = kwargs.get('retry_policy') or policies.AsyncRetryPolicy(**kwargs) + self.custom_hook_policy = kwargs.get('custom_hook_policy') or policies.CustomHookPolicy(**kwargs) + self.redirect_policy = kwargs.get('redirect_policy') or policies.AsyncRedirectPolicy(**kwargs) + self.authentication_policy = kwargs.get('authentication_policy') diff --git a/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/aio/operations/__init__.py b/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/aio/operations/__init__.py index 96d0f1292ecb..f9ce203e2885 100644 --- a/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/aio/operations/__init__.py +++ b/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/aio/operations/__init__.py @@ -8,12 +8,6 @@ from ._sms_operations import SmsOperations -from ._patch import __all__ as _patch_all -from ._patch import * # type: ignore # pylint: disable=unused-wildcard-import -from ._patch import patch_sdk as _patch_sdk - __all__ = [ - "SmsOperations", + 'SmsOperations', ] -__all__.extend([p for p in _patch_all if p not in __all__]) -_patch_sdk() diff --git a/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/aio/operations/_sms_operations.py b/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/aio/operations/_sms_operations.py index 5bafac3025b9..7ec83da71f2e 100644 --- a/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/aio/operations/_sms_operations.py +++ b/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/aio/operations/_sms_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -6,159 +5,96 @@ # 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, Callable, Dict, IO, Optional, TypeVar, Union, overload - -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) +from typing import Any, Callable, Dict, Generic, Optional, TypeVar +import warnings + +from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error from azure.core.pipeline import PipelineResponse -from azure.core.pipeline.transport import AsyncHttpResponse -from azure.core.rest import HttpRequest -from azure.core.tracing.decorator_async import distributed_trace_async -from azure.core.utils import case_insensitive_dict +from azure.core.pipeline.transport import AsyncHttpResponse, HttpRequest from ... import models as _models -from ..._vendor import _convert_request -from ...operations._sms_operations import build_send_request -T = TypeVar("T") +T = TypeVar('T') ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] - class SmsOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. + """SmsOperations async operations. + + You should not instantiate this class directly. Instead, you should create a Client instance that + instantiates it for you and attaches it as an attribute. - Instead, you should access the following operations through - :class:`~azure.communication.sms.aio.AzureCommunicationSMSService`'s - :attr:`sms` attribute. + :ivar models: Alias to model classes used in this operation group. + :type models: ~azure.communication.sms.models + :param client: Client for service requests. + :param config: Configuration of service client. + :param serializer: An object model serializer. + :param deserializer: An object model deserializer. """ models = _models - def __init__(self, *args, **kwargs) -> None: - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") + def __init__(self, client, config, serializer, deserializer) -> None: + self._client = client + self._serialize = serializer + self._deserialize = deserializer + self._config = config - @overload async def send( - self, send_message_request: _models.SendMessageRequest, *, content_type: str = "application/json", **kwargs: Any - ) -> _models.SmsSendResponse: + self, + send_message_request: "_models.SendMessageRequest", + **kwargs: Any + ) -> "_models.SmsSendResponse": """Sends a SMS message from a phone number that belongs to the authenticated account. Sends a SMS message from a phone number that belongs to the authenticated account. - :param send_message_request: Represents the body of the send message request. Required. + :param send_message_request: Represents the body of the send message request. :type send_message_request: ~azure.communication.sms.models.SendMessageRequest - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :keyword callable cls: A custom type or function that will be passed the direct response - :return: SmsSendResponse or the result of cls(response) - :rtype: ~azure.communication.sms.models.SmsSendResponse - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def send( - self, send_message_request: IO, *, content_type: str = "application/json", **kwargs: Any - ) -> _models.SmsSendResponse: - """Sends a SMS message from a phone number that belongs to the authenticated account. - - Sends a SMS message from a phone number that belongs to the authenticated account. - - :param send_message_request: Represents the body of the send message request. Required. - :type send_message_request: IO - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: SmsSendResponse or the result of cls(response) + :return: SmsSendResponse, or the result of cls(response) :rtype: ~azure.communication.sms.models.SmsSendResponse - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace_async - async def send( - self, send_message_request: Union[_models.SendMessageRequest, IO], **kwargs: Any - ) -> _models.SmsSendResponse: - """Sends a SMS message from a phone number that belongs to the authenticated account. - - Sends a SMS message from a phone number that belongs to the authenticated account. - - :param send_message_request: Represents the body of the send message request. Is either a model - type or a IO type. Required. - :type send_message_request: ~azure.communication.sms.models.SendMessageRequest or IO - :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. - Default value is None. - :paramtype content_type: str - :keyword callable cls: A custom type or function that will be passed the direct response - :return: SmsSendResponse or the result of cls(response) - :rtype: ~azure.communication.sms.models.SmsSendResponse - :raises ~azure.core.exceptions.HttpResponseError: + :raises: ~azure.core.exceptions.HttpResponseError """ + cls = kwargs.pop('cls', None) # type: ClsType["_models.SmsSendResponse"] error_map = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, + 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.SmsSendResponse] - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(send_message_request, (IO, bytes)): - _content = send_message_request - else: - _json = self._serialize.body(send_message_request, "SendMessageRequest") - - request = build_send_request( - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - template_url=self.send.metadata["url"], - headers=_headers, - params=_params, - ) - request = _convert_request(request) + error_map.update(kwargs.pop('error_map', {})) + api_version = "2021-03-07" + content_type = kwargs.pop("content_type", "application/json") + accept = "application/json" + + # Construct URL + url = self.send.metadata['url'] # type: ignore path_format_arguments = { - "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), + 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), } - request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore - - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs - ) - + url = self._client.format_url(url, **path_format_arguments) + + # Construct parameters + query_parameters = {} # type: Dict[str, Any] + query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') + + # Construct headers + header_parameters = {} # type: Dict[str, Any] + header_parameters['Content-Type'] = self._serialize.header("content_type", content_type, 'str') + header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') + + body_content_kwargs = {} # type: Dict[str, Any] + body_content = self._serialize.body(send_message_request, 'SendMessageRequest') + body_content_kwargs['content'] = body_content + request = self._client.post(url, query_parameters, header_parameters, **body_content_kwargs) + pipeline_response = await self._client._pipeline.run(request, stream=False, **kwargs) response = pipeline_response.http_response if response.status_code not in [202]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response) - deserialized = self._deserialize("SmsSendResponse", pipeline_response) + deserialized = self._deserialize('SmsSendResponse', pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - - send.metadata = {"url": "/sms"} # type: ignore + send.metadata = {'url': '/sms'} # type: ignore diff --git a/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/models/__init__.py b/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/models/__init__.py index c1a416fd6af8..74b2447dbed0 100644 --- a/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/models/__init__.py +++ b/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/models/__init__.py @@ -6,24 +6,28 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from ._models_py3 import SendMessageRequest -from ._models_py3 import SmsRecipient -from ._models_py3 import SmsSendOptions -from ._models_py3 import SmsSendResponse -from ._models_py3 import SmsSendResponseItem +try: + from ._models_py3 import SendMessageRequest + from ._models_py3 import SmsRecipient + from ._models_py3 import SmsSendOptions + from ._models_py3 import SmsSendResponse + from ._models_py3 import SmsSendResponseItem +except (SyntaxError, ImportError): + from ._models import SendMessageRequest # type: ignore + from ._models import SmsRecipient # type: ignore + from ._models import SmsSendOptions # type: ignore + from ._models import SmsSendResponse # type: ignore + from ._models import SmsSendResponseItem # type: ignore -from ._azure_communication_sms_service_enums import SmsSendResponseItemRepeatabilityResult -from ._patch import __all__ as _patch_all -from ._patch import * # type: ignore # pylint: disable=unused-wildcard-import -from ._patch import patch_sdk as _patch_sdk +from ._azure_communication_sms_service_enums import ( + SmsSendResponseItemRepeatabilityResult, +) __all__ = [ - "SendMessageRequest", - "SmsRecipient", - "SmsSendOptions", - "SmsSendResponse", - "SmsSendResponseItem", - "SmsSendResponseItemRepeatabilityResult", + 'SendMessageRequest', + 'SmsRecipient', + 'SmsSendOptions', + 'SmsSendResponse', + 'SmsSendResponseItem', + 'SmsSendResponseItemRepeatabilityResult', ] -__all__.extend([p for p in _patch_all if p not in __all__]) -_patch_sdk() diff --git a/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/models/_azure_communication_sms_service_enums.py b/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/models/_azure_communication_sms_service_enums.py index eea2580b1f0b..635ce86194d5 100644 --- a/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/models/_azure_communication_sms_service_enums.py +++ b/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/models/_azure_communication_sms_service_enums.py @@ -6,11 +6,27 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from enum import Enum -from azure.core import CaseInsensitiveEnumMeta +from enum import Enum, EnumMeta +from six import with_metaclass +class _CaseInsensitiveEnumMeta(EnumMeta): + def __getitem__(self, name): + return super().__getitem__(name.upper()) -class SmsSendResponseItemRepeatabilityResult(str, Enum, metaclass=CaseInsensitiveEnumMeta): + def __getattr__(cls, name): + """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. + """ + try: + return cls._member_map_[name.upper()] + except KeyError: + raise AttributeError(name) + + +class SmsSendResponseItemRepeatabilityResult(with_metaclass(_CaseInsensitiveEnumMeta, str, Enum)): """The result of a repeatable request with one of the case-insensitive values accepted or rejected. """ diff --git a/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/models/_models.py b/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/models/_models.py new file mode 100644 index 000000000000..3dd8dab3bef2 --- /dev/null +++ b/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/models/_models.py @@ -0,0 +1,197 @@ +# 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. +# -------------------------------------------------------------------------- + +import msrest.serialization + + +class SendMessageRequest(msrest.serialization.Model): + """Represents the properties of a send message request. + + All required parameters must be populated in order to send to Azure. + + :param from_property: Required. The sender's phone number in E.164 format that is owned by the + authenticated account. + :type from_property: str + :param sms_recipients: Required. The recipient's phone number in E.164 format. In this version, + a minimum of 1 and upto 100 recipients in the list are supported. + :type sms_recipients: list[~azure.communication.sms.models.SmsRecipient] + :param message: Required. The contents of the message that will be sent to the recipient. The + allowable content is defined by RFC 5724. + :type message: str + :param sms_send_options: Optional configuration for sending SMS messages. + :type sms_send_options: ~azure.communication.sms.models.SmsSendOptions + """ + + _validation = { + 'from_property': {'required': True}, + 'sms_recipients': {'required': True}, + 'message': {'required': True, 'max_length': 2048, 'min_length': 0}, + } + + _attribute_map = { + 'from_property': {'key': 'from', 'type': 'str'}, + 'sms_recipients': {'key': 'smsRecipients', 'type': '[SmsRecipient]'}, + 'message': {'key': 'message', 'type': 'str'}, + 'sms_send_options': {'key': 'smsSendOptions', 'type': 'SmsSendOptions'}, + } + + def __init__( + self, + **kwargs + ): + super(SendMessageRequest, self).__init__(**kwargs) + self.from_property = kwargs['from_property'] + self.sms_recipients = kwargs['sms_recipients'] + self.message = kwargs['message'] + self.sms_send_options = kwargs.get('sms_send_options', None) + + +class SmsRecipient(msrest.serialization.Model): + """Recipient details for sending SMS messages. + + All required parameters must be populated in order to send to Azure. + + :param to: Required. The recipient's phone number in E.164 format. + :type to: str + :param repeatability_request_id: If specified, the client directs that the request is + repeatable; that is, the client can make the request multiple times with the same + Repeatability-Request-ID and get back an appropriate response without the server executing the + request multiple times. The value of the Repeatability-Request-ID is an opaque string + representing a client-generated, 36-character hexadecimal case-insensitive encoding of a UUID + (GUID), identifier for the request. + :type repeatability_request_id: str + :param repeatability_first_sent: MUST be sent by clients to specify that a request is + repeatable. Repeatability-First-Sent is used to specify the date and time at which the request + was first created.eg- Tue, 26 Mar 2019 16:06:51 GMT. + :type repeatability_first_sent: str + """ + + _validation = { + 'to': {'required': True}, + } + + _attribute_map = { + 'to': {'key': 'to', 'type': 'str'}, + 'repeatability_request_id': {'key': 'repeatabilityRequestId', 'type': 'str'}, + 'repeatability_first_sent': {'key': 'repeatabilityFirstSent', 'type': 'str'}, + } + + def __init__( + self, + **kwargs + ): + super(SmsRecipient, self).__init__(**kwargs) + self.to = kwargs['to'] + self.repeatability_request_id = kwargs.get('repeatability_request_id', None) + self.repeatability_first_sent = kwargs.get('repeatability_first_sent', None) + + +class SmsSendOptions(msrest.serialization.Model): + """Optional configuration for sending SMS messages. + + All required parameters must be populated in order to send to Azure. + + :param enable_delivery_report: Required. Enable this flag to receive a delivery report for this + message on the Azure Resource EventGrid. + :type enable_delivery_report: bool + :param tag: Use this field to provide metadata that will then be sent back in the corresponding + Delivery Report. + :type tag: str + """ + + _validation = { + 'enable_delivery_report': {'required': True}, + } + + _attribute_map = { + 'enable_delivery_report': {'key': 'enableDeliveryReport', 'type': 'bool'}, + 'tag': {'key': 'tag', 'type': 'str'}, + } + + def __init__( + self, + **kwargs + ): + super(SmsSendOptions, self).__init__(**kwargs) + self.enable_delivery_report = kwargs['enable_delivery_report'] + self.tag = kwargs.get('tag', None) + + +class SmsSendResponse(msrest.serialization.Model): + """Response for a successful or multi status send Sms request. + + All required parameters must be populated in order to send to Azure. + + :param value: Required. + :type value: list[~azure.communication.sms.models.SmsSendResponseItem] + """ + + _validation = { + 'value': {'required': True}, + } + + _attribute_map = { + 'value': {'key': 'value', 'type': '[SmsSendResponseItem]'}, + } + + def __init__( + self, + **kwargs + ): + super(SmsSendResponse, self).__init__(**kwargs) + self.value = kwargs['value'] + + +class SmsSendResponseItem(msrest.serialization.Model): + """Response for a single recipient. + + All required parameters must be populated in order to send to Azure. + + :param to: Required. The recipient's phone number in E.164 format. + :type to: str + :param message_id: The identifier of the outgoing Sms message. Only present if message + processed. + :type message_id: str + :param http_status_code: Required. HTTP Status code. + :type http_status_code: int + :param repeatability_result: The result of a repeatable request with one of the + case-insensitive values accepted or rejected. Possible values include: "accepted", "rejected". + :type repeatability_result: str or + ~azure.communication.sms.models.SmsSendResponseItemRepeatabilityResult + :param successful: Required. Indicates if the message is processed successfully or not. + :type successful: bool + :param error_message: Optional error message in case of 4xx/5xx/repeatable errors. + :type error_message: str + """ + + _validation = { + 'to': {'required': True}, + 'http_status_code': {'required': True}, + 'successful': {'required': True}, + } + + _attribute_map = { + 'to': {'key': 'to', 'type': 'str'}, + 'message_id': {'key': 'messageId', 'type': 'str'}, + 'http_status_code': {'key': 'httpStatusCode', 'type': 'int'}, + 'repeatability_result': {'key': 'repeatabilityResult', 'type': 'str'}, + 'successful': {'key': 'successful', 'type': 'bool'}, + 'error_message': {'key': 'errorMessage', 'type': 'str'}, + } + + def __init__( + self, + **kwargs + ): + super(SmsSendResponseItem, self).__init__(**kwargs) + self.to = kwargs['to'] + self.message_id = kwargs.get('message_id', None) + self.http_status_code = kwargs['http_status_code'] + self.repeatability_result = kwargs.get('repeatability_result', None) + self.successful = kwargs['successful'] + self.error_message = kwargs.get('error_message', None) diff --git a/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/models/_models_py3.py b/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/models/_models_py3.py index 2dff456ae996..7934352a7708 100644 --- a/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/models/_models_py3.py +++ b/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/models/_models_py3.py @@ -1,5 +1,4 @@ # coding=utf-8 -# pylint: disable=too-many-lines # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for license information. @@ -7,103 +6,88 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import List, Optional, TYPE_CHECKING, Union +from typing import List, Optional, Union -from .. import _serialization +import msrest.serialization -if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports - from .. import models as _models +from ._azure_communication_sms_service_enums import * -class SendMessageRequest(_serialization.Model): +class SendMessageRequest(msrest.serialization.Model): """Represents the properties of a send message request. All required parameters must be populated in order to send to Azure. - :ivar from_property: The sender's phone number in E.164 format that is owned by the - authenticated account. Required. - :vartype from_property: str - :ivar sms_recipients: The recipient's phone number in E.164 format. In this version, a minimum - of 1 and upto 100 recipients in the list are supported. Required. - :vartype sms_recipients: list[~azure.communication.sms.models.SmsRecipient] - :ivar message: The contents of the message that will be sent to the recipient. The allowable - content is defined by RFC 5724. Required. - :vartype message: str - :ivar sms_send_options: Optional configuration for sending SMS messages. - :vartype sms_send_options: ~azure.communication.sms.models.SmsSendOptions + :param from_property: Required. The sender's phone number in E.164 format that is owned by the + authenticated account. + :type from_property: str + :param sms_recipients: Required. The recipient's phone number in E.164 format. In this version, + a minimum of 1 and upto 100 recipients in the list are supported. + :type sms_recipients: list[~azure.communication.sms.models.SmsRecipient] + :param message: Required. The contents of the message that will be sent to the recipient. The + allowable content is defined by RFC 5724. + :type message: str + :param sms_send_options: Optional configuration for sending SMS messages. + :type sms_send_options: ~azure.communication.sms.models.SmsSendOptions """ _validation = { - "from_property": {"required": True}, - "sms_recipients": {"required": True}, - "message": {"required": True, "max_length": 2048}, + 'from_property': {'required': True}, + 'sms_recipients': {'required': True}, + 'message': {'required': True, 'max_length': 2048, 'min_length': 0}, } _attribute_map = { - "from_property": {"key": "from", "type": "str"}, - "sms_recipients": {"key": "smsRecipients", "type": "[SmsRecipient]"}, - "message": {"key": "message", "type": "str"}, - "sms_send_options": {"key": "smsSendOptions", "type": "SmsSendOptions"}, + 'from_property': {'key': 'from', 'type': 'str'}, + 'sms_recipients': {'key': 'smsRecipients', 'type': '[SmsRecipient]'}, + 'message': {'key': 'message', 'type': 'str'}, + 'sms_send_options': {'key': 'smsSendOptions', 'type': 'SmsSendOptions'}, } def __init__( self, *, from_property: str, - sms_recipients: List["_models.SmsRecipient"], + sms_recipients: List["SmsRecipient"], message: str, - sms_send_options: Optional["_models.SmsSendOptions"] = None, + sms_send_options: Optional["SmsSendOptions"] = None, **kwargs ): - """ - :keyword from_property: The sender's phone number in E.164 format that is owned by the - authenticated account. Required. - :paramtype from_property: str - :keyword sms_recipients: The recipient's phone number in E.164 format. In this version, a - minimum of 1 and upto 100 recipients in the list are supported. Required. - :paramtype sms_recipients: list[~azure.communication.sms.models.SmsRecipient] - :keyword message: The contents of the message that will be sent to the recipient. The allowable - content is defined by RFC 5724. Required. - :paramtype message: str - :keyword sms_send_options: Optional configuration for sending SMS messages. - :paramtype sms_send_options: ~azure.communication.sms.models.SmsSendOptions - """ - super().__init__(**kwargs) + super(SendMessageRequest, self).__init__(**kwargs) self.from_property = from_property self.sms_recipients = sms_recipients self.message = message self.sms_send_options = sms_send_options -class SmsRecipient(_serialization.Model): +class SmsRecipient(msrest.serialization.Model): """Recipient details for sending SMS messages. All required parameters must be populated in order to send to Azure. - :ivar to: The recipient's phone number in E.164 format. Required. - :vartype to: str - :ivar repeatability_request_id: If specified, the client directs that the request is + :param to: Required. The recipient's phone number in E.164 format. + :type to: str + :param repeatability_request_id: If specified, the client directs that the request is repeatable; that is, the client can make the request multiple times with the same Repeatability-Request-ID and get back an appropriate response without the server executing the request multiple times. The value of the Repeatability-Request-ID is an opaque string representing a client-generated, 36-character hexadecimal case-insensitive encoding of a UUID (GUID), identifier for the request. - :vartype repeatability_request_id: str - :ivar repeatability_first_sent: MUST be sent by clients to specify that a request is + :type repeatability_request_id: str + :param repeatability_first_sent: MUST be sent by clients to specify that a request is repeatable. Repeatability-First-Sent is used to specify the date and time at which the request was first created.eg- Tue, 26 Mar 2019 16:06:51 GMT. - :vartype repeatability_first_sent: str + :type repeatability_first_sent: str """ _validation = { - "to": {"required": True}, + 'to': {'required': True}, } _attribute_map = { - "to": {"key": "to", "type": "str"}, - "repeatability_request_id": {"key": "repeatabilityRequestId", "type": "str"}, - "repeatability_first_sent": {"key": "repeatabilityFirstSent", "type": "str"}, + 'to': {'key': 'to', 'type': 'str'}, + 'repeatability_request_id': {'key': 'repeatabilityRequestId', 'type': 'str'}, + 'repeatability_first_sent': {'key': 'repeatabilityFirstSent', 'type': 'str'}, } def __init__( @@ -114,124 +98,108 @@ def __init__( repeatability_first_sent: Optional[str] = None, **kwargs ): - """ - :keyword to: The recipient's phone number in E.164 format. Required. - :paramtype to: str - :keyword repeatability_request_id: If specified, the client directs that the request is - repeatable; that is, the client can make the request multiple times with the same - Repeatability-Request-ID and get back an appropriate response without the server executing the - request multiple times. The value of the Repeatability-Request-ID is an opaque string - representing a client-generated, 36-character hexadecimal case-insensitive encoding of a UUID - (GUID), identifier for the request. - :paramtype repeatability_request_id: str - :keyword repeatability_first_sent: MUST be sent by clients to specify that a request is - repeatable. Repeatability-First-Sent is used to specify the date and time at which the request - was first created.eg- Tue, 26 Mar 2019 16:06:51 GMT. - :paramtype repeatability_first_sent: str - """ - super().__init__(**kwargs) + super(SmsRecipient, self).__init__(**kwargs) self.to = to self.repeatability_request_id = repeatability_request_id self.repeatability_first_sent = repeatability_first_sent -class SmsSendOptions(_serialization.Model): +class SmsSendOptions(msrest.serialization.Model): """Optional configuration for sending SMS messages. All required parameters must be populated in order to send to Azure. - :ivar enable_delivery_report: Enable this flag to receive a delivery report for this message on - the Azure Resource EventGrid. Required. - :vartype enable_delivery_report: bool - :ivar tag: Use this field to provide metadata that will then be sent back in the corresponding + :param enable_delivery_report: Required. Enable this flag to receive a delivery report for this + message on the Azure Resource EventGrid. + :type enable_delivery_report: bool + :param tag: Use this field to provide metadata that will then be sent back in the corresponding Delivery Report. - :vartype tag: str + :type tag: str """ _validation = { - "enable_delivery_report": {"required": True}, + 'enable_delivery_report': {'required': True}, } _attribute_map = { - "enable_delivery_report": {"key": "enableDeliveryReport", "type": "bool"}, - "tag": {"key": "tag", "type": "str"}, + 'enable_delivery_report': {'key': 'enableDeliveryReport', 'type': 'bool'}, + 'tag': {'key': 'tag', 'type': 'str'}, } - def __init__(self, *, enable_delivery_report: bool, tag: Optional[str] = None, **kwargs): - """ - :keyword enable_delivery_report: Enable this flag to receive a delivery report for this message - on the Azure Resource EventGrid. Required. - :paramtype enable_delivery_report: bool - :keyword tag: Use this field to provide metadata that will then be sent back in the - corresponding Delivery Report. - :paramtype tag: str - """ - super().__init__(**kwargs) + def __init__( + self, + *, + enable_delivery_report: bool, + tag: Optional[str] = None, + **kwargs + ): + super(SmsSendOptions, self).__init__(**kwargs) self.enable_delivery_report = enable_delivery_report self.tag = tag -class SmsSendResponse(_serialization.Model): +class SmsSendResponse(msrest.serialization.Model): """Response for a successful or multi status send Sms request. All required parameters must be populated in order to send to Azure. - :ivar value: Required. - :vartype value: list[~azure.communication.sms.models.SmsSendResponseItem] + :param value: Required. + :type value: list[~azure.communication.sms.models.SmsSendResponseItem] """ _validation = { - "value": {"required": True}, + 'value': {'required': True}, } _attribute_map = { - "value": {"key": "value", "type": "[SmsSendResponseItem]"}, + 'value': {'key': 'value', 'type': '[SmsSendResponseItem]'}, } - def __init__(self, *, value: List["_models.SmsSendResponseItem"], **kwargs): - """ - :keyword value: Required. - :paramtype value: list[~azure.communication.sms.models.SmsSendResponseItem] - """ - super().__init__(**kwargs) + def __init__( + self, + *, + value: List["SmsSendResponseItem"], + **kwargs + ): + super(SmsSendResponse, self).__init__(**kwargs) self.value = value -class SmsSendResponseItem(_serialization.Model): +class SmsSendResponseItem(msrest.serialization.Model): """Response for a single recipient. All required parameters must be populated in order to send to Azure. - :ivar to: The recipient's phone number in E.164 format. Required. - :vartype to: str - :ivar message_id: The identifier of the outgoing Sms message. Only present if message + :param to: Required. The recipient's phone number in E.164 format. + :type to: str + :param message_id: The identifier of the outgoing Sms message. Only present if message processed. - :vartype message_id: str - :ivar http_status_code: HTTP Status code. Required. - :vartype http_status_code: int - :ivar repeatability_result: The result of a repeatable request with one of the case-insensitive - values accepted or rejected. Known values are: "accepted" and "rejected". - :vartype repeatability_result: str or + :type message_id: str + :param http_status_code: Required. HTTP Status code. + :type http_status_code: int + :param repeatability_result: The result of a repeatable request with one of the + case-insensitive values accepted or rejected. Possible values include: "accepted", "rejected". + :type repeatability_result: str or ~azure.communication.sms.models.SmsSendResponseItemRepeatabilityResult - :ivar successful: Indicates if the message is processed successfully or not. Required. - :vartype successful: bool - :ivar error_message: Optional error message in case of 4xx/5xx/repeatable errors. - :vartype error_message: str + :param successful: Required. Indicates if the message is processed successfully or not. + :type successful: bool + :param error_message: Optional error message in case of 4xx/5xx/repeatable errors. + :type error_message: str """ _validation = { - "to": {"required": True}, - "http_status_code": {"required": True}, - "successful": {"required": True}, + 'to': {'required': True}, + 'http_status_code': {'required': True}, + 'successful': {'required': True}, } _attribute_map = { - "to": {"key": "to", "type": "str"}, - "message_id": {"key": "messageId", "type": "str"}, - "http_status_code": {"key": "httpStatusCode", "type": "int"}, - "repeatability_result": {"key": "repeatabilityResult", "type": "str"}, - "successful": {"key": "successful", "type": "bool"}, - "error_message": {"key": "errorMessage", "type": "str"}, + 'to': {'key': 'to', 'type': 'str'}, + 'message_id': {'key': 'messageId', 'type': 'str'}, + 'http_status_code': {'key': 'httpStatusCode', 'type': 'int'}, + 'repeatability_result': {'key': 'repeatabilityResult', 'type': 'str'}, + 'successful': {'key': 'successful', 'type': 'bool'}, + 'error_message': {'key': 'errorMessage', 'type': 'str'}, } def __init__( @@ -241,28 +209,11 @@ def __init__( http_status_code: int, successful: bool, message_id: Optional[str] = None, - repeatability_result: Optional[Union[str, "_models.SmsSendResponseItemRepeatabilityResult"]] = None, + repeatability_result: Optional[Union[str, "SmsSendResponseItemRepeatabilityResult"]] = None, error_message: Optional[str] = None, **kwargs ): - """ - :keyword to: The recipient's phone number in E.164 format. Required. - :paramtype to: str - :keyword message_id: The identifier of the outgoing Sms message. Only present if message - processed. - :paramtype message_id: str - :keyword http_status_code: HTTP Status code. Required. - :paramtype http_status_code: int - :keyword repeatability_result: The result of a repeatable request with one of the - case-insensitive values accepted or rejected. Known values are: "accepted" and "rejected". - :paramtype repeatability_result: str or - ~azure.communication.sms.models.SmsSendResponseItemRepeatabilityResult - :keyword successful: Indicates if the message is processed successfully or not. Required. - :paramtype successful: bool - :keyword error_message: Optional error message in case of 4xx/5xx/repeatable errors. - :paramtype error_message: str - """ - super().__init__(**kwargs) + super(SmsSendResponseItem, self).__init__(**kwargs) self.to = to self.message_id = message_id self.http_status_code = http_status_code diff --git a/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/operations/__init__.py b/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/operations/__init__.py index 96d0f1292ecb..f9ce203e2885 100644 --- a/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/operations/__init__.py +++ b/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/operations/__init__.py @@ -8,12 +8,6 @@ from ._sms_operations import SmsOperations -from ._patch import __all__ as _patch_all -from ._patch import * # type: ignore # pylint: disable=unused-wildcard-import -from ._patch import patch_sdk as _patch_sdk - __all__ = [ - "SmsOperations", + 'SmsOperations', ] -__all__.extend([p for p in _patch_all if p not in __all__]) -_patch_sdk() diff --git a/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/operations/_sms_operations.py b/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/operations/_sms_operations.py index 9248c59115e9..1f0d0640e125 100644 --- a/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/operations/_sms_operations.py +++ b/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/operations/_sms_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -6,184 +5,101 @@ # 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, Callable, Dict, IO, Optional, TypeVar, Union, overload - -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) +from typing import TYPE_CHECKING +import warnings + +from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error from azure.core.pipeline import PipelineResponse -from azure.core.pipeline.transport import HttpResponse -from azure.core.rest import HttpRequest -from azure.core.tracing.decorator import distributed_trace -from azure.core.utils import case_insensitive_dict +from azure.core.pipeline.transport import HttpRequest, HttpResponse from .. import models as _models -from .._serialization import Serializer -from .._vendor import _convert_request - -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] - -_SERIALIZER = Serializer() -_SERIALIZER.client_side_validation = False - - -def build_send_request(**kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-03-07")) # type: str - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop("template_url", "/sms") - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - # Construct headers - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") +if TYPE_CHECKING: + # pylint: disable=unused-import,ungrouped-imports + from typing import Any, Callable, Dict, Generic, Optional, TypeVar - return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs) + T = TypeVar('T') + ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] +class SmsOperations(object): + """SmsOperations operations. -class SmsOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. + You should not instantiate this class directly. Instead, you should create a Client instance that + instantiates it for you and attaches it as an attribute. - Instead, you should access the following operations through - :class:`~azure.communication.sms.AzureCommunicationSMSService`'s - :attr:`sms` attribute. + :ivar models: Alias to model classes used in this operation group. + :type models: ~azure.communication.sms.models + :param client: Client for service requests. + :param config: Configuration of service client. + :param serializer: An object model serializer. + :param deserializer: An object model deserializer. """ models = _models - def __init__(self, *args, **kwargs): - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") + def __init__(self, client, config, serializer, deserializer): + self._client = client + self._serialize = serializer + self._deserialize = deserializer + self._config = config - @overload def send( - self, send_message_request: _models.SendMessageRequest, *, content_type: str = "application/json", **kwargs: Any - ) -> _models.SmsSendResponse: + self, + send_message_request, # type: "_models.SendMessageRequest" + **kwargs # type: Any + ): + # type: (...) -> "_models.SmsSendResponse" """Sends a SMS message from a phone number that belongs to the authenticated account. Sends a SMS message from a phone number that belongs to the authenticated account. - :param send_message_request: Represents the body of the send message request. Required. + :param send_message_request: Represents the body of the send message request. :type send_message_request: ~azure.communication.sms.models.SendMessageRequest - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: SmsSendResponse or the result of cls(response) + :return: SmsSendResponse, or the result of cls(response) :rtype: ~azure.communication.sms.models.SmsSendResponse - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def send( - self, send_message_request: IO, *, content_type: str = "application/json", **kwargs: Any - ) -> _models.SmsSendResponse: - """Sends a SMS message from a phone number that belongs to the authenticated account. - - Sends a SMS message from a phone number that belongs to the authenticated account. - - :param send_message_request: Represents the body of the send message request. Required. - :type send_message_request: IO - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :keyword callable cls: A custom type or function that will be passed the direct response - :return: SmsSendResponse or the result of cls(response) - :rtype: ~azure.communication.sms.models.SmsSendResponse - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace - def send( - self, send_message_request: Union[_models.SendMessageRequest, IO], **kwargs: Any - ) -> _models.SmsSendResponse: - """Sends a SMS message from a phone number that belongs to the authenticated account. - - Sends a SMS message from a phone number that belongs to the authenticated account. - - :param send_message_request: Represents the body of the send message request. Is either a model - type or a IO type. Required. - :type send_message_request: ~azure.communication.sms.models.SendMessageRequest or IO - :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. - Default value is None. - :paramtype content_type: str - :keyword callable cls: A custom type or function that will be passed the direct response - :return: SmsSendResponse or the result of cls(response) - :rtype: ~azure.communication.sms.models.SmsSendResponse - :raises ~azure.core.exceptions.HttpResponseError: + :raises: ~azure.core.exceptions.HttpResponseError """ + cls = kwargs.pop('cls', None) # type: ClsType["_models.SmsSendResponse"] error_map = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, + 401: ClientAuthenticationError, 404: ResourceNotFoundError, 409: ResourceExistsError } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.SmsSendResponse] - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(send_message_request, (IO, bytes)): - _content = send_message_request - else: - _json = self._serialize.body(send_message_request, "SendMessageRequest") - - request = build_send_request( - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - template_url=self.send.metadata["url"], - headers=_headers, - params=_params, - ) - request = _convert_request(request) + error_map.update(kwargs.pop('error_map', {})) + api_version = "2021-03-07" + content_type = kwargs.pop("content_type", "application/json") + accept = "application/json" + + # Construct URL + url = self.send.metadata['url'] # type: ignore path_format_arguments = { - "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), + 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), } - request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore - - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs - ) - + url = self._client.format_url(url, **path_format_arguments) + + # Construct parameters + query_parameters = {} # type: Dict[str, Any] + query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') + + # Construct headers + header_parameters = {} # type: Dict[str, Any] + header_parameters['Content-Type'] = self._serialize.header("content_type", content_type, 'str') + header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') + + body_content_kwargs = {} # type: Dict[str, Any] + body_content = self._serialize.body(send_message_request, 'SendMessageRequest') + body_content_kwargs['content'] = body_content + request = self._client.post(url, query_parameters, header_parameters, **body_content_kwargs) + pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs) response = pipeline_response.http_response if response.status_code not in [202]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response) - deserialized = self._deserialize("SmsSendResponse", pipeline_response) + deserialized = self._deserialize('SmsSendResponse', pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized - - send.metadata = {"url": "/sms"} # type: ignore + send.metadata = {'url': '/sms'} # type: ignore diff --git a/sdk/communication/azure-communication-sms/azure/communication/sms/_sms_client.py b/sdk/communication/azure-communication-sms/azure/communication/sms/_sms_client.py index 559acc8fbea7..05f244208467 100644 --- a/sdk/communication/azure-communication-sms/azure/communication/sms/_sms_client.py +++ b/sdk/communication/azure-communication-sms/azure/communication/sms/_sms_client.py @@ -16,9 +16,8 @@ from ._generated._azure_communication_sms_service import AzureCommunicationSMSService from ._shared.utils import parse_connection_str, get_authentication_policy, get_current_utc_time from ._version import SDK_MONIKER -from ._api_versions import DEFAULT_VERSION -class SmsClient(object): +class SmsClient(object): # pylint: disable=client-accepts-api-version-keyword """A client to interact with the AzureCommunicationService Sms gateway. This client provides operations to send an SMS via a phone number. @@ -27,9 +26,6 @@ class SmsClient(object): The endpoint url for Azure Communication Service resource. :param TokenCredential credential: The TokenCredential we use to authenticate against the service. - :keyword api_version: Azure Communication SMS API version. - The default value is "2021-03-07". Note that overriding this default value may result in unsupported behavior. - :paramtype api_version: str """ def __init__( self, endpoint, # type: str @@ -48,11 +44,9 @@ def __init__( "invalid credential from connection string.") self._endpoint = endpoint - self._api_version = kwargs.pop("api_version", DEFAULT_VERSION) self._authentication_policy = get_authentication_policy(endpoint, credential) self._sms_service_client = AzureCommunicationSMSService( self._endpoint, - api_version=self._api_version, authentication_policy=self._authentication_policy, sdk_moniker=SDK_MONIKER, **kwargs) diff --git a/sdk/communication/azure-communication-sms/azure/communication/sms/aio/_sms_client_async.py b/sdk/communication/azure-communication-sms/azure/communication/sms/aio/_sms_client_async.py index 2987e5e051d0..1d78278fb9be 100644 --- a/sdk/communication/azure-communication-sms/azure/communication/sms/aio/_sms_client_async.py +++ b/sdk/communication/azure-communication-sms/azure/communication/sms/aio/_sms_client_async.py @@ -11,14 +11,13 @@ SmsRecipient, SmsSendOptions, ) -from .._models import SmsSendResult +from azure.communication.sms._models import SmsSendResult from .._generated.aio._azure_communication_sms_service import AzureCommunicationSMSService from .._shared.utils import parse_connection_str, get_authentication_policy, get_current_utc_time from .._version import SDK_MONIKER -from .._api_versions import DEFAULT_VERSION -class SmsClient(object): +class SmsClient(object): # pylint: disable=client-accepts-api-version-keyword """A client to interact with the AzureCommunicationService Sms gateway asynchronously. This client provides operations to send an SMS via a phone number. @@ -27,9 +26,6 @@ class SmsClient(object): The endpoint url for Azure Communication Service resource. :param AsyncTokenCredential credential: The AsyncTokenCredential we use to authenticate against the service. - :keyword api_version: Azure Communication SMS API version. - The default value is "2021-03-07". Note that overriding this default value may result in unsupported behavior. - :paramtype api_version: str """ def __init__( self, endpoint, # type: str @@ -48,12 +44,10 @@ def __init__( "invalid credential from connection string.") self._endpoint = endpoint - self._api_version = kwargs.pop("api_version", DEFAULT_VERSION) self._authentication_policy = get_authentication_policy(endpoint, credential, decode_url=True, is_async=True) self._sms_service_client = AzureCommunicationSMSService( self._endpoint, - api_version=self._api_version, authentication_policy=self._authentication_policy, sdk_moniker=SDK_MONIKER, **kwargs) From 0b3e3a5e77202bbc81bad8ab89217f8602ffa4da Mon Sep 17 00:00:00 2001 From: Olena Stoliarova Date: Mon, 17 Oct 2022 17:06:12 +0300 Subject: [PATCH 11/19] rollback changes for sms modality --- .../azure/communication/chat/_api_versions.py | 14 - .../communication/chat/_generated/_patch.py | 20 - .../chat/_generated/_serialization.py | 1970 ----------------- .../communication/chat/_generated/_vendor.py | 27 - .../chat/_generated/aio/_patch.py | 20 - .../chat/_generated/aio/operations/_patch.py | 20 - .../chat/_generated/models/_patch.py | 20 - .../chat/_generated/operations/_patch.py | 20 - 8 files changed, 2111 deletions(-) delete mode 100644 sdk/communication/azure-communication-chat/azure/communication/chat/_api_versions.py delete mode 100644 sdk/communication/azure-communication-chat/azure/communication/chat/_generated/_patch.py delete mode 100644 sdk/communication/azure-communication-chat/azure/communication/chat/_generated/_serialization.py delete mode 100644 sdk/communication/azure-communication-chat/azure/communication/chat/_generated/_vendor.py delete mode 100644 sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/_patch.py delete mode 100644 sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/operations/_patch.py delete mode 100644 sdk/communication/azure-communication-chat/azure/communication/chat/_generated/models/_patch.py delete mode 100644 sdk/communication/azure-communication-chat/azure/communication/chat/_generated/operations/_patch.py diff --git a/sdk/communication/azure-communication-chat/azure/communication/chat/_api_versions.py b/sdk/communication/azure-communication-chat/azure/communication/chat/_api_versions.py deleted file mode 100644 index 707620078403..000000000000 --- a/sdk/communication/azure-communication-chat/azure/communication/chat/_api_versions.py +++ /dev/null @@ -1,14 +0,0 @@ -# ------------------------------------ -# Copyright (c) Microsoft Corporation. -# Licensed under the MIT License. -# ------------------------------------ - -from enum import Enum -from azure.core import CaseInsensitiveEnumMeta - - -class ApiVersion(str, Enum, metaclass=CaseInsensitiveEnumMeta): - V2021_09_07 = "2021-09-07" - - -DEFAULT_VERSION = ApiVersion.V2021_09_07 diff --git a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/_patch.py b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/_patch.py deleted file mode 100644 index f7dd32510333..000000000000 --- a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/_patch.py +++ /dev/null @@ -1,20 +0,0 @@ -# ------------------------------------ -# Copyright (c) Microsoft Corporation. -# Licensed under the MIT License. -# ------------------------------------ -"""Customize generated code here. - -Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize -""" -from typing import List - -__all__: List[str] = [] # Add all objects you want publicly available to users at this package level - - -def patch_sdk(): - """Do not remove from this file. - - `patch_sdk` is a last resort escape hatch that allows you to do customizations - you can't accomplish using the techniques described in - https://aka.ms/azsdk/python/dpcodegen/python/customize - """ diff --git a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/_serialization.py b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/_serialization.py deleted file mode 100644 index 7c1dedb5133d..000000000000 --- a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/_serialization.py +++ /dev/null @@ -1,1970 +0,0 @@ -# -------------------------------------------------------------------------- -# -# 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 - -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 - -try: - from urllib import quote # type: ignore -except ImportError: - from urllib.parse import quote # type: ignore -import xml.etree.ElementTree as ET - -import isodate - -from typing import Dict, Any, cast, TYPE_CHECKING - -from azure.core.exceptions import DeserializationError, SerializationError, raise_with_traceback - -_BOM = codecs.BOM_UTF8.decode(encoding="utf-8") - -if TYPE_CHECKING: - from typing import Optional, Union, AnyStr, IO, Mapping - - -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, content_type=None): - # type: (Optional[Union[AnyStr, IO]], Optional[str]) -> 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, headers): - # type: (Optional[Union[AnyStr, IO]], 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 # type: ignore - unicode_str = str # type: ignore - -_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 -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 "".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 # type: ignore -except ImportError: - TZ_UTC = UTC() # type: ignore - -_FLATTEN = re.compile(r"(? 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=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(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) - continue - if xml_desc.get("text", False): - serialized.text = new_attr - continue - if isinstance(new_attr, list): - serialized.extend(new_attr) - 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) - 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) - else: # JSON - for k in reversed(keys): - unflattened = {k: new_attr} - new_attr = unflattened - - _new_attr = new_attr - _serialized = serialized - for k in keys: - if k not in _serialized: - _serialized.update(_new_attr) - _new_attr = _new_attr[k] - _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 = data_type.strip("[]{}") - internal_data_type = self.dependencies.get(internal_data_type, 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 = [ - 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_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): - # 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) - return result - except ValueError: - for enum_value in enum_obj: - 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: - 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 = 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=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(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 - 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 - 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 deseralize. - """ - 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__ - - 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 deseralize. - :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) - 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) - 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 value 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 is empty string. - return "" - else: - # None or '', node 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): - 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)) - - @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) - attr = attr + padding - 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) - 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) - - @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): - 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): - 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) - 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() - 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) - 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 diff --git a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/_vendor.py b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/_vendor.py deleted file mode 100644 index 9aad73fc743e..000000000000 --- a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/_vendor.py +++ /dev/null @@ -1,27 +0,0 @@ -# -------------------------------------------------------------------------- -# 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 azure.core.pipeline.transport import HttpRequest - - -def _convert_request(request, files=None): - data = request.content if not files else None - request = HttpRequest(method=request.method, url=request.url, headers=request.headers, data=data) - if files: - request.set_formdata_body(files) - return request - - -def _format_url_section(template, **kwargs): - components = template.split("/") - while components: - try: - return template.format(**kwargs) - except KeyError as key: - formatted_components = template.split("/") - components = [c for c in formatted_components if "{}".format(key.args[0]) not in c] - template = "/".join(components) diff --git a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/_patch.py b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/_patch.py deleted file mode 100644 index f7dd32510333..000000000000 --- a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/_patch.py +++ /dev/null @@ -1,20 +0,0 @@ -# ------------------------------------ -# Copyright (c) Microsoft Corporation. -# Licensed under the MIT License. -# ------------------------------------ -"""Customize generated code here. - -Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize -""" -from typing import List - -__all__: List[str] = [] # Add all objects you want publicly available to users at this package level - - -def patch_sdk(): - """Do not remove from this file. - - `patch_sdk` is a last resort escape hatch that allows you to do customizations - you can't accomplish using the techniques described in - https://aka.ms/azsdk/python/dpcodegen/python/customize - """ diff --git a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/operations/_patch.py b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/operations/_patch.py deleted file mode 100644 index f7dd32510333..000000000000 --- a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/operations/_patch.py +++ /dev/null @@ -1,20 +0,0 @@ -# ------------------------------------ -# Copyright (c) Microsoft Corporation. -# Licensed under the MIT License. -# ------------------------------------ -"""Customize generated code here. - -Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize -""" -from typing import List - -__all__: List[str] = [] # Add all objects you want publicly available to users at this package level - - -def patch_sdk(): - """Do not remove from this file. - - `patch_sdk` is a last resort escape hatch that allows you to do customizations - you can't accomplish using the techniques described in - https://aka.ms/azsdk/python/dpcodegen/python/customize - """ diff --git a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/models/_patch.py b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/models/_patch.py deleted file mode 100644 index f7dd32510333..000000000000 --- a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/models/_patch.py +++ /dev/null @@ -1,20 +0,0 @@ -# ------------------------------------ -# Copyright (c) Microsoft Corporation. -# Licensed under the MIT License. -# ------------------------------------ -"""Customize generated code here. - -Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize -""" -from typing import List - -__all__: List[str] = [] # Add all objects you want publicly available to users at this package level - - -def patch_sdk(): - """Do not remove from this file. - - `patch_sdk` is a last resort escape hatch that allows you to do customizations - you can't accomplish using the techniques described in - https://aka.ms/azsdk/python/dpcodegen/python/customize - """ diff --git a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/operations/_patch.py b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/operations/_patch.py deleted file mode 100644 index f7dd32510333..000000000000 --- a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/operations/_patch.py +++ /dev/null @@ -1,20 +0,0 @@ -# ------------------------------------ -# Copyright (c) Microsoft Corporation. -# Licensed under the MIT License. -# ------------------------------------ -"""Customize generated code here. - -Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize -""" -from typing import List - -__all__: List[str] = [] # Add all objects you want publicly available to users at this package level - - -def patch_sdk(): - """Do not remove from this file. - - `patch_sdk` is a last resort escape hatch that allows you to do customizations - you can't accomplish using the techniques described in - https://aka.ms/azsdk/python/dpcodegen/python/customize - """ From 49913f3d2ab4165636e1c674915a1d9abd101b1c Mon Sep 17 00:00:00 2001 From: Olena Stoliarova Date: Mon, 17 Oct 2022 17:11:28 +0300 Subject: [PATCH 12/19] rollback changes for sms modality --- .../azure/communication/chat}/_generated/_patch.py | 0 .../chat}/_generated/_serialization.py | 0 .../communication/chat}/_generated/_vendor.py | 11 +++++++++++ .../communication/chat}/_generated/aio/_patch.py | 0 .../chat}/_generated/aio/operations/_patch.py | 0 .../chat}/_generated/models/_patch.py | 0 .../chat}/_generated/operations/_patch.py | 0 .../azure/communication/sms/_api_versions.py | 14 -------------- 8 files changed, 11 insertions(+), 14 deletions(-) rename sdk/communication/{azure-communication-sms/azure/communication/sms => azure-communication-chat/azure/communication/chat}/_generated/_patch.py (100%) rename sdk/communication/{azure-communication-sms/azure/communication/sms => azure-communication-chat/azure/communication/chat}/_generated/_serialization.py (100%) rename sdk/communication/{azure-communication-sms/azure/communication/sms => azure-communication-chat/azure/communication/chat}/_generated/_vendor.py (66%) rename sdk/communication/{azure-communication-sms/azure/communication/sms => azure-communication-chat/azure/communication/chat}/_generated/aio/_patch.py (100%) rename sdk/communication/{azure-communication-sms/azure/communication/sms => azure-communication-chat/azure/communication/chat}/_generated/aio/operations/_patch.py (100%) rename sdk/communication/{azure-communication-sms/azure/communication/sms => azure-communication-chat/azure/communication/chat}/_generated/models/_patch.py (100%) rename sdk/communication/{azure-communication-sms/azure/communication/sms => azure-communication-chat/azure/communication/chat}/_generated/operations/_patch.py (100%) delete mode 100644 sdk/communication/azure-communication-sms/azure/communication/sms/_api_versions.py diff --git a/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/_patch.py b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/_patch.py similarity index 100% rename from sdk/communication/azure-communication-sms/azure/communication/sms/_generated/_patch.py rename to sdk/communication/azure-communication-chat/azure/communication/chat/_generated/_patch.py diff --git a/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/_serialization.py b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/_serialization.py similarity index 100% rename from sdk/communication/azure-communication-sms/azure/communication/sms/_generated/_serialization.py rename to sdk/communication/azure-communication-chat/azure/communication/chat/_generated/_serialization.py diff --git a/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/_vendor.py b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/_vendor.py similarity index 66% rename from sdk/communication/azure-communication-sms/azure/communication/sms/_generated/_vendor.py rename to sdk/communication/azure-communication-chat/azure/communication/chat/_generated/_vendor.py index 0dafe0e287ff..9aad73fc743e 100644 --- a/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/_vendor.py +++ b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/_vendor.py @@ -14,3 +14,14 @@ def _convert_request(request, files=None): if files: request.set_formdata_body(files) return request + + +def _format_url_section(template, **kwargs): + components = template.split("/") + while components: + try: + return template.format(**kwargs) + except KeyError as key: + formatted_components = template.split("/") + components = [c for c in formatted_components if "{}".format(key.args[0]) not in c] + template = "/".join(components) diff --git a/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/aio/_patch.py b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/_patch.py similarity index 100% rename from sdk/communication/azure-communication-sms/azure/communication/sms/_generated/aio/_patch.py rename to sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/_patch.py diff --git a/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/aio/operations/_patch.py b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/operations/_patch.py similarity index 100% rename from sdk/communication/azure-communication-sms/azure/communication/sms/_generated/aio/operations/_patch.py rename to sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/operations/_patch.py diff --git a/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/models/_patch.py b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/models/_patch.py similarity index 100% rename from sdk/communication/azure-communication-sms/azure/communication/sms/_generated/models/_patch.py rename to sdk/communication/azure-communication-chat/azure/communication/chat/_generated/models/_patch.py diff --git a/sdk/communication/azure-communication-sms/azure/communication/sms/_generated/operations/_patch.py b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/operations/_patch.py similarity index 100% rename from sdk/communication/azure-communication-sms/azure/communication/sms/_generated/operations/_patch.py rename to sdk/communication/azure-communication-chat/azure/communication/chat/_generated/operations/_patch.py diff --git a/sdk/communication/azure-communication-sms/azure/communication/sms/_api_versions.py b/sdk/communication/azure-communication-sms/azure/communication/sms/_api_versions.py deleted file mode 100644 index ce0c5eba7d43..000000000000 --- a/sdk/communication/azure-communication-sms/azure/communication/sms/_api_versions.py +++ /dev/null @@ -1,14 +0,0 @@ -# ------------------------------------ -# Copyright (c) Microsoft Corporation. -# Licensed under the MIT License. -# ------------------------------------ - -from enum import Enum -from azure.core import CaseInsensitiveEnumMeta - - -class ApiVersion(str, Enum, metaclass=CaseInsensitiveEnumMeta): - V2021_03_07 = "2021-03-07" - - -DEFAULT_VERSION = ApiVersion.V2021_03_07 From e3d64fef93f04c0981437fbd3fbc10c2aacce97e Mon Sep 17 00:00:00 2001 From: Olena Stoliarova Date: Mon, 17 Oct 2022 17:42:27 +0300 Subject: [PATCH 13/19] add missing versions file --- .../azure-communication-chat/_api_versions.py | 14 ++++++++++++++ 1 file changed, 14 insertions(+) create mode 100644 sdk/communication/azure-communication-chat/_api_versions.py diff --git a/sdk/communication/azure-communication-chat/_api_versions.py b/sdk/communication/azure-communication-chat/_api_versions.py new file mode 100644 index 000000000000..c95b1f3c19e2 --- /dev/null +++ b/sdk/communication/azure-communication-chat/_api_versions.py @@ -0,0 +1,14 @@ +# ------------------------------------ +# Copyright (c) Microsoft Corporation. +# Licensed under the MIT License. +# ------------------------------------ + +from enum import Enum +from azure.core import CaseInsensitiveEnumMeta + + +class ApiVersion(str, Enum, metaclass=CaseInsensitiveEnumMeta): + V2021_09_07 = "2021-09-07" + + +DEFAULT_VERSION = ApiVersion.V2021_09_07 \ No newline at end of file From 4f27c292fe1cfb1d9115ef7c3cf51fcf4706ff4c Mon Sep 17 00:00:00 2001 From: Olena Stoliarova Date: Mon, 17 Oct 2022 18:32:33 +0300 Subject: [PATCH 14/19] move to correct directory --- .../{ => azure/communication/chat}/_api_versions.py | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename sdk/communication/azure-communication-chat/{ => azure/communication/chat}/_api_versions.py (100%) diff --git a/sdk/communication/azure-communication-chat/_api_versions.py b/sdk/communication/azure-communication-chat/azure/communication/chat/_api_versions.py similarity index 100% rename from sdk/communication/azure-communication-chat/_api_versions.py rename to sdk/communication/azure-communication-chat/azure/communication/chat/_api_versions.py From 559bf7e2707cf112feff7c233c5e5da2e98f463e Mon Sep 17 00:00:00 2001 From: Olena Stoliarova Date: Mon, 17 Oct 2022 20:38:36 +0300 Subject: [PATCH 15/19] fixing lint error --- .../azure/communication/chat/_api_versions.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sdk/communication/azure-communication-chat/azure/communication/chat/_api_versions.py b/sdk/communication/azure-communication-chat/azure/communication/chat/_api_versions.py index c95b1f3c19e2..707620078403 100644 --- a/sdk/communication/azure-communication-chat/azure/communication/chat/_api_versions.py +++ b/sdk/communication/azure-communication-chat/azure/communication/chat/_api_versions.py @@ -11,4 +11,4 @@ class ApiVersion(str, Enum, metaclass=CaseInsensitiveEnumMeta): V2021_09_07 = "2021-09-07" -DEFAULT_VERSION = ApiVersion.V2021_09_07 \ No newline at end of file +DEFAULT_VERSION = ApiVersion.V2021_09_07 From 31b5b8dc924e246f17f933f4e64473e076fd4e67 Mon Sep 17 00:00:00 2001 From: Olena Stoliarova Date: Thu, 20 Oct 2022 12:19:34 +0300 Subject: [PATCH 16/19] update changelogs --- sdk/communication/azure-communication-chat/CHANGELOG.md | 1 + sdk/communication/azure-communication-email/CHANGELOG.md | 1 + sdk/communication/azure-communication-identity/CHANGELOG.md | 1 + sdk/communication/azure-communication-jobrouter/CHANGELOG.md | 3 +++ .../azure-communication-networktraversal/CHANGELOG.md | 1 + .../azure-communication-phonenumbers/CHANGELOG.md | 1 + sdk/communication/azure-communication-rooms/CHANGELOG.md | 1 + 7 files changed, 9 insertions(+) diff --git a/sdk/communication/azure-communication-chat/CHANGELOG.md b/sdk/communication/azure-communication-chat/CHANGELOG.md index 3eb62acb5e87..0c15fd9df5e7 100644 --- a/sdk/communication/azure-communication-chat/CHANGELOG.md +++ b/sdk/communication/azure-communication-chat/CHANGELOG.md @@ -7,6 +7,7 @@ - `CommunicationTokenCredential` exposes a new boolean keyword argument `proactive_refresh` that defaults to `False`. If set to `True`, the refreshing of the token will be scheduled in the background ensuring continuous authentication state. - Added disposal function `close` for `CommunicationTokenCredential`. - Added `identifier_from_raw_id` and ensured that `CommunicationIdentifier.raw_id` is populated on creation. Together, these can be used to translate between a `CommunicationIdentifier` and its underlying canonical raw ID representation. Developers can now use the raw ID as an encoded format for identifiers to store in their databases or as stable keys in general. +- Added the ability specify the API version by an optional `api_version` keyword parameter. ### Breaking Changes diff --git a/sdk/communication/azure-communication-email/CHANGELOG.md b/sdk/communication/azure-communication-email/CHANGELOG.md index 9fb97430a8c5..d5eab7f5ff60 100644 --- a/sdk/communication/azure-communication-email/CHANGELOG.md +++ b/sdk/communication/azure-communication-email/CHANGELOG.md @@ -3,6 +3,7 @@ ## 1.0.0b2 (Unreleased) ### Features Added +- Added the ability specify the API version by an optional `api_version` keyword parameter. ### Breaking Changes diff --git a/sdk/communication/azure-communication-identity/CHANGELOG.md b/sdk/communication/azure-communication-identity/CHANGELOG.md index c566fe7c3912..8ce399bd2226 100644 --- a/sdk/communication/azure-communication-identity/CHANGELOG.md +++ b/sdk/communication/azure-communication-identity/CHANGELOG.md @@ -7,6 +7,7 @@ - Added support to customize the Communication Identity access token's validity period: - `create_user_and_token` and `get_token` methods in both sync and async clients can now accept keyword argument `token_expires_in: ~datetime.timedelta` that provides the ability to create a Communication Identity access token with custom expiration. - Added a new API version `ApiVersion.V2022_10_01` that is now the default API version. +- Added the ability specify the API version by an optional `api_version` keyword parameter. ## 1.2.0 (2022-08-24) diff --git a/sdk/communication/azure-communication-jobrouter/CHANGELOG.md b/sdk/communication/azure-communication-jobrouter/CHANGELOG.md index 5eff5bbdf7b8..5b9ef8a92394 100644 --- a/sdk/communication/azure-communication-jobrouter/CHANGELOG.md +++ b/sdk/communication/azure-communication-jobrouter/CHANGELOG.md @@ -2,6 +2,9 @@ ## 1.0.0b1 (Unreleased) +### Features Added +- Added the ability specify the API version by an optional `api_version` keyword parameter. + ### Added - Preview release of the package. - Add RouterClient diff --git a/sdk/communication/azure-communication-networktraversal/CHANGELOG.md b/sdk/communication/azure-communication-networktraversal/CHANGELOG.md index 32a6e3bef4a0..255028b5002b 100644 --- a/sdk/communication/azure-communication-networktraversal/CHANGELOG.md +++ b/sdk/communication/azure-communication-networktraversal/CHANGELOG.md @@ -3,6 +3,7 @@ ## 1.1.0b2 (Unreleased) ### Features Added +- Added the ability specify the API version by an optional `api_version` keyword parameter. ### Breaking Changes diff --git a/sdk/communication/azure-communication-phonenumbers/CHANGELOG.md b/sdk/communication/azure-communication-phonenumbers/CHANGELOG.md index a583b93d1219..120272633066 100644 --- a/sdk/communication/azure-communication-phonenumbers/CHANGELOG.md +++ b/sdk/communication/azure-communication-phonenumbers/CHANGELOG.md @@ -4,6 +4,7 @@ ### Features Added - Added new SIP routing client for handling Direct routing numbers. +- Added the ability specify the API version by an optional `api_version` keyword parameter. ### Other Changes Python 3.6 is no longer supported. Please use Python version 3.7 or later. For more details, please read our page on [Azure SDK for Python version support policy](https://github.com/Azure/azure-sdk-for-python/wiki/Azure-SDKs-Python-version-support-policy). diff --git a/sdk/communication/azure-communication-rooms/CHANGELOG.md b/sdk/communication/azure-communication-rooms/CHANGELOG.md index 0ff2f8d3897c..b75cc038c7b7 100644 --- a/sdk/communication/azure-communication-rooms/CHANGELOG.md +++ b/sdk/communication/azure-communication-rooms/CHANGELOG.md @@ -3,6 +3,7 @@ ## 1.0.0b3 (Unreleased) ### Features Added +- Added the ability specify the API version by an optional `api_version` keyword parameter. ### Breaking Changes From e548305fbf656a0ff611381ef0a11133f46ecbcb Mon Sep 17 00:00:00 2001 From: Olena Stoliarova Date: Mon, 24 Oct 2022 12:30:05 +0300 Subject: [PATCH 17/19] rollback chat changes --- .../azure-communication-chat/CHANGELOG.md | 1 - .../azure/communication/chat/_chat_client.py | 22 +- .../communication/chat/_chat_thread_client.py | 25 +- .../communication/chat/_generated/__init__.py | 13 +- .../_azure_communication_chat_service.py | 79 +- .../chat/_generated/_configuration.py | 58 +- .../chat/_generated/aio/__init__.py | 13 +- .../aio/_azure_communication_chat_service.py | 72 +- .../chat/_generated/aio/_configuration.py | 53 +- .../_generated/aio/operations/__init__.py | 10 +- .../aio/operations/_chat_operations.py | 408 ++-- .../aio/operations/_chat_thread_operations.py | 1710 ++++--------- .../chat/_generated/models/__init__.py | 147 +- ..._azure_communication_chat_service_enums.py | 31 +- .../chat/_generated/models/_models.py | 875 +++++++ .../chat/_generated/models/_models_py3.py | 978 ++++---- .../chat/_generated/operations/__init__.py | 10 +- .../_generated/operations/_chat_operations.py | 493 ++-- .../operations/_chat_thread_operations.py | 2121 +++++------------ .../chat/aio/_chat_client_async.py | 18 +- .../chat/aio/_chat_thread_client_async.py | 20 +- .../swagger/SWAGGER.md | 2 +- 22 files changed, 2938 insertions(+), 4221 deletions(-) create mode 100644 sdk/communication/azure-communication-chat/azure/communication/chat/_generated/models/_models.py diff --git a/sdk/communication/azure-communication-chat/CHANGELOG.md b/sdk/communication/azure-communication-chat/CHANGELOG.md index 0c15fd9df5e7..3eb62acb5e87 100644 --- a/sdk/communication/azure-communication-chat/CHANGELOG.md +++ b/sdk/communication/azure-communication-chat/CHANGELOG.md @@ -7,7 +7,6 @@ - `CommunicationTokenCredential` exposes a new boolean keyword argument `proactive_refresh` that defaults to `False`. If set to `True`, the refreshing of the token will be scheduled in the background ensuring continuous authentication state. - Added disposal function `close` for `CommunicationTokenCredential`. - Added `identifier_from_raw_id` and ensured that `CommunicationIdentifier.raw_id` is populated on creation. Together, these can be used to translate between a `CommunicationIdentifier` and its underlying canonical raw ID representation. Developers can now use the raw ID as an encoded format for identifiers to store in their databases or as stable keys in general. -- Added the ability specify the API version by an optional `api_version` keyword parameter. ### Breaking Changes diff --git a/sdk/communication/azure-communication-chat/azure/communication/chat/_chat_client.py b/sdk/communication/azure-communication-chat/azure/communication/chat/_chat_client.py index b1f54736abc9..0c334008cd71 100644 --- a/sdk/communication/azure-communication-chat/azure/communication/chat/_chat_client.py +++ b/sdk/communication/azure-communication-chat/azure/communication/chat/_chat_client.py @@ -3,15 +3,15 @@ # Licensed under the MIT License. See License.txt in the project root for # license information. # -------------------------------------------------------------------------- -from typing import TYPE_CHECKING, Union +from typing import TYPE_CHECKING from uuid import uuid4 from urllib.parse import urlparse -from azure.core.credentials import TokenCredential, AzureKeyCredential from azure.core.tracing.decorator import distributed_trace from azure.core.pipeline.policies import BearerTokenCredentialPolicy from ._chat_thread_client import ChatThreadClient +from ._shared.user_credential import CommunicationTokenCredential from ._generated import AzureCommunicationChatService from ._generated.models import CreateChatThreadRequest from ._models import ( @@ -24,16 +24,15 @@ CommunicationErrorResponseConverter ) from ._version import SDK_MONIKER -from ._api_versions import DEFAULT_VERSION if TYPE_CHECKING: # pylint: disable=unused-import,ungrouped-imports - from typing import Any, Callable, Dict, Generic, List, Optional, TypeVar + from typing import Any, Callable, Dict, Generic, List, Optional, TypeVar, Union from datetime import datetime from azure.core.paging import ItemPaged -class ChatClient(object): +class ChatClient(object): # pylint: disable=client-accepts-api-version-keyword """A client to interact with the AzureCommunicationService Chat gateway. This client provides operations to create chat thread, delete chat thread, @@ -41,12 +40,8 @@ class ChatClient(object): :param str endpoint: The endpoint of the Azure Communication resource. - :param Union[TokenCredential, AzureKeyCredential] credential: - The credential we use to authenticate against the service. - - :keyword api_version: Azure Communication Chat API version. - Default value is "2021-09-07". Note that overriding this default value may result in unsupported behavior. - :paramtype api_version: str + :param CommunicationTokenCredential credential: + The credentials with which to authenticate. .. admonition:: Example: @@ -61,7 +56,7 @@ class ChatClient(object): def __init__( self, endpoint, # type: str - credential: Union[TokenCredential, AzureKeyCredential], + credential, # type: CommunicationTokenCredential **kwargs # type: Any ): # type: (...) -> None @@ -79,13 +74,10 @@ def __init__( raise ValueError("Invalid URL: {}".format(endpoint)) self._endpoint = endpoint - self._api_version = kwargs.pop("api_version", DEFAULT_VERSION) self._credential = credential self._client = AzureCommunicationChatService( - self._credential, self._endpoint, - api_version=self._api_version, authentication_policy=BearerTokenCredentialPolicy(self._credential), sdk_moniker=SDK_MONIKER, **kwargs diff --git a/sdk/communication/azure-communication-chat/azure/communication/chat/_chat_thread_client.py b/sdk/communication/azure-communication-chat/azure/communication/chat/_chat_thread_client.py index 13c89c2938b5..0a206322b31b 100644 --- a/sdk/communication/azure-communication-chat/azure/communication/chat/_chat_thread_client.py +++ b/sdk/communication/azure-communication-chat/azure/communication/chat/_chat_thread_client.py @@ -3,14 +3,14 @@ # Licensed under the MIT License. See License.txt in the project root for # license information. # -------------------------------------------------------------------------- -from typing import TYPE_CHECKING, Union +from typing import TYPE_CHECKING from urllib.parse import urlparse -from azure.core.credentials import TokenCredential, AzureKeyCredential from azure.core.tracing.decorator import distributed_trace from azure.core.pipeline.policies import BearerTokenCredentialPolicy +from ._shared.user_credential import CommunicationTokenCredential from ._shared.models import CommunicationIdentifier from ._generated import AzureCommunicationChatService from ._generated.models import ( @@ -33,16 +33,15 @@ from ._communication_identifier_serializer import serialize_identifier from ._utils import CommunicationErrorResponseConverter from ._version import SDK_MONIKER -from ._api_versions import DEFAULT_VERSION if TYPE_CHECKING: # pylint: disable=unused-import,ungrouped-imports - from typing import Any, Callable, Dict, Generic, List, Optional, TypeVar, Tuple + from typing import Any, Callable, Dict, Generic, List, Optional, TypeVar, Union, Tuple from datetime import datetime from azure.core.paging import ItemPaged -class ChatThreadClient(object): +class ChatThreadClient(object): # pylint: disable=client-accepts-api-version-keyword """A client to interact with the AzureCommunicationService Chat gateway. Instances of this class is normally retrieved by ChatClient.get_chat_thread_client() @@ -55,15 +54,12 @@ class ChatThreadClient(object): :param str endpoint: The endpoint of the Azure Communication resource. - :param Union[TokenCredential, AzureKeyCredential] credential: - The credential we use to authenticate against the service. + :param CommunicationTokenCredential credential: + The credentials with which to authenticate. The value contains a User + Access Token :param str thread_id: The unique thread id. - :keyword api_version: Azure Communication Chat API version. - Default value is "2021-09-07". Note that overriding this default value may result in unsupported behavior. - :paramtype api_version: str - .. admonition:: Example: .. literalinclude:: ../samples/chat_thread_client_sample.py @@ -77,7 +73,7 @@ class ChatThreadClient(object): def __init__( self, endpoint, # type: str - credential: Union[TokenCredential, AzureKeyCredential], + credential, # type: CommunicationTokenCredential thread_id, # type: str **kwargs # type: Any ): @@ -100,13 +96,10 @@ def __init__( self._thread_id = thread_id self._endpoint = endpoint - self._api_version = kwargs.pop("api_version", DEFAULT_VERSION) self._credential = credential self._client = AzureCommunicationChatService( - self._credential, - self._endpoint, - api_version=self._api_version, + endpoint, authentication_policy=BearerTokenCredentialPolicy(self._credential), sdk_moniker=SDK_MONIKER, **kwargs diff --git a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/__init__.py b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/__init__.py index 9de5d6d8f3d2..8dc4fad2a1ac 100644 --- a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/__init__.py +++ b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/__init__.py @@ -7,15 +7,10 @@ # -------------------------------------------------------------------------- from ._azure_communication_chat_service import AzureCommunicationChatService +__all__ = ['AzureCommunicationChatService'] try: - from ._patch import __all__ as _patch_all - from ._patch import * # type: ignore # pylint: disable=unused-wildcard-import + from ._patch import patch_sdk # type: ignore + patch_sdk() except ImportError: - _patch_all = [] -from ._patch import patch_sdk as _patch_sdk - -__all__ = ["AzureCommunicationChatService"] -__all__.extend([p for p in _patch_all if p not in __all__]) - -_patch_sdk() + pass diff --git a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/_azure_communication_chat_service.py b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/_azure_communication_chat_service.py index 3d5ddb26a688..78780c4d9d5d 100644 --- a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/_azure_communication_chat_service.py +++ b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/_azure_communication_chat_service.py @@ -6,72 +6,71 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from copy import deepcopy -from typing import Any +from typing import TYPE_CHECKING from azure.core import PipelineClient -from azure.core.credentials import AzureKeyCredential -from azure.core.rest import HttpRequest, HttpResponse +from msrest import Deserializer, Serializer + +if TYPE_CHECKING: + # pylint: disable=unused-import,ungrouped-imports + from typing import Any + + from azure.core.pipeline.transport import HttpRequest, HttpResponse -from . import models from ._configuration import AzureCommunicationChatServiceConfiguration -from ._serialization import Deserializer, Serializer -from .operations import ChatOperations, ChatThreadOperations +from .operations import ChatThreadOperations +from .operations import ChatOperations +from . import models -class AzureCommunicationChatService: # pylint: disable=client-accepts-api-version-keyword +class AzureCommunicationChatService(object): """Azure Communication Chat Service. :ivar chat_thread: ChatThreadOperations operations :vartype chat_thread: azure.communication.chat.operations.ChatThreadOperations :ivar chat: ChatOperations operations :vartype chat: azure.communication.chat.operations.ChatOperations - :param credential: Credential needed for the client to connect to Azure. Required. - :type credential: ~azure.core.credentials.AzureKeyCredential - :param endpoint: The endpoint of the Azure Communication resource. Required. + :param endpoint: The endpoint of the Azure Communication resource. :type endpoint: str - :keyword api_version: Api Version. Default value is "2021-09-07". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str """ - def __init__(self, credential: AzureKeyCredential, endpoint: str, **kwargs: Any) -> None: - _endpoint = "{endpoint}" - self._config = AzureCommunicationChatServiceConfiguration(credential=credential, endpoint=endpoint, **kwargs) - self._client = PipelineClient(base_url=_endpoint, config=self._config, **kwargs) + def __init__( + self, + endpoint, # type: str + **kwargs # type: Any + ): + # type: (...) -> None + base_url = '{endpoint}' + self._config = AzureCommunicationChatServiceConfiguration(endpoint, **kwargs) + self._client = PipelineClient(base_url=base_url, config=self._config, **kwargs) client_models = {k: v for k, v in models.__dict__.items() if isinstance(v, type)} self._serialize = Serializer(client_models) - self._deserialize = Deserializer(client_models) self._serialize.client_side_validation = False - self.chat_thread = ChatThreadOperations(self._client, self._config, self._serialize, self._deserialize) - self.chat = ChatOperations(self._client, self._config, self._serialize, self._deserialize) - - def _send_request(self, request: HttpRequest, **kwargs: Any) -> HttpResponse: - """Runs the network request through the client's chained policies. + self._deserialize = Deserializer(client_models) - >>> from azure.core.rest import HttpRequest - >>> request = HttpRequest("GET", "https://www.example.org/") - - >>> response = client._send_request(request) - + self.chat_thread = ChatThreadOperations( + self._client, self._config, self._serialize, self._deserialize) + self.chat = ChatOperations( + self._client, self._config, self._serialize, self._deserialize) - For more information on this code flow, see https://aka.ms/azsdk/dpcodegen/python/send_request + def _send_request(self, http_request, **kwargs): + # type: (HttpRequest, Any) -> HttpResponse + """Runs the network request through the client's chained policies. - :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. + :param http_request: The network request you want to make. Required. + :type http_request: ~azure.core.pipeline.transport.HttpRequest + :keyword bool stream: Whether the response payload will be streamed. Defaults to True. :return: The response of your network call. Does not do error handling on your response. - :rtype: ~azure.core.rest.HttpResponse + :rtype: ~azure.core.pipeline.transport.HttpResponse """ - - request_copy = deepcopy(request) path_format_arguments = { - "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), + 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), } - - request_copy.url = self._client.format_url(request_copy.url, **path_format_arguments) - return self._client.send_request(request_copy, **kwargs) + http_request.url = self._client.format_url(http_request.url, **path_format_arguments) + stream = kwargs.pop("stream", True) + pipeline_response = self._client._pipeline.run(http_request, stream=stream, **kwargs) + return pipeline_response.http_response def close(self): # type: () -> None diff --git a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/_configuration.py b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/_configuration.py index 779b2fca3569..5b58f12b9f2e 100644 --- a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/_configuration.py +++ b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/_configuration.py @@ -6,57 +6,53 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any +from typing import TYPE_CHECKING from azure.core.configuration import Configuration -from azure.core.credentials import AzureKeyCredential from azure.core.pipeline import policies -VERSION = "unknown" +if TYPE_CHECKING: + # pylint: disable=unused-import,ungrouped-imports + from typing import Any +VERSION = "unknown" -class AzureCommunicationChatServiceConfiguration(Configuration): # pylint: disable=too-many-instance-attributes +class AzureCommunicationChatServiceConfiguration(Configuration): """Configuration for AzureCommunicationChatService. 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.AzureKeyCredential - :param endpoint: The endpoint of the Azure Communication resource. Required. + :param endpoint: The endpoint of the Azure Communication resource. :type endpoint: str - :keyword api_version: Api Version. Default value is "2021-09-07". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str """ - def __init__(self, credential: AzureKeyCredential, endpoint: str, **kwargs: Any) -> None: - super(AzureCommunicationChatServiceConfiguration, self).__init__(**kwargs) - api_version = kwargs.pop("api_version", "2021-09-07") # type: str - - if credential is None: - raise ValueError("Parameter 'credential' must not be None.") + def __init__( + self, + endpoint, # type: str + **kwargs # type: Any + ): + # type: (...) -> None if endpoint is None: raise ValueError("Parameter 'endpoint' must not be None.") + super(AzureCommunicationChatServiceConfiguration, self).__init__(**kwargs) - self.credential = credential self.endpoint = endpoint - self.api_version = api_version - kwargs.setdefault("sdk_moniker", "azurecommunicationchatservice/{}".format(VERSION)) + self.api_version = "2021-09-07" + kwargs.setdefault('sdk_moniker', 'azurecommunicationchatservice/{}'.format(VERSION)) self._configure(**kwargs) def _configure( - self, **kwargs # type: Any + self, + **kwargs # type: Any ): # type: (...) -> None - 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 policies.HttpLoggingPolicy(**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 = policies.AzureKeyCredentialPolicy(self.credential, "Authorization", **kwargs) + 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 policies.HttpLoggingPolicy(**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') diff --git a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/__init__.py b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/__init__.py index 9de5d6d8f3d2..70f222baebdc 100644 --- a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/__init__.py +++ b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/__init__.py @@ -7,15 +7,4 @@ # -------------------------------------------------------------------------- from ._azure_communication_chat_service import AzureCommunicationChatService - -try: - from ._patch import __all__ as _patch_all - from ._patch import * # type: ignore # pylint: disable=unused-wildcard-import -except ImportError: - _patch_all = [] -from ._patch import patch_sdk as _patch_sdk - -__all__ = ["AzureCommunicationChatService"] -__all__.extend([p for p in _patch_all if p not in __all__]) - -_patch_sdk() +__all__ = ['AzureCommunicationChatService'] diff --git a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/_azure_communication_chat_service.py b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/_azure_communication_chat_service.py index 4aee3f9f4649..97865a75beaf 100644 --- a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/_azure_communication_chat_service.py +++ b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/_azure_communication_chat_service.py @@ -6,72 +6,64 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from copy import deepcopy -from typing import Any, Awaitable +from typing import Any from azure.core import AsyncPipelineClient -from azure.core.credentials import AzureKeyCredential -from azure.core.rest import AsyncHttpResponse, HttpRequest +from azure.core.pipeline.transport import AsyncHttpResponse, HttpRequest +from msrest import Deserializer, Serializer -from .. import models -from .._serialization import Deserializer, Serializer from ._configuration import AzureCommunicationChatServiceConfiguration -from .operations import ChatOperations, ChatThreadOperations +from .operations import ChatThreadOperations +from .operations import ChatOperations +from .. import models -class AzureCommunicationChatService: # pylint: disable=client-accepts-api-version-keyword +class AzureCommunicationChatService(object): """Azure Communication Chat Service. :ivar chat_thread: ChatThreadOperations operations :vartype chat_thread: azure.communication.chat.aio.operations.ChatThreadOperations :ivar chat: ChatOperations operations :vartype chat: azure.communication.chat.aio.operations.ChatOperations - :param credential: Credential needed for the client to connect to Azure. Required. - :type credential: ~azure.core.credentials.AzureKeyCredential - :param endpoint: The endpoint of the Azure Communication resource. Required. + :param endpoint: The endpoint of the Azure Communication resource. :type endpoint: str - :keyword api_version: Api Version. Default value is "2021-09-07". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str """ - def __init__(self, credential: AzureKeyCredential, endpoint: str, **kwargs: Any) -> None: - _endpoint = "{endpoint}" - self._config = AzureCommunicationChatServiceConfiguration(credential=credential, endpoint=endpoint, **kwargs) - self._client = AsyncPipelineClient(base_url=_endpoint, config=self._config, **kwargs) + def __init__( + self, + endpoint: str, + **kwargs: Any + ) -> None: + base_url = '{endpoint}' + self._config = AzureCommunicationChatServiceConfiguration(endpoint, **kwargs) + self._client = AsyncPipelineClient(base_url=base_url, config=self._config, **kwargs) client_models = {k: v for k, v in models.__dict__.items() if isinstance(v, type)} self._serialize = Serializer(client_models) - self._deserialize = Deserializer(client_models) self._serialize.client_side_validation = False - self.chat_thread = ChatThreadOperations(self._client, self._config, self._serialize, self._deserialize) - self.chat = ChatOperations(self._client, self._config, self._serialize, self._deserialize) - - def _send_request(self, request: HttpRequest, **kwargs: Any) -> Awaitable[AsyncHttpResponse]: - """Runs the network request through the client's chained policies. + self._deserialize = Deserializer(client_models) - >>> from azure.core.rest import HttpRequest - >>> request = HttpRequest("GET", "https://www.example.org/") - - >>> response = await client._send_request(request) - + self.chat_thread = ChatThreadOperations( + self._client, self._config, self._serialize, self._deserialize) + self.chat = ChatOperations( + self._client, self._config, self._serialize, self._deserialize) - For more information on this code flow, see https://aka.ms/azsdk/dpcodegen/python/send_request + async def _send_request(self, http_request: HttpRequest, **kwargs: Any) -> AsyncHttpResponse: + """Runs the network request through the client's chained policies. - :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. + :param http_request: The network request you want to make. Required. + :type http_request: ~azure.core.pipeline.transport.HttpRequest + :keyword bool stream: Whether the response payload will be streamed. Defaults to True. :return: The response of your network call. Does not do error handling on your response. - :rtype: ~azure.core.rest.AsyncHttpResponse + :rtype: ~azure.core.pipeline.transport.AsyncHttpResponse """ - - request_copy = deepcopy(request) path_format_arguments = { - "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), + 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), } - - request_copy.url = self._client.format_url(request_copy.url, **path_format_arguments) - return self._client.send_request(request_copy, **kwargs) + http_request.url = self._client.format_url(http_request.url, **path_format_arguments) + stream = kwargs.pop("stream", True) + pipeline_response = await self._client._pipeline.run(http_request, stream=stream, **kwargs) + return pipeline_response.http_response async def close(self) -> None: await self._client.close() diff --git a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/_configuration.py b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/_configuration.py index 77a2651ff4db..00cb6d19b824 100644 --- a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/_configuration.py +++ b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/_configuration.py @@ -9,51 +9,44 @@ from typing import Any from azure.core.configuration import Configuration -from azure.core.credentials import AzureKeyCredential from azure.core.pipeline import policies VERSION = "unknown" - -class AzureCommunicationChatServiceConfiguration(Configuration): # pylint: disable=too-many-instance-attributes +class AzureCommunicationChatServiceConfiguration(Configuration): """Configuration for AzureCommunicationChatService. 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.AzureKeyCredential - :param endpoint: The endpoint of the Azure Communication resource. Required. + :param endpoint: The endpoint of the Azure Communication resource. :type endpoint: str - :keyword api_version: Api Version. Default value is "2021-09-07". Note that overriding this - default value may result in unsupported behavior. - :paramtype api_version: str """ - def __init__(self, credential: AzureKeyCredential, endpoint: str, **kwargs: Any) -> None: - super(AzureCommunicationChatServiceConfiguration, self).__init__(**kwargs) - api_version = kwargs.pop("api_version", "2021-09-07") # type: str - - if credential is None: - raise ValueError("Parameter 'credential' must not be None.") + def __init__( + self, + endpoint: str, + **kwargs: Any + ) -> None: if endpoint is None: raise ValueError("Parameter 'endpoint' must not be None.") + super(AzureCommunicationChatServiceConfiguration, self).__init__(**kwargs) - self.credential = credential self.endpoint = endpoint - self.api_version = api_version - kwargs.setdefault("sdk_moniker", "azurecommunicationchatservice/{}".format(VERSION)) + self.api_version = "2021-09-07" + kwargs.setdefault('sdk_moniker', 'azurecommunicationchatservice/{}'.format(VERSION)) self._configure(**kwargs) - def _configure(self, **kwargs: Any) -> None: - 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 policies.HttpLoggingPolicy(**kwargs) - self.retry_policy = kwargs.get("retry_policy") or policies.AsyncRetryPolicy(**kwargs) - self.custom_hook_policy = kwargs.get("custom_hook_policy") or policies.CustomHookPolicy(**kwargs) - self.redirect_policy = kwargs.get("redirect_policy") or policies.AsyncRedirectPolicy(**kwargs) - self.authentication_policy = kwargs.get("authentication_policy") - if self.credential and not self.authentication_policy: - self.authentication_policy = policies.AzureKeyCredentialPolicy(self.credential, "Authorization", **kwargs) + def _configure( + self, + **kwargs: Any + ) -> None: + 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 policies.HttpLoggingPolicy(**kwargs) + self.retry_policy = kwargs.get('retry_policy') or policies.AsyncRetryPolicy(**kwargs) + self.custom_hook_policy = kwargs.get('custom_hook_policy') or policies.CustomHookPolicy(**kwargs) + self.redirect_policy = kwargs.get('redirect_policy') or policies.AsyncRedirectPolicy(**kwargs) + self.authentication_policy = kwargs.get('authentication_policy') diff --git a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/operations/__init__.py b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/operations/__init__.py index dbe389acb5e7..ca0d822356d7 100644 --- a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/operations/__init__.py +++ b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/operations/__init__.py @@ -9,13 +9,7 @@ from ._chat_thread_operations import ChatThreadOperations from ._chat_operations import ChatOperations -from ._patch import __all__ as _patch_all -from ._patch import * # type: ignore # pylint: disable=unused-wildcard-import -from ._patch import patch_sdk as _patch_sdk - __all__ = [ - "ChatThreadOperations", - "ChatOperations", + 'ChatThreadOperations', + 'ChatOperations', ] -__all__.extend([p for p in _patch_all if p not in __all__]) -_patch_sdk() diff --git a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/operations/_chat_operations.py b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/operations/_chat_operations.py index 406d617b161e..0295ca765368 100644 --- a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/operations/_chat_operations.py +++ b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/operations/_chat_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -7,306 +6,182 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- import datetime -from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, TypeVar, Union, overload -import urllib.parse +from typing import Any, AsyncIterable, Callable, Dict, Generic, Optional, TypeVar +import warnings from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) +from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error from azure.core.pipeline import PipelineResponse -from azure.core.pipeline.transport import AsyncHttpResponse -from azure.core.rest import HttpRequest -from azure.core.tracing.decorator import distributed_trace -from azure.core.tracing.decorator_async import distributed_trace_async -from azure.core.utils import case_insensitive_dict +from azure.core.pipeline.transport import AsyncHttpResponse, HttpRequest from ... import models as _models -from ..._vendor import _convert_request -from ...operations._chat_operations import ( - build_create_chat_thread_request, - build_delete_chat_thread_request, - build_list_chat_threads_request, -) - -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] +T = TypeVar('T') +ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] class ChatOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. + """ChatOperations async operations. + + You should not instantiate this class directly. Instead, you should create a Client instance that + instantiates it for you and attaches it as an attribute. - Instead, you should access the following operations through - :class:`~azure.communication.chat.aio.AzureCommunicationChatService`'s - :attr:`chat` attribute. + :ivar models: Alias to model classes used in this operation group. + :type models: ~azure.communication.chat.models + :param client: Client for service requests. + :param config: Configuration of service client. + :param serializer: An object model serializer. + :param deserializer: An object model deserializer. """ models = _models - def __init__(self, *args, **kwargs) -> None: - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") + def __init__(self, client, config, serializer, deserializer) -> None: + self._client = client + self._serialize = serializer + self._deserialize = deserializer + self._config = config - @overload async def create_chat_thread( self, - create_chat_thread_request: _models.CreateChatThreadRequest, + create_chat_thread_request: "_models.CreateChatThreadRequest", repeatability_request_id: Optional[str] = None, - *, - content_type: str = "application/json", **kwargs: Any - ) -> _models.CreateChatThreadResult: + ) -> "_models.CreateChatThreadResult": """Creates a chat thread. Creates a chat thread. - :param create_chat_thread_request: Request payload for creating a chat thread. Required. + :param create_chat_thread_request: Request payload for creating a chat thread. :type create_chat_thread_request: ~azure.communication.chat.models.CreateChatThreadRequest :param repeatability_request_id: If specified, the client directs that the request is repeatable; that is, that the client can make the request multiple times with the same Repeatability-Request-Id and get back an appropriate response without the server executing the request multiple times. The value of the Repeatability-Request-Id is an opaque string representing a client-generated, globally unique for all time, identifier for the request. It - is recommended to use version 4 (random) UUIDs. Default value is None. - :type repeatability_request_id: str - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :keyword callable cls: A custom type or function that will be passed the direct response - :return: CreateChatThreadResult or the result of cls(response) - :rtype: ~azure.communication.chat.models.CreateChatThreadResult - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def create_chat_thread( - self, - create_chat_thread_request: IO, - repeatability_request_id: Optional[str] = None, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.CreateChatThreadResult: - """Creates a chat thread. - - Creates a chat thread. - - :param create_chat_thread_request: Request payload for creating a chat thread. Required. - :type create_chat_thread_request: IO - :param repeatability_request_id: If specified, the client directs that the request is - repeatable; that is, that the client can make the request multiple times with the same - Repeatability-Request-Id and get back an appropriate response without the server executing the - request multiple times. The value of the Repeatability-Request-Id is an opaque string - representing a client-generated, globally unique for all time, identifier for the request. It - is recommended to use version 4 (random) UUIDs. Default value is None. - :type repeatability_request_id: str - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :keyword callable cls: A custom type or function that will be passed the direct response - :return: CreateChatThreadResult or the result of cls(response) - :rtype: ~azure.communication.chat.models.CreateChatThreadResult - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace_async - async def create_chat_thread( - self, - create_chat_thread_request: Union[_models.CreateChatThreadRequest, IO], - repeatability_request_id: Optional[str] = None, - **kwargs: Any - ) -> _models.CreateChatThreadResult: - """Creates a chat thread. - - Creates a chat thread. - - :param create_chat_thread_request: Request payload for creating a chat thread. Is either a - model type or a IO type. Required. - :type create_chat_thread_request: ~azure.communication.chat.models.CreateChatThreadRequest or - IO - :param repeatability_request_id: If specified, the client directs that the request is - repeatable; that is, that the client can make the request multiple times with the same - Repeatability-Request-Id and get back an appropriate response without the server executing the - request multiple times. The value of the Repeatability-Request-Id is an opaque string - representing a client-generated, globally unique for all time, identifier for the request. It - is recommended to use version 4 (random) UUIDs. Default value is None. + is recommended to use version 4 (random) UUIDs. :type repeatability_request_id: str - :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. - Default value is None. - :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: CreateChatThreadResult or the result of cls(response) + :return: CreateChatThreadResult, or the result of cls(response) :rtype: ~azure.communication.chat.models.CreateChatThreadResult - :raises ~azure.core.exceptions.HttpResponseError: + :raises: ~azure.core.exceptions.HttpResponseError """ + cls = kwargs.pop('cls', None) # type: ClsType["_models.CreateChatThreadResult"] error_map = { 404: ResourceNotFoundError, 409: ResourceExistsError, - 304: ResourceNotModifiedError, - 401: lambda response: ClientAuthenticationError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 403: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 429: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 503: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), + 401: lambda response: ClientAuthenticationError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 403: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 429: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 503: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.CreateChatThreadResult] - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(create_chat_thread_request, (IO, bytes)): - _content = create_chat_thread_request - else: - _json = self._serialize.body(create_chat_thread_request, "CreateChatThreadRequest") - - request = build_create_chat_thread_request( - repeatability_request_id=repeatability_request_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - template_url=self.create_chat_thread.metadata["url"], - headers=_headers, - params=_params, - ) - request = _convert_request(request) + error_map.update(kwargs.pop('error_map', {})) + api_version = "2021-09-07" + content_type = kwargs.pop("content_type", "application/json") + accept = "application/json" + + # Construct URL + url = self.create_chat_thread.metadata['url'] # type: ignore path_format_arguments = { - "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), + 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), } - request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore - - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs - ) - + url = self._client.format_url(url, **path_format_arguments) + + # Construct parameters + query_parameters = {} # type: Dict[str, Any] + query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') + + # Construct headers + header_parameters = {} # type: Dict[str, Any] + if repeatability_request_id is not None: + header_parameters['repeatability-request-id'] = self._serialize.header("repeatability_request_id", repeatability_request_id, 'str') + header_parameters['Content-Type'] = self._serialize.header("content_type", content_type, 'str') + header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') + + body_content_kwargs = {} # type: Dict[str, Any] + body_content = self._serialize.body(create_chat_thread_request, 'CreateChatThreadRequest') + body_content_kwargs['content'] = body_content + request = self._client.post(url, query_parameters, header_parameters, **body_content_kwargs) + pipeline_response = await self._client._pipeline.run(request, stream=False, **kwargs) response = pipeline_response.http_response if response.status_code not in [201]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response) - deserialized = self._deserialize("CreateChatThreadResult", pipeline_response) + deserialized = self._deserialize('CreateChatThreadResult', pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized + create_chat_thread.metadata = {'url': '/chat/threads'} # type: ignore - create_chat_thread.metadata = {"url": "/chat/threads"} # type: ignore - - @distributed_trace def list_chat_threads( - self, max_page_size: Optional[int] = None, start_time: Optional[datetime.datetime] = None, **kwargs: Any - ) -> AsyncIterable["_models.ChatThreadItem"]: + self, + max_page_size: Optional[int] = None, + start_time: Optional[datetime.datetime] = None, + **kwargs: Any + ) -> AsyncIterable["_models.ChatThreadsItemCollection"]: """Gets the list of chat threads of a user. Gets the list of chat threads of a user. - :param max_page_size: The maximum number of chat threads returned per page. Default value is - None. + :param max_page_size: The maximum number of chat threads returned per page. :type max_page_size: int :param start_time: The earliest point in time to get chat threads up to. The timestamp should - be in RFC3339 format: ``yyyy-MM-ddTHH:mm:ssZ``. Default value is None. + be in RFC3339 format: ``yyyy-MM-ddTHH:mm:ssZ``. :type start_time: ~datetime.datetime :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either ChatThreadItem or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.communication.chat.models.ChatThreadItem] - :raises ~azure.core.exceptions.HttpResponseError: + :return: An iterator like instance of either ChatThreadsItemCollection or the result of cls(response) + :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.communication.chat.models.ChatThreadsItemCollection] + :raises: ~azure.core.exceptions.HttpResponseError """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str - cls = kwargs.pop("cls", None) # type: ClsType[_models.ChatThreadsItemCollection] - + cls = kwargs.pop('cls', None) # type: ClsType["_models.ChatThreadsItemCollection"] error_map = { 404: ResourceNotFoundError, 409: ResourceExistsError, - 304: ResourceNotModifiedError, - 401: lambda response: ClientAuthenticationError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 403: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 429: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 503: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), + 401: lambda response: ClientAuthenticationError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 403: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 429: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 503: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), } - error_map.update(kwargs.pop("error_map", {}) or {}) + error_map.update(kwargs.pop('error_map', {})) + api_version = "2021-09-07" + accept = "application/json" def prepare_request(next_link=None): - if not next_link: + # Construct headers + header_parameters = {} # type: Dict[str, Any] + header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') - request = build_list_chat_threads_request( - max_page_size=max_page_size, - start_time=start_time, - api_version=api_version, - template_url=self.list_chat_threads.metadata["url"], - headers=_headers, - params=_params, - ) - request = _convert_request(request) + if not next_link: + # Construct URL + url = self.list_chat_threads.metadata['url'] # type: ignore path_format_arguments = { - "endpoint": self._serialize.url( - "self._config.endpoint", self._config.endpoint, "str", skip_quote=True - ), + 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), } - request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore - + url = self._client.format_url(url, **path_format_arguments) + # Construct parameters + query_parameters = {} # type: Dict[str, Any] + if max_page_size is not None: + query_parameters['maxPageSize'] = self._serialize.query("max_page_size", max_page_size, 'int') + if start_time is not None: + query_parameters['startTime'] = self._serialize.query("start_time", start_time, 'iso-8601') + query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') + + request = self._client.get(url, query_parameters, header_parameters) else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._config.api_version - request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - request = _convert_request(request) + url = next_link + query_parameters = {} # type: Dict[str, Any] path_format_arguments = { - "endpoint": self._serialize.url( - "self._config.endpoint", self._config.endpoint, "str", skip_quote=True - ), + 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), } - request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore - request.method = "GET" + url = self._client.format_url(url, **path_format_arguments) + request = self._client.get(url, query_parameters, header_parameters) return request async def extract_data(pipeline_response): - deserialized = self._deserialize("ChatThreadsItemCollection", pipeline_response) + deserialized = self._deserialize('ChatThreadsItemCollection', pipeline_response) list_of_elem = deserialized.value if cls: list_of_elem = cls(list_of_elem) @@ -315,9 +190,7 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs - ) + pipeline_response = await self._client._pipeline.run(request, stream=False, **kwargs) response = pipeline_response.http_response if response.status_code not in [200]: @@ -326,67 +199,58 @@ async def get_next(next_link=None): return pipeline_response - return AsyncItemPaged(get_next, extract_data) - - list_chat_threads.metadata = {"url": "/chat/threads"} # type: ignore + return AsyncItemPaged( + get_next, extract_data + ) + list_chat_threads.metadata = {'url': '/chat/threads'} # type: ignore - @distributed_trace_async - async def delete_chat_thread( # pylint: disable=inconsistent-return-statements - self, chat_thread_id: str, **kwargs: Any + async def delete_chat_thread( + self, + chat_thread_id: str, + **kwargs: Any ) -> None: """Deletes a thread. Deletes a thread. - :param chat_thread_id: Id of the thread to be deleted. Required. + :param chat_thread_id: Id of the thread to be deleted. :type chat_thread_id: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None or the result of cls(response) + :return: None, or the result of cls(response) :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: + :raises: ~azure.core.exceptions.HttpResponseError """ + cls = kwargs.pop('cls', None) # type: ClsType[None] error_map = { 404: ResourceNotFoundError, 409: ResourceExistsError, - 304: ResourceNotModifiedError, - 401: lambda response: ClientAuthenticationError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 403: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 429: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 503: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), + 401: lambda response: ClientAuthenticationError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 403: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 429: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 503: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str - cls = kwargs.pop("cls", None) # type: ClsType[None] + error_map.update(kwargs.pop('error_map', {})) + api_version = "2021-09-07" + accept = "application/json" - request = build_delete_chat_thread_request( - chat_thread_id=chat_thread_id, - api_version=api_version, - template_url=self.delete_chat_thread.metadata["url"], - headers=_headers, - params=_params, - ) - request = _convert_request(request) + # Construct URL + url = self.delete_chat_thread.metadata['url'] # type: ignore path_format_arguments = { - "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), + 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), + 'chatThreadId': self._serialize.url("chat_thread_id", chat_thread_id, 'str'), } - request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore + url = self._client.format_url(url, **path_format_arguments) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs - ) + # Construct parameters + query_parameters = {} # type: Dict[str, Any] + query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') + + # Construct headers + header_parameters = {} # type: Dict[str, Any] + header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') + request = self._client.delete(url, query_parameters, header_parameters) + pipeline_response = await self._client._pipeline.run(request, stream=False, **kwargs) response = pipeline_response.http_response if response.status_code not in [204]: @@ -396,4 +260,4 @@ async def delete_chat_thread( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete_chat_thread.metadata = {"url": "/chat/threads/{chatThreadId}"} # type: ignore + delete_chat_thread.metadata = {'url': '/chat/threads/{chatThreadId}'} # type: ignore diff --git a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/operations/_chat_thread_operations.py b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/operations/_chat_thread_operations.py index 9a944dc0a036..c045d32f074c 100644 --- a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/operations/_chat_thread_operations.py +++ b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/operations/_chat_thread_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -7,159 +6,111 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- import datetime -from typing import Any, AsyncIterable, Callable, Dict, IO, Optional, TypeVar, Union, overload -import urllib.parse +from typing import Any, AsyncIterable, Callable, Dict, Generic, Optional, TypeVar +import warnings from azure.core.async_paging import AsyncItemPaged, AsyncList -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) +from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error from azure.core.pipeline import PipelineResponse -from azure.core.pipeline.transport import AsyncHttpResponse -from azure.core.rest import HttpRequest -from azure.core.tracing.decorator import distributed_trace -from azure.core.tracing.decorator_async import distributed_trace_async -from azure.core.utils import case_insensitive_dict +from azure.core.pipeline.transport import AsyncHttpResponse, HttpRequest from ... import models as _models -from ..._vendor import _convert_request -from ...operations._chat_thread_operations import ( - build_add_chat_participants_request, - build_delete_chat_message_request, - build_get_chat_message_request, - build_get_chat_thread_properties_request, - build_list_chat_messages_request, - build_list_chat_participants_request, - build_list_chat_read_receipts_request, - build_remove_chat_participant_request, - build_send_chat_message_request, - build_send_chat_read_receipt_request, - build_send_typing_notification_request, - build_update_chat_message_request, - build_update_chat_thread_properties_request, -) - -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] +T = TypeVar('T') +ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str, Any]], Any]] class ChatThreadOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. + """ChatThreadOperations async operations. - Instead, you should access the following operations through - :class:`~azure.communication.chat.aio.AzureCommunicationChatService`'s - :attr:`chat_thread` attribute. + You should not instantiate this class directly. Instead, you should create a Client instance that + instantiates it for you and attaches it as an attribute. + + :ivar models: Alias to model classes used in this operation group. + :type models: ~azure.communication.chat.models + :param client: Client for service requests. + :param config: Configuration of service client. + :param serializer: An object model serializer. + :param deserializer: An object model deserializer. """ models = _models - def __init__(self, *args, **kwargs) -> None: - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") + def __init__(self, client, config, serializer, deserializer) -> None: + self._client = client + self._serialize = serializer + self._deserialize = deserializer + self._config = config - @distributed_trace def list_chat_read_receipts( - self, chat_thread_id: str, max_page_size: Optional[int] = None, skip: Optional[int] = None, **kwargs: Any - ) -> AsyncIterable["_models.ChatMessageReadReceipt"]: + self, + chat_thread_id: str, + max_page_size: Optional[int] = None, + skip: Optional[int] = None, + **kwargs: Any + ) -> AsyncIterable["_models.ChatMessageReadReceiptsCollection"]: """Gets chat message read receipts for a thread. Gets chat message read receipts for a thread. - :param chat_thread_id: Thread id to get the chat message read receipts for. Required. + :param chat_thread_id: Thread id to get the chat message read receipts for. :type chat_thread_id: str :param max_page_size: The maximum number of chat message read receipts to be returned per page. - Default value is None. :type max_page_size: int - :param skip: Skips chat message read receipts up to a specified position in response. Default - value is None. + :param skip: Skips chat message read receipts up to a specified position in response. :type skip: int :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either ChatMessageReadReceipt or the result of - cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.communication.chat.models.ChatMessageReadReceipt] - :raises ~azure.core.exceptions.HttpResponseError: + :return: An iterator like instance of either ChatMessageReadReceiptsCollection or the result of cls(response) + :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.communication.chat.models.ChatMessageReadReceiptsCollection] + :raises: ~azure.core.exceptions.HttpResponseError """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str - cls = kwargs.pop("cls", None) # type: ClsType[_models.ChatMessageReadReceiptsCollection] - + cls = kwargs.pop('cls', None) # type: ClsType["_models.ChatMessageReadReceiptsCollection"] error_map = { 404: ResourceNotFoundError, 409: ResourceExistsError, - 304: ResourceNotModifiedError, - 401: lambda response: ClientAuthenticationError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 403: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 429: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 503: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), + 401: lambda response: ClientAuthenticationError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 403: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 429: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 503: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), } - error_map.update(kwargs.pop("error_map", {}) or {}) + error_map.update(kwargs.pop('error_map', {})) + api_version = "2021-09-07" + accept = "application/json" def prepare_request(next_link=None): - if not next_link: + # Construct headers + header_parameters = {} # type: Dict[str, Any] + header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') - request = build_list_chat_read_receipts_request( - chat_thread_id=chat_thread_id, - max_page_size=max_page_size, - skip=skip, - api_version=api_version, - template_url=self.list_chat_read_receipts.metadata["url"], - headers=_headers, - params=_params, - ) - request = _convert_request(request) + if not next_link: + # Construct URL + url = self.list_chat_read_receipts.metadata['url'] # type: ignore path_format_arguments = { - "endpoint": self._serialize.url( - "self._config.endpoint", self._config.endpoint, "str", skip_quote=True - ), + 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), + 'chatThreadId': self._serialize.url("chat_thread_id", chat_thread_id, 'str'), } - request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore - + url = self._client.format_url(url, **path_format_arguments) + # Construct parameters + query_parameters = {} # type: Dict[str, Any] + if max_page_size is not None: + query_parameters['maxPageSize'] = self._serialize.query("max_page_size", max_page_size, 'int') + if skip is not None: + query_parameters['skip'] = self._serialize.query("skip", skip, 'int') + query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') + + request = self._client.get(url, query_parameters, header_parameters) else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._config.api_version - request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - request = _convert_request(request) + url = next_link + query_parameters = {} # type: Dict[str, Any] path_format_arguments = { - "endpoint": self._serialize.url( - "self._config.endpoint", self._config.endpoint, "str", skip_quote=True - ), + 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), + 'chatThreadId': self._serialize.url("chat_thread_id", chat_thread_id, 'str'), } - request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore - request.method = "GET" + url = self._client.format_url(url, **path_format_arguments) + request = self._client.get(url, query_parameters, header_parameters) return request async def extract_data(pipeline_response): - deserialized = self._deserialize("ChatMessageReadReceiptsCollection", pipeline_response) + deserialized = self._deserialize('ChatMessageReadReceiptsCollection', pipeline_response) list_of_elem = deserialized.value if cls: list_of_elem = cls(list_of_elem) @@ -168,9 +119,7 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs - ) + pipeline_response = await self._client._pipeline.run(request, stream=False, **kwargs) response = pipeline_response.http_response if response.status_code not in [200]: @@ -179,137 +128,66 @@ async def get_next(next_link=None): return pipeline_response - return AsyncItemPaged(get_next, extract_data) - - list_chat_read_receipts.metadata = {"url": "/chat/threads/{chatThreadId}/readReceipts"} # type: ignore + return AsyncItemPaged( + get_next, extract_data + ) + list_chat_read_receipts.metadata = {'url': '/chat/threads/{chatThreadId}/readReceipts'} # type: ignore - @overload - async def send_chat_read_receipt( # pylint: disable=inconsistent-return-statements + async def send_chat_read_receipt( self, chat_thread_id: str, - send_read_receipt_request: _models.SendReadReceiptRequest, - *, - content_type: str = "application/json", + send_read_receipt_request: "_models.SendReadReceiptRequest", **kwargs: Any ) -> None: """Sends a read receipt event to a thread, on behalf of a user. Sends a read receipt event to a thread, on behalf of a user. - :param chat_thread_id: Thread id to send the read receipt event to. Required. + :param chat_thread_id: Thread id to send the read receipt event to. :type chat_thread_id: str - :param send_read_receipt_request: Read receipt details. Required. + :param send_read_receipt_request: Read receipt details. :type send_read_receipt_request: ~azure.communication.chat.models.SendReadReceiptRequest - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None or the result of cls(response) + :return: None, or the result of cls(response) :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def send_chat_read_receipt( # pylint: disable=inconsistent-return-statements - self, - chat_thread_id: str, - send_read_receipt_request: IO, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> None: - """Sends a read receipt event to a thread, on behalf of a user. - - Sends a read receipt event to a thread, on behalf of a user. - - :param chat_thread_id: Thread id to send the read receipt event to. Required. - :type chat_thread_id: str - :param send_read_receipt_request: Read receipt details. Required. - :type send_read_receipt_request: IO - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :keyword callable cls: A custom type or function that will be passed the direct response - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace_async - async def send_chat_read_receipt( # pylint: disable=inconsistent-return-statements - self, chat_thread_id: str, send_read_receipt_request: Union[_models.SendReadReceiptRequest, IO], **kwargs: Any - ) -> None: - """Sends a read receipt event to a thread, on behalf of a user. - - Sends a read receipt event to a thread, on behalf of a user. - - :param chat_thread_id: Thread id to send the read receipt event to. Required. - :type chat_thread_id: str - :param send_read_receipt_request: Read receipt details. Is either a model type or a IO type. - Required. - :type send_read_receipt_request: ~azure.communication.chat.models.SendReadReceiptRequest or IO - :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. - Default value is None. - :paramtype content_type: str - :keyword callable cls: A custom type or function that will be passed the direct response - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: + :raises: ~azure.core.exceptions.HttpResponseError """ + cls = kwargs.pop('cls', None) # type: ClsType[None] error_map = { 404: ResourceNotFoundError, 409: ResourceExistsError, - 304: ResourceNotModifiedError, - 401: lambda response: ClientAuthenticationError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 403: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 429: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 503: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), + 401: lambda response: ClientAuthenticationError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 403: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 429: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 503: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[None] + error_map.update(kwargs.pop('error_map', {})) + api_version = "2021-09-07" + content_type = kwargs.pop("content_type", "application/json") + accept = "application/json" - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(send_read_receipt_request, (IO, bytes)): - _content = send_read_receipt_request - else: - _json = self._serialize.body(send_read_receipt_request, "SendReadReceiptRequest") - - request = build_send_chat_read_receipt_request( - chat_thread_id=chat_thread_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - template_url=self.send_chat_read_receipt.metadata["url"], - headers=_headers, - params=_params, - ) - request = _convert_request(request) + # Construct URL + url = self.send_chat_read_receipt.metadata['url'] # type: ignore path_format_arguments = { - "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), + 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), + 'chatThreadId': self._serialize.url("chat_thread_id", chat_thread_id, 'str'), } - request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore - - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs - ) - + url = self._client.format_url(url, **path_format_arguments) + + # Construct parameters + query_parameters = {} # type: Dict[str, Any] + query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') + + # Construct headers + header_parameters = {} # type: Dict[str, Any] + header_parameters['Content-Type'] = self._serialize.header("content_type", content_type, 'str') + header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') + + body_content_kwargs = {} # type: Dict[str, Any] + body_content = self._serialize.body(send_read_receipt_request, 'SendReadReceiptRequest') + body_content_kwargs['content'] = body_content + request = self._client.post(url, query_parameters, header_parameters, **body_content_kwargs) + pipeline_response = await self._client._pipeline.run(request, stream=False, **kwargs) response = pipeline_response.http_response if response.status_code not in [200]: @@ -319,245 +197,148 @@ async def send_chat_read_receipt( # pylint: disable=inconsistent-return-stateme if cls: return cls(pipeline_response, None, {}) - send_chat_read_receipt.metadata = {"url": "/chat/threads/{chatThreadId}/readReceipts"} # type: ignore + send_chat_read_receipt.metadata = {'url': '/chat/threads/{chatThreadId}/readReceipts'} # type: ignore - @overload async def send_chat_message( self, chat_thread_id: str, - send_chat_message_request: _models.SendChatMessageRequest, - *, - content_type: str = "application/json", + send_chat_message_request: "_models.SendChatMessageRequest", **kwargs: Any - ) -> _models.SendChatMessageResult: + ) -> "_models.SendChatMessageResult": """Sends a message to a thread. Sends a message to a thread. - :param chat_thread_id: The thread id to send the message to. Required. + :param chat_thread_id: The thread id to send the message to. :type chat_thread_id: str - :param send_chat_message_request: Details of the message to send. Required. + :param send_chat_message_request: Details of the message to send. :type send_chat_message_request: ~azure.communication.chat.models.SendChatMessageRequest - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :keyword callable cls: A custom type or function that will be passed the direct response - :return: SendChatMessageResult or the result of cls(response) - :rtype: ~azure.communication.chat.models.SendChatMessageResult - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def send_chat_message( - self, - chat_thread_id: str, - send_chat_message_request: IO, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.SendChatMessageResult: - """Sends a message to a thread. - - Sends a message to a thread. - - :param chat_thread_id: The thread id to send the message to. Required. - :type chat_thread_id: str - :param send_chat_message_request: Details of the message to send. Required. - :type send_chat_message_request: IO - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :keyword callable cls: A custom type or function that will be passed the direct response - :return: SendChatMessageResult or the result of cls(response) - :rtype: ~azure.communication.chat.models.SendChatMessageResult - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace_async - async def send_chat_message( - self, chat_thread_id: str, send_chat_message_request: Union[_models.SendChatMessageRequest, IO], **kwargs: Any - ) -> _models.SendChatMessageResult: - """Sends a message to a thread. - - Sends a message to a thread. - - :param chat_thread_id: The thread id to send the message to. Required. - :type chat_thread_id: str - :param send_chat_message_request: Details of the message to send. Is either a model type or a - IO type. Required. - :type send_chat_message_request: ~azure.communication.chat.models.SendChatMessageRequest or IO - :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. - Default value is None. - :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: SendChatMessageResult or the result of cls(response) + :return: SendChatMessageResult, or the result of cls(response) :rtype: ~azure.communication.chat.models.SendChatMessageResult - :raises ~azure.core.exceptions.HttpResponseError: + :raises: ~azure.core.exceptions.HttpResponseError """ + cls = kwargs.pop('cls', None) # type: ClsType["_models.SendChatMessageResult"] error_map = { 404: ResourceNotFoundError, 409: ResourceExistsError, - 304: ResourceNotModifiedError, - 401: lambda response: ClientAuthenticationError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 403: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 429: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 503: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), + 401: lambda response: ClientAuthenticationError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 403: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 429: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 503: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + error_map.update(kwargs.pop('error_map', {})) + api_version = "2021-09-07" + content_type = kwargs.pop("content_type", "application/json") + accept = "application/json" - api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.SendChatMessageResult] - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(send_chat_message_request, (IO, bytes)): - _content = send_chat_message_request - else: - _json = self._serialize.body(send_chat_message_request, "SendChatMessageRequest") - - request = build_send_chat_message_request( - chat_thread_id=chat_thread_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - template_url=self.send_chat_message.metadata["url"], - headers=_headers, - params=_params, - ) - request = _convert_request(request) + # Construct URL + url = self.send_chat_message.metadata['url'] # type: ignore path_format_arguments = { - "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), + 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), + 'chatThreadId': self._serialize.url("chat_thread_id", chat_thread_id, 'str'), } - request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore - - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs - ) - + url = self._client.format_url(url, **path_format_arguments) + + # Construct parameters + query_parameters = {} # type: Dict[str, Any] + query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') + + # Construct headers + header_parameters = {} # type: Dict[str, Any] + header_parameters['Content-Type'] = self._serialize.header("content_type", content_type, 'str') + header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') + + body_content_kwargs = {} # type: Dict[str, Any] + body_content = self._serialize.body(send_chat_message_request, 'SendChatMessageRequest') + body_content_kwargs['content'] = body_content + request = self._client.post(url, query_parameters, header_parameters, **body_content_kwargs) + pipeline_response = await self._client._pipeline.run(request, stream=False, **kwargs) response = pipeline_response.http_response if response.status_code not in [201]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response) - deserialized = self._deserialize("SendChatMessageResult", pipeline_response) + deserialized = self._deserialize('SendChatMessageResult', pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized + send_chat_message.metadata = {'url': '/chat/threads/{chatThreadId}/messages'} # type: ignore - send_chat_message.metadata = {"url": "/chat/threads/{chatThreadId}/messages"} # type: ignore - - @distributed_trace def list_chat_messages( self, chat_thread_id: str, max_page_size: Optional[int] = None, start_time: Optional[datetime.datetime] = None, **kwargs: Any - ) -> AsyncIterable["_models.ChatMessage"]: + ) -> AsyncIterable["_models.ChatMessagesCollection"]: """Gets a list of messages from a thread. Gets a list of messages from a thread. - :param chat_thread_id: The thread id of the message. Required. + :param chat_thread_id: The thread id of the message. :type chat_thread_id: str - :param max_page_size: The maximum number of messages to be returned per page. Default value is - None. + :param max_page_size: The maximum number of messages to be returned per page. :type max_page_size: int :param start_time: The earliest point in time to get messages up to. The timestamp should be in - RFC3339 format: ``yyyy-MM-ddTHH:mm:ssZ``. Default value is None. + RFC3339 format: ``yyyy-MM-ddTHH:mm:ssZ``. :type start_time: ~datetime.datetime :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either ChatMessage or the result of cls(response) - :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.communication.chat.models.ChatMessage] - :raises ~azure.core.exceptions.HttpResponseError: + :return: An iterator like instance of either ChatMessagesCollection or the result of cls(response) + :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.communication.chat.models.ChatMessagesCollection] + :raises: ~azure.core.exceptions.HttpResponseError """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str - cls = kwargs.pop("cls", None) # type: ClsType[_models.ChatMessagesCollection] - + cls = kwargs.pop('cls', None) # type: ClsType["_models.ChatMessagesCollection"] error_map = { 404: ResourceNotFoundError, 409: ResourceExistsError, - 304: ResourceNotModifiedError, - 401: lambda response: ClientAuthenticationError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 403: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 429: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 503: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), + 401: lambda response: ClientAuthenticationError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 403: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 429: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 503: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), } - error_map.update(kwargs.pop("error_map", {}) or {}) + error_map.update(kwargs.pop('error_map', {})) + api_version = "2021-09-07" + accept = "application/json" def prepare_request(next_link=None): - if not next_link: + # Construct headers + header_parameters = {} # type: Dict[str, Any] + header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') - request = build_list_chat_messages_request( - chat_thread_id=chat_thread_id, - max_page_size=max_page_size, - start_time=start_time, - api_version=api_version, - template_url=self.list_chat_messages.metadata["url"], - headers=_headers, - params=_params, - ) - request = _convert_request(request) + if not next_link: + # Construct URL + url = self.list_chat_messages.metadata['url'] # type: ignore path_format_arguments = { - "endpoint": self._serialize.url( - "self._config.endpoint", self._config.endpoint, "str", skip_quote=True - ), + 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), + 'chatThreadId': self._serialize.url("chat_thread_id", chat_thread_id, 'str'), } - request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore - + url = self._client.format_url(url, **path_format_arguments) + # Construct parameters + query_parameters = {} # type: Dict[str, Any] + if max_page_size is not None: + query_parameters['maxPageSize'] = self._serialize.query("max_page_size", max_page_size, 'int') + if start_time is not None: + query_parameters['startTime'] = self._serialize.query("start_time", start_time, 'iso-8601') + query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') + + request = self._client.get(url, query_parameters, header_parameters) else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._config.api_version - request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - request = _convert_request(request) + url = next_link + query_parameters = {} # type: Dict[str, Any] path_format_arguments = { - "endpoint": self._serialize.url( - "self._config.endpoint", self._config.endpoint, "str", skip_quote=True - ), + 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), + 'chatThreadId': self._serialize.url("chat_thread_id", chat_thread_id, 'str'), } - request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore - request.method = "GET" + url = self._client.format_url(url, **path_format_arguments) + request = self._client.get(url, query_parameters, header_parameters) return request async def extract_data(pipeline_response): - deserialized = self._deserialize("ChatMessagesCollection", pipeline_response) + deserialized = self._deserialize('ChatMessagesCollection', pipeline_response) list_of_elem = deserialized.value if cls: list_of_elem = cls(list_of_elem) @@ -566,9 +347,7 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs - ) + pipeline_response = await self._client._pipeline.run(request, stream=False, **kwargs) response = pipeline_response.http_response if response.status_code not in [200]: @@ -577,224 +356,135 @@ async def get_next(next_link=None): return pipeline_response - return AsyncItemPaged(get_next, extract_data) - - list_chat_messages.metadata = {"url": "/chat/threads/{chatThreadId}/messages"} # type: ignore + return AsyncItemPaged( + get_next, extract_data + ) + list_chat_messages.metadata = {'url': '/chat/threads/{chatThreadId}/messages'} # type: ignore - @distributed_trace_async - async def get_chat_message(self, chat_thread_id: str, chat_message_id: str, **kwargs: Any) -> _models.ChatMessage: + async def get_chat_message( + self, + chat_thread_id: str, + chat_message_id: str, + **kwargs: Any + ) -> "_models.ChatMessage": """Gets a message by id. Gets a message by id. - :param chat_thread_id: The thread id to which the message was sent. Required. + :param chat_thread_id: The thread id to which the message was sent. :type chat_thread_id: str - :param chat_message_id: The message id. Required. + :param chat_message_id: The message id. :type chat_message_id: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: ChatMessage or the result of cls(response) + :return: ChatMessage, or the result of cls(response) :rtype: ~azure.communication.chat.models.ChatMessage - :raises ~azure.core.exceptions.HttpResponseError: + :raises: ~azure.core.exceptions.HttpResponseError """ + cls = kwargs.pop('cls', None) # type: ClsType["_models.ChatMessage"] error_map = { 404: ResourceNotFoundError, 409: ResourceExistsError, - 304: ResourceNotModifiedError, - 401: lambda response: ClientAuthenticationError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 403: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 429: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 503: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), + 401: lambda response: ClientAuthenticationError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 403: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 429: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 503: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + error_map.update(kwargs.pop('error_map', {})) + api_version = "2021-09-07" + accept = "application/json" - api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str - cls = kwargs.pop("cls", None) # type: ClsType[_models.ChatMessage] - - request = build_get_chat_message_request( - chat_thread_id=chat_thread_id, - chat_message_id=chat_message_id, - api_version=api_version, - template_url=self.get_chat_message.metadata["url"], - headers=_headers, - params=_params, - ) - request = _convert_request(request) + # Construct URL + url = self.get_chat_message.metadata['url'] # type: ignore path_format_arguments = { - "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), + 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), + 'chatThreadId': self._serialize.url("chat_thread_id", chat_thread_id, 'str'), + 'chatMessageId': self._serialize.url("chat_message_id", chat_message_id, 'str'), } - request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore + url = self._client.format_url(url, **path_format_arguments) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs - ) + # Construct parameters + query_parameters = {} # type: Dict[str, Any] + query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') + + # Construct headers + header_parameters = {} # type: Dict[str, Any] + header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') + request = self._client.get(url, query_parameters, header_parameters) + pipeline_response = await self._client._pipeline.run(request, stream=False, **kwargs) response = pipeline_response.http_response if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response) - deserialized = self._deserialize("ChatMessage", pipeline_response) + deserialized = self._deserialize('ChatMessage', pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized + get_chat_message.metadata = {'url': '/chat/threads/{chatThreadId}/messages/{chatMessageId}'} # type: ignore - get_chat_message.metadata = {"url": "/chat/threads/{chatThreadId}/messages/{chatMessageId}"} # type: ignore - - @overload - async def update_chat_message( # pylint: disable=inconsistent-return-statements + async def update_chat_message( self, chat_thread_id: str, chat_message_id: str, - update_chat_message_request: _models.UpdateChatMessageRequest, - *, - content_type: str = "application/merge-patch+json", + update_chat_message_request: "_models.UpdateChatMessageRequest", **kwargs: Any ) -> None: """Updates a message. Updates a message. - :param chat_thread_id: The thread id to which the message was sent. Required. + :param chat_thread_id: The thread id to which the message was sent. :type chat_thread_id: str - :param chat_message_id: The message id. Required. + :param chat_message_id: The message id. :type chat_message_id: str - :param update_chat_message_request: Details of the request to update the message. Required. + :param update_chat_message_request: Details of the request to update the message. :type update_chat_message_request: ~azure.communication.chat.models.UpdateChatMessageRequest - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/merge-patch+json". - :paramtype content_type: str - :keyword callable cls: A custom type or function that will be passed the direct response - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def update_chat_message( # pylint: disable=inconsistent-return-statements - self, - chat_thread_id: str, - chat_message_id: str, - update_chat_message_request: IO, - *, - content_type: str = "application/merge-patch+json", - **kwargs: Any - ) -> None: - """Updates a message. - - Updates a message. - - :param chat_thread_id: The thread id to which the message was sent. Required. - :type chat_thread_id: str - :param chat_message_id: The message id. Required. - :type chat_message_id: str - :param update_chat_message_request: Details of the request to update the message. Required. - :type update_chat_message_request: IO - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/merge-patch+json". - :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None or the result of cls(response) + :return: None, or the result of cls(response) :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace_async - async def update_chat_message( # pylint: disable=inconsistent-return-statements - self, - chat_thread_id: str, - chat_message_id: str, - update_chat_message_request: Union[_models.UpdateChatMessageRequest, IO], - **kwargs: Any - ) -> None: - """Updates a message. - - Updates a message. - - :param chat_thread_id: The thread id to which the message was sent. Required. - :type chat_thread_id: str - :param chat_message_id: The message id. Required. - :type chat_message_id: str - :param update_chat_message_request: Details of the request to update the message. Is either a - model type or a IO type. Required. - :type update_chat_message_request: ~azure.communication.chat.models.UpdateChatMessageRequest or - IO - :keyword content_type: Body Parameter content-type. Known values are: - 'application/merge-patch+json'. Default value is None. - :paramtype content_type: str - :keyword callable cls: A custom type or function that will be passed the direct response - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: + :raises: ~azure.core.exceptions.HttpResponseError """ + cls = kwargs.pop('cls', None) # type: ClsType[None] error_map = { 404: ResourceNotFoundError, 409: ResourceExistsError, - 304: ResourceNotModifiedError, - 401: lambda response: ClientAuthenticationError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 403: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 429: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 503: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), + 401: lambda response: ClientAuthenticationError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 403: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 429: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 503: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + error_map.update(kwargs.pop('error_map', {})) + api_version = "2021-09-07" + content_type = kwargs.pop("content_type", "application/merge-patch+json") + accept = "application/json" - api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[None] - - content_type = content_type or "application/merge-patch+json" - _json = None - _content = None - if isinstance(update_chat_message_request, (IO, bytes)): - _content = update_chat_message_request - else: - _json = self._serialize.body(update_chat_message_request, "UpdateChatMessageRequest") - - request = build_update_chat_message_request( - chat_thread_id=chat_thread_id, - chat_message_id=chat_message_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - template_url=self.update_chat_message.metadata["url"], - headers=_headers, - params=_params, - ) - request = _convert_request(request) + # Construct URL + url = self.update_chat_message.metadata['url'] # type: ignore path_format_arguments = { - "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), + 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), + 'chatThreadId': self._serialize.url("chat_thread_id", chat_thread_id, 'str'), + 'chatMessageId': self._serialize.url("chat_message_id", chat_message_id, 'str'), } - request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore - - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs - ) - + url = self._client.format_url(url, **path_format_arguments) + + # Construct parameters + query_parameters = {} # type: Dict[str, Any] + query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') + + # Construct headers + header_parameters = {} # type: Dict[str, Any] + header_parameters['Content-Type'] = self._serialize.header("content_type", content_type, 'str') + header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') + + body_content_kwargs = {} # type: Dict[str, Any] + body_content = self._serialize.body(update_chat_message_request, 'UpdateChatMessageRequest') + body_content_kwargs['content'] = body_content + request = self._client.patch(url, query_parameters, header_parameters, **body_content_kwargs) + pipeline_response = await self._client._pipeline.run(request, stream=False, **kwargs) response = pipeline_response.http_response if response.status_code not in [204]: @@ -804,68 +494,59 @@ async def update_chat_message( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - update_chat_message.metadata = {"url": "/chat/threads/{chatThreadId}/messages/{chatMessageId}"} # type: ignore + update_chat_message.metadata = {'url': '/chat/threads/{chatThreadId}/messages/{chatMessageId}'} # type: ignore - @distributed_trace_async - async def delete_chat_message( # pylint: disable=inconsistent-return-statements - self, chat_thread_id: str, chat_message_id: str, **kwargs: Any + async def delete_chat_message( + self, + chat_thread_id: str, + chat_message_id: str, + **kwargs: Any ) -> None: """Deletes a message. Deletes a message. - :param chat_thread_id: The thread id to which the message was sent. Required. + :param chat_thread_id: The thread id to which the message was sent. :type chat_thread_id: str - :param chat_message_id: The message id. Required. + :param chat_message_id: The message id. :type chat_message_id: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None or the result of cls(response) + :return: None, or the result of cls(response) :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: + :raises: ~azure.core.exceptions.HttpResponseError """ + cls = kwargs.pop('cls', None) # type: ClsType[None] error_map = { 404: ResourceNotFoundError, 409: ResourceExistsError, - 304: ResourceNotModifiedError, - 401: lambda response: ClientAuthenticationError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 403: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 429: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 503: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), + 401: lambda response: ClientAuthenticationError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 403: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 429: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 503: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + error_map.update(kwargs.pop('error_map', {})) + api_version = "2021-09-07" + accept = "application/json" - api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str - cls = kwargs.pop("cls", None) # type: ClsType[None] - - request = build_delete_chat_message_request( - chat_thread_id=chat_thread_id, - chat_message_id=chat_message_id, - api_version=api_version, - template_url=self.delete_chat_message.metadata["url"], - headers=_headers, - params=_params, - ) - request = _convert_request(request) + # Construct URL + url = self.delete_chat_message.metadata['url'] # type: ignore path_format_arguments = { - "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), + 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), + 'chatThreadId': self._serialize.url("chat_thread_id", chat_thread_id, 'str'), + 'chatMessageId': self._serialize.url("chat_message_id", chat_message_id, 'str'), } - request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore + url = self._client.format_url(url, **path_format_arguments) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs - ) + # Construct parameters + query_parameters = {} # type: Dict[str, Any] + query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') + + # Construct headers + header_parameters = {} # type: Dict[str, Any] + header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') + request = self._client.delete(url, query_parameters, header_parameters) + pipeline_response = await self._client._pipeline.run(request, stream=False, **kwargs) response = pipeline_response.http_response if response.status_code not in [204]: @@ -875,99 +556,78 @@ async def delete_chat_message( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete_chat_message.metadata = {"url": "/chat/threads/{chatThreadId}/messages/{chatMessageId}"} # type: ignore + delete_chat_message.metadata = {'url': '/chat/threads/{chatThreadId}/messages/{chatMessageId}'} # type: ignore - @distributed_trace def list_chat_participants( - self, chat_thread_id: str, max_page_size: Optional[int] = None, skip: Optional[int] = None, **kwargs: Any - ) -> AsyncIterable["_models.ChatParticipant"]: + self, + chat_thread_id: str, + max_page_size: Optional[int] = None, + skip: Optional[int] = None, + **kwargs: Any + ) -> AsyncIterable["_models.ChatParticipantsCollection"]: """Gets the participants of a thread. Gets the participants of a thread. - :param chat_thread_id: Thread id to get participants for. Required. + :param chat_thread_id: Thread id to get participants for. :type chat_thread_id: str - :param max_page_size: The maximum number of participants to be returned per page. Default value - is None. + :param max_page_size: The maximum number of participants to be returned per page. :type max_page_size: int - :param skip: Skips participants up to a specified position in response. Default value is None. + :param skip: Skips participants up to a specified position in response. :type skip: int :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either ChatParticipant or the result of cls(response) - :rtype: - ~azure.core.async_paging.AsyncItemPaged[~azure.communication.chat.models.ChatParticipant] - :raises ~azure.core.exceptions.HttpResponseError: + :return: An iterator like instance of either ChatParticipantsCollection or the result of cls(response) + :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.communication.chat.models.ChatParticipantsCollection] + :raises: ~azure.core.exceptions.HttpResponseError """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str - cls = kwargs.pop("cls", None) # type: ClsType[_models.ChatParticipantsCollection] - + cls = kwargs.pop('cls', None) # type: ClsType["_models.ChatParticipantsCollection"] error_map = { 404: ResourceNotFoundError, 409: ResourceExistsError, - 304: ResourceNotModifiedError, - 401: lambda response: ClientAuthenticationError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 403: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 429: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 503: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), + 401: lambda response: ClientAuthenticationError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 403: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 429: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 503: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), } - error_map.update(kwargs.pop("error_map", {}) or {}) + error_map.update(kwargs.pop('error_map', {})) + api_version = "2021-09-07" + accept = "application/json" def prepare_request(next_link=None): - if not next_link: + # Construct headers + header_parameters = {} # type: Dict[str, Any] + header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') - request = build_list_chat_participants_request( - chat_thread_id=chat_thread_id, - max_page_size=max_page_size, - skip=skip, - api_version=api_version, - template_url=self.list_chat_participants.metadata["url"], - headers=_headers, - params=_params, - ) - request = _convert_request(request) + if not next_link: + # Construct URL + url = self.list_chat_participants.metadata['url'] # type: ignore path_format_arguments = { - "endpoint": self._serialize.url( - "self._config.endpoint", self._config.endpoint, "str", skip_quote=True - ), + 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), + 'chatThreadId': self._serialize.url("chat_thread_id", chat_thread_id, 'str'), } - request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore - + url = self._client.format_url(url, **path_format_arguments) + # Construct parameters + query_parameters = {} # type: Dict[str, Any] + if max_page_size is not None: + query_parameters['maxPageSize'] = self._serialize.query("max_page_size", max_page_size, 'int') + if skip is not None: + query_parameters['skip'] = self._serialize.query("skip", skip, 'int') + query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') + + request = self._client.get(url, query_parameters, header_parameters) else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._config.api_version - request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - request = _convert_request(request) + url = next_link + query_parameters = {} # type: Dict[str, Any] path_format_arguments = { - "endpoint": self._serialize.url( - "self._config.endpoint", self._config.endpoint, "str", skip_quote=True - ), + 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), + 'chatThreadId': self._serialize.url("chat_thread_id", chat_thread_id, 'str'), } - request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore - request.method = "GET" + url = self._client.format_url(url, **path_format_arguments) + request = self._client.get(url, query_parameters, header_parameters) return request async def extract_data(pipeline_response): - deserialized = self._deserialize("ChatParticipantsCollection", pipeline_response) + deserialized = self._deserialize('ChatParticipantsCollection', pipeline_response) list_of_elem = deserialized.value if cls: list_of_elem = cls(list_of_elem) @@ -976,9 +636,7 @@ async def extract_data(pipeline_response): async def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs - ) + pipeline_response = await self._client._pipeline.run(request, stream=False, **kwargs) response = pipeline_response.http_response if response.status_code not in [200]: @@ -987,145 +645,67 @@ async def get_next(next_link=None): return pipeline_response - return AsyncItemPaged(get_next, extract_data) - - list_chat_participants.metadata = {"url": "/chat/threads/{chatThreadId}/participants"} # type: ignore - - @overload - async def remove_chat_participant( # pylint: disable=inconsistent-return-statements - self, - chat_thread_id: str, - participant_communication_identifier: _models.CommunicationIdentifierModel, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> None: - """Remove a participant from a thread. - - Remove a participant from a thread. - - :param chat_thread_id: Thread id to remove the participant from. Required. - :type chat_thread_id: str - :param participant_communication_identifier: Id of the thread participant to remove from the - thread. Required. - :type participant_communication_identifier: - ~azure.communication.chat.models.CommunicationIdentifierModel - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :keyword callable cls: A custom type or function that will be passed the direct response - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def remove_chat_participant( # pylint: disable=inconsistent-return-statements - self, - chat_thread_id: str, - participant_communication_identifier: IO, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> None: - """Remove a participant from a thread. - - Remove a participant from a thread. - - :param chat_thread_id: Thread id to remove the participant from. Required. - :type chat_thread_id: str - :param participant_communication_identifier: Id of the thread participant to remove from the - thread. Required. - :type participant_communication_identifier: IO - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Known values are: 'application/json', 'application/merge-patch+json'. Default value is - "application/json". - :paramtype content_type: str - :keyword callable cls: A custom type or function that will be passed the direct response - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ + return AsyncItemPaged( + get_next, extract_data + ) + list_chat_participants.metadata = {'url': '/chat/threads/{chatThreadId}/participants'} # type: ignore - @distributed_trace_async - async def remove_chat_participant( # pylint: disable=inconsistent-return-statements + async def remove_chat_participant( self, chat_thread_id: str, - participant_communication_identifier: Union[_models.CommunicationIdentifierModel, IO], + participant_communication_identifier: "_models.CommunicationIdentifierModel", **kwargs: Any ) -> None: """Remove a participant from a thread. Remove a participant from a thread. - :param chat_thread_id: Thread id to remove the participant from. Required. + :param chat_thread_id: Thread id to remove the participant from. :type chat_thread_id: str :param participant_communication_identifier: Id of the thread participant to remove from the - thread. Is either a model type or a IO type. Required. - :type participant_communication_identifier: - ~azure.communication.chat.models.CommunicationIdentifierModel or IO - :keyword content_type: Body Parameter content-type. Known values are: 'application/json', - 'application/merge-patch+json'. Default value is None. - :paramtype content_type: str + thread. + :type participant_communication_identifier: ~azure.communication.chat.models.CommunicationIdentifierModel :keyword callable cls: A custom type or function that will be passed the direct response - :return: None or the result of cls(response) + :return: None, or the result of cls(response) :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: + :raises: ~azure.core.exceptions.HttpResponseError """ + cls = kwargs.pop('cls', None) # type: ClsType[None] error_map = { 404: ResourceNotFoundError, 409: ResourceExistsError, - 304: ResourceNotModifiedError, - 401: lambda response: ClientAuthenticationError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 403: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 429: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 503: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), + 401: lambda response: ClientAuthenticationError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 403: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 429: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 503: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + error_map.update(kwargs.pop('error_map', {})) + api_version = "2021-09-07" + content_type = kwargs.pop("content_type", "application/json") + accept = "application/json" - api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[None] - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(participant_communication_identifier, (IO, bytes)): - _content = participant_communication_identifier - else: - _json = self._serialize.body(participant_communication_identifier, "CommunicationIdentifierModel") - - request = build_remove_chat_participant_request( - chat_thread_id=chat_thread_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - template_url=self.remove_chat_participant.metadata["url"], - headers=_headers, - params=_params, - ) - request = _convert_request(request) + # Construct URL + url = self.remove_chat_participant.metadata['url'] # type: ignore path_format_arguments = { - "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), + 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), + 'chatThreadId': self._serialize.url("chat_thread_id", chat_thread_id, 'str'), } - request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore - - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs - ) - + url = self._client.format_url(url, **path_format_arguments) + + # Construct parameters + query_parameters = {} # type: Dict[str, Any] + query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') + + # Construct headers + header_parameters = {} # type: Dict[str, Any] + header_parameters['Content-Type'] = self._serialize.header("content_type", content_type, 'str') + header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') + + body_content_kwargs = {} # type: Dict[str, Any] + body_content = self._serialize.body(participant_communication_identifier, 'CommunicationIdentifierModel') + body_content_kwargs['content'] = body_content + request = self._client.post(url, query_parameters, header_parameters, **body_content_kwargs) + pipeline_response = await self._client._pipeline.run(request, stream=False, **kwargs) response = pipeline_response.http_response if response.status_code not in [204]: @@ -1135,283 +715,132 @@ async def remove_chat_participant( # pylint: disable=inconsistent-return-statem if cls: return cls(pipeline_response, None, {}) - remove_chat_participant.metadata = {"url": "/chat/threads/{chatThreadId}/participants/:remove"} # type: ignore - - @overload - async def add_chat_participants( - self, - chat_thread_id: str, - add_chat_participants_request: _models.AddChatParticipantsRequest, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.AddChatParticipantsResult: - """Adds thread participants to a thread. If participants already exist, no change occurs. - - Adds thread participants to a thread. If participants already exist, no change occurs. - - :param chat_thread_id: Id of the thread to add participants to. Required. - :type chat_thread_id: str - :param add_chat_participants_request: Thread participants to be added to the thread. Required. - :type add_chat_participants_request: - ~azure.communication.chat.models.AddChatParticipantsRequest - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :keyword callable cls: A custom type or function that will be passed the direct response - :return: AddChatParticipantsResult or the result of cls(response) - :rtype: ~azure.communication.chat.models.AddChatParticipantsResult - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def add_chat_participants( - self, - chat_thread_id: str, - add_chat_participants_request: IO, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.AddChatParticipantsResult: - """Adds thread participants to a thread. If participants already exist, no change occurs. - - Adds thread participants to a thread. If participants already exist, no change occurs. - - :param chat_thread_id: Id of the thread to add participants to. Required. - :type chat_thread_id: str - :param add_chat_participants_request: Thread participants to be added to the thread. Required. - :type add_chat_participants_request: IO - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :keyword callable cls: A custom type or function that will be passed the direct response - :return: AddChatParticipantsResult or the result of cls(response) - :rtype: ~azure.communication.chat.models.AddChatParticipantsResult - :raises ~azure.core.exceptions.HttpResponseError: - """ + remove_chat_participant.metadata = {'url': '/chat/threads/{chatThreadId}/participants/:remove'} # type: ignore - @distributed_trace_async async def add_chat_participants( self, chat_thread_id: str, - add_chat_participants_request: Union[_models.AddChatParticipantsRequest, IO], + add_chat_participants_request: "_models.AddChatParticipantsRequest", **kwargs: Any - ) -> _models.AddChatParticipantsResult: + ) -> "_models.AddChatParticipantsResult": """Adds thread participants to a thread. If participants already exist, no change occurs. Adds thread participants to a thread. If participants already exist, no change occurs. - :param chat_thread_id: Id of the thread to add participants to. Required. + :param chat_thread_id: Id of the thread to add participants to. :type chat_thread_id: str - :param add_chat_participants_request: Thread participants to be added to the thread. Is either - a model type or a IO type. Required. - :type add_chat_participants_request: - ~azure.communication.chat.models.AddChatParticipantsRequest or IO - :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. - Default value is None. - :paramtype content_type: str + :param add_chat_participants_request: Thread participants to be added to the thread. + :type add_chat_participants_request: ~azure.communication.chat.models.AddChatParticipantsRequest :keyword callable cls: A custom type or function that will be passed the direct response - :return: AddChatParticipantsResult or the result of cls(response) + :return: AddChatParticipantsResult, or the result of cls(response) :rtype: ~azure.communication.chat.models.AddChatParticipantsResult - :raises ~azure.core.exceptions.HttpResponseError: + :raises: ~azure.core.exceptions.HttpResponseError """ + cls = kwargs.pop('cls', None) # type: ClsType["_models.AddChatParticipantsResult"] error_map = { 404: ResourceNotFoundError, 409: ResourceExistsError, - 304: ResourceNotModifiedError, - 401: lambda response: ClientAuthenticationError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 403: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 429: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 503: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), + 401: lambda response: ClientAuthenticationError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 403: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 429: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 503: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.AddChatParticipantsResult] + error_map.update(kwargs.pop('error_map', {})) + api_version = "2021-09-07" + content_type = kwargs.pop("content_type", "application/json") + accept = "application/json" - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(add_chat_participants_request, (IO, bytes)): - _content = add_chat_participants_request - else: - _json = self._serialize.body(add_chat_participants_request, "AddChatParticipantsRequest") - - request = build_add_chat_participants_request( - chat_thread_id=chat_thread_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - template_url=self.add_chat_participants.metadata["url"], - headers=_headers, - params=_params, - ) - request = _convert_request(request) + # Construct URL + url = self.add_chat_participants.metadata['url'] # type: ignore path_format_arguments = { - "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), + 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), + 'chatThreadId': self._serialize.url("chat_thread_id", chat_thread_id, 'str'), } - request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore - - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs - ) - + url = self._client.format_url(url, **path_format_arguments) + + # Construct parameters + query_parameters = {} # type: Dict[str, Any] + query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') + + # Construct headers + header_parameters = {} # type: Dict[str, Any] + header_parameters['Content-Type'] = self._serialize.header("content_type", content_type, 'str') + header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') + + body_content_kwargs = {} # type: Dict[str, Any] + body_content = self._serialize.body(add_chat_participants_request, 'AddChatParticipantsRequest') + body_content_kwargs['content'] = body_content + request = self._client.post(url, query_parameters, header_parameters, **body_content_kwargs) + pipeline_response = await self._client._pipeline.run(request, stream=False, **kwargs) response = pipeline_response.http_response if response.status_code not in [201]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response) - deserialized = self._deserialize("AddChatParticipantsResult", pipeline_response) + deserialized = self._deserialize('AddChatParticipantsResult', pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized + add_chat_participants.metadata = {'url': '/chat/threads/{chatThreadId}/participants/:add'} # type: ignore - add_chat_participants.metadata = {"url": "/chat/threads/{chatThreadId}/participants/:add"} # type: ignore - - @overload - async def update_chat_thread_properties( # pylint: disable=inconsistent-return-statements + async def update_chat_thread_properties( self, chat_thread_id: str, - update_chat_thread_request: _models.UpdateChatThreadRequest, - *, - content_type: str = "application/merge-patch+json", + update_chat_thread_request: "_models.UpdateChatThreadRequest", **kwargs: Any ) -> None: """Updates a thread's properties. Updates a thread's properties. - :param chat_thread_id: The id of the thread to update. Required. + :param chat_thread_id: The id of the thread to update. :type chat_thread_id: str - :param update_chat_thread_request: Request payload for updating a chat thread. Required. + :param update_chat_thread_request: Request payload for updating a chat thread. :type update_chat_thread_request: ~azure.communication.chat.models.UpdateChatThreadRequest - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/merge-patch+json". - :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None or the result of cls(response) + :return: None, or the result of cls(response) :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def update_chat_thread_properties( # pylint: disable=inconsistent-return-statements - self, - chat_thread_id: str, - update_chat_thread_request: IO, - *, - content_type: str = "application/merge-patch+json", - **kwargs: Any - ) -> None: - """Updates a thread's properties. - - Updates a thread's properties. - - :param chat_thread_id: The id of the thread to update. Required. - :type chat_thread_id: str - :param update_chat_thread_request: Request payload for updating a chat thread. Required. - :type update_chat_thread_request: IO - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/merge-patch+json". - :paramtype content_type: str - :keyword callable cls: A custom type or function that will be passed the direct response - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace_async - async def update_chat_thread_properties( # pylint: disable=inconsistent-return-statements - self, chat_thread_id: str, update_chat_thread_request: Union[_models.UpdateChatThreadRequest, IO], **kwargs: Any - ) -> None: - """Updates a thread's properties. - - Updates a thread's properties. - - :param chat_thread_id: The id of the thread to update. Required. - :type chat_thread_id: str - :param update_chat_thread_request: Request payload for updating a chat thread. Is either a - model type or a IO type. Required. - :type update_chat_thread_request: ~azure.communication.chat.models.UpdateChatThreadRequest or - IO - :keyword content_type: Body Parameter content-type. Known values are: - 'application/merge-patch+json'. Default value is None. - :paramtype content_type: str - :keyword callable cls: A custom type or function that will be passed the direct response - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: + :raises: ~azure.core.exceptions.HttpResponseError """ + cls = kwargs.pop('cls', None) # type: ClsType[None] error_map = { 404: ResourceNotFoundError, 409: ResourceExistsError, - 304: ResourceNotModifiedError, - 401: lambda response: ClientAuthenticationError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 403: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 429: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 503: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), + 401: lambda response: ClientAuthenticationError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 403: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 429: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 503: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + error_map.update(kwargs.pop('error_map', {})) + api_version = "2021-09-07" + content_type = kwargs.pop("content_type", "application/merge-patch+json") + accept = "application/json" - api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[None] - - content_type = content_type or "application/merge-patch+json" - _json = None - _content = None - if isinstance(update_chat_thread_request, (IO, bytes)): - _content = update_chat_thread_request - else: - _json = self._serialize.body(update_chat_thread_request, "UpdateChatThreadRequest") - - request = build_update_chat_thread_properties_request( - chat_thread_id=chat_thread_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - template_url=self.update_chat_thread_properties.metadata["url"], - headers=_headers, - params=_params, - ) - request = _convert_request(request) + # Construct URL + url = self.update_chat_thread_properties.metadata['url'] # type: ignore path_format_arguments = { - "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), + 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), + 'chatThreadId': self._serialize.url("chat_thread_id", chat_thread_id, 'str'), } - request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore - - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs - ) - + url = self._client.format_url(url, **path_format_arguments) + + # Construct parameters + query_parameters = {} # type: Dict[str, Any] + query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') + + # Construct headers + header_parameters = {} # type: Dict[str, Any] + header_parameters['Content-Type'] = self._serialize.header("content_type", content_type, 'str') + header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') + + body_content_kwargs = {} # type: Dict[str, Any] + body_content = self._serialize.body(update_chat_thread_request, 'UpdateChatThreadRequest') + body_content_kwargs['content'] = body_content + request = self._client.patch(url, query_parameters, header_parameters, **body_content_kwargs) + pipeline_response = await self._client._pipeline.run(request, stream=False, **kwargs) response = pipeline_response.http_response if response.status_code not in [204]: @@ -1421,216 +850,127 @@ async def update_chat_thread_properties( # pylint: disable=inconsistent-return- if cls: return cls(pipeline_response, None, {}) - update_chat_thread_properties.metadata = {"url": "/chat/threads/{chatThreadId}"} # type: ignore + update_chat_thread_properties.metadata = {'url': '/chat/threads/{chatThreadId}'} # type: ignore - @distributed_trace_async - async def get_chat_thread_properties(self, chat_thread_id: str, **kwargs: Any) -> _models.ChatThreadProperties: + async def get_chat_thread_properties( + self, + chat_thread_id: str, + **kwargs: Any + ) -> "_models.ChatThreadProperties": """Gets a chat thread's properties. Gets a chat thread's properties. - :param chat_thread_id: Id of the thread. Required. + :param chat_thread_id: Id of the thread. :type chat_thread_id: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: ChatThreadProperties or the result of cls(response) + :return: ChatThreadProperties, or the result of cls(response) :rtype: ~azure.communication.chat.models.ChatThreadProperties - :raises ~azure.core.exceptions.HttpResponseError: + :raises: ~azure.core.exceptions.HttpResponseError """ + cls = kwargs.pop('cls', None) # type: ClsType["_models.ChatThreadProperties"] error_map = { 404: ResourceNotFoundError, 409: ResourceExistsError, - 304: ResourceNotModifiedError, - 401: lambda response: ClientAuthenticationError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 403: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 429: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 503: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), + 401: lambda response: ClientAuthenticationError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 403: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 429: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 503: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), } - error_map.update(kwargs.pop("error_map", {}) or {}) + error_map.update(kwargs.pop('error_map', {})) + api_version = "2021-09-07" + accept = "application/json" - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str - cls = kwargs.pop("cls", None) # type: ClsType[_models.ChatThreadProperties] - - request = build_get_chat_thread_properties_request( - chat_thread_id=chat_thread_id, - api_version=api_version, - template_url=self.get_chat_thread_properties.metadata["url"], - headers=_headers, - params=_params, - ) - request = _convert_request(request) + # Construct URL + url = self.get_chat_thread_properties.metadata['url'] # type: ignore path_format_arguments = { - "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), + 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), + 'chatThreadId': self._serialize.url("chat_thread_id", chat_thread_id, 'str'), } - request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore + url = self._client.format_url(url, **path_format_arguments) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs - ) + # Construct parameters + query_parameters = {} # type: Dict[str, Any] + query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') + # Construct headers + header_parameters = {} # type: Dict[str, Any] + header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') + + request = self._client.get(url, query_parameters, header_parameters) + pipeline_response = await self._client._pipeline.run(request, stream=False, **kwargs) response = pipeline_response.http_response if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response) - deserialized = self._deserialize("ChatThreadProperties", pipeline_response) + deserialized = self._deserialize('ChatThreadProperties', pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized + get_chat_thread_properties.metadata = {'url': '/chat/threads/{chatThreadId}'} # type: ignore - get_chat_thread_properties.metadata = {"url": "/chat/threads/{chatThreadId}"} # type: ignore - - @overload - async def send_typing_notification( # pylint: disable=inconsistent-return-statements - self, - chat_thread_id: str, - send_typing_notification_request: Optional[_models.SendTypingNotificationRequest] = None, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> None: - """Posts a typing event to a thread, on behalf of a user. - - Posts a typing event to a thread, on behalf of a user. - - :param chat_thread_id: Id of the thread. Required. - :type chat_thread_id: str - :param send_typing_notification_request: Details of the typing notification request. Default - value is None. - :type send_typing_notification_request: - ~azure.communication.chat.models.SendTypingNotificationRequest - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :keyword callable cls: A custom type or function that will be passed the direct response - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def send_typing_notification( # pylint: disable=inconsistent-return-statements - self, - chat_thread_id: str, - send_typing_notification_request: Optional[IO] = None, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> None: - """Posts a typing event to a thread, on behalf of a user. - - Posts a typing event to a thread, on behalf of a user. - - :param chat_thread_id: Id of the thread. Required. - :type chat_thread_id: str - :param send_typing_notification_request: Details of the typing notification request. Default - value is None. - :type send_typing_notification_request: IO - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Known values are: 'application/json', 'application/merge-patch+json'. Default value is - "application/json". - :paramtype content_type: str - :keyword callable cls: A custom type or function that will be passed the direct response - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace_async - async def send_typing_notification( # pylint: disable=inconsistent-return-statements + async def send_typing_notification( self, chat_thread_id: str, - send_typing_notification_request: Optional[Union[_models.SendTypingNotificationRequest, IO]] = None, + send_typing_notification_request: Optional["_models.SendTypingNotificationRequest"] = None, **kwargs: Any ) -> None: """Posts a typing event to a thread, on behalf of a user. Posts a typing event to a thread, on behalf of a user. - :param chat_thread_id: Id of the thread. Required. + :param chat_thread_id: Id of the thread. :type chat_thread_id: str - :param send_typing_notification_request: Details of the typing notification request. Is either - a model type or a IO type. Default value is None. - :type send_typing_notification_request: - ~azure.communication.chat.models.SendTypingNotificationRequest or IO - :keyword content_type: Body Parameter content-type. Known values are: 'application/json', - 'application/merge-patch+json'. Default value is None. - :paramtype content_type: str + :param send_typing_notification_request: Details of the typing notification request. + :type send_typing_notification_request: ~azure.communication.chat.models.SendTypingNotificationRequest :keyword callable cls: A custom type or function that will be passed the direct response - :return: None or the result of cls(response) + :return: None, or the result of cls(response) :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: + :raises: ~azure.core.exceptions.HttpResponseError """ + cls = kwargs.pop('cls', None) # type: ClsType[None] error_map = { 404: ResourceNotFoundError, 409: ResourceExistsError, - 304: ResourceNotModifiedError, - 401: lambda response: ClientAuthenticationError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 403: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 429: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 503: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), + 401: lambda response: ClientAuthenticationError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 403: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 429: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 503: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[None] + error_map.update(kwargs.pop('error_map', {})) + api_version = "2021-09-07" + content_type = kwargs.pop("content_type", "application/json") + accept = "application/json" - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(send_typing_notification_request, (IO, bytes)): - _content = send_typing_notification_request - else: - if send_typing_notification_request is not None: - _json = self._serialize.body(send_typing_notification_request, "SendTypingNotificationRequest") - else: - _json = None - - request = build_send_typing_notification_request( - chat_thread_id=chat_thread_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - template_url=self.send_typing_notification.metadata["url"], - headers=_headers, - params=_params, - ) - request = _convert_request(request) + # Construct URL + url = self.send_typing_notification.metadata['url'] # type: ignore path_format_arguments = { - "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), + 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), + 'chatThreadId': self._serialize.url("chat_thread_id", chat_thread_id, 'str'), } - request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore + url = self._client.format_url(url, **path_format_arguments) - pipeline_response = await self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs - ) + # Construct parameters + query_parameters = {} # type: Dict[str, Any] + query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') + # Construct headers + header_parameters = {} # type: Dict[str, Any] + header_parameters['Content-Type'] = self._serialize.header("content_type", content_type, 'str') + header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') + + body_content_kwargs = {} # type: Dict[str, Any] + if send_typing_notification_request is not None: + body_content = self._serialize.body(send_typing_notification_request, 'SendTypingNotificationRequest') + else: + body_content = None + body_content_kwargs['content'] = body_content + request = self._client.post(url, query_parameters, header_parameters, **body_content_kwargs) + pipeline_response = await self._client._pipeline.run(request, stream=False, **kwargs) response = pipeline_response.http_response if response.status_code not in [200]: @@ -1640,4 +980,4 @@ async def send_typing_notification( # pylint: disable=inconsistent-return-state if cls: return cls(pipeline_response, None, {}) - send_typing_notification.metadata = {"url": "/chat/threads/{chatThreadId}/typing"} # type: ignore + send_typing_notification.metadata = {'url': '/chat/threads/{chatThreadId}/typing'} # type: ignore diff --git a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/models/__init__.py b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/models/__init__.py index 9ed9d984c521..f7749b38d83e 100644 --- a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/models/__init__.py +++ b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/models/__init__.py @@ -6,68 +6,93 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from ._models_py3 import AddChatParticipantsRequest -from ._models_py3 import AddChatParticipantsResult -from ._models_py3 import ChatError -from ._models_py3 import ChatMessage -from ._models_py3 import ChatMessageContent -from ._models_py3 import ChatMessageReadReceipt -from ._models_py3 import ChatMessageReadReceiptsCollection -from ._models_py3 import ChatMessagesCollection -from ._models_py3 import ChatParticipant -from ._models_py3 import ChatParticipantsCollection -from ._models_py3 import ChatThreadItem -from ._models_py3 import ChatThreadProperties -from ._models_py3 import ChatThreadsItemCollection -from ._models_py3 import CommunicationErrorResponse -from ._models_py3 import CommunicationIdentifierModel -from ._models_py3 import CommunicationUserIdentifierModel -from ._models_py3 import CreateChatThreadRequest -from ._models_py3 import CreateChatThreadResult -from ._models_py3 import MicrosoftTeamsUserIdentifierModel -from ._models_py3 import PhoneNumberIdentifierModel -from ._models_py3 import SendChatMessageRequest -from ._models_py3 import SendChatMessageResult -from ._models_py3 import SendReadReceiptRequest -from ._models_py3 import SendTypingNotificationRequest -from ._models_py3 import UpdateChatMessageRequest -from ._models_py3 import UpdateChatThreadRequest +try: + from ._models_py3 import AddChatParticipantsRequest + from ._models_py3 import AddChatParticipantsResult + from ._models_py3 import ChatError + from ._models_py3 import ChatMessage + from ._models_py3 import ChatMessageContent + from ._models_py3 import ChatMessageReadReceipt + from ._models_py3 import ChatMessageReadReceiptsCollection + from ._models_py3 import ChatMessagesCollection + from ._models_py3 import ChatParticipant + from ._models_py3 import ChatParticipantsCollection + from ._models_py3 import ChatThreadItem + from ._models_py3 import ChatThreadProperties + from ._models_py3 import ChatThreadsItemCollection + from ._models_py3 import CommunicationErrorResponse + from ._models_py3 import CommunicationIdentifierModel + from ._models_py3 import CommunicationUserIdentifierModel + from ._models_py3 import CreateChatThreadRequest + from ._models_py3 import CreateChatThreadResult + from ._models_py3 import MicrosoftTeamsUserIdentifierModel + from ._models_py3 import PhoneNumberIdentifierModel + from ._models_py3 import SendChatMessageRequest + from ._models_py3 import SendChatMessageResult + from ._models_py3 import SendReadReceiptRequest + from ._models_py3 import SendTypingNotificationRequest + from ._models_py3 import UpdateChatMessageRequest + from ._models_py3 import UpdateChatThreadRequest +except (SyntaxError, ImportError): + from ._models import AddChatParticipantsRequest # type: ignore + from ._models import AddChatParticipantsResult # type: ignore + from ._models import ChatError # type: ignore + from ._models import ChatMessage # type: ignore + from ._models import ChatMessageContent # type: ignore + from ._models import ChatMessageReadReceipt # type: ignore + from ._models import ChatMessageReadReceiptsCollection # type: ignore + from ._models import ChatMessagesCollection # type: ignore + from ._models import ChatParticipant # type: ignore + from ._models import ChatParticipantsCollection # type: ignore + from ._models import ChatThreadItem # type: ignore + from ._models import ChatThreadProperties # type: ignore + from ._models import ChatThreadsItemCollection # type: ignore + from ._models import CommunicationErrorResponse # type: ignore + from ._models import CommunicationIdentifierModel # type: ignore + from ._models import CommunicationUserIdentifierModel # type: ignore + from ._models import CreateChatThreadRequest # type: ignore + from ._models import CreateChatThreadResult # type: ignore + from ._models import MicrosoftTeamsUserIdentifierModel # type: ignore + from ._models import PhoneNumberIdentifierModel # type: ignore + from ._models import SendChatMessageRequest # type: ignore + from ._models import SendChatMessageResult # type: ignore + from ._models import SendReadReceiptRequest # type: ignore + from ._models import SendTypingNotificationRequest # type: ignore + from ._models import UpdateChatMessageRequest # type: ignore + from ._models import UpdateChatThreadRequest # type: ignore -from ._azure_communication_chat_service_enums import ChatMessageType -from ._azure_communication_chat_service_enums import CommunicationCloudEnvironmentModel -from ._patch import __all__ as _patch_all -from ._patch import * # type: ignore # pylint: disable=unused-wildcard-import -from ._patch import patch_sdk as _patch_sdk +from ._azure_communication_chat_service_enums import ( + ChatMessageType, + CommunicationCloudEnvironmentModel, +) __all__ = [ - "AddChatParticipantsRequest", - "AddChatParticipantsResult", - "ChatError", - "ChatMessage", - "ChatMessageContent", - "ChatMessageReadReceipt", - "ChatMessageReadReceiptsCollection", - "ChatMessagesCollection", - "ChatParticipant", - "ChatParticipantsCollection", - "ChatThreadItem", - "ChatThreadProperties", - "ChatThreadsItemCollection", - "CommunicationErrorResponse", - "CommunicationIdentifierModel", - "CommunicationUserIdentifierModel", - "CreateChatThreadRequest", - "CreateChatThreadResult", - "MicrosoftTeamsUserIdentifierModel", - "PhoneNumberIdentifierModel", - "SendChatMessageRequest", - "SendChatMessageResult", - "SendReadReceiptRequest", - "SendTypingNotificationRequest", - "UpdateChatMessageRequest", - "UpdateChatThreadRequest", - "ChatMessageType", - "CommunicationCloudEnvironmentModel", + 'AddChatParticipantsRequest', + 'AddChatParticipantsResult', + 'ChatError', + 'ChatMessage', + 'ChatMessageContent', + 'ChatMessageReadReceipt', + 'ChatMessageReadReceiptsCollection', + 'ChatMessagesCollection', + 'ChatParticipant', + 'ChatParticipantsCollection', + 'ChatThreadItem', + 'ChatThreadProperties', + 'ChatThreadsItemCollection', + 'CommunicationErrorResponse', + 'CommunicationIdentifierModel', + 'CommunicationUserIdentifierModel', + 'CreateChatThreadRequest', + 'CreateChatThreadResult', + 'MicrosoftTeamsUserIdentifierModel', + 'PhoneNumberIdentifierModel', + 'SendChatMessageRequest', + 'SendChatMessageResult', + 'SendReadReceiptRequest', + 'SendTypingNotificationRequest', + 'UpdateChatMessageRequest', + 'UpdateChatThreadRequest', + 'ChatMessageType', + 'CommunicationCloudEnvironmentModel', ] -__all__.extend([p for p in _patch_all if p not in __all__]) -_patch_sdk() diff --git a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/models/_azure_communication_chat_service_enums.py b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/models/_azure_communication_chat_service_enums.py index 1413d4e6d606..0a32c53074ba 100644 --- a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/models/_azure_communication_chat_service_enums.py +++ b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/models/_azure_communication_chat_service_enums.py @@ -6,12 +6,29 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from enum import Enum -from azure.core import CaseInsensitiveEnumMeta +from enum import Enum, EnumMeta +from six import with_metaclass +class _CaseInsensitiveEnumMeta(EnumMeta): + def __getitem__(self, name): + return super().__getitem__(name.upper()) -class ChatMessageType(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The chat message type.""" + def __getattr__(cls, name): + """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. + """ + try: + return cls._member_map_[name.upper()] + except KeyError: + raise AttributeError(name) + + +class ChatMessageType(with_metaclass(_CaseInsensitiveEnumMeta, str, Enum)): + """The chat message type. + """ TEXT = "text" HTML = "html" @@ -19,9 +36,9 @@ class ChatMessageType(str, Enum, metaclass=CaseInsensitiveEnumMeta): PARTICIPANT_ADDED = "participantAdded" PARTICIPANT_REMOVED = "participantRemoved" - -class CommunicationCloudEnvironmentModel(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """The cloud that the identifier belongs to.""" +class CommunicationCloudEnvironmentModel(with_metaclass(_CaseInsensitiveEnumMeta, str, Enum)): + """The cloud that the identifier belongs to. + """ PUBLIC = "public" DOD = "dod" diff --git a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/models/_models.py b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/models/_models.py new file mode 100644 index 000000000000..2e1e946d3b86 --- /dev/null +++ b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/models/_models.py @@ -0,0 +1,875 @@ +# 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 azure.core.exceptions import HttpResponseError +import msrest.serialization + + +class AddChatParticipantsRequest(msrest.serialization.Model): + """Participants to be added to the thread. + + All required parameters must be populated in order to send to Azure. + + :param participants: Required. Participants to add to a chat thread. + :type participants: list[~azure.communication.chat.models.ChatParticipant] + """ + + _validation = { + 'participants': {'required': True}, + } + + _attribute_map = { + 'participants': {'key': 'participants', 'type': '[ChatParticipant]'}, + } + + def __init__( + self, + **kwargs + ): + super(AddChatParticipantsRequest, self).__init__(**kwargs) + self.participants = kwargs['participants'] + + +class AddChatParticipantsResult(msrest.serialization.Model): + """Result of the add chat participants operation. + + Variables are only populated by the server, and will be ignored when sending a request. + + :ivar invalid_participants: The participants that failed to be added to the chat thread. + :vartype invalid_participants: list[~azure.communication.chat.models.ChatError] + """ + + _validation = { + 'invalid_participants': {'readonly': True}, + } + + _attribute_map = { + 'invalid_participants': {'key': 'invalidParticipants', 'type': '[ChatError]'}, + } + + def __init__( + self, + **kwargs + ): + super(AddChatParticipantsResult, self).__init__(**kwargs) + self.invalid_participants = None + + +class ChatError(msrest.serialization.Model): + """The Communication Services error. + + Variables are only populated by the server, and will be ignored when sending a request. + + All required parameters must be populated in order to send to Azure. + + :param code: Required. The error code. + :type code: str + :param message: Required. The error message. + :type message: str + :ivar target: The error target. + :vartype target: str + :ivar details: Further details about specific errors that led to this error. + :vartype details: list[~azure.communication.chat.models.ChatError] + :ivar inner_error: The inner error if any. + :vartype inner_error: ~azure.communication.chat.models.ChatError + """ + + _validation = { + 'code': {'required': True}, + 'message': {'required': True}, + 'target': {'readonly': True}, + 'details': {'readonly': True}, + 'inner_error': {'readonly': True}, + } + + _attribute_map = { + 'code': {'key': 'code', 'type': 'str'}, + 'message': {'key': 'message', 'type': 'str'}, + 'target': {'key': 'target', 'type': 'str'}, + 'details': {'key': 'details', 'type': '[ChatError]'}, + 'inner_error': {'key': 'innererror', 'type': 'ChatError'}, + } + + def __init__( + self, + **kwargs + ): + super(ChatError, self).__init__(**kwargs) + self.code = kwargs['code'] + self.message = kwargs['message'] + self.target = None + self.details = None + self.inner_error = None + + +class ChatMessage(msrest.serialization.Model): + """Chat message. + + All required parameters must be populated in order to send to Azure. + + :param id: Required. The id of the chat message. This id is server generated. + :type id: str + :param type: Required. The chat message type. Possible values include: "text", "html", + "topicUpdated", "participantAdded", "participantRemoved". + :type type: str or ~azure.communication.chat.models.ChatMessageType + :param sequence_id: Required. Sequence of the chat message in the conversation. + :type sequence_id: str + :param version: Required. Version of the chat message. + :type version: str + :param content: Content of a chat message. + :type content: ~azure.communication.chat.models.ChatMessageContent + :param sender_display_name: The display name of the chat message sender. This property is used + to populate sender name for push notifications. + :type sender_display_name: str + :param created_on: Required. The timestamp when the chat message arrived at the server. The + timestamp is in RFC3339 format: ``yyyy-MM-ddTHH:mm:ssZ``. + :type created_on: ~datetime.datetime + :param sender_communication_identifier: Identifies a participant in Azure Communication + services. A participant is, for example, a phone number or an Azure communication user. This + model must be interpreted as a union: Apart from rawId, at most one further property may be + set. + :type sender_communication_identifier: + ~azure.communication.chat.models.CommunicationIdentifierModel + :param deleted_on: The timestamp (if applicable) when the message was deleted. The timestamp is + in RFC3339 format: ``yyyy-MM-ddTHH:mm:ssZ``. + :type deleted_on: ~datetime.datetime + :param edited_on: The last timestamp (if applicable) when the message was edited. The timestamp + is in RFC3339 format: ``yyyy-MM-ddTHH:mm:ssZ``. + :type edited_on: ~datetime.datetime + :param metadata: Message metadata. + :type metadata: dict[str, str] + """ + + _validation = { + 'id': {'required': True}, + 'type': {'required': True}, + 'sequence_id': {'required': True}, + 'version': {'required': True}, + 'created_on': {'required': True}, + } + + _attribute_map = { + 'id': {'key': 'id', 'type': 'str'}, + 'type': {'key': 'type', 'type': 'str'}, + 'sequence_id': {'key': 'sequenceId', 'type': 'str'}, + 'version': {'key': 'version', 'type': 'str'}, + 'content': {'key': 'content', 'type': 'ChatMessageContent'}, + 'sender_display_name': {'key': 'senderDisplayName', 'type': 'str'}, + 'created_on': {'key': 'createdOn', 'type': 'iso-8601'}, + 'sender_communication_identifier': {'key': 'senderCommunicationIdentifier', 'type': 'CommunicationIdentifierModel'}, + 'deleted_on': {'key': 'deletedOn', 'type': 'iso-8601'}, + 'edited_on': {'key': 'editedOn', 'type': 'iso-8601'}, + 'metadata': {'key': 'metadata', 'type': '{str}'}, + } + + def __init__( + self, + **kwargs + ): + super(ChatMessage, self).__init__(**kwargs) + self.id = kwargs['id'] + self.type = kwargs['type'] + self.sequence_id = kwargs['sequence_id'] + self.version = kwargs['version'] + self.content = kwargs.get('content', None) + self.sender_display_name = kwargs.get('sender_display_name', None) + self.created_on = kwargs['created_on'] + self.sender_communication_identifier = kwargs.get('sender_communication_identifier', None) + self.deleted_on = kwargs.get('deleted_on', None) + self.edited_on = kwargs.get('edited_on', None) + self.metadata = kwargs.get('metadata', None) + + +class ChatMessageContent(msrest.serialization.Model): + """Content of a chat message. + + :param message: Chat message content for messages of types text or html. + :type message: str + :param topic: Chat message content for messages of type topicUpdated. + :type topic: str + :param participants: Chat message content for messages of types participantAdded or + participantRemoved. + :type participants: list[~azure.communication.chat.models.ChatParticipant] + :param initiator_communication_identifier: Identifies a participant in Azure Communication + services. A participant is, for example, a phone number or an Azure communication user. This + model must be interpreted as a union: Apart from rawId, at most one further property may be + set. + :type initiator_communication_identifier: + ~azure.communication.chat.models.CommunicationIdentifierModel + """ + + _attribute_map = { + 'message': {'key': 'message', 'type': 'str'}, + 'topic': {'key': 'topic', 'type': 'str'}, + 'participants': {'key': 'participants', 'type': '[ChatParticipant]'}, + 'initiator_communication_identifier': {'key': 'initiatorCommunicationIdentifier', 'type': 'CommunicationIdentifierModel'}, + } + + def __init__( + self, + **kwargs + ): + super(ChatMessageContent, self).__init__(**kwargs) + self.message = kwargs.get('message', None) + self.topic = kwargs.get('topic', None) + self.participants = kwargs.get('participants', None) + self.initiator_communication_identifier = kwargs.get('initiator_communication_identifier', None) + + +class ChatMessageReadReceipt(msrest.serialization.Model): + """A chat message read receipt indicates the time a chat message was read by a recipient. + + All required parameters must be populated in order to send to Azure. + + :param sender_communication_identifier: Required. Identifies a participant in Azure + Communication services. A participant is, for example, a phone number or an Azure communication + user. This model must be interpreted as a union: Apart from rawId, at most one further property + may be set. + :type sender_communication_identifier: + ~azure.communication.chat.models.CommunicationIdentifierModel + :param chat_message_id: Required. Id of the chat message that has been read. This id is + generated by the server. + :type chat_message_id: str + :param read_on: Required. The time at which the message was read. The timestamp is in RFC3339 + format: ``yyyy-MM-ddTHH:mm:ssZ``. + :type read_on: ~datetime.datetime + """ + + _validation = { + 'sender_communication_identifier': {'required': True}, + 'chat_message_id': {'required': True}, + 'read_on': {'required': True}, + } + + _attribute_map = { + 'sender_communication_identifier': {'key': 'senderCommunicationIdentifier', 'type': 'CommunicationIdentifierModel'}, + 'chat_message_id': {'key': 'chatMessageId', 'type': 'str'}, + 'read_on': {'key': 'readOn', 'type': 'iso-8601'}, + } + + def __init__( + self, + **kwargs + ): + super(ChatMessageReadReceipt, self).__init__(**kwargs) + self.sender_communication_identifier = kwargs['sender_communication_identifier'] + self.chat_message_id = kwargs['chat_message_id'] + self.read_on = kwargs['read_on'] + + +class ChatMessageReadReceiptsCollection(msrest.serialization.Model): + """A paged collection of chat message read receipts. + + Variables are only populated by the server, and will be ignored when sending a request. + + All required parameters must be populated in order to send to Azure. + + :param value: Required. Collection of chat message read receipts. + :type value: list[~azure.communication.chat.models.ChatMessageReadReceipt] + :ivar next_link: If there are more chat message read receipts that can be retrieved, the next + link will be populated. + :vartype next_link: str + """ + + _validation = { + 'value': {'required': True}, + 'next_link': {'readonly': True}, + } + + _attribute_map = { + 'value': {'key': 'value', 'type': '[ChatMessageReadReceipt]'}, + 'next_link': {'key': 'nextLink', 'type': 'str'}, + } + + def __init__( + self, + **kwargs + ): + super(ChatMessageReadReceiptsCollection, self).__init__(**kwargs) + self.value = kwargs['value'] + self.next_link = None + + +class ChatMessagesCollection(msrest.serialization.Model): + """Collection of chat messages for a particular chat thread. + + Variables are only populated by the server, and will be ignored when sending a request. + + All required parameters must be populated in order to send to Azure. + + :param value: Required. Collection of chat messages. + :type value: list[~azure.communication.chat.models.ChatMessage] + :ivar next_link: If there are more chat messages that can be retrieved, the next link will be + populated. + :vartype next_link: str + """ + + _validation = { + 'value': {'required': True}, + 'next_link': {'readonly': True}, + } + + _attribute_map = { + 'value': {'key': 'value', 'type': '[ChatMessage]'}, + 'next_link': {'key': 'nextLink', 'type': 'str'}, + } + + def __init__( + self, + **kwargs + ): + super(ChatMessagesCollection, self).__init__(**kwargs) + self.value = kwargs['value'] + self.next_link = None + + +class ChatParticipant(msrest.serialization.Model): + """A participant of the chat thread. + + All required parameters must be populated in order to send to Azure. + + :param communication_identifier: Required. Identifies a participant in Azure Communication + services. A participant is, for example, a phone number or an Azure communication user. This + model must be interpreted as a union: Apart from rawId, at most one further property may be + set. + :type communication_identifier: ~azure.communication.chat.models.CommunicationIdentifierModel + :param display_name: Display name for the chat participant. + :type display_name: str + :param share_history_time: Time from which the chat history is shared with the participant. The + timestamp is in RFC3339 format: ``yyyy-MM-ddTHH:mm:ssZ``. + :type share_history_time: ~datetime.datetime + """ + + _validation = { + 'communication_identifier': {'required': True}, + } + + _attribute_map = { + 'communication_identifier': {'key': 'communicationIdentifier', 'type': 'CommunicationIdentifierModel'}, + 'display_name': {'key': 'displayName', 'type': 'str'}, + 'share_history_time': {'key': 'shareHistoryTime', 'type': 'iso-8601'}, + } + + def __init__( + self, + **kwargs + ): + super(ChatParticipant, self).__init__(**kwargs) + self.communication_identifier = kwargs['communication_identifier'] + self.display_name = kwargs.get('display_name', None) + self.share_history_time = kwargs.get('share_history_time', None) + + +class ChatParticipantsCollection(msrest.serialization.Model): + """Collection of participants belong to a particular thread. + + Variables are only populated by the server, and will be ignored when sending a request. + + All required parameters must be populated in order to send to Azure. + + :param value: Required. Chat participants. + :type value: list[~azure.communication.chat.models.ChatParticipant] + :ivar next_link: If there are more chat participants that can be retrieved, the next link will + be populated. + :vartype next_link: str + """ + + _validation = { + 'value': {'required': True}, + 'next_link': {'readonly': True}, + } + + _attribute_map = { + 'value': {'key': 'value', 'type': '[ChatParticipant]'}, + 'next_link': {'key': 'nextLink', 'type': 'str'}, + } + + def __init__( + self, + **kwargs + ): + super(ChatParticipantsCollection, self).__init__(**kwargs) + self.value = kwargs['value'] + self.next_link = None + + +class ChatThreadItem(msrest.serialization.Model): + """Summary information of a chat thread. + + Variables are only populated by the server, and will be ignored when sending a request. + + All required parameters must be populated in order to send to Azure. + + :param id: Required. Chat thread id. + :type id: str + :param topic: Required. Chat thread topic. + :type topic: str + :param deleted_on: The timestamp when the chat thread was deleted. The timestamp is in RFC3339 + format: ``yyyy-MM-ddTHH:mm:ssZ``. + :type deleted_on: ~datetime.datetime + :ivar last_message_received_on: The timestamp when the last message arrived at the server. The + timestamp is in RFC3339 format: ``yyyy-MM-ddTHH:mm:ssZ``. + :vartype last_message_received_on: ~datetime.datetime + """ + + _validation = { + 'id': {'required': True}, + 'topic': {'required': True}, + 'last_message_received_on': {'readonly': True}, + } + + _attribute_map = { + 'id': {'key': 'id', 'type': 'str'}, + 'topic': {'key': 'topic', 'type': 'str'}, + 'deleted_on': {'key': 'deletedOn', 'type': 'iso-8601'}, + 'last_message_received_on': {'key': 'lastMessageReceivedOn', 'type': 'iso-8601'}, + } + + def __init__( + self, + **kwargs + ): + super(ChatThreadItem, self).__init__(**kwargs) + self.id = kwargs['id'] + self.topic = kwargs['topic'] + self.deleted_on = kwargs.get('deleted_on', None) + self.last_message_received_on = None + + +class ChatThreadProperties(msrest.serialization.Model): + """Chat thread. + + All required parameters must be populated in order to send to Azure. + + :param id: Required. Chat thread id. + :type id: str + :param topic: Required. Chat thread topic. + :type topic: str + :param created_on: Required. The timestamp when the chat thread was created. The timestamp is + in RFC3339 format: ``yyyy-MM-ddTHH:mm:ssZ``. + :type created_on: ~datetime.datetime + :param created_by_communication_identifier: Required. Identifies a participant in Azure + Communication services. A participant is, for example, a phone number or an Azure communication + user. This model must be interpreted as a union: Apart from rawId, at most one further property + may be set. + :type created_by_communication_identifier: + ~azure.communication.chat.models.CommunicationIdentifierModel + :param deleted_on: The timestamp when the chat thread was deleted. The timestamp is in RFC3339 + format: ``yyyy-MM-ddTHH:mm:ssZ``. + :type deleted_on: ~datetime.datetime + """ + + _validation = { + 'id': {'required': True}, + 'topic': {'required': True}, + 'created_on': {'required': True}, + 'created_by_communication_identifier': {'required': True}, + } + + _attribute_map = { + 'id': {'key': 'id', 'type': 'str'}, + 'topic': {'key': 'topic', 'type': 'str'}, + 'created_on': {'key': 'createdOn', 'type': 'iso-8601'}, + 'created_by_communication_identifier': {'key': 'createdByCommunicationIdentifier', 'type': 'CommunicationIdentifierModel'}, + 'deleted_on': {'key': 'deletedOn', 'type': 'iso-8601'}, + } + + def __init__( + self, + **kwargs + ): + super(ChatThreadProperties, self).__init__(**kwargs) + self.id = kwargs['id'] + self.topic = kwargs['topic'] + self.created_on = kwargs['created_on'] + self.created_by_communication_identifier = kwargs['created_by_communication_identifier'] + self.deleted_on = kwargs.get('deleted_on', None) + + +class ChatThreadsItemCollection(msrest.serialization.Model): + """Collection of chat threads. + + Variables are only populated by the server, and will be ignored when sending a request. + + All required parameters must be populated in order to send to Azure. + + :param value: Required. Collection of chat threads. + :type value: list[~azure.communication.chat.models.ChatThreadItem] + :ivar next_link: If there are more chat threads that can be retrieved, the next link will be + populated. + :vartype next_link: str + """ + + _validation = { + 'value': {'required': True}, + 'next_link': {'readonly': True}, + } + + _attribute_map = { + 'value': {'key': 'value', 'type': '[ChatThreadItem]'}, + 'next_link': {'key': 'nextLink', 'type': 'str'}, + } + + def __init__( + self, + **kwargs + ): + super(ChatThreadsItemCollection, self).__init__(**kwargs) + self.value = kwargs['value'] + self.next_link = None + + +class CommunicationErrorResponse(msrest.serialization.Model): + """The Communication Services error. + + All required parameters must be populated in order to send to Azure. + + :param error: Required. The Communication Services error. + :type error: ~azure.communication.chat.models.ChatError + """ + + _validation = { + 'error': {'required': True}, + } + + _attribute_map = { + 'error': {'key': 'error', 'type': 'ChatError'}, + } + + def __init__( + self, + **kwargs + ): + super(CommunicationErrorResponse, self).__init__(**kwargs) + self.error = kwargs['error'] + + +class CommunicationIdentifierModel(msrest.serialization.Model): + """Identifies a participant in Azure Communication services. A participant is, for example, a phone number or an Azure communication user. This model must be interpreted as a union: Apart from rawId, at most one further property may be set. + + :param raw_id: Raw Id of the identifier. Optional in requests, required in responses. + :type raw_id: str + :param communication_user: The communication user. + :type communication_user: ~azure.communication.chat.models.CommunicationUserIdentifierModel + :param phone_number: The phone number. + :type phone_number: ~azure.communication.chat.models.PhoneNumberIdentifierModel + :param microsoft_teams_user: The Microsoft Teams user. + :type microsoft_teams_user: ~azure.communication.chat.models.MicrosoftTeamsUserIdentifierModel + """ + + _attribute_map = { + 'raw_id': {'key': 'rawId', 'type': 'str'}, + 'communication_user': {'key': 'communicationUser', 'type': 'CommunicationUserIdentifierModel'}, + 'phone_number': {'key': 'phoneNumber', 'type': 'PhoneNumberIdentifierModel'}, + 'microsoft_teams_user': {'key': 'microsoftTeamsUser', 'type': 'MicrosoftTeamsUserIdentifierModel'}, + } + + def __init__( + self, + **kwargs + ): + super(CommunicationIdentifierModel, self).__init__(**kwargs) + self.raw_id = kwargs.get('raw_id', None) + self.communication_user = kwargs.get('communication_user', None) + self.phone_number = kwargs.get('phone_number', None) + self.microsoft_teams_user = kwargs.get('microsoft_teams_user', None) + + +class CommunicationUserIdentifierModel(msrest.serialization.Model): + """A user that got created with an Azure Communication Services resource. + + All required parameters must be populated in order to send to Azure. + + :param id: Required. The Id of the communication user. + :type id: str + """ + + _validation = { + 'id': {'required': True}, + } + + _attribute_map = { + 'id': {'key': 'id', 'type': 'str'}, + } + + def __init__( + self, + **kwargs + ): + super(CommunicationUserIdentifierModel, self).__init__(**kwargs) + self.id = kwargs['id'] + + +class CreateChatThreadRequest(msrest.serialization.Model): + """Request payload for creating a chat thread. + + All required parameters must be populated in order to send to Azure. + + :param topic: Required. The chat thread topic. + :type topic: str + :param participants: Participants to be added to the chat thread. + :type participants: list[~azure.communication.chat.models.ChatParticipant] + """ + + _validation = { + 'topic': {'required': True}, + } + + _attribute_map = { + 'topic': {'key': 'topic', 'type': 'str'}, + 'participants': {'key': 'participants', 'type': '[ChatParticipant]'}, + } + + def __init__( + self, + **kwargs + ): + super(CreateChatThreadRequest, self).__init__(**kwargs) + self.topic = kwargs['topic'] + self.participants = kwargs.get('participants', None) + + +class CreateChatThreadResult(msrest.serialization.Model): + """Result of the create chat thread operation. + + Variables are only populated by the server, and will be ignored when sending a request. + + :param chat_thread: Chat thread. + :type chat_thread: ~azure.communication.chat.models.ChatThreadProperties + :ivar invalid_participants: The participants that failed to be added to the chat thread. + :vartype invalid_participants: list[~azure.communication.chat.models.ChatError] + """ + + _validation = { + 'invalid_participants': {'readonly': True}, + } + + _attribute_map = { + 'chat_thread': {'key': 'chatThread', 'type': 'ChatThreadProperties'}, + 'invalid_participants': {'key': 'invalidParticipants', 'type': '[ChatError]'}, + } + + def __init__( + self, + **kwargs + ): + super(CreateChatThreadResult, self).__init__(**kwargs) + self.chat_thread = kwargs.get('chat_thread', None) + self.invalid_participants = None + + +class MicrosoftTeamsUserIdentifierModel(msrest.serialization.Model): + """A Microsoft Teams user. + + All required parameters must be populated in order to send to Azure. + + :param user_id: Required. The Id of the Microsoft Teams user. If not anonymous, this is the AAD + object Id of the user. + :type user_id: str + :param is_anonymous: True if the Microsoft Teams user is anonymous. By default false if + missing. + :type is_anonymous: bool + :param cloud: The cloud that the Microsoft Teams user belongs to. By default 'public' if + missing. Possible values include: "public", "dod", "gcch". + :type cloud: str or ~azure.communication.chat.models.CommunicationCloudEnvironmentModel + """ + + _validation = { + 'user_id': {'required': True}, + } + + _attribute_map = { + 'user_id': {'key': 'userId', 'type': 'str'}, + 'is_anonymous': {'key': 'isAnonymous', 'type': 'bool'}, + 'cloud': {'key': 'cloud', 'type': 'str'}, + } + + def __init__( + self, + **kwargs + ): + super(MicrosoftTeamsUserIdentifierModel, self).__init__(**kwargs) + self.user_id = kwargs['user_id'] + self.is_anonymous = kwargs.get('is_anonymous', None) + self.cloud = kwargs.get('cloud', None) + + +class PhoneNumberIdentifierModel(msrest.serialization.Model): + """A phone number. + + All required parameters must be populated in order to send to Azure. + + :param value: Required. The phone number in E.164 format. + :type value: str + """ + + _validation = { + 'value': {'required': True}, + } + + _attribute_map = { + 'value': {'key': 'value', 'type': 'str'}, + } + + def __init__( + self, + **kwargs + ): + super(PhoneNumberIdentifierModel, self).__init__(**kwargs) + self.value = kwargs['value'] + + +class SendChatMessageRequest(msrest.serialization.Model): + """Details of the message to send. + + All required parameters must be populated in order to send to Azure. + + :param content: Required. Chat message content. + :type content: str + :param sender_display_name: The display name of the chat message sender. This property is used + to populate sender name for push notifications. + :type sender_display_name: str + :param type: The chat message type. Possible values include: "text", "html", "topicUpdated", + "participantAdded", "participantRemoved". + :type type: str or ~azure.communication.chat.models.ChatMessageType + :param metadata: Message metadata. + :type metadata: dict[str, str] + """ + + _validation = { + 'content': {'required': True}, + } + + _attribute_map = { + 'content': {'key': 'content', 'type': 'str'}, + 'sender_display_name': {'key': 'senderDisplayName', 'type': 'str'}, + 'type': {'key': 'type', 'type': 'str'}, + 'metadata': {'key': 'metadata', 'type': '{str}'}, + } + + def __init__( + self, + **kwargs + ): + super(SendChatMessageRequest, self).__init__(**kwargs) + self.content = kwargs['content'] + self.sender_display_name = kwargs.get('sender_display_name', None) + self.type = kwargs.get('type', None) + self.metadata = kwargs.get('metadata', None) + + +class SendChatMessageResult(msrest.serialization.Model): + """Result of the send message operation. + + All required parameters must be populated in order to send to Azure. + + :param id: Required. A server-generated message id. + :type id: str + """ + + _validation = { + 'id': {'required': True}, + } + + _attribute_map = { + 'id': {'key': 'id', 'type': 'str'}, + } + + def __init__( + self, + **kwargs + ): + super(SendChatMessageResult, self).__init__(**kwargs) + self.id = kwargs['id'] + + +class SendReadReceiptRequest(msrest.serialization.Model): + """Request payload for sending a read receipt. + + All required parameters must be populated in order to send to Azure. + + :param chat_message_id: Required. Id of the latest chat message read by the user. + :type chat_message_id: str + """ + + _validation = { + 'chat_message_id': {'required': True}, + } + + _attribute_map = { + 'chat_message_id': {'key': 'chatMessageId', 'type': 'str'}, + } + + def __init__( + self, + **kwargs + ): + super(SendReadReceiptRequest, self).__init__(**kwargs) + self.chat_message_id = kwargs['chat_message_id'] + + +class SendTypingNotificationRequest(msrest.serialization.Model): + """Request payload for typing notifications. + + :param sender_display_name: The display name of the typing notification sender. This property + is used to populate sender name for push notifications. + :type sender_display_name: str + """ + + _attribute_map = { + 'sender_display_name': {'key': 'senderDisplayName', 'type': 'str'}, + } + + def __init__( + self, + **kwargs + ): + super(SendTypingNotificationRequest, self).__init__(**kwargs) + self.sender_display_name = kwargs.get('sender_display_name', None) + + +class UpdateChatMessageRequest(msrest.serialization.Model): + """Request payload for updating a chat message. + + :param content: Chat message content. + :type content: str + :param metadata: Message metadata. + :type metadata: dict[str, str] + """ + + _attribute_map = { + 'content': {'key': 'content', 'type': 'str'}, + 'metadata': {'key': 'metadata', 'type': '{str}'}, + } + + def __init__( + self, + **kwargs + ): + super(UpdateChatMessageRequest, self).__init__(**kwargs) + self.content = kwargs.get('content', None) + self.metadata = kwargs.get('metadata', None) + + +class UpdateChatThreadRequest(msrest.serialization.Model): + """Request payload for updating a chat thread. + + :param topic: Chat thread topic. + :type topic: str + """ + + _attribute_map = { + 'topic': {'key': 'topic', 'type': 'str'}, + } + + def __init__( + self, + **kwargs + ): + super(UpdateChatThreadRequest, self).__init__(**kwargs) + self.topic = kwargs.get('topic', None) diff --git a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/models/_models_py3.py b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/models/_models_py3.py index 10a46d69b197..aeed862eed73 100644 --- a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/models/_models_py3.py +++ b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/models/_models_py3.py @@ -1,5 +1,4 @@ # coding=utf-8 -# pylint: disable=too-many-lines # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for license information. @@ -8,42 +7,42 @@ # -------------------------------------------------------------------------- import datetime -from typing import Dict, List, Optional, TYPE_CHECKING, Union +from typing import Dict, List, Optional, Union -from .. import _serialization +from azure.core.exceptions import HttpResponseError +import msrest.serialization -if TYPE_CHECKING: - # pylint: disable=unused-import,ungrouped-imports - from .. import models as _models +from ._azure_communication_chat_service_enums import * -class AddChatParticipantsRequest(_serialization.Model): +class AddChatParticipantsRequest(msrest.serialization.Model): """Participants to be added to the thread. All required parameters must be populated in order to send to Azure. - :ivar participants: Participants to add to a chat thread. Required. - :vartype participants: list[~azure.communication.chat.models.ChatParticipant] + :param participants: Required. Participants to add to a chat thread. + :type participants: list[~azure.communication.chat.models.ChatParticipant] """ _validation = { - "participants": {"required": True}, + 'participants': {'required': True}, } _attribute_map = { - "participants": {"key": "participants", "type": "[ChatParticipant]"}, + 'participants': {'key': 'participants', 'type': '[ChatParticipant]'}, } - def __init__(self, *, participants: List["_models.ChatParticipant"], **kwargs): - """ - :keyword participants: Participants to add to a chat thread. Required. - :paramtype participants: list[~azure.communication.chat.models.ChatParticipant] - """ - super().__init__(**kwargs) + def __init__( + self, + *, + participants: List["ChatParticipant"], + **kwargs + ): + super(AddChatParticipantsRequest, self).__init__(**kwargs) self.participants = participants -class AddChatParticipantsResult(_serialization.Model): +class AddChatParticipantsResult(msrest.serialization.Model): """Result of the add chat participants operation. Variables are only populated by the server, and will be ignored when sending a request. @@ -53,30 +52,32 @@ class AddChatParticipantsResult(_serialization.Model): """ _validation = { - "invalid_participants": {"readonly": True}, + 'invalid_participants': {'readonly': True}, } _attribute_map = { - "invalid_participants": {"key": "invalidParticipants", "type": "[ChatError]"}, + 'invalid_participants': {'key': 'invalidParticipants', 'type': '[ChatError]'}, } - def __init__(self, **kwargs): - """ """ - super().__init__(**kwargs) + def __init__( + self, + **kwargs + ): + super(AddChatParticipantsResult, self).__init__(**kwargs) self.invalid_participants = None -class ChatError(_serialization.Model): +class ChatError(msrest.serialization.Model): """The Communication Services error. Variables are only populated by the server, and will be ignored when sending a request. All required parameters must be populated in order to send to Azure. - :ivar code: The error code. Required. - :vartype code: str - :ivar message: The error message. Required. - :vartype message: str + :param code: Required. The error code. + :type code: str + :param message: Required. The error message. + :type message: str :ivar target: The error target. :vartype target: str :ivar details: Further details about specific errors that led to this error. @@ -86,29 +87,29 @@ class ChatError(_serialization.Model): """ _validation = { - "code": {"required": True}, - "message": {"required": True}, - "target": {"readonly": True}, - "details": {"readonly": True}, - "inner_error": {"readonly": True}, + 'code': {'required': True}, + 'message': {'required': True}, + 'target': {'readonly': True}, + 'details': {'readonly': True}, + 'inner_error': {'readonly': True}, } _attribute_map = { - "code": {"key": "code", "type": "str"}, - "message": {"key": "message", "type": "str"}, - "target": {"key": "target", "type": "str"}, - "details": {"key": "details", "type": "[ChatError]"}, - "inner_error": {"key": "innererror", "type": "ChatError"}, + 'code': {'key': 'code', 'type': 'str'}, + 'message': {'key': 'message', 'type': 'str'}, + 'target': {'key': 'target', 'type': 'str'}, + 'details': {'key': 'details', 'type': '[ChatError]'}, + 'inner_error': {'key': 'innererror', 'type': 'ChatError'}, } - def __init__(self, *, code: str, message: str, **kwargs): - """ - :keyword code: The error code. Required. - :paramtype code: str - :keyword message: The error message. Required. - :paramtype message: str - """ - super().__init__(**kwargs) + def __init__( + self, + *, + code: str, + message: str, + **kwargs + ): + super(ChatError, self).__init__(**kwargs) self.code = code self.message = message self.target = None @@ -116,119 +117,83 @@ def __init__(self, *, code: str, message: str, **kwargs): self.inner_error = None -class ChatMessage(_serialization.Model): # pylint: disable=too-many-instance-attributes +class ChatMessage(msrest.serialization.Model): """Chat message. All required parameters must be populated in order to send to Azure. - :ivar id: The id of the chat message. This id is server generated. Required. - :vartype id: str - :ivar type: The chat message type. Required. Known values are: "text", "html", "topicUpdated", - "participantAdded", and "participantRemoved". - :vartype type: str or ~azure.communication.chat.models.ChatMessageType - :ivar sequence_id: Sequence of the chat message in the conversation. Required. - :vartype sequence_id: str - :ivar version: Version of the chat message. Required. - :vartype version: str - :ivar content: Content of a chat message. - :vartype content: ~azure.communication.chat.models.ChatMessageContent - :ivar sender_display_name: The display name of the chat message sender. This property is used + :param id: Required. The id of the chat message. This id is server generated. + :type id: str + :param type: Required. The chat message type. Possible values include: "text", "html", + "topicUpdated", "participantAdded", "participantRemoved". + :type type: str or ~azure.communication.chat.models.ChatMessageType + :param sequence_id: Required. Sequence of the chat message in the conversation. + :type sequence_id: str + :param version: Required. Version of the chat message. + :type version: str + :param content: Content of a chat message. + :type content: ~azure.communication.chat.models.ChatMessageContent + :param sender_display_name: The display name of the chat message sender. This property is used to populate sender name for push notifications. - :vartype sender_display_name: str - :ivar created_on: The timestamp when the chat message arrived at the server. The timestamp is - in RFC3339 format: ``yyyy-MM-ddTHH:mm:ssZ``. Required. - :vartype created_on: ~datetime.datetime - :ivar sender_communication_identifier: Identifies a participant in Azure Communication + :type sender_display_name: str + :param created_on: Required. The timestamp when the chat message arrived at the server. The + timestamp is in RFC3339 format: ``yyyy-MM-ddTHH:mm:ssZ``. + :type created_on: ~datetime.datetime + :param sender_communication_identifier: Identifies a participant in Azure Communication services. A participant is, for example, a phone number or an Azure communication user. This model must be interpreted as a union: Apart from rawId, at most one further property may be set. - :vartype sender_communication_identifier: + :type sender_communication_identifier: ~azure.communication.chat.models.CommunicationIdentifierModel - :ivar deleted_on: The timestamp (if applicable) when the message was deleted. The timestamp is + :param deleted_on: The timestamp (if applicable) when the message was deleted. The timestamp is in RFC3339 format: ``yyyy-MM-ddTHH:mm:ssZ``. - :vartype deleted_on: ~datetime.datetime - :ivar edited_on: The last timestamp (if applicable) when the message was edited. The timestamp + :type deleted_on: ~datetime.datetime + :param edited_on: The last timestamp (if applicable) when the message was edited. The timestamp is in RFC3339 format: ``yyyy-MM-ddTHH:mm:ssZ``. - :vartype edited_on: ~datetime.datetime - :ivar metadata: Message metadata. - :vartype metadata: dict[str, str] + :type edited_on: ~datetime.datetime + :param metadata: Message metadata. + :type metadata: dict[str, str] """ _validation = { - "id": {"required": True}, - "type": {"required": True}, - "sequence_id": {"required": True}, - "version": {"required": True}, - "created_on": {"required": True}, + 'id': {'required': True}, + 'type': {'required': True}, + 'sequence_id': {'required': True}, + 'version': {'required': True}, + 'created_on': {'required': True}, } _attribute_map = { - "id": {"key": "id", "type": "str"}, - "type": {"key": "type", "type": "str"}, - "sequence_id": {"key": "sequenceId", "type": "str"}, - "version": {"key": "version", "type": "str"}, - "content": {"key": "content", "type": "ChatMessageContent"}, - "sender_display_name": {"key": "senderDisplayName", "type": "str"}, - "created_on": {"key": "createdOn", "type": "iso-8601"}, - "sender_communication_identifier": { - "key": "senderCommunicationIdentifier", - "type": "CommunicationIdentifierModel", - }, - "deleted_on": {"key": "deletedOn", "type": "iso-8601"}, - "edited_on": {"key": "editedOn", "type": "iso-8601"}, - "metadata": {"key": "metadata", "type": "{str}"}, + 'id': {'key': 'id', 'type': 'str'}, + 'type': {'key': 'type', 'type': 'str'}, + 'sequence_id': {'key': 'sequenceId', 'type': 'str'}, + 'version': {'key': 'version', 'type': 'str'}, + 'content': {'key': 'content', 'type': 'ChatMessageContent'}, + 'sender_display_name': {'key': 'senderDisplayName', 'type': 'str'}, + 'created_on': {'key': 'createdOn', 'type': 'iso-8601'}, + 'sender_communication_identifier': {'key': 'senderCommunicationIdentifier', 'type': 'CommunicationIdentifierModel'}, + 'deleted_on': {'key': 'deletedOn', 'type': 'iso-8601'}, + 'edited_on': {'key': 'editedOn', 'type': 'iso-8601'}, + 'metadata': {'key': 'metadata', 'type': '{str}'}, } def __init__( self, *, - id: str, # pylint: disable=redefined-builtin - type: Union[str, "_models.ChatMessageType"], + id: str, + type: Union[str, "ChatMessageType"], sequence_id: str, version: str, created_on: datetime.datetime, - content: Optional["_models.ChatMessageContent"] = None, + content: Optional["ChatMessageContent"] = None, sender_display_name: Optional[str] = None, - sender_communication_identifier: Optional["_models.CommunicationIdentifierModel"] = None, + sender_communication_identifier: Optional["CommunicationIdentifierModel"] = None, deleted_on: Optional[datetime.datetime] = None, edited_on: Optional[datetime.datetime] = None, metadata: Optional[Dict[str, str]] = None, **kwargs ): - """ - :keyword id: The id of the chat message. This id is server generated. Required. - :paramtype id: str - :keyword type: The chat message type. Required. Known values are: "text", "html", - "topicUpdated", "participantAdded", and "participantRemoved". - :paramtype type: str or ~azure.communication.chat.models.ChatMessageType - :keyword sequence_id: Sequence of the chat message in the conversation. Required. - :paramtype sequence_id: str - :keyword version: Version of the chat message. Required. - :paramtype version: str - :keyword content: Content of a chat message. - :paramtype content: ~azure.communication.chat.models.ChatMessageContent - :keyword sender_display_name: The display name of the chat message sender. This property is - used to populate sender name for push notifications. - :paramtype sender_display_name: str - :keyword created_on: The timestamp when the chat message arrived at the server. The timestamp - is in RFC3339 format: ``yyyy-MM-ddTHH:mm:ssZ``. Required. - :paramtype created_on: ~datetime.datetime - :keyword sender_communication_identifier: Identifies a participant in Azure Communication - services. A participant is, for example, a phone number or an Azure communication user. This - model must be interpreted as a union: Apart from rawId, at most one further property may be - set. - :paramtype sender_communication_identifier: - ~azure.communication.chat.models.CommunicationIdentifierModel - :keyword deleted_on: The timestamp (if applicable) when the message was deleted. The timestamp - is in RFC3339 format: ``yyyy-MM-ddTHH:mm:ssZ``. - :paramtype deleted_on: ~datetime.datetime - :keyword edited_on: The last timestamp (if applicable) when the message was edited. The - timestamp is in RFC3339 format: ``yyyy-MM-ddTHH:mm:ssZ``. - :paramtype edited_on: ~datetime.datetime - :keyword metadata: Message metadata. - :paramtype metadata: dict[str, str] - """ - super().__init__(**kwargs) + super(ChatMessage, self).__init__(**kwargs) self.id = id self.type = type self.sequence_id = sequence_id @@ -242,32 +207,29 @@ def __init__( self.metadata = metadata -class ChatMessageContent(_serialization.Model): +class ChatMessageContent(msrest.serialization.Model): """Content of a chat message. - :ivar message: Chat message content for messages of types text or html. - :vartype message: str - :ivar topic: Chat message content for messages of type topicUpdated. - :vartype topic: str - :ivar participants: Chat message content for messages of types participantAdded or + :param message: Chat message content for messages of types text or html. + :type message: str + :param topic: Chat message content for messages of type topicUpdated. + :type topic: str + :param participants: Chat message content for messages of types participantAdded or participantRemoved. - :vartype participants: list[~azure.communication.chat.models.ChatParticipant] - :ivar initiator_communication_identifier: Identifies a participant in Azure Communication + :type participants: list[~azure.communication.chat.models.ChatParticipant] + :param initiator_communication_identifier: Identifies a participant in Azure Communication services. A participant is, for example, a phone number or an Azure communication user. This model must be interpreted as a union: Apart from rawId, at most one further property may be set. - :vartype initiator_communication_identifier: + :type initiator_communication_identifier: ~azure.communication.chat.models.CommunicationIdentifierModel """ _attribute_map = { - "message": {"key": "message", "type": "str"}, - "topic": {"key": "topic", "type": "str"}, - "participants": {"key": "participants", "type": "[ChatParticipant]"}, - "initiator_communication_identifier": { - "key": "initiatorCommunicationIdentifier", - "type": "CommunicationIdentifierModel", - }, + 'message': {'key': 'message', 'type': 'str'}, + 'topic': {'key': 'topic', 'type': 'str'}, + 'participants': {'key': 'participants', 'type': '[ChatParticipant]'}, + 'initiator_communication_identifier': {'key': 'initiatorCommunicationIdentifier', 'type': 'CommunicationIdentifierModel'}, } def __init__( @@ -275,375 +237,304 @@ def __init__( *, message: Optional[str] = None, topic: Optional[str] = None, - participants: Optional[List["_models.ChatParticipant"]] = None, - initiator_communication_identifier: Optional["_models.CommunicationIdentifierModel"] = None, + participants: Optional[List["ChatParticipant"]] = None, + initiator_communication_identifier: Optional["CommunicationIdentifierModel"] = None, **kwargs ): - """ - :keyword message: Chat message content for messages of types text or html. - :paramtype message: str - :keyword topic: Chat message content for messages of type topicUpdated. - :paramtype topic: str - :keyword participants: Chat message content for messages of types participantAdded or - participantRemoved. - :paramtype participants: list[~azure.communication.chat.models.ChatParticipant] - :keyword initiator_communication_identifier: Identifies a participant in Azure Communication - services. A participant is, for example, a phone number or an Azure communication user. This - model must be interpreted as a union: Apart from rawId, at most one further property may be - set. - :paramtype initiator_communication_identifier: - ~azure.communication.chat.models.CommunicationIdentifierModel - """ - super().__init__(**kwargs) + super(ChatMessageContent, self).__init__(**kwargs) self.message = message self.topic = topic self.participants = participants self.initiator_communication_identifier = initiator_communication_identifier -class ChatMessageReadReceipt(_serialization.Model): +class ChatMessageReadReceipt(msrest.serialization.Model): """A chat message read receipt indicates the time a chat message was read by a recipient. All required parameters must be populated in order to send to Azure. - :ivar sender_communication_identifier: Identifies a participant in Azure Communication - services. A participant is, for example, a phone number or an Azure communication user. This - model must be interpreted as a union: Apart from rawId, at most one further property may be - set. Required. - :vartype sender_communication_identifier: + :param sender_communication_identifier: Required. Identifies a participant in Azure + Communication services. A participant is, for example, a phone number or an Azure communication + user. This model must be interpreted as a union: Apart from rawId, at most one further property + may be set. + :type sender_communication_identifier: ~azure.communication.chat.models.CommunicationIdentifierModel - :ivar chat_message_id: Id of the chat message that has been read. This id is generated by the - server. Required. - :vartype chat_message_id: str - :ivar read_on: The time at which the message was read. The timestamp is in RFC3339 format: - ``yyyy-MM-ddTHH:mm:ssZ``. Required. - :vartype read_on: ~datetime.datetime + :param chat_message_id: Required. Id of the chat message that has been read. This id is + generated by the server. + :type chat_message_id: str + :param read_on: Required. The time at which the message was read. The timestamp is in RFC3339 + format: ``yyyy-MM-ddTHH:mm:ssZ``. + :type read_on: ~datetime.datetime """ _validation = { - "sender_communication_identifier": {"required": True}, - "chat_message_id": {"required": True}, - "read_on": {"required": True}, + 'sender_communication_identifier': {'required': True}, + 'chat_message_id': {'required': True}, + 'read_on': {'required': True}, } _attribute_map = { - "sender_communication_identifier": { - "key": "senderCommunicationIdentifier", - "type": "CommunicationIdentifierModel", - }, - "chat_message_id": {"key": "chatMessageId", "type": "str"}, - "read_on": {"key": "readOn", "type": "iso-8601"}, + 'sender_communication_identifier': {'key': 'senderCommunicationIdentifier', 'type': 'CommunicationIdentifierModel'}, + 'chat_message_id': {'key': 'chatMessageId', 'type': 'str'}, + 'read_on': {'key': 'readOn', 'type': 'iso-8601'}, } def __init__( self, *, - sender_communication_identifier: "_models.CommunicationIdentifierModel", + sender_communication_identifier: "CommunicationIdentifierModel", chat_message_id: str, read_on: datetime.datetime, **kwargs ): - """ - :keyword sender_communication_identifier: Identifies a participant in Azure Communication - services. A participant is, for example, a phone number or an Azure communication user. This - model must be interpreted as a union: Apart from rawId, at most one further property may be - set. Required. - :paramtype sender_communication_identifier: - ~azure.communication.chat.models.CommunicationIdentifierModel - :keyword chat_message_id: Id of the chat message that has been read. This id is generated by - the server. Required. - :paramtype chat_message_id: str - :keyword read_on: The time at which the message was read. The timestamp is in RFC3339 format: - ``yyyy-MM-ddTHH:mm:ssZ``. Required. - :paramtype read_on: ~datetime.datetime - """ - super().__init__(**kwargs) + super(ChatMessageReadReceipt, self).__init__(**kwargs) self.sender_communication_identifier = sender_communication_identifier self.chat_message_id = chat_message_id self.read_on = read_on -class ChatMessageReadReceiptsCollection(_serialization.Model): +class ChatMessageReadReceiptsCollection(msrest.serialization.Model): """A paged collection of chat message read receipts. Variables are only populated by the server, and will be ignored when sending a request. All required parameters must be populated in order to send to Azure. - :ivar value: Collection of chat message read receipts. Required. - :vartype value: list[~azure.communication.chat.models.ChatMessageReadReceipt] + :param value: Required. Collection of chat message read receipts. + :type value: list[~azure.communication.chat.models.ChatMessageReadReceipt] :ivar next_link: If there are more chat message read receipts that can be retrieved, the next link will be populated. :vartype next_link: str """ _validation = { - "value": {"required": True}, - "next_link": {"readonly": True}, + 'value': {'required': True}, + 'next_link': {'readonly': True}, } _attribute_map = { - "value": {"key": "value", "type": "[ChatMessageReadReceipt]"}, - "next_link": {"key": "nextLink", "type": "str"}, + 'value': {'key': 'value', 'type': '[ChatMessageReadReceipt]'}, + 'next_link': {'key': 'nextLink', 'type': 'str'}, } - def __init__(self, *, value: List["_models.ChatMessageReadReceipt"], **kwargs): - """ - :keyword value: Collection of chat message read receipts. Required. - :paramtype value: list[~azure.communication.chat.models.ChatMessageReadReceipt] - """ - super().__init__(**kwargs) + def __init__( + self, + *, + value: List["ChatMessageReadReceipt"], + **kwargs + ): + super(ChatMessageReadReceiptsCollection, self).__init__(**kwargs) self.value = value self.next_link = None -class ChatMessagesCollection(_serialization.Model): +class ChatMessagesCollection(msrest.serialization.Model): """Collection of chat messages for a particular chat thread. Variables are only populated by the server, and will be ignored when sending a request. All required parameters must be populated in order to send to Azure. - :ivar value: Collection of chat messages. Required. - :vartype value: list[~azure.communication.chat.models.ChatMessage] + :param value: Required. Collection of chat messages. + :type value: list[~azure.communication.chat.models.ChatMessage] :ivar next_link: If there are more chat messages that can be retrieved, the next link will be populated. :vartype next_link: str """ _validation = { - "value": {"required": True}, - "next_link": {"readonly": True}, + 'value': {'required': True}, + 'next_link': {'readonly': True}, } _attribute_map = { - "value": {"key": "value", "type": "[ChatMessage]"}, - "next_link": {"key": "nextLink", "type": "str"}, + 'value': {'key': 'value', 'type': '[ChatMessage]'}, + 'next_link': {'key': 'nextLink', 'type': 'str'}, } - def __init__(self, *, value: List["_models.ChatMessage"], **kwargs): - """ - :keyword value: Collection of chat messages. Required. - :paramtype value: list[~azure.communication.chat.models.ChatMessage] - """ - super().__init__(**kwargs) + def __init__( + self, + *, + value: List["ChatMessage"], + **kwargs + ): + super(ChatMessagesCollection, self).__init__(**kwargs) self.value = value self.next_link = None -class ChatParticipant(_serialization.Model): +class ChatParticipant(msrest.serialization.Model): """A participant of the chat thread. All required parameters must be populated in order to send to Azure. - :ivar communication_identifier: Identifies a participant in Azure Communication services. A - participant is, for example, a phone number or an Azure communication user. This model must be - interpreted as a union: Apart from rawId, at most one further property may be set. Required. - :vartype communication_identifier: - ~azure.communication.chat.models.CommunicationIdentifierModel - :ivar display_name: Display name for the chat participant. - :vartype display_name: str - :ivar share_history_time: Time from which the chat history is shared with the participant. The + :param communication_identifier: Required. Identifies a participant in Azure Communication + services. A participant is, for example, a phone number or an Azure communication user. This + model must be interpreted as a union: Apart from rawId, at most one further property may be + set. + :type communication_identifier: ~azure.communication.chat.models.CommunicationIdentifierModel + :param display_name: Display name for the chat participant. + :type display_name: str + :param share_history_time: Time from which the chat history is shared with the participant. The timestamp is in RFC3339 format: ``yyyy-MM-ddTHH:mm:ssZ``. - :vartype share_history_time: ~datetime.datetime + :type share_history_time: ~datetime.datetime """ _validation = { - "communication_identifier": {"required": True}, + 'communication_identifier': {'required': True}, } _attribute_map = { - "communication_identifier": {"key": "communicationIdentifier", "type": "CommunicationIdentifierModel"}, - "display_name": {"key": "displayName", "type": "str"}, - "share_history_time": {"key": "shareHistoryTime", "type": "iso-8601"}, + 'communication_identifier': {'key': 'communicationIdentifier', 'type': 'CommunicationIdentifierModel'}, + 'display_name': {'key': 'displayName', 'type': 'str'}, + 'share_history_time': {'key': 'shareHistoryTime', 'type': 'iso-8601'}, } def __init__( self, *, - communication_identifier: "_models.CommunicationIdentifierModel", + communication_identifier: "CommunicationIdentifierModel", display_name: Optional[str] = None, share_history_time: Optional[datetime.datetime] = None, **kwargs ): - """ - :keyword communication_identifier: Identifies a participant in Azure Communication services. A - participant is, for example, a phone number or an Azure communication user. This model must be - interpreted as a union: Apart from rawId, at most one further property may be set. Required. - :paramtype communication_identifier: - ~azure.communication.chat.models.CommunicationIdentifierModel - :keyword display_name: Display name for the chat participant. - :paramtype display_name: str - :keyword share_history_time: Time from which the chat history is shared with the participant. - The timestamp is in RFC3339 format: ``yyyy-MM-ddTHH:mm:ssZ``. - :paramtype share_history_time: ~datetime.datetime - """ - super().__init__(**kwargs) + super(ChatParticipant, self).__init__(**kwargs) self.communication_identifier = communication_identifier self.display_name = display_name self.share_history_time = share_history_time -class ChatParticipantsCollection(_serialization.Model): +class ChatParticipantsCollection(msrest.serialization.Model): """Collection of participants belong to a particular thread. Variables are only populated by the server, and will be ignored when sending a request. All required parameters must be populated in order to send to Azure. - :ivar value: Chat participants. Required. - :vartype value: list[~azure.communication.chat.models.ChatParticipant] + :param value: Required. Chat participants. + :type value: list[~azure.communication.chat.models.ChatParticipant] :ivar next_link: If there are more chat participants that can be retrieved, the next link will be populated. :vartype next_link: str """ _validation = { - "value": {"required": True}, - "next_link": {"readonly": True}, + 'value': {'required': True}, + 'next_link': {'readonly': True}, } _attribute_map = { - "value": {"key": "value", "type": "[ChatParticipant]"}, - "next_link": {"key": "nextLink", "type": "str"}, + 'value': {'key': 'value', 'type': '[ChatParticipant]'}, + 'next_link': {'key': 'nextLink', 'type': 'str'}, } - def __init__(self, *, value: List["_models.ChatParticipant"], **kwargs): - """ - :keyword value: Chat participants. Required. - :paramtype value: list[~azure.communication.chat.models.ChatParticipant] - """ - super().__init__(**kwargs) + def __init__( + self, + *, + value: List["ChatParticipant"], + **kwargs + ): + super(ChatParticipantsCollection, self).__init__(**kwargs) self.value = value self.next_link = None -class ChatThreadItem(_serialization.Model): +class ChatThreadItem(msrest.serialization.Model): """Summary information of a chat thread. Variables are only populated by the server, and will be ignored when sending a request. All required parameters must be populated in order to send to Azure. - :ivar id: Chat thread id. Required. - :vartype id: str - :ivar topic: Chat thread topic. Required. - :vartype topic: str - :ivar deleted_on: The timestamp when the chat thread was deleted. The timestamp is in RFC3339 + :param id: Required. Chat thread id. + :type id: str + :param topic: Required. Chat thread topic. + :type topic: str + :param deleted_on: The timestamp when the chat thread was deleted. The timestamp is in RFC3339 format: ``yyyy-MM-ddTHH:mm:ssZ``. - :vartype deleted_on: ~datetime.datetime + :type deleted_on: ~datetime.datetime :ivar last_message_received_on: The timestamp when the last message arrived at the server. The timestamp is in RFC3339 format: ``yyyy-MM-ddTHH:mm:ssZ``. :vartype last_message_received_on: ~datetime.datetime """ _validation = { - "id": {"required": True}, - "topic": {"required": True}, - "last_message_received_on": {"readonly": True}, + 'id': {'required': True}, + 'topic': {'required': True}, + 'last_message_received_on': {'readonly': True}, } _attribute_map = { - "id": {"key": "id", "type": "str"}, - "topic": {"key": "topic", "type": "str"}, - "deleted_on": {"key": "deletedOn", "type": "iso-8601"}, - "last_message_received_on": {"key": "lastMessageReceivedOn", "type": "iso-8601"}, + 'id': {'key': 'id', 'type': 'str'}, + 'topic': {'key': 'topic', 'type': 'str'}, + 'deleted_on': {'key': 'deletedOn', 'type': 'iso-8601'}, + 'last_message_received_on': {'key': 'lastMessageReceivedOn', 'type': 'iso-8601'}, } def __init__( self, *, - id: str, # pylint: disable=redefined-builtin + id: str, topic: str, deleted_on: Optional[datetime.datetime] = None, **kwargs ): - """ - :keyword id: Chat thread id. Required. - :paramtype id: str - :keyword topic: Chat thread topic. Required. - :paramtype topic: str - :keyword deleted_on: The timestamp when the chat thread was deleted. The timestamp is in - RFC3339 format: ``yyyy-MM-ddTHH:mm:ssZ``. - :paramtype deleted_on: ~datetime.datetime - """ - super().__init__(**kwargs) + super(ChatThreadItem, self).__init__(**kwargs) self.id = id self.topic = topic self.deleted_on = deleted_on self.last_message_received_on = None -class ChatThreadProperties(_serialization.Model): +class ChatThreadProperties(msrest.serialization.Model): """Chat thread. All required parameters must be populated in order to send to Azure. - :ivar id: Chat thread id. Required. - :vartype id: str - :ivar topic: Chat thread topic. Required. - :vartype topic: str - :ivar created_on: The timestamp when the chat thread was created. The timestamp is in RFC3339 - format: ``yyyy-MM-ddTHH:mm:ssZ``. Required. - :vartype created_on: ~datetime.datetime - :ivar created_by_communication_identifier: Identifies a participant in Azure Communication - services. A participant is, for example, a phone number or an Azure communication user. This - model must be interpreted as a union: Apart from rawId, at most one further property may be - set. Required. - :vartype created_by_communication_identifier: + :param id: Required. Chat thread id. + :type id: str + :param topic: Required. Chat thread topic. + :type topic: str + :param created_on: Required. The timestamp when the chat thread was created. The timestamp is + in RFC3339 format: ``yyyy-MM-ddTHH:mm:ssZ``. + :type created_on: ~datetime.datetime + :param created_by_communication_identifier: Required. Identifies a participant in Azure + Communication services. A participant is, for example, a phone number or an Azure communication + user. This model must be interpreted as a union: Apart from rawId, at most one further property + may be set. + :type created_by_communication_identifier: ~azure.communication.chat.models.CommunicationIdentifierModel - :ivar deleted_on: The timestamp when the chat thread was deleted. The timestamp is in RFC3339 + :param deleted_on: The timestamp when the chat thread was deleted. The timestamp is in RFC3339 format: ``yyyy-MM-ddTHH:mm:ssZ``. - :vartype deleted_on: ~datetime.datetime + :type deleted_on: ~datetime.datetime """ _validation = { - "id": {"required": True}, - "topic": {"required": True}, - "created_on": {"required": True}, - "created_by_communication_identifier": {"required": True}, + 'id': {'required': True}, + 'topic': {'required': True}, + 'created_on': {'required': True}, + 'created_by_communication_identifier': {'required': True}, } _attribute_map = { - "id": {"key": "id", "type": "str"}, - "topic": {"key": "topic", "type": "str"}, - "created_on": {"key": "createdOn", "type": "iso-8601"}, - "created_by_communication_identifier": { - "key": "createdByCommunicationIdentifier", - "type": "CommunicationIdentifierModel", - }, - "deleted_on": {"key": "deletedOn", "type": "iso-8601"}, + 'id': {'key': 'id', 'type': 'str'}, + 'topic': {'key': 'topic', 'type': 'str'}, + 'created_on': {'key': 'createdOn', 'type': 'iso-8601'}, + 'created_by_communication_identifier': {'key': 'createdByCommunicationIdentifier', 'type': 'CommunicationIdentifierModel'}, + 'deleted_on': {'key': 'deletedOn', 'type': 'iso-8601'}, } def __init__( self, *, - id: str, # pylint: disable=redefined-builtin + id: str, topic: str, created_on: datetime.datetime, - created_by_communication_identifier: "_models.CommunicationIdentifierModel", + created_by_communication_identifier: "CommunicationIdentifierModel", deleted_on: Optional[datetime.datetime] = None, **kwargs ): - """ - :keyword id: Chat thread id. Required. - :paramtype id: str - :keyword topic: Chat thread topic. Required. - :paramtype topic: str - :keyword created_on: The timestamp when the chat thread was created. The timestamp is in - RFC3339 format: ``yyyy-MM-ddTHH:mm:ssZ``. Required. - :paramtype created_on: ~datetime.datetime - :keyword created_by_communication_identifier: Identifies a participant in Azure Communication - services. A participant is, for example, a phone number or an Azure communication user. This - model must be interpreted as a union: Apart from rawId, at most one further property may be - set. Required. - :paramtype created_by_communication_identifier: - ~azure.communication.chat.models.CommunicationIdentifierModel - :keyword deleted_on: The timestamp when the chat thread was deleted. The timestamp is in - RFC3339 format: ``yyyy-MM-ddTHH:mm:ssZ``. - :paramtype deleted_on: ~datetime.datetime - """ - super().__init__(**kwargs) + super(ChatThreadProperties, self).__init__(**kwargs) self.id = id self.topic = topic self.created_on = created_on @@ -651,226 +542,218 @@ def __init__( self.deleted_on = deleted_on -class ChatThreadsItemCollection(_serialization.Model): +class ChatThreadsItemCollection(msrest.serialization.Model): """Collection of chat threads. Variables are only populated by the server, and will be ignored when sending a request. All required parameters must be populated in order to send to Azure. - :ivar value: Collection of chat threads. Required. - :vartype value: list[~azure.communication.chat.models.ChatThreadItem] + :param value: Required. Collection of chat threads. + :type value: list[~azure.communication.chat.models.ChatThreadItem] :ivar next_link: If there are more chat threads that can be retrieved, the next link will be populated. :vartype next_link: str """ _validation = { - "value": {"required": True}, - "next_link": {"readonly": True}, + 'value': {'required': True}, + 'next_link': {'readonly': True}, } _attribute_map = { - "value": {"key": "value", "type": "[ChatThreadItem]"}, - "next_link": {"key": "nextLink", "type": "str"}, + 'value': {'key': 'value', 'type': '[ChatThreadItem]'}, + 'next_link': {'key': 'nextLink', 'type': 'str'}, } - def __init__(self, *, value: List["_models.ChatThreadItem"], **kwargs): - """ - :keyword value: Collection of chat threads. Required. - :paramtype value: list[~azure.communication.chat.models.ChatThreadItem] - """ - super().__init__(**kwargs) + def __init__( + self, + *, + value: List["ChatThreadItem"], + **kwargs + ): + super(ChatThreadsItemCollection, self).__init__(**kwargs) self.value = value self.next_link = None -class CommunicationErrorResponse(_serialization.Model): +class CommunicationErrorResponse(msrest.serialization.Model): """The Communication Services error. All required parameters must be populated in order to send to Azure. - :ivar error: The Communication Services error. Required. - :vartype error: ~azure.communication.chat.models.ChatError + :param error: Required. The Communication Services error. + :type error: ~azure.communication.chat.models.ChatError """ _validation = { - "error": {"required": True}, + 'error': {'required': True}, } _attribute_map = { - "error": {"key": "error", "type": "ChatError"}, + 'error': {'key': 'error', 'type': 'ChatError'}, } - def __init__(self, *, error: "_models.ChatError", **kwargs): - """ - :keyword error: The Communication Services error. Required. - :paramtype error: ~azure.communication.chat.models.ChatError - """ - super().__init__(**kwargs) + def __init__( + self, + *, + error: "ChatError", + **kwargs + ): + super(CommunicationErrorResponse, self).__init__(**kwargs) self.error = error -class CommunicationIdentifierModel(_serialization.Model): +class CommunicationIdentifierModel(msrest.serialization.Model): """Identifies a participant in Azure Communication services. A participant is, for example, a phone number or an Azure communication user. This model must be interpreted as a union: Apart from rawId, at most one further property may be set. - :ivar raw_id: Raw Id of the identifier. Optional in requests, required in responses. - :vartype raw_id: str - :ivar communication_user: The communication user. - :vartype communication_user: ~azure.communication.chat.models.CommunicationUserIdentifierModel - :ivar phone_number: The phone number. - :vartype phone_number: ~azure.communication.chat.models.PhoneNumberIdentifierModel - :ivar microsoft_teams_user: The Microsoft Teams user. - :vartype microsoft_teams_user: - ~azure.communication.chat.models.MicrosoftTeamsUserIdentifierModel + :param raw_id: Raw Id of the identifier. Optional in requests, required in responses. + :type raw_id: str + :param communication_user: The communication user. + :type communication_user: ~azure.communication.chat.models.CommunicationUserIdentifierModel + :param phone_number: The phone number. + :type phone_number: ~azure.communication.chat.models.PhoneNumberIdentifierModel + :param microsoft_teams_user: The Microsoft Teams user. + :type microsoft_teams_user: ~azure.communication.chat.models.MicrosoftTeamsUserIdentifierModel """ _attribute_map = { - "raw_id": {"key": "rawId", "type": "str"}, - "communication_user": {"key": "communicationUser", "type": "CommunicationUserIdentifierModel"}, - "phone_number": {"key": "phoneNumber", "type": "PhoneNumberIdentifierModel"}, - "microsoft_teams_user": {"key": "microsoftTeamsUser", "type": "MicrosoftTeamsUserIdentifierModel"}, + 'raw_id': {'key': 'rawId', 'type': 'str'}, + 'communication_user': {'key': 'communicationUser', 'type': 'CommunicationUserIdentifierModel'}, + 'phone_number': {'key': 'phoneNumber', 'type': 'PhoneNumberIdentifierModel'}, + 'microsoft_teams_user': {'key': 'microsoftTeamsUser', 'type': 'MicrosoftTeamsUserIdentifierModel'}, } def __init__( self, *, raw_id: Optional[str] = None, - communication_user: Optional["_models.CommunicationUserIdentifierModel"] = None, - phone_number: Optional["_models.PhoneNumberIdentifierModel"] = None, - microsoft_teams_user: Optional["_models.MicrosoftTeamsUserIdentifierModel"] = None, + communication_user: Optional["CommunicationUserIdentifierModel"] = None, + phone_number: Optional["PhoneNumberIdentifierModel"] = None, + microsoft_teams_user: Optional["MicrosoftTeamsUserIdentifierModel"] = None, **kwargs ): - """ - :keyword raw_id: Raw Id of the identifier. Optional in requests, required in responses. - :paramtype raw_id: str - :keyword communication_user: The communication user. - :paramtype communication_user: - ~azure.communication.chat.models.CommunicationUserIdentifierModel - :keyword phone_number: The phone number. - :paramtype phone_number: ~azure.communication.chat.models.PhoneNumberIdentifierModel - :keyword microsoft_teams_user: The Microsoft Teams user. - :paramtype microsoft_teams_user: - ~azure.communication.chat.models.MicrosoftTeamsUserIdentifierModel - """ - super().__init__(**kwargs) + super(CommunicationIdentifierModel, self).__init__(**kwargs) self.raw_id = raw_id self.communication_user = communication_user self.phone_number = phone_number self.microsoft_teams_user = microsoft_teams_user -class CommunicationUserIdentifierModel(_serialization.Model): +class CommunicationUserIdentifierModel(msrest.serialization.Model): """A user that got created with an Azure Communication Services resource. All required parameters must be populated in order to send to Azure. - :ivar id: The Id of the communication user. Required. - :vartype id: str + :param id: Required. The Id of the communication user. + :type id: str """ _validation = { - "id": {"required": True}, + 'id': {'required': True}, } _attribute_map = { - "id": {"key": "id", "type": "str"}, + 'id': {'key': 'id', 'type': 'str'}, } - def __init__(self, *, id: str, **kwargs): # pylint: disable=redefined-builtin - """ - :keyword id: The Id of the communication user. Required. - :paramtype id: str - """ - super().__init__(**kwargs) + def __init__( + self, + *, + id: str, + **kwargs + ): + super(CommunicationUserIdentifierModel, self).__init__(**kwargs) self.id = id -class CreateChatThreadRequest(_serialization.Model): +class CreateChatThreadRequest(msrest.serialization.Model): """Request payload for creating a chat thread. All required parameters must be populated in order to send to Azure. - :ivar topic: The chat thread topic. Required. - :vartype topic: str - :ivar participants: Participants to be added to the chat thread. - :vartype participants: list[~azure.communication.chat.models.ChatParticipant] + :param topic: Required. The chat thread topic. + :type topic: str + :param participants: Participants to be added to the chat thread. + :type participants: list[~azure.communication.chat.models.ChatParticipant] """ _validation = { - "topic": {"required": True}, + 'topic': {'required': True}, } _attribute_map = { - "topic": {"key": "topic", "type": "str"}, - "participants": {"key": "participants", "type": "[ChatParticipant]"}, + 'topic': {'key': 'topic', 'type': 'str'}, + 'participants': {'key': 'participants', 'type': '[ChatParticipant]'}, } - def __init__(self, *, topic: str, participants: Optional[List["_models.ChatParticipant"]] = None, **kwargs): - """ - :keyword topic: The chat thread topic. Required. - :paramtype topic: str - :keyword participants: Participants to be added to the chat thread. - :paramtype participants: list[~azure.communication.chat.models.ChatParticipant] - """ - super().__init__(**kwargs) + def __init__( + self, + *, + topic: str, + participants: Optional[List["ChatParticipant"]] = None, + **kwargs + ): + super(CreateChatThreadRequest, self).__init__(**kwargs) self.topic = topic self.participants = participants -class CreateChatThreadResult(_serialization.Model): +class CreateChatThreadResult(msrest.serialization.Model): """Result of the create chat thread operation. Variables are only populated by the server, and will be ignored when sending a request. - :ivar chat_thread: Chat thread. - :vartype chat_thread: ~azure.communication.chat.models.ChatThreadProperties + :param chat_thread: Chat thread. + :type chat_thread: ~azure.communication.chat.models.ChatThreadProperties :ivar invalid_participants: The participants that failed to be added to the chat thread. :vartype invalid_participants: list[~azure.communication.chat.models.ChatError] """ _validation = { - "invalid_participants": {"readonly": True}, + 'invalid_participants': {'readonly': True}, } _attribute_map = { - "chat_thread": {"key": "chatThread", "type": "ChatThreadProperties"}, - "invalid_participants": {"key": "invalidParticipants", "type": "[ChatError]"}, + 'chat_thread': {'key': 'chatThread', 'type': 'ChatThreadProperties'}, + 'invalid_participants': {'key': 'invalidParticipants', 'type': '[ChatError]'}, } - def __init__(self, *, chat_thread: Optional["_models.ChatThreadProperties"] = None, **kwargs): - """ - :keyword chat_thread: Chat thread. - :paramtype chat_thread: ~azure.communication.chat.models.ChatThreadProperties - """ - super().__init__(**kwargs) + def __init__( + self, + *, + chat_thread: Optional["ChatThreadProperties"] = None, + **kwargs + ): + super(CreateChatThreadResult, self).__init__(**kwargs) self.chat_thread = chat_thread self.invalid_participants = None -class MicrosoftTeamsUserIdentifierModel(_serialization.Model): +class MicrosoftTeamsUserIdentifierModel(msrest.serialization.Model): """A Microsoft Teams user. All required parameters must be populated in order to send to Azure. - :ivar user_id: The Id of the Microsoft Teams user. If not anonymous, this is the AAD object Id - of the user. Required. - :vartype user_id: str - :ivar is_anonymous: True if the Microsoft Teams user is anonymous. By default false if missing. - :vartype is_anonymous: bool - :ivar cloud: The cloud that the Microsoft Teams user belongs to. By default 'public' if - missing. Known values are: "public", "dod", and "gcch". - :vartype cloud: str or ~azure.communication.chat.models.CommunicationCloudEnvironmentModel + :param user_id: Required. The Id of the Microsoft Teams user. If not anonymous, this is the AAD + object Id of the user. + :type user_id: str + :param is_anonymous: True if the Microsoft Teams user is anonymous. By default false if + missing. + :type is_anonymous: bool + :param cloud: The cloud that the Microsoft Teams user belongs to. By default 'public' if + missing. Possible values include: "public", "dod", "gcch". + :type cloud: str or ~azure.communication.chat.models.CommunicationCloudEnvironmentModel """ _validation = { - "user_id": {"required": True}, + 'user_id': {'required': True}, } _attribute_map = { - "user_id": {"key": "userId", "type": "str"}, - "is_anonymous": {"key": "isAnonymous", "type": "bool"}, - "cloud": {"key": "cloud", "type": "str"}, + 'user_id': {'key': 'userId', 'type': 'str'}, + 'is_anonymous': {'key': 'isAnonymous', 'type': 'bool'}, + 'cloud': {'key': 'cloud', 'type': 'str'}, } def __init__( @@ -878,78 +761,68 @@ def __init__( *, user_id: str, is_anonymous: Optional[bool] = None, - cloud: Optional[Union[str, "_models.CommunicationCloudEnvironmentModel"]] = None, + cloud: Optional[Union[str, "CommunicationCloudEnvironmentModel"]] = None, **kwargs ): - """ - :keyword user_id: The Id of the Microsoft Teams user. If not anonymous, this is the AAD object - Id of the user. Required. - :paramtype user_id: str - :keyword is_anonymous: True if the Microsoft Teams user is anonymous. By default false if - missing. - :paramtype is_anonymous: bool - :keyword cloud: The cloud that the Microsoft Teams user belongs to. By default 'public' if - missing. Known values are: "public", "dod", and "gcch". - :paramtype cloud: str or ~azure.communication.chat.models.CommunicationCloudEnvironmentModel - """ - super().__init__(**kwargs) + super(MicrosoftTeamsUserIdentifierModel, self).__init__(**kwargs) self.user_id = user_id self.is_anonymous = is_anonymous self.cloud = cloud -class PhoneNumberIdentifierModel(_serialization.Model): +class PhoneNumberIdentifierModel(msrest.serialization.Model): """A phone number. All required parameters must be populated in order to send to Azure. - :ivar value: The phone number in E.164 format. Required. - :vartype value: str + :param value: Required. The phone number in E.164 format. + :type value: str """ _validation = { - "value": {"required": True}, + 'value': {'required': True}, } _attribute_map = { - "value": {"key": "value", "type": "str"}, + 'value': {'key': 'value', 'type': 'str'}, } - def __init__(self, *, value: str, **kwargs): - """ - :keyword value: The phone number in E.164 format. Required. - :paramtype value: str - """ - super().__init__(**kwargs) + def __init__( + self, + *, + value: str, + **kwargs + ): + super(PhoneNumberIdentifierModel, self).__init__(**kwargs) self.value = value -class SendChatMessageRequest(_serialization.Model): +class SendChatMessageRequest(msrest.serialization.Model): """Details of the message to send. All required parameters must be populated in order to send to Azure. - :ivar content: Chat message content. Required. - :vartype content: str - :ivar sender_display_name: The display name of the chat message sender. This property is used + :param content: Required. Chat message content. + :type content: str + :param sender_display_name: The display name of the chat message sender. This property is used to populate sender name for push notifications. - :vartype sender_display_name: str - :ivar type: The chat message type. Known values are: "text", "html", "topicUpdated", - "participantAdded", and "participantRemoved". - :vartype type: str or ~azure.communication.chat.models.ChatMessageType - :ivar metadata: Message metadata. - :vartype metadata: dict[str, str] + :type sender_display_name: str + :param type: The chat message type. Possible values include: "text", "html", "topicUpdated", + "participantAdded", "participantRemoved". + :type type: str or ~azure.communication.chat.models.ChatMessageType + :param metadata: Message metadata. + :type metadata: dict[str, str] """ _validation = { - "content": {"required": True}, + 'content': {'required': True}, } _attribute_map = { - "content": {"key": "content", "type": "str"}, - "sender_display_name": {"key": "senderDisplayName", "type": "str"}, - "type": {"key": "type", "type": "str"}, - "metadata": {"key": "metadata", "type": "{str}"}, + 'content': {'key': 'content', 'type': 'str'}, + 'sender_display_name': {'key': 'senderDisplayName', 'type': 'str'}, + 'type': {'key': 'type', 'type': 'str'}, + 'metadata': {'key': 'metadata', 'type': '{str}'}, } def __init__( @@ -957,144 +830,135 @@ def __init__( *, content: str, sender_display_name: Optional[str] = None, - type: Optional[Union[str, "_models.ChatMessageType"]] = None, + type: Optional[Union[str, "ChatMessageType"]] = None, metadata: Optional[Dict[str, str]] = None, **kwargs ): - """ - :keyword content: Chat message content. Required. - :paramtype content: str - :keyword sender_display_name: The display name of the chat message sender. This property is - used to populate sender name for push notifications. - :paramtype sender_display_name: str - :keyword type: The chat message type. Known values are: "text", "html", "topicUpdated", - "participantAdded", and "participantRemoved". - :paramtype type: str or ~azure.communication.chat.models.ChatMessageType - :keyword metadata: Message metadata. - :paramtype metadata: dict[str, str] - """ - super().__init__(**kwargs) + super(SendChatMessageRequest, self).__init__(**kwargs) self.content = content self.sender_display_name = sender_display_name self.type = type self.metadata = metadata -class SendChatMessageResult(_serialization.Model): +class SendChatMessageResult(msrest.serialization.Model): """Result of the send message operation. All required parameters must be populated in order to send to Azure. - :ivar id: A server-generated message id. Required. - :vartype id: str + :param id: Required. A server-generated message id. + :type id: str """ _validation = { - "id": {"required": True}, + 'id': {'required': True}, } _attribute_map = { - "id": {"key": "id", "type": "str"}, + 'id': {'key': 'id', 'type': 'str'}, } - def __init__(self, *, id: str, **kwargs): # pylint: disable=redefined-builtin - """ - :keyword id: A server-generated message id. Required. - :paramtype id: str - """ - super().__init__(**kwargs) + def __init__( + self, + *, + id: str, + **kwargs + ): + super(SendChatMessageResult, self).__init__(**kwargs) self.id = id -class SendReadReceiptRequest(_serialization.Model): +class SendReadReceiptRequest(msrest.serialization.Model): """Request payload for sending a read receipt. All required parameters must be populated in order to send to Azure. - :ivar chat_message_id: Id of the latest chat message read by the user. Required. - :vartype chat_message_id: str + :param chat_message_id: Required. Id of the latest chat message read by the user. + :type chat_message_id: str """ _validation = { - "chat_message_id": {"required": True}, + 'chat_message_id': {'required': True}, } _attribute_map = { - "chat_message_id": {"key": "chatMessageId", "type": "str"}, + 'chat_message_id': {'key': 'chatMessageId', 'type': 'str'}, } - def __init__(self, *, chat_message_id: str, **kwargs): - """ - :keyword chat_message_id: Id of the latest chat message read by the user. Required. - :paramtype chat_message_id: str - """ - super().__init__(**kwargs) + def __init__( + self, + *, + chat_message_id: str, + **kwargs + ): + super(SendReadReceiptRequest, self).__init__(**kwargs) self.chat_message_id = chat_message_id -class SendTypingNotificationRequest(_serialization.Model): +class SendTypingNotificationRequest(msrest.serialization.Model): """Request payload for typing notifications. - :ivar sender_display_name: The display name of the typing notification sender. This property is - used to populate sender name for push notifications. - :vartype sender_display_name: str + :param sender_display_name: The display name of the typing notification sender. This property + is used to populate sender name for push notifications. + :type sender_display_name: str """ _attribute_map = { - "sender_display_name": {"key": "senderDisplayName", "type": "str"}, + 'sender_display_name': {'key': 'senderDisplayName', 'type': 'str'}, } - def __init__(self, *, sender_display_name: Optional[str] = None, **kwargs): - """ - :keyword sender_display_name: The display name of the typing notification sender. This property - is used to populate sender name for push notifications. - :paramtype sender_display_name: str - """ - super().__init__(**kwargs) + def __init__( + self, + *, + sender_display_name: Optional[str] = None, + **kwargs + ): + super(SendTypingNotificationRequest, self).__init__(**kwargs) self.sender_display_name = sender_display_name -class UpdateChatMessageRequest(_serialization.Model): +class UpdateChatMessageRequest(msrest.serialization.Model): """Request payload for updating a chat message. - :ivar content: Chat message content. - :vartype content: str - :ivar metadata: Message metadata. - :vartype metadata: dict[str, str] + :param content: Chat message content. + :type content: str + :param metadata: Message metadata. + :type metadata: dict[str, str] """ _attribute_map = { - "content": {"key": "content", "type": "str"}, - "metadata": {"key": "metadata", "type": "{str}"}, + 'content': {'key': 'content', 'type': 'str'}, + 'metadata': {'key': 'metadata', 'type': '{str}'}, } - def __init__(self, *, content: Optional[str] = None, metadata: Optional[Dict[str, str]] = None, **kwargs): - """ - :keyword content: Chat message content. - :paramtype content: str - :keyword metadata: Message metadata. - :paramtype metadata: dict[str, str] - """ - super().__init__(**kwargs) + def __init__( + self, + *, + content: Optional[str] = None, + metadata: Optional[Dict[str, str]] = None, + **kwargs + ): + super(UpdateChatMessageRequest, self).__init__(**kwargs) self.content = content self.metadata = metadata -class UpdateChatThreadRequest(_serialization.Model): +class UpdateChatThreadRequest(msrest.serialization.Model): """Request payload for updating a chat thread. - :ivar topic: Chat thread topic. - :vartype topic: str + :param topic: Chat thread topic. + :type topic: str """ _attribute_map = { - "topic": {"key": "topic", "type": "str"}, + 'topic': {'key': 'topic', 'type': 'str'}, } - def __init__(self, *, topic: Optional[str] = None, **kwargs): - """ - :keyword topic: Chat thread topic. - :paramtype topic: str - """ - super().__init__(**kwargs) + def __init__( + self, + *, + topic: Optional[str] = None, + **kwargs + ): + super(UpdateChatThreadRequest, self).__init__(**kwargs) self.topic = topic diff --git a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/operations/__init__.py b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/operations/__init__.py index dbe389acb5e7..ca0d822356d7 100644 --- a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/operations/__init__.py +++ b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/operations/__init__.py @@ -9,13 +9,7 @@ from ._chat_thread_operations import ChatThreadOperations from ._chat_operations import ChatOperations -from ._patch import __all__ as _patch_all -from ._patch import * # type: ignore # pylint: disable=unused-wildcard-import -from ._patch import patch_sdk as _patch_sdk - __all__ = [ - "ChatThreadOperations", - "ChatOperations", + 'ChatThreadOperations', + 'ChatOperations', ] -__all__.extend([p for p in _patch_all if p not in __all__]) -_patch_sdk() diff --git a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/operations/_chat_operations.py b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/operations/_chat_operations.py index 4e13e83e4c75..915d1dbfa95a 100644 --- a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/operations/_chat_operations.py +++ b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/operations/_chat_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -7,378 +6,188 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- import datetime -from typing import Any, Callable, Dict, IO, Iterable, Optional, TypeVar, Union, overload -import urllib.parse - -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) +from typing import TYPE_CHECKING +import warnings + +from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error from azure.core.paging import ItemPaged from azure.core.pipeline import PipelineResponse -from azure.core.pipeline.transport import HttpResponse -from azure.core.rest import HttpRequest -from azure.core.tracing.decorator import distributed_trace -from azure.core.utils import case_insensitive_dict +from azure.core.pipeline.transport import HttpRequest, HttpResponse from .. import models as _models -from .._serialization import Serializer -from .._vendor import _convert_request, _format_url_section - -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] - -_SERIALIZER = Serializer() -_SERIALIZER.client_side_validation = False - - -def build_create_chat_thread_request(*, repeatability_request_id: Optional[str] = None, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-09-07")) # type: str - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop("template_url", "/chat/threads") - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - if repeatability_request_id is not None: - _headers["repeatability-request-id"] = _SERIALIZER.header( - "repeatability_request_id", repeatability_request_id, "str" - ) - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_list_chat_threads_request( - *, max_page_size: Optional[int] = None, start_time: Optional[datetime.datetime] = None, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-09-07")) # type: str - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop("template_url", "/chat/threads") - - # Construct parameters - if max_page_size is not None: - _params["maxPageSize"] = _SERIALIZER.query("max_page_size", max_page_size, "int") - if start_time is not None: - _params["startTime"] = _SERIALIZER.query("start_time", start_time, "iso-8601") - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_delete_chat_thread_request(chat_thread_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-09-07")) # type: str - accept = _headers.pop("Accept", "application/json") +if TYPE_CHECKING: + # pylint: disable=unused-import,ungrouped-imports + from typing import Any, Callable, Dict, Generic, Iterable, Optional, TypeVar - # Construct URL - _url = kwargs.pop("template_url", "/chat/threads/{chatThreadId}") - path_format_arguments = { - "chatThreadId": _SERIALIZER.url("chat_thread_id", chat_thread_id, "str"), - } + T = TypeVar('T') + ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] - _url = _format_url_section(_url, **path_format_arguments) +class ChatOperations(object): + """ChatOperations operations. - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") + You should not instantiate this class directly. Instead, you should create a Client instance that + instantiates it for you and attaches it as an attribute. - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs) - - -class ChatOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.communication.chat.AzureCommunicationChatService`'s - :attr:`chat` attribute. + :ivar models: Alias to model classes used in this operation group. + :type models: ~azure.communication.chat.models + :param client: Client for service requests. + :param config: Configuration of service client. + :param serializer: An object model serializer. + :param deserializer: An object model deserializer. """ models = _models - def __init__(self, *args, **kwargs): - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") + def __init__(self, client, config, serializer, deserializer): + self._client = client + self._serialize = serializer + self._deserialize = deserializer + self._config = config - @overload def create_chat_thread( self, - create_chat_thread_request: _models.CreateChatThreadRequest, - repeatability_request_id: Optional[str] = None, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.CreateChatThreadResult: + create_chat_thread_request, # type: "_models.CreateChatThreadRequest" + repeatability_request_id=None, # type: Optional[str] + **kwargs # type: Any + ): + # type: (...) -> "_models.CreateChatThreadResult" """Creates a chat thread. Creates a chat thread. - :param create_chat_thread_request: Request payload for creating a chat thread. Required. + :param create_chat_thread_request: Request payload for creating a chat thread. :type create_chat_thread_request: ~azure.communication.chat.models.CreateChatThreadRequest :param repeatability_request_id: If specified, the client directs that the request is repeatable; that is, that the client can make the request multiple times with the same Repeatability-Request-Id and get back an appropriate response without the server executing the request multiple times. The value of the Repeatability-Request-Id is an opaque string representing a client-generated, globally unique for all time, identifier for the request. It - is recommended to use version 4 (random) UUIDs. Default value is None. + is recommended to use version 4 (random) UUIDs. :type repeatability_request_id: str - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: CreateChatThreadResult or the result of cls(response) + :return: CreateChatThreadResult, or the result of cls(response) :rtype: ~azure.communication.chat.models.CreateChatThreadResult - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def create_chat_thread( - self, - create_chat_thread_request: IO, - repeatability_request_id: Optional[str] = None, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.CreateChatThreadResult: - """Creates a chat thread. - - Creates a chat thread. - - :param create_chat_thread_request: Request payload for creating a chat thread. Required. - :type create_chat_thread_request: IO - :param repeatability_request_id: If specified, the client directs that the request is - repeatable; that is, that the client can make the request multiple times with the same - Repeatability-Request-Id and get back an appropriate response without the server executing the - request multiple times. The value of the Repeatability-Request-Id is an opaque string - representing a client-generated, globally unique for all time, identifier for the request. It - is recommended to use version 4 (random) UUIDs. Default value is None. - :type repeatability_request_id: str - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :keyword callable cls: A custom type or function that will be passed the direct response - :return: CreateChatThreadResult or the result of cls(response) - :rtype: ~azure.communication.chat.models.CreateChatThreadResult - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace - def create_chat_thread( - self, - create_chat_thread_request: Union[_models.CreateChatThreadRequest, IO], - repeatability_request_id: Optional[str] = None, - **kwargs: Any - ) -> _models.CreateChatThreadResult: - """Creates a chat thread. - - Creates a chat thread. - - :param create_chat_thread_request: Request payload for creating a chat thread. Is either a - model type or a IO type. Required. - :type create_chat_thread_request: ~azure.communication.chat.models.CreateChatThreadRequest or - IO - :param repeatability_request_id: If specified, the client directs that the request is - repeatable; that is, that the client can make the request multiple times with the same - Repeatability-Request-Id and get back an appropriate response without the server executing the - request multiple times. The value of the Repeatability-Request-Id is an opaque string - representing a client-generated, globally unique for all time, identifier for the request. It - is recommended to use version 4 (random) UUIDs. Default value is None. - :type repeatability_request_id: str - :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. - Default value is None. - :paramtype content_type: str - :keyword callable cls: A custom type or function that will be passed the direct response - :return: CreateChatThreadResult or the result of cls(response) - :rtype: ~azure.communication.chat.models.CreateChatThreadResult - :raises ~azure.core.exceptions.HttpResponseError: + :raises: ~azure.core.exceptions.HttpResponseError """ + cls = kwargs.pop('cls', None) # type: ClsType["_models.CreateChatThreadResult"] error_map = { 404: ResourceNotFoundError, 409: ResourceExistsError, - 304: ResourceNotModifiedError, - 401: lambda response: ClientAuthenticationError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 403: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 429: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 503: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), + 401: lambda response: ClientAuthenticationError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 403: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 429: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 503: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.CreateChatThreadResult] - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(create_chat_thread_request, (IO, bytes)): - _content = create_chat_thread_request - else: - _json = self._serialize.body(create_chat_thread_request, "CreateChatThreadRequest") - - request = build_create_chat_thread_request( - repeatability_request_id=repeatability_request_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - template_url=self.create_chat_thread.metadata["url"], - headers=_headers, - params=_params, - ) - request = _convert_request(request) + error_map.update(kwargs.pop('error_map', {})) + api_version = "2021-09-07" + content_type = kwargs.pop("content_type", "application/json") + accept = "application/json" + + # Construct URL + url = self.create_chat_thread.metadata['url'] # type: ignore path_format_arguments = { - "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), + 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), } - request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore - - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs - ) - + url = self._client.format_url(url, **path_format_arguments) + + # Construct parameters + query_parameters = {} # type: Dict[str, Any] + query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') + + # Construct headers + header_parameters = {} # type: Dict[str, Any] + if repeatability_request_id is not None: + header_parameters['repeatability-request-id'] = self._serialize.header("repeatability_request_id", repeatability_request_id, 'str') + header_parameters['Content-Type'] = self._serialize.header("content_type", content_type, 'str') + header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') + + body_content_kwargs = {} # type: Dict[str, Any] + body_content = self._serialize.body(create_chat_thread_request, 'CreateChatThreadRequest') + body_content_kwargs['content'] = body_content + request = self._client.post(url, query_parameters, header_parameters, **body_content_kwargs) + pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs) response = pipeline_response.http_response if response.status_code not in [201]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response) - deserialized = self._deserialize("CreateChatThreadResult", pipeline_response) + deserialized = self._deserialize('CreateChatThreadResult', pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized + create_chat_thread.metadata = {'url': '/chat/threads'} # type: ignore - create_chat_thread.metadata = {"url": "/chat/threads"} # type: ignore - - @distributed_trace def list_chat_threads( - self, max_page_size: Optional[int] = None, start_time: Optional[datetime.datetime] = None, **kwargs: Any - ) -> Iterable["_models.ChatThreadItem"]: + self, + max_page_size=None, # type: Optional[int] + start_time=None, # type: Optional[datetime.datetime] + **kwargs # type: Any + ): + # type: (...) -> Iterable["_models.ChatThreadsItemCollection"] """Gets the list of chat threads of a user. Gets the list of chat threads of a user. - :param max_page_size: The maximum number of chat threads returned per page. Default value is - None. + :param max_page_size: The maximum number of chat threads returned per page. :type max_page_size: int :param start_time: The earliest point in time to get chat threads up to. The timestamp should - be in RFC3339 format: ``yyyy-MM-ddTHH:mm:ssZ``. Default value is None. + be in RFC3339 format: ``yyyy-MM-ddTHH:mm:ssZ``. :type start_time: ~datetime.datetime :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either ChatThreadItem or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.communication.chat.models.ChatThreadItem] - :raises ~azure.core.exceptions.HttpResponseError: + :return: An iterator like instance of either ChatThreadsItemCollection or the result of cls(response) + :rtype: ~azure.core.paging.ItemPaged[~azure.communication.chat.models.ChatThreadsItemCollection] + :raises: ~azure.core.exceptions.HttpResponseError """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str - cls = kwargs.pop("cls", None) # type: ClsType[_models.ChatThreadsItemCollection] - + cls = kwargs.pop('cls', None) # type: ClsType["_models.ChatThreadsItemCollection"] error_map = { 404: ResourceNotFoundError, 409: ResourceExistsError, - 304: ResourceNotModifiedError, - 401: lambda response: ClientAuthenticationError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 403: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 429: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 503: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), + 401: lambda response: ClientAuthenticationError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 403: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 429: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 503: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), } - error_map.update(kwargs.pop("error_map", {}) or {}) + error_map.update(kwargs.pop('error_map', {})) + api_version = "2021-09-07" + accept = "application/json" def prepare_request(next_link=None): - if not next_link: + # Construct headers + header_parameters = {} # type: Dict[str, Any] + header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') - request = build_list_chat_threads_request( - max_page_size=max_page_size, - start_time=start_time, - api_version=api_version, - template_url=self.list_chat_threads.metadata["url"], - headers=_headers, - params=_params, - ) - request = _convert_request(request) + if not next_link: + # Construct URL + url = self.list_chat_threads.metadata['url'] # type: ignore path_format_arguments = { - "endpoint": self._serialize.url( - "self._config.endpoint", self._config.endpoint, "str", skip_quote=True - ), + 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), } - request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore - + url = self._client.format_url(url, **path_format_arguments) + # Construct parameters + query_parameters = {} # type: Dict[str, Any] + if max_page_size is not None: + query_parameters['maxPageSize'] = self._serialize.query("max_page_size", max_page_size, 'int') + if start_time is not None: + query_parameters['startTime'] = self._serialize.query("start_time", start_time, 'iso-8601') + query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') + + request = self._client.get(url, query_parameters, header_parameters) else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._config.api_version - request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - request = _convert_request(request) + url = next_link + query_parameters = {} # type: Dict[str, Any] path_format_arguments = { - "endpoint": self._serialize.url( - "self._config.endpoint", self._config.endpoint, "str", skip_quote=True - ), + 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), } - request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore - request.method = "GET" + url = self._client.format_url(url, **path_format_arguments) + request = self._client.get(url, query_parameters, header_parameters) return request def extract_data(pipeline_response): - deserialized = self._deserialize("ChatThreadsItemCollection", pipeline_response) + deserialized = self._deserialize('ChatThreadsItemCollection', pipeline_response) list_of_elem = deserialized.value if cls: list_of_elem = cls(list_of_elem) @@ -387,9 +196,7 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs - ) + pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs) response = pipeline_response.http_response if response.status_code not in [200]: @@ -398,67 +205,59 @@ def get_next(next_link=None): return pipeline_response - return ItemPaged(get_next, extract_data) - - list_chat_threads.metadata = {"url": "/chat/threads"} # type: ignore + return ItemPaged( + get_next, extract_data + ) + list_chat_threads.metadata = {'url': '/chat/threads'} # type: ignore - @distributed_trace - def delete_chat_thread( # pylint: disable=inconsistent-return-statements - self, chat_thread_id: str, **kwargs: Any - ) -> None: + def delete_chat_thread( + self, + chat_thread_id, # type: str + **kwargs # type: Any + ): + # type: (...) -> None """Deletes a thread. Deletes a thread. - :param chat_thread_id: Id of the thread to be deleted. Required. + :param chat_thread_id: Id of the thread to be deleted. :type chat_thread_id: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None or the result of cls(response) + :return: None, or the result of cls(response) :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: + :raises: ~azure.core.exceptions.HttpResponseError """ + cls = kwargs.pop('cls', None) # type: ClsType[None] error_map = { 404: ResourceNotFoundError, 409: ResourceExistsError, - 304: ResourceNotModifiedError, - 401: lambda response: ClientAuthenticationError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 403: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 429: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 503: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), + 401: lambda response: ClientAuthenticationError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 403: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 429: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 503: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + error_map.update(kwargs.pop('error_map', {})) + api_version = "2021-09-07" + accept = "application/json" - api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str - cls = kwargs.pop("cls", None) # type: ClsType[None] - - request = build_delete_chat_thread_request( - chat_thread_id=chat_thread_id, - api_version=api_version, - template_url=self.delete_chat_thread.metadata["url"], - headers=_headers, - params=_params, - ) - request = _convert_request(request) + # Construct URL + url = self.delete_chat_thread.metadata['url'] # type: ignore path_format_arguments = { - "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), + 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), + 'chatThreadId': self._serialize.url("chat_thread_id", chat_thread_id, 'str'), } - request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore + url = self._client.format_url(url, **path_format_arguments) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs - ) + # Construct parameters + query_parameters = {} # type: Dict[str, Any] + query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') + + # Construct headers + header_parameters = {} # type: Dict[str, Any] + header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') + request = self._client.delete(url, query_parameters, header_parameters) + pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs) response = pipeline_response.http_response if response.status_code not in [204]: @@ -468,4 +267,4 @@ def delete_chat_thread( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete_chat_thread.metadata = {"url": "/chat/threads/{chatThreadId}"} # type: ignore + delete_chat_thread.metadata = {'url': '/chat/threads/{chatThreadId}'} # type: ignore diff --git a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/operations/_chat_thread_operations.py b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/operations/_chat_thread_operations.py index e99049a11bb0..a9e049d59f73 100644 --- a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/operations/_chat_thread_operations.py +++ b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/operations/_chat_thread_operations.py @@ -1,4 +1,3 @@ -# pylint: disable=too-many-lines # coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. @@ -7,504 +6,116 @@ # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- import datetime -from typing import Any, Callable, Dict, IO, Iterable, Optional, TypeVar, Union, overload -import urllib.parse - -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) +from typing import TYPE_CHECKING +import warnings + +from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error from azure.core.paging import ItemPaged from azure.core.pipeline import PipelineResponse -from azure.core.pipeline.transport import HttpResponse -from azure.core.rest import HttpRequest -from azure.core.tracing.decorator import distributed_trace -from azure.core.utils import case_insensitive_dict +from azure.core.pipeline.transport import HttpRequest, HttpResponse from .. import models as _models -from .._serialization import Serializer -from .._vendor import _convert_request, _format_url_section - -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] - -_SERIALIZER = Serializer() -_SERIALIZER.client_side_validation = False - - -def build_list_chat_read_receipts_request( - chat_thread_id: str, *, max_page_size: Optional[int] = None, skip: Optional[int] = None, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-09-07")) # type: str - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop("template_url", "/chat/threads/{chatThreadId}/readReceipts") - path_format_arguments = { - "chatThreadId": _SERIALIZER.url("chat_thread_id", chat_thread_id, "str"), - } - - _url = _format_url_section(_url, **path_format_arguments) - - # Construct parameters - if max_page_size is not None: - _params["maxPageSize"] = _SERIALIZER.query("max_page_size", max_page_size, "int") - if skip is not None: - _params["skip"] = _SERIALIZER.query("skip", skip, "int") - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_send_chat_read_receipt_request(chat_thread_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-09-07")) # type: str - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop("template_url", "/chat/threads/{chatThreadId}/readReceipts") - path_format_arguments = { - "chatThreadId": _SERIALIZER.url("chat_thread_id", chat_thread_id, "str"), - } - - _url = _format_url_section(_url, **path_format_arguments) - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_send_chat_message_request(chat_thread_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-09-07")) # type: str - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop("template_url", "/chat/threads/{chatThreadId}/messages") - path_format_arguments = { - "chatThreadId": _SERIALIZER.url("chat_thread_id", chat_thread_id, "str"), - } - - _url = _format_url_section(_url, **path_format_arguments) - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_list_chat_messages_request( - chat_thread_id: str, - *, - max_page_size: Optional[int] = None, - start_time: Optional[datetime.datetime] = None, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-09-07")) # type: str - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop("template_url", "/chat/threads/{chatThreadId}/messages") - path_format_arguments = { - "chatThreadId": _SERIALIZER.url("chat_thread_id", chat_thread_id, "str"), - } - - _url = _format_url_section(_url, **path_format_arguments) - - # Construct parameters - if max_page_size is not None: - _params["maxPageSize"] = _SERIALIZER.query("max_page_size", max_page_size, "int") - if start_time is not None: - _params["startTime"] = _SERIALIZER.query("start_time", start_time, "iso-8601") - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_get_chat_message_request(chat_thread_id: str, chat_message_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-09-07")) # type: str - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop("template_url", "/chat/threads/{chatThreadId}/messages/{chatMessageId}") - path_format_arguments = { - "chatThreadId": _SERIALIZER.url("chat_thread_id", chat_thread_id, "str"), - "chatMessageId": _SERIALIZER.url("chat_message_id", chat_message_id, "str"), - } - - _url = _format_url_section(_url, **path_format_arguments) - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_update_chat_message_request(chat_thread_id: str, chat_message_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-09-07")) # type: str - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop("template_url", "/chat/threads/{chatThreadId}/messages/{chatMessageId}") - path_format_arguments = { - "chatThreadId": _SERIALIZER.url("chat_thread_id", chat_thread_id, "str"), - "chatMessageId": _SERIALIZER.url("chat_message_id", chat_message_id, "str"), - } - - _url = _format_url_section(_url, **path_format_arguments) - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PATCH", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_delete_chat_message_request(chat_thread_id: str, chat_message_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-09-07")) # type: str - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop("template_url", "/chat/threads/{chatThreadId}/messages/{chatMessageId}") - path_format_arguments = { - "chatThreadId": _SERIALIZER.url("chat_thread_id", chat_thread_id, "str"), - "chatMessageId": _SERIALIZER.url("chat_message_id", chat_message_id, "str"), - } - - _url = _format_url_section(_url, **path_format_arguments) - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_list_chat_participants_request( - chat_thread_id: str, *, max_page_size: Optional[int] = None, skip: Optional[int] = None, **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-09-07")) # type: str - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop("template_url", "/chat/threads/{chatThreadId}/participants") - path_format_arguments = { - "chatThreadId": _SERIALIZER.url("chat_thread_id", chat_thread_id, "str"), - } - - _url = _format_url_section(_url, **path_format_arguments) - - # Construct parameters - if max_page_size is not None: - _params["maxPageSize"] = _SERIALIZER.query("max_page_size", max_page_size, "int") - if skip is not None: - _params["skip"] = _SERIALIZER.query("skip", skip, "int") - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_remove_chat_participant_request(chat_thread_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-09-07")) # type: str - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop("template_url", "/chat/threads/{chatThreadId}/participants/:remove") - path_format_arguments = { - "chatThreadId": _SERIALIZER.url("chat_thread_id", chat_thread_id, "str"), - } - - _url = _format_url_section(_url, **path_format_arguments) - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_add_chat_participants_request(chat_thread_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-09-07")) # type: str - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop("template_url", "/chat/threads/{chatThreadId}/participants/:add") - path_format_arguments = { - "chatThreadId": _SERIALIZER.url("chat_thread_id", chat_thread_id, "str"), - } - - _url = _format_url_section(_url, **path_format_arguments) - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_update_chat_thread_properties_request(chat_thread_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-09-07")) # type: str - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop("template_url", "/chat/threads/{chatThreadId}") - path_format_arguments = { - "chatThreadId": _SERIALIZER.url("chat_thread_id", chat_thread_id, "str"), - } - _url = _format_url_section(_url, **path_format_arguments) +if TYPE_CHECKING: + # pylint: disable=unused-import,ungrouped-imports + from typing import Any, Callable, Dict, Generic, Iterable, Optional, TypeVar - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") + T = TypeVar('T') + ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, Dict[str, Any]], Any]] - # Construct headers - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") +class ChatThreadOperations(object): + """ChatThreadOperations operations. - return HttpRequest(method="PATCH", url=_url, params=_params, headers=_headers, **kwargs) + You should not instantiate this class directly. Instead, you should create a Client instance that + instantiates it for you and attaches it as an attribute. - -def build_get_chat_thread_properties_request(chat_thread_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-09-07")) # type: str - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop("template_url", "/chat/threads/{chatThreadId}") - path_format_arguments = { - "chatThreadId": _SERIALIZER.url("chat_thread_id", chat_thread_id, "str"), - } - - _url = _format_url_section(_url, **path_format_arguments) - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_send_typing_notification_request(chat_thread_id: str, **kwargs: Any) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version = kwargs.pop("api_version", _params.pop("api-version", "2021-09-07")) # type: str - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop("template_url", "/chat/threads/{chatThreadId}/typing") - path_format_arguments = { - "chatThreadId": _SERIALIZER.url("chat_thread_id", chat_thread_id, "str"), - } - - _url = _format_url_section(_url, **path_format_arguments) - - # Construct parameters - _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str") - - # Construct headers - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs) - - -class ChatThreadOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.communication.chat.AzureCommunicationChatService`'s - :attr:`chat_thread` attribute. + :ivar models: Alias to model classes used in this operation group. + :type models: ~azure.communication.chat.models + :param client: Client for service requests. + :param config: Configuration of service client. + :param serializer: An object model serializer. + :param deserializer: An object model deserializer. """ models = _models - def __init__(self, *args, **kwargs): - input_args = list(args) - self._client = input_args.pop(0) if input_args else kwargs.pop("client") - self._config = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize = input_args.pop(0) if input_args else kwargs.pop("deserializer") + def __init__(self, client, config, serializer, deserializer): + self._client = client + self._serialize = serializer + self._deserialize = deserializer + self._config = config - @distributed_trace def list_chat_read_receipts( - self, chat_thread_id: str, max_page_size: Optional[int] = None, skip: Optional[int] = None, **kwargs: Any - ) -> Iterable["_models.ChatMessageReadReceipt"]: + self, + chat_thread_id, # type: str + max_page_size=None, # type: Optional[int] + skip=None, # type: Optional[int] + **kwargs # type: Any + ): + # type: (...) -> Iterable["_models.ChatMessageReadReceiptsCollection"] """Gets chat message read receipts for a thread. Gets chat message read receipts for a thread. - :param chat_thread_id: Thread id to get the chat message read receipts for. Required. + :param chat_thread_id: Thread id to get the chat message read receipts for. :type chat_thread_id: str :param max_page_size: The maximum number of chat message read receipts to be returned per page. - Default value is None. :type max_page_size: int - :param skip: Skips chat message read receipts up to a specified position in response. Default - value is None. + :param skip: Skips chat message read receipts up to a specified position in response. :type skip: int :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either ChatMessageReadReceipt or the result of - cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.communication.chat.models.ChatMessageReadReceipt] - :raises ~azure.core.exceptions.HttpResponseError: + :return: An iterator like instance of either ChatMessageReadReceiptsCollection or the result of cls(response) + :rtype: ~azure.core.paging.ItemPaged[~azure.communication.chat.models.ChatMessageReadReceiptsCollection] + :raises: ~azure.core.exceptions.HttpResponseError """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str - cls = kwargs.pop("cls", None) # type: ClsType[_models.ChatMessageReadReceiptsCollection] - + cls = kwargs.pop('cls', None) # type: ClsType["_models.ChatMessageReadReceiptsCollection"] error_map = { 404: ResourceNotFoundError, 409: ResourceExistsError, - 304: ResourceNotModifiedError, - 401: lambda response: ClientAuthenticationError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 403: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 429: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 503: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), + 401: lambda response: ClientAuthenticationError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 403: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 429: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 503: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), } - error_map.update(kwargs.pop("error_map", {}) or {}) + error_map.update(kwargs.pop('error_map', {})) + api_version = "2021-09-07" + accept = "application/json" def prepare_request(next_link=None): - if not next_link: + # Construct headers + header_parameters = {} # type: Dict[str, Any] + header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') - request = build_list_chat_read_receipts_request( - chat_thread_id=chat_thread_id, - max_page_size=max_page_size, - skip=skip, - api_version=api_version, - template_url=self.list_chat_read_receipts.metadata["url"], - headers=_headers, - params=_params, - ) - request = _convert_request(request) + if not next_link: + # Construct URL + url = self.list_chat_read_receipts.metadata['url'] # type: ignore path_format_arguments = { - "endpoint": self._serialize.url( - "self._config.endpoint", self._config.endpoint, "str", skip_quote=True - ), + 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), + 'chatThreadId': self._serialize.url("chat_thread_id", chat_thread_id, 'str'), } - request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore - + url = self._client.format_url(url, **path_format_arguments) + # Construct parameters + query_parameters = {} # type: Dict[str, Any] + if max_page_size is not None: + query_parameters['maxPageSize'] = self._serialize.query("max_page_size", max_page_size, 'int') + if skip is not None: + query_parameters['skip'] = self._serialize.query("skip", skip, 'int') + query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') + + request = self._client.get(url, query_parameters, header_parameters) else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._config.api_version - request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - request = _convert_request(request) + url = next_link + query_parameters = {} # type: Dict[str, Any] path_format_arguments = { - "endpoint": self._serialize.url( - "self._config.endpoint", self._config.endpoint, "str", skip_quote=True - ), + 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), + 'chatThreadId': self._serialize.url("chat_thread_id", chat_thread_id, 'str'), } - request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore - request.method = "GET" + url = self._client.format_url(url, **path_format_arguments) + request = self._client.get(url, query_parameters, header_parameters) return request def extract_data(pipeline_response): - deserialized = self._deserialize("ChatMessageReadReceiptsCollection", pipeline_response) + deserialized = self._deserialize('ChatMessageReadReceiptsCollection', pipeline_response) list_of_elem = deserialized.value if cls: list_of_elem = cls(list_of_elem) @@ -513,9 +124,7 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs - ) + pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs) response = pipeline_response.http_response if response.status_code not in [200]: @@ -524,137 +133,67 @@ def get_next(next_link=None): return pipeline_response - return ItemPaged(get_next, extract_data) - - list_chat_read_receipts.metadata = {"url": "/chat/threads/{chatThreadId}/readReceipts"} # type: ignore + return ItemPaged( + get_next, extract_data + ) + list_chat_read_receipts.metadata = {'url': '/chat/threads/{chatThreadId}/readReceipts'} # type: ignore - @overload - def send_chat_read_receipt( # pylint: disable=inconsistent-return-statements + def send_chat_read_receipt( self, - chat_thread_id: str, - send_read_receipt_request: _models.SendReadReceiptRequest, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> None: + chat_thread_id, # type: str + send_read_receipt_request, # type: "_models.SendReadReceiptRequest" + **kwargs # type: Any + ): + # type: (...) -> None """Sends a read receipt event to a thread, on behalf of a user. Sends a read receipt event to a thread, on behalf of a user. - :param chat_thread_id: Thread id to send the read receipt event to. Required. + :param chat_thread_id: Thread id to send the read receipt event to. :type chat_thread_id: str - :param send_read_receipt_request: Read receipt details. Required. + :param send_read_receipt_request: Read receipt details. :type send_read_receipt_request: ~azure.communication.chat.models.SendReadReceiptRequest - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :keyword callable cls: A custom type or function that will be passed the direct response - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def send_chat_read_receipt( # pylint: disable=inconsistent-return-statements - self, - chat_thread_id: str, - send_read_receipt_request: IO, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> None: - """Sends a read receipt event to a thread, on behalf of a user. - - Sends a read receipt event to a thread, on behalf of a user. - - :param chat_thread_id: Thread id to send the read receipt event to. Required. - :type chat_thread_id: str - :param send_read_receipt_request: Read receipt details. Required. - :type send_read_receipt_request: IO - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :keyword callable cls: A custom type or function that will be passed the direct response - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace - def send_chat_read_receipt( # pylint: disable=inconsistent-return-statements - self, chat_thread_id: str, send_read_receipt_request: Union[_models.SendReadReceiptRequest, IO], **kwargs: Any - ) -> None: - """Sends a read receipt event to a thread, on behalf of a user. - - Sends a read receipt event to a thread, on behalf of a user. - - :param chat_thread_id: Thread id to send the read receipt event to. Required. - :type chat_thread_id: str - :param send_read_receipt_request: Read receipt details. Is either a model type or a IO type. - Required. - :type send_read_receipt_request: ~azure.communication.chat.models.SendReadReceiptRequest or IO - :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. - Default value is None. - :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None or the result of cls(response) + :return: None, or the result of cls(response) :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: + :raises: ~azure.core.exceptions.HttpResponseError """ + cls = kwargs.pop('cls', None) # type: ClsType[None] error_map = { 404: ResourceNotFoundError, 409: ResourceExistsError, - 304: ResourceNotModifiedError, - 401: lambda response: ClientAuthenticationError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 403: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 429: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 503: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), + 401: lambda response: ClientAuthenticationError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 403: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 429: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 503: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), } - error_map.update(kwargs.pop("error_map", {}) or {}) + error_map.update(kwargs.pop('error_map', {})) + api_version = "2021-09-07" + content_type = kwargs.pop("content_type", "application/json") + accept = "application/json" - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[None] - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(send_read_receipt_request, (IO, bytes)): - _content = send_read_receipt_request - else: - _json = self._serialize.body(send_read_receipt_request, "SendReadReceiptRequest") - - request = build_send_chat_read_receipt_request( - chat_thread_id=chat_thread_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - template_url=self.send_chat_read_receipt.metadata["url"], - headers=_headers, - params=_params, - ) - request = _convert_request(request) + # Construct URL + url = self.send_chat_read_receipt.metadata['url'] # type: ignore path_format_arguments = { - "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), + 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), + 'chatThreadId': self._serialize.url("chat_thread_id", chat_thread_id, 'str'), } - request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore - - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs - ) - + url = self._client.format_url(url, **path_format_arguments) + + # Construct parameters + query_parameters = {} # type: Dict[str, Any] + query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') + + # Construct headers + header_parameters = {} # type: Dict[str, Any] + header_parameters['Content-Type'] = self._serialize.header("content_type", content_type, 'str') + header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') + + body_content_kwargs = {} # type: Dict[str, Any] + body_content = self._serialize.body(send_read_receipt_request, 'SendReadReceiptRequest') + body_content_kwargs['content'] = body_content + request = self._client.post(url, query_parameters, header_parameters, **body_content_kwargs) + pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs) response = pipeline_response.http_response if response.status_code not in [200]: @@ -664,245 +203,150 @@ def send_chat_read_receipt( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - send_chat_read_receipt.metadata = {"url": "/chat/threads/{chatThreadId}/readReceipts"} # type: ignore + send_chat_read_receipt.metadata = {'url': '/chat/threads/{chatThreadId}/readReceipts'} # type: ignore - @overload def send_chat_message( self, - chat_thread_id: str, - send_chat_message_request: _models.SendChatMessageRequest, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.SendChatMessageResult: + chat_thread_id, # type: str + send_chat_message_request, # type: "_models.SendChatMessageRequest" + **kwargs # type: Any + ): + # type: (...) -> "_models.SendChatMessageResult" """Sends a message to a thread. Sends a message to a thread. - :param chat_thread_id: The thread id to send the message to. Required. + :param chat_thread_id: The thread id to send the message to. :type chat_thread_id: str - :param send_chat_message_request: Details of the message to send. Required. + :param send_chat_message_request: Details of the message to send. :type send_chat_message_request: ~azure.communication.chat.models.SendChatMessageRequest - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :keyword callable cls: A custom type or function that will be passed the direct response - :return: SendChatMessageResult or the result of cls(response) - :rtype: ~azure.communication.chat.models.SendChatMessageResult - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def send_chat_message( - self, - chat_thread_id: str, - send_chat_message_request: IO, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.SendChatMessageResult: - """Sends a message to a thread. - - Sends a message to a thread. - - :param chat_thread_id: The thread id to send the message to. Required. - :type chat_thread_id: str - :param send_chat_message_request: Details of the message to send. Required. - :type send_chat_message_request: IO - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: SendChatMessageResult or the result of cls(response) + :return: SendChatMessageResult, or the result of cls(response) :rtype: ~azure.communication.chat.models.SendChatMessageResult - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace - def send_chat_message( - self, chat_thread_id: str, send_chat_message_request: Union[_models.SendChatMessageRequest, IO], **kwargs: Any - ) -> _models.SendChatMessageResult: - """Sends a message to a thread. - - Sends a message to a thread. - - :param chat_thread_id: The thread id to send the message to. Required. - :type chat_thread_id: str - :param send_chat_message_request: Details of the message to send. Is either a model type or a - IO type. Required. - :type send_chat_message_request: ~azure.communication.chat.models.SendChatMessageRequest or IO - :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. - Default value is None. - :paramtype content_type: str - :keyword callable cls: A custom type or function that will be passed the direct response - :return: SendChatMessageResult or the result of cls(response) - :rtype: ~azure.communication.chat.models.SendChatMessageResult - :raises ~azure.core.exceptions.HttpResponseError: + :raises: ~azure.core.exceptions.HttpResponseError """ + cls = kwargs.pop('cls', None) # type: ClsType["_models.SendChatMessageResult"] error_map = { 404: ResourceNotFoundError, 409: ResourceExistsError, - 304: ResourceNotModifiedError, - 401: lambda response: ClientAuthenticationError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 403: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 429: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 503: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), + 401: lambda response: ClientAuthenticationError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 403: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 429: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 503: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.SendChatMessageResult] + error_map.update(kwargs.pop('error_map', {})) + api_version = "2021-09-07" + content_type = kwargs.pop("content_type", "application/json") + accept = "application/json" - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(send_chat_message_request, (IO, bytes)): - _content = send_chat_message_request - else: - _json = self._serialize.body(send_chat_message_request, "SendChatMessageRequest") - - request = build_send_chat_message_request( - chat_thread_id=chat_thread_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - template_url=self.send_chat_message.metadata["url"], - headers=_headers, - params=_params, - ) - request = _convert_request(request) + # Construct URL + url = self.send_chat_message.metadata['url'] # type: ignore path_format_arguments = { - "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), + 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), + 'chatThreadId': self._serialize.url("chat_thread_id", chat_thread_id, 'str'), } - request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore - - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs - ) - + url = self._client.format_url(url, **path_format_arguments) + + # Construct parameters + query_parameters = {} # type: Dict[str, Any] + query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') + + # Construct headers + header_parameters = {} # type: Dict[str, Any] + header_parameters['Content-Type'] = self._serialize.header("content_type", content_type, 'str') + header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') + + body_content_kwargs = {} # type: Dict[str, Any] + body_content = self._serialize.body(send_chat_message_request, 'SendChatMessageRequest') + body_content_kwargs['content'] = body_content + request = self._client.post(url, query_parameters, header_parameters, **body_content_kwargs) + pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs) response = pipeline_response.http_response if response.status_code not in [201]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response) - deserialized = self._deserialize("SendChatMessageResult", pipeline_response) + deserialized = self._deserialize('SendChatMessageResult', pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized + send_chat_message.metadata = {'url': '/chat/threads/{chatThreadId}/messages'} # type: ignore - send_chat_message.metadata = {"url": "/chat/threads/{chatThreadId}/messages"} # type: ignore - - @distributed_trace def list_chat_messages( self, - chat_thread_id: str, - max_page_size: Optional[int] = None, - start_time: Optional[datetime.datetime] = None, - **kwargs: Any - ) -> Iterable["_models.ChatMessage"]: + chat_thread_id, # type: str + max_page_size=None, # type: Optional[int] + start_time=None, # type: Optional[datetime.datetime] + **kwargs # type: Any + ): + # type: (...) -> Iterable["_models.ChatMessagesCollection"] """Gets a list of messages from a thread. Gets a list of messages from a thread. - :param chat_thread_id: The thread id of the message. Required. + :param chat_thread_id: The thread id of the message. :type chat_thread_id: str - :param max_page_size: The maximum number of messages to be returned per page. Default value is - None. + :param max_page_size: The maximum number of messages to be returned per page. :type max_page_size: int :param start_time: The earliest point in time to get messages up to. The timestamp should be in - RFC3339 format: ``yyyy-MM-ddTHH:mm:ssZ``. Default value is None. + RFC3339 format: ``yyyy-MM-ddTHH:mm:ssZ``. :type start_time: ~datetime.datetime :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either ChatMessage or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.communication.chat.models.ChatMessage] - :raises ~azure.core.exceptions.HttpResponseError: + :return: An iterator like instance of either ChatMessagesCollection or the result of cls(response) + :rtype: ~azure.core.paging.ItemPaged[~azure.communication.chat.models.ChatMessagesCollection] + :raises: ~azure.core.exceptions.HttpResponseError """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str - cls = kwargs.pop("cls", None) # type: ClsType[_models.ChatMessagesCollection] - + cls = kwargs.pop('cls', None) # type: ClsType["_models.ChatMessagesCollection"] error_map = { 404: ResourceNotFoundError, 409: ResourceExistsError, - 304: ResourceNotModifiedError, - 401: lambda response: ClientAuthenticationError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 403: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 429: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 503: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), + 401: lambda response: ClientAuthenticationError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 403: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 429: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 503: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), } - error_map.update(kwargs.pop("error_map", {}) or {}) + error_map.update(kwargs.pop('error_map', {})) + api_version = "2021-09-07" + accept = "application/json" def prepare_request(next_link=None): - if not next_link: + # Construct headers + header_parameters = {} # type: Dict[str, Any] + header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') - request = build_list_chat_messages_request( - chat_thread_id=chat_thread_id, - max_page_size=max_page_size, - start_time=start_time, - api_version=api_version, - template_url=self.list_chat_messages.metadata["url"], - headers=_headers, - params=_params, - ) - request = _convert_request(request) + if not next_link: + # Construct URL + url = self.list_chat_messages.metadata['url'] # type: ignore path_format_arguments = { - "endpoint": self._serialize.url( - "self._config.endpoint", self._config.endpoint, "str", skip_quote=True - ), + 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), + 'chatThreadId': self._serialize.url("chat_thread_id", chat_thread_id, 'str'), } - request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore - + url = self._client.format_url(url, **path_format_arguments) + # Construct parameters + query_parameters = {} # type: Dict[str, Any] + if max_page_size is not None: + query_parameters['maxPageSize'] = self._serialize.query("max_page_size", max_page_size, 'int') + if start_time is not None: + query_parameters['startTime'] = self._serialize.query("start_time", start_time, 'iso-8601') + query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') + + request = self._client.get(url, query_parameters, header_parameters) else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._config.api_version - request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - request = _convert_request(request) + url = next_link + query_parameters = {} # type: Dict[str, Any] path_format_arguments = { - "endpoint": self._serialize.url( - "self._config.endpoint", self._config.endpoint, "str", skip_quote=True - ), + 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), + 'chatThreadId': self._serialize.url("chat_thread_id", chat_thread_id, 'str'), } - request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore - request.method = "GET" + url = self._client.format_url(url, **path_format_arguments) + request = self._client.get(url, query_parameters, header_parameters) return request def extract_data(pipeline_response): - deserialized = self._deserialize("ChatMessagesCollection", pipeline_response) + deserialized = self._deserialize('ChatMessagesCollection', pipeline_response) list_of_elem = deserialized.value if cls: list_of_elem = cls(list_of_elem) @@ -911,9 +355,7 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs - ) + pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs) response = pipeline_response.http_response if response.status_code not in [200]: @@ -922,224 +364,137 @@ def get_next(next_link=None): return pipeline_response - return ItemPaged(get_next, extract_data) - - list_chat_messages.metadata = {"url": "/chat/threads/{chatThreadId}/messages"} # type: ignore + return ItemPaged( + get_next, extract_data + ) + list_chat_messages.metadata = {'url': '/chat/threads/{chatThreadId}/messages'} # type: ignore - @distributed_trace - def get_chat_message(self, chat_thread_id: str, chat_message_id: str, **kwargs: Any) -> _models.ChatMessage: + def get_chat_message( + self, + chat_thread_id, # type: str + chat_message_id, # type: str + **kwargs # type: Any + ): + # type: (...) -> "_models.ChatMessage" """Gets a message by id. Gets a message by id. - :param chat_thread_id: The thread id to which the message was sent. Required. + :param chat_thread_id: The thread id to which the message was sent. :type chat_thread_id: str - :param chat_message_id: The message id. Required. + :param chat_message_id: The message id. :type chat_message_id: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: ChatMessage or the result of cls(response) + :return: ChatMessage, or the result of cls(response) :rtype: ~azure.communication.chat.models.ChatMessage - :raises ~azure.core.exceptions.HttpResponseError: + :raises: ~azure.core.exceptions.HttpResponseError """ + cls = kwargs.pop('cls', None) # type: ClsType["_models.ChatMessage"] error_map = { 404: ResourceNotFoundError, 409: ResourceExistsError, - 304: ResourceNotModifiedError, - 401: lambda response: ClientAuthenticationError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 403: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 429: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 503: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), + 401: lambda response: ClientAuthenticationError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 403: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 429: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 503: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str - cls = kwargs.pop("cls", None) # type: ClsType[_models.ChatMessage] + error_map.update(kwargs.pop('error_map', {})) + api_version = "2021-09-07" + accept = "application/json" - request = build_get_chat_message_request( - chat_thread_id=chat_thread_id, - chat_message_id=chat_message_id, - api_version=api_version, - template_url=self.get_chat_message.metadata["url"], - headers=_headers, - params=_params, - ) - request = _convert_request(request) + # Construct URL + url = self.get_chat_message.metadata['url'] # type: ignore path_format_arguments = { - "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), + 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), + 'chatThreadId': self._serialize.url("chat_thread_id", chat_thread_id, 'str'), + 'chatMessageId': self._serialize.url("chat_message_id", chat_message_id, 'str'), } - request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore + url = self._client.format_url(url, **path_format_arguments) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs - ) + # Construct parameters + query_parameters = {} # type: Dict[str, Any] + query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') + + # Construct headers + header_parameters = {} # type: Dict[str, Any] + header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') + request = self._client.get(url, query_parameters, header_parameters) + pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs) response = pipeline_response.http_response if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response) - deserialized = self._deserialize("ChatMessage", pipeline_response) + deserialized = self._deserialize('ChatMessage', pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized + get_chat_message.metadata = {'url': '/chat/threads/{chatThreadId}/messages/{chatMessageId}'} # type: ignore - get_chat_message.metadata = {"url": "/chat/threads/{chatThreadId}/messages/{chatMessageId}"} # type: ignore - - @overload - def update_chat_message( # pylint: disable=inconsistent-return-statements + def update_chat_message( self, - chat_thread_id: str, - chat_message_id: str, - update_chat_message_request: _models.UpdateChatMessageRequest, - *, - content_type: str = "application/merge-patch+json", - **kwargs: Any - ) -> None: + chat_thread_id, # type: str + chat_message_id, # type: str + update_chat_message_request, # type: "_models.UpdateChatMessageRequest" + **kwargs # type: Any + ): + # type: (...) -> None """Updates a message. Updates a message. - :param chat_thread_id: The thread id to which the message was sent. Required. + :param chat_thread_id: The thread id to which the message was sent. :type chat_thread_id: str - :param chat_message_id: The message id. Required. + :param chat_message_id: The message id. :type chat_message_id: str - :param update_chat_message_request: Details of the request to update the message. Required. + :param update_chat_message_request: Details of the request to update the message. :type update_chat_message_request: ~azure.communication.chat.models.UpdateChatMessageRequest - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/merge-patch+json". - :paramtype content_type: str - :keyword callable cls: A custom type or function that will be passed the direct response - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def update_chat_message( # pylint: disable=inconsistent-return-statements - self, - chat_thread_id: str, - chat_message_id: str, - update_chat_message_request: IO, - *, - content_type: str = "application/merge-patch+json", - **kwargs: Any - ) -> None: - """Updates a message. - - Updates a message. - - :param chat_thread_id: The thread id to which the message was sent. Required. - :type chat_thread_id: str - :param chat_message_id: The message id. Required. - :type chat_message_id: str - :param update_chat_message_request: Details of the request to update the message. Required. - :type update_chat_message_request: IO - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/merge-patch+json". - :paramtype content_type: str - :keyword callable cls: A custom type or function that will be passed the direct response - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace - def update_chat_message( # pylint: disable=inconsistent-return-statements - self, - chat_thread_id: str, - chat_message_id: str, - update_chat_message_request: Union[_models.UpdateChatMessageRequest, IO], - **kwargs: Any - ) -> None: - """Updates a message. - - Updates a message. - - :param chat_thread_id: The thread id to which the message was sent. Required. - :type chat_thread_id: str - :param chat_message_id: The message id. Required. - :type chat_message_id: str - :param update_chat_message_request: Details of the request to update the message. Is either a - model type or a IO type. Required. - :type update_chat_message_request: ~azure.communication.chat.models.UpdateChatMessageRequest or - IO - :keyword content_type: Body Parameter content-type. Known values are: - 'application/merge-patch+json'. Default value is None. - :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None or the result of cls(response) + :return: None, or the result of cls(response) :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: + :raises: ~azure.core.exceptions.HttpResponseError """ + cls = kwargs.pop('cls', None) # type: ClsType[None] error_map = { 404: ResourceNotFoundError, 409: ResourceExistsError, - 304: ResourceNotModifiedError, - 401: lambda response: ClientAuthenticationError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 403: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 429: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 503: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), + 401: lambda response: ClientAuthenticationError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 403: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 429: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 503: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + error_map.update(kwargs.pop('error_map', {})) + api_version = "2021-09-07" + content_type = kwargs.pop("content_type", "application/merge-patch+json") + accept = "application/json" - api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[None] - - content_type = content_type or "application/merge-patch+json" - _json = None - _content = None - if isinstance(update_chat_message_request, (IO, bytes)): - _content = update_chat_message_request - else: - _json = self._serialize.body(update_chat_message_request, "UpdateChatMessageRequest") - - request = build_update_chat_message_request( - chat_thread_id=chat_thread_id, - chat_message_id=chat_message_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - template_url=self.update_chat_message.metadata["url"], - headers=_headers, - params=_params, - ) - request = _convert_request(request) + # Construct URL + url = self.update_chat_message.metadata['url'] # type: ignore path_format_arguments = { - "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), + 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), + 'chatThreadId': self._serialize.url("chat_thread_id", chat_thread_id, 'str'), + 'chatMessageId': self._serialize.url("chat_message_id", chat_message_id, 'str'), } - request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore - - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs - ) - + url = self._client.format_url(url, **path_format_arguments) + + # Construct parameters + query_parameters = {} # type: Dict[str, Any] + query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') + + # Construct headers + header_parameters = {} # type: Dict[str, Any] + header_parameters['Content-Type'] = self._serialize.header("content_type", content_type, 'str') + header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') + + body_content_kwargs = {} # type: Dict[str, Any] + body_content = self._serialize.body(update_chat_message_request, 'UpdateChatMessageRequest') + body_content_kwargs['content'] = body_content + request = self._client.patch(url, query_parameters, header_parameters, **body_content_kwargs) + pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs) response = pipeline_response.http_response if response.status_code not in [204]: @@ -1149,68 +504,60 @@ def update_chat_message( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - update_chat_message.metadata = {"url": "/chat/threads/{chatThreadId}/messages/{chatMessageId}"} # type: ignore + update_chat_message.metadata = {'url': '/chat/threads/{chatThreadId}/messages/{chatMessageId}'} # type: ignore - @distributed_trace - def delete_chat_message( # pylint: disable=inconsistent-return-statements - self, chat_thread_id: str, chat_message_id: str, **kwargs: Any - ) -> None: + def delete_chat_message( + self, + chat_thread_id, # type: str + chat_message_id, # type: str + **kwargs # type: Any + ): + # type: (...) -> None """Deletes a message. Deletes a message. - :param chat_thread_id: The thread id to which the message was sent. Required. + :param chat_thread_id: The thread id to which the message was sent. :type chat_thread_id: str - :param chat_message_id: The message id. Required. + :param chat_message_id: The message id. :type chat_message_id: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None or the result of cls(response) + :return: None, or the result of cls(response) :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: + :raises: ~azure.core.exceptions.HttpResponseError """ + cls = kwargs.pop('cls', None) # type: ClsType[None] error_map = { 404: ResourceNotFoundError, 409: ResourceExistsError, - 304: ResourceNotModifiedError, - 401: lambda response: ClientAuthenticationError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 403: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 429: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 503: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), + 401: lambda response: ClientAuthenticationError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 403: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 429: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 503: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str - cls = kwargs.pop("cls", None) # type: ClsType[None] + error_map.update(kwargs.pop('error_map', {})) + api_version = "2021-09-07" + accept = "application/json" - request = build_delete_chat_message_request( - chat_thread_id=chat_thread_id, - chat_message_id=chat_message_id, - api_version=api_version, - template_url=self.delete_chat_message.metadata["url"], - headers=_headers, - params=_params, - ) - request = _convert_request(request) + # Construct URL + url = self.delete_chat_message.metadata['url'] # type: ignore path_format_arguments = { - "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), + 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), + 'chatThreadId': self._serialize.url("chat_thread_id", chat_thread_id, 'str'), + 'chatMessageId': self._serialize.url("chat_message_id", chat_message_id, 'str'), } - request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore + url = self._client.format_url(url, **path_format_arguments) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs - ) + # Construct parameters + query_parameters = {} # type: Dict[str, Any] + query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') + # Construct headers + header_parameters = {} # type: Dict[str, Any] + header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') + + request = self._client.delete(url, query_parameters, header_parameters) + pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs) response = pipeline_response.http_response if response.status_code not in [204]: @@ -1220,98 +567,79 @@ def delete_chat_message( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - delete_chat_message.metadata = {"url": "/chat/threads/{chatThreadId}/messages/{chatMessageId}"} # type: ignore + delete_chat_message.metadata = {'url': '/chat/threads/{chatThreadId}/messages/{chatMessageId}'} # type: ignore - @distributed_trace def list_chat_participants( - self, chat_thread_id: str, max_page_size: Optional[int] = None, skip: Optional[int] = None, **kwargs: Any - ) -> Iterable["_models.ChatParticipant"]: + self, + chat_thread_id, # type: str + max_page_size=None, # type: Optional[int] + skip=None, # type: Optional[int] + **kwargs # type: Any + ): + # type: (...) -> Iterable["_models.ChatParticipantsCollection"] """Gets the participants of a thread. Gets the participants of a thread. - :param chat_thread_id: Thread id to get participants for. Required. + :param chat_thread_id: Thread id to get participants for. :type chat_thread_id: str - :param max_page_size: The maximum number of participants to be returned per page. Default value - is None. + :param max_page_size: The maximum number of participants to be returned per page. :type max_page_size: int - :param skip: Skips participants up to a specified position in response. Default value is None. + :param skip: Skips participants up to a specified position in response. :type skip: int :keyword callable cls: A custom type or function that will be passed the direct response - :return: An iterator like instance of either ChatParticipant or the result of cls(response) - :rtype: ~azure.core.paging.ItemPaged[~azure.communication.chat.models.ChatParticipant] - :raises ~azure.core.exceptions.HttpResponseError: + :return: An iterator like instance of either ChatParticipantsCollection or the result of cls(response) + :rtype: ~azure.core.paging.ItemPaged[~azure.communication.chat.models.ChatParticipantsCollection] + :raises: ~azure.core.exceptions.HttpResponseError """ - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str - cls = kwargs.pop("cls", None) # type: ClsType[_models.ChatParticipantsCollection] - + cls = kwargs.pop('cls', None) # type: ClsType["_models.ChatParticipantsCollection"] error_map = { 404: ResourceNotFoundError, 409: ResourceExistsError, - 304: ResourceNotModifiedError, - 401: lambda response: ClientAuthenticationError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 403: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 429: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 503: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), + 401: lambda response: ClientAuthenticationError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 403: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 429: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 503: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), } - error_map.update(kwargs.pop("error_map", {}) or {}) + error_map.update(kwargs.pop('error_map', {})) + api_version = "2021-09-07" + accept = "application/json" def prepare_request(next_link=None): - if not next_link: + # Construct headers + header_parameters = {} # type: Dict[str, Any] + header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') - request = build_list_chat_participants_request( - chat_thread_id=chat_thread_id, - max_page_size=max_page_size, - skip=skip, - api_version=api_version, - template_url=self.list_chat_participants.metadata["url"], - headers=_headers, - params=_params, - ) - request = _convert_request(request) + if not next_link: + # Construct URL + url = self.list_chat_participants.metadata['url'] # type: ignore path_format_arguments = { - "endpoint": self._serialize.url( - "self._config.endpoint", self._config.endpoint, "str", skip_quote=True - ), + 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), + 'chatThreadId': self._serialize.url("chat_thread_id", chat_thread_id, 'str'), } - request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore - + url = self._client.format_url(url, **path_format_arguments) + # Construct parameters + query_parameters = {} # type: Dict[str, Any] + if max_page_size is not None: + query_parameters['maxPageSize'] = self._serialize.query("max_page_size", max_page_size, 'int') + if skip is not None: + query_parameters['skip'] = self._serialize.query("skip", skip, 'int') + query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') + + request = self._client.get(url, query_parameters, header_parameters) else: - # make call to next link with the client's api-version - _parsed_next_link = urllib.parse.urlparse(next_link) - _next_request_params = case_insensitive_dict( - { - key: [urllib.parse.quote(v) for v in value] - for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items() - } - ) - _next_request_params["api-version"] = self._config.api_version - request = HttpRequest( - "GET", urllib.parse.urljoin(next_link, _parsed_next_link.path), params=_next_request_params - ) - request = _convert_request(request) + url = next_link + query_parameters = {} # type: Dict[str, Any] path_format_arguments = { - "endpoint": self._serialize.url( - "self._config.endpoint", self._config.endpoint, "str", skip_quote=True - ), + 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), + 'chatThreadId': self._serialize.url("chat_thread_id", chat_thread_id, 'str'), } - request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore - request.method = "GET" + url = self._client.format_url(url, **path_format_arguments) + request = self._client.get(url, query_parameters, header_parameters) return request def extract_data(pipeline_response): - deserialized = self._deserialize("ChatParticipantsCollection", pipeline_response) + deserialized = self._deserialize('ChatParticipantsCollection', pipeline_response) list_of_elem = deserialized.value if cls: list_of_elem = cls(list_of_elem) @@ -1320,9 +648,7 @@ def extract_data(pipeline_response): def get_next(next_link=None): request = prepare_request(next_link) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs - ) + pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs) response = pipeline_response.http_response if response.status_code not in [200]: @@ -1331,145 +657,68 @@ def get_next(next_link=None): return pipeline_response - return ItemPaged(get_next, extract_data) - - list_chat_participants.metadata = {"url": "/chat/threads/{chatThreadId}/participants"} # type: ignore - - @overload - def remove_chat_participant( # pylint: disable=inconsistent-return-statements - self, - chat_thread_id: str, - participant_communication_identifier: _models.CommunicationIdentifierModel, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> None: - """Remove a participant from a thread. - - Remove a participant from a thread. - - :param chat_thread_id: Thread id to remove the participant from. Required. - :type chat_thread_id: str - :param participant_communication_identifier: Id of the thread participant to remove from the - thread. Required. - :type participant_communication_identifier: - ~azure.communication.chat.models.CommunicationIdentifierModel - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :keyword callable cls: A custom type or function that will be passed the direct response - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def remove_chat_participant( # pylint: disable=inconsistent-return-statements - self, - chat_thread_id: str, - participant_communication_identifier: IO, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> None: - """Remove a participant from a thread. - - Remove a participant from a thread. - - :param chat_thread_id: Thread id to remove the participant from. Required. - :type chat_thread_id: str - :param participant_communication_identifier: Id of the thread participant to remove from the - thread. Required. - :type participant_communication_identifier: IO - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Known values are: 'application/json', 'application/merge-patch+json'. Default value is - "application/json". - :paramtype content_type: str - :keyword callable cls: A custom type or function that will be passed the direct response - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ + return ItemPaged( + get_next, extract_data + ) + list_chat_participants.metadata = {'url': '/chat/threads/{chatThreadId}/participants'} # type: ignore - @distributed_trace - def remove_chat_participant( # pylint: disable=inconsistent-return-statements + def remove_chat_participant( self, - chat_thread_id: str, - participant_communication_identifier: Union[_models.CommunicationIdentifierModel, IO], - **kwargs: Any - ) -> None: + chat_thread_id, # type: str + participant_communication_identifier, # type: "_models.CommunicationIdentifierModel" + **kwargs # type: Any + ): + # type: (...) -> None """Remove a participant from a thread. Remove a participant from a thread. - :param chat_thread_id: Thread id to remove the participant from. Required. + :param chat_thread_id: Thread id to remove the participant from. :type chat_thread_id: str :param participant_communication_identifier: Id of the thread participant to remove from the - thread. Is either a model type or a IO type. Required. - :type participant_communication_identifier: - ~azure.communication.chat.models.CommunicationIdentifierModel or IO - :keyword content_type: Body Parameter content-type. Known values are: 'application/json', - 'application/merge-patch+json'. Default value is None. - :paramtype content_type: str + thread. + :type participant_communication_identifier: ~azure.communication.chat.models.CommunicationIdentifierModel :keyword callable cls: A custom type or function that will be passed the direct response - :return: None or the result of cls(response) + :return: None, or the result of cls(response) :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: + :raises: ~azure.core.exceptions.HttpResponseError """ + cls = kwargs.pop('cls', None) # type: ClsType[None] error_map = { 404: ResourceNotFoundError, 409: ResourceExistsError, - 304: ResourceNotModifiedError, - 401: lambda response: ClientAuthenticationError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 403: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 429: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 503: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), + 401: lambda response: ClientAuthenticationError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 403: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 429: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 503: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[None] + error_map.update(kwargs.pop('error_map', {})) + api_version = "2021-09-07" + content_type = kwargs.pop("content_type", "application/json") + accept = "application/json" - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(participant_communication_identifier, (IO, bytes)): - _content = participant_communication_identifier - else: - _json = self._serialize.body(participant_communication_identifier, "CommunicationIdentifierModel") - - request = build_remove_chat_participant_request( - chat_thread_id=chat_thread_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - template_url=self.remove_chat_participant.metadata["url"], - headers=_headers, - params=_params, - ) - request = _convert_request(request) + # Construct URL + url = self.remove_chat_participant.metadata['url'] # type: ignore path_format_arguments = { - "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), + 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), + 'chatThreadId': self._serialize.url("chat_thread_id", chat_thread_id, 'str'), } - request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore - - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs - ) - + url = self._client.format_url(url, **path_format_arguments) + + # Construct parameters + query_parameters = {} # type: Dict[str, Any] + query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') + + # Construct headers + header_parameters = {} # type: Dict[str, Any] + header_parameters['Content-Type'] = self._serialize.header("content_type", content_type, 'str') + header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') + + body_content_kwargs = {} # type: Dict[str, Any] + body_content = self._serialize.body(participant_communication_identifier, 'CommunicationIdentifierModel') + body_content_kwargs['content'] = body_content + request = self._client.post(url, query_parameters, header_parameters, **body_content_kwargs) + pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs) response = pipeline_response.http_response if response.status_code not in [204]: @@ -1479,283 +728,134 @@ def remove_chat_participant( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - remove_chat_participant.metadata = {"url": "/chat/threads/{chatThreadId}/participants/:remove"} # type: ignore + remove_chat_participant.metadata = {'url': '/chat/threads/{chatThreadId}/participants/:remove'} # type: ignore - @overload def add_chat_participants( self, - chat_thread_id: str, - add_chat_participants_request: _models.AddChatParticipantsRequest, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.AddChatParticipantsResult: + chat_thread_id, # type: str + add_chat_participants_request, # type: "_models.AddChatParticipantsRequest" + **kwargs # type: Any + ): + # type: (...) -> "_models.AddChatParticipantsResult" """Adds thread participants to a thread. If participants already exist, no change occurs. Adds thread participants to a thread. If participants already exist, no change occurs. - :param chat_thread_id: Id of the thread to add participants to. Required. + :param chat_thread_id: Id of the thread to add participants to. :type chat_thread_id: str - :param add_chat_participants_request: Thread participants to be added to the thread. Required. - :type add_chat_participants_request: - ~azure.communication.chat.models.AddChatParticipantsRequest - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str + :param add_chat_participants_request: Thread participants to be added to the thread. + :type add_chat_participants_request: ~azure.communication.chat.models.AddChatParticipantsRequest :keyword callable cls: A custom type or function that will be passed the direct response - :return: AddChatParticipantsResult or the result of cls(response) + :return: AddChatParticipantsResult, or the result of cls(response) :rtype: ~azure.communication.chat.models.AddChatParticipantsResult - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def add_chat_participants( - self, - chat_thread_id: str, - add_chat_participants_request: IO, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> _models.AddChatParticipantsResult: - """Adds thread participants to a thread. If participants already exist, no change occurs. - - Adds thread participants to a thread. If participants already exist, no change occurs. - - :param chat_thread_id: Id of the thread to add participants to. Required. - :type chat_thread_id: str - :param add_chat_participants_request: Thread participants to be added to the thread. Required. - :type add_chat_participants_request: IO - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :keyword callable cls: A custom type or function that will be passed the direct response - :return: AddChatParticipantsResult or the result of cls(response) - :rtype: ~azure.communication.chat.models.AddChatParticipantsResult - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace - def add_chat_participants( - self, - chat_thread_id: str, - add_chat_participants_request: Union[_models.AddChatParticipantsRequest, IO], - **kwargs: Any - ) -> _models.AddChatParticipantsResult: - """Adds thread participants to a thread. If participants already exist, no change occurs. - - Adds thread participants to a thread. If participants already exist, no change occurs. - - :param chat_thread_id: Id of the thread to add participants to. Required. - :type chat_thread_id: str - :param add_chat_participants_request: Thread participants to be added to the thread. Is either - a model type or a IO type. Required. - :type add_chat_participants_request: - ~azure.communication.chat.models.AddChatParticipantsRequest or IO - :keyword content_type: Body Parameter content-type. Known values are: 'application/json'. - Default value is None. - :paramtype content_type: str - :keyword callable cls: A custom type or function that will be passed the direct response - :return: AddChatParticipantsResult or the result of cls(response) - :rtype: ~azure.communication.chat.models.AddChatParticipantsResult - :raises ~azure.core.exceptions.HttpResponseError: + :raises: ~azure.core.exceptions.HttpResponseError """ + cls = kwargs.pop('cls', None) # type: ClsType["_models.AddChatParticipantsResult"] error_map = { 404: ResourceNotFoundError, 409: ResourceExistsError, - 304: ResourceNotModifiedError, - 401: lambda response: ClientAuthenticationError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 403: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 429: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 503: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), + 401: lambda response: ClientAuthenticationError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 403: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 429: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 503: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), } - error_map.update(kwargs.pop("error_map", {}) or {}) + error_map.update(kwargs.pop('error_map', {})) + api_version = "2021-09-07" + content_type = kwargs.pop("content_type", "application/json") + accept = "application/json" - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[_models.AddChatParticipantsResult] - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(add_chat_participants_request, (IO, bytes)): - _content = add_chat_participants_request - else: - _json = self._serialize.body(add_chat_participants_request, "AddChatParticipantsRequest") - - request = build_add_chat_participants_request( - chat_thread_id=chat_thread_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - template_url=self.add_chat_participants.metadata["url"], - headers=_headers, - params=_params, - ) - request = _convert_request(request) + # Construct URL + url = self.add_chat_participants.metadata['url'] # type: ignore path_format_arguments = { - "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), + 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), + 'chatThreadId': self._serialize.url("chat_thread_id", chat_thread_id, 'str'), } - request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore - - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs - ) - + url = self._client.format_url(url, **path_format_arguments) + + # Construct parameters + query_parameters = {} # type: Dict[str, Any] + query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') + + # Construct headers + header_parameters = {} # type: Dict[str, Any] + header_parameters['Content-Type'] = self._serialize.header("content_type", content_type, 'str') + header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') + + body_content_kwargs = {} # type: Dict[str, Any] + body_content = self._serialize.body(add_chat_participants_request, 'AddChatParticipantsRequest') + body_content_kwargs['content'] = body_content + request = self._client.post(url, query_parameters, header_parameters, **body_content_kwargs) + pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs) response = pipeline_response.http_response if response.status_code not in [201]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response) - deserialized = self._deserialize("AddChatParticipantsResult", pipeline_response) + deserialized = self._deserialize('AddChatParticipantsResult', pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized + add_chat_participants.metadata = {'url': '/chat/threads/{chatThreadId}/participants/:add'} # type: ignore - add_chat_participants.metadata = {"url": "/chat/threads/{chatThreadId}/participants/:add"} # type: ignore - - @overload - def update_chat_thread_properties( # pylint: disable=inconsistent-return-statements + def update_chat_thread_properties( self, - chat_thread_id: str, - update_chat_thread_request: _models.UpdateChatThreadRequest, - *, - content_type: str = "application/merge-patch+json", - **kwargs: Any - ) -> None: + chat_thread_id, # type: str + update_chat_thread_request, # type: "_models.UpdateChatThreadRequest" + **kwargs # type: Any + ): + # type: (...) -> None """Updates a thread's properties. Updates a thread's properties. - :param chat_thread_id: The id of the thread to update. Required. + :param chat_thread_id: The id of the thread to update. :type chat_thread_id: str - :param update_chat_thread_request: Request payload for updating a chat thread. Required. + :param update_chat_thread_request: Request payload for updating a chat thread. :type update_chat_thread_request: ~azure.communication.chat.models.UpdateChatThreadRequest - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/merge-patch+json". - :paramtype content_type: str - :keyword callable cls: A custom type or function that will be passed the direct response - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def update_chat_thread_properties( # pylint: disable=inconsistent-return-statements - self, - chat_thread_id: str, - update_chat_thread_request: IO, - *, - content_type: str = "application/merge-patch+json", - **kwargs: Any - ) -> None: - """Updates a thread's properties. - - Updates a thread's properties. - - :param chat_thread_id: The id of the thread to update. Required. - :type chat_thread_id: str - :param update_chat_thread_request: Request payload for updating a chat thread. Required. - :type update_chat_thread_request: IO - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/merge-patch+json". - :paramtype content_type: str - :keyword callable cls: A custom type or function that will be passed the direct response - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace - def update_chat_thread_properties( # pylint: disable=inconsistent-return-statements - self, chat_thread_id: str, update_chat_thread_request: Union[_models.UpdateChatThreadRequest, IO], **kwargs: Any - ) -> None: - """Updates a thread's properties. - - Updates a thread's properties. - - :param chat_thread_id: The id of the thread to update. Required. - :type chat_thread_id: str - :param update_chat_thread_request: Request payload for updating a chat thread. Is either a - model type or a IO type. Required. - :type update_chat_thread_request: ~azure.communication.chat.models.UpdateChatThreadRequest or - IO - :keyword content_type: Body Parameter content-type. Known values are: - 'application/merge-patch+json'. Default value is None. - :paramtype content_type: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: None or the result of cls(response) + :return: None, or the result of cls(response) :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: + :raises: ~azure.core.exceptions.HttpResponseError """ + cls = kwargs.pop('cls', None) # type: ClsType[None] error_map = { 404: ResourceNotFoundError, 409: ResourceExistsError, - 304: ResourceNotModifiedError, - 401: lambda response: ClientAuthenticationError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 403: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 429: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 503: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), + 401: lambda response: ClientAuthenticationError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 403: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 429: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 503: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[None] + error_map.update(kwargs.pop('error_map', {})) + api_version = "2021-09-07" + content_type = kwargs.pop("content_type", "application/merge-patch+json") + accept = "application/json" - content_type = content_type or "application/merge-patch+json" - _json = None - _content = None - if isinstance(update_chat_thread_request, (IO, bytes)): - _content = update_chat_thread_request - else: - _json = self._serialize.body(update_chat_thread_request, "UpdateChatThreadRequest") - - request = build_update_chat_thread_properties_request( - chat_thread_id=chat_thread_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - template_url=self.update_chat_thread_properties.metadata["url"], - headers=_headers, - params=_params, - ) - request = _convert_request(request) + # Construct URL + url = self.update_chat_thread_properties.metadata['url'] # type: ignore path_format_arguments = { - "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), + 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), + 'chatThreadId': self._serialize.url("chat_thread_id", chat_thread_id, 'str'), } - request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore - - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs - ) - + url = self._client.format_url(url, **path_format_arguments) + + # Construct parameters + query_parameters = {} # type: Dict[str, Any] + query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') + + # Construct headers + header_parameters = {} # type: Dict[str, Any] + header_parameters['Content-Type'] = self._serialize.header("content_type", content_type, 'str') + header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') + + body_content_kwargs = {} # type: Dict[str, Any] + body_content = self._serialize.body(update_chat_thread_request, 'UpdateChatThreadRequest') + body_content_kwargs['content'] = body_content + request = self._client.patch(url, query_parameters, header_parameters, **body_content_kwargs) + pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs) response = pipeline_response.http_response if response.status_code not in [204]: @@ -1765,216 +865,129 @@ def update_chat_thread_properties( # pylint: disable=inconsistent-return-statem if cls: return cls(pipeline_response, None, {}) - update_chat_thread_properties.metadata = {"url": "/chat/threads/{chatThreadId}"} # type: ignore + update_chat_thread_properties.metadata = {'url': '/chat/threads/{chatThreadId}'} # type: ignore - @distributed_trace - def get_chat_thread_properties(self, chat_thread_id: str, **kwargs: Any) -> _models.ChatThreadProperties: + def get_chat_thread_properties( + self, + chat_thread_id, # type: str + **kwargs # type: Any + ): + # type: (...) -> "_models.ChatThreadProperties" """Gets a chat thread's properties. Gets a chat thread's properties. - :param chat_thread_id: Id of the thread. Required. + :param chat_thread_id: Id of the thread. :type chat_thread_id: str :keyword callable cls: A custom type or function that will be passed the direct response - :return: ChatThreadProperties or the result of cls(response) + :return: ChatThreadProperties, or the result of cls(response) :rtype: ~azure.communication.chat.models.ChatThreadProperties - :raises ~azure.core.exceptions.HttpResponseError: + :raises: ~azure.core.exceptions.HttpResponseError """ + cls = kwargs.pop('cls', None) # type: ClsType["_models.ChatThreadProperties"] error_map = { 404: ResourceNotFoundError, 409: ResourceExistsError, - 304: ResourceNotModifiedError, - 401: lambda response: ClientAuthenticationError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 403: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 429: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 503: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), + 401: lambda response: ClientAuthenticationError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 403: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 429: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 503: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str - cls = kwargs.pop("cls", None) # type: ClsType[_models.ChatThreadProperties] + error_map.update(kwargs.pop('error_map', {})) + api_version = "2021-09-07" + accept = "application/json" - request = build_get_chat_thread_properties_request( - chat_thread_id=chat_thread_id, - api_version=api_version, - template_url=self.get_chat_thread_properties.metadata["url"], - headers=_headers, - params=_params, - ) - request = _convert_request(request) + # Construct URL + url = self.get_chat_thread_properties.metadata['url'] # type: ignore path_format_arguments = { - "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), + 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), + 'chatThreadId': self._serialize.url("chat_thread_id", chat_thread_id, 'str'), } - request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore + url = self._client.format_url(url, **path_format_arguments) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs - ) + # Construct parameters + query_parameters = {} # type: Dict[str, Any] + query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') + + # Construct headers + header_parameters = {} # type: Dict[str, Any] + header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') + request = self._client.get(url, query_parameters, header_parameters) + pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs) response = pipeline_response.http_response if response.status_code not in [200]: map_error(status_code=response.status_code, response=response, error_map=error_map) raise HttpResponseError(response=response) - deserialized = self._deserialize("ChatThreadProperties", pipeline_response) + deserialized = self._deserialize('ChatThreadProperties', pipeline_response) if cls: return cls(pipeline_response, deserialized, {}) return deserialized + get_chat_thread_properties.metadata = {'url': '/chat/threads/{chatThreadId}'} # type: ignore - get_chat_thread_properties.metadata = {"url": "/chat/threads/{chatThreadId}"} # type: ignore - - @overload - def send_typing_notification( # pylint: disable=inconsistent-return-statements + def send_typing_notification( self, - chat_thread_id: str, - send_typing_notification_request: Optional[_models.SendTypingNotificationRequest] = None, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> None: + chat_thread_id, # type: str + send_typing_notification_request=None, # type: Optional["_models.SendTypingNotificationRequest"] + **kwargs # type: Any + ): + # type: (...) -> None """Posts a typing event to a thread, on behalf of a user. Posts a typing event to a thread, on behalf of a user. - :param chat_thread_id: Id of the thread. Required. + :param chat_thread_id: Id of the thread. :type chat_thread_id: str - :param send_typing_notification_request: Details of the typing notification request. Default - value is None. - :type send_typing_notification_request: - ~azure.communication.chat.models.SendTypingNotificationRequest - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str + :param send_typing_notification_request: Details of the typing notification request. + :type send_typing_notification_request: ~azure.communication.chat.models.SendTypingNotificationRequest :keyword callable cls: A custom type or function that will be passed the direct response - :return: None or the result of cls(response) + :return: None, or the result of cls(response) :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def send_typing_notification( # pylint: disable=inconsistent-return-statements - self, - chat_thread_id: str, - send_typing_notification_request: Optional[IO] = None, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> None: - """Posts a typing event to a thread, on behalf of a user. - - Posts a typing event to a thread, on behalf of a user. - - :param chat_thread_id: Id of the thread. Required. - :type chat_thread_id: str - :param send_typing_notification_request: Details of the typing notification request. Default - value is None. - :type send_typing_notification_request: IO - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Known values are: 'application/json', 'application/merge-patch+json'. Default value is - "application/json". - :paramtype content_type: str - :keyword callable cls: A custom type or function that will be passed the direct response - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace - def send_typing_notification( # pylint: disable=inconsistent-return-statements - self, - chat_thread_id: str, - send_typing_notification_request: Optional[Union[_models.SendTypingNotificationRequest, IO]] = None, - **kwargs: Any - ) -> None: - """Posts a typing event to a thread, on behalf of a user. - - Posts a typing event to a thread, on behalf of a user. - - :param chat_thread_id: Id of the thread. Required. - :type chat_thread_id: str - :param send_typing_notification_request: Details of the typing notification request. Is either - a model type or a IO type. Default value is None. - :type send_typing_notification_request: - ~azure.communication.chat.models.SendTypingNotificationRequest or IO - :keyword content_type: Body Parameter content-type. Known values are: 'application/json', - 'application/merge-patch+json'. Default value is None. - :paramtype content_type: str - :keyword callable cls: A custom type or function that will be passed the direct response - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: + :raises: ~azure.core.exceptions.HttpResponseError """ + cls = kwargs.pop('cls', None) # type: ClsType[None] error_map = { 404: ResourceNotFoundError, 409: ResourceExistsError, - 304: ResourceNotModifiedError, - 401: lambda response: ClientAuthenticationError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 403: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 429: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), - 503: lambda response: HttpResponseError( - response=response, model=self._deserialize(_models.CommunicationErrorResponse, response) - ), + 401: lambda response: ClientAuthenticationError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 403: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 429: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), + 503: lambda response: HttpResponseError(response=response, model=self._deserialize(_models.CommunicationErrorResponse, response)), } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + error_map.update(kwargs.pop('error_map', {})) + api_version = "2021-09-07" + content_type = kwargs.pop("content_type", "application/json") + accept = "application/json" - api_version = kwargs.pop("api_version", _params.pop("api-version", self._config.api_version)) # type: str - content_type = kwargs.pop("content_type", _headers.pop("Content-Type", None)) # type: Optional[str] - cls = kwargs.pop("cls", None) # type: ClsType[None] - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(send_typing_notification_request, (IO, bytes)): - _content = send_typing_notification_request - else: - if send_typing_notification_request is not None: - _json = self._serialize.body(send_typing_notification_request, "SendTypingNotificationRequest") - else: - _json = None - - request = build_send_typing_notification_request( - chat_thread_id=chat_thread_id, - api_version=api_version, - content_type=content_type, - json=_json, - content=_content, - template_url=self.send_typing_notification.metadata["url"], - headers=_headers, - params=_params, - ) - request = _convert_request(request) + # Construct URL + url = self.send_typing_notification.metadata['url'] # type: ignore path_format_arguments = { - "endpoint": self._serialize.url("self._config.endpoint", self._config.endpoint, "str", skip_quote=True), + 'endpoint': self._serialize.url("self._config.endpoint", self._config.endpoint, 'str', skip_quote=True), + 'chatThreadId': self._serialize.url("chat_thread_id", chat_thread_id, 'str'), } - request.url = self._client.format_url(request.url, **path_format_arguments) # type: ignore + url = self._client.format_url(url, **path_format_arguments) - pipeline_response = self._client._pipeline.run( # type: ignore # pylint: disable=protected-access - request, stream=False, **kwargs - ) + # Construct parameters + query_parameters = {} # type: Dict[str, Any] + query_parameters['api-version'] = self._serialize.query("api_version", api_version, 'str') + # Construct headers + header_parameters = {} # type: Dict[str, Any] + header_parameters['Content-Type'] = self._serialize.header("content_type", content_type, 'str') + header_parameters['Accept'] = self._serialize.header("accept", accept, 'str') + + body_content_kwargs = {} # type: Dict[str, Any] + if send_typing_notification_request is not None: + body_content = self._serialize.body(send_typing_notification_request, 'SendTypingNotificationRequest') + else: + body_content = None + body_content_kwargs['content'] = body_content + request = self._client.post(url, query_parameters, header_parameters, **body_content_kwargs) + pipeline_response = self._client._pipeline.run(request, stream=False, **kwargs) response = pipeline_response.http_response if response.status_code not in [200]: @@ -1984,4 +997,4 @@ def send_typing_notification( # pylint: disable=inconsistent-return-statements if cls: return cls(pipeline_response, None, {}) - send_typing_notification.metadata = {"url": "/chat/threads/{chatThreadId}/typing"} # type: ignore + send_typing_notification.metadata = {'url': '/chat/threads/{chatThreadId}/typing'} # type: ignore diff --git a/sdk/communication/azure-communication-chat/azure/communication/chat/aio/_chat_client_async.py b/sdk/communication/azure-communication-chat/azure/communication/chat/aio/_chat_client_async.py index d03b84e01ff1..3c6c7822ac55 100644 --- a/sdk/communication/azure-communication-chat/azure/communication/chat/aio/_chat_client_async.py +++ b/sdk/communication/azure-communication-chat/azure/communication/chat/aio/_chat_client_async.py @@ -11,7 +11,6 @@ from uuid import uuid4 import six -from azure.core.credentials import TokenCredential, AzureKeyCredential from azure.core.tracing.decorator import distributed_trace from azure.core.tracing.decorator_async import distributed_trace_async from azure.core.pipeline.policies import AsyncBearerTokenCredentialPolicy @@ -36,9 +35,9 @@ CommunicationErrorResponseConverter ) from .._version import SDK_MONIKER -from .._api_versions import DEFAULT_VERSION -class ChatClient(object): + +class ChatClient(object): # pylint: disable=client-accepts-api-version-keyword """A client to interact with the AzureCommunicationService Chat gateway. This client provides operations to create chat thread, delete chat thread, @@ -46,12 +45,8 @@ class ChatClient(object): :param str endpoint: The endpoint of the Azure Communication resource. - :param Union[TokenCredential, AzureKeyCredential] credential: - The credential we use to authenticate against the service. - - :keyword api_version: Azure Communication Chat API version. - Default value is "2021-09-07". Note that overriding this default value may result in unsupported behavior. - :paramtype api_version: str + :param CommunicationTokenCredential credential: + The credentials with which to authenticate. .. admonition:: Example: @@ -65,7 +60,7 @@ class ChatClient(object): def __init__( self, endpoint: str, - credential: Union[TokenCredential, AzureKeyCredential], + credential: CommunicationTokenCredential, **kwargs: Any ) -> None: # type: (...) -> None @@ -84,13 +79,10 @@ def __init__( raise ValueError("Invalid URL: {}".format(endpoint)) self._endpoint = endpoint - self._api_version = kwargs.pop("api_version", DEFAULT_VERSION) self._credential = credential self._client = AzureCommunicationChatService( - self._credential, self._endpoint, - api_version=self._api_version, authentication_policy=AsyncBearerTokenCredentialPolicy(self._credential), sdk_moniker=SDK_MONIKER, **kwargs) diff --git a/sdk/communication/azure-communication-chat/azure/communication/chat/aio/_chat_thread_client_async.py b/sdk/communication/azure-communication-chat/azure/communication/chat/aio/_chat_thread_client_async.py index 0b0b987902db..1ca7d2f9f395 100644 --- a/sdk/communication/azure-communication-chat/azure/communication/chat/aio/_chat_thread_client_async.py +++ b/sdk/communication/azure-communication-chat/azure/communication/chat/aio/_chat_thread_client_async.py @@ -10,7 +10,6 @@ from datetime import datetime import six -from azure.core.credentials import TokenCredential, AzureKeyCredential from azure.core.tracing.decorator import distributed_trace from azure.core.tracing.decorator_async import distributed_trace_async from azure.core.pipeline.policies import AsyncBearerTokenCredentialPolicy @@ -39,10 +38,9 @@ from .._communication_identifier_serializer import serialize_identifier from .._utils import CommunicationErrorResponseConverter from .._version import SDK_MONIKER -from .._api_versions import DEFAULT_VERSION -class ChatThreadClient(object): +class ChatThreadClient(object): # pylint: disable=client-accepts-api-version-keyword """A client to interact with the AzureCommunicationService Chat gateway. Instances of this class is normally retrieved by ChatClient.get_chat_thread_client() @@ -55,15 +53,12 @@ class ChatThreadClient(object): :param str endpoint: The endpoint of the Azure Communication resource. - :param Union[TokenCredential, AzureKeyCredential] credential: - The credential we use to authenticate against the service. + :param CommunicationTokenCredential credential: + The credentials with which to authenticate. The value contains a User + Access Token :param str thread_id: The unique thread id. - :keyword api_version: Azure Communication Chat API version. - Default value is "2021-09-07". Note that overriding this default value may result in unsupported behavior. - :paramtype api_version: str - .. admonition:: Example: .. literalinclude:: ../samples/chat_thread_client_sample_async.py @@ -77,7 +72,7 @@ class ChatThreadClient(object): def __init__( self, endpoint: str, - credential: Union[TokenCredential, AzureKeyCredential], + credential: CommunicationTokenCredential, thread_id: str, **kwargs: Any ): # type: (...) -> None @@ -99,13 +94,10 @@ def __init__( self._thread_id = thread_id self._endpoint = endpoint - self._api_version = kwargs.pop("api_version", DEFAULT_VERSION) self._credential = credential self._client = AzureCommunicationChatService( - self._credential, - self._endpoint, - api_version=self._api_version, + endpoint, authentication_policy=AsyncBearerTokenCredentialPolicy(self._credential), sdk_moniker=SDK_MONIKER, **kwargs) diff --git a/sdk/communication/azure-communication-chat/swagger/SWAGGER.md b/sdk/communication/azure-communication-chat/swagger/SWAGGER.md index 093f2c29b6a1..5631017f096c 100644 --- a/sdk/communication/azure-communication-chat/swagger/SWAGGER.md +++ b/sdk/communication/azure-communication-chat/swagger/SWAGGER.md @@ -17,7 +17,7 @@ autorest SWAGGER.md ```yaml tag: package-chat-2021-09-07 -require: https://raw.githubusercontent.com/Azure/azure-rest-api-specs/8dbeba81f3a838cd4b7efd70234f29cc1cdc7374/specification/communication/data-plane/Chat/readme.md +require: https://raw.githubusercontent.com/Azure/azure-rest-api-specs/main/specification/communication/data-plane/Chat/readme.md output-folder: ../azure/communication/chat/_generated namespace: azure.communication.chat no-namespace-folders: true From 212e2e03ad3460d2d74a52f0f46ac413aeaac114 Mon Sep 17 00:00:00 2001 From: Olena Stoliarova Date: Mon, 24 Oct 2022 12:31:42 +0300 Subject: [PATCH 18/19] rollback chat changes --- .../azure/communication/chat/_api_versions.py | 14 - .../communication/chat/_generated/_patch.py | 20 - .../chat/_generated/_serialization.py | 1970 ----------------- .../communication/chat/_generated/_vendor.py | 27 - .../chat/_generated/aio/_patch.py | 20 - .../chat/_generated/models/_patch.py | 20 - .../chat/_generated/operations/_patch.py | 20 - 7 files changed, 2091 deletions(-) delete mode 100644 sdk/communication/azure-communication-chat/azure/communication/chat/_api_versions.py delete mode 100644 sdk/communication/azure-communication-chat/azure/communication/chat/_generated/_patch.py delete mode 100644 sdk/communication/azure-communication-chat/azure/communication/chat/_generated/_serialization.py delete mode 100644 sdk/communication/azure-communication-chat/azure/communication/chat/_generated/_vendor.py delete mode 100644 sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/_patch.py delete mode 100644 sdk/communication/azure-communication-chat/azure/communication/chat/_generated/models/_patch.py delete mode 100644 sdk/communication/azure-communication-chat/azure/communication/chat/_generated/operations/_patch.py diff --git a/sdk/communication/azure-communication-chat/azure/communication/chat/_api_versions.py b/sdk/communication/azure-communication-chat/azure/communication/chat/_api_versions.py deleted file mode 100644 index 707620078403..000000000000 --- a/sdk/communication/azure-communication-chat/azure/communication/chat/_api_versions.py +++ /dev/null @@ -1,14 +0,0 @@ -# ------------------------------------ -# Copyright (c) Microsoft Corporation. -# Licensed under the MIT License. -# ------------------------------------ - -from enum import Enum -from azure.core import CaseInsensitiveEnumMeta - - -class ApiVersion(str, Enum, metaclass=CaseInsensitiveEnumMeta): - V2021_09_07 = "2021-09-07" - - -DEFAULT_VERSION = ApiVersion.V2021_09_07 diff --git a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/_patch.py b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/_patch.py deleted file mode 100644 index f7dd32510333..000000000000 --- a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/_patch.py +++ /dev/null @@ -1,20 +0,0 @@ -# ------------------------------------ -# Copyright (c) Microsoft Corporation. -# Licensed under the MIT License. -# ------------------------------------ -"""Customize generated code here. - -Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize -""" -from typing import List - -__all__: List[str] = [] # Add all objects you want publicly available to users at this package level - - -def patch_sdk(): - """Do not remove from this file. - - `patch_sdk` is a last resort escape hatch that allows you to do customizations - you can't accomplish using the techniques described in - https://aka.ms/azsdk/python/dpcodegen/python/customize - """ diff --git a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/_serialization.py b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/_serialization.py deleted file mode 100644 index 7c1dedb5133d..000000000000 --- a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/_serialization.py +++ /dev/null @@ -1,1970 +0,0 @@ -# -------------------------------------------------------------------------- -# -# 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 - -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 - -try: - from urllib import quote # type: ignore -except ImportError: - from urllib.parse import quote # type: ignore -import xml.etree.ElementTree as ET - -import isodate - -from typing import Dict, Any, cast, TYPE_CHECKING - -from azure.core.exceptions import DeserializationError, SerializationError, raise_with_traceback - -_BOM = codecs.BOM_UTF8.decode(encoding="utf-8") - -if TYPE_CHECKING: - from typing import Optional, Union, AnyStr, IO, Mapping - - -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, content_type=None): - # type: (Optional[Union[AnyStr, IO]], Optional[str]) -> 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, headers): - # type: (Optional[Union[AnyStr, IO]], 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 # type: ignore - unicode_str = str # type: ignore - -_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 -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 "".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 # type: ignore -except ImportError: - TZ_UTC = UTC() # type: ignore - -_FLATTEN = re.compile(r"(? 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=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(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) - continue - if xml_desc.get("text", False): - serialized.text = new_attr - continue - if isinstance(new_attr, list): - serialized.extend(new_attr) - 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) - 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) - else: # JSON - for k in reversed(keys): - unflattened = {k: new_attr} - new_attr = unflattened - - _new_attr = new_attr - _serialized = serialized - for k in keys: - if k not in _serialized: - _serialized.update(_new_attr) - _new_attr = _new_attr[k] - _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 = data_type.strip("[]{}") - internal_data_type = self.dependencies.get(internal_data_type, 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 = [ - 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_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): - # 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) - return result - except ValueError: - for enum_value in enum_obj: - 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: - 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 = 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=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(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 - 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 - 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 deseralize. - """ - 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__ - - 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 deseralize. - :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) - 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) - 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 value 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 is empty string. - return "" - else: - # None or '', node 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): - 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)) - - @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) - attr = attr + padding - 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) - 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) - - @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): - 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): - 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) - 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() - 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) - 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 diff --git a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/_vendor.py b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/_vendor.py deleted file mode 100644 index 9aad73fc743e..000000000000 --- a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/_vendor.py +++ /dev/null @@ -1,27 +0,0 @@ -# -------------------------------------------------------------------------- -# 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 azure.core.pipeline.transport import HttpRequest - - -def _convert_request(request, files=None): - data = request.content if not files else None - request = HttpRequest(method=request.method, url=request.url, headers=request.headers, data=data) - if files: - request.set_formdata_body(files) - return request - - -def _format_url_section(template, **kwargs): - components = template.split("/") - while components: - try: - return template.format(**kwargs) - except KeyError as key: - formatted_components = template.split("/") - components = [c for c in formatted_components if "{}".format(key.args[0]) not in c] - template = "/".join(components) diff --git a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/_patch.py b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/_patch.py deleted file mode 100644 index f7dd32510333..000000000000 --- a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/_patch.py +++ /dev/null @@ -1,20 +0,0 @@ -# ------------------------------------ -# Copyright (c) Microsoft Corporation. -# Licensed under the MIT License. -# ------------------------------------ -"""Customize generated code here. - -Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize -""" -from typing import List - -__all__: List[str] = [] # Add all objects you want publicly available to users at this package level - - -def patch_sdk(): - """Do not remove from this file. - - `patch_sdk` is a last resort escape hatch that allows you to do customizations - you can't accomplish using the techniques described in - https://aka.ms/azsdk/python/dpcodegen/python/customize - """ diff --git a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/models/_patch.py b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/models/_patch.py deleted file mode 100644 index f7dd32510333..000000000000 --- a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/models/_patch.py +++ /dev/null @@ -1,20 +0,0 @@ -# ------------------------------------ -# Copyright (c) Microsoft Corporation. -# Licensed under the MIT License. -# ------------------------------------ -"""Customize generated code here. - -Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize -""" -from typing import List - -__all__: List[str] = [] # Add all objects you want publicly available to users at this package level - - -def patch_sdk(): - """Do not remove from this file. - - `patch_sdk` is a last resort escape hatch that allows you to do customizations - you can't accomplish using the techniques described in - https://aka.ms/azsdk/python/dpcodegen/python/customize - """ diff --git a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/operations/_patch.py b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/operations/_patch.py deleted file mode 100644 index f7dd32510333..000000000000 --- a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/operations/_patch.py +++ /dev/null @@ -1,20 +0,0 @@ -# ------------------------------------ -# Copyright (c) Microsoft Corporation. -# Licensed under the MIT License. -# ------------------------------------ -"""Customize generated code here. - -Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize -""" -from typing import List - -__all__: List[str] = [] # Add all objects you want publicly available to users at this package level - - -def patch_sdk(): - """Do not remove from this file. - - `patch_sdk` is a last resort escape hatch that allows you to do customizations - you can't accomplish using the techniques described in - https://aka.ms/azsdk/python/dpcodegen/python/customize - """ From 722b360aa7fdfcc455ef33ebf562de0a1c18907e Mon Sep 17 00:00:00 2001 From: Olena Stoliarova Date: Mon, 24 Oct 2022 12:32:44 +0300 Subject: [PATCH 19/19] rollback chat changes --- .../chat/_generated/aio/operations/_patch.py | 20 ------------------- 1 file changed, 20 deletions(-) delete mode 100644 sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/operations/_patch.py diff --git a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/operations/_patch.py b/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/operations/_patch.py deleted file mode 100644 index f7dd32510333..000000000000 --- a/sdk/communication/azure-communication-chat/azure/communication/chat/_generated/aio/operations/_patch.py +++ /dev/null @@ -1,20 +0,0 @@ -# ------------------------------------ -# Copyright (c) Microsoft Corporation. -# Licensed under the MIT License. -# ------------------------------------ -"""Customize generated code here. - -Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize -""" -from typing import List - -__all__: List[str] = [] # Add all objects you want publicly available to users at this package level - - -def patch_sdk(): - """Do not remove from this file. - - `patch_sdk` is a last resort escape hatch that allows you to do customizations - you can't accomplish using the techniques described in - https://aka.ms/azsdk/python/dpcodegen/python/customize - """