Squashed commit of the following:

commit 43bef00
Author: Franko Morales <67804607+cochi2@users.noreply.github.com>
Date:   Tue Oct 5 17:05:52 2021 -0700

    Adding recording apis and download apis (#20749)

    This commit adds Recording and Download Async APIs.

commit d279fc6
Author: ravithanneeru <80485423+ravithanneeru@users.noreply.github.com>
Date:   Tue Oct 5 17:58:48 2021 +0000

    Changes for implementing server calling APIs (#21029)

    * Call automation and recording APIs implementation

    * Changes to call recording APIs

    * Recording download live test - Sync

    * Resolving lint warnings

    * Changing from AsyncHttpReponse to HttpReponse in sync files

    * Removing convertor for StartCallRecording and fix for CI build failure

    * Fixing CI build issues with importing urlparse

    * Updating recording file for recording download parallel

    * skipping test_download_content_to_stream_on_chunks_parallel as it's failing with 401 and needs investigation

    * Resolving lint errors

Author: zihzhan-msft

sdk/communication/azure-communication-callingserver/azure/communication/callingserver/_callingserver_client.py

@@ -64,6 +64,7 @@ class CallingServerClient(object):
             :language: python
             :dedent: 8
     """
+
     def __init__(
         self,
         endpoint,  # type: str
@@ -379,11 +380,11 @@ def cancel_participant_media_operation(
             raise ValueError("media_operation_id can not be None")
 
         cancel_participant_media_operation_request = \
-            CancelParticipantMediaOperationWithCallLocatorRequestConverter.convert(
-                serialize_call_locator(call_locator),
-                serialize_identifier(participant),
-                media_operation_id=media_operation_id
-                )
+        CancelParticipantMediaOperationWithCallLocatorRequestConverter.convert(
+            serialize_call_locator(call_locator),
+            serialize_identifier(participant),
+            media_operation_id=media_operation_id
+            )
 
         return self._server_call_client.cancel_participant_media_operation(
             cancel_participant_media_operation_request=cancel_participant_media_operation_request,
@@ -500,20 +501,19 @@ def download(
         if not CallingServerUtils.is_valid_url(content_url):
             raise ValueError("content_url is invalid")
 
+        # pylint:disable=protected-access
         content_downloader = ContentDownloader(
-            self._callingserver_service_client._client, # pylint:disable=protected-access
-            self._callingserver_service_client._serialize, # pylint:disable=protected-access
-            self._callingserver_service_client._deserialize, # pylint:disable=protected-access
-            self._callingserver_service_client._config) # pylint:disable=protected-access
-        stream_downloader = ContentStreamDownloader(
+            self._callingserver_service_client._client,
+            self._callingserver_service_client._serialize,
+            self._callingserver_service_client._deserialize,
+            self._callingserver_service_client._config)
+
+        return ContentStreamDownloader(
             content_downloader,
-            self._callingserver_service_client._config, # pylint:disable=protected-access
+            self._callingserver_service_client._config,
             start_range,
             end_range,
             endpoint=content_url,
             parallel_download_options=parallel_download_options,
             **kwargs
         )
-        stream_downloader._setup() # pylint:disable=protected-access
-
-        return stream_downloader

sdk/communication/azure-communication-callingserver/azure/communication/callingserver/_communication_identifier_serializer.py

@@ -30,7 +30,8 @@ def serialize_identifier(identifier):
             request_model[identifier.kind] = dict(identifier.properties)
         return request_model
     except AttributeError:
-        raise TypeError("Unsupported identifier type " + identifier.__class__.__name__)
+        raise TypeError("Unsupported identifier type " +
+                        identifier.__class__.__name__)
 
 
 def deserialize_identifier(identifier_model):

sdk/communication/azure-communication-callingserver/azure/communication/callingserver/_download.py

@@ -11,35 +11,7 @@
 from io import BytesIO
 from azure.core.exceptions import HttpResponseError
 from azure.core.tracing.common import with_current_context
-
-
-def parse_length_from_content_range(content_range):
-    '''
-    Parses the content length from the content range header: bytes 1-3/65537
-    '''
-    if content_range is None:
-        return None
-
-    # First, split in space and take the second half: '1-3/65537'
-    # Next, split on slash and take the second half: '65537'
-    # Finally, convert to an int: 65537
-    return int(content_range.split(' ', 1)[1].split('/', 1)[1])
-
-
-def validate_and_format_range_headers(start_range, end_range):
-    # If end range is provided, start range must be provided
-    if (end_range is not None) and start_range is None:
-        raise ValueError("/ value cannot be None.")
-
-    # Format based on whether end_range is present
-    range_header = None
-    if end_range is not None:
-        range_header = 'bytes={0}-{1}'.format(start_range, end_range)
-    elif start_range is not None:
-        range_header = "bytes={0}-".format(start_range)
-
-    return range_header
-
+from .utils._utils import CallingServerUtils
 
 class _ChunkDownloader(object):  # pylint: disable=too-many-instance-attributes
     def __init__(
@@ -120,7 +92,7 @@ def _write_to_stream(self, chunk_data, chunk_start):
             self.stream.write(chunk_data)
 
     def _download_chunk(self, chunk_start, chunk_end):
-        range_header = validate_and_format_range_headers(
+        range_header = CallingServerUtils.validate_and_format_range_headers(
             chunk_start,
             chunk_end
         )
@@ -236,16 +208,14 @@ def __init__(
             initial_request_end = initial_request_start + self._block_size - 1
 
         self._initial_range = (initial_request_start, initial_request_end)
-
-    def _setup(self):
         self._response = self._initial_request()
         if self.size == 0:
             self._current_content = b""
         else:
             self._current_content = self._response.response.internal_response.content  # pylint: disable=protected-access
 
     def _initial_request(self):
-        range_header = validate_and_format_range_headers(
+        range_header = CallingServerUtils.validate_and_format_range_headers(
             self._initial_range[0],
             self._initial_range[1])
         try:
@@ -255,7 +225,7 @@ def _initial_request(self):
                 **self._request_options)
             # Parse the total file size and adjust the download size if ranges
             # were specified
-            self._file_size = parse_length_from_content_range(
+            self._file_size = CallingServerUtils.parse_length_from_content_range(
                 response.response.headers["Content-Range"])
 
             if self._end_range is not None:

sdk/communication/azure-communication-callingserver/azure/communication/callingserver/_shared/models.py

@@ -51,7 +51,7 @@ class CommunicationIdentifier(Protocol):
 )
 
 
-class CommunicationUserIdentifier(object):
+class CommunicationUserIdentifier(CommunicationIdentifier):
     """Represents a user in Azure Communication Service.
 
     :ivar str raw_id: Optional raw ID of the identifier.
@@ -77,7 +77,7 @@ def __init__(self, id, **kwargs):
 )
 
 
-class PhoneNumberIdentifier(object):
+class PhoneNumberIdentifier(CommunicationIdentifier):
     """Represents a phone number.
 
     :ivar str raw_id: Optional raw ID of the identifier.
@@ -125,7 +125,7 @@ def __init__(self, identifier):
 )
 
 
-class MicrosoftTeamsUserIdentifier(object):
+class MicrosoftTeamsUserIdentifier(CommunicationIdentifier):
     """Represents an identifier for a Microsoft Teams user.
 
     :ivar str raw_id: Optional raw ID of the identifier.

sdk/communication/azure-communication-callingserver/azure/communication/callingserver/aio/_callingserver_client_async.py

@@ -11,6 +11,8 @@
 from typing import TYPE_CHECKING, Any, List, Optional  # pylint: disable=unused-import
 
 from azure.core.tracing.decorator_async import distributed_trace_async
+from azure.core.pipeline.transport import HttpResponse
+
 from ..utils._utils import CallingServerUtils
 from .._communication_identifier_serializer import serialize_identifier
 from .._communication_call_locator_serializer import serialize_call_locator
@@ -20,10 +22,16 @@
     CreateCallRequest,
     PhoneNumberIdentifierModel,
     PlayAudioResult,
-    AddParticipantResult
+    AddParticipantResult,
+    StartCallRecordingResult,
+    CallRecordingProperties,
+    StartCallRecordingWithCallLocatorRequest,
+    StartCallRecordingRequest
     )
 from .._shared.models import CommunicationIdentifier
