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

diracx/client/{operations → generated/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
@@ -918,7 +918,7 @@ class WellKnownOperations:
         **DO NOT** instantiate this class directly.
 
         Instead, you should access the following operations through
-        :class:`~client.Dirac`'s
+        :class:`~generated.Dirac`'s
         :attr:`well_known` attribute.
     """
 
@@ -943,12 +943,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 {}
@@ -972,14 +974,12 @@ class WellKnownOperations:
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
-            if _stream:
-                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
@@ -993,15 +993,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 {}
@@ -1025,14 +1027,12 @@ class WellKnownOperations:
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
-            if _stream:
-                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
@@ -1046,7 +1046,7 @@ class AuthOperations:  # pylint: disable=abstract-class-instantiated
         **DO NOT** instantiate this class directly.
 
         Instead, you should access the following operations through
-        :class:`~client.Dirac`'s
+        :class:`~generated.Dirac`'s
         :attr:`auth` attribute.
     """
 
@@ -1077,7 +1077,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``.
@@ -1087,15 +1087,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 {}
@@ -1121,15 +1123,13 @@ class AuthOperations:  # pylint: disable=abstract-class-instantiated
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
-            if _stream:
-                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:
@@ -1156,12 +1156,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 {}
@@ -1186,14 +1188,12 @@ class AuthOperations:  # pylint: disable=abstract-class-instantiated
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
-            if _stream:
-                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
@@ -1218,12 +1218,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 {}
@@ -1249,14 +1251,12 @@ class AuthOperations:  # pylint: disable=abstract-class-instantiated
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
-            if _stream:
-                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
@@ -1273,12 +1273,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 {}
@@ -1302,14 +1304,12 @@ class AuthOperations:  # pylint: disable=abstract-class-instantiated
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
-            if _stream:
-                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
@@ -1327,12 +1327,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 {}
@@ -1356,14 +1358,12 @@ class AuthOperations:  # pylint: disable=abstract-class-instantiated
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
-            if _stream:
-                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
@@ -1383,12 +1383,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 {}
@@ -1413,14 +1415,12 @@ class AuthOperations:  # pylint: disable=abstract-class-instantiated
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
-            if _stream:
-                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
@@ -1434,15 +1434,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 {}
@@ -1466,14 +1468,14 @@ class AuthOperations:  # pylint: disable=abstract-class-instantiated
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
-            if _stream:
-                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
@@ -1504,11 +1506,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.
@@ -1521,12 +1523,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 {}
@@ -1557,14 +1561,12 @@ class AuthOperations:  # pylint: disable=abstract-class-instantiated
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
-            if _stream:
-                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
@@ -1593,12 +1595,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 {}
@@ -1624,14 +1628,12 @@ class AuthOperations:  # pylint: disable=abstract-class-instantiated
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
-            if _stream:
-                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
@@ -1645,7 +1647,7 @@ class ConfigOperations:
         **DO NOT** instantiate this class directly.
 
         Instead, you should access the following operations through
-        :class:`~client.Dirac`'s
+        :class:`~generated.Dirac`'s
         :attr:`config` attribute.
     """
 
@@ -1689,12 +1691,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:
@@ -1727,14 +1731,12 @@ class ConfigOperations:
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
-            if _stream:
-                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
@@ -1748,7 +1750,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.Dirac`'s
+        :class:`~generated.Dirac`'s
         :attr:`jobs` attribute.
     """
 
@@ -1782,12 +1784,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:
         """
 
@@ -1811,7 +1813,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:
         """
 
@@ -1830,17 +1832,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 {})
@@ -1878,14 +1882,14 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
-            if _stream:
-                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
@@ -1898,7 +1902,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
@@ -1909,15 +1913,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 {}
@@ -1942,14 +1948,14 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
-            if _stream:
-                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
@@ -1970,12 +1976,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 {}
@@ -2000,14 +2008,12 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
-            if _stream:
-                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
@@ -2026,12 +2032,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 {}
@@ -2056,14 +2064,12 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
-            if _stream:
-                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
@@ -2082,12 +2088,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 {}
@@ -2112,14 +2120,12 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
-            if _stream:
-                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
@@ -2137,17 +2143,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 {}
@@ -2173,14 +2181,12 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
-            if _stream:
-                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
@@ -2201,12 +2207,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 {})
@@ -2238,14 +2246,12 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
-            if _stream:
-                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
@@ -2266,7 +2272,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:
         """
 
@@ -2284,7 +2290,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:
         """
 
@@ -2299,15 +2305,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 {})
@@ -2345,14 +2353,14 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
-            if _stream:
-                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
@@ -2371,12 +2379,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 {}
@@ -2401,14 +2411,12 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
-            if _stream:
-                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
@@ -2427,12 +2435,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 {}
@@ -2457,14 +2467,12 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
-            if _stream:
-                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
@@ -2487,12 +2495,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 {}
@@ -2517,14 +2527,12 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
-            if _stream:
-                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
@@ -2542,15 +2550,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 {}
@@ -2577,14 +2587,14 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
-            if _stream:
-                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
@@ -2605,14 +2615,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:
         """
 
@@ -2637,7 +2647,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:
         """
 
@@ -2654,19 +2664,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 {})
@@ -2705,14 +2717,14 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
-            if _stream:
-                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
@@ -2730,15 +2742,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 {}
@@ -2763,14 +2777,14 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
-            if _stream:
-                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
@@ -2789,12 +2803,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 {}
@@ -2819,14 +2835,12 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
-            if _stream:
-                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
@@ -2845,12 +2859,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 {}
@@ -2875,14 +2891,12 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
-            if _stream:
-                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
@@ -2906,7 +2920,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.
@@ -2965,7 +2979,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.
@@ -2974,12 +2988,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 {})
@@ -3022,23 +3038,18 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         response = pipeline_response.http_response
 
         if response.status_code not in [200, 206]:
-            if _stream:
-                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
@@ -3058,7 +3069,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
@@ -3094,17 +3105,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 {})
@@ -3142,14 +3155,12 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
-            if _stream:
-                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
@@ -3168,12 +3179,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 {}
@@ -3198,14 +3211,12 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
-            if _stream:
-                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
@@ -3224,12 +3235,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 {}
@@ -3254,14 +3267,12 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
-            if _stream:
-                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
@@ -3286,12 +3297,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 {})
@@ -3324,14 +3337,12 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
-            if _stream:
-                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
@@ -3350,12 +3361,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 {}
@@ -3380,14 +3393,12 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
-            if _stream:
-                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
@@ -3410,12 +3421,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 {}
@@ -3440,14 +3453,12 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
-            if _stream:
-                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
@@ -3465,15 +3476,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 {}
@@ -3500,14 +3513,14 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
-            if _stream:
-                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
@@ -3531,14 +3544,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:
         """
 
@@ -3566,7 +3579,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:
         """
 
@@ -3586,19 +3599,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 {})
@@ -3638,14 +3653,14 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
-            if _stream:
-                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
@@ -3663,15 +3678,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 {}
@@ -3696,14 +3713,14 @@ class JobsOperations:  # pylint: disable=too-many-public-methods
         response = pipeline_response.http_response
 
         if response.status_code not in [200]:
-            if _stream:
-                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