diracx-client 0.0.1a17__py3-none-any.whl → 0.0.1a19__py3-none-any.whl

diracx/client/{aio → generated/aio}/operations/_operations.py

@@ -1,7 +1,7 @@
 # pylint: disable=too-many-lines,too-many-statements
 # coding=utf-8
 # --------------------------------------------------------------------------
-# Code generated by Microsoft (R) AutoRest Code Generator (autorest: 3.10.2, generator: @autorest/python@6.13.19)
+# Code generated by Microsoft (R) AutoRest Code Generator (autorest: 3.10.0, generator: @autorest/python@6.23.0)
 # Changes may cause incorrect behavior and will be lost if the code is regenerated.
 # --------------------------------------------------------------------------
 from io import IOBase
@@ -94,7 +94,7 @@ class WellKnownOperations:
         **DO NOT** instantiate this class directly.
 
         Instead, you should access the following operations through
-        :class:`~client.aio.Dirac`'s
+        :class:`~generated.aio.Dirac`'s
         :attr:`well_known` attribute.
     """
 
@@ -119,12 +119,14 @@ class WellKnownOperations:
         :rtype: any
         :raises ~azure.core.exceptions.HttpResponseError:
         """
-        error_map: MutableMapping[int, Type[HttpResponseError]] = {
-            401: ClientAuthenticationError,
-            404: ResourceNotFoundError,
-            409: ResourceExistsError,
-            304: ResourceNotModifiedError,
-        }
+        error_map: MutableMapping[int, Type[HttpResponseError]] = (
+            {  # pylint: disable=unsubscriptable-object
+                401: ClientAuthenticationError,
+                404: ResourceNotFoundError,
+                409: ResourceExistsError,
+                304: ResourceNotModifiedError,
+            }
+        )
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = kwargs.pop("headers", {}) or {}
@@ -148,14 +150,12 @@ class WellKnownOperations:
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
-            if _stream:
-                await response.read()  # Load the body in memory and close the socket
             map_error(
                 status_code=response.status_code, response=response, error_map=error_map
             )
             raise HttpResponseError(response=response)
 
-        deserialized = self._deserialize("object", pipeline_response)
+        deserialized = self._deserialize("object", pipeline_response.http_response)
 
         if cls:
             return cls(pipeline_response, deserialized, {})  # type: ignore
@@ -169,15 +169,17 @@ class WellKnownOperations:
         Get metadata about the dirac installation.
 
         :return: Metadata
-        :rtype: ~client.models.Metadata
+        :rtype: ~generated.models.Metadata
         :raises ~azure.core.exceptions.HttpResponseError:
         """
-        error_map: MutableMapping[int, Type[HttpResponseError]] = {
-            401: ClientAuthenticationError,
-            404: ResourceNotFoundError,
-            409: ResourceExistsError,
-            304: ResourceNotModifiedError,
-        }
+        error_map: MutableMapping[int, Type[HttpResponseError]] = (
+            {  # pylint: disable=unsubscriptable-object
+                401: ClientAuthenticationError,
+                404: ResourceNotFoundError,
+                409: ResourceExistsError,
+                304: ResourceNotModifiedError,
+            }
+        )
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = kwargs.pop("headers", {}) or {}
@@ -201,14 +203,12 @@ class WellKnownOperations:
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
-            if _stream:
-                await response.read()  # Load the body in memory and close the socket
             map_error(
                 status_code=response.status_code, response=response, error_map=error_map
             )
             raise HttpResponseError(response=response)
 
-        deserialized = self._deserialize("Metadata", pipeline_response)
+        deserialized = self._deserialize("Metadata", pipeline_response.http_response)
 
         if cls:
             return cls(pipeline_response, deserialized, {})  # type: ignore
@@ -222,7 +222,7 @@ class AuthOperations:  # pylint: disable=abstract-class-instantiated
         **DO NOT** instantiate this class directly.
 
         Instead, you should access the following operations through
-        :class:`~client.aio.Dirac`'s
+        :class:`~generated.aio.Dirac`'s
         :attr:`auth` attribute.
     """
 
@@ -253,7 +253,7 @@ class AuthOperations:  # pylint: disable=abstract-class-instantiated
         Initiate the device flow against DIRAC authorization Server.
         Scope must have exactly up to one ``group`` (otherwise default) and
         one or more ``property`` scope.
-        If no property, then get default one
+        If no property, then get default one.
 
         Offers the user to go with the browser to
         ``auth/<vo>/device?user_code=XYZ``.
@@ -263,15 +263,17 @@ class AuthOperations:  # pylint: disable=abstract-class-instantiated
         :keyword scope: Required.
         :paramtype scope: str
         :return: InitiateDeviceFlowResponse
-        :rtype: ~client.models.InitiateDeviceFlowResponse
+        :rtype: ~generated.models.InitiateDeviceFlowResponse
         :raises ~azure.core.exceptions.HttpResponseError:
         """
-        error_map: MutableMapping[int, Type[HttpResponseError]] = {
-            401: ClientAuthenticationError,
-            404: ResourceNotFoundError,
-            409: ResourceExistsError,
-            304: ResourceNotModifiedError,
-        }
+        error_map: MutableMapping[int, Type[HttpResponseError]] = (
+            {  # pylint: disable=unsubscriptable-object
+                401: ClientAuthenticationError,
+                404: ResourceNotFoundError,
+                409: ResourceExistsError,
+                304: ResourceNotModifiedError,
+            }
+        )
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = kwargs.pop("headers", {}) or {}
@@ -297,15 +299,13 @@ class AuthOperations:  # pylint: disable=abstract-class-instantiated
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
-            if _stream:
-                await response.read()  # Load the body in memory and close the socket
             map_error(
                 status_code=response.status_code, response=response, error_map=error_map
             )
             raise HttpResponseError(response=response)
 
         deserialized = self._deserialize(
-            "InitiateDeviceFlowResponse", pipeline_response
+            "InitiateDeviceFlowResponse", pipeline_response.http_response
         )
 
         if cls:
@@ -332,12 +332,14 @@ class AuthOperations:  # pylint: disable=abstract-class-instantiated
         :rtype: any
         :raises ~azure.core.exceptions.HttpResponseError:
         """
-        error_map: MutableMapping[int, Type[HttpResponseError]] = {
-            401: ClientAuthenticationError,
-            404: ResourceNotFoundError,
-            409: ResourceExistsError,
-            304: ResourceNotModifiedError,
-        }
+        error_map: MutableMapping[int, Type[HttpResponseError]] = (
+            {  # pylint: disable=unsubscriptable-object
+                401: ClientAuthenticationError,
+                404: ResourceNotFoundError,
+                409: ResourceExistsError,
+                304: ResourceNotModifiedError,
+            }
+        )
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = kwargs.pop("headers", {}) or {}
@@ -362,14 +364,12 @@ class AuthOperations:  # pylint: disable=abstract-class-instantiated
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
-            if _stream:
-                await response.read()  # Load the body in memory and close the socket
             map_error(
                 status_code=response.status_code, response=response, error_map=error_map
             )
             raise HttpResponseError(response=response)
 
-        deserialized = self._deserialize("object", pipeline_response)
+        deserialized = self._deserialize("object", pipeline_response.http_response)
 
         if cls:
             return cls(pipeline_response, deserialized, {})  # type: ignore