-from .._models import CallLocator
+from ._content_downloader_async import ContentDownloader
+from ._download_async import ContentStreamDownloader
+from .._models import CallLocator, ParallelDownloadOptions
 from ._call_connection_async import CallConnection
 from .._converters import (
     JoinCallRequestConverter,
@@ -66,8 +74,8 @@ def __init__(
         try:
             if not endpoint.lower().startswith('http'):
                 endpoint = "https://" + endpoint
-        except AttributeError:
-            raise ValueError("Account URL must be a string.")
+        except AttributeError as ex:
+            raise ValueError("Account URL must be a string.") from ex
 
         if not credential:
             raise ValueError(
@@ -377,17 +385,134 @@ async def cancel_participant_media_operation(
             raise ValueError("media_operation_id can not be None")
 
         cancel_participant_media_operation_request = \
-            CancelParticipantMediaOperationWithCallLocatorRequestConverter.convert(
-                serialize_call_locator(call_locator),
-                serialize_identifier(participant),
-                media_operation_id=media_operation_id
-                )
+        CancelParticipantMediaOperationWithCallLocatorRequestConverter.convert(
+            serialize_call_locator(call_locator),
+            serialize_identifier(participant),
+            media_operation_id=media_operation_id
+            )
 
         return await self._server_call_client.cancel_participant_media_operation(
             cancel_participant_media_operation_request=cancel_participant_media_operation_request,
             **kwargs
             )
 
+    @distributed_trace_async()
+    async def start_recording(
+        self,
+        call_locator: CallLocator,
+        recording_state_callback_uri: str,
+        **kwargs: Any
+    ) -> StartCallRecordingResult:
+
+        if not call_locator:
+            raise ValueError("call_locator cannot be None")
+        if not CallingServerUtils.is_valid_url(recording_state_callback_uri):
+            raise ValueError("recording_state_callback_uri is invalid")
+
+        start_call_recording_request = StartCallRecordingRequest(
+            recording_state_callback_uri=recording_state_callback_uri,
+            **kwargs
+        )
+
+        start_call_recording_with_calllocator_request = StartCallRecordingWithCallLocatorRequest(
+            call_locator=serialize_call_locator(call_locator),
+            start_call_recording_request=start_call_recording_request
+        )
+
+        return await self._server_call_client.start_recording(
+            start_call_recording_with_calllocator_request,
+            **kwargs
+        )
+
+    @distributed_trace_async()
+    async def pause_recording(
+        self,
+        recording_id: str,
+        **kwargs: Any
+    ) -> HttpResponse:
+
+        if not recording_id:
+            raise ValueError("recording_id cannot be None")
+
+        return await self._server_call_client.pause_recording(
+            recording_id=recording_id,
+            **kwargs
+        )
+
+    @distributed_trace_async()
+    async def resume_recording(
+        self,
+        recording_id: str,
+        **kwargs: Any
+    ) -> HttpResponse:
+
+        if not recording_id:
+            raise ValueError("recording_id cannot be None")
+
+        return await self._server_call_client.resume_recording(
+            recording_id=recording_id,
+            **kwargs
+        )
+
+    @distributed_trace_async()
+    async def stop_recording(
+        self,
+        recording_id: str,
+        **kwargs: Any
+    ) -> HttpResponse:
+
+        if not recording_id:
+            raise ValueError("recording_id cannot be None")
+
+        return await self._server_call_client.stop_recording(
+            recording_id=recording_id,
+            **kwargs
+        )
+
+    @distributed_trace_async()
+    async def get_recording_properities(
+        self,
+        recording_id: str,
+        **kwargs: Any
+    ) -> CallRecordingProperties:
+
+        if not recording_id:
+            raise ValueError("recording_id cannot be None")
+
+        return await self._server_call_client.get_recording_properties(
+            recording_id=recording_id,
+            **kwargs
+        )
+
+    @distributed_trace_async
+    async def download(
+            self,
+            content_url: str,
+            start_range: int = None,
+            end_range: int = None,
+            parallel_download_options: ParallelDownloadOptions = None,
+            **kwargs: Any
+        ) -> ContentStreamDownloader:
+
+        #pylint: disable=protected-access
+        content_downloader = ContentDownloader(
+            self._callingserver_service_client._client,
+            self._callingserver_service_client._config,
+            self._callingserver_service_client._serialize,
+            self._callingserver_service_client._deserialize
+        )
+        stream_downloader = ContentStreamDownloader(
+            content_downloader,
+            self._callingserver_service_client._config,
+            start_range,
+            end_range,
+            endpoint=content_url,
+            parallel_download_options=parallel_download_options,
+            **kwargs
+        )
+        await stream_downloader._setup()
+        return stream_downloader
+
     async def close(self) -> None:
         """Close the :class:
         `~azure.communication.callingserver.aio.CallingServerClient` session.