@@ -394,12 +394,14 @@ class AuthOperations:  # pylint: disable=abstract-class-instantiated
         :rtype: any
         :raises ~azure.core.exceptions.HttpResponseError:
         """
-        error_map: MutableMapping[int, Type[HttpResponseError]] = {
-            401: ClientAuthenticationError,
-            404: ResourceNotFoundError,
-            409: ResourceExistsError,
-            304: ResourceNotModifiedError,
-        }
+        error_map: MutableMapping[int, Type[HttpResponseError]] = (
+            {  # pylint: disable=unsubscriptable-object
+                401: ClientAuthenticationError,
+                404: ResourceNotFoundError,
+                409: ResourceExistsError,
+                304: ResourceNotModifiedError,
+            }
+        )
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = kwargs.pop("headers", {}) or {}
@@ -425,14 +427,12 @@ class AuthOperations:  # pylint: disable=abstract-class-instantiated
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
-            if _stream:
-                await response.read()  # Load the body in memory and close the socket
             map_error(
                 status_code=response.status_code, response=response, error_map=error_map
             )
             raise HttpResponseError(response=response)
 
-        deserialized = self._deserialize("object", pipeline_response)
+        deserialized = self._deserialize("object", pipeline_response.http_response)
 
         if cls:
             return cls(pipeline_response, deserialized, {})  # type: ignore
@@ -449,12 +449,14 @@ class AuthOperations:  # pylint: disable=abstract-class-instantiated
         :rtype: any
         :raises ~azure.core.exceptions.HttpResponseError:
         """
-        error_map: MutableMapping[int, Type[HttpResponseError]] = {
-            401: ClientAuthenticationError,
-            404: ResourceNotFoundError,
-            409: ResourceExistsError,
-            304: ResourceNotModifiedError,
-        }
+        error_map: MutableMapping[int, Type[HttpResponseError]] = (
+            {  # pylint: disable=unsubscriptable-object
+                401: ClientAuthenticationError,
+                404: ResourceNotFoundError,
+                409: ResourceExistsError,
+                304: ResourceNotModifiedError,
+            }
+        )
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = kwargs.pop("headers", {}) or {}
@@ -478,14 +480,12 @@ class AuthOperations:  # pylint: disable=abstract-class-instantiated
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
-            if _stream:
-                await response.read()  # Load the body in memory and close the socket
             map_error(
                 status_code=response.status_code, response=response, error_map=error_map
             )
             raise HttpResponseError(response=response)
 
-        deserialized = self._deserialize("object", pipeline_response)
+        deserialized = self._deserialize("object", pipeline_response.http_response)
 
         if cls:
             return cls(pipeline_response, deserialized, {})  # type: ignore
@@ -503,12 +503,14 @@ class AuthOperations:  # pylint: disable=abstract-class-instantiated
         :rtype: list[any]
         :raises ~azure.core.exceptions.HttpResponseError:
         """
-        error_map: MutableMapping[int, Type[HttpResponseError]] = {
-            401: ClientAuthenticationError,
-            404: ResourceNotFoundError,
-            409: ResourceExistsError,
-            304: ResourceNotModifiedError,
-        }
+        error_map: MutableMapping[int, Type[HttpResponseError]] = (
+            {  # pylint: disable=unsubscriptable-object
+                401: ClientAuthenticationError,
+                404: ResourceNotFoundError,
+                409: ResourceExistsError,
+                304: ResourceNotModifiedError,
+            }
+        )
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = kwargs.pop("headers", {}) or {}
@@ -532,14 +534,12 @@ class AuthOperations:  # pylint: disable=abstract-class-instantiated
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
-            if _stream:
-                await response.read()  # Load the body in memory and close the socket
             map_error(
                 status_code=response.status_code, response=response, error_map=error_map
             )
             raise HttpResponseError(response=response)
 
-        deserialized = self._deserialize("[object]", pipeline_response)
+        deserialized = self._deserialize("[object]", pipeline_response.http_response)
 
         if cls:
             return cls(pipeline_response, deserialized, {})  # type: ignore
@@ -559,12 +559,14 @@ class AuthOperations:  # pylint: disable=abstract-class-instantiated
         :rtype: str
         :raises ~azure.core.exceptions.HttpResponseError:
         """
-        error_map: MutableMapping[int, Type[HttpResponseError]] = {
-            401: ClientAuthenticationError,
-            404: ResourceNotFoundError,
-            409: ResourceExistsError,
-            304: ResourceNotModifiedError,
-        }
+        error_map: MutableMapping[int, Type[HttpResponseError]] = (
+            {  # pylint: disable=unsubscriptable-object
+                401: ClientAuthenticationError,
+                404: ResourceNotFoundError,
+                409: ResourceExistsError,
+                304: ResourceNotModifiedError,
+            }
+        )
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = kwargs.pop("headers", {}) or {}
@@ -589,14 +591,12 @@ class AuthOperations:  # pylint: disable=abstract-class-instantiated
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
-            if _stream:
-                await response.read()  # Load the body in memory and close the socket
             map_error(
                 status_code=response.status_code, response=response, error_map=error_map
             )
             raise HttpResponseError(response=response)
 
-        deserialized = self._deserialize("str", pipeline_response)
+        deserialized = self._deserialize("str", pipeline_response.http_response)
 
         if cls:
             return cls(pipeline_response, deserialized, {})  # type: ignore
@@ -610,15 +610,17 @@ class AuthOperations:  # pylint: disable=abstract-class-instantiated
         Get information about the user's identity.
 
         :return: UserInfoResponse
-        :rtype: ~client.models.UserInfoResponse
+        :rtype: ~generated.models.UserInfoResponse
         :raises ~azure.core.exceptions.HttpResponseError:
         """
-        error_map: MutableMapping[int, Type[HttpResponseError]] = {
-            401: ClientAuthenticationError,
-            404: ResourceNotFoundError,
-            409: ResourceExistsError,
-            304: ResourceNotModifiedError,
-        }
+        error_map: MutableMapping[int, Type[HttpResponseError]] = (
+            {  # pylint: disable=unsubscriptable-object
+                401: ClientAuthenticationError,
+                404: ResourceNotFoundError,
+                409: ResourceExistsError,
+                304: ResourceNotModifiedError,
+            }
+        )
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = kwargs.pop("headers", {}) or {}
@@ -642,14 +644,14 @@ class AuthOperations:  # pylint: disable=abstract-class-instantiated
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
-            if _stream:
-                await response.read()  # Load the body in memory and close the socket
             map_error(
                 status_code=response.status_code, response=response, error_map=error_map
             )
             raise HttpResponseError(response=response)
 
-        deserialized = self._deserialize("UserInfoResponse", pipeline_response)
+        deserialized = self._deserialize(
+            "UserInfoResponse", pipeline_response.http_response
+        )
 
         if cls:
             return cls(pipeline_response, deserialized, {})  # type: ignore
@@ -680,11 +682,11 @@ class AuthOperations:  # pylint: disable=abstract-class-instantiated
         user authorize flow.
 
         :keyword response_type: "code" Required.
-        :paramtype response_type: str or ~client.models.Enum0
+        :paramtype response_type: str or ~generated.models.Enum0
         :keyword code_challenge: Required.
         :paramtype code_challenge: str
         :keyword code_challenge_method: "S256" Required.
-        :paramtype code_challenge_method: str or ~client.models.Enum1
+        :paramtype code_challenge_method: str or ~generated.models.Enum1
         :keyword client_id: Required.
         :paramtype client_id: str
         :keyword redirect_uri: Required.
@@ -697,12 +699,14 @@ class AuthOperations:  # pylint: disable=abstract-class-instantiated
         :rtype: any
         :raises ~azure.core.exceptions.HttpResponseError:
         """
-        error_map: MutableMapping[int, Type[HttpResponseError]] = {
-            401: ClientAuthenticationError,
-            404: ResourceNotFoundError,
-            409: ResourceExistsError,
-            304: ResourceNotModifiedError,
-        }
+        error_map: MutableMapping[int, Type[HttpResponseError]] = (
+            {  # pylint: disable=unsubscriptable-object
+                401: ClientAuthenticationError,
+                404: ResourceNotFoundError,
+                409: ResourceExistsError,
+                304: ResourceNotModifiedError,
+            }
+        )
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = kwargs.pop("headers", {}) or {}
@@ -733,14 +737,12 @@ class AuthOperations:  # pylint: disable=abstract-class-instantiated
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
-            if _stream:
-                await response.read()  # Load the body in memory and close the socket
             map_error(
                 status_code=response.status_code, response=response, error_map=error_map
             )
             raise HttpResponseError(response=response)
 
-        deserialized = self._deserialize("object", pipeline_response)
+        deserialized = self._deserialize("object", pipeline_response.http_response)
 
         if cls:
             return cls(pipeline_response, deserialized, {})  # type: ignore
@@ -769,12 +771,14 @@ class AuthOperations:  # pylint: disable=abstract-class-instantiated
         :rtype: any
         :raises ~azure.core.exceptions.HttpResponseError:
         """
-        error_map: MutableMapping[int, Type[HttpResponseError]] = {
-            401: ClientAuthenticationError,
-            404: ResourceNotFoundError,
-            409: ResourceExistsError,
-            304: ResourceNotModifiedError,
-        }
+        error_map: MutableMapping[int, Type[HttpResponseError]] = (
+            {  # pylint: disable=unsubscriptable-object
+                401: ClientAuthenticationError,
+                404: ResourceNotFoundError,
+                409: ResourceExistsError,
+                304: ResourceNotModifiedError,
+            }
+        )
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = kwargs.pop("headers", {}) or {}
@@ -800,14 +804,12 @@ class AuthOperations:  # pylint: disable=abstract-class-instantiated
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
-            if _stream:
-                await response.read()  # Load the body in memory and close the socket
             map_error(
                 status_code=response.status_code, response=response, error_map=error_map
             )
             raise HttpResponseError(response=response)
 
-        deserialized = self._deserialize("object", pipeline_response)
+        deserialized = self._deserialize("object", pipeline_response.http_response)
 
         if cls:
             return cls(pipeline_response, deserialized, {})  # type: ignore
@@ -821,7 +823,7 @@ class ConfigOperations:
         **DO NOT** instantiate this class directly.
 
         Instead, you should access the following operations through
-        :class:`~client.aio.Dirac`'s
+        :class:`~generated.aio.Dirac`'s
         :attr:`config` attribute.
     """
 
@@ -865,12 +867,14 @@ class ConfigOperations:
         :rtype: any
         :raises ~azure.core.exceptions.HttpResponseError:
         """
-        error_map: MutableMapping[int, Type[HttpResponseError]] = {
-            401: ClientAuthenticationError,
-            404: ResourceNotFoundError,
-            409: ResourceExistsError,
-            304: ResourceNotModifiedError,
-        }
+        error_map: MutableMapping[int, Type[HttpResponseError]] = (
+            {  # pylint: disable=unsubscriptable-object
+                401: ClientAuthenticationError,
+                404: ResourceNotFoundError,
+                409: ResourceExistsError,
+                304: ResourceNotModifiedError,
+            }
+        )
         if match_condition == MatchConditions.IfNotModified:
             error_map[412] = ResourceModifiedError
         elif match_condition == MatchConditions.IfPresent:
@@ -903,14 +907,12 @@ class ConfigOperations:
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
-            if _stream:
-                await response.read()  # Load the body in memory and close the socket
             map_error(
                 status_code=response.status_code, response=response, error_map=error_map
             )
             raise HttpResponseError(response=response)
 
-        deserialized = self._deserialize("object", pipeline_response)
+        deserialized = self._deserialize("object", pipeline_response.http_response)
 
         if cls:
             return cls(pipeline_response, deserialized, {})  # type: ignore
@@ -924,7 +926,7 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         **DO NOT** instantiate this class directly.
 
         Instead, you should access the following operations through
-        :class:`~client.aio.Dirac`'s
+        :class:`~generated.aio.Dirac`'s
         :attr:`jobs` attribute.
     """
 
@@ -958,12 +960,12 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         should be used to upload the sandbox to the storage backend.
 
         :param body: Required.
-        :type body: ~client.models.SandboxInfo
+        :type body: ~generated.models.SandboxInfo
         :keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
          Default value is "application/json".
         :paramtype content_type: str
         :return: SandboxUploadResponse
-        :rtype: ~client.models.SandboxUploadResponse
+        :rtype: ~generated.models.SandboxUploadResponse
         :raises ~azure.core.exceptions.HttpResponseError:
         """
 
@@ -987,7 +989,7 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
          Default value is "application/json".
         :paramtype content_type: str
         :return: SandboxUploadResponse
-        :rtype: ~client.models.SandboxUploadResponse
+        :rtype: ~generated.models.SandboxUploadResponse
         :raises ~azure.core.exceptions.HttpResponseError:
         """
 
@@ -1006,17 +1008,19 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         should be used to upload the sandbox to the storage backend.
 
         :param body: Is either a SandboxInfo type or a IO[bytes] type. Required.
-        :type body: ~client.models.SandboxInfo or IO[bytes]
+        :type body: ~generated.models.SandboxInfo or IO[bytes]
         :return: SandboxUploadResponse
-        :rtype: ~client.models.SandboxUploadResponse
+        :rtype: ~generated.models.SandboxUploadResponse
         :raises ~azure.core.exceptions.HttpResponseError:
         """
-        error_map: MutableMapping[int, Type[HttpResponseError]] = {
-            401: ClientAuthenticationError,
-            404: ResourceNotFoundError,
-            409: ResourceExistsError,
-            304: ResourceNotModifiedError,
-        }
+        error_map: MutableMapping[int, Type[HttpResponseError]] = (
+            {  # pylint: disable=unsubscriptable-object
+                401: ClientAuthenticationError,
+                404: ResourceNotFoundError,
+                409: ResourceExistsError,
+                304: ResourceNotModifiedError,
+            }
+        )
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
@@ -1054,14 +1058,14 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
-            if _stream:
-                await response.read()  # Load the body in memory and close the socket
             map_error(
                 status_code=response.status_code, response=response, error_map=error_map
             )
             raise HttpResponseError(response=response)
 
-        deserialized = self._deserialize("SandboxUploadResponse", pipeline_response)
+        deserialized = self._deserialize(
+            "SandboxUploadResponse", pipeline_response.http_response
+        )
 
         if cls:
             return cls(pipeline_response, deserialized, {})  # type: ignore
@@ -1074,7 +1078,7 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
     ) -> _models.SandboxDownloadResponse:
         """Get Sandbox File.
 
-        Get a presigned URL to download a sandbox file
+        Get a presigned URL to download a sandbox file.
 
         This route cannot use a redirect response most clients will also send the
         authorization header when following a redirect. This is not desirable as
@@ -1085,15 +1089,17 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         :keyword pfn: Required.
         :paramtype pfn: str
         :return: SandboxDownloadResponse
-        :rtype: ~client.models.SandboxDownloadResponse
+        :rtype: ~generated.models.SandboxDownloadResponse
         :raises ~azure.core.exceptions.HttpResponseError:
         """
-        error_map: MutableMapping[int, Type[HttpResponseError]] = {
-            401: ClientAuthenticationError,
-            404: ResourceNotFoundError,
-            409: ResourceExistsError,
-            304: ResourceNotModifiedError,
-        }
+        error_map: MutableMapping[int, Type[HttpResponseError]] = (
+            {  # pylint: disable=unsubscriptable-object
+                401: ClientAuthenticationError,
+                404: ResourceNotFoundError,
+                409: ResourceExistsError,
+                304: ResourceNotModifiedError,
+            }
+        )
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = kwargs.pop("headers", {}) or {}
@@ -1118,14 +1124,14 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
-            if _stream:
-                await response.read()  # Load the body in memory and close the socket
             map_error(
                 status_code=response.status_code, response=response, error_map=error_map
             )
             raise HttpResponseError(response=response)
 
-        deserialized = self._deserialize("SandboxDownloadResponse", pipeline_response)
+        deserialized = self._deserialize(
+            "SandboxDownloadResponse", pipeline_response.http_response
+        )
 
         if cls:
             return cls(pipeline_response, deserialized, {})  # type: ignore
@@ -1146,12 +1152,14 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         :rtype: any
         :raises ~azure.core.exceptions.HttpResponseError:
         """
-        error_map: MutableMapping[int, Type[HttpResponseError]] = {
-            401: ClientAuthenticationError,
-            404: ResourceNotFoundError,
-            409: ResourceExistsError,
-            304: ResourceNotModifiedError,
-        }
+        error_map: MutableMapping[int, Type[HttpResponseError]] = (
+            {  # pylint: disable=unsubscriptable-object
+                401: ClientAuthenticationError,
+                404: ResourceNotFoundError,
+                409: ResourceExistsError,
+                304: ResourceNotModifiedError,
+            }
+        )
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = kwargs.pop("headers", {}) or {}
@@ -1176,14 +1184,12 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
-            if _stream:
-                await response.read()  # Load the body in memory and close the socket
             map_error(
                 status_code=response.status_code, response=response, error_map=error_map
             )
             raise HttpResponseError(response=response)
 
-        deserialized = self._deserialize("object", pipeline_response)
+        deserialized = self._deserialize("object", pipeline_response.http_response)
 
         if cls:
             return cls(pipeline_response, deserialized, {})  # type: ignore
@@ -1204,12 +1210,14 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         :rtype: dict[str, list[any]]
         :raises ~azure.core.exceptions.HttpResponseError:
         """
-        error_map: MutableMapping[int, Type[HttpResponseError]] = {
-            401: ClientAuthenticationError,
-            404: ResourceNotFoundError,
-            409: ResourceExistsError,
-            304: ResourceNotModifiedError,
-        }
+        error_map: MutableMapping[int, Type[HttpResponseError]] = (
+            {  # pylint: disable=unsubscriptable-object
+                401: ClientAuthenticationError,
+                404: ResourceNotFoundError,
+                409: ResourceExistsError,
+                304: ResourceNotModifiedError,
+            }
+        )
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = kwargs.pop("headers", {}) or {}
@@ -1234,14 +1242,12 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
-            if _stream:
-                await response.read()  # Load the body in memory and close the socket
             map_error(
                 status_code=response.status_code, response=response, error_map=error_map
             )
             raise HttpResponseError(response=response)
 
-        deserialized = self._deserialize("{[object]}", pipeline_response)
+        deserialized = self._deserialize("{[object]}", pipeline_response.http_response)
 
         if cls:
             return cls(pipeline_response, deserialized, {})  # type: ignore
@@ -1260,12 +1266,14 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         :rtype: any
         :raises ~azure.core.exceptions.HttpResponseError:
         """
-        error_map: MutableMapping[int, Type[HttpResponseError]] = {
-            401: ClientAuthenticationError,
-            404: ResourceNotFoundError,
-            409: ResourceExistsError,
-            304: ResourceNotModifiedError,
-        }
+        error_map: MutableMapping[int, Type[HttpResponseError]] = (
+            {  # pylint: disable=unsubscriptable-object
+                401: ClientAuthenticationError,
+                404: ResourceNotFoundError,
+                409: ResourceExistsError,
+                304: ResourceNotModifiedError,
+            }
+        )
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = kwargs.pop("headers", {}) or {}
@@ -1290,14 +1298,12 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
-            if _stream:
-                await response.read()  # Load the body in memory and close the socket
             map_error(
                 status_code=response.status_code, response=response, error_map=error_map
             )
             raise HttpResponseError(response=response)
 
-        deserialized = self._deserialize("object", pipeline_response)
+        deserialized = self._deserialize("object", pipeline_response.http_response)
 
         if cls:
             return cls(pipeline_response, deserialized, {})  # type: ignore
@@ -1315,17 +1321,19 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         :param job_id: Required.
         :type job_id: int
         :param sandbox_type: Known values are: "input" and "output". Required.
-        :type sandbox_type: str or ~client.models.SandboxType
+        :type sandbox_type: str or ~generated.models.SandboxType
         :return: list of any
         :rtype: list[any]
         :raises ~azure.core.exceptions.HttpResponseError:
         """
-        error_map: MutableMapping[int, Type[HttpResponseError]] = {
-            401: ClientAuthenticationError,
-            404: ResourceNotFoundError,
-            409: ResourceExistsError,
-            304: ResourceNotModifiedError,
-        }
+        error_map: MutableMapping[int, Type[HttpResponseError]] = (
+            {  # pylint: disable=unsubscriptable-object
+                401: ClientAuthenticationError,
+                404: ResourceNotFoundError,
+                409: ResourceExistsError,
+                304: ResourceNotModifiedError,
+            }
+        )
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = kwargs.pop("headers", {}) or {}
@@ -1351,14 +1359,12 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
-            if _stream:
-                await response.read()  # Load the body in memory and close the socket
             map_error(
                 status_code=response.status_code, response=response, error_map=error_map
             )
             raise HttpResponseError(response=response)
 
-        deserialized = self._deserialize("[object]", pipeline_response)
+        deserialized = self._deserialize("[object]", pipeline_response.http_response)
 
         if cls:
             return cls(pipeline_response, deserialized, {})  # type: ignore
@@ -1379,12 +1385,14 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         :rtype: any
         :raises ~azure.core.exceptions.HttpResponseError:
         """
-        error_map: MutableMapping[int, Type[HttpResponseError]] = {
-            401: ClientAuthenticationError,
-            404: ResourceNotFoundError,
-            409: ResourceExistsError,
-            304: ResourceNotModifiedError,
-        }
+        error_map: MutableMapping[int, Type[HttpResponseError]] = (
+            {  # pylint: disable=unsubscriptable-object
+                401: ClientAuthenticationError,
+                404: ResourceNotFoundError,
+                409: ResourceExistsError,
+                304: ResourceNotModifiedError,
+            }
+        )
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
@@ -1416,14 +1424,12 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
-            if _stream:
-                await response.read()  # Load the body in memory and close the socket
             map_error(
                 status_code=response.status_code, response=response, error_map=error_map
             )
             raise HttpResponseError(response=response)
 
-        deserialized = self._deserialize("object", pipeline_response)
+        deserialized = self._deserialize("object", pipeline_response.http_response)
 
         if cls:
             return cls(pipeline_response, deserialized, {})  # type: ignore
@@ -1444,7 +1450,7 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
          Default value is "application/json".
         :paramtype content_type: str
         :return: list of InsertedJob
-        :rtype: list[~client.models.InsertedJob]
+        :rtype: list[~generated.models.InsertedJob]
         :raises ~azure.core.exceptions.HttpResponseError:
         """
 
@@ -1462,7 +1468,7 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
          Default value is "application/json".
         :paramtype content_type: str
         :return: list of InsertedJob
-        :rtype: list[~client.models.InsertedJob]
+        :rtype: list[~generated.models.InsertedJob]
         :raises ~azure.core.exceptions.HttpResponseError:
         """
 
@@ -1477,15 +1483,17 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         :param body: Is either a [str] type or a IO[bytes] type. Required.
         :type body: list[str] or IO[bytes]
         :return: list of InsertedJob
-        :rtype: list[~client.models.InsertedJob]
+        :rtype: list[~generated.models.InsertedJob]
         :raises ~azure.core.exceptions.HttpResponseError:
         """
-        error_map: MutableMapping[int, Type[HttpResponseError]] = {
-            401: ClientAuthenticationError,
-            404: ResourceNotFoundError,
-            409: ResourceExistsError,
-            304: ResourceNotModifiedError,
-        }
+        error_map: MutableMapping[int, Type[HttpResponseError]] = (
+            {  # pylint: disable=unsubscriptable-object
+                401: ClientAuthenticationError,
+                404: ResourceNotFoundError,
+                409: ResourceExistsError,
+                304: ResourceNotModifiedError,
+            }
+        )
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
@@ -1523,14 +1531,14 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
-            if _stream:
-                await response.read()  # Load the body in memory and close the socket
             map_error(
                 status_code=response.status_code, response=response, error_map=error_map
             )
             raise HttpResponseError(response=response)
 
-        deserialized = self._deserialize("[InsertedJob]", pipeline_response)
+        deserialized = self._deserialize(
+            "[InsertedJob]", pipeline_response.http_response
+        )
 
         if cls:
             return cls(pipeline_response, deserialized, {})  # type: ignore
@@ -1549,12 +1557,14 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         :rtype: any
         :raises ~azure.core.exceptions.HttpResponseError:
         """
-        error_map: MutableMapping[int, Type[HttpResponseError]] = {
-            401: ClientAuthenticationError,
-            404: ResourceNotFoundError,
-            409: ResourceExistsError,
-            304: ResourceNotModifiedError,
-        }
+        error_map: MutableMapping[int, Type[HttpResponseError]] = (
+            {  # pylint: disable=unsubscriptable-object
+                401: ClientAuthenticationError,
+                404: ResourceNotFoundError,
+                409: ResourceExistsError,
+                304: ResourceNotModifiedError,
+            }
+        )
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = kwargs.pop("headers", {}) or {}
@@ -1579,14 +1589,12 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
-            if _stream:
-                await response.read()  # Load the body in memory and close the socket
             map_error(
                 status_code=response.status_code, response=response, error_map=error_map
             )
             raise HttpResponseError(response=response)
 
-        deserialized = self._deserialize("object", pipeline_response)
+        deserialized = self._deserialize("object", pipeline_response.http_response)
 
         if cls:
             return cls(pipeline_response, deserialized, {})  # type: ignore
@@ -1605,12 +1613,14 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         :rtype: any
         :raises ~azure.core.exceptions.HttpResponseError:
         """
-        error_map: MutableMapping[int, Type[HttpResponseError]] = {
-            401: ClientAuthenticationError,
-            404: ResourceNotFoundError,
-            409: ResourceExistsError,
-            304: ResourceNotModifiedError,
-        }
+        error_map: MutableMapping[int, Type[HttpResponseError]] = (
+            {  # pylint: disable=unsubscriptable-object
+                401: ClientAuthenticationError,
+                404: ResourceNotFoundError,
+                409: ResourceExistsError,
+                304: ResourceNotModifiedError,
+            }
+        )
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = kwargs.pop("headers", {}) or {}
@@ -1635,14 +1645,12 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
-            if _stream:
-                await response.read()  # Load the body in memory and close the socket
             map_error(
                 status_code=response.status_code, response=response, error_map=error_map
             )
             raise HttpResponseError(response=response)
 
-        deserialized = self._deserialize("object", pipeline_response)
+        deserialized = self._deserialize("object", pipeline_response.http_response)
 
         if cls:
             return cls(pipeline_response, deserialized, {})  # type: ignore
@@ -1665,12 +1673,14 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         :rtype: any
         :raises ~azure.core.exceptions.HttpResponseError:
         """
-        error_map: MutableMapping[int, Type[HttpResponseError]] = {
-            401: ClientAuthenticationError,
-            404: ResourceNotFoundError,
-            409: ResourceExistsError,
-            304: ResourceNotModifiedError,
-        }
+        error_map: MutableMapping[int, Type[HttpResponseError]] = (
+            {  # pylint: disable=unsubscriptable-object
+                401: ClientAuthenticationError,
+                404: ResourceNotFoundError,
+                409: ResourceExistsError,
+                304: ResourceNotModifiedError,
+            }
+        )
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = kwargs.pop("headers", {}) or {}
@@ -1695,14 +1705,12 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
-            if _stream:
-                await response.read()  # Load the body in memory and close the socket
             map_error(
                 status_code=response.status_code, response=response, error_map=error_map
             )
             raise HttpResponseError(response=response)
 
-        deserialized = self._deserialize("object", pipeline_response)
+        deserialized = self._deserialize("object", pipeline_response.http_response)
 
         if cls:
             return cls(pipeline_response, deserialized, {})  # type: ignore
@@ -1720,15 +1728,17 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         :keyword job_ids: Required.
         :paramtype job_ids: list[int]
         :return: dict mapping str to LimitedJobStatusReturn
-        :rtype: dict[str, ~client.models.LimitedJobStatusReturn]
+        :rtype: dict[str, ~generated.models.LimitedJobStatusReturn]
         :raises ~azure.core.exceptions.HttpResponseError:
         """
-        error_map: MutableMapping[int, Type[HttpResponseError]] = {
-            401: ClientAuthenticationError,
-            404: ResourceNotFoundError,
-            409: ResourceExistsError,
-            304: ResourceNotModifiedError,
-        }
+        error_map: MutableMapping[int, Type[HttpResponseError]] = (
+            {  # pylint: disable=unsubscriptable-object
+                401: ClientAuthenticationError,
+                404: ResourceNotFoundError,
+                409: ResourceExistsError,
+                304: ResourceNotModifiedError,
+            }
+        )
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = kwargs.pop("headers", {}) or {}
@@ -1755,14 +1765,14 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
-            if _stream:
-                await response.read()  # Load the body in memory and close the socket
             map_error(
                 status_code=response.status_code, response=response, error_map=error_map
             )
             raise HttpResponseError(response=response)
 
-        deserialized = self._deserialize("{LimitedJobStatusReturn}", pipeline_response)
+        deserialized = self._deserialize(
+            "{LimitedJobStatusReturn}", pipeline_response.http_response
+        )
 
         if cls:
             return cls(pipeline_response, deserialized, {})  # type: ignore
@@ -1783,14 +1793,14 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         Set Job Status Bulk.
 
         :param body: Required.
-        :type body: dict[str, dict[str, ~client.models.JobStatusUpdate]]
+        :type body: dict[str, dict[str, ~generated.models.JobStatusUpdate]]
         :keyword force: Default value is False.
         :paramtype force: bool
         :keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
          Default value is "application/json".
         :paramtype content_type: str
         :return: dict mapping str to SetJobStatusReturn
-        :rtype: dict[str, ~client.models.SetJobStatusReturn]
+        :rtype: dict[str, ~generated.models.SetJobStatusReturn]
         :raises ~azure.core.exceptions.HttpResponseError:
         """
 
@@ -1815,7 +1825,7 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
          Default value is "application/json".
         :paramtype content_type: str
         :return: dict mapping str to SetJobStatusReturn
-        :rtype: dict[str, ~client.models.SetJobStatusReturn]
+        :rtype: dict[str, ~generated.models.SetJobStatusReturn]
         :raises ~azure.core.exceptions.HttpResponseError:
         """
 
@@ -1832,19 +1842,21 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         Set Job Status Bulk.
 
         :param body: Is either a {str: {str: JobStatusUpdate}} type or a IO[bytes] type. Required.
-        :type body: dict[str, dict[str, ~client.models.JobStatusUpdate]] or IO[bytes]
+        :type body: dict[str, dict[str, ~generated.models.JobStatusUpdate]] or IO[bytes]
         :keyword force: Default value is False.
         :paramtype force: bool
         :return: dict mapping str to SetJobStatusReturn
-        :rtype: dict[str, ~client.models.SetJobStatusReturn]
+        :rtype: dict[str, ~generated.models.SetJobStatusReturn]
         :raises ~azure.core.exceptions.HttpResponseError:
         """
-        error_map: MutableMapping[int, Type[HttpResponseError]] = {
-            401: ClientAuthenticationError,
-            404: ResourceNotFoundError,
-            409: ResourceExistsError,
-            304: ResourceNotModifiedError,
-        }
+        error_map: MutableMapping[int, Type[HttpResponseError]] = (
+            {  # pylint: disable=unsubscriptable-object
+                401: ClientAuthenticationError,
+                404: ResourceNotFoundError,
+                409: ResourceExistsError,
+                304: ResourceNotModifiedError,
+            }
+        )
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
@@ -1883,14 +1895,14 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
-            if _stream:
-                await response.read()  # Load the body in memory and close the socket
             map_error(
                 status_code=response.status_code, response=response, error_map=error_map
             )
             raise HttpResponseError(response=response)
 
-        deserialized = self._deserialize("{SetJobStatusReturn}", pipeline_response)
+        deserialized = self._deserialize(
+            "{SetJobStatusReturn}", pipeline_response.http_response
+        )
 
         if cls:
             return cls(pipeline_response, deserialized, {})  # type: ignore
@@ -1908,15 +1920,17 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         :keyword job_ids: Required.
         :paramtype job_ids: list[int]
         :return: dict mapping str to list of JobStatusReturn
-        :rtype: dict[str, list[~client.models.JobStatusReturn]]
+        :rtype: dict[str, list[~generated.models.JobStatusReturn]]
         :raises ~azure.core.exceptions.HttpResponseError:
         """
-        error_map: MutableMapping[int, Type[HttpResponseError]] = {
-            401: ClientAuthenticationError,
-            404: ResourceNotFoundError,
-            409: ResourceExistsError,
-            304: ResourceNotModifiedError,
-        }
+        error_map: MutableMapping[int, Type[HttpResponseError]] = (
+            {  # pylint: disable=unsubscriptable-object
+                401: ClientAuthenticationError,
+                404: ResourceNotFoundError,
+                409: ResourceExistsError,
+                304: ResourceNotModifiedError,
+            }
+        )
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = kwargs.pop("headers", {}) or {}
@@ -1941,14 +1955,14 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
-            if _stream:
-                await response.read()  # Load the body in memory and close the socket
             map_error(
                 status_code=response.status_code, response=response, error_map=error_map
             )
             raise HttpResponseError(response=response)
 
-        deserialized = self._deserialize("{[JobStatusReturn]}", pipeline_response)
+        deserialized = self._deserialize(
+            "{[JobStatusReturn]}", pipeline_response.http_response
+        )
 
         if cls:
             return cls(pipeline_response, deserialized, {})  # type: ignore
@@ -1967,12 +1981,14 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         :rtype: any
         :raises ~azure.core.exceptions.HttpResponseError:
         """
-        error_map: MutableMapping[int, Type[HttpResponseError]] = {
-            401: ClientAuthenticationError,
-            404: ResourceNotFoundError,
-            409: ResourceExistsError,
-            304: ResourceNotModifiedError,
-        }
+        error_map: MutableMapping[int, Type[HttpResponseError]] = (
+            {  # pylint: disable=unsubscriptable-object
+                401: ClientAuthenticationError,
+                404: ResourceNotFoundError,
+                409: ResourceExistsError,
+                304: ResourceNotModifiedError,
+            }
+        )
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = kwargs.pop("headers", {}) or {}
@@ -1997,14 +2013,12 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
-            if _stream:
-                await response.read()  # Load the body in memory and close the socket
             map_error(
                 status_code=response.status_code, response=response, error_map=error_map
             )
             raise HttpResponseError(response=response)
 
-        deserialized = self._deserialize("object", pipeline_response)
+        deserialized = self._deserialize("object", pipeline_response.http_response)
 
         if cls:
             return cls(pipeline_response, deserialized, {})  # type: ignore
@@ -2023,12 +2037,14 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         :rtype: any
         :raises ~azure.core.exceptions.HttpResponseError:
         """
-        error_map: MutableMapping[int, Type[HttpResponseError]] = {
-            401: ClientAuthenticationError,
-            404: ResourceNotFoundError,
-            409: ResourceExistsError,
-            304: ResourceNotModifiedError,
-        }
+        error_map: MutableMapping[int, Type[HttpResponseError]] = (
+            {  # pylint: disable=unsubscriptable-object
+                401: ClientAuthenticationError,
+                404: ResourceNotFoundError,
+                409: ResourceExistsError,
+                304: ResourceNotModifiedError,
+            }
+        )
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = kwargs.pop("headers", {}) or {}
@@ -2053,14 +2069,12 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
-            if _stream:
-                await response.read()  # Load the body in memory and close the socket
             map_error(
                 status_code=response.status_code, response=response, error_map=error_map
             )
             raise HttpResponseError(response=response)
 
-        deserialized = self._deserialize("object", pipeline_response)
+        deserialized = self._deserialize("object", pipeline_response.http_response)
 
         if cls:
             return cls(pipeline_response, deserialized, {})  # type: ignore
@@ -2084,7 +2098,7 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         **TODO: Add more docs**.
 
         :param body: Default value is None.
-        :type body: ~client.models.JobSearchParams
+        :type body: ~generated.models.JobSearchParams
         :keyword page: Default value is 1.
         :paramtype page: int
         :keyword per_page: Default value is 100.
@@ -2143,7 +2157,7 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         **TODO: Add more docs**.
 
         :param body: Is either a JobSearchParams type or a IO[bytes] type. Default value is None.
-        :type body: ~client.models.JobSearchParams or IO[bytes]
+        :type body: ~generated.models.JobSearchParams or IO[bytes]
         :keyword page: Default value is 1.
         :paramtype page: int
         :keyword per_page: Default value is 100.
@@ -2152,12 +2166,14 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         :rtype: list[JSON]
         :raises ~azure.core.exceptions.HttpResponseError:
         """
-        error_map: MutableMapping[int, Type[HttpResponseError]] = {
-            401: ClientAuthenticationError,
-            404: ResourceNotFoundError,
-            409: ResourceExistsError,
-            304: ResourceNotModifiedError,
-        }
+        error_map: MutableMapping[int, Type[HttpResponseError]] = (
+            {  # pylint: disable=unsubscriptable-object
+                401: ClientAuthenticationError,
+                404: ResourceNotFoundError,
+                409: ResourceExistsError,
+                304: ResourceNotModifiedError,
+            }
+        )
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
@@ -2200,23 +2216,18 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         response = pipeline_response.http_response
 
         if response.status_code not in [200, 206]:
-            if _stream:
-                await response.read()  # Load the body in memory and close the socket
             map_error(
                 status_code=response.status_code, response=response, error_map=error_map
             )
             raise HttpResponseError(response=response)
 
         response_headers = {}
-        if response.status_code == 200:
-            deserialized = self._deserialize("[object]", pipeline_response)
-
         if response.status_code == 206:
             response_headers["Content-Range"] = self._deserialize(
                 "str", response.headers.get("Content-Range")
             )
 
-            deserialized = self._deserialize("[object]", pipeline_response)
+        deserialized = self._deserialize("[object]", pipeline_response.http_response)
 
         if cls:
             return cls(pipeline_response, deserialized, response_headers)  # type: ignore
@@ -2236,7 +2247,7 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         Show information suitable for plotting.
 
         :param body: Required.
-        :type body: ~client.models.JobSummaryParams
+        :type body: ~generated.models.JobSummaryParams
         :keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
          Default value is "application/json".
         :paramtype content_type: str
@@ -2272,17 +2283,19 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         Show information suitable for plotting.
 
         :param body: Is either a JobSummaryParams type or a IO[bytes] type. Required.
-        :type body: ~client.models.JobSummaryParams or IO[bytes]
+        :type body: ~generated.models.JobSummaryParams or IO[bytes]
         :return: any
         :rtype: any
         :raises ~azure.core.exceptions.HttpResponseError:
         """
-        error_map: MutableMapping[int, Type[HttpResponseError]] = {
-            401: ClientAuthenticationError,
-            404: ResourceNotFoundError,
-            409: ResourceExistsError,
-            304: ResourceNotModifiedError,
-        }
+        error_map: MutableMapping[int, Type[HttpResponseError]] = (
+            {  # pylint: disable=unsubscriptable-object
+                401: ClientAuthenticationError,
+                404: ResourceNotFoundError,
+                409: ResourceExistsError,
+                304: ResourceNotModifiedError,
+            }
+        )
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
@@ -2320,14 +2333,12 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
-            if _stream:
-                await response.read()  # Load the body in memory and close the socket
             map_error(
                 status_code=response.status_code, response=response, error_map=error_map
             )
             raise HttpResponseError(response=response)
 
-        deserialized = self._deserialize("object", pipeline_response)
+        deserialized = self._deserialize("object", pipeline_response.http_response)
 
         if cls:
             return cls(pipeline_response, deserialized, {})  # type: ignore
@@ -2346,12 +2357,14 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         :rtype: any
         :raises ~azure.core.exceptions.HttpResponseError:
         """
-        error_map: MutableMapping[int, Type[HttpResponseError]] = {
-            401: ClientAuthenticationError,
-            404: ResourceNotFoundError,
-            409: ResourceExistsError,
-            304: ResourceNotModifiedError,
-        }
+        error_map: MutableMapping[int, Type[HttpResponseError]] = (
+            {  # pylint: disable=unsubscriptable-object
+                401: ClientAuthenticationError,
+                404: ResourceNotFoundError,
+                409: ResourceExistsError,
+                304: ResourceNotModifiedError,
+            }
+        )
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = kwargs.pop("headers", {}) or {}
@@ -2376,14 +2389,12 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
-            if _stream:
-                await response.read()  # Load the body in memory and close the socket
             map_error(
                 status_code=response.status_code, response=response, error_map=error_map
             )
             raise HttpResponseError(response=response)
 
-        deserialized = self._deserialize("object", pipeline_response)
+        deserialized = self._deserialize("object", pipeline_response.http_response)
 
         if cls:
             return cls(pipeline_response, deserialized, {})  # type: ignore
@@ -2402,12 +2413,14 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         :rtype: any
         :raises ~azure.core.exceptions.HttpResponseError:
         """
-        error_map: MutableMapping[int, Type[HttpResponseError]] = {
-            401: ClientAuthenticationError,
-            404: ResourceNotFoundError,
-            409: ResourceExistsError,
-            304: ResourceNotModifiedError,
-        }
+        error_map: MutableMapping[int, Type[HttpResponseError]] = (
+            {  # pylint: disable=unsubscriptable-object
+                401: ClientAuthenticationError,
+                404: ResourceNotFoundError,
+                409: ResourceExistsError,
+                304: ResourceNotModifiedError,
+            }
+        )
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = kwargs.pop("headers", {}) or {}
@@ -2432,14 +2445,12 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
-            if _stream:
-                await response.read()  # Load the body in memory and close the socket
             map_error(
                 status_code=response.status_code, response=response, error_map=error_map
             )
             raise HttpResponseError(response=response)
 
-        deserialized = self._deserialize("object", pipeline_response)
+        deserialized = self._deserialize("object", pipeline_response.http_response)
 
         if cls:
             return cls(pipeline_response, deserialized, {})  # type: ignore
@@ -2464,12 +2475,14 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         :rtype: any
         :raises ~azure.core.exceptions.HttpResponseError:
         """
-        error_map: MutableMapping[int, Type[HttpResponseError]] = {
-            401: ClientAuthenticationError,
-            404: ResourceNotFoundError,
-            409: ResourceExistsError,
-            304: ResourceNotModifiedError,
-        }
+        error_map: MutableMapping[int, Type[HttpResponseError]] = (
+            {  # pylint: disable=unsubscriptable-object
+                401: ClientAuthenticationError,
+                404: ResourceNotFoundError,
+                409: ResourceExistsError,
+                304: ResourceNotModifiedError,
+            }
+        )
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
@@ -2502,14 +2515,12 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
-            if _stream:
-                await response.read()  # Load the body in memory and close the socket
             map_error(
                 status_code=response.status_code, response=response, error_map=error_map
             )
             raise HttpResponseError(response=response)
 
-        deserialized = self._deserialize("object", pipeline_response)
+        deserialized = self._deserialize("object", pipeline_response.http_response)
 
         if cls:
             return cls(pipeline_response, deserialized, {})  # type: ignore
@@ -2528,12 +2539,14 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         :rtype: any
         :raises ~azure.core.exceptions.HttpResponseError:
         """
-        error_map: MutableMapping[int, Type[HttpResponseError]] = {
-            401: ClientAuthenticationError,
-            404: ResourceNotFoundError,
-            409: ResourceExistsError,
-            304: ResourceNotModifiedError,
-        }
+        error_map: MutableMapping[int, Type[HttpResponseError]] = (
+            {  # pylint: disable=unsubscriptable-object
+                401: ClientAuthenticationError,
+                404: ResourceNotFoundError,
+                409: ResourceExistsError,
+                304: ResourceNotModifiedError,
+            }
+        )
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = kwargs.pop("headers", {}) or {}
@@ -2558,14 +2571,12 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
-            if _stream:
-                await response.read()  # Load the body in memory and close the socket
             map_error(
                 status_code=response.status_code, response=response, error_map=error_map
             )
             raise HttpResponseError(response=response)
 
-        deserialized = self._deserialize("object", pipeline_response)
+        deserialized = self._deserialize("object", pipeline_response.http_response)
 
         if cls:
             return cls(pipeline_response, deserialized, {})  # type: ignore
@@ -2588,12 +2599,14 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         :rtype: any
         :raises ~azure.core.exceptions.HttpResponseError:
         """
-        error_map: MutableMapping[int, Type[HttpResponseError]] = {
-            401: ClientAuthenticationError,
-            404: ResourceNotFoundError,
-            409: ResourceExistsError,
-            304: ResourceNotModifiedError,
-        }
+        error_map: MutableMapping[int, Type[HttpResponseError]] = (
+            {  # pylint: disable=unsubscriptable-object
+                401: ClientAuthenticationError,
+                404: ResourceNotFoundError,
+                409: ResourceExistsError,
+                304: ResourceNotModifiedError,
+            }
+        )
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = kwargs.pop("headers", {}) or {}
@@ -2618,14 +2631,12 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
-            if _stream:
-                await response.read()  # Load the body in memory and close the socket
             map_error(
                 status_code=response.status_code, response=response, error_map=error_map
             )
             raise HttpResponseError(response=response)
 
-        deserialized = self._deserialize("object", pipeline_response)
+        deserialized = self._deserialize("object", pipeline_response.http_response)
 
         if cls:
             return cls(pipeline_response, deserialized, {})  # type: ignore
@@ -2643,15 +2654,17 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         :param job_id: Required.
         :type job_id: int
         :return: dict mapping str to LimitedJobStatusReturn
-        :rtype: dict[str, ~client.models.LimitedJobStatusReturn]
+        :rtype: dict[str, ~generated.models.LimitedJobStatusReturn]
         :raises ~azure.core.exceptions.HttpResponseError:
         """
-        error_map: MutableMapping[int, Type[HttpResponseError]] = {
-            401: ClientAuthenticationError,
-            404: ResourceNotFoundError,
-            409: ResourceExistsError,
-            304: ResourceNotModifiedError,
-        }
+        error_map: MutableMapping[int, Type[HttpResponseError]] = (
+            {  # pylint: disable=unsubscriptable-object
+                401: ClientAuthenticationError,
+                404: ResourceNotFoundError,
+                409: ResourceExistsError,
+                304: ResourceNotModifiedError,
+            }
+        )
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = kwargs.pop("headers", {}) or {}
@@ -2678,14 +2691,14 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
-            if _stream:
-                await response.read()  # Load the body in memory and close the socket
             map_error(
                 status_code=response.status_code, response=response, error_map=error_map
             )
             raise HttpResponseError(response=response)
 
-        deserialized = self._deserialize("{LimitedJobStatusReturn}", pipeline_response)
+        deserialized = self._deserialize(
+            "{LimitedJobStatusReturn}", pipeline_response.http_response
+        )
 
         if cls:
             return cls(pipeline_response, deserialized, {})  # type: ignore
@@ -2709,14 +2722,14 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         :param job_id: Required.
         :type job_id: int
         :param body: Required.
-        :type body: dict[str, ~client.models.JobStatusUpdate]
+        :type body: dict[str, ~generated.models.JobStatusUpdate]
         :keyword force: Default value is False.
         :paramtype force: bool
         :keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
          Default value is "application/json".
         :paramtype content_type: str
         :return: dict mapping str to SetJobStatusReturn
-        :rtype: dict[str, ~client.models.SetJobStatusReturn]
+        :rtype: dict[str, ~generated.models.SetJobStatusReturn]
         :raises ~azure.core.exceptions.HttpResponseError:
         """
 
@@ -2744,7 +2757,7 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
          Default value is "application/json".
         :paramtype content_type: str
         :return: dict mapping str to SetJobStatusReturn
-        :rtype: dict[str, ~client.models.SetJobStatusReturn]
+        :rtype: dict[str, ~generated.models.SetJobStatusReturn]
         :raises ~azure.core.exceptions.HttpResponseError:
         """
 
@@ -2764,19 +2777,21 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         :param job_id: Required.
         :type job_id: int
         :param body: Is either a {str: JobStatusUpdate} type or a IO[bytes] type. Required.
-        :type body: dict[str, ~client.models.JobStatusUpdate] or IO[bytes]
+        :type body: dict[str, ~generated.models.JobStatusUpdate] or IO[bytes]
         :keyword force: Default value is False.
         :paramtype force: bool
         :return: dict mapping str to SetJobStatusReturn
-        :rtype: dict[str, ~client.models.SetJobStatusReturn]
+        :rtype: dict[str, ~generated.models.SetJobStatusReturn]
         :raises ~azure.core.exceptions.HttpResponseError:
         """
-        error_map: MutableMapping[int, Type[HttpResponseError]] = {
-            401: ClientAuthenticationError,
-            404: ResourceNotFoundError,
-            409: ResourceExistsError,
-            304: ResourceNotModifiedError,
-        }
+        error_map: MutableMapping[int, Type[HttpResponseError]] = (
+            {  # pylint: disable=unsubscriptable-object
+                401: ClientAuthenticationError,
+                404: ResourceNotFoundError,
+                409: ResourceExistsError,
+                304: ResourceNotModifiedError,
+            }
+        )
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
@@ -2816,14 +2831,14 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
-            if _stream:
-                await response.read()  # Load the body in memory and close the socket
             map_error(
                 status_code=response.status_code, response=response, error_map=error_map
             )
             raise HttpResponseError(response=response)
 
-        deserialized = self._deserialize("{SetJobStatusReturn}", pipeline_response)
+        deserialized = self._deserialize(
+            "{SetJobStatusReturn}", pipeline_response.http_response
+        )
 
         if cls:
             return cls(pipeline_response, deserialized, {})  # type: ignore
@@ -2841,15 +2856,17 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         :param job_id: Required.
         :type job_id: int
         :return: dict mapping str to list of JobStatusReturn
-        :rtype: dict[str, list[~client.models.JobStatusReturn]]
+        :rtype: dict[str, list[~generated.models.JobStatusReturn]]
         :raises ~azure.core.exceptions.HttpResponseError:
         """
-        error_map: MutableMapping[int, Type[HttpResponseError]] = {
-            401: ClientAuthenticationError,
-            404: ResourceNotFoundError,
-            409: ResourceExistsError,
-            304: ResourceNotModifiedError,
-        }
+        error_map: MutableMapping[int, Type[HttpResponseError]] = (
+            {  # pylint: disable=unsubscriptable-object
+                401: ClientAuthenticationError,
+                404: ResourceNotFoundError,
+                409: ResourceExistsError,
+                304: ResourceNotModifiedError,
+            }
+        )
         error_map.update(kwargs.pop("error_map", {}) or {})
 
         _headers = kwargs.pop("headers", {}) or {}
@@ -2874,14 +2891,14 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
-            if _stream:
-                await response.read()  # Load the body in memory and close the socket
             map_error(
                 status_code=response.status_code, response=response, error_map=error_map
             )
             raise HttpResponseError(response=response)
 
-        deserialized = self._deserialize("{[JobStatusReturn]}", pipeline_response)
+        deserialized = self._deserialize(
+            "{[JobStatusReturn]}", pipeline_response.http_response
+        )
 
         if cls:
             return cls(pipeline_response, deserialized, {})  # type: ignore