diff --git a/sdk/storage/azure-storage-file-share/CHANGELOG.md b/sdk/storage/azure-storage-file-share/CHANGELOG.md index 162222511349..ada28a578d11 100644 --- a/sdk/storage/azure-storage-file-share/CHANGELOG.md +++ b/sdk/storage/azure-storage-file-share/CHANGELOG.md @@ -4,6 +4,9 @@ ### Features Added +### Other Changes +- Legacy transports will not be supported moving forward + ## 12.25.0 (2026-05-14) ### Features Added diff --git a/sdk/storage/azure-storage-file-share/MANIFEST.in b/sdk/storage/azure-storage-file-share/MANIFEST.in index b67e266799ba..1da294d9d659 100644 --- a/sdk/storage/azure-storage-file-share/MANIFEST.in +++ b/sdk/storage/azure-storage-file-share/MANIFEST.in @@ -1,7 +1,7 @@ include *.md -include azure/__init__.py -include azure/storage/__init__.py include LICENSE +include azure/storage/fileshare/py.typed recursive-include tests *.py recursive-include samples *.py *.md -include azure/storage/fileshare/py.typed +include azure/__init__.py +include azure/storage/__init__.py diff --git a/sdk/storage/azure-storage-file-share/_metadata.json b/sdk/storage/azure-storage-file-share/_metadata.json new file mode 100644 index 000000000000..48cc0626e1f3 --- /dev/null +++ b/sdk/storage/azure-storage-file-share/_metadata.json @@ -0,0 +1,6 @@ +{ + "apiVersion": "2026-06-06", + "apiVersions": { + "Storage.File": "2026-06-06" + } +} \ No newline at end of file diff --git a/sdk/storage/azure-storage-file-share/apiview-properties.json b/sdk/storage/azure-storage-file-share/apiview-properties.json new file mode 100644 index 000000000000..ebaba2c5f7d4 --- /dev/null +++ b/sdk/storage/azure-storage-file-share/apiview-properties.json @@ -0,0 +1,161 @@ +{ + "CrossLanguagePackageId": "Storage.File", + "CrossLanguageDefinitionId": { + "azure.storage.fileshare.models.AccessPolicy": "Storage.File.AccessPolicy", + "azure.storage.fileshare.models.ClearRange": "Storage.File.ClearRange", + "azure.storage.fileshare.models.CorsRule": "Storage.File.CorsRule", + "azure.storage.fileshare.models.DirectoryItem": "Storage.File.DirectoryItem", + "azure.storage.fileshare.models.Error": "Storage.File.Error", + "azure.storage.fileshare.models.FileItem": "Storage.File.FileItem", + "azure.storage.fileshare.models.FileProperty": "Storage.File.FileProperty", + "azure.storage.fileshare.models.FileRange": "Storage.File.FileRange", + "azure.storage.fileshare.models.FilesAndDirectoriesListSegment": "Storage.File.FilesAndDirectoriesListSegment", + "azure.storage.fileshare.models.HandleItem": "Storage.File.HandleItem", + "azure.storage.fileshare.models.KeyInfo": "Storage.File.KeyInfo", + "azure.storage.fileshare.models.ListFilesAndDirectoriesSegmentResponse": "Storage.File.ListFilesAndDirectoriesSegmentResponse", + "azure.storage.fileshare.models.ListHandlesResponse": "Storage.File.ListHandlesResponse", + "azure.storage.fileshare.models.ListSharesResponse": "Storage.File.ListSharesResponse", + "azure.storage.fileshare.models.Metrics": "Storage.File.Metrics", + "azure.storage.fileshare.models.RetentionPolicy": "Storage.File.RetentionPolicy", + "azure.storage.fileshare.models.ShareFileRangeList": "Storage.File.ShareFileRangeList", + "azure.storage.fileshare.models.ShareItemInternal": "Storage.File.ShareItemInternal", + "azure.storage.fileshare.models.ShareNfsSettings": "Storage.File.ShareNfsSettings", + "azure.storage.fileshare.models.ShareNfsSettingsEncryptionInTransit": "Storage.File.ShareNfsSettingsEncryptionInTransit", + "azure.storage.fileshare.models.SharePermission": "Storage.File.SharePermission", + "azure.storage.fileshare.models.SharePropertiesInternal": "Storage.File.SharePropertiesInternal", + "azure.storage.fileshare.models.ShareProtocolSettings": "Storage.File.ShareProtocolSettings", + "azure.storage.fileshare.models.ShareSmbSettings": "Storage.File.ShareSmbSettings", + "azure.storage.fileshare.models.ShareSmbSettingsEncryptionInTransit": "Storage.File.ShareSmbSettingsEncryptionInTransit", + "azure.storage.fileshare.models.ShareStats": "Storage.File.ShareStats", + "azure.storage.fileshare.models.SignedIdentifier": "Storage.File.SignedIdentifier", + "azure.storage.fileshare.models.SignedIdentifiers": "Storage.File.SignedIdentifiers", + "azure.storage.fileshare.models.SmbMultichannel": "Storage.File.SmbMultichannel", + "azure.storage.fileshare.models.StorageServiceProperties": "Storage.File.StorageServiceProperties", + "azure.storage.fileshare.models.StringEncoded": "Storage.File.StringEncoded", + "azure.storage.fileshare.models.UserDelegationKey": "Storage.File.UserDelegationKey", + "azure.storage.fileshare.models.NfsFileType": "Storage.File.NfsFileType", + "azure.storage.fileshare.models.StorageErrorCode": "Storage.File.StorageErrorCode", + "azure.storage.fileshare.models.FilePermissionFormat": "Storage.File.FilePermissionFormat", + "azure.storage.fileshare.models.ShareTokenIntent": "Storage.File.ShareTokenIntent", + "azure.storage.fileshare.models.FilePropertySemantics": "Storage.File.FilePropertySemantics", + "azure.storage.fileshare.models.ListFilesIncludeType": "Storage.File.ListFilesIncludeType", + "azure.storage.fileshare.models.AccessRight": "Storage.File.AccessRight", + "azure.storage.fileshare.models.CopyStatus": "Storage.File.CopyStatus", + "azure.storage.fileshare.models.FileRangeWriteType": "Storage.File.FileRangeWriteType", + "azure.storage.fileshare.models.FileLastWrittenMode": "Storage.File.FileLastWrittenMode", + "azure.storage.fileshare.models.FileRangeWriteFromUrlType": "Storage.File.FileRangeWriteFromUrlType", + "azure.storage.fileshare.models.PermissionCopyModeType": "Storage.File.PermissionCopyModeType", + "azure.storage.fileshare.models.ModeCopyMode": "Storage.File.ModeCopyMode", + "azure.storage.fileshare.models.OwnerCopyMode": "Storage.File.OwnerCopyMode", + "azure.storage.fileshare.models.LeaseStatusType": "Storage.File.LeaseStatusType", + "azure.storage.fileshare.models.LeaseStateType": "Storage.File.LeaseStateType", + "azure.storage.fileshare.models.LeaseDurationType": "Storage.File.LeaseDurationType", + "azure.storage.fileshare.models.ShareRootSquash": "Storage.File.ShareRootSquash", + "azure.storage.fileshare.models.ListSharesIncludeType": "Storage.File.ListSharesIncludeType", + "azure.storage.fileshare.models.ShareAccessTier": "Storage.File.ShareAccessTier", + "azure.storage.fileshare.models.DeleteSnapshotsOptionType": "Storage.File.DeleteSnapshotsOptionType", + "azure.storage.fileshare.operations.DirectoryOperations.create": "Storage.File.Directory.create", + "azure.storage.fileshare.aio.operations.DirectoryOperations.create": "Storage.File.Directory.create", + "azure.storage.fileshare.operations.DirectoryOperations.get_properties": "Storage.File.Directory.getProperties", + "azure.storage.fileshare.aio.operations.DirectoryOperations.get_properties": "Storage.File.Directory.getProperties", + "azure.storage.fileshare.operations.DirectoryOperations.delete": "Storage.File.Directory.delete", + "azure.storage.fileshare.aio.operations.DirectoryOperations.delete": "Storage.File.Directory.delete", + "azure.storage.fileshare.operations.DirectoryOperations.set_properties": "Storage.File.Directory.setProperties", + "azure.storage.fileshare.aio.operations.DirectoryOperations.set_properties": "Storage.File.Directory.setProperties", + "azure.storage.fileshare.operations.DirectoryOperations.set_metadata": "Storage.File.Directory.setMetadata", + "azure.storage.fileshare.aio.operations.DirectoryOperations.set_metadata": "Storage.File.Directory.setMetadata", + "azure.storage.fileshare.operations.DirectoryOperations.list_files_and_directories_segment": "Storage.File.Directory.listFilesAndDirectoriesSegment", + "azure.storage.fileshare.aio.operations.DirectoryOperations.list_files_and_directories_segment": "Storage.File.Directory.listFilesAndDirectoriesSegment", + "azure.storage.fileshare.operations.DirectoryOperations.list_handles": "Storage.File.Directory.listHandles", + "azure.storage.fileshare.aio.operations.DirectoryOperations.list_handles": "Storage.File.Directory.listHandles", + "azure.storage.fileshare.operations.DirectoryOperations.force_close_handles": "Storage.File.Directory.forceCloseHandles", + "azure.storage.fileshare.aio.operations.DirectoryOperations.force_close_handles": "Storage.File.Directory.forceCloseHandles", + "azure.storage.fileshare.operations.DirectoryOperations.rename": "Storage.File.Directory.rename", + "azure.storage.fileshare.aio.operations.DirectoryOperations.rename": "Storage.File.Directory.rename", + "azure.storage.fileshare.operations.FileOperations.create": "Storage.File.File.create", + "azure.storage.fileshare.aio.operations.FileOperations.create": "Storage.File.File.create", + "azure.storage.fileshare.operations.FileOperations.download": "Storage.File.File.download", + "azure.storage.fileshare.aio.operations.FileOperations.download": "Storage.File.File.download", + "azure.storage.fileshare.operations.FileOperations.get_properties": "Storage.File.File.getProperties", + "azure.storage.fileshare.aio.operations.FileOperations.get_properties": "Storage.File.File.getProperties", + "azure.storage.fileshare.operations.FileOperations.delete": "Storage.File.File.delete", + "azure.storage.fileshare.aio.operations.FileOperations.delete": "Storage.File.File.delete", + "azure.storage.fileshare.operations.FileOperations.set_http_headers": "Storage.File.File.setHttpHeaders", + "azure.storage.fileshare.aio.operations.FileOperations.set_http_headers": "Storage.File.File.setHttpHeaders", + "azure.storage.fileshare.operations.FileOperations.set_metadata": "Storage.File.File.setMetadata", + "azure.storage.fileshare.aio.operations.FileOperations.set_metadata": "Storage.File.File.setMetadata", + "azure.storage.fileshare.operations.FileOperations.acquire_lease": "Storage.File.File.acquireLease", + "azure.storage.fileshare.aio.operations.FileOperations.acquire_lease": "Storage.File.File.acquireLease", + "azure.storage.fileshare.operations.FileOperations.release_lease": "Storage.File.File.releaseLease", + "azure.storage.fileshare.aio.operations.FileOperations.release_lease": "Storage.File.File.releaseLease", + "azure.storage.fileshare.operations.FileOperations.change_lease": "Storage.File.File.changeLease", + "azure.storage.fileshare.aio.operations.FileOperations.change_lease": "Storage.File.File.changeLease", + "azure.storage.fileshare.operations.FileOperations.break_lease": "Storage.File.File.breakLease", + "azure.storage.fileshare.aio.operations.FileOperations.break_lease": "Storage.File.File.breakLease", + "azure.storage.fileshare.operations.FileOperations.upload_range": "Storage.File.File.uploadRange", + "azure.storage.fileshare.aio.operations.FileOperations.upload_range": "Storage.File.File.uploadRange", + "azure.storage.fileshare.operations.FileOperations.upload_range_from_url": "Storage.File.File.uploadRangeFromUrl", + "azure.storage.fileshare.aio.operations.FileOperations.upload_range_from_url": "Storage.File.File.uploadRangeFromUrl", + "azure.storage.fileshare.operations.FileOperations.get_range_list": "Storage.File.File.getRangeList", + "azure.storage.fileshare.aio.operations.FileOperations.get_range_list": "Storage.File.File.getRangeList", + "azure.storage.fileshare.operations.FileOperations.start_copy": "Storage.File.File.startCopy", + "azure.storage.fileshare.aio.operations.FileOperations.start_copy": "Storage.File.File.startCopy", + "azure.storage.fileshare.operations.FileOperations.abort_copy": "Storage.File.File.abortCopy", + "azure.storage.fileshare.aio.operations.FileOperations.abort_copy": "Storage.File.File.abortCopy", + "azure.storage.fileshare.operations.FileOperations.list_handles": "Storage.File.File.listHandles", + "azure.storage.fileshare.aio.operations.FileOperations.list_handles": "Storage.File.File.listHandles", + "azure.storage.fileshare.operations.FileOperations.force_close_handles": "Storage.File.File.forceCloseHandles", + "azure.storage.fileshare.aio.operations.FileOperations.force_close_handles": "Storage.File.File.forceCloseHandles", + "azure.storage.fileshare.operations.FileOperations.rename": "Storage.File.File.rename", + "azure.storage.fileshare.aio.operations.FileOperations.rename": "Storage.File.File.rename", + "azure.storage.fileshare.operations.FileOperations.create_symbolic_link": "Storage.File.File.createSymbolicLink", + "azure.storage.fileshare.aio.operations.FileOperations.create_symbolic_link": "Storage.File.File.createSymbolicLink", + "azure.storage.fileshare.operations.FileOperations.get_symbolic_link": "Storage.File.File.getSymbolicLink", + "azure.storage.fileshare.aio.operations.FileOperations.get_symbolic_link": "Storage.File.File.getSymbolicLink", + "azure.storage.fileshare.operations.FileOperations.create_hard_link": "Storage.File.File.createHardLink", + "azure.storage.fileshare.aio.operations.FileOperations.create_hard_link": "Storage.File.File.createHardLink", + "azure.storage.fileshare.operations.ServiceOperations.set_properties": "Storage.File.Service.setProperties", + "azure.storage.fileshare.aio.operations.ServiceOperations.set_properties": "Storage.File.Service.setProperties", + "azure.storage.fileshare.operations.ServiceOperations.get_properties": "Storage.File.Service.getProperties", + "azure.storage.fileshare.aio.operations.ServiceOperations.get_properties": "Storage.File.Service.getProperties", + "azure.storage.fileshare.operations.ServiceOperations.list_shares_segment": "Storage.File.Service.listSharesSegment", + "azure.storage.fileshare.aio.operations.ServiceOperations.list_shares_segment": "Storage.File.Service.listSharesSegment", + "azure.storage.fileshare.operations.ServiceOperations.get_user_delegation_key": "Storage.File.Service.getUserDelegationKey", + "azure.storage.fileshare.aio.operations.ServiceOperations.get_user_delegation_key": "Storage.File.Service.getUserDelegationKey", + "azure.storage.fileshare.operations.ShareOperations.create": "Storage.File.Share.create", + "azure.storage.fileshare.aio.operations.ShareOperations.create": "Storage.File.Share.create", + "azure.storage.fileshare.operations.ShareOperations.get_properties": "Storage.File.Share.getProperties", + "azure.storage.fileshare.aio.operations.ShareOperations.get_properties": "Storage.File.Share.getProperties", + "azure.storage.fileshare.operations.ShareOperations.delete": "Storage.File.Share.delete", + "azure.storage.fileshare.aio.operations.ShareOperations.delete": "Storage.File.Share.delete", + "azure.storage.fileshare.operations.ShareOperations.acquire_lease": "Storage.File.Share.acquireLease", + "azure.storage.fileshare.aio.operations.ShareOperations.acquire_lease": "Storage.File.Share.acquireLease", + "azure.storage.fileshare.operations.ShareOperations.release_lease": "Storage.File.Share.releaseLease", + "azure.storage.fileshare.aio.operations.ShareOperations.release_lease": "Storage.File.Share.releaseLease", + "azure.storage.fileshare.operations.ShareOperations.change_lease": "Storage.File.Share.changeLease", + "azure.storage.fileshare.aio.operations.ShareOperations.change_lease": "Storage.File.Share.changeLease", + "azure.storage.fileshare.operations.ShareOperations.renew_lease": "Storage.File.Share.renewLease", + "azure.storage.fileshare.aio.operations.ShareOperations.renew_lease": "Storage.File.Share.renewLease", + "azure.storage.fileshare.operations.ShareOperations.break_lease": "Storage.File.Share.breakLease", + "azure.storage.fileshare.aio.operations.ShareOperations.break_lease": "Storage.File.Share.breakLease", + "azure.storage.fileshare.operations.ShareOperations.create_snapshot": "Storage.File.Share.createSnapshot", + "azure.storage.fileshare.aio.operations.ShareOperations.create_snapshot": "Storage.File.Share.createSnapshot", + "azure.storage.fileshare.operations.ShareOperations.create_permission": "Storage.File.Share.createPermission", + "azure.storage.fileshare.aio.operations.ShareOperations.create_permission": "Storage.File.Share.createPermission", + "azure.storage.fileshare.operations.ShareOperations.get_permission": "Storage.File.Share.getPermission", + "azure.storage.fileshare.aio.operations.ShareOperations.get_permission": "Storage.File.Share.getPermission", + "azure.storage.fileshare.operations.ShareOperations.set_properties": "Storage.File.Share.setProperties", + "azure.storage.fileshare.aio.operations.ShareOperations.set_properties": "Storage.File.Share.setProperties", + "azure.storage.fileshare.operations.ShareOperations.set_metadata": "Storage.File.Share.setMetadata", + "azure.storage.fileshare.aio.operations.ShareOperations.set_metadata": "Storage.File.Share.setMetadata", + "azure.storage.fileshare.operations.ShareOperations.get_access_policy": "Storage.File.Share.getAccessPolicy", + "azure.storage.fileshare.aio.operations.ShareOperations.get_access_policy": "Storage.File.Share.getAccessPolicy", + "azure.storage.fileshare.operations.ShareOperations.set_access_policy": "Storage.File.Share.setAccessPolicy", + "azure.storage.fileshare.aio.operations.ShareOperations.set_access_policy": "Storage.File.Share.setAccessPolicy", + "azure.storage.fileshare.operations.ShareOperations.get_statistics": "Storage.File.Share.getStatistics", + "azure.storage.fileshare.aio.operations.ShareOperations.get_statistics": "Storage.File.Share.getStatistics", + "azure.storage.fileshare.operations.ShareOperations.restore": "Storage.File.Share.restore", + "azure.storage.fileshare.aio.operations.ShareOperations.restore": "Storage.File.Share.restore" + }, + "CrossLanguageVersion": "fdd35c41a0ed" +} \ No newline at end of file diff --git a/sdk/storage/azure-storage-file-share/azure/__init__.py b/sdk/storage/azure-storage-file-share/azure/__init__.py index 0c36c2076ba0..d55ccad1f573 100644 --- a/sdk/storage/azure-storage-file-share/azure/__init__.py +++ b/sdk/storage/azure-storage-file-share/azure/__init__.py @@ -1 +1 @@ -__path__ = __import__('pkgutil').extend_path(__path__, __name__) # type: ignore +__path__ = __import__("pkgutil").extend_path(__path__, __name__) # type: ignore diff --git a/sdk/storage/azure-storage-file-share/azure/storage/__init__.py b/sdk/storage/azure-storage-file-share/azure/storage/__init__.py index 0c36c2076ba0..d55ccad1f573 100644 --- a/sdk/storage/azure-storage-file-share/azure/storage/__init__.py +++ b/sdk/storage/azure-storage-file-share/azure/storage/__init__.py @@ -1 +1 @@ -__path__ = __import__('pkgutil').extend_path(__path__, __name__) # type: ignore +__path__ = __import__("pkgutil").extend_path(__path__, __name__) # type: ignore diff --git a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/__init__.py b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/__init__.py index 660fa3798557..4b1cf17142a8 100644 --- a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/__init__.py +++ b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/__init__.py @@ -42,52 +42,49 @@ ShareProtocolSettings, ShareProtocols, ) -from ._generated.models import ( - ShareAccessTier, - ShareRootSquash -) +from ._generated.models import ShareAccessTier, ShareRootSquash __version__ = VERSION __all__ = [ - 'AccessPolicy', - 'AccountSasPermissions', - 'ContentSettings', - 'CorsRule', - 'DirectoryProperties', - 'ExponentialRetry', - 'FileProperties', - 'FileSasPermissions', - 'generate_account_sas', - 'generate_file_sas', - 'generate_share_sas', - 'Handle', - 'LinearRetry', - 'LocationMode', - 'Metrics', - 'NfsEncryptionInTransit', - 'NTFSAttributes', - 'ResourceTypes', - 'RetentionPolicy', - 'Services', - 'ShareAccessTier', - 'ShareClient', - 'ShareDirectoryClient', - 'ShareFileClient', - 'ShareLeaseClient', - 'ShareNfsSettings', - 'ShareProperties', - 'ShareProtocolSettings', - 'ShareProtocols', - 'ShareRootSquash', - 'ShareSasPermissions', - 'ShareServiceClient', - 'ShareSmbSettings', - 'SmbEncryptionInTransit', - 'SmbMultichannel', - 'StorageErrorCode', - 'UserDelegationKey' + "AccessPolicy", + "AccountSasPermissions", + "ContentSettings", + "CorsRule", + "DirectoryProperties", + "ExponentialRetry", + "FileProperties", + "FileSasPermissions", + "generate_account_sas", + "generate_file_sas", + "generate_share_sas", + "Handle", + "LinearRetry", + "LocationMode", + "Metrics", + "NfsEncryptionInTransit", + "NTFSAttributes", + "ResourceTypes", + "RetentionPolicy", + "Services", + "ShareAccessTier", + "ShareClient", + "ShareDirectoryClient", + "ShareFileClient", + "ShareLeaseClient", + "ShareNfsSettings", + "ShareProperties", + "ShareProtocolSettings", + "ShareProtocols", + "ShareRootSquash", + "ShareSasPermissions", + "ShareServiceClient", + "ShareSmbSettings", + "SmbEncryptionInTransit", + "SmbMultichannel", + "StorageErrorCode", + "UserDelegationKey", ] @@ -96,12 +93,10 @@ # to prevent it from showing in intellisense/docs but we handle it here to prevent # breaking any existing code which may have imported it. def __getattr__(name): - if name == 'HandleItem': + if name == "HandleItem": from ._generated.models import HandleItem - warnings.warn( - "HandleItem is deprecated and should not be used. Use Handle instead.", - DeprecationWarning - ) + + warnings.warn("HandleItem is deprecated and should not be used. Use Handle instead.", DeprecationWarning) return HandleItem raise AttributeError(f"module 'azure.storage.fileshare' has no attribute {name}") diff --git a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_deserialize.py b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_deserialize.py index 5db600d5f5ed..a3adccf3cac7 100644 --- a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_deserialize.py +++ b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_deserialize.py @@ -3,10 +3,7 @@ # Licensed under the MIT License. See License.txt in the project root for # license information. # --------------------------------------------------------------------------_ -from typing import ( - Any, cast, Dict, List, Optional, Tuple, - TYPE_CHECKING -) +from typing import Any, cast, Dict, List, Optional, Tuple, TYPE_CHECKING from ._generated.models import ShareFileRangeList from ._models import DirectoryProperties, FileProperties, ShareProperties @@ -19,67 +16,89 @@ def deserialize_share_properties(response: "PipelineResponse", obj: Any, headers: Dict[str, Any]) -> ShareProperties: metadata = deserialize_metadata(response, obj, headers) - share_properties = ShareProperties( - metadata=metadata, - **headers - ) + share_properties = ShareProperties(metadata=metadata, **headers) return share_properties def deserialize_directory_properties( - response: "PipelineResponse", - obj: Any, - headers: Dict[str, Any] + response: "PipelineResponse", obj: Any, headers: Dict[str, Any] ) -> DirectoryProperties: metadata = deserialize_metadata(response, obj, headers) - directory_properties = DirectoryProperties( - metadata=metadata, - **headers - ) + directory_properties = DirectoryProperties(metadata=metadata, **headers) return directory_properties +class _StreamWrapper: + """Wraps a bytes iterator (sync or async) so that properties can be attached.""" + + def __init__(self, stream): + self._stream = stream + self.properties = None + self.response = None + + def __iter__(self): + return iter(self._stream) + + def __next__(self): + return next(self._stream) + + def __aiter__(self): + return self._stream.__aiter__() + + async def __anext__(self): + return await self._stream.__anext__() + + def deserialize_file_properties(response: "PipelineResponse", obj: Any, headers: Dict[str, Any]) -> FileProperties: metadata = deserialize_metadata(response, obj, headers) - file_properties = FileProperties( - metadata=metadata, - **headers - ) - if 'Content-Range' in headers: - if 'x-ms-content-md5' in headers: - file_properties.content_settings.content_md5 = headers['x-ms-content-md5'] + file_properties = FileProperties(metadata=metadata, **headers) + if "Content-Range" in headers: + if "x-ms-content-md5" in headers: + file_properties.content_settings.content_md5 = headers["x-ms-content-md5"] else: file_properties.content_settings.content_md5 = None return file_properties def deserialize_file_stream( - response: "PipelineResponse", - obj: Any, - headers: Dict[str, Any] + response: "PipelineResponse", obj: Any, headers: Dict[str, Any] ) -> Tuple["LocationMode", Any]: file_properties = deserialize_file_properties(response, obj, headers) + # The new TypeSpec-generated download returns an iterator (from iter_bytes/iter_raw) + # instead of a response object with settable attributes. Wrap it. + if not hasattr(obj, "properties") or isinstance(obj, type(iter(b""))): + wrapped = _StreamWrapper(obj) + wrapped.properties = file_properties + try: + wrapped.response = response.http_response + except AttributeError: + pass + return response.http_response.location_mode, wrapped obj.properties = file_properties return response.http_response.location_mode, obj # Extracts out file permission -def deserialize_permission(response: "PipelineResponse", obj: Any, headers: Dict[str, Any]) -> Optional[str]: # pylint: disable=unused-argument +def deserialize_permission( # pylint: disable=unused-argument + response: "PipelineResponse", obj: Any, headers: Dict[str, Any] +) -> Optional[str]: return cast(Optional[str], obj.permission) # Extracts out file permission key -def deserialize_permission_key(response: "PipelineResponse", obj: Any, headers: Dict[str, Any]) -> Optional[str]: # pylint: disable=unused-argument +def deserialize_permission_key( # pylint: disable=unused-argument + response: "PipelineResponse", obj: Any, headers: Dict[str, Any] +) -> Optional[str]: if response is None or headers is None: return None - return cast(Optional[str], headers.get('x-ms-file-permission-key', None)) + return cast(Optional[str], headers.get("x-ms-file-permission-key", None)) def get_file_ranges_result(ranges: ShareFileRangeList) -> Tuple[List[Dict[str, int]], List[Dict[str, int]]]: file_ranges = [] clear_ranges = [] if ranges.ranges: - file_ranges = [{'start': file_range.start, 'end': file_range.end} for file_range in ranges.ranges] + file_ranges = [{"start": file_range.start, "end": file_range.end} for file_range in ranges.ranges] if ranges.clear_ranges: - clear_ranges = [{'start': clear_range.start, 'end': clear_range.end} for clear_range in ranges.clear_ranges] + clear_ranges = [{"start": clear_range.start, "end": clear_range.end} for clear_range in ranges.clear_ranges] return file_ranges, clear_ranges diff --git a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_directory_client.py b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_directory_client.py index 5191ff9392ab..652f64ed4dce 100644 --- a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_directory_client.py +++ b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_directory_client.py @@ -1,3 +1,4 @@ +# pylint: disable=too-many-lines # ------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for @@ -9,10 +10,7 @@ import sys import time from datetime import datetime -from typing import ( - Any, AnyStr, cast, Dict, IO, Iterable, Optional, Union, - TYPE_CHECKING -) +from typing import Any, AnyStr, cast, Dict, IO, Iterable, Optional, Union, TYPE_CHECKING from typing_extensions import Self from azure.core.exceptions import HttpResponseError, ResourceNotFoundError @@ -20,15 +18,11 @@ from azure.core.pipeline import Pipeline from azure.core.tracing.decorator import distributed_trace from ._deserialize import deserialize_directory_properties -from ._directory_client_helpers import ( - _format_url, - _from_directory_url, - _parse_url -) +from ._directory_client_helpers import _format_url, _from_directory_url, _parse_url from ._file_client import ShareFileClient -from ._generated import AzureFileStorage +from ._generated import FileClient as AzureFileStorage from ._models import DirectoryPropertiesPaged, Handle, HandlesPaged -from ._parser import _datetime_to_str, _get_file_permission, _parse_snapshot +from ._parser import _datetime_to_str, _get_file_permission, _parse_snapshot, _strip_snapshot_from_url from ._serialize import get_api_version, get_dest_access_conditions, get_rename_smb_properties from ._shared.base_client import parse_connection_str, parse_query, StorageAccountHostsMixin, TransportWrapper from ._shared.request_handlers import add_metadata_headers @@ -103,42 +97,41 @@ class ShareDirectoryClient(StorageAccountHostsMixin): authentication. Only has an effect when credential is of type TokenCredential. The value could be https://storage.azure.com/ (default) or https://.file.core.windows.net. """ + def __init__( - self, account_url: str, + self, + account_url: str, share_name: str, directory_path: str, snapshot: Optional[Union[str, Dict[str, Any]]] = None, - credential: Optional[Union[str, Dict[str, str], "AzureNamedKeyCredential", "AzureSasCredential", "TokenCredential"]] = None, # pylint: disable=line-too-long + credential: Optional[ + Union[str, Dict[str, str], "AzureNamedKeyCredential", "AzureSasCredential", "TokenCredential"] + ] = None, # pylint: disable=line-too-long *, - token_intent: Optional[Literal['backup']] = None, - **kwargs: Any + token_intent: Optional[Literal["backup"]] = None, + **kwargs: Any, ) -> None: - if hasattr(credential, 'get_token') and not token_intent: + if hasattr(credential, "get_token") and not token_intent: raise ValueError("'token_intent' keyword is required when 'credential' is an TokenCredential.") parsed_url = _parse_url(account_url, share_name) path_snapshot, sas_token = parse_query(parsed_url.query) if not sas_token and not credential: raise ValueError( - 'You need to provide either an account shared key or SAS token when creating a storage service.') + "You need to provide either an account shared key or SAS token when creating a storage service." + ) self.snapshot = _parse_snapshot(snapshot, path_snapshot) self.share_name = share_name self.directory_path = directory_path - self._query_str, credential = self._format_query_string( - sas_token, credential, share_snapshot=self.snapshot) - super(ShareDirectoryClient, self).__init__( - parsed_url, service='file-share', credential=credential, **kwargs) - self.allow_trailing_dot = kwargs.pop('allow_trailing_dot', None) - self.allow_source_trailing_dot = kwargs.pop('allow_source_trailing_dot', None) + self._query_str, credential = self._format_query_string(sas_token, credential, share_snapshot=self.snapshot) + super(ShareDirectoryClient, self).__init__(parsed_url, service="file-share", credential=credential, **kwargs) + self.allow_trailing_dot = kwargs.pop("allow_trailing_dot", None) + self.allow_source_trailing_dot = kwargs.pop("allow_source_trailing_dot", None) self.file_request_intent = token_intent self._client = AzureFileStorage( + url=_strip_snapshot_from_url(self.url), version=get_api_version(kwargs), - url=self.url, - base_url=self.url, pipeline=self._pipeline, - allow_trailing_dot=self.allow_trailing_dot, - allow_source_trailing_dot=self.allow_source_trailing_dot, - file_request_intent=self.file_request_intent ) def __enter__(self) -> Self: @@ -159,10 +152,13 @@ def close(self) -> None: @classmethod def from_directory_url( - cls, directory_url: str, + cls, + directory_url: str, snapshot: Optional[Union[str, Dict[str, Any]]] = None, - credential: Optional[Union[str, Dict[str, str], "AzureNamedKeyCredential", "AzureSasCredential", "TokenCredential"]] = None, # pylint: disable=line-too-long - **kwargs: Any + credential: Optional[ + Union[str, Dict[str, str], "AzureNamedKeyCredential", "AzureSasCredential", "TokenCredential"] + ] = None, # pylint: disable=line-too-long + **kwargs: Any, ) -> Self: """Create a ShareDirectoryClient from a directory url. @@ -193,8 +189,13 @@ def from_directory_url( """ account_url, share_name, directory_path, snapshot = _from_directory_url(directory_url, snapshot) return cls( - account_url=account_url, share_name=share_name, directory_path=directory_path, - snapshot=snapshot, credential=credential, **kwargs) + account_url=account_url, + share_name=share_name, + directory_path=directory_path, + snapshot=snapshot, + credential=credential, + **kwargs, + ) def _format_url(self, hostname: str) -> str: """Format the endpoint URL according to the current location mode hostname. @@ -208,11 +209,14 @@ def _format_url(self, hostname: str) -> str: @classmethod def from_connection_string( - cls, conn_str: str, + cls, + conn_str: str, share_name: str, directory_path: str, - credential: Optional[Union[str, Dict[str, str], "AzureNamedKeyCredential", "AzureSasCredential", "TokenCredential"]] = None, # pylint: disable=line-too-long - **kwargs: Any + credential: Optional[ + Union[str, Dict[str, str], "AzureNamedKeyCredential", "AzureSasCredential", "TokenCredential"] + ] = None, # pylint: disable=line-too-long + **kwargs: Any, ) -> Self: """Create ShareDirectoryClient from a Connection String. @@ -239,11 +243,10 @@ def from_connection_string( :returns: A directory client. :rtype: ~azure.storage.fileshare.ShareDirectoryClient """ - account_url, secondary, credential = parse_connection_str(conn_str, credential, 'file') - if 'secondary_hostname' not in kwargs: - kwargs['secondary_hostname'] = secondary - return cls( - account_url, share_name=share_name, directory_path=directory_path, credential=credential, **kwargs) + account_url, secondary, credential = parse_connection_str(conn_str, credential, "file") + if "secondary_hostname" not in kwargs: + kwargs["secondary_hostname"] = secondary + return cls(account_url, share_name=share_name, directory_path=directory_path, credential=credential, **kwargs) def get_file_client(self, file_name: str, **kwargs: Any) -> ShareFileClient: """Get a client to interact with a specific file. @@ -255,19 +258,28 @@ def get_file_client(self, file_name: str, **kwargs: Any) -> ShareFileClient: :rtype: ~azure.storage.fileshare.ShareFileClient """ if self.directory_path: - file_name = self.directory_path.rstrip('/') + "/" + file_name + file_name = self.directory_path.rstrip("/") + "/" + file_name _pipeline = Pipeline( transport=TransportWrapper(self._pipeline._transport), # pylint: disable=protected-access - policies=self._pipeline._impl_policies # pylint: disable=protected-access + policies=self._pipeline._impl_policies, # pylint: disable=protected-access ) return ShareFileClient( - self.url, file_path=file_name, share_name=self.share_name, snapshot=self.snapshot, - credential=self.credential, token_intent=self.file_request_intent, api_version=self.api_version, - _hosts=self._hosts, _configuration=self._config, - _pipeline=_pipeline, _location_mode=self._location_mode, + self.url, + file_path=file_name, + share_name=self.share_name, + snapshot=self.snapshot, + credential=self.credential, + token_intent=self.file_request_intent, + api_version=self.api_version, + _hosts=self._hosts, + _configuration=self._config, + _pipeline=_pipeline, + _location_mode=self._location_mode, allow_trailing_dot=self.allow_trailing_dot, - allow_source_trailing_dot=self.allow_source_trailing_dot, **kwargs) + allow_source_trailing_dot=self.allow_source_trailing_dot, + **kwargs, + ) def get_subdirectory_client(self, directory_name: str, **kwargs: Any) -> "ShareDirectoryClient": """Get a client to interact with a specific subdirectory. @@ -290,18 +302,28 @@ def get_subdirectory_client(self, directory_name: str, **kwargs: Any) -> "ShareD """ directory_path = directory_name if self.directory_path: - directory_path = self.directory_path.rstrip('/') + "/" + directory_name + directory_path = self.directory_path.rstrip("/") + "/" + directory_name _pipeline = Pipeline( transport=TransportWrapper(self._pipeline._transport), # pylint: disable=protected-access - policies=self._pipeline._impl_policies # pylint: disable=protected-access + policies=self._pipeline._impl_policies, # pylint: disable=protected-access ) return ShareDirectoryClient( - self.url, share_name=self.share_name, directory_path=directory_path, snapshot=self.snapshot, - credential=self.credential, token_intent=self.file_request_intent, api_version=self.api_version, - _hosts=self._hosts, _configuration=self._config, _pipeline=_pipeline, - _location_mode=self._location_mode, allow_trailing_dot=self.allow_trailing_dot, - allow_source_trailing_dot=self.allow_source_trailing_dot, **kwargs) + self.url, + share_name=self.share_name, + directory_path=directory_path, + snapshot=self.snapshot, + credential=self.credential, + token_intent=self.file_request_intent, + api_version=self.api_version, + _hosts=self._hosts, + _configuration=self._config, + _pipeline=_pipeline, + _location_mode=self._location_mode, + allow_trailing_dot=self.allow_trailing_dot, + allow_source_trailing_dot=self.allow_source_trailing_dot, + **kwargs, + ) @distributed_trace def create_directory(self, **kwargs: Any) -> Dict[str, Any]: @@ -374,31 +396,37 @@ def create_directory(self, **kwargs: Any) -> Dict[str, Any]: :dedent: 12 :caption: Creates a directory. """ - timeout = kwargs.pop('timeout', None) - metadata = kwargs.pop('metadata', None) - headers = kwargs.pop('headers', {}) + timeout = kwargs.pop("timeout", None) + metadata = kwargs.pop("metadata", None) + headers = kwargs.pop("headers", {}) headers.update(add_metadata_headers(metadata)) - file_attributes = kwargs.pop('file_attributes', None) - file_creation_time = kwargs.pop('file_creation_time', None) - file_last_write_time = kwargs.pop('file_last_write_time', None) - file_change_time = kwargs.pop('file_change_time', None) - file_permission = kwargs.pop('file_permission', None) - file_permission_key = kwargs.pop('file_permission_key', None) + file_attributes = kwargs.pop("file_attributes", None) + file_creation_time = kwargs.pop("file_creation_time", None) + file_last_write_time = kwargs.pop("file_last_write_time", None) + file_change_time = kwargs.pop("file_change_time", None) + file_permission = kwargs.pop("file_permission", None) + file_permission_key = kwargs.pop("file_permission_key", None) file_permission = _get_file_permission(file_permission, file_permission_key, None) try: - return cast(Dict[str, Any], self._client.directory.create( - file_attributes=str(file_attributes) if file_attributes is not None else file_attributes, - file_creation_time=_datetime_to_str(file_creation_time), - file_last_write_time=_datetime_to_str(file_last_write_time), - file_change_time=_datetime_to_str(file_change_time), - file_permission=file_permission, - file_permission_key=file_permission_key, - timeout=timeout, - cls=return_response_headers, - headers=headers, - **kwargs)) + return cast( + Dict[str, Any], + self._client.directory.create( + file_attributes=str(file_attributes) if file_attributes is not None else file_attributes, + file_creation_time=_datetime_to_str(file_creation_time), + file_last_write_time=_datetime_to_str(file_last_write_time), + file_change_time=_datetime_to_str(file_change_time), + file_permission=file_permission, + file_permission_key=file_permission_key, + timeout=timeout, + cls=return_response_headers, + headers=headers, + allow_trailing_dot=self.allow_trailing_dot, + file_request_intent=self.file_request_intent, + **kwargs, + ), + ) except HttpResponseError as error: process_storage_error(error) @@ -424,9 +452,14 @@ def delete_directory(self, **kwargs: Any) -> None: :dedent: 12 :caption: Deletes a directory. """ - timeout = kwargs.pop('timeout', None) + timeout = kwargs.pop("timeout", None) try: - self._client.directory.delete(timeout=timeout, **kwargs) + self._client.directory.delete( + timeout=timeout, + allow_trailing_dot=self.allow_trailing_dot, + file_request_intent=self.file_request_intent, + **kwargs, + ) except HttpResponseError as error: process_storage_error(error) @@ -494,40 +527,51 @@ def rename_directory(self, new_name: str, **kwargs: Any) -> "ShareDirectoryClien if not new_name: raise ValueError("Please specify a new directory name.") - new_name = new_name.strip('/') - new_path_and_query = new_name.split('?') + new_name = new_name.strip("/") + new_path_and_query = new_name.split("?") new_dir_path = new_path_and_query[0] if len(new_path_and_query) == 2: - new_dir_sas = new_path_and_query[1] or self._query_str.strip('?') + new_dir_sas = new_path_and_query[1] or self._query_str.strip("?") else: - new_dir_sas = self._query_str.strip('?') + new_dir_sas = self._query_str.strip("?") new_directory_client = ShareDirectoryClient( - f'{self.scheme}://{self.primary_hostname}', self.share_name, new_dir_path, - credential=new_dir_sas or self.credential, api_version=self.api_version, - _hosts=self._hosts, _configuration=self._config, _pipeline=self._pipeline, - _location_mode=self._location_mode, allow_trailing_dot=self.allow_trailing_dot, - allow_source_trailing_dot=self.allow_source_trailing_dot, token_intent=self.file_request_intent + f"{self.scheme}://{self.primary_hostname}", + self.share_name, + new_dir_path, + credential=new_dir_sas or self.credential, + api_version=self.api_version, + _hosts=self._hosts, + _configuration=self._config, + _pipeline=self._pipeline, + _location_mode=self._location_mode, + allow_trailing_dot=self.allow_trailing_dot, + allow_source_trailing_dot=self.allow_source_trailing_dot, + token_intent=self.file_request_intent, ) kwargs.update(get_rename_smb_properties(kwargs)) - timeout = kwargs.pop('timeout', None) - overwrite = kwargs.pop('overwrite', None) - metadata = kwargs.pop('metadata', None) - headers = kwargs.pop('headers', {}) + timeout = kwargs.pop("timeout", None) + overwrite = kwargs.pop("overwrite", None) + metadata = kwargs.pop("metadata", None) + headers = kwargs.pop("headers", {}) headers.update(add_metadata_headers(metadata)) - destination_access_conditions = get_dest_access_conditions(kwargs.pop('destination_lease', None)) + destination_access_conditions = get_dest_access_conditions(kwargs.pop("destination_lease", None)) try: new_directory_client._client.directory.rename( # pylint: disable=protected-access - self.url, + rename_source=self.url, timeout=timeout, replace_if_exists=overwrite, - destination_lease_access_conditions=destination_access_conditions, + destination_lease_id=destination_access_conditions, headers=headers, - **kwargs) + allow_trailing_dot=self.allow_trailing_dot, + allow_source_trailing_dot=self.allow_source_trailing_dot, + file_request_intent=self.file_request_intent, + **kwargs, + ) return new_directory_client except HttpResponseError as error: @@ -535,9 +579,7 @@ def rename_directory(self, new_name: str, **kwargs: Any) -> "ShareDirectoryClien @distributed_trace def list_directories_and_files( - self, - name_starts_with: Optional[str] = None, - **kwargs: Any + self, name_starts_with: Optional[str] = None, **kwargs: Any ) -> ItemPaged[Union["DirectoryProperties", "FileProperties"]]: """Lists all the directories and files under the directory. @@ -577,16 +619,22 @@ def list_directories_and_files( :dedent: 12 :caption: List directories and files. """ - timeout = kwargs.pop('timeout', None) - results_per_page = kwargs.pop('results_per_page', None) + timeout = kwargs.pop("timeout", None) + results_per_page = kwargs.pop("results_per_page", None) command = functools.partial( self._client.directory.list_files_and_directories_segment, sharesnapshot=self.snapshot, timeout=timeout, - **kwargs) + allow_trailing_dot=self.allow_trailing_dot, + file_request_intent=self.file_request_intent, + **kwargs, + ) return ItemPaged( - command, prefix=name_starts_with, results_per_page=results_per_page, - page_iterator_class=DirectoryPropertiesPaged) + command, + prefix=name_starts_with, + results_per_page=results_per_page, + page_iterator_class=DirectoryPropertiesPaged, + ) @distributed_trace def list_handles(self, recursive: bool = False, **kwargs: Any) -> ItemPaged[Handle]: @@ -604,17 +652,18 @@ def list_handles(self, recursive: bool = False, **kwargs: Any) -> ItemPaged[Hand :returns: An auto-paging iterable of Handle :rtype: ~azure.core.paging.ItemPaged[~azure.storage.fileshare.Handle] """ - timeout = kwargs.pop('timeout', None) - results_per_page = kwargs.pop('results_per_page', None) + timeout = kwargs.pop("timeout", None) + results_per_page = kwargs.pop("results_per_page", None) command = functools.partial( self._client.directory.list_handles, sharesnapshot=self.snapshot, timeout=timeout, recursive=recursive, - **kwargs) - return ItemPaged( - command, results_per_page=results_per_page, - page_iterator_class=HandlesPaged) + allow_trailing_dot=self.allow_trailing_dot, + file_request_intent=self.file_request_intent, + **kwargs, + ) + return ItemPaged(command, results_per_page=results_per_page, page_iterator_class=HandlesPaged) @distributed_trace def close_handle(self, handle: Union[str, Handle], **kwargs: Any) -> Dict[str, int]: @@ -638,20 +687,22 @@ def close_handle(self, handle: Union[str, Handle], **kwargs: Any) -> Dict[str, i handle_id = handle.id else: handle_id = handle - if handle_id == '*': + if handle_id == "*": raise ValueError("Handle ID '*' is not supported. Use 'close_all_handles' instead.") try: response = self._client.directory.force_close_handles( - handle_id, + handle_id=handle_id, marker=None, recursive=None, sharesnapshot=self.snapshot, cls=return_response_headers, - **kwargs + allow_trailing_dot=self.allow_trailing_dot, + file_request_intent=self.file_request_intent, + **kwargs, ) return { - 'closed_handles_count': response.get('number_of_handles_closed', 0), - 'failed_handles_count': response.get('number_of_handles_failed', 0) + "closed_handles_count": response.get("number_of_handles_closed", 0), + "failed_handles_count": response.get("number_of_handles_failed", 0), } except HttpResponseError as error: process_storage_error(error) @@ -675,7 +726,7 @@ def close_all_handles(self, recursive: bool = False, **kwargs: Any) -> Dict[str, and the number of handles failed to close in a dict. :rtype: dict[str, int] """ - timeout = kwargs.pop('timeout', None) + timeout = kwargs.pop("timeout", None) start_time = time.time() try_close = True @@ -685,26 +736,25 @@ def close_all_handles(self, recursive: bool = False, **kwargs: Any) -> Dict[str, while try_close: try: response = self._client.directory.force_close_handles( - handle_id='*', + handle_id="*", timeout=timeout, marker=continuation_token, recursive=recursive, sharesnapshot=self.snapshot, cls=return_response_headers, - **kwargs + allow_trailing_dot=self.allow_trailing_dot, + file_request_intent=self.file_request_intent, + **kwargs, ) except HttpResponseError as error: process_storage_error(error) - continuation_token = response.get('marker') + continuation_token = response.get("marker") try_close = bool(continuation_token) - total_closed += response.get('number_of_handles_closed', 0) - total_failed += response.get('number_of_handles_failed', 0) + total_closed += response.get("number_of_handles_closed", 0) + total_failed += response.get("number_of_handles_failed", 0) if timeout: timeout = max(0, timeout - (time.time() - start_time)) - return { - 'closed_handles_count': total_closed, - 'failed_handles_count': total_failed - } + return {"closed_handles_count": total_closed, "failed_handles_count": total_failed} @distributed_trace def get_directory_properties(self, **kwargs: Any) -> "DirectoryProperties": @@ -721,12 +771,19 @@ def get_directory_properties(self, **kwargs: Any) -> "DirectoryProperties": :returns: DirectoryProperties :rtype: ~azure.storage.fileshare.DirectoryProperties """ - timeout = kwargs.pop('timeout', None) + timeout = kwargs.pop("timeout", None) try: - response = cast("DirectoryProperties", self._client.directory.get_properties( - timeout=timeout, - cls=deserialize_directory_properties, - **kwargs)) + response = cast( + "DirectoryProperties", + self._client.directory.get_properties( + timeout=timeout, + cls=deserialize_directory_properties, + allow_trailing_dot=self.allow_trailing_dot, + file_request_intent=self.file_request_intent, + sharesnapshot=self.snapshot, + **kwargs, + ), + ) except HttpResponseError as error: process_storage_error(error) return response @@ -751,15 +808,21 @@ def set_directory_metadata(self, metadata: Dict[str, Any], **kwargs: Any) -> Dic :returns: Directory-updated property dict (Etag and last modified). :rtype: dict[str, Any] """ - timeout = kwargs.pop('timeout', None) - headers = kwargs.pop('headers', {}) + timeout = kwargs.pop("timeout", None) + headers = kwargs.pop("headers", {}) headers.update(add_metadata_headers(metadata)) try: - return cast(Dict[str, Any], self._client.directory.set_metadata( - timeout=timeout, - cls=return_response_headers, - headers=headers, - **kwargs)) + return cast( + Dict[str, Any], + self._client.directory.set_metadata( + timeout=timeout, + cls=return_response_headers, + headers=headers, + allow_trailing_dot=self.allow_trailing_dot, + file_request_intent=self.file_request_intent, + **kwargs, + ), + ) except HttpResponseError as error: process_storage_error(error) @@ -778,7 +841,12 @@ def exists(self, **kwargs: Any) -> bool: :rtype: bool """ try: - self._client.directory.get_properties(**kwargs) + self._client.directory.get_properties( + allow_trailing_dot=self.allow_trailing_dot, + file_request_intent=self.file_request_intent, + sharesnapshot=self.snapshot, + **kwargs, + ) return True except HttpResponseError as error: try: @@ -788,12 +856,13 @@ def exists(self, **kwargs: Any) -> bool: @distributed_trace def set_http_headers( - self, file_attributes: Optional[Union[str, "NTFSAttributes"]] = None, + self, + file_attributes: Optional[Union[str, "NTFSAttributes"]] = None, file_creation_time: Optional[Union[str, datetime]] = None, file_last_write_time: Optional[Union[str, datetime]] = None, file_permission: Optional[str] = None, permission_key: Optional[str] = None, - **kwargs: Any + **kwargs: Any, ) -> Dict[str, Any]: """Sets HTTP headers on the directory. @@ -843,20 +912,26 @@ def set_http_headers( :returns: File-updated property dict (Etag and last modified). :rtype: dict[str, Any] """ - timeout = kwargs.pop('timeout', None) + timeout = kwargs.pop("timeout", None) file_permission = _get_file_permission(file_permission, permission_key, None) - file_change_time = kwargs.pop('file_change_time', None) + file_change_time = kwargs.pop("file_change_time", None) try: - return cast(Dict[str, Any], self._client.directory.set_properties( - file_attributes=str(file_attributes) if file_attributes is not None else file_attributes, - file_creation_time=_datetime_to_str(file_creation_time), - file_last_write_time=_datetime_to_str(file_last_write_time), - file_change_time=_datetime_to_str(file_change_time), - file_permission=file_permission, - file_permission_key=permission_key, - timeout=timeout, - cls=return_response_headers, - **kwargs)) + return cast( + Dict[str, Any], + self._client.directory.set_properties( + file_attributes=str(file_attributes) if file_attributes is not None else file_attributes, + file_creation_time=_datetime_to_str(file_creation_time), + file_last_write_time=_datetime_to_str(file_last_write_time), + file_change_time=_datetime_to_str(file_change_time), + file_permission=file_permission, + file_permission_key=permission_key, + timeout=timeout, + cls=return_response_headers, + allow_trailing_dot=self.allow_trailing_dot, + file_request_intent=self.file_request_intent, + **kwargs, + ), + ) except HttpResponseError as error: process_storage_error(error) @@ -888,8 +963,8 @@ def create_subdirectory(self, directory_name: str, **kwargs: Any) -> "ShareDirec :dedent: 12 :caption: Create a subdirectory. """ - metadata = kwargs.pop('metadata', None) - timeout = kwargs.pop('timeout', None) + metadata = kwargs.pop("metadata", None) + timeout = kwargs.pop("timeout", None) subdir = self.get_subdirectory_client(directory_name) subdir.create_directory(metadata=metadata, timeout=timeout, **kwargs) return subdir @@ -917,16 +992,17 @@ def delete_subdirectory(self, directory_name: str, **kwargs: Any) -> None: :dedent: 12 :caption: Delete a subdirectory. """ - timeout = kwargs.pop('timeout', None) + timeout = kwargs.pop("timeout", None) subdir = self.get_subdirectory_client(directory_name) subdir.delete_directory(timeout=timeout, **kwargs) @distributed_trace def upload_file( - self, file_name: str, + self, + file_name: str, data: Union[bytes, str, Iterable[AnyStr], IO[AnyStr]], length: Optional[int] = None, - **kwargs: Any + **kwargs: Any, ) -> ShareFileClient: """Creates a new file in the directory and returns a ShareFileClient to interact with the file. @@ -979,10 +1055,7 @@ def upload_file( :caption: Upload a file to a directory. """ file_client = self.get_file_client(file_name) - file_client.upload_file( - data, - length=length, - **kwargs) + file_client.upload_file(data, length=length, **kwargs) return file_client @distributed_trace diff --git a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_directory_client_helpers.py b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_directory_client_helpers.py index cf37c24f02e1..4f05e151ffc9 100644 --- a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_directory_client_helpers.py +++ b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_directory_client_helpers.py @@ -4,10 +4,7 @@ # license information. # -------------------------------------------------------------------------- -from typing import ( - Any, Dict, Optional, Tuple, Union, - TYPE_CHECKING -) +from typing import Any, Dict, Optional, Tuple, Union, TYPE_CHECKING from urllib.parse import quote, unquote, urlparse from ._shared.base_client import parse_query @@ -18,11 +15,11 @@ def _parse_url(account_url: str, share_name: str) -> "ParseResult": try: - if not account_url.lower().startswith('http'): + if not account_url.lower().startswith("http"): account_url = "https://" + account_url except AttributeError as exc: raise ValueError("Account URL must be a string.") from exc - parsed_url = urlparse(account_url.rstrip('/')) + parsed_url = urlparse(account_url.rstrip("/")) if not share_name: raise ValueError("Please specify a share name.") if not parsed_url.netloc: @@ -32,29 +29,28 @@ def _parse_url(account_url: str, share_name: str) -> "ParseResult": def _format_url(scheme: str, hostname: str, share_name: Union[str, bytes], dir_path: str, query_str: str) -> str: if isinstance(share_name, str): - share_name = share_name.encode('UTF-8') + share_name = share_name.encode("UTF-8") directory_path = "" if dir_path: - directory_path = "/" + quote(dir_path, safe='~') + directory_path = "/" + quote(dir_path, safe="~") return f"{scheme}://{hostname}/{quote(share_name)}{directory_path}{query_str}" def _from_directory_url( - directory_url: str, - snapshot: Optional[Union[str, Dict[str, Any]]] = None + directory_url: str, snapshot: Optional[Union[str, Dict[str, Any]]] = None ) -> Tuple[str, str, str, Optional[Union[str, Dict[str, Any]]]]: try: - if not directory_url.lower().startswith('http'): + if not directory_url.lower().startswith("http"): directory_url = "https://" + directory_url except AttributeError as exc: raise ValueError("Directory URL must be a string.") from exc - parsed_url = urlparse(directory_url.rstrip('/')) + parsed_url = urlparse(directory_url.rstrip("/")) if not parsed_url.path and not parsed_url.netloc: raise ValueError(f"Invalid URL: {directory_url}") - account_url = parsed_url.netloc.rstrip('/') + "?" + parsed_url.query + account_url = parsed_url.netloc.rstrip("/") + "?" + parsed_url.query path_snapshot, _ = parse_query(parsed_url.query) - share_name, _, path_dir = parsed_url.path.lstrip('/').partition('/') + share_name, _, path_dir = parsed_url.path.lstrip("/").partition("/") share_name = unquote(share_name) snapshot = snapshot or path_snapshot diff --git a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_download.py b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_download.py index c087390eb09b..4f1f11300d54 100644 --- a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_download.py +++ b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_download.py @@ -8,10 +8,7 @@ import threading import warnings from io import BytesIO -from typing import ( - Any, Callable, Generator, IO, Iterator, Optional, Tuple, - TYPE_CHECKING -) +from typing import Any, Callable, Generator, IO, Iterator, Optional, Tuple, TYPE_CHECKING from azure.core.exceptions import HttpResponseError, ResourceModifiedError from azure.core.tracing.common import with_current_context @@ -38,7 +35,8 @@ def process_content(data: Any) -> bytes: class _ChunkDownloader: # pylint: disable=too-many-instance-attributes def __init__( - self, client: "FileOperations", + self, + client: "FileOperations", total_size: int, chunk_size: int, current_progress: int, @@ -49,7 +47,7 @@ def __init__( stream: Any = None, parallel: Optional[int] = None, progress_hook: Optional[Callable[[int, Optional[int]], None]] = None, - **kwargs: Any + **kwargs: Any, ) -> None: self.client = client self.etag = etag @@ -121,9 +119,7 @@ def _write_to_stream(self, chunk_data: bytes, chunk_start: int) -> None: def _download_chunk(self, chunk_start: int, chunk_end: int) -> bytes: range_header, range_validation = validate_and_format_range_headers( - chunk_start, - chunk_end, - check_content_md5=is_md5_validation(self.validate_content) + chunk_start, chunk_end, check_content_md5=is_md5_validation(self.validate_content) ) try: @@ -134,7 +130,7 @@ def _download_chunk(self, chunk_start: int, chunk_end: int) -> bytes: validate_content=self.validate_content, data_stream_total=self.total_size, download_stream_current=self.progress_total, - **self.request_options + **self.request_options, ) if response.properties.etag != self.etag: raise ResourceModifiedError(message="The file has been modified while downloading.") @@ -195,7 +191,7 @@ def __next__(self) -> bytes: def _get_chunk_data(self) -> bytes: chunk_data = self._current_content[: self._chunk_size] - self._current_content = self._current_content[self._chunk_size:] + self._current_content = self._current_content[self._chunk_size :] return chunk_data @@ -216,7 +212,8 @@ class StorageStreamDownloader: # pylint: disable=too-many-instance-attributes otherwise the total size of the file.""" def __init__( - self, client: "FileOperations" = None, # type: ignore [assignment] + self, + client: "FileOperations" = None, # type: ignore [assignment] config: "StorageConfiguration" = None, # type: ignore [assignment] start_range: Optional[int] = None, end_range: Optional[int] = None, @@ -226,7 +223,7 @@ def __init__( path: str = None, # type: ignore [assignment] share: str = None, # type: ignore [assignment] encoding: Optional[str] = None, - **kwargs: Any + **kwargs: Any, ) -> None: self.name = name self.path = path @@ -240,7 +237,7 @@ def __init__( self._max_concurrency = max_concurrency if max_concurrency is not None else DEFAULT_MAX_CONCURRENCY self._encoding = encoding self._validate_content = validate_content - self._progress_hook = kwargs.pop('progress_hook', None) + self._progress_hook = kwargs.pop("progress_hook", None) self._request_options = kwargs self._location_mode = None self._download_complete = False @@ -298,7 +295,7 @@ def _initial_request(self): self._initial_range[1], start_range_required=False, end_range_required=False, - check_content_md5=is_md5_validation(self._validate_content) + check_content_md5=is_md5_validation(self._validate_content), ) try: @@ -308,7 +305,7 @@ def _initial_request(self): validate_content=self._validate_content, data_stream_total=None, download_stream_current=0, - **self._request_options + **self._request_options, ) # Check the location we read from to ensure we use the same one @@ -339,7 +336,7 @@ def _initial_request(self): validate_content=self._validate_content, data_stream_total=0, download_stream_current=0, - **self._request_options + **self._request_options, ) except HttpResponseError as e: process_storage_error(e) @@ -383,13 +380,14 @@ def chunks(self) -> Iterator[bytes]: validate_content=self._validate_content, use_location=self._location_mode, etag=self._etag, - **self._request_options + **self._request_options, ) return _ChunkIterator( size=self.size, content=self._current_content, downloader=iter_downloader, - chunk_size=self._config.max_chunk_get_size) + chunk_size=self._config.max_chunk_get_size, + ) def readall(self) -> bytes: """Download the contents of this file. @@ -417,10 +415,7 @@ def content_as_bytes(self, max_concurrency=None): :return: The contents of the file as bytes. :rtype: bytes """ - warnings.warn( - "content_as_bytes is deprecated, use readall instead", - DeprecationWarning - ) + warnings.warn("content_as_bytes is deprecated, use readall instead", DeprecationWarning) self._max_concurrency = max_concurrency if max_concurrency is not None else DEFAULT_MAX_CONCURRENCY return self.readall() @@ -438,10 +433,7 @@ def content_as_text(self, max_concurrency=None, encoding="UTF-8"): :return: The contents of the file as a str. :rtype: str """ - warnings.warn( - "content_as_text is deprecated, use readall instead", - DeprecationWarning - ) + warnings.warn("content_as_text is deprecated, use readall instead", DeprecationWarning) self._max_concurrency = max_concurrency if max_concurrency is not None else DEFAULT_MAX_CONCURRENCY self._encoding = encoding return self.readall() @@ -494,15 +486,13 @@ def readinto(self, stream: IO[bytes]) -> int: use_location=self._location_mode, progress_hook=self._progress_hook, etag=self._etag, - **self._request_options + **self._request_options, ) if parallel: import concurrent.futures + with concurrent.futures.ThreadPoolExecutor(self._max_concurrency) as executor: - list(executor.map( - with_current_context(downloader.process_chunk), - downloader.get_chunk_offsets() - )) + list(executor.map(with_current_context(downloader.process_chunk), downloader.get_chunk_offsets())) else: for chunk in downloader.get_chunk_offsets(): downloader.process_chunk(chunk) @@ -522,10 +512,7 @@ def download_to_stream(self, stream, max_concurrency=None): :returns: The properties of the downloaded file. :rtype: Any """ - warnings.warn( - "download_to_stream is deprecated, use readinto instead", - DeprecationWarning - ) + warnings.warn("download_to_stream is deprecated, use readinto instead", DeprecationWarning) self._max_concurrency = max_concurrency if max_concurrency is not None else DEFAULT_MAX_CONCURRENCY self.readinto(stream) return self.properties diff --git a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_file_client.py b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_file_client.py index 2dc032a9eb43..f41c63a409a0 100644 --- a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_file_client.py +++ b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_file_client.py @@ -1,3 +1,4 @@ +# pylint: disable=too-many-lines # ------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for @@ -9,10 +10,7 @@ import time from datetime import datetime from io import BytesIO -from typing import ( - Any, AnyStr, Callable, cast, Dict, IO, Iterable, List, Literal, Optional, Tuple, Union, - TYPE_CHECKING -) +from typing import Any, AnyStr, Callable, cast, Dict, IO, Iterable, List, Literal, Optional, Tuple, Union, TYPE_CHECKING from typing_extensions import Self from azure.core.exceptions import HttpResponseError, ResourceNotFoundError @@ -25,20 +23,19 @@ _from_file_url, _get_ranges_options, _parse_url, - _upload_range_from_url_options + _upload_range_from_url_options, ) -from ._generated import AzureFileStorage -from ._generated.models import FileHTTPHeaders +from ._generated import FileClient as AzureFileStorage from ._lease import ShareLeaseClient from ._models import FileProperties, Handle, HandlesPaged -from ._parser import _datetime_to_str, _get_file_permission, _parse_snapshot +from ._parser import _datetime_to_str, _get_file_permission, _parse_snapshot, _strip_snapshot_from_url from ._serialize import ( get_access_conditions, get_api_version, get_dest_access_conditions, get_rename_smb_properties, get_smb_properties, - get_source_access_conditions + get_source_access_conditions, ) from ._shared.base_client import StorageAccountHostsMixin, parse_connection_str, parse_query from ._shared.constants import DEFAULT_MAX_CONCURRENCY @@ -69,7 +66,7 @@ def _upload_file_helper( file_permission: Optional[str] = None, file_permission_key: Optional[str] = None, progress_hook: Optional[Callable[[int, Optional[int]], None]] = None, - **kwargs: Any + **kwargs: Any, ) -> Dict[str, Any]: try: if size is None or size < 0: @@ -84,7 +81,7 @@ def _upload_file_helper( file_last_write_time=file_last_write_time, file_permission=file_permission, permission_key=file_permission_key, - **kwargs + **kwargs, ) if size == 0: return response @@ -99,9 +96,9 @@ def _upload_file_helper( validate_content=validate_content, progress_hook=progress_hook, timeout=timeout, - **kwargs + **kwargs, ) - return cast(Dict[str, Any], sorted(responses, key=lambda r: r.get('last_modified'))[-1]) + return cast(Dict[str, Any], sorted(responses, key=lambda r: r.get("last_modified"))[-1]) except HttpResponseError as error: process_storage_error(error) @@ -162,44 +159,43 @@ class ShareFileClient(StorageAccountHostsMixin): authentication. Only has an effect when credential is of type TokenCredential. The value could be https://storage.azure.com/ (default) or https://.file.core.windows.net. """ + def __init__( - self, account_url: str, + self, + account_url: str, share_name: str, file_path: str, snapshot: Optional[Union[str, Dict[str, Any]]] = None, - credential: Optional[Union[str, Dict[str, str], "AzureNamedKeyCredential", "AzureSasCredential", "TokenCredential"]] = None, # pylint: disable=line-too-long + credential: Optional[ + Union[str, Dict[str, str], "AzureNamedKeyCredential", "AzureSasCredential", "TokenCredential"] + ] = None, # pylint: disable=line-too-long *, - token_intent: Optional[Literal['backup']] = None, - **kwargs: Any + token_intent: Optional[Literal["backup"]] = None, + **kwargs: Any, ) -> None: - if hasattr(credential, 'get_token') and not token_intent: + if hasattr(credential, "get_token") and not token_intent: raise ValueError("'token_intent' keyword is required when 'credential' is an TokenCredential.") parsed_url = _parse_url(account_url, share_name, file_path) path_snapshot, sas_token = parse_query(parsed_url.query) if not sas_token and not credential: raise ValueError( - 'You need to provide either an account shared key or SAS token when creating a storage service.') + "You need to provide either an account shared key or SAS token when creating a storage service." + ) self.snapshot = _parse_snapshot(snapshot, path_snapshot) self.share_name = share_name - self.file_path = file_path.split('/') + self.file_path = file_path.split("/") self.file_name = self.file_path[-1] self.directory_path = "/".join(self.file_path[:-1]) - self._query_str, credential = self._format_query_string( - sas_token, credential, share_snapshot=self.snapshot) - super(ShareFileClient, self).__init__( - parsed_url, service='file-share', credential=credential, **kwargs) - self.allow_trailing_dot = kwargs.pop('allow_trailing_dot', None) - self.allow_source_trailing_dot = kwargs.pop('allow_source_trailing_dot', None) + self._query_str, credential = self._format_query_string(sas_token, credential, share_snapshot=self.snapshot) + super(ShareFileClient, self).__init__(parsed_url, service="file-share", credential=credential, **kwargs) + self.allow_trailing_dot = kwargs.pop("allow_trailing_dot", None) + self.allow_source_trailing_dot = kwargs.pop("allow_source_trailing_dot", None) self.file_request_intent = token_intent self._client = AzureFileStorage( + url=_strip_snapshot_from_url(self.url), version=get_api_version(kwargs), - url=self.url, - base_url=self.url, pipeline=self._pipeline, - allow_trailing_dot=self.allow_trailing_dot, - allow_source_trailing_dot=self.allow_source_trailing_dot, - file_request_intent=self.file_request_intent ) def __enter__(self) -> Self: @@ -220,10 +216,13 @@ def close(self) -> None: @classmethod def from_file_url( - cls, file_url: str, + cls, + file_url: str, snapshot: Optional[Union[str, Dict[str, Any]]] = None, - credential: Optional[Union[str, Dict[str, str], "AzureNamedKeyCredential", "AzureSasCredential", "TokenCredential"]] = None, # pylint: disable=line-too-long - **kwargs: Any + credential: Optional[ + Union[str, Dict[str, str], "AzureNamedKeyCredential", "AzureSasCredential", "TokenCredential"] + ] = None, # pylint: disable=line-too-long + **kwargs: Any, ) -> Self: """A client to interact with a specific file, although that file may not yet exist. @@ -259,12 +258,15 @@ def _format_url(self, hostname: str): @classmethod def from_connection_string( - cls, conn_str: str, + cls, + conn_str: str, share_name: str, file_path: str, snapshot: Optional[Union[str, Dict[str, Any]]] = None, - credential: Optional[Union[str, Dict[str, str], "AzureNamedKeyCredential", "AzureSasCredential", "TokenCredential"]] = None, # pylint: disable=line-too-long - **kwargs: Any + credential: Optional[ + Union[str, Dict[str, str], "AzureNamedKeyCredential", "AzureSasCredential", "TokenCredential"] + ] = None, # pylint: disable=line-too-long + **kwargs: Any, ) -> Self: """Create ShareFileClient from a Connection String. @@ -306,11 +308,12 @@ def from_connection_string( :dedent: 12 :caption: Creates the file client with connection string. """ - account_url, secondary, credential = parse_connection_str(conn_str, credential, 'file') - if 'secondary_hostname' not in kwargs: - kwargs['secondary_hostname'] = secondary + account_url, secondary, credential = parse_connection_str(conn_str, credential, "file") + if "secondary_hostname" not in kwargs: + kwargs["secondary_hostname"] = secondary return cls( - account_url, share_name=share_name, file_path=file_path, snapshot=snapshot, credential=credential, **kwargs) + account_url, share_name=share_name, file_path=file_path, snapshot=snapshot, credential=credential, **kwargs + ) @distributed_trace def acquire_lease(self, lease_id: Optional[str] = None, **kwargs: Any) -> ShareLeaseClient: @@ -341,7 +344,7 @@ def acquire_lease(self, lease_id: Optional[str] = None, **kwargs: Any) -> ShareL :dedent: 12 :caption: Acquiring a lease on a file. """ - kwargs['lease_duration'] = -1 + kwargs["lease_duration"] = -1 lease = ShareLeaseClient(self, lease_id=lease_id) lease.acquire(**kwargs) return lease @@ -361,7 +364,12 @@ def exists(self, **kwargs: Any) -> bool: :rtype: bool """ try: - self._client.file.get_properties(**kwargs) + self._client.file.get_properties( + allow_trailing_dot=self.allow_trailing_dot, + file_request_intent=self.file_request_intent, + sharesnapshot=self.snapshot, + **kwargs, + ) return True except HttpResponseError as error: try: @@ -371,13 +379,14 @@ def exists(self, **kwargs: Any) -> bool: @distributed_trace def create_file( - self, size: int, + self, + size: int, file_attributes: Optional[Union[str, "NTFSAttributes"]] = None, file_creation_time: Optional[Union[str, datetime]] = None, file_last_write_time: Optional[Union[str, datetime]] = None, file_permission: Optional[str] = None, permission_key: Optional[str] = None, - **kwargs: Any + **kwargs: Any, ) -> Dict[str, Any]: """Creates a new file. @@ -473,61 +482,65 @@ def create_file( :dedent: 12 :caption: Create a file. """ - access_conditions = get_access_conditions(kwargs.pop('lease', None)) - content_settings = kwargs.pop('content_settings', None) - metadata = kwargs.pop('metadata', None) - timeout = kwargs.pop('timeout', None) - validate_content = parse_validation_option( - kwargs.pop('validate_content', None), - force_structured_message=True - ) - headers = kwargs.pop('headers', {}) + access_conditions = get_access_conditions(kwargs.pop("lease", None)) + content_settings = kwargs.pop("content_settings", None) + metadata = kwargs.pop("metadata", None) + timeout = kwargs.pop("timeout", None) + validate_content = parse_validation_option(kwargs.pop("validate_content", None), force_structured_message=True) + headers = kwargs.pop("headers", {}) headers.update(add_metadata_headers(metadata)) - data = kwargs.pop('data', None) - file_http_headers = None + data = kwargs.pop("data", None) + file_http_headers = {} if content_settings: - file_http_headers = FileHTTPHeaders( - file_cache_control=content_settings.cache_control, - file_content_type=content_settings.content_type, - file_content_md5=bytearray(content_settings.content_md5) if content_settings.content_md5 else None, - file_content_encoding=content_settings.content_encoding, - file_content_language=content_settings.content_language, - file_content_disposition=content_settings.content_disposition - ) + file_http_headers = { + "file_cache_control": content_settings.cache_control, + "file_content_type": content_settings.content_type, + "file_content_md5": bytearray(content_settings.content_md5) if content_settings.content_md5 else None, + "file_content_encoding": content_settings.content_encoding, + "file_content_language": content_settings.content_language, + "file_content_disposition": content_settings.content_disposition, + } file_permission = _get_file_permission(file_permission, permission_key, None) - file_change_time = kwargs.pop('file_change_time', None) + file_change_time = kwargs.pop("file_change_time", None) try: - return cast(Dict[str, Any], self._client.file.create( - file_content_length=size, - metadata=metadata, - file_attributes=str(file_attributes) if file_attributes is not None else file_attributes, - file_creation_time=_datetime_to_str(file_creation_time), - file_last_write_time=_datetime_to_str(file_last_write_time), - file_change_time=_datetime_to_str(file_change_time), - file_permission=file_permission, - file_permission_key=permission_key, - file_http_headers=file_http_headers, - optionalbody=data, - validate_content=validate_content, - content_length=len(data) if data is not None else None, - lease_access_conditions=access_conditions, - headers=headers, - timeout=timeout, - cls=return_response_headers, - **kwargs)) + return cast( + Dict[str, Any], + self._client.file.create( + file_content_length=size, + metadata=metadata, + file_attributes=str(file_attributes) if file_attributes is not None else file_attributes, + file_creation_time=_datetime_to_str(file_creation_time), + file_last_write_time=_datetime_to_str(file_last_write_time), + file_change_time=_datetime_to_str(file_change_time), + file_permission=file_permission, + file_permission_key=permission_key, + **file_http_headers, + optional_body=data, + validate_content=validate_content, + content_length=len(data) if data is not None else None, + lease_id=access_conditions, + headers=headers, + timeout=timeout, + cls=return_response_headers, + allow_trailing_dot=self.allow_trailing_dot, + file_request_intent=self.file_request_intent, + **kwargs, + ), + ) except HttpResponseError as error: process_storage_error(error) @distributed_trace def upload_file( - self, data: Union[bytes, str, Iterable[AnyStr], IO[bytes]], + self, + data: Union[bytes, str, Iterable[AnyStr], IO[bytes]], length: Optional[int] = None, file_attributes: Optional[Union[str, "NTFSAttributes"]] = None, file_creation_time: Optional[Union[str, datetime]] = None, file_last_write_time: Optional[Union[str, datetime]] = None, file_permission: Optional[str] = None, permission_key: Optional[str] = None, - **kwargs + **kwargs, ) -> Dict[str, Any]: """Uploads a new file. @@ -614,18 +627,15 @@ def upload_file( :dedent: 12 :caption: Upload a file. """ - metadata = kwargs.pop('metadata', None) - content_settings = kwargs.pop('content_settings', None) - max_concurrency = kwargs.pop('max_concurrency', None) + metadata = kwargs.pop("metadata", None) + content_settings = kwargs.pop("content_settings", None) + max_concurrency = kwargs.pop("max_concurrency", None) if max_concurrency is None: max_concurrency = DEFAULT_MAX_CONCURRENCY - validate_content = parse_validation_option( - kwargs.pop('validate_content', None), - force_structured_message=True - ) - progress_hook = kwargs.pop('progress_hook', None) - timeout = kwargs.pop('timeout', None) - encoding = kwargs.pop('encoding', 'UTF-8') + validate_content = parse_validation_option(kwargs.pop("validate_content", None), force_structured_message=True) + progress_hook = kwargs.pop("progress_hook", None) + timeout = kwargs.pop("timeout", None) + encoding = kwargs.pop("encoding", "UTF-8") if isinstance(data, str): data = data.encode(encoding) @@ -637,9 +647,9 @@ def upload_file( stream: Optional[Any] = None if isinstance(data, bytes): stream = BytesIO(data) - elif hasattr(data, 'read'): + elif hasattr(data, "read"): stream = data - elif hasattr(data, '__iter__'): + elif hasattr(data, "__iter__"): stream = IterStreamer(data, encoding=encoding) else: raise TypeError(f"Unsupported data type: {type(data)}") @@ -659,7 +669,8 @@ def upload_file( file_permission=file_permission, file_permission_key=permission_key, progress_hook=progress_hook, - **kwargs) + **kwargs, + ) @distributed_trace def start_copy_from_url(self, source_url: str, **kwargs: Any) -> Dict[str, Any]: @@ -801,31 +812,38 @@ def start_copy_from_url(self, source_url: str, **kwargs: Any) -> Dict[str, Any]: :dedent: 12 :caption: Copy a file from a URL """ - metadata = kwargs.pop('metadata', None) - access_conditions = get_access_conditions(kwargs.pop('lease', None)) - timeout = kwargs.pop('timeout', None) - owner = kwargs.pop('owner', None) - group = kwargs.pop('group', None) - file_mode = kwargs.pop('file_mode', None) - file_mode_copy_mode = kwargs.pop('file_mode_copy_mode', None) - file_owner_copy_mode = kwargs.pop('owner_copy_mode', None) - headers = kwargs.pop('headers', {}) + metadata = kwargs.pop("metadata", None) + access_conditions = get_access_conditions(kwargs.pop("lease", None)) + timeout = kwargs.pop("timeout", None) + owner = kwargs.pop("owner", None) + group = kwargs.pop("group", None) + file_mode = kwargs.pop("file_mode", None) + file_mode_copy_mode = kwargs.pop("file_mode_copy_mode", None) + file_owner_copy_mode = kwargs.pop("owner_copy_mode", None) + headers = kwargs.pop("headers", {}) headers.update(add_metadata_headers(metadata)) kwargs.update(get_smb_properties(kwargs)) try: - return cast(Dict[str, Any], self._client.file.start_copy( - source_url, - metadata=metadata, - lease_access_conditions=access_conditions, - owner=owner, - group=group, - file_mode=file_mode, - file_mode_copy_mode=file_mode_copy_mode, - file_owner_copy_mode=file_owner_copy_mode, - headers=headers, - cls=return_response_headers, - timeout=timeout, - **kwargs)) + return cast( + Dict[str, Any], + self._client.file.start_copy( + copy_source=source_url, + metadata=metadata, + lease_id=access_conditions, + owner=owner, + group=group, + file_mode=file_mode, + file_mode_copy_mode=file_mode_copy_mode, + file_owner_copy_mode=file_owner_copy_mode, + headers=headers, + cls=return_response_headers, + timeout=timeout, + allow_trailing_dot=self.allow_trailing_dot, + allow_source_trailing_dot=self.allow_source_trailing_dot, + file_request_intent=self.file_request_intent, + **kwargs, + ), + ) except HttpResponseError as error: process_storage_error(error) @@ -855,25 +873,28 @@ def abort_copy(self, copy_id: Union[str, FileProperties], **kwargs: Any) -> None #other-client--per-operation-configuration>`__. :rtype: None """ - access_conditions = get_access_conditions(kwargs.pop('lease', None)) - timeout = kwargs.pop('timeout', None) + access_conditions = get_access_conditions(kwargs.pop("lease", None)) + timeout = kwargs.pop("timeout", None) if isinstance(copy_id, FileProperties): copy_id = copy_id.copy.id elif isinstance(copy_id, Dict): - copy_id = copy_id['copy_id'] + copy_id = copy_id["copy_id"] try: - self._client.file.abort_copy(copy_id=copy_id, - lease_access_conditions=access_conditions, - timeout=timeout, **kwargs) + self._client.file.abort_copy( + copyid=copy_id, + lease_id=access_conditions, + timeout=timeout, + allow_trailing_dot=self.allow_trailing_dot, + file_request_intent=self.file_request_intent, + **kwargs, + ) except HttpResponseError as error: process_storage_error(error) @distributed_trace def download_file( - self, offset: Optional[int] = None, - length: Optional[int] = None, - **kwargs: Any + self, offset: Optional[int] = None, length: Optional[int] = None, **kwargs: Any ) -> StorageStreamDownloader: """Downloads a file to the StorageStreamDownloader. The readall() method must be used to read all the content or readinto() must be used to download the file into @@ -932,8 +953,14 @@ def download_file( raise ValueError("Offset value must not be None if length is set.") range_end = offset + length - 1 # Service actually uses an end-range inclusive index - access_conditions = get_access_conditions(kwargs.pop('lease', None)) - validate_content = parse_validation_option(kwargs.pop('validate_content', None)) + access_conditions = get_access_conditions(kwargs.pop("lease", None)) + + # download doesn't accept sharesnapshot as a kwarg, inject via params + if self.snapshot: + params = kwargs.pop("params", {}) or {} + params["sharesnapshot"] = self.snapshot + kwargs["params"] = params + validate_content = parse_validation_option(kwargs.pop("validate_content", None)) return StorageStreamDownloader( client=self._client.file, @@ -942,11 +969,14 @@ def download_file( end_range=range_end, validate_content=validate_content, name=self.file_name, - path='/'.join(self.file_path), + path="/".join(self.file_path), share=self.share_name, - lease_access_conditions=access_conditions, + lease_id=access_conditions, cls=deserialize_file_stream, - **kwargs) + allow_trailing_dot=self.allow_trailing_dot, + file_request_intent=self.file_request_intent, + **kwargs, + ) @distributed_trace def delete_file(self, **kwargs: Any) -> None: @@ -977,10 +1007,16 @@ def delete_file(self, **kwargs: Any) -> None: :dedent: 12 :caption: Delete a file. """ - access_conditions = get_access_conditions(kwargs.pop('lease', None)) - timeout = kwargs.pop('timeout', None) + access_conditions = get_access_conditions(kwargs.pop("lease", None)) + timeout = kwargs.pop("timeout", None) try: - self._client.file.delete(lease_access_conditions=access_conditions, timeout=timeout, **kwargs) + self._client.file.delete( + lease_id=access_conditions, + timeout=timeout, + allow_trailing_dot=self.allow_trailing_dot, + file_request_intent=self.file_request_intent, + **kwargs, + ) except HttpResponseError as error: process_storage_error(error) @@ -1059,50 +1095,56 @@ def rename_file(self, new_name: str, **kwargs: Any) -> "ShareFileClient": if not new_name: raise ValueError("Please specify a new file name.") - new_name = new_name.strip('/') - new_path_and_query = new_name.split('?') + new_name = new_name.strip("/") + new_path_and_query = new_name.split("?") new_file_path = new_path_and_query[0] if len(new_path_and_query) == 2: - new_file_sas = new_path_and_query[1] or self._query_str.strip('?') + new_file_sas = new_path_and_query[1] or self._query_str.strip("?") else: - new_file_sas = self._query_str.strip('?') + new_file_sas = self._query_str.strip("?") new_file_client = ShareFileClient( - f'{self.scheme}://{self.primary_hostname}', self.share_name, new_file_path, - credential=new_file_sas or self.credential, api_version=self.api_version, - _hosts=self._hosts, _configuration=self._config, _pipeline=self._pipeline, - _location_mode=self._location_mode, allow_trailing_dot=self.allow_trailing_dot, - allow_source_trailing_dot=self.allow_source_trailing_dot, token_intent=self.file_request_intent + f"{self.scheme}://{self.primary_hostname}", + self.share_name, + new_file_path, + credential=new_file_sas or self.credential, + api_version=self.api_version, + _hosts=self._hosts, + _configuration=self._config, + _pipeline=self._pipeline, + _location_mode=self._location_mode, + allow_trailing_dot=self.allow_trailing_dot, + allow_source_trailing_dot=self.allow_source_trailing_dot, + token_intent=self.file_request_intent, ) kwargs.update(get_rename_smb_properties(kwargs)) - file_http_headers = None - content_type = kwargs.pop('content_type', None) - if content_type: - file_http_headers = FileHTTPHeaders( - file_content_type=content_type - ) + file_content_type = kwargs.pop("content_type", None) - timeout = kwargs.pop('timeout', None) - overwrite = kwargs.pop('overwrite', None) - metadata = kwargs.pop('metadata', None) - headers = kwargs.pop('headers', {}) + timeout = kwargs.pop("timeout", None) + overwrite = kwargs.pop("overwrite", None) + metadata = kwargs.pop("metadata", None) + headers = kwargs.pop("headers", {}) headers.update(add_metadata_headers(metadata)) - source_access_conditions = get_source_access_conditions(kwargs.pop('source_lease', None)) - dest_access_conditions = get_dest_access_conditions(kwargs.pop('destination_lease', None)) + source_access_conditions = get_source_access_conditions(kwargs.pop("source_lease", None)) + dest_access_conditions = get_dest_access_conditions(kwargs.pop("destination_lease", None)) try: new_file_client._client.file.rename( # pylint: disable=protected-access - self.url, + rename_source=self.url, timeout=timeout, replace_if_exists=overwrite, - file_http_headers=file_http_headers, - source_lease_access_conditions=source_access_conditions, - destination_lease_access_conditions=dest_access_conditions, + file_content_type=file_content_type, + source_lease_id=source_access_conditions, + destination_lease_id=dest_access_conditions, headers=headers, - **kwargs) + allow_trailing_dot=self.allow_trailing_dot, + allow_source_trailing_dot=self.allow_source_trailing_dot, + file_request_intent=self.file_request_intent, + **kwargs, + ) return new_file_client except HttpResponseError as error: @@ -1129,32 +1171,39 @@ def get_file_properties(self, **kwargs: Any) -> FileProperties: :returns: FileProperties :rtype: ~azure.storage.fileshare.FileProperties """ - access_conditions = get_access_conditions(kwargs.pop('lease', None)) - timeout = kwargs.pop('timeout', None) + access_conditions = get_access_conditions(kwargs.pop("lease", None)) + timeout = kwargs.pop("timeout", None) try: - file_props = cast(FileProperties, self._client.file.get_properties( - sharesnapshot=self.snapshot, - lease_access_conditions=access_conditions, - timeout=timeout, - cls=deserialize_file_properties, - **kwargs)) + file_props = cast( + FileProperties, + self._client.file.get_properties( + sharesnapshot=self.snapshot, + lease_id=access_conditions, + timeout=timeout, + cls=deserialize_file_properties, + allow_trailing_dot=self.allow_trailing_dot, + file_request_intent=self.file_request_intent, + **kwargs, + ), + ) except HttpResponseError as error: process_storage_error(error) file_props.name = self.file_name file_props.share = self.share_name file_props.snapshot = self.snapshot - file_props.path = '/'.join(self.file_path) + file_props.path = "/".join(self.file_path) return file_props @distributed_trace def set_http_headers( - self, content_settings: "ContentSettings", + self, + content_settings: "ContentSettings", file_attributes: Optional[Union[str, "NTFSAttributes"]] = None, file_creation_time: Optional[Union[str, datetime]] = None, file_last_write_time: Optional[Union[str, datetime]] = None, file_permission: Optional[str] = None, permission_key: Optional[str] = None, - **kwargs: Any + **kwargs: Any, ) -> Dict[str, Any]: """Sets HTTP headers on the file. @@ -1216,33 +1265,39 @@ def set_http_headers( :returns: File-updated property dict (Etag and last modified). :rtype: dict[str, Any] """ - access_conditions = get_access_conditions(kwargs.pop('lease', None)) - timeout = kwargs.pop('timeout', None) - file_content_length = kwargs.pop('size', None) - file_http_headers = FileHTTPHeaders( - file_cache_control=content_settings.cache_control, - file_content_type=content_settings.content_type, - file_content_md5=bytearray(content_settings.content_md5) if content_settings.content_md5 else None, - file_content_encoding=content_settings.content_encoding, - file_content_language=content_settings.content_language, - file_content_disposition=content_settings.content_disposition - ) + access_conditions = get_access_conditions(kwargs.pop("lease", None)) + timeout = kwargs.pop("timeout", None) + file_content_length = kwargs.pop("size", None) + file_http_headers = { + "file_cache_control": content_settings.cache_control, + "file_content_type": content_settings.content_type, + "file_content_md5": bytearray(content_settings.content_md5) if content_settings.content_md5 else None, + "file_content_encoding": content_settings.content_encoding, + "file_content_language": content_settings.content_language, + "file_content_disposition": content_settings.content_disposition, + } file_permission = _get_file_permission(file_permission, permission_key, None) - file_change_time = kwargs.pop('file_change_time', None) + file_change_time = kwargs.pop("file_change_time", None) try: - return cast(Dict[str, Any], self._client.file.set_http_headers( - file_content_length=file_content_length, - file_http_headers=file_http_headers, - file_attributes=str(file_attributes) if file_attributes is not None else file_attributes, - file_creation_time=_datetime_to_str(file_creation_time), - file_last_write_time=_datetime_to_str(file_last_write_time), - file_change_time=_datetime_to_str(file_change_time), - file_permission=file_permission, - file_permission_key=permission_key, - lease_access_conditions=access_conditions, - timeout=timeout, - cls=return_response_headers, - **kwargs)) + return cast( + Dict[str, Any], + self._client.file.set_http_headers( + file_content_length=file_content_length, + **file_http_headers, + file_attributes=str(file_attributes) if file_attributes is not None else file_attributes, + file_creation_time=_datetime_to_str(file_creation_time), + file_last_write_time=_datetime_to_str(file_last_write_time), + file_change_time=_datetime_to_str(file_change_time), + file_permission=file_permission, + file_permission_key=permission_key, + lease_id=access_conditions, + timeout=timeout, + cls=return_response_headers, + allow_trailing_dot=self.allow_trailing_dot, + file_request_intent=self.file_request_intent, + **kwargs, + ), + ) except HttpResponseError as error: process_storage_error(error) @@ -1274,28 +1329,29 @@ def set_file_metadata(self, metadata: Optional[Dict[str, Any]] = None, **kwargs: :returns: File-updated property dict (Etag and last modified). :rtype: dict[str, Any] """ - access_conditions = get_access_conditions(kwargs.pop('lease', None)) - timeout = kwargs.pop('timeout', None) - headers = kwargs.pop('headers', {}) + access_conditions = get_access_conditions(kwargs.pop("lease", None)) + timeout = kwargs.pop("timeout", None) + headers = kwargs.pop("headers", {}) headers.update(add_metadata_headers(metadata)) try: - return cast(Dict[str, Any], self._client.file.set_metadata( - timeout=timeout, - cls=return_response_headers, - headers=headers, - metadata=metadata, - lease_access_conditions=access_conditions, - **kwargs)) + return cast( + Dict[str, Any], + self._client.file.set_metadata( + timeout=timeout, + cls=return_response_headers, + headers=headers, + metadata=metadata, + lease_id=access_conditions, + allow_trailing_dot=self.allow_trailing_dot, + file_request_intent=self.file_request_intent, + **kwargs, + ), + ) except HttpResponseError as error: process_storage_error(error) @distributed_trace - def upload_range( - self, data: bytes, - offset: int, - length: int, - **kwargs: Any - ) -> Dict[str, Any]: + def upload_range(self, data: bytes, offset: int, length: int, **kwargs: Any) -> Dict[str, Any]: """Upload a range of bytes to a file. :param bytes data: @@ -1339,40 +1395,40 @@ def upload_range( :returns: File-updated property dict (Etag and last modified). :rtype: Dict[str, Any] """ - validate_content = parse_validation_option( - kwargs.pop('validate_content', None), - force_structured_message=True - ) - timeout = kwargs.pop('timeout', None) - encoding = kwargs.pop('encoding', 'UTF-8') - file_last_write_mode = kwargs.pop('file_last_write_mode', None) + validate_content = parse_validation_option(kwargs.pop("validate_content", None), force_structured_message=True) + timeout = kwargs.pop("timeout", None) + encoding = kwargs.pop("encoding", "UTF-8") + file_last_write_mode = kwargs.pop("file_last_write_mode", None) if isinstance(data, str): data = data.encode(encoding) end_range = offset + length - 1 # Reformat to an inclusive range index - content_range = f'bytes={offset}-{end_range}' - access_conditions = get_access_conditions(kwargs.pop('lease', None)) + content_range = f"bytes={offset}-{end_range}" + access_conditions = get_access_conditions(kwargs.pop("lease", None)) try: - return cast(Dict[str, Any], self._client.file.upload_range( - range=content_range, - content_length=length, - optionalbody=data, - timeout=timeout, - validate_content=validate_content, - file_last_written_mode=file_last_write_mode, - lease_access_conditions=access_conditions, - cls=return_response_headers, - **kwargs)) + return cast( + Dict[str, Any], + self._client.file.upload_range( + range=content_range, + file_range_write="update", + content_length=length, + optional_body=data, + timeout=timeout, + validate_content=validate_content, + file_last_written_mode=file_last_write_mode, + lease_id=access_conditions, + cls=return_response_headers, + allow_trailing_dot=self.allow_trailing_dot, + file_request_intent=self.file_request_intent, + **kwargs, + ), + ) except HttpResponseError as error: process_storage_error(error) @distributed_trace def upload_range_from_url( - self, source_url: str, - offset: int, - length: int, - source_offset: int, - **kwargs: Any + self, source_url: str, offset: int, length: int, source_offset: int, **kwargs: Any ) -> Dict[str, Any]: """ Writes the bytes from one Azure File endpoint into the specified range of another Azure File endpoint. @@ -1442,12 +1498,11 @@ def upload_range_from_url( :rtype: dict[str, Any] """ options = _upload_range_from_url_options( - source_url=source_url, - offset=offset, - length=length, - source_offset=source_offset, - **kwargs + source_url=source_url, offset=offset, length=length, source_offset=source_offset, **kwargs ) + options["allow_trailing_dot"] = self.allow_trailing_dot + options["allow_source_trailing_dot"] = self.allow_source_trailing_dot + options["file_request_intent"] = self.file_request_intent try: return cast(Dict[str, Any], self._client.file.upload_range_from_url(**options)) except HttpResponseError as error: @@ -1455,9 +1510,7 @@ def upload_range_from_url( @distributed_trace def get_ranges( - self, offset: Optional[int] = None, - length: Optional[int] = None, - **kwargs: Any + self, offset: Optional[int] = None, length: Optional[int] = None, **kwargs: Any ) -> List[Dict[str, int]]: """Returns the list of valid page ranges for a file or snapshot of a file. @@ -1483,25 +1536,24 @@ def get_ranges( A list of valid ranges. :rtype: List[dict[str, int]] """ - options = _get_ranges_options( - snapshot=self.snapshot, - offset=offset, - length=length, - **kwargs) + options = _get_ranges_options(snapshot=self.snapshot, offset=offset, length=length, **kwargs) + options["allow_trailing_dot"] = self.allow_trailing_dot + options["file_request_intent"] = self.file_request_intent try: ranges = self._client.file.get_range_list(**options) except HttpResponseError as error: process_storage_error(error) - return [{'start': file_range.start, 'end': file_range.end} for file_range in ranges.ranges] + return [{"start": file_range.start, "end": file_range.end} for file_range in (ranges.ranges or [])] @distributed_trace def get_ranges_diff( - self, previous_sharesnapshot: Union[str, Dict[str, Any]], + self, + previous_sharesnapshot: Union[str, Dict[str, Any]], offset: Optional[int] = None, length: Optional[int] = None, *, include_renames: Optional[bool] = None, - **kwargs: Any + **kwargs: Any, ) -> Tuple[List[Dict[str, int]], List[Dict[str, int]]]: """Returns the list of valid page ranges for a file or snapshot of a file. @@ -1542,7 +1594,10 @@ def get_ranges_diff( length=length, previous_sharesnapshot=previous_sharesnapshot, support_rename=include_renames, - **kwargs) + **kwargs, + ) + options["allow_trailing_dot"] = self.allow_trailing_dot + options["file_request_intent"] = self.file_request_intent try: ranges = self._client.file.get_range_list(**options) except HttpResponseError as error: @@ -1576,25 +1631,31 @@ def clear_range(self, offset: int, length: int, **kwargs: Any) -> Dict[str, Any] :returns: File-updated property dict (Etag and last modified). :rtype: Dict[str, Any] """ - access_conditions = get_access_conditions(kwargs.pop('lease', None)) - timeout = kwargs.pop('timeout', None) + access_conditions = get_access_conditions(kwargs.pop("lease", None)) + timeout = kwargs.pop("timeout", None) if offset is None or offset % 512 != 0: raise ValueError("offset must be an integer that aligns with 512 bytes file size") if length is None or length % 512 != 0: raise ValueError("length must be an integer that aligns with 512 bytes file size") end_range = length + offset - 1 # Reformat to an inclusive range index - content_range = f'bytes={offset}-{end_range}' + content_range = f"bytes={offset}-{end_range}" try: - return cast(Dict[str, Any], self._client.file.upload_range( - timeout=timeout, - cls=return_response_headers, - content_length=0, - optionalbody=None, - file_range_write="clear", - range=content_range, - lease_access_conditions=access_conditions, - **kwargs)) + return cast( + Dict[str, Any], + self._client.file.upload_range( + timeout=timeout, + cls=return_response_headers, + content_length=0, + optional_body=None, + file_range_write="clear", + range=content_range, + lease_id=access_conditions, + allow_trailing_dot=self.allow_trailing_dot, + file_request_intent=self.file_request_intent, + **kwargs, + ), + ) except HttpResponseError as error: process_storage_error(error) @@ -1620,19 +1681,25 @@ def resize_file(self, size: int, **kwargs: Any) -> Dict[str, Any]: :returns: File-updated property dict (Etag and last modified). :rtype: Dict[str, Any] """ - access_conditions = get_access_conditions(kwargs.pop('lease', None)) - timeout = kwargs.pop('timeout', None) + access_conditions = get_access_conditions(kwargs.pop("lease", None)) + timeout = kwargs.pop("timeout", None) try: - return cast(Dict[str, Any], self._client.file.set_http_headers( - file_content_length=size, - file_attributes=None, - file_creation_time=None, - file_last_write_time=None, - file_permission="preserve", - lease_access_conditions=access_conditions, - cls=return_response_headers, - timeout=timeout, - **kwargs)) + return cast( + Dict[str, Any], + self._client.file.set_http_headers( + file_content_length=size, + file_attributes=None, + file_creation_time=None, + file_last_write_time=None, + file_permission="preserve", + lease_id=access_conditions, + cls=return_response_headers, + timeout=timeout, + allow_trailing_dot=self.allow_trailing_dot, + file_request_intent=self.file_request_intent, + **kwargs, + ), + ) except HttpResponseError as error: process_storage_error(error) @@ -1649,16 +1716,17 @@ def list_handles(self, **kwargs: Any) -> ItemPaged[Handle]: :returns: An auto-paging iterable of Handle :rtype: ~azure.core.paging.ItemPaged[~azure.storage.fileshare.Handle] """ - timeout = kwargs.pop('timeout', None) - results_per_page = kwargs.pop('results_per_page', None) + timeout = kwargs.pop("timeout", None) + results_per_page = kwargs.pop("results_per_page", None) command = functools.partial( self._client.file.list_handles, sharesnapshot=self.snapshot, timeout=timeout, - **kwargs) - return ItemPaged( - command, results_per_page=results_per_page, - page_iterator_class=HandlesPaged) + allow_trailing_dot=self.allow_trailing_dot, + file_request_intent=self.file_request_intent, + **kwargs, + ) + return ItemPaged(command, results_per_page=results_per_page, page_iterator_class=HandlesPaged) @distributed_trace def close_handle(self, handle: Union[str, Handle], **kwargs: Any) -> Dict[str, int]: @@ -1682,19 +1750,21 @@ def close_handle(self, handle: Union[str, Handle], **kwargs: Any) -> Dict[str, i handle_id = handle.id else: handle_id = handle - if handle_id == '*': + if handle_id == "*": raise ValueError("Handle ID '*' is not supported. Use 'close_all_handles' instead.") try: response = self._client.file.force_close_handles( - handle_id, + handle_id=handle_id, marker=None, sharesnapshot=self.snapshot, cls=return_response_headers, - **kwargs + allow_trailing_dot=self.allow_trailing_dot, + file_request_intent=self.file_request_intent, + **kwargs, ) return { - 'closed_handles_count': response.get('number_of_handles_closed', 0), - 'failed_handles_count': response.get('number_of_handles_failed', 0) + "closed_handles_count": response.get("number_of_handles_closed", 0), + "failed_handles_count": response.get("number_of_handles_failed", 0), } except HttpResponseError as error: process_storage_error(error) @@ -1715,7 +1785,7 @@ def close_all_handles(self, **kwargs: Any) -> Dict[str, int]: and the number of handles failed to close in a dict. :rtype: dict[str, int] """ - timeout = kwargs.pop('timeout', None) + timeout = kwargs.pop("timeout", None) start_time = time.time() try_close = True @@ -1725,33 +1795,33 @@ def close_all_handles(self, **kwargs: Any) -> Dict[str, int]: while try_close: try: response = self._client.file.force_close_handles( - handle_id='*', + handle_id="*", timeout=timeout, marker=continuation_token, sharesnapshot=self.snapshot, cls=return_response_headers, - **kwargs + allow_trailing_dot=self.allow_trailing_dot, + file_request_intent=self.file_request_intent, + **kwargs, ) except HttpResponseError as error: process_storage_error(error) - continuation_token = response.get('marker') + continuation_token = response.get("marker") try_close = bool(continuation_token) - total_closed += response.get('number_of_handles_closed', 0) - total_failed += response.get('number_of_handles_failed', 0) + total_closed += response.get("number_of_handles_closed", 0) + total_failed += response.get("number_of_handles_failed", 0) if timeout: timeout = max(0, timeout - (time.time() - start_time)) - return { - 'closed_handles_count': total_closed, - 'failed_handles_count': total_failed - } + return {"closed_handles_count": total_closed, "failed_handles_count": total_failed} @distributed_trace def create_hardlink( - self, target: str, + self, + target: str, *, lease: Optional[Union[ShareLeaseClient, str]] = None, timeout: Optional[int] = None, - **kwargs: Any + **kwargs: Any, ) -> Dict[str, Any]: """NFS only. Creates a hard link to the file specified by path. @@ -1773,19 +1843,24 @@ def create_hardlink( :rtype: dict[str, Any] """ try: - return cast(Dict[str, Any], self._client.file.create_hard_link( - target_file=target, - lease_access_conditions=lease, - timeout=timeout, - cls=return_response_headers, - **kwargs - )) + return cast( + Dict[str, Any], + self._client.file.create_hard_link( + target_file=target, + lease_id=lease, + timeout=timeout, + cls=return_response_headers, + file_request_intent=self.file_request_intent, + **kwargs, + ), + ) except HttpResponseError as error: process_storage_error(error) @distributed_trace def create_symlink( - self, target: str, + self, + target: str, *, metadata: Optional[Dict[str, str]] = None, file_creation_time: Optional[Union[str, datetime]] = None, @@ -1794,7 +1869,7 @@ def create_symlink( group: Optional[str] = None, lease: Optional[Union[ShareLeaseClient, str]] = None, timeout: Optional[int] = None, - **kwargs: Any + **kwargs: Any, ) -> Dict[str, Any]: """NFS only. Creates a symbolic link to the specified file. @@ -1822,28 +1897,27 @@ def create_symlink( :rtype: dict[str, Any] """ try: - return cast(Dict[str, Any], self._client.file.create_symbolic_link( - link_text=target, - metadata=metadata, - file_creation_time=file_creation_time, - file_last_write_time=file_last_write_time, - owner=owner, - group=group, - lease_access_conditions=lease, - timeout=timeout, - cls=return_response_headers, - **kwargs - )) + return cast( + Dict[str, Any], + self._client.file.create_symbolic_link( + link_text=target, + metadata=metadata, + file_creation_time=file_creation_time, + file_last_write_time=file_last_write_time, + owner=owner, + group=group, + lease_id=lease, + timeout=timeout, + cls=return_response_headers, + file_request_intent=self.file_request_intent, + **kwargs, + ), + ) except HttpResponseError as error: process_storage_error(error) @distributed_trace - def get_symlink( - self, - *, - timeout: Optional[int] = None, - **kwargs: Any - ) -> Dict[str, Any]: + def get_symlink(self, *, timeout: Optional[int] = None, **kwargs: Any) -> Dict[str, Any]: """NFS only. Gets the symbolic link for the file client. :keyword int timeout: @@ -1856,10 +1930,14 @@ def get_symlink( :rtype: dict[str, Any] """ try: - return cast(Dict[str, Any], self._client.file.get_symbolic_link( - timeout=timeout, - cls=return_response_headers, - **kwargs - )) + return cast( + Dict[str, Any], + self._client.file.get_symbolic_link( + timeout=timeout, + cls=return_response_headers, + file_request_intent=self.file_request_intent, + **kwargs, + ), + ) except HttpResponseError as error: process_storage_error(error) diff --git a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_file_client.pyi b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_file_client.pyi index a517773f19ca..64deea3957e7 100644 --- a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_file_client.pyi +++ b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_file_client.pyi @@ -134,7 +134,7 @@ class ShareFileClient(StorageAccountHostsMixin): file_mode: Optional[str] = None, file_property_semantics: Optional[Literal["New", "Restore"]] = None, data: Optional[bytes] = None, - validate_content: Optional[Literal['auto', 'crc64', 'md5']] = None, + validate_content: Optional[Literal["auto", "crc64", "md5"]] = None, timeout: Optional[int] = None, **kwargs: Any ) -> Dict[str, Any]: ... @@ -152,7 +152,7 @@ class ShareFileClient(StorageAccountHostsMixin): file_change_time: Optional[Union[str, datetime]] = None, metadata: Optional[Dict[str, str]] = None, content_settings: Optional[ContentSettings] = None, - validate_content: Optional[Union[bool, Literal['auto', 'crc64', 'md5']]] = None, + validate_content: Optional[Union[bool, Literal["auto", "crc64", "md5"]]] = None, max_concurrency: Optional[int] = None, lease: Optional[Union[ShareLeaseClient, str]] = None, progress_hook: Optional[Callable[[int, Optional[int]], None]] = None, @@ -200,7 +200,7 @@ class ShareFileClient(StorageAccountHostsMixin): length: Optional[int] = None, *, max_concurrency: Optional[int] = None, - validate_content: Optional[Union[bool, Literal['auto', 'crc64', 'md5']]] = None, + validate_content: Optional[Union[bool, Literal["auto", "crc64", "md5"]]] = None, lease: Optional[Union[ShareLeaseClient, str]] = None, progress_hook: Optional[Callable[[int, Optional[int]], None]] = None, decompress: Optional[bool] = None, @@ -271,7 +271,7 @@ class ShareFileClient(StorageAccountHostsMixin): offset: int, length: int, *, - validate_content: Optional[Union[bool, Literal['auto', 'crc64', 'md5']]] = None, + validate_content: Optional[Union[bool, Literal["auto", "crc64", "md5"]]] = None, encoding: str = "UTF-8", file_last_write_mode: Optional[Literal["preserve", "now"]] = None, lease: Optional[Union[ShareLeaseClient, str]] = None, diff --git a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_file_client_helpers.py b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_file_client_helpers.py index ea225f3c596c..e0bfe66d4769 100644 --- a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_file_client_helpers.py +++ b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_file_client_helpers.py @@ -4,10 +4,7 @@ # license information. # -------------------------------------------------------------------------- -from typing import ( - Any, Dict, List, Optional, Tuple, Union, - TYPE_CHECKING -) +from typing import Any, Dict, List, Optional, Tuple, Union, TYPE_CHECKING from urllib.parse import quote, unquote, urlparse from ._serialize import get_access_conditions, get_source_conditions @@ -20,11 +17,11 @@ def _parse_url(account_url: str, share_name: str, file_path: str) -> "ParseResult": try: - if not account_url.lower().startswith('http'): + if not account_url.lower().startswith("http"): account_url = "https://" + account_url except AttributeError as exc: raise ValueError("Account URL must be a string.") from exc - parsed_url = urlparse(account_url.rstrip('/')) + parsed_url = urlparse(account_url.rstrip("/")) if not (share_name and file_path): raise ValueError("Please specify a share name and file name.") if not parsed_url.netloc: @@ -33,48 +30,38 @@ def _parse_url(account_url: str, share_name: str, file_path: str) -> "ParseResul def _from_file_url( - file_url: str, - snapshot: Optional[Union[str, Dict[str, Any]]] = None + file_url: str, snapshot: Optional[Union[str, Dict[str, Any]]] = None ) -> Tuple[str, str, str, Optional[Union[str, Dict[str, Any]]]]: try: - if not file_url.lower().startswith('http'): + if not file_url.lower().startswith("http"): file_url = "https://" + file_url except AttributeError as exc: raise ValueError("File URL must be a string.") from exc - parsed_url = urlparse(file_url.rstrip('/')) + parsed_url = urlparse(file_url.rstrip("/")) if not (parsed_url.netloc and parsed_url.path): raise ValueError(f"Invalid URL: {file_url}") - account_url = parsed_url.netloc.rstrip('/') + "?" + parsed_url.query + account_url = parsed_url.netloc.rstrip("/") + "?" + parsed_url.query - path_share, _, path_file = parsed_url.path.lstrip('/').partition('/') + path_share, _, path_file = parsed_url.path.lstrip("/").partition("/") path_snapshot, _ = parse_query(parsed_url.query) snapshot = snapshot or path_snapshot share_name = unquote(path_share) - file_path = '/'.join([unquote(p) for p in path_file.split('/')]) + file_path = "/".join([unquote(p) for p in path_file.split("/")]) return account_url, share_name, file_path, snapshot -def _format_url( - scheme: str, - hostname: str, - share_name: Union[str, bytes], - file_path: List[str], - query_str: str -) -> str: +def _format_url(scheme: str, hostname: str, share_name: Union[str, bytes], file_path: List[str], query_str: str) -> str: if isinstance(share_name, str): - share_name = share_name.encode('UTF-8') - return (f"{scheme}://{hostname}/{quote(share_name)}" - f"/{'/'.join([quote(p, safe='~') for p in file_path])}{query_str}") + share_name = share_name.encode("UTF-8") + return ( + f"{scheme}://{hostname}/{quote(share_name)}" f"/{'/'.join([quote(p, safe='~') for p in file_path])}{query_str}" + ) def _upload_range_from_url_options( - source_url: str, - offset: int, - length: int, - source_offset: int, - **kwargs: Any + source_url: str, offset: int, length: int, source_offset: int, **kwargs: Any ) -> Dict[str, Any]: if offset is None: raise ValueError("offset must be provided.") @@ -85,24 +72,27 @@ def _upload_range_from_url_options( # Format range end_range = offset + length - 1 - destination_range = f'bytes={offset}-{end_range}' - source_range = f'bytes={source_offset}-{source_offset + length - 1}' - source_authorization = kwargs.pop('source_authorization', None) - source_mod_conditions = get_source_conditions(kwargs) - access_conditions = get_access_conditions(kwargs.pop('lease', None)) - file_last_write_mode = kwargs.pop('file_last_write_mode', None) + destination_range = f"bytes={offset}-{end_range}" + source_range = f"bytes={source_offset}-{source_offset + length - 1}" + source_authorization = kwargs.pop("source_authorization", None) + _source_mod_conditions = get_source_conditions(kwargs) + access_conditions = get_access_conditions(kwargs.pop("lease", None)) + file_last_write_mode = kwargs.pop("file_last_write_mode", None) options = { - 'copy_source_authorization': source_authorization, - 'copy_source': source_url, - 'content_length': 0, - 'source_range': source_range, - 'range': destination_range, - 'file_last_written_mode': file_last_write_mode, - 'source_modified_access_conditions': source_mod_conditions, - 'lease_access_conditions': access_conditions, - 'timeout': kwargs.pop('timeout', None), - 'cls': return_response_headers + "copy_source_authorization": source_authorization, + "copy_source": source_url, + "content_length": 0, + "source_range": source_range, + "range": destination_range, + "file_range_write_from_url": "update", + "file_last_written_mode": file_last_write_mode, + "source_content_crc64": kwargs.pop("source_content_crc64", None), + "source_if_match_crc64": kwargs.pop("source_if_match_crc64", None), + "source_if_none_match_crc64": kwargs.pop("source_if_none_match_crc64", None), + "lease_id": access_conditions, + "timeout": kwargs.pop("timeout", None), + "cls": return_response_headers, } options.update(kwargs) @@ -114,32 +104,32 @@ def _get_ranges_options( offset: Optional[int] = None, length: Optional[int] = None, previous_sharesnapshot: Optional[Union[str, Dict[str, Any]]] = None, - **kwargs: Any + **kwargs: Any, ) -> Dict[str, Any]: - access_conditions = get_access_conditions(kwargs.pop('lease', None)) + access_conditions = get_access_conditions(kwargs.pop("lease", None)) content_range = None if offset: if length: end_range = offset + length - 1 # Reformat to an inclusive range index - content_range = f'bytes={offset}-{end_range}' + content_range = f"bytes={offset}-{end_range}" else: - content_range = f'bytes={offset}-' + content_range = f"bytes={offset}-" options = { - 'sharesnapshot': snapshot, - 'lease_access_conditions': access_conditions, - 'timeout': kwargs.pop('timeout', None), - 'range': content_range + "sharesnapshot": snapshot, + "lease_id": access_conditions, + "timeout": kwargs.pop("timeout", None), + "range": content_range, } if previous_sharesnapshot: - if hasattr(previous_sharesnapshot, 'snapshot'): - options['prevsharesnapshot'] = previous_sharesnapshot.snapshot + if hasattr(previous_sharesnapshot, "snapshot"): + options["prevsharesnapshot"] = previous_sharesnapshot.snapshot elif isinstance(previous_sharesnapshot, Dict): - options['prevsharesnapshot'] = previous_sharesnapshot['snapshot'] + options["prevsharesnapshot"] = previous_sharesnapshot["snapshot"] else: - options['prevsharesnapshot'] = previous_sharesnapshot + options["prevsharesnapshot"] = previous_sharesnapshot options.update(kwargs) return options diff --git a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/__init__.py b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/__init__.py index b4f1dd31c73a..95af3b88f994 100644 --- a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/__init__.py +++ b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/__init__.py @@ -2,7 +2,7 @@ # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. +# Code generated by Microsoft (R) Python Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- # pylint: disable=wrong-import-position @@ -12,7 +12,10 @@ if TYPE_CHECKING: from ._patch import * # pylint: disable=unused-wildcard-import -from ._azure_file_storage import AzureFileStorage # type: ignore +from ._client import FileClient # type: ignore +from ._version import VERSION + +__version__ = VERSION try: from ._patch import __all__ as _patch_all @@ -22,7 +25,7 @@ from ._patch import patch_sdk as _patch_sdk __all__ = [ - "AzureFileStorage", + "FileClient", ] __all__.extend([p for p in _patch_all if p not in __all__]) # pyright: ignore diff --git a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/_azure_file_storage.py b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/_client.py similarity index 60% rename from sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/_azure_file_storage.py rename to sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/_client.py index cea1a9e2ac4c..91c54c5094ef 100644 --- a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/_azure_file_storage.py +++ b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/_client.py @@ -2,74 +2,57 @@ # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. +# Code generated by Microsoft (R) Python Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- from copy import deepcopy -from typing import Any, Optional, Union -from typing_extensions import Self +import sys +from typing import Any, TYPE_CHECKING from azure.core import PipelineClient from azure.core.pipeline import policies from azure.core.rest import HttpRequest, HttpResponse -from . import models as _models -from ._configuration import AzureFileStorageConfiguration +from ._configuration import FileClientConfiguration from ._utils.serialization import Deserializer, Serializer from .operations import DirectoryOperations, FileOperations, ServiceOperations, ShareOperations +if sys.version_info >= (3, 11): + from typing import Self +else: + from typing_extensions import Self # type: ignore -class AzureFileStorage: # pylint: disable=client-accepts-api-version-keyword - """AzureFileStorage. +if TYPE_CHECKING: + from azure.core.credentials import TokenCredential + + +class FileClient: # pylint: disable=client-accepts-api-version-keyword + """Azure File Storage provides scalable file shares in the cloud using SMB and NFS protocols. - :ivar service: ServiceOperations operations - :vartype service: azure.storage.fileshare.operations.ServiceOperations - :ivar share: ShareOperations operations - :vartype share: azure.storage.fileshare.operations.ShareOperations :ivar directory: DirectoryOperations operations :vartype directory: azure.storage.fileshare.operations.DirectoryOperations :ivar file: FileOperations operations :vartype file: azure.storage.fileshare.operations.FileOperations - :param version: Specifies the version of the operation to use for this request. Required. - :type version: str + :ivar service: ServiceOperations operations + :vartype service: azure.storage.fileshare.operations.ServiceOperations + :ivar share: ShareOperations operations + :vartype share: azure.storage.fileshare.operations.ShareOperations :param url: The URL of the service account, share, directory or file that is the target of the desired operation. Required. :type url: str - :param base_url: Service URL. Required. Default value is "". - :type base_url: str - :param file_request_intent: Valid value is backup. "backup" Default value is None. - :type file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent - :param allow_trailing_dot: If true, the trailing dot will not be trimmed from the target URI. - Default value is None. - :type allow_trailing_dot: bool - :param allow_source_trailing_dot: If true, the trailing dot will not be trimmed from the source - URI. Default value is None. - :type allow_source_trailing_dot: bool - :keyword file_range_write_from_url: Only update is supported: - Update: Writes the bytes - downloaded from the source url into the specified range. Default value is "update". Note that - overriding this default value may result in unsupported behavior. - :paramtype file_range_write_from_url: str + :param credential: Credential used to authenticate requests to the service. Required. + :type credential: ~azure.core.credentials.TokenCredential + :keyword version: Specifies the version of the operation to use for this request. Known values + are "2026-06-06" and None. Default value is None. If not set, the operation's default API + version will be used. Note that overriding this default value may result in unsupported + behavior. + :paramtype version: str """ - def __init__( # pylint: disable=missing-client-constructor-parameter-credential - self, - version: str, - url: str, - base_url: str = "", - file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, - allow_trailing_dot: Optional[bool] = None, - allow_source_trailing_dot: Optional[bool] = None, - **kwargs: Any - ) -> None: - self._config = AzureFileStorageConfiguration( - version=version, - url=url, - file_request_intent=file_request_intent, - allow_trailing_dot=allow_trailing_dot, - allow_source_trailing_dot=allow_source_trailing_dot, - **kwargs - ) + def __init__(self, url: str, credential: "TokenCredential", **kwargs: Any) -> None: + _endpoint = "{url}" + self._config = FileClientConfiguration(url=url, credential=credential, **kwargs) _policies = kwargs.pop("policies", None) if _policies is None: @@ -88,24 +71,23 @@ def __init__( # pylint: disable=missing-client-constructor-parameter-credential policies.SensitiveHeaderCleanupPolicy(**kwargs) if self._config.redirect_policy else None, self._config.http_logging_policy, ] - self._client: PipelineClient = PipelineClient(base_url=base_url, policies=_policies, **kwargs) + self._client: PipelineClient = PipelineClient(base_url=_endpoint, policies=_policies, **kwargs) - client_models = {k: v for k, v in _models.__dict__.items() if isinstance(v, type)} - self._serialize = Serializer(client_models) - self._deserialize = Deserializer(client_models) + self._serialize = Serializer() + self._deserialize = Deserializer() self._serialize.client_side_validation = False - self.service = ServiceOperations(self._client, self._config, self._serialize, self._deserialize) - self.share = ShareOperations(self._client, self._config, self._serialize, self._deserialize) self.directory = DirectoryOperations(self._client, self._config, self._serialize, self._deserialize) self.file = FileOperations(self._client, self._config, self._serialize, self._deserialize) + self.service = ServiceOperations(self._client, self._config, self._serialize, self._deserialize) + self.share = ShareOperations(self._client, self._config, self._serialize, self._deserialize) - def _send_request(self, request: HttpRequest, *, stream: bool = False, **kwargs: Any) -> HttpResponse: + def send_request(self, request: HttpRequest, *, stream: bool = False, **kwargs: Any) -> HttpResponse: """Runs the network request through the client's chained policies. >>> from azure.core.rest import HttpRequest >>> request = HttpRequest("GET", "https://www.example.org/") - >>> response = client._send_request(request) + >>> response = client.send_request(request) For more information on this code flow, see https://aka.ms/azsdk/dpcodegen/python/send_request @@ -118,7 +100,11 @@ def _send_request(self, request: HttpRequest, *, stream: bool = False, **kwargs: """ request_copy = deepcopy(request) - request_copy.url = self._client.format_url(request_copy.url) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + + request_copy.url = self._client.format_url(request_copy.url, **path_format_arguments) return self._client.send_request(request_copy, stream=stream, **kwargs) # type: ignore def close(self) -> None: diff --git a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/_configuration.py b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/_configuration.py index 51f09f3c22f7..ff0fbd76c9ce 100644 --- a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/_configuration.py +++ b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/_configuration.py @@ -2,67 +2,51 @@ # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. +# Code generated by Microsoft (R) Python Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any, Literal, Optional, Union +from typing import Any, TYPE_CHECKING from azure.core.pipeline import policies -from . import models as _models +from ._version import VERSION -VERSION = "unknown" +if TYPE_CHECKING: + from azure.core.credentials import TokenCredential -class AzureFileStorageConfiguration: # pylint: disable=too-many-instance-attributes - """Configuration for AzureFileStorage. +class FileClientConfiguration: # pylint: disable=too-many-instance-attributes + """Configuration for FileClient. Note that all parameters used to create this instance are saved as instance attributes. - :param version: Specifies the version of the operation to use for this request. Required. - :type version: str :param url: The URL of the service account, share, directory or file that is the target of the desired operation. Required. :type url: str - :param file_request_intent: Valid value is backup. "backup" Default value is None. - :type file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent - :param allow_trailing_dot: If true, the trailing dot will not be trimmed from the target URI. - Default value is None. - :type allow_trailing_dot: bool - :param allow_source_trailing_dot: If true, the trailing dot will not be trimmed from the source - URI. Default value is None. - :type allow_source_trailing_dot: bool - :keyword file_range_write_from_url: Only update is supported: - Update: Writes the bytes - downloaded from the source url into the specified range. Default value is "update". Note that - overriding this default value may result in unsupported behavior. - :paramtype file_range_write_from_url: str + :param credential: Credential used to authenticate requests to the service. Required. + :type credential: ~azure.core.credentials.TokenCredential + :keyword version: Specifies the version of the operation to use for this request. Known values + are "2026-06-06" and None. Default value is None. If not set, the operation's default API + version will be used. Note that overriding this default value may result in unsupported + behavior. + :paramtype version: str """ - def __init__( - self, - version: str, - url: str, - file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, - allow_trailing_dot: Optional[bool] = None, - allow_source_trailing_dot: Optional[bool] = None, - **kwargs: Any - ) -> None: - file_range_write_from_url: Literal["update"] = kwargs.pop("file_range_write_from_url", "update") + def __init__(self, url: str, credential: "TokenCredential", **kwargs: Any) -> None: + version: str = kwargs.pop("version", "2026-06-06") - if version is None: - raise ValueError("Parameter 'version' must not be None.") if url is None: raise ValueError("Parameter 'url' must not be None.") + if credential is None: + raise ValueError("Parameter 'credential' must not be None.") - self.version = version self.url = url - self.file_request_intent = file_request_intent - self.allow_trailing_dot = allow_trailing_dot - self.allow_source_trailing_dot = allow_source_trailing_dot - self.file_range_write_from_url = file_range_write_from_url - kwargs.setdefault("sdk_moniker", "azurefilestorage/{}".format(VERSION)) + self.credential = credential + self.version = version + self.credential_scopes = kwargs.pop("credential_scopes", ["https://storage.azure.com/.default"]) + kwargs.setdefault("sdk_moniker", "storage-file-share/{}".format(VERSION)) self.polling_interval = kwargs.get("polling_interval", 30) self._configure(**kwargs) @@ -76,3 +60,7 @@ def _configure(self, **kwargs: Any) -> None: self.redirect_policy = kwargs.get("redirect_policy") or policies.RedirectPolicy(**kwargs) self.retry_policy = kwargs.get("retry_policy") or policies.RetryPolicy(**kwargs) self.authentication_policy = kwargs.get("authentication_policy") + if self.credential and not self.authentication_policy: + self.authentication_policy = policies.BearerTokenCredentialPolicy( + self.credential, *self.credential_scopes, **kwargs + ) diff --git a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/_patch.py b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/_patch.py index f7dd32510333..64509fb03024 100644 --- a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/_patch.py +++ b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/_patch.py @@ -1,14 +1,138 @@ -# ------------------------------------ -# Copyright (c) Microsoft Corporation. -# Licensed under the MIT License. -# ------------------------------------ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# -------------------------------------------------------------------------- """Customize generated code here. Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize """ -from typing import List -__all__: List[str] = [] # Add all objects you want publicly available to users at this package level +from typing import Any, Optional, TYPE_CHECKING + +from azure.core import PipelineClient +from azure.core.pipeline import Pipeline, PipelineRequest +from azure.core.pipeline import policies +from azure.core.pipeline.policies import SansIOHTTPPolicy + +from ._utils.serialization import Deserializer, Serializer +from .operations import DirectoryOperations, FileOperations, ServiceOperations, ShareOperations +from ._client import FileClient as GeneratedFileClient +from ._configuration import FileClientConfiguration as GeneratedFileClientConfiguration + +if TYPE_CHECKING: + from azure.core.credentials import TokenCredential + + +class RangeHeaderPolicy(SansIOHTTPPolicy): + """Policy that converts the 'Range' header to 'x-ms-range'.""" + + def on_request(self, request: PipelineRequest) -> None: + range_value = request.http_request.headers.pop("Range", None) + if range_value is not None: + request.http_request.headers["x-ms-range"] = range_value + + +class FileClientConfiguration(GeneratedFileClientConfiguration): + """Configuration for FileClient. + + Note that all parameters used to create this instance are saved as instance + attributes. + + :param url: The URL of the service account, share, directory or file that is the target of the + desired operation. Required. + :type url: str + :param credential: Credential used to authenticate requests to the service. + :type credential: ~azure.core.credentials.TokenCredential or None + :keyword version: Specifies the version of the operation to use for this request. Known values + are "2026-06-06". Default value is "2026-06-06". Note that overriding this default value may + result in unsupported behavior. + :paramtype version: str + """ + + def __init__(self, url: str, credential: Optional["TokenCredential"] = None, **kwargs: Any) -> None: + if url is None: + raise ValueError("Parameter 'url' must not be None.") + + version: str = kwargs.pop("version", "2026-06-06") + self.url = url + self.credential = credential + self.version = version + self.credential_scopes = kwargs.pop("credential_scopes", ["https://storage.azure.com/.default"]) + from ._version import VERSION + + kwargs.setdefault("sdk_moniker", "storage-file-share/{}".format(VERSION)) + self.polling_interval = kwargs.get("polling_interval", 30) + self._configure(**kwargs) + + +class FileClient(GeneratedFileClient): + """Azure File Storage provides scalable file shares in the cloud using SMB and NFS protocols. + + :ivar directory: DirectoryOperations operations + :vartype directory: azure.storage.fileshare.operations.DirectoryOperations + :ivar file: FileOperations operations + :vartype file: azure.storage.fileshare.operations.FileOperations + :ivar service: ServiceOperations operations + :vartype service: azure.storage.fileshare.operations.ServiceOperations + :ivar share: ShareOperations operations + :vartype share: azure.storage.fileshare.operations.ShareOperations + :param url: The URL of the service account, share, directory or file that is the target of the + desired operation. Required. + :type url: str + :param credential: Credential used to authenticate requests to the service. + :type credential: ~azure.core.credentials.TokenCredential or None + :keyword version: Specifies the version of the operation to use for this request. Known values + are "2026-06-06". Default value is "2026-06-06". Note that overriding this default value may + result in unsupported behavior. + :paramtype version: str + """ + + def __init__( + self, url: str, credential: Optional["TokenCredential"] = None, *, pipeline: Any = None, **kwargs: Any + ) -> None: + _endpoint = "{url}" + self._config = FileClientConfiguration(url=url, credential=credential, **kwargs) + + if pipeline is not None: + # Wrap the pre-built pipeline to inject RangeHeaderPolicy + _wrapped_pipeline = Pipeline( + transport=pipeline._transport, + policies=[RangeHeaderPolicy()] + list(pipeline._impl_policies), + ) + self._client = PipelineClient(base_url=_endpoint, pipeline=_wrapped_pipeline) + else: + _policies = kwargs.pop("policies", None) + if _policies is None: + _policies = [ + RangeHeaderPolicy(), + policies.RequestIdPolicy(**kwargs), + self._config.headers_policy, + self._config.user_agent_policy, + self._config.proxy_policy, + policies.ContentDecodePolicy(**kwargs), + self._config.redirect_policy, + self._config.retry_policy, + self._config.authentication_policy, + self._config.custom_hook_policy, + self._config.logging_policy, + policies.DistributedTracingPolicy(**kwargs), + policies.SensitiveHeaderCleanupPolicy(**kwargs) if self._config.redirect_policy else None, + self._config.http_logging_policy, + ] + self._client = PipelineClient(base_url=_endpoint, policies=_policies, **kwargs) + + self._serialize = Serializer() + self._deserialize = Deserializer() + self._serialize.client_side_validation = False + + self.service = ServiceOperations(self._client, self._config, self._serialize, self._deserialize) + self.share = ShareOperations(self._client, self._config, self._serialize, self._deserialize) + self.directory = DirectoryOperations(self._client, self._config, self._serialize, self._deserialize) + self.file = FileOperations(self._client, self._config, self._serialize, self._deserialize) + + +__all__: list[str] = ["FileClient"] def patch_sdk(): diff --git a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/_utils/__init__.py b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/_utils/__init__.py index 0af9b28f6607..8026245c2abc 100644 --- a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/_utils/__init__.py +++ b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/_utils/__init__.py @@ -1,6 +1,6 @@ # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. +# Code generated by Microsoft (R) Python Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- diff --git a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/_utils/model_base.py b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/_utils/model_base.py new file mode 100644 index 000000000000..bd5b9caf1022 --- /dev/null +++ b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/_utils/model_base.py @@ -0,0 +1,1755 @@ +# pylint: disable=line-too-long,useless-suppression,too-many-lines +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) Python Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- +# pylint: disable=protected-access, broad-except + +import copy +import calendar +import decimal +import functools +import sys +import logging +import base64 +import re +import typing +import enum +import email.utils +from datetime import datetime, date, time, timedelta, timezone +from json import JSONEncoder +import xml.etree.ElementTree as ET +from collections.abc import MutableMapping +import isodate +from azure.core.exceptions import DeserializationError +from azure.core import CaseInsensitiveEnumMeta +from azure.core.pipeline import PipelineResponse +from azure.core.serialization import _Null + +from azure.core.rest import HttpResponse + +if sys.version_info >= (3, 11): + from typing import Self +else: + from typing_extensions import Self + +_LOGGER = logging.getLogger(__name__) + +__all__ = ["SdkJSONEncoder", "Model", "rest_field", "rest_discriminator"] + +TZ_UTC = timezone.utc +_T = typing.TypeVar("_T") +_NONE_TYPE = type(None) + + +def _timedelta_as_isostr(td: timedelta) -> str: + """Converts a datetime.timedelta object into an ISO 8601 formatted string, e.g. 'P4DT12H30M05S' + + Function adapted from the Tin Can Python project: https://github.com/RusticiSoftware/TinCanPython + + :param timedelta td: The timedelta to convert + :rtype: str + :return: ISO8601 version of this timedelta + """ + + # Split seconds to larger units + seconds = td.total_seconds() + minutes, seconds = divmod(seconds, 60) + hours, minutes = divmod(minutes, 60) + days, hours = divmod(hours, 24) + + days, hours, minutes = list(map(int, (days, hours, minutes))) + seconds = round(seconds, 6) + + # Build date + date_str = "" + if days: + date_str = "%sD" % days + + if hours or minutes or seconds: + # Build time + time_str = "T" + + # Hours + bigger_exists = date_str or hours + if bigger_exists: + time_str += "{:02}H".format(hours) + + # Minutes + bigger_exists = bigger_exists or minutes + if bigger_exists: + time_str += "{:02}M".format(minutes) + + # Seconds + try: + if seconds.is_integer(): + seconds_string = "{:02}".format(int(seconds)) + else: + # 9 chars long w/ leading 0, 6 digits after decimal + seconds_string = "%09.6f" % seconds + # Remove trailing zeros + seconds_string = seconds_string.rstrip("0") + except AttributeError: # int.is_integer() raises + seconds_string = "{:02}".format(seconds) + + time_str += "{}S".format(seconds_string) + else: + time_str = "" + + return "P" + date_str + time_str + + +def _serialize_bytes(o, format: typing.Optional[str] = None) -> str: + encoded = base64.b64encode(o).decode() + if format == "base64url": + return encoded.strip("=").replace("+", "-").replace("/", "_") + return encoded + + +def _serialize_datetime(o, format: typing.Optional[str] = None): + if hasattr(o, "year") and hasattr(o, "hour"): + if format == "rfc7231": + return email.utils.format_datetime(o, usegmt=True) + if format == "unix-timestamp": + return int(calendar.timegm(o.utctimetuple())) + + # astimezone() fails for naive times in Python 2.7, so make make sure o is aware (tzinfo is set) + if not o.tzinfo: + iso_formatted = o.replace(tzinfo=TZ_UTC).isoformat() + else: + iso_formatted = o.astimezone(TZ_UTC).isoformat() + # Replace the trailing "+00:00" UTC offset with "Z" (RFC 3339: https://www.ietf.org/rfc/rfc3339.txt) + return iso_formatted.replace("+00:00", "Z") + # Next try datetime.date or datetime.time + return o.isoformat() + + +def _is_readonly(p): + try: + return p._visibility == ["read"] + except AttributeError: + return False + + +class SdkJSONEncoder(JSONEncoder): + """A JSON encoder that's capable of serializing datetime objects and bytes.""" + + def __init__(self, *args, exclude_readonly: bool = False, format: typing.Optional[str] = None, **kwargs): + super().__init__(*args, **kwargs) + self.exclude_readonly = exclude_readonly + self.format = format + + def default(self, o): # pylint: disable=too-many-return-statements + if _is_model(o): + if self.exclude_readonly: + readonly_props = [p._rest_name for p in o._attr_to_rest_field.values() if _is_readonly(p)] + return {k: v for k, v in o.items() if k not in readonly_props} + return dict(o.items()) + try: + return super(SdkJSONEncoder, self).default(o) + except TypeError: + if isinstance(o, _Null): + return None + if isinstance(o, decimal.Decimal): + return float(o) + if isinstance(o, (bytes, bytearray)): + return _serialize_bytes(o, self.format) + try: + # First try datetime.datetime + return _serialize_datetime(o, self.format) + except AttributeError: + pass + # Last, try datetime.timedelta + try: + return _timedelta_as_isostr(o) + except AttributeError: + # This will be raised when it hits value.total_seconds in the method above + pass + return super(SdkJSONEncoder, self).default(o) + + +_VALID_DATE = re.compile(r"\d{4}[-]\d{2}[-]\d{2}T\d{2}:\d{2}:\d{2}" + r"\.?\d*Z?[-+]?[\d{2}]?:?[\d{2}]?") +_VALID_RFC7231 = re.compile( + r"(Mon|Tue|Wed|Thu|Fri|Sat|Sun),\s\d{2}\s" + r"(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)\s\d{4}\s\d{2}:\d{2}:\d{2}\sGMT" +) + +_ARRAY_ENCODE_MAPPING = { + "pipeDelimited": "|", + "spaceDelimited": " ", + "commaDelimited": ",", + "newlineDelimited": "\n", +} + + +def _deserialize_array_encoded(delimit: str, attr): + if isinstance(attr, str): + if attr == "": + return [] + return attr.split(delimit) + return attr + + +def _deserialize_datetime(attr: typing.Union[str, datetime]) -> datetime: + """Deserialize ISO-8601 formatted string into Datetime object. + + :param str attr: response string to be deserialized. + :rtype: ~datetime.datetime + :returns: The datetime object from that input + """ + if isinstance(attr, datetime): + # i'm already deserialized + return attr + attr = attr.upper() + match = _VALID_DATE.match(attr) + if not match: + raise ValueError("Invalid datetime string: " + attr) + + check_decimal = attr.split(".") + if len(check_decimal) > 1: + decimal_str = "" + for digit in check_decimal[1]: + if digit.isdigit(): + decimal_str += digit + else: + break + if len(decimal_str) > 6: + attr = attr.replace(decimal_str, decimal_str[0:6]) + + date_obj = isodate.parse_datetime(attr) + test_utc = date_obj.utctimetuple() + if test_utc.tm_year > 9999 or test_utc.tm_year < 1: + raise OverflowError("Hit max or min date") + return date_obj # type: ignore[no-any-return] + + +def _deserialize_datetime_rfc7231(attr: typing.Union[str, datetime]) -> datetime: + """Deserialize RFC7231 formatted string into Datetime object. + + :param str attr: response string to be deserialized. + :rtype: ~datetime.datetime + :returns: The datetime object from that input + """ + if isinstance(attr, datetime): + # i'm already deserialized + return attr + match = _VALID_RFC7231.match(attr) + if not match: + raise ValueError("Invalid datetime string: " + attr) + + return email.utils.parsedate_to_datetime(attr) + + +def _deserialize_datetime_unix_timestamp(attr: typing.Union[float, datetime]) -> datetime: + """Deserialize unix timestamp into Datetime object. + + :param str attr: response string to be deserialized. + :rtype: ~datetime.datetime + :returns: The datetime object from that input + """ + if isinstance(attr, datetime): + # i'm already deserialized + return attr + return datetime.fromtimestamp(attr, TZ_UTC) + + +def _deserialize_date(attr: typing.Union[str, date]) -> date: + """Deserialize ISO-8601 formatted string into Date object. + :param str attr: response string to be deserialized. + :rtype: date + :returns: The date object from that input + """ + # This must NOT use defaultmonth/defaultday. Using None ensure this raises an exception. + if isinstance(attr, date): + return attr + return isodate.parse_date(attr, defaultmonth=None, defaultday=None) # type: ignore + + +def _deserialize_time(attr: typing.Union[str, time]) -> time: + """Deserialize ISO-8601 formatted string into time object. + + :param str attr: response string to be deserialized. + :rtype: datetime.time + :returns: The time object from that input + """ + if isinstance(attr, time): + return attr + return isodate.parse_time(attr) # type: ignore[no-any-return] + + +def _deserialize_bytes(attr): + if isinstance(attr, (bytes, bytearray)): + return attr + return bytes(base64.b64decode(attr)) + + +def _deserialize_bytes_base64(attr): + if isinstance(attr, (bytes, bytearray)): + return attr + padding = "=" * (3 - (len(attr) + 3) % 4) # type: ignore + attr = attr + padding # type: ignore + encoded = attr.replace("-", "+").replace("_", "/") + return bytes(base64.b64decode(encoded)) + + +def _deserialize_duration(attr): + if isinstance(attr, timedelta): + return attr + return isodate.parse_duration(attr) + + +def _deserialize_decimal(attr): + if isinstance(attr, decimal.Decimal): + return attr + return decimal.Decimal(str(attr)) + + +def _deserialize_int_as_str(attr): + if isinstance(attr, int): + return attr + return int(attr) + + +_DESERIALIZE_MAPPING = { + datetime: _deserialize_datetime, + date: _deserialize_date, + time: _deserialize_time, + bytes: _deserialize_bytes, + bytearray: _deserialize_bytes, + timedelta: _deserialize_duration, + typing.Any: lambda x: x, + decimal.Decimal: _deserialize_decimal, +} + +_DESERIALIZE_MAPPING_WITHFORMAT = { + "rfc3339": _deserialize_datetime, + "rfc7231": _deserialize_datetime_rfc7231, + "unix-timestamp": _deserialize_datetime_unix_timestamp, + "base64": _deserialize_bytes, + "base64url": _deserialize_bytes_base64, +} + + +def get_deserializer(annotation: typing.Any, rf: typing.Optional["_RestField"] = None): + if annotation is int and rf and rf._format == "str": + return _deserialize_int_as_str + if annotation is str and rf and rf._format in _ARRAY_ENCODE_MAPPING: + return functools.partial(_deserialize_array_encoded, _ARRAY_ENCODE_MAPPING[rf._format]) + if rf and rf._format: + return _DESERIALIZE_MAPPING_WITHFORMAT.get(rf._format) + return _DESERIALIZE_MAPPING.get(annotation) # pyright: ignore + + +def _get_type_alias_type(module_name: str, alias_name: str): + types = { + k: v + for k, v in sys.modules[module_name].__dict__.items() + if isinstance(v, typing._GenericAlias) # type: ignore + } + if alias_name not in types: + return alias_name + return types[alias_name] + + +def _get_model(module_name: str, model_name: str): + models = {k: v for k, v in sys.modules[module_name].__dict__.items() if isinstance(v, type)} + module_end = module_name.rsplit(".", 1)[0] + models.update({k: v for k, v in sys.modules[module_end].__dict__.items() if isinstance(v, type)}) + if isinstance(model_name, str): + model_name = model_name.split(".")[-1] + if model_name not in models: + return model_name + return models[model_name] + + +_UNSET = object() + + +class _MyMutableMapping(MutableMapping[str, typing.Any]): + def __init__(self, data: dict[str, typing.Any]) -> None: + self._data = data + + def __contains__(self, key: typing.Any) -> bool: + return key in self._data + + def __getitem__(self, key: str) -> typing.Any: + # If this key has been deserialized (for mutable types), we need to handle serialization + if hasattr(self, "_attr_to_rest_field"): + cache_attr = f"_deserialized_{key}" + if hasattr(self, cache_attr): + rf = _get_rest_field(getattr(self, "_attr_to_rest_field"), key) + if rf: + value = self._data.get(key) + if isinstance(value, (dict, list, set)): + # For mutable types, serialize and return + # But also update _data with serialized form and clear flag + # so mutations via this returned value affect _data + serialized = _serialize(value, rf._format) + # If serialized form is same type (no transformation needed), + # return _data directly so mutations work + if isinstance(serialized, type(value)) and serialized == value: + return self._data.get(key) + # Otherwise return serialized copy and clear flag + try: + object.__delattr__(self, cache_attr) + except AttributeError: + pass + # Store serialized form back + self._data[key] = serialized + return serialized + return self._data.__getitem__(key) + + def __setitem__(self, key: str, value: typing.Any) -> None: + # Clear any cached deserialized value when setting through dictionary access + cache_attr = f"_deserialized_{key}" + try: + object.__delattr__(self, cache_attr) + except AttributeError: + pass + self._data.__setitem__(key, value) + + def __delitem__(self, key: str) -> None: + self._data.__delitem__(key) + + def __iter__(self) -> typing.Iterator[typing.Any]: + return self._data.__iter__() + + def __len__(self) -> int: + return self._data.__len__() + + def __ne__(self, other: typing.Any) -> bool: + return not self.__eq__(other) + + def keys(self) -> typing.KeysView[str]: + """ + :returns: a set-like object providing a view on D's keys + :rtype: ~typing.KeysView + """ + return self._data.keys() + + def values(self) -> typing.ValuesView[typing.Any]: + """ + :returns: an object providing a view on D's values + :rtype: ~typing.ValuesView + """ + return self._data.values() + + def items(self) -> typing.ItemsView[str, typing.Any]: + """ + :returns: set-like object providing a view on D's items + :rtype: ~typing.ItemsView + """ + return self._data.items() + + def get(self, key: str, default: typing.Any = None) -> typing.Any: + """ + Get the value for key if key is in the dictionary, else default. + :param str key: The key to look up. + :param any default: The value to return if key is not in the dictionary. Defaults to None + :returns: D[k] if k in D, else d. + :rtype: any + """ + try: + return self[key] + except KeyError: + return default + + @typing.overload + def pop(self, key: str) -> typing.Any: ... # pylint: disable=arguments-differ + + @typing.overload + def pop(self, key: str, default: _T) -> _T: ... # pylint: disable=signature-differs + + @typing.overload + def pop(self, key: str, default: typing.Any) -> typing.Any: ... # pylint: disable=signature-differs + + def pop(self, key: str, default: typing.Any = _UNSET) -> typing.Any: + """ + Removes specified key and return the corresponding value. + :param str key: The key to pop. + :param any default: The value to return if key is not in the dictionary + :returns: The value corresponding to the key. + :rtype: any + :raises KeyError: If key is not found and default is not given. + """ + if default is _UNSET: + return self._data.pop(key) + return self._data.pop(key, default) + + def popitem(self) -> tuple[str, typing.Any]: + """ + Removes and returns some (key, value) pair + :returns: The (key, value) pair. + :rtype: tuple + :raises KeyError: if D is empty. + """ + return self._data.popitem() + + def clear(self) -> None: + """ + Remove all items from D. + """ + self._data.clear() + + def update(self, *args: typing.Any, **kwargs: typing.Any) -> None: # pylint: disable=arguments-differ + """ + Updates D from mapping/iterable E and F. + :param any args: Either a mapping object or an iterable of key-value pairs. + """ + self._data.update(*args, **kwargs) + + @typing.overload + def setdefault(self, key: str, default: None = None) -> None: ... + + @typing.overload + def setdefault(self, key: str, default: typing.Any) -> typing.Any: ... # pylint: disable=signature-differs + + def setdefault(self, key: str, default: typing.Any = _UNSET) -> typing.Any: + """ + Same as calling D.get(k, d), and setting D[k]=d if k not found + :param str key: The key to look up. + :param any default: The value to set if key is not in the dictionary + :returns: D[k] if k in D, else d. + :rtype: any + """ + if default is _UNSET: + return self._data.setdefault(key) + return self._data.setdefault(key, default) + + def __eq__(self, other: typing.Any) -> bool: + if isinstance(other, _MyMutableMapping): + return self._data == other._data + try: + other_model = self.__class__(other) + except Exception: + return False + return self._data == other_model._data + + def __repr__(self) -> str: + return str(self._data) + + +def _is_model(obj: typing.Any) -> bool: + return getattr(obj, "_is_model", False) + + +def _serialize(o, format: typing.Optional[str] = None): # pylint: disable=too-many-return-statements + if isinstance(o, list): + if format in _ARRAY_ENCODE_MAPPING and all(isinstance(x, str) for x in o): + return _ARRAY_ENCODE_MAPPING[format].join(o) + return [_serialize(x, format) for x in o] + if isinstance(o, dict): + return {k: _serialize(v, format) for k, v in o.items()} + if isinstance(o, set): + return {_serialize(x, format) for x in o} + if isinstance(o, tuple): + return tuple(_serialize(x, format) for x in o) + if isinstance(o, (bytes, bytearray)): + return _serialize_bytes(o, format) + if isinstance(o, decimal.Decimal): + return float(o) + if isinstance(o, enum.Enum): + return o.value + if isinstance(o, int): + if format == "str": + return str(o) + return o + try: + # First try datetime.datetime + return _serialize_datetime(o, format) + except AttributeError: + pass + # Last, try datetime.timedelta + try: + return _timedelta_as_isostr(o) + except AttributeError: + # This will be raised when it hits value.total_seconds in the method above + pass + return o + + +def _get_rest_field(attr_to_rest_field: dict[str, "_RestField"], rest_name: str) -> typing.Optional["_RestField"]: + try: + return next(rf for rf in attr_to_rest_field.values() if rf._rest_name == rest_name) + except StopIteration: + return None + + +def _create_value(rf: typing.Optional["_RestField"], value: typing.Any) -> typing.Any: + if not rf: + return _serialize(value, None) + if rf._is_multipart_file_input: + return value + if rf._is_model: + return _deserialize(rf._type, value) + if isinstance(value, ET.Element): + value = _deserialize(rf._type, value) + return _serialize(value, rf._format) + + +# ============================================================================ +# Fast-path scalar deserializer functions for rest_field(deserializer=...) +# These are referenced from rest_field declarations to bypass the generic +# _deserialize -> _deserialize_with_callable chain. +# Only simple/primitive types — no models or container types. +# ============================================================================ + + +def _xml_deser_str(value): + if isinstance(value, ET.Element): + return value.text or "" + return str(value) if value is not None else None + + +def _xml_deser_int(value): + if isinstance(value, ET.Element): + return int(value.text) if value.text else None + return int(value) if value is not None else None + + +def _xml_deser_float(value): + if isinstance(value, ET.Element): + return float(value.text) if value.text else None + return float(value) if value is not None else None + + +def _xml_deser_bool(value): + if isinstance(value, ET.Element): + text = value.text + else: + text = value + if text is None: + return None + if text in (True, False): + return text + return text.lower() == "true" + + +# pylint: disable=docstring-missing-param +def _xml_deser_bytes(value): + """Deserialize bytes from XML (base64).""" + if isinstance(value, ET.Element): + text = value.text + else: + text = value + if text is None: + return None + return _deserialize_bytes(text) + + +def _xml_deser_bytes_base64url(value): + """Deserialize bytes from XML (base64url).""" + if isinstance(value, ET.Element): + text = value.text + else: + text = value + if text is None: + return None + return _deserialize_bytes_base64(text) + + +def _xml_deser_datetime(value): + """Deserialize a datetime from XML (ISO 8601 / rfc3339).""" + if isinstance(value, ET.Element): + text = value.text + else: + text = value + if text is None: + return None + return _deserialize_datetime(text) + + +def _xml_deser_datetime_rfc7231(value): + """Deserialize a datetime from XML (RFC7231 format).""" + if isinstance(value, ET.Element): + text = value.text + else: + text = value + if text is None: + return None + return _deserialize_datetime_rfc7231(text) + + +def _xml_deser_datetime_unix_timestamp(value): + """Deserialize a datetime from XML (Unix timestamp).""" + if isinstance(value, ET.Element): + text = value.text + else: + text = value + if text is None: + return None + return _deserialize_datetime_unix_timestamp(float(text)) + + +def _xml_deser_date(value): + """Deserialize a date from XML (ISO 8601).""" + if isinstance(value, ET.Element): + text = value.text + else: + text = value + if text is None: + return None + return _deserialize_date(text) + + +def _xml_deser_time(value): + """Deserialize a time from XML (ISO 8601).""" + if isinstance(value, ET.Element): + text = value.text + else: + text = value + if text is None: + return None + return _deserialize_time(text) + + +def _xml_deser_duration(value): + """Deserialize a timedelta from XML (ISO 8601 duration).""" + if isinstance(value, ET.Element): + text = value.text + else: + text = value + if text is None: + return None + return _deserialize_duration(text) + + +def _xml_deser_decimal(value): + """Deserialize a Decimal from XML.""" + if isinstance(value, ET.Element): + text = value.text + else: + text = value + if text is None: + return None + return _deserialize_decimal(text) + + +def _xml_deser_enum_or_str(enum_cls, value): + """Deserialize a Union[EnumType, str] from XML.""" + text = value.text if isinstance(value, ET.Element) else value + if text is None: + return None + try: + return enum_cls(text) + except ValueError: + return text + + +def _extract_xml_model_type(rf_type): + """Extract the concrete Model class from a resolved rf._type partial chain. + + Unwraps ``Optional[Model]`` and ``_deserialize_model(Model, ...)`` + wrappers. Only handles Model and Optional[Model] — other composite + types (List, Dict, Union, etc.) return None and fall through to the + generic ``_deserialize`` path at runtime. + """ + if rf_type is None: + return None + if isinstance(rf_type, type) and _is_model(rf_type): + return rf_type + if not isinstance(rf_type, functools.partial): + return None + func = rf_type.func + args = rf_type.args + if func is _deserialize_with_optional and args: + return _extract_xml_model_type(args[0]) + if func is _deserialize_model and args: + cls = args[0] + return cls if isinstance(cls, type) and _is_model(cls) else None + return None + + +def _build_xml_field_plan( # pylint: disable=docstring-missing-return, docstring-missing-rtype, unused-variable + cls, attr_to_rest_field: dict +) -> list: + """Build a precomputed XML field plan for fast _init_from_xml iteration. + + Called once per model class in __new__. Returns a list of tuples: + (rest_name, xml_name, kind, deser, rf_type, is_optional, items_name) + + kind: 0=wrapped, 1=attribute, 2=unwrapped, 3=text + + For Model and Optional[Model] fields that lack a scalar + ``_deserializer``, this function precomputes the Model class as the + deserializer so ``_init_from_xml`` can call ``ModelClass(element)`` + directly instead of going through the expensive + ``_get_deserialize_callable_from_annotation`` chain at runtime. + """ + model_meta = getattr(cls, "_xml", {}) + model_ns = model_meta.get("ns") or model_meta.get("namespace") + plan = [] + + for rf in attr_to_rest_field.values(): + prop_meta = getattr(rf, "_xml", {}) + deser = rf._deserializer + + xml_name = prop_meta.get("name", rf._rest_name) + xml_ns = _resolve_xml_ns(prop_meta, model_meta) + if xml_ns: + xml_name = "{" + xml_ns + "}" + xml_name + + is_optional = rf._is_optional + + # For Model / Optional[Model] fields without a scalar deserializer, + # precompute the Model class as the deserializer. + if deser is None and rf._type is not None: + model_cls = _extract_xml_model_type(rf._type) + if model_cls is not None: + deser = model_cls + + if prop_meta.get("attribute", False): + plan.append((rf._rest_name, xml_name, 1, deser, rf._type, is_optional, None)) + elif prop_meta.get("unwrapped", False): + items_name = prop_meta.get("itemsName") + if items_name: + items_ns = prop_meta.get("itemsNs") + if items_ns is not None: + xml_ns = items_ns + if xml_ns: + items_name = "{" + xml_ns + "}" + items_name + else: + items_name = xml_name + plan.append((rf._rest_name, xml_name, 2, deser, rf._type, is_optional, items_name)) + elif prop_meta.get("text", False): + plan.append((rf._rest_name, xml_name, 3, deser, rf._type, is_optional, None)) + else: + plan.append((rf._rest_name, xml_name, 0, deser, rf._type, is_optional, None)) + + return plan + + +# pylint: enable=docstring-missing-param +class Model(_MyMutableMapping): + _is_model = True + # label whether current class's _attr_to_rest_field has been calculated + # could not see _attr_to_rest_field directly because subclass inherits it from parent class + _calculated: set[str] = set() + + def __init__(self, *args: typing.Any, **kwargs: typing.Any) -> None: + class_name = self.__class__.__name__ + if len(args) > 1: + raise TypeError(f"{class_name}.__init__() takes 2 positional arguments but {len(args) + 1} were given") + dict_to_pass: dict[str, typing.Any] = {} + if args: + if isinstance(args[0], ET.Element): + dict_to_pass.update(self._init_from_xml(args[0])) + else: + dict_to_pass.update( + {k: _create_value(_get_rest_field(self._attr_to_rest_field, k), v) for k, v in args[0].items()} + ) + else: + non_attr_kwargs = [k for k in kwargs if k not in self._attr_to_rest_field] + if non_attr_kwargs: + # actual type errors only throw the first wrong keyword arg they see, so following that. + raise TypeError(f"{class_name}.__init__() got an unexpected keyword argument '{non_attr_kwargs[0]}'") + dict_to_pass.update( + { + self._attr_to_rest_field[k]._rest_name: _create_value(self._attr_to_rest_field[k], v) + for k, v in kwargs.items() + if v is not None + } + ) + # Apply client default values for fields the caller didn't set so that + # defaults are part of `_data` and therefore included during serialization. + for rf in self._attr_to_rest_field.values(): + if rf._default is _UNSET: + continue + if rf._rest_name in dict_to_pass: + continue + dict_to_pass[rf._rest_name] = _create_value(rf, rf._default) + super().__init__(dict_to_pass) + + def _init_from_xml( # pylint: disable=too-many-branches, too-many-statements + self, element: ET.Element + ) -> dict[str, typing.Any]: + """Deserialize an XML element into a dict mapping rest field names to values. + + :param ET.Element element: The XML element to deserialize from. + :returns: A dictionary of rest_name to deserialized value pairs. + :rtype: dict + """ + result: dict[str, typing.Any] = {} + existed_attr_keys: list[str] = [] + + field_plan = getattr(self, "_xml_field_plan", None) + if field_plan: + for rest_name, xml_name, kind, deser, rf_type, is_optional, items_name in field_plan: + if kind == 0: # wrapped element (most common) + item = element.find(xml_name) + if item is not None: + existed_attr_keys.append(xml_name) + if deser: + result[rest_name] = deser(item) + else: + result[rest_name] = _deserialize(rf_type, item) + elif kind == 1: # attribute + attr_val = element.get(xml_name) + if attr_val is not None: + existed_attr_keys.append(xml_name) + if deser: + result[rest_name] = deser(attr_val) + else: + result[rest_name] = attr_val + elif kind == 2: # unwrapped array + items = element.findall(items_name) # pyright: ignore + if len(items) > 0: + existed_attr_keys.append(items_name) + if deser: + result[rest_name] = deser(items) + else: + result[rest_name] = _deserialize(rf_type, items) + elif not is_optional: + existed_attr_keys.append(items_name) + result[rest_name] = [] + elif kind == 3: # text + if element.text is not None: + if deser: + result[rest_name] = deser(element.text) + else: + result[rest_name] = element.text + else: + model_meta = getattr(self, "_xml", {}) + for rf in self._attr_to_rest_field.values(): + prop_meta = getattr(rf, "_xml", {}) + xml_name = prop_meta.get("name", rf._rest_name) + xml_ns = _resolve_xml_ns(prop_meta, model_meta) + if xml_ns: + xml_name = "{" + xml_ns + "}" + xml_name + + # attribute + if prop_meta.get("attribute", False) and element.get(xml_name) is not None: + existed_attr_keys.append(xml_name) + result[rf._rest_name] = _deserialize(rf._type, element.get(xml_name)) + continue + + # unwrapped element is array + if prop_meta.get("unwrapped", False): + _items_name = prop_meta.get("itemsName") + if _items_name: + xml_name = _items_name + _items_ns = prop_meta.get("itemsNs") + if _items_ns is not None: + xml_ns = _items_ns + if xml_ns: + xml_name = "{" + xml_ns + "}" + xml_name + items = element.findall(xml_name) # pyright: ignore + if len(items) > 0: + existed_attr_keys.append(xml_name) + result[rf._rest_name] = _deserialize(rf._type, items) + elif not rf._is_optional: + existed_attr_keys.append(xml_name) + result[rf._rest_name] = [] + continue + + # text element is primitive type + if prop_meta.get("text", False): + if element.text is not None: + result[rf._rest_name] = _deserialize(rf._type, element.text) + continue + + # wrapped element could be normal property or array + item = element.find(xml_name) + if item is not None: + existed_attr_keys.append(xml_name) + result[rf._rest_name] = _deserialize(rf._type, item) + + # rest thing is additional properties + for e in element: + if e.tag not in existed_attr_keys: + result[e.tag] = _convert_element(e) + + return result + + def copy(self) -> "Model": + return Model(self.__dict__) + + def __new__(cls, *args: typing.Any, **kwargs: typing.Any) -> Self: + if f"{cls.__module__}.{cls.__qualname__}" not in cls._calculated: + # we know the last nine classes in mro are going to be 'Model', '_MyMutableMapping', 'MutableMapping', + # 'Mapping', 'Collection', 'Sized', 'Iterable', 'Container' and 'object' + mros = cls.__mro__[:-9][::-1] # ignore parents, and reverse the mro order + attr_to_rest_field: dict[str, _RestField] = { # map attribute name to rest_field property + k: v for mro_class in mros for k, v in mro_class.__dict__.items() if k[0] != "_" and hasattr(v, "_type") + } + annotations = { + k: v + for mro_class in mros + if hasattr(mro_class, "__annotations__") + for k, v in mro_class.__annotations__.items() + } + for attr, rf in attr_to_rest_field.items(): + rf._module = cls.__module__ + if not rf._type: + rf._type = rf._get_deserialize_callable_from_annotation(annotations.get(attr, None)) + if not rf._rest_name_input: + rf._rest_name_input = attr + cls._attr_to_rest_field: dict[str, _RestField] = dict(attr_to_rest_field.items()) + cls._backcompat_attr_to_rest_field: dict[str, _RestField] = { + Model._get_backcompat_attribute_name(cls._attr_to_rest_field, attr): rf + for attr, rf in cls._attr_to_rest_field.items() + } + # Build XML field plan for fast _init_from_xml (only for XML models) + if getattr(cls, "_xml", None): + cls._xml_field_plan = _build_xml_field_plan(cls, attr_to_rest_field) + cls._calculated.add(f"{cls.__module__}.{cls.__qualname__}") + + return super().__new__(cls) + + def __init_subclass__(cls, discriminator: typing.Optional[str] = None) -> None: + for base in cls.__bases__: + if hasattr(base, "__mapping__"): + base.__mapping__[discriminator or cls.__name__] = cls # type: ignore + + @classmethod + def _get_backcompat_attribute_name(cls, attr_to_rest_field: dict[str, "_RestField"], attr_name: str) -> str: + rest_field_obj = attr_to_rest_field.get(attr_name) # pylint: disable=protected-access + if rest_field_obj is None: + return attr_name + original_tsp_name = getattr(rest_field_obj, "_original_tsp_name", None) # pylint: disable=protected-access + if original_tsp_name: + return original_tsp_name + return attr_name + + @classmethod + def _get_discriminator(cls, exist_discriminators) -> typing.Optional["_RestField"]: + for v in cls.__dict__.values(): + if isinstance(v, _RestField) and v._is_discriminator and v._rest_name not in exist_discriminators: + return v + return None + + @classmethod + def _deserialize(cls, data, exist_discriminators): + if not hasattr(cls, "__mapping__"): + return cls(data) + discriminator = cls._get_discriminator(exist_discriminators) + if discriminator is None: + return cls(data) + exist_discriminators.append(discriminator._rest_name) + if isinstance(data, ET.Element): + model_meta = getattr(cls, "_xml", {}) + prop_meta = getattr(discriminator, "_xml", {}) + xml_name = prop_meta.get("name", discriminator._rest_name) + xml_ns = _resolve_xml_ns(prop_meta, model_meta) + if xml_ns: + xml_name = "{" + xml_ns + "}" + xml_name + + if data.get(xml_name) is not None: + discriminator_value = data.get(xml_name) + else: + discriminator_value = data.find(xml_name).text # pyright: ignore + else: + discriminator_value = data.get(discriminator._rest_name) + mapped_cls = cls.__mapping__.get(discriminator_value, cls) # pyright: ignore # pylint: disable=no-member + return mapped_cls._deserialize(data, exist_discriminators) + + def as_dict(self, *, exclude_readonly: bool = False) -> dict[str, typing.Any]: + """Return a dict that can be turned into json using json.dump. + + :keyword bool exclude_readonly: Whether to remove the readonly properties. + :returns: A dict JSON compatible object + :rtype: dict + """ + + result = {} + readonly_props = [] + if exclude_readonly: + readonly_props = [p._rest_name for p in self._attr_to_rest_field.values() if _is_readonly(p)] + for k, v in self.items(): + if exclude_readonly and k in readonly_props: # pyright: ignore + continue + is_multipart_file_input = False + try: + is_multipart_file_input = next( + rf for rf in self._attr_to_rest_field.values() if rf._rest_name == k + )._is_multipart_file_input + except StopIteration: + pass + result[k] = v if is_multipart_file_input else Model._as_dict_value(v, exclude_readonly=exclude_readonly) + return result + + @staticmethod + def _as_dict_value(v: typing.Any, exclude_readonly: bool = False) -> typing.Any: + if v is None or isinstance(v, _Null): + return None + if isinstance(v, (list, tuple, set)): + return type(v)(Model._as_dict_value(x, exclude_readonly=exclude_readonly) for x in v) + if isinstance(v, dict): + return {dk: Model._as_dict_value(dv, exclude_readonly=exclude_readonly) for dk, dv in v.items()} + return v.as_dict(exclude_readonly=exclude_readonly) if hasattr(v, "as_dict") else v + + +def _deserialize_model(model_deserializer: typing.Optional[typing.Callable], obj): + if _is_model(obj): + return obj + return _deserialize(model_deserializer, obj) + + +def _deserialize_with_optional(if_obj_deserializer: typing.Optional[typing.Callable], obj): + if obj is None: + return obj + return _deserialize_with_callable(if_obj_deserializer, obj) + + +def _deserialize_with_union(deserializers, obj): + for deserializer in deserializers: + try: + return _deserialize(deserializer, obj) + except DeserializationError: + pass + raise DeserializationError() + + +def _deserialize_dict( + value_deserializer: typing.Optional[typing.Callable], + module: typing.Optional[str], + obj: dict[typing.Any, typing.Any], +): + if obj is None: + return obj + if isinstance(obj, ET.Element): + obj = {child.tag: child for child in obj} + return {k: _deserialize(value_deserializer, v, module) for k, v in obj.items()} + + +def _deserialize_multiple_sequence( + entry_deserializers: list[typing.Optional[typing.Callable]], + module: typing.Optional[str], + obj, +): + if obj is None: + return obj + return type(obj)(_deserialize(deserializer, entry, module) for entry, deserializer in zip(obj, entry_deserializers)) + + +def _is_array_encoded_deserializer(deserializer: functools.partial) -> bool: + return ( + isinstance(deserializer, functools.partial) + and isinstance(deserializer.args[0], functools.partial) + and deserializer.args[0].func == _deserialize_array_encoded # pylint: disable=comparison-with-callable + ) + + +def _deserialize_sequence( + deserializer: typing.Optional[typing.Callable], + module: typing.Optional[str], + obj, +): + if obj is None: + return obj + if isinstance(obj, ET.Element): + obj = list(obj) + + # encoded string may be deserialized to sequence + if isinstance(obj, str) and isinstance(deserializer, functools.partial): + # for list[str] + if _is_array_encoded_deserializer(deserializer): + return deserializer(obj) + + # for list[Union[...]] + if isinstance(deserializer.args[0], list): + for sub_deserializer in deserializer.args[0]: + if _is_array_encoded_deserializer(sub_deserializer): + return sub_deserializer(obj) + + return type(obj)(_deserialize(deserializer, entry, module) for entry in obj) + + +def _sorted_annotations(types: list[typing.Any]) -> list[typing.Any]: + return sorted( + types, + key=lambda x: hasattr(x, "__name__") and x.__name__.lower() in ("str", "float", "int", "bool"), + ) + + +def _get_deserialize_callable_from_annotation( # pylint: disable=too-many-return-statements, too-many-statements, too-many-branches + annotation: typing.Any, + module: typing.Optional[str], + rf: typing.Optional["_RestField"] = None, +) -> typing.Optional[typing.Callable[[typing.Any], typing.Any]]: + if not annotation: + return None + + # is it a type alias? + if isinstance(annotation, str): + if module is not None: + annotation = _get_type_alias_type(module, annotation) + + # is it a forward ref / in quotes? + if isinstance(annotation, (str, typing.ForwardRef)): + try: + model_name = annotation.__forward_arg__ # type: ignore + except AttributeError: + model_name = annotation + if module is not None: + annotation = _get_model(module, model_name) # type: ignore + + try: + if module and _is_model(annotation): + if rf: + rf._is_model = True + + return functools.partial(_deserialize_model, annotation) # pyright: ignore + except Exception: + pass + + # is it a literal? + try: + if annotation.__origin__ is typing.Literal: # pyright: ignore + return None + except AttributeError: + pass + + # is it optional? + try: + if any(a is _NONE_TYPE for a in annotation.__args__): # pyright: ignore + if rf: + rf._is_optional = True + if len(annotation.__args__) <= 2: # pyright: ignore + if_obj_deserializer = _get_deserialize_callable_from_annotation( + next(a for a in annotation.__args__ if a is not _NONE_TYPE), module, rf # pyright: ignore + ) + + return functools.partial(_deserialize_with_optional, if_obj_deserializer) + # the type is Optional[Union[...]], we need to remove the None type from the Union + annotation_copy = copy.copy(annotation) + annotation_copy.__args__ = [a for a in annotation_copy.__args__ if a is not _NONE_TYPE] # pyright: ignore + return _get_deserialize_callable_from_annotation(annotation_copy, module, rf) + except AttributeError: + pass + + # is it union? + if getattr(annotation, "__origin__", None) is typing.Union: + # initial ordering is we make `string` the last deserialization option, because it is often them most generic + deserializers = [ + _get_deserialize_callable_from_annotation(arg, module, rf) + for arg in _sorted_annotations(annotation.__args__) # pyright: ignore + ] + + return functools.partial(_deserialize_with_union, deserializers) + + try: + annotation_name = ( + annotation.__name__ if hasattr(annotation, "__name__") else annotation._name # pyright: ignore + ) + if annotation_name.lower() == "dict": + value_deserializer = _get_deserialize_callable_from_annotation( + annotation.__args__[1], module, rf # pyright: ignore + ) + + return functools.partial( + _deserialize_dict, + value_deserializer, + module, + ) + except (AttributeError, IndexError): + pass + try: + annotation_name = ( + annotation.__name__ if hasattr(annotation, "__name__") else annotation._name # pyright: ignore + ) + if annotation_name.lower() in ["list", "set", "tuple", "sequence"]: + if len(annotation.__args__) > 1: # pyright: ignore + entry_deserializers = [ + _get_deserialize_callable_from_annotation(dt, module, rf) + for dt in annotation.__args__ # pyright: ignore + ] + return functools.partial(_deserialize_multiple_sequence, entry_deserializers, module) + deserializer = _get_deserialize_callable_from_annotation( + annotation.__args__[0], module, rf # pyright: ignore + ) + + return functools.partial(_deserialize_sequence, deserializer, module) + except (TypeError, IndexError, AttributeError, SyntaxError): + pass + + def _deserialize_default( + deserializer, + obj, + ): + if obj is None: + return obj + try: + return _deserialize_with_callable(deserializer, obj) + except Exception: + pass + return obj + + if get_deserializer(annotation, rf): + return functools.partial(_deserialize_default, get_deserializer(annotation, rf)) + + return functools.partial(_deserialize_default, annotation) + + +def _deserialize_with_callable( + deserializer: typing.Optional[typing.Callable[[typing.Any], typing.Any]], + value: typing.Any, +): # pylint: disable=too-many-return-statements + try: + if value is None or isinstance(value, _Null): + return None + if isinstance(value, ET.Element): + if deserializer is str: + return value.text or "" + if deserializer is int: + return int(value.text) if value.text else None + if deserializer is float: + return float(value.text) if value.text else None + if deserializer is bool: + return value.text == "true" if value.text else None + if deserializer and deserializer in _DESERIALIZE_MAPPING.values(): + return deserializer(value.text) if value.text else None + if deserializer and deserializer in _DESERIALIZE_MAPPING_WITHFORMAT.values(): + return deserializer(value.text) if value.text else None + if deserializer is None: + return value + if deserializer in [int, float, bool]: + return deserializer(value) + if isinstance(deserializer, CaseInsensitiveEnumMeta): + try: + return deserializer(value.text if isinstance(value, ET.Element) else value) + except ValueError: + # for unknown value, return raw value + return value.text if isinstance(value, ET.Element) else value + if isinstance(deserializer, type) and issubclass(deserializer, Model): + return deserializer._deserialize(value, []) + return typing.cast(typing.Callable[[typing.Any], typing.Any], deserializer)(value) + except Exception as e: + raise DeserializationError() from e + + +def _deserialize( + deserializer: typing.Any, + value: typing.Any, + module: typing.Optional[str] = None, + rf: typing.Optional["_RestField"] = None, + format: typing.Optional[str] = None, +) -> typing.Any: + if isinstance(value, PipelineResponse): + value = value.http_response.json() + if rf is None and format: + rf = _RestField(format=format) + if not isinstance(deserializer, functools.partial): + deserializer = _get_deserialize_callable_from_annotation(deserializer, module, rf) + return _deserialize_with_callable(deserializer, value) + + +def _failsafe_deserialize( + deserializer: typing.Any, + response: HttpResponse, + module: typing.Optional[str] = None, + rf: typing.Optional["_RestField"] = None, + format: typing.Optional[str] = None, +) -> typing.Any: + try: + return _deserialize(deserializer, response.json(), module, rf, format) + except Exception: # pylint: disable=broad-except + _LOGGER.warning( + "Ran into a deserialization error. Ignoring since this is failsafe deserialization", exc_info=True + ) + return None + + +def _failsafe_deserialize_xml( + deserializer: typing.Any, + response: HttpResponse, +) -> typing.Any: + try: + return _deserialize_xml(deserializer, response.text()) + except Exception: # pylint: disable=broad-except + _LOGGER.warning( + "Ran into a deserialization error. Ignoring since this is failsafe deserialization", exc_info=True + ) + return None + + +# pylint: disable=too-many-instance-attributes +class _RestField: + def __init__( + self, + *, + name: typing.Optional[str] = None, + type: typing.Optional[typing.Callable] = None, # pylint: disable=redefined-builtin + is_discriminator: bool = False, + visibility: typing.Optional[list[str]] = None, + default: typing.Any = _UNSET, + format: typing.Optional[str] = None, + is_multipart_file_input: bool = False, + xml: typing.Optional[dict[str, typing.Any]] = None, + deserializer: typing.Optional[typing.Callable] = None, + original_tsp_name: typing.Optional[str] = None, + ): + self._type = type + self._rest_name_input = name + self._module: typing.Optional[str] = None + self._is_discriminator = is_discriminator + self._visibility = visibility + self._is_model = False + self._is_optional = False + self._default = default + self._format = format + self._is_multipart_file_input = is_multipart_file_input + self._xml = xml if xml is not None else {} + self._deserializer = deserializer + self._original_tsp_name = original_tsp_name + + @property + def _class_type(self) -> typing.Any: + result = getattr(self._type, "args", [None])[0] + # type may be wrapped by nested functools.partial so we need to check for that + if isinstance(result, functools.partial): + return getattr(result, "args", [None])[0] + return result + + @property + def _rest_name(self) -> str: + if self._rest_name_input is None: + raise ValueError("Rest name was never set") + return self._rest_name_input + + def __get__(self, obj: Model, type=None): # pylint: disable=redefined-builtin + # by this point, type and rest_name will have a value bc we default + # them in __new__ of the Model class + # Use _data.get() directly to avoid triggering __getitem__ which clears the cache + item = obj._data.get(self._rest_name, _UNSET) + if item is _UNSET: + # Field not set by user; return the client default if one exists, otherwise None + return self._default if self._default is not _UNSET else None + if item is None: + return item + if self._is_model: + return item + + # For mutable types, we want mutations to directly affect _data + # Check if we've already deserialized this value + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + # Return the value from _data directly (it's been deserialized in place) + return obj._data.get(self._rest_name) + + # Fast path: use _deserializer directly (avoids _serialize/_deserialize chain) + if self._deserializer: + deserialized = self._deserializer(item) + else: + deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self) + + # For mutable types, store the deserialized value back in _data + # so mutations directly affect _data + if isinstance(deserialized, (dict, list, set)): + obj._data[self._rest_name] = deserialized + object.__setattr__(obj, cache_attr, True) # Mark as deserialized + return deserialized + + return deserialized + + def __set__(self, obj: Model, value) -> None: + # Clear the cached deserialized object when setting a new value + cache_attr = f"_deserialized_{self._rest_name}" + if hasattr(obj, cache_attr): + object.__delattr__(obj, cache_attr) + + if value is None: + # we want to wipe out entries if users set attr to None + try: + obj.__delitem__(self._rest_name) + except KeyError: + pass + return + if self._is_model: + if not _is_model(value): + value = _deserialize(self._type, value) + obj.__setitem__(self._rest_name, value) + return + obj.__setitem__(self._rest_name, _serialize(value, self._format)) + + def _get_deserialize_callable_from_annotation( + self, annotation: typing.Any + ) -> typing.Optional[typing.Callable[[typing.Any], typing.Any]]: + return _get_deserialize_callable_from_annotation(annotation, self._module, self) + + +def rest_field( + *, + name: typing.Optional[str] = None, + type: typing.Optional[typing.Callable] = None, # pylint: disable=redefined-builtin + visibility: typing.Optional[list[str]] = None, + default: typing.Any = _UNSET, + format: typing.Optional[str] = None, + is_multipart_file_input: bool = False, + xml: typing.Optional[dict[str, typing.Any]] = None, + deserializer: typing.Optional[typing.Callable] = None, + original_tsp_name: typing.Optional[str] = None, +) -> typing.Any: + return _RestField( + name=name, + type=type, + visibility=visibility, + default=default, + format=format, + is_multipart_file_input=is_multipart_file_input, + xml=xml, + deserializer=deserializer, + original_tsp_name=original_tsp_name, + ) + + +def rest_discriminator( + *, + name: typing.Optional[str] = None, + type: typing.Optional[typing.Callable] = None, # pylint: disable=redefined-builtin + visibility: typing.Optional[list[str]] = None, + xml: typing.Optional[dict[str, typing.Any]] = None, +) -> typing.Any: + return _RestField(name=name, type=type, is_discriminator=True, visibility=visibility, xml=xml) + + +def serialize_xml(model: Model, exclude_readonly: bool = False) -> str: + """Serialize a model to XML. + + :param Model model: The model to serialize. + :param bool exclude_readonly: Whether to exclude readonly properties. + :returns: The XML representation of the model. + :rtype: str + """ + return ET.tostring(_get_element(model, exclude_readonly), encoding="unicode") # type: ignore + + +def _get_xml_ns(meta: dict[str, typing.Any]) -> typing.Optional[str]: + """Return the XML namespace from a metadata dict, checking both 'ns' (old-style) and 'namespace' (DPG) keys. + + :param dict meta: The metadata dictionary to extract namespace from. + :returns: The namespace string if 'ns' or 'namespace' key is present, None otherwise. + :rtype: str or None + """ + ns = meta.get("ns") + if ns is None: + ns = meta.get("namespace") + return ns + + +def _resolve_xml_ns( + prop_meta: dict[str, typing.Any], model_meta: typing.Optional[dict[str, typing.Any]] = None +) -> typing.Optional[str]: + """Resolve XML namespace for a property, falling back to model namespace when appropriate. + + Checks the property metadata first; if no namespace is found and the model does not declare + an explicit prefix, falls back to the model-level namespace. + + :param dict prop_meta: The property metadata dictionary. + :param dict model_meta: The model metadata dictionary, used as fallback. + :returns: The resolved namespace string, or None. + :rtype: str or None + """ + ns = _get_xml_ns(prop_meta) + if ns is None and model_meta is not None and not model_meta.get("prefix"): + ns = _get_xml_ns(model_meta) + return ns + + +def _set_xml_attribute(element: ET.Element, name: str, value: typing.Any, prop_meta: dict[str, typing.Any]) -> None: + """Set an XML attribute on an element, handling namespace prefix registration. + + :param ET.Element element: The element to set the attribute on. + :param str name: The default attribute name (wire name). + :param any value: The attribute value. + :param dict prop_meta: The property metadata dictionary. + """ + xml_name = prop_meta.get("name", name) + _attr_ns = _get_xml_ns(prop_meta) + if _attr_ns: + _attr_prefix = prop_meta.get("prefix") + if _attr_prefix: + _safe_register_namespace(_attr_prefix, _attr_ns) + xml_name = "{" + _attr_ns + "}" + xml_name + element.set(xml_name, _get_primitive_type_value(value)) + + +def _get_element( + o: typing.Any, + exclude_readonly: bool = False, + parent_meta: typing.Optional[dict[str, typing.Any]] = None, + wrapped_element: typing.Optional[ET.Element] = None, +) -> typing.Union[ET.Element, list[ET.Element]]: + if _is_model(o): + model_meta = getattr(o, "_xml", {}) + + # if prop is a model, then use the prop element directly, else generate a wrapper of model + if wrapped_element is None: + # When serializing as an array item (parent_meta is set), check if the parent has an + # explicit itemsName. This ensures correct element names for unwrapped arrays (where + # the element tag is the property/items name, not the model type name). + _items_name = parent_meta.get("itemsName") if parent_meta is not None else None + element_name = _items_name if _items_name else (model_meta.get("name") or o.__class__.__name__) + _model_ns = _get_xml_ns(model_meta) + wrapped_element = _create_xml_element( + element_name, + model_meta.get("prefix"), + _model_ns, + ) + + readonly_props = [] + if exclude_readonly: + readonly_props = [p._rest_name for p in o._attr_to_rest_field.values() if _is_readonly(p)] + + for k, v in o.items(): + # do not serialize readonly properties + if exclude_readonly and k in readonly_props: + continue + + prop_rest_field = _get_rest_field(o._attr_to_rest_field, k) + if prop_rest_field: + prop_meta = getattr(prop_rest_field, "_xml").copy() + # use the wire name as xml name if no specific name is set + if prop_meta.get("name") is None: + prop_meta["name"] = k + else: + # additional properties will not have rest field, use the wire name as xml name + prop_meta = {"name": k} + + # Propagate model namespace to properties only for old-style "ns"-keyed models. + # DPG-generated models use the "namespace" key and explicitly declare namespace on + # each property that needs it, so propagation is intentionally skipped for them. + if prop_meta.get("ns") is None and model_meta.get("ns"): + prop_meta["ns"] = model_meta.get("ns") + prop_meta["prefix"] = model_meta.get("prefix") + + if prop_meta.get("unwrapped", False): + # unwrapped could only set on array + wrapped_element.extend(_get_element(v, exclude_readonly, prop_meta)) + elif prop_meta.get("text", False): + # text could only set on primitive type + wrapped_element.text = _get_primitive_type_value(v) + elif prop_meta.get("attribute", False): + _set_xml_attribute(wrapped_element, k, v, prop_meta) + else: + # other wrapped prop element + wrapped_element.append(_get_wrapped_element(v, exclude_readonly, prop_meta)) + return wrapped_element + if isinstance(o, list): + return [_get_element(x, exclude_readonly, parent_meta) for x in o] # type: ignore + if isinstance(o, dict): + result = [] + _dict_ns = _get_xml_ns(parent_meta) if parent_meta else None + for k, v in o.items(): + result.append( + _get_wrapped_element( + v, + exclude_readonly, + { + "name": k, + "ns": _dict_ns, + "prefix": parent_meta.get("prefix") if parent_meta else None, + }, + ) + ) + return result + + # primitive case need to create element based on parent_meta + if parent_meta: + _items_ns = parent_meta.get("itemsNs") + if _items_ns is None: + _items_ns = _get_xml_ns(parent_meta) + return _get_wrapped_element( + o, + exclude_readonly, + { + "name": parent_meta.get("itemsName", parent_meta.get("name")), + "prefix": parent_meta.get("itemsPrefix", parent_meta.get("prefix")), + "ns": _items_ns, + }, + ) + + raise ValueError("Could not serialize value into xml: " + o) + + +def _get_wrapped_element( + v: typing.Any, + exclude_readonly: bool, + meta: typing.Optional[dict[str, typing.Any]], +) -> ET.Element: + _meta_ns = _get_xml_ns(meta) if meta else None + wrapped_element = _create_xml_element( + meta.get("name") if meta else None, meta.get("prefix") if meta else None, _meta_ns + ) + if isinstance(v, (dict, list)): + wrapped_element.extend(_get_element(v, exclude_readonly, meta)) + elif _is_model(v): + _get_element(v, exclude_readonly, meta, wrapped_element) + else: + wrapped_element.text = _get_primitive_type_value(v) + return wrapped_element # type: ignore[no-any-return] + + +def _get_primitive_type_value(v) -> str: + if v is True: + return "true" + if v is False: + return "false" + if isinstance(v, _Null): + return "" + return str(v) + + +def _safe_register_namespace(prefix: str, ns: str) -> None: + """Register an XML namespace prefix, handling reserved prefix patterns. + + Some prefixes (e.g. 'ns2') match Python's reserved 'ns\\d+' pattern used for + auto-generated prefixes, causing register_namespace to raise ValueError. + Falls back to directly registering in the internal namespace map. + + :param str prefix: The namespace prefix to register. + :param str ns: The namespace URI. + """ + try: + ET.register_namespace(prefix, ns) + except ValueError: + _ns_map = getattr(ET, "_namespace_map", None) + if _ns_map is not None: + _ns_map[ns] = prefix + + +def _create_xml_element( + tag: typing.Any, prefix: typing.Optional[str] = None, ns: typing.Optional[str] = None +) -> ET.Element: + if prefix and ns: + _safe_register_namespace(prefix, ns) + if ns: + return ET.Element("{" + ns + "}" + tag) + return ET.Element(tag) + + +def _deserialize_xml( + deserializer: typing.Any, + value: str, +) -> typing.Any: + element = ET.fromstring(value) # nosec + if _is_model(deserializer): + return deserializer._deserialize(element, []) + return _deserialize(deserializer, element) + + +def _convert_element(e: ET.Element): + # dict case + if len(e.attrib) > 0 or len({child.tag for child in e}) > 1: + dict_result: dict[str, typing.Any] = {} + for child in e: + if dict_result.get(child.tag) is not None: + if isinstance(dict_result[child.tag], list): + dict_result[child.tag].append(_convert_element(child)) + else: + dict_result[child.tag] = [dict_result[child.tag], _convert_element(child)] + else: + dict_result[child.tag] = _convert_element(child) + dict_result.update(e.attrib) + return dict_result + # array case + if len(e) > 0: + array_result: list[typing.Any] = [] + for child in e: + array_result.append(_convert_element(child)) + return array_result + # primitive case + return e.text diff --git a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/_utils/serialization.py b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/_utils/serialization.py index 6da830e0cf4a..a088671e9c51 100644 --- a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/_utils/serialization.py +++ b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/_utils/serialization.py @@ -3,7 +3,7 @@ # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. +# Code generated by Microsoft (R) Python Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- @@ -39,11 +39,15 @@ import xml.etree.ElementTree as ET import isodate # type: ignore -from typing_extensions import Self from azure.core.exceptions import DeserializationError, SerializationError from azure.core.serialization import NULL as CoreNull +if sys.version_info >= (3, 11): + from typing import Self +else: + from typing_extensions import Self + _BOM = codecs.BOM_UTF8.decode(encoding="utf-8") JSON = MutableMapping[str, Any] @@ -1401,7 +1405,7 @@ def __init__(self, classes: Optional[Mapping[str, type]] = None) -> None: # Otherwise, result are unexpected self.additional_properties_detection = True - def __call__(self, target_obj, response_data, content_type=None): + def __call__(self, target_obj, response_data, content_type=None): # pylint: disable=too-many-return-statements """Call the deserializer to process a REST response. :param str target_obj: Target data type to deserialize to. @@ -1411,6 +1415,27 @@ def __call__(self, target_obj, response_data, content_type=None): :return: Deserialized object. :rtype: object """ + # Fast path for header deserialization: response_data is a plain str or None + # and target_obj is a simple scalar type. This avoids the expensive + # _unpack_content → _deserialize → _classify_target → deserialize_data chain. + if response_data is None: + return None + if target_obj == "str" and isinstance(response_data, str): + return response_data + if isinstance(response_data, str): + if target_obj == "int": + return int(response_data) + if target_obj == "bool": + if response_data in ("true", "1", "True"): + return True + if response_data in ("false", "0", "False"): + return False + return bool(response_data) + if target_obj == "rfc-1123": + return Deserializer.deserialize_rfc(response_data) + if target_obj == "bytearray": + return Deserializer.deserialize_bytearray(response_data) + data = self._unpack_content(response_data, content_type) return self._deserialize(target_obj, data) diff --git a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/_version.py b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/_version.py new file mode 100644 index 000000000000..b992dd7e5110 --- /dev/null +++ b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/_version.py @@ -0,0 +1,9 @@ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) Python Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- + +VERSION = "12.26.0b1" diff --git a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/aio/__init__.py b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/aio/__init__.py index b4f1dd31c73a..973c8f2ff212 100644 --- a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/aio/__init__.py +++ b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/aio/__init__.py @@ -2,7 +2,7 @@ # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. +# Code generated by Microsoft (R) Python Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- # pylint: disable=wrong-import-position @@ -12,7 +12,7 @@ if TYPE_CHECKING: from ._patch import * # pylint: disable=unused-wildcard-import -from ._azure_file_storage import AzureFileStorage # type: ignore +from ._client import FileClient # type: ignore try: from ._patch import __all__ as _patch_all @@ -22,7 +22,7 @@ from ._patch import patch_sdk as _patch_sdk __all__ = [ - "AzureFileStorage", + "FileClient", ] __all__.extend([p for p in _patch_all if p not in __all__]) # pyright: ignore diff --git a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/aio/_azure_file_storage.py b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/aio/_client.py similarity index 63% rename from sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/aio/_azure_file_storage.py rename to sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/aio/_client.py index 4aac6aa9a1d4..11aa09210c9c 100644 --- a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/aio/_azure_file_storage.py +++ b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/aio/_client.py @@ -2,74 +2,57 @@ # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. +# Code generated by Microsoft (R) Python Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- from copy import deepcopy -from typing import Any, Awaitable, Optional, Union -from typing_extensions import Self +import sys +from typing import Any, Awaitable, TYPE_CHECKING from azure.core import AsyncPipelineClient from azure.core.pipeline import policies from azure.core.rest import AsyncHttpResponse, HttpRequest -from .. import models as _models from .._utils.serialization import Deserializer, Serializer -from ._configuration import AzureFileStorageConfiguration +from ._configuration import FileClientConfiguration from .operations import DirectoryOperations, FileOperations, ServiceOperations, ShareOperations +if sys.version_info >= (3, 11): + from typing import Self +else: + from typing_extensions import Self # type: ignore -class AzureFileStorage: # pylint: disable=client-accepts-api-version-keyword - """AzureFileStorage. +if TYPE_CHECKING: + from azure.core.credentials_async import AsyncTokenCredential + + +class FileClient: # pylint: disable=client-accepts-api-version-keyword + """Azure File Storage provides scalable file shares in the cloud using SMB and NFS protocols. - :ivar service: ServiceOperations operations - :vartype service: azure.storage.fileshare.aio.operations.ServiceOperations - :ivar share: ShareOperations operations - :vartype share: azure.storage.fileshare.aio.operations.ShareOperations :ivar directory: DirectoryOperations operations :vartype directory: azure.storage.fileshare.aio.operations.DirectoryOperations :ivar file: FileOperations operations :vartype file: azure.storage.fileshare.aio.operations.FileOperations - :param version: Specifies the version of the operation to use for this request. Required. - :type version: str + :ivar service: ServiceOperations operations + :vartype service: azure.storage.fileshare.aio.operations.ServiceOperations + :ivar share: ShareOperations operations + :vartype share: azure.storage.fileshare.aio.operations.ShareOperations :param url: The URL of the service account, share, directory or file that is the target of the desired operation. Required. :type url: str - :param base_url: Service URL. Required. Default value is "". - :type base_url: str - :param file_request_intent: Valid value is backup. "backup" Default value is None. - :type file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent - :param allow_trailing_dot: If true, the trailing dot will not be trimmed from the target URI. - Default value is None. - :type allow_trailing_dot: bool - :param allow_source_trailing_dot: If true, the trailing dot will not be trimmed from the source - URI. Default value is None. - :type allow_source_trailing_dot: bool - :keyword file_range_write_from_url: Only update is supported: - Update: Writes the bytes - downloaded from the source url into the specified range. Default value is "update". Note that - overriding this default value may result in unsupported behavior. - :paramtype file_range_write_from_url: str + :param credential: Credential used to authenticate requests to the service. Required. + :type credential: ~azure.core.credentials_async.AsyncTokenCredential + :keyword version: Specifies the version of the operation to use for this request. Known values + are "2026-06-06" and None. Default value is None. If not set, the operation's default API + version will be used. Note that overriding this default value may result in unsupported + behavior. + :paramtype version: str """ - def __init__( # pylint: disable=missing-client-constructor-parameter-credential - self, - version: str, - url: str, - base_url: str = "", - file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, - allow_trailing_dot: Optional[bool] = None, - allow_source_trailing_dot: Optional[bool] = None, - **kwargs: Any - ) -> None: - self._config = AzureFileStorageConfiguration( - version=version, - url=url, - file_request_intent=file_request_intent, - allow_trailing_dot=allow_trailing_dot, - allow_source_trailing_dot=allow_source_trailing_dot, - **kwargs - ) + def __init__(self, url: str, credential: "AsyncTokenCredential", **kwargs: Any) -> None: + _endpoint = "{url}" + self._config = FileClientConfiguration(url=url, credential=credential, **kwargs) _policies = kwargs.pop("policies", None) if _policies is None: @@ -88,18 +71,17 @@ def __init__( # pylint: disable=missing-client-constructor-parameter-credential policies.SensitiveHeaderCleanupPolicy(**kwargs) if self._config.redirect_policy else None, self._config.http_logging_policy, ] - self._client: AsyncPipelineClient = AsyncPipelineClient(base_url=base_url, policies=_policies, **kwargs) + self._client: AsyncPipelineClient = AsyncPipelineClient(base_url=_endpoint, policies=_policies, **kwargs) - client_models = {k: v for k, v in _models.__dict__.items() if isinstance(v, type)} - self._serialize = Serializer(client_models) - self._deserialize = Deserializer(client_models) + self._serialize = Serializer() + self._deserialize = Deserializer() self._serialize.client_side_validation = False - self.service = ServiceOperations(self._client, self._config, self._serialize, self._deserialize) - self.share = ShareOperations(self._client, self._config, self._serialize, self._deserialize) self.directory = DirectoryOperations(self._client, self._config, self._serialize, self._deserialize) self.file = FileOperations(self._client, self._config, self._serialize, self._deserialize) + self.service = ServiceOperations(self._client, self._config, self._serialize, self._deserialize) + self.share = ShareOperations(self._client, self._config, self._serialize, self._deserialize) - def _send_request( + def send_request( self, request: HttpRequest, *, stream: bool = False, **kwargs: Any ) -> Awaitable[AsyncHttpResponse]: """Runs the network request through the client's chained policies. @@ -107,7 +89,7 @@ def _send_request( >>> from azure.core.rest import HttpRequest >>> request = HttpRequest("GET", "https://www.example.org/") - >>> response = await client._send_request(request) + >>> response = await client.send_request(request) For more information on this code flow, see https://aka.ms/azsdk/dpcodegen/python/send_request @@ -120,7 +102,11 @@ def _send_request( """ request_copy = deepcopy(request) - request_copy.url = self._client.format_url(request_copy.url) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + + request_copy.url = self._client.format_url(request_copy.url, **path_format_arguments) return self._client.send_request(request_copy, stream=stream, **kwargs) # type: ignore async def close(self) -> None: diff --git a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/aio/_configuration.py b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/aio/_configuration.py index bc7aa571cdd4..e0f68c0e30fd 100644 --- a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/aio/_configuration.py +++ b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/aio/_configuration.py @@ -2,67 +2,51 @@ # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. +# Code generated by Microsoft (R) Python Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- -from typing import Any, Literal, Optional, Union +from typing import Any, TYPE_CHECKING from azure.core.pipeline import policies -from .. import models as _models +from .._version import VERSION -VERSION = "unknown" +if TYPE_CHECKING: + from azure.core.credentials_async import AsyncTokenCredential -class AzureFileStorageConfiguration: # pylint: disable=too-many-instance-attributes - """Configuration for AzureFileStorage. +class FileClientConfiguration: # pylint: disable=too-many-instance-attributes + """Configuration for FileClient. Note that all parameters used to create this instance are saved as instance attributes. - :param version: Specifies the version of the operation to use for this request. Required. - :type version: str :param url: The URL of the service account, share, directory or file that is the target of the desired operation. Required. :type url: str - :param file_request_intent: Valid value is backup. "backup" Default value is None. - :type file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent - :param allow_trailing_dot: If true, the trailing dot will not be trimmed from the target URI. - Default value is None. - :type allow_trailing_dot: bool - :param allow_source_trailing_dot: If true, the trailing dot will not be trimmed from the source - URI. Default value is None. - :type allow_source_trailing_dot: bool - :keyword file_range_write_from_url: Only update is supported: - Update: Writes the bytes - downloaded from the source url into the specified range. Default value is "update". Note that - overriding this default value may result in unsupported behavior. - :paramtype file_range_write_from_url: str + :param credential: Credential used to authenticate requests to the service. Required. + :type credential: ~azure.core.credentials_async.AsyncTokenCredential + :keyword version: Specifies the version of the operation to use for this request. Known values + are "2026-06-06" and None. Default value is None. If not set, the operation's default API + version will be used. Note that overriding this default value may result in unsupported + behavior. + :paramtype version: str """ - def __init__( - self, - version: str, - url: str, - file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, - allow_trailing_dot: Optional[bool] = None, - allow_source_trailing_dot: Optional[bool] = None, - **kwargs: Any - ) -> None: - file_range_write_from_url: Literal["update"] = kwargs.pop("file_range_write_from_url", "update") + def __init__(self, url: str, credential: "AsyncTokenCredential", **kwargs: Any) -> None: + version: str = kwargs.pop("version", "2026-06-06") - if version is None: - raise ValueError("Parameter 'version' must not be None.") if url is None: raise ValueError("Parameter 'url' must not be None.") + if credential is None: + raise ValueError("Parameter 'credential' must not be None.") - self.version = version self.url = url - self.file_request_intent = file_request_intent - self.allow_trailing_dot = allow_trailing_dot - self.allow_source_trailing_dot = allow_source_trailing_dot - self.file_range_write_from_url = file_range_write_from_url - kwargs.setdefault("sdk_moniker", "azurefilestorage/{}".format(VERSION)) + self.credential = credential + self.version = version + self.credential_scopes = kwargs.pop("credential_scopes", ["https://storage.azure.com/.default"]) + kwargs.setdefault("sdk_moniker", "storage-file-share/{}".format(VERSION)) self.polling_interval = kwargs.get("polling_interval", 30) self._configure(**kwargs) @@ -76,3 +60,7 @@ def _configure(self, **kwargs: Any) -> None: self.redirect_policy = kwargs.get("redirect_policy") or policies.AsyncRedirectPolicy(**kwargs) self.retry_policy = kwargs.get("retry_policy") or policies.AsyncRetryPolicy(**kwargs) self.authentication_policy = kwargs.get("authentication_policy") + if self.credential and not self.authentication_policy: + self.authentication_policy = policies.AsyncBearerTokenCredentialPolicy( + self.credential, *self.credential_scopes, **kwargs + ) diff --git a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/aio/_patch.py b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/aio/_patch.py index f7dd32510333..af3f434c7d47 100644 --- a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/aio/_patch.py +++ b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/aio/_patch.py @@ -1,14 +1,137 @@ -# ------------------------------------ -# Copyright (c) Microsoft Corporation. -# Licensed under the MIT License. -# ------------------------------------ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# -------------------------------------------------------------------------- """Customize generated code here. Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize """ -from typing import List -__all__: List[str] = [] # Add all objects you want publicly available to users at this package level +from typing import Any, Optional, TYPE_CHECKING + +from azure.core import AsyncPipelineClient +from azure.core.pipeline import AsyncPipeline, PipelineRequest +from azure.core.pipeline.policies import SansIOHTTPPolicy +from azure.core.pipeline import policies + +from .._utils.serialization import Deserializer, Serializer +from .operations import DirectoryOperations, FileOperations, ServiceOperations, ShareOperations +from ._client import FileClient as GeneratedFileClient +from ._configuration import FileClientConfiguration as GeneratedFileClientConfiguration + +if TYPE_CHECKING: + from azure.core.credentials_async import AsyncTokenCredential + + +class RangeHeaderPolicy(SansIOHTTPPolicy): + """Policy that converts the 'Range' header to 'x-ms-range'.""" + + def on_request(self, request: PipelineRequest) -> None: + range_value = request.http_request.headers.pop("Range", None) + if range_value is not None: + request.http_request.headers["x-ms-range"] = range_value + + +class FileClientConfiguration(GeneratedFileClientConfiguration): + """Configuration for FileClient. + + Note that all parameters used to create this instance are saved as instance + attributes. + + :param url: The URL of the service account, share, directory or file that is the target of the + desired operation. Required. + :type url: str + :param credential: Credential used to authenticate requests to the service. + :type credential: ~azure.core.credentials_async.AsyncTokenCredential or None + :keyword version: Specifies the version of the operation to use for this request. Known values + are "2026-06-06". Default value is "2026-06-06". Note that overriding this default value may + result in unsupported behavior. + :paramtype version: str + """ + + def __init__(self, url: str, credential: Optional["AsyncTokenCredential"] = None, **kwargs: Any) -> None: + if url is None: + raise ValueError("Parameter 'url' must not be None.") + + version: str = kwargs.pop("version", "2026-06-06") + self.url = url + self.credential = credential + self.version = version + self.credential_scopes = kwargs.pop("credential_scopes", ["https://storage.azure.com/.default"]) + from .._version import VERSION + + kwargs.setdefault("sdk_moniker", "storage-file-share/{}".format(VERSION)) + self.polling_interval = kwargs.get("polling_interval", 30) + self._configure(**kwargs) + + +class FileClient(GeneratedFileClient): + """Azure File Storage provides scalable file shares in the cloud using SMB and NFS protocols. + + :ivar directory: DirectoryOperations operations + :vartype directory: azure.storage.fileshare.aio.operations.DirectoryOperations + :ivar file: FileOperations operations + :vartype file: azure.storage.fileshare.aio.operations.FileOperations + :ivar service: ServiceOperations operations + :vartype service: azure.storage.fileshare.aio.operations.ServiceOperations + :ivar share: ShareOperations operations + :vartype share: azure.storage.fileshare.aio.operations.ShareOperations + :param url: The URL of the service account, share, directory or file that is the target of the + desired operation. Required. + :type url: str + :param credential: Credential used to authenticate requests to the service. + :type credential: ~azure.core.credentials_async.AsyncTokenCredential or None + :keyword version: Specifies the version of the operation to use for this request. Known values + are "2026-06-06". Default value is "2026-06-06". Note that overriding this default value may + result in unsupported behavior. + :paramtype version: str + """ + + def __init__( + self, url: str, credential: Optional["AsyncTokenCredential"] = None, *, pipeline: Any = None, **kwargs: Any + ) -> None: + _endpoint = "{url}" + self._config = FileClientConfiguration(url=url, credential=credential, **kwargs) + + if pipeline is not None: + _wrapped_pipeline = AsyncPipeline( + transport=pipeline._transport, + policies=[RangeHeaderPolicy()] + list(pipeline._impl_policies), + ) + self._client = AsyncPipelineClient(base_url=_endpoint, pipeline=_wrapped_pipeline) + else: + _policies = kwargs.pop("policies", None) + if _policies is None: + _policies = [ + RangeHeaderPolicy(), + policies.RequestIdPolicy(**kwargs), + self._config.headers_policy, + self._config.user_agent_policy, + self._config.proxy_policy, + policies.ContentDecodePolicy(**kwargs), + self._config.redirect_policy, + self._config.retry_policy, + self._config.authentication_policy, + self._config.custom_hook_policy, + self._config.logging_policy, + policies.DistributedTracingPolicy(**kwargs), + policies.SensitiveHeaderCleanupPolicy(**kwargs) if self._config.redirect_policy else None, + self._config.http_logging_policy, + ] + self._client = AsyncPipelineClient(base_url=_endpoint, policies=_policies, **kwargs) + + self._serialize = Serializer() + self._deserialize = Deserializer() + self._serialize.client_side_validation = False + + self.service = ServiceOperations(self._client, self._config, self._serialize, self._deserialize) + self.share = ShareOperations(self._client, self._config, self._serialize, self._deserialize) + self.directory = DirectoryOperations(self._client, self._config, self._serialize, self._deserialize) + self.file = FileOperations(self._client, self._config, self._serialize, self._deserialize) + + +__all__: list[str] = ["FileClient"] def patch_sdk(): diff --git a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/aio/operations/__init__.py b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/aio/operations/__init__.py index 092b7efde334..9599ab012f5e 100644 --- a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/aio/operations/__init__.py +++ b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/aio/operations/__init__.py @@ -2,7 +2,7 @@ # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. +# Code generated by Microsoft (R) Python Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- # pylint: disable=wrong-import-position @@ -12,20 +12,20 @@ if TYPE_CHECKING: from ._patch import * # pylint: disable=unused-wildcard-import -from ._service_operations import ServiceOperations # type: ignore -from ._share_operations import ShareOperations # type: ignore -from ._directory_operations import DirectoryOperations # type: ignore -from ._file_operations import FileOperations # type: ignore +from ._operations import DirectoryOperations # type: ignore +from ._operations import FileOperations # type: ignore +from ._operations import ServiceOperations # type: ignore +from ._operations import ShareOperations # type: ignore from ._patch import __all__ as _patch_all from ._patch import * from ._patch import patch_sdk as _patch_sdk __all__ = [ - "ServiceOperations", - "ShareOperations", "DirectoryOperations", "FileOperations", + "ServiceOperations", + "ShareOperations", ] __all__.extend([p for p in _patch_all if p not in __all__]) # pyright: ignore _patch_sdk() diff --git a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/aio/operations/_directory_operations.py b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/aio/operations/_directory_operations.py deleted file mode 100644 index b83ffd8a6223..000000000000 --- a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/aio/operations/_directory_operations.py +++ /dev/null @@ -1,1077 +0,0 @@ -# pylint: disable=line-too-long,useless-suppression,too-many-lines -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -from collections.abc import MutableMapping -from typing import Any, Callable, Literal, Optional, TypeVar, Union - -from azure.core import AsyncPipelineClient -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.pipeline import PipelineResponse -from azure.core.rest import AsyncHttpResponse, HttpRequest -from azure.core.tracing.decorator_async import distributed_trace_async -from azure.core.utils import case_insensitive_dict - -from ... import models as _models -from ..._utils.serialization import Deserializer, Serializer -from ...operations._directory_operations import ( - build_create_request, - build_delete_request, - build_force_close_handles_request, - build_get_properties_request, - build_list_files_and_directories_segment_request, - build_list_handles_request, - build_rename_request, - build_set_metadata_request, - build_set_properties_request, -) -from .._configuration import AzureFileStorageConfiguration - -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, dict[str, Any]], Any]] - - -class DirectoryOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.storage.fileshare.aio.AzureFileStorage`'s - :attr:`directory` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs) -> None: - input_args = list(args) - self._client: AsyncPipelineClient = input_args.pop(0) if input_args else kwargs.pop("client") - self._config: AzureFileStorageConfiguration = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize: Serializer = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize: Deserializer = input_args.pop(0) if input_args else kwargs.pop("deserializer") - - @distributed_trace_async - async def create( # pylint: disable=too-many-locals - self, - timeout: Optional[int] = None, - metadata: Optional[dict[str, str]] = None, - file_permission: str = "inherit", - file_permission_format: Optional[Union[str, _models.FilePermissionFormat]] = None, - file_permission_key: Optional[str] = None, - file_attributes: str = "none", - file_creation_time: str = "now", - file_last_write_time: str = "now", - file_change_time: Optional[str] = None, - owner: Optional[str] = None, - group: Optional[str] = None, - file_mode: Optional[str] = None, - file_property_semantics: Optional[Union[str, _models.FilePropertySemantics]] = None, - **kwargs: Any - ) -> None: - """Creates a new directory under the specified share or parent directory. - - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param metadata: A name-value pair to associate with a file storage object. Default value is - None. - :type metadata: dict[str, str] - :param file_permission: If specified the permission (security descriptor) shall be set for the - directory/file. This header can be used if Permission size is <= 8KB, else - x-ms-file-permission-key header shall be used. Default value: Inherit. If SDDL is specified as - input, it must have owner, group and dacl. Note: Only one of the x-ms-file-permission or - x-ms-file-permission-key should be specified. Default value is "inherit". - :type file_permission: str - :param file_permission_format: Optional. Available for version 2023-06-01 and later. Specifies - the format in which the permission is returned. Acceptable values are SDDL or binary. If - x-ms-file-permission-format is unspecified or explicitly set to SDDL, the permission is - returned in SDDL format. If x-ms-file-permission-format is explicitly set to binary, the - permission is returned as a base64 string representing the binary encoding of the permission. - Known values are: "Sddl" and "Binary". Default value is None. - :type file_permission_format: str or ~azure.storage.fileshare.models.FilePermissionFormat - :param file_permission_key: Key of the permission to be set for the directory/file. Note: Only - one of the x-ms-file-permission or x-ms-file-permission-key should be specified. Default value - is None. - :type file_permission_key: str - :param file_attributes: If specified, the provided file attributes shall be set. Default value: - ‘Archive’ for file and ‘Directory’ for directory. ‘None’ can also be specified as default. - Default value is "none". - :type file_attributes: str - :param file_creation_time: Creation time for the file/directory. Default value: Now. Default - value is "now". - :type file_creation_time: str - :param file_last_write_time: Last write time for the file/directory. Default value: Now. - Default value is "now". - :type file_last_write_time: str - :param file_change_time: Change time for the file/directory. Default value: Now. Default value - is None. - :type file_change_time: str - :param owner: Optional, NFS only. The owner of the file or directory. Default value is None. - :type owner: str - :param group: Optional, NFS only. The owning group of the file or directory. Default value is - None. - :type group: str - :param file_mode: Optional, NFS only. The file mode of the file or directory. Default value is - None. - :type file_mode: str - :param file_property_semantics: SMB only, default value is New. New will forcefully add the - ARCHIVE attribute flag and alter the permissions specified in x-ms-file-permission to inherit - missing permissions from the parent. Restore will apply changes without further modification. - Known values are: "New" and "Restore". Default value is None. - :type file_property_semantics: str or ~azure.storage.fileshare.models.FilePropertySemantics - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - restype: Literal["directory"] = kwargs.pop("restype", _params.pop("restype", "directory")) - cls: ClsType[None] = kwargs.pop("cls", None) - - _request = build_create_request( - url=self._config.url, - version=self._config.version, - timeout=timeout, - metadata=metadata, - file_permission=file_permission, - file_permission_format=file_permission_format, - file_permission_key=file_permission_key, - file_attributes=file_attributes, - file_creation_time=file_creation_time, - file_last_write_time=file_last_write_time, - file_change_time=file_change_time, - owner=owner, - group=group, - file_mode=file_mode, - file_property_semantics=file_property_semantics, - allow_trailing_dot=self._config.allow_trailing_dot, - file_request_intent=self._config.file_request_intent, - restype=restype, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [201]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) - response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - response_headers["x-ms-request-server-encrypted"] = self._deserialize( - "bool", response.headers.get("x-ms-request-server-encrypted") - ) - response_headers["x-ms-file-permission-key"] = self._deserialize( - "str", response.headers.get("x-ms-file-permission-key") - ) - response_headers["x-ms-file-attributes"] = self._deserialize( - "str", response.headers.get("x-ms-file-attributes") - ) - response_headers["x-ms-file-creation-time"] = self._deserialize( - "str", response.headers.get("x-ms-file-creation-time") - ) - response_headers["x-ms-file-last-write-time"] = self._deserialize( - "str", response.headers.get("x-ms-file-last-write-time") - ) - response_headers["x-ms-file-change-time"] = self._deserialize( - "str", response.headers.get("x-ms-file-change-time") - ) - response_headers["x-ms-file-id"] = self._deserialize("str", response.headers.get("x-ms-file-id")) - response_headers["x-ms-file-parent-id"] = self._deserialize("str", response.headers.get("x-ms-file-parent-id")) - response_headers["x-ms-mode"] = self._deserialize("str", response.headers.get("x-ms-mode")) - response_headers["x-ms-owner"] = self._deserialize("str", response.headers.get("x-ms-owner")) - response_headers["x-ms-group"] = self._deserialize("str", response.headers.get("x-ms-group")) - response_headers["x-ms-file-file-type"] = self._deserialize("str", response.headers.get("x-ms-file-file-type")) - - if cls: - return cls(pipeline_response, None, response_headers) # type: ignore - - @distributed_trace_async - async def get_properties( - self, sharesnapshot: Optional[str] = None, timeout: Optional[int] = None, **kwargs: Any - ) -> None: - """Returns all system properties for the specified directory, and can also be used to check the - existence of a directory. The data returned does not include the files in the directory or any - subdirectories. - - :param sharesnapshot: The snapshot parameter is an opaque DateTime value that, when present, - specifies the share snapshot to query. Default value is None. - :type sharesnapshot: str - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - restype: Literal["directory"] = kwargs.pop("restype", _params.pop("restype", "directory")) - cls: ClsType[None] = kwargs.pop("cls", None) - - _request = build_get_properties_request( - url=self._config.url, - version=self._config.version, - sharesnapshot=sharesnapshot, - timeout=timeout, - allow_trailing_dot=self._config.allow_trailing_dot, - file_request_intent=self._config.file_request_intent, - restype=restype, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["x-ms-meta"] = self._deserialize("{str}", response.headers.get("x-ms-meta")) - response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) - response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - response_headers["x-ms-server-encrypted"] = self._deserialize( - "bool", response.headers.get("x-ms-server-encrypted") - ) - response_headers["x-ms-file-attributes"] = self._deserialize( - "str", response.headers.get("x-ms-file-attributes") - ) - response_headers["x-ms-file-creation-time"] = self._deserialize( - "str", response.headers.get("x-ms-file-creation-time") - ) - response_headers["x-ms-file-last-write-time"] = self._deserialize( - "str", response.headers.get("x-ms-file-last-write-time") - ) - response_headers["x-ms-file-change-time"] = self._deserialize( - "str", response.headers.get("x-ms-file-change-time") - ) - response_headers["x-ms-file-permission-key"] = self._deserialize( - "str", response.headers.get("x-ms-file-permission-key") - ) - response_headers["x-ms-file-id"] = self._deserialize("str", response.headers.get("x-ms-file-id")) - response_headers["x-ms-file-parent-id"] = self._deserialize("str", response.headers.get("x-ms-file-parent-id")) - response_headers["x-ms-mode"] = self._deserialize("str", response.headers.get("x-ms-mode")) - response_headers["x-ms-owner"] = self._deserialize("str", response.headers.get("x-ms-owner")) - response_headers["x-ms-group"] = self._deserialize("str", response.headers.get("x-ms-group")) - response_headers["x-ms-file-file-type"] = self._deserialize("str", response.headers.get("x-ms-file-file-type")) - - if cls: - return cls(pipeline_response, None, response_headers) # type: ignore - - @distributed_trace_async - async def delete(self, timeout: Optional[int] = None, **kwargs: Any) -> None: - """Removes the specified empty directory. Note that the directory must be empty before it can be - deleted. - - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - restype: Literal["directory"] = kwargs.pop("restype", _params.pop("restype", "directory")) - cls: ClsType[None] = kwargs.pop("cls", None) - - _request = build_delete_request( - url=self._config.url, - version=self._config.version, - timeout=timeout, - allow_trailing_dot=self._config.allow_trailing_dot, - file_request_intent=self._config.file_request_intent, - restype=restype, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [202]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - - if cls: - return cls(pipeline_response, None, response_headers) # type: ignore - - @distributed_trace_async - async def set_properties( # pylint: disable=too-many-locals - self, - timeout: Optional[int] = None, - file_permission: str = "inherit", - file_permission_format: Optional[Union[str, _models.FilePermissionFormat]] = None, - file_permission_key: Optional[str] = None, - file_attributes: str = "none", - file_creation_time: str = "now", - file_last_write_time: str = "now", - file_change_time: Optional[str] = None, - owner: Optional[str] = None, - group: Optional[str] = None, - file_mode: Optional[str] = None, - **kwargs: Any - ) -> None: - """Sets properties on the directory. - - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param file_permission: If specified the permission (security descriptor) shall be set for the - directory/file. This header can be used if Permission size is <= 8KB, else - x-ms-file-permission-key header shall be used. Default value: Inherit. If SDDL is specified as - input, it must have owner, group and dacl. Note: Only one of the x-ms-file-permission or - x-ms-file-permission-key should be specified. Default value is "inherit". - :type file_permission: str - :param file_permission_format: Optional. Available for version 2023-06-01 and later. Specifies - the format in which the permission is returned. Acceptable values are SDDL or binary. If - x-ms-file-permission-format is unspecified or explicitly set to SDDL, the permission is - returned in SDDL format. If x-ms-file-permission-format is explicitly set to binary, the - permission is returned as a base64 string representing the binary encoding of the permission. - Known values are: "Sddl" and "Binary". Default value is None. - :type file_permission_format: str or ~azure.storage.fileshare.models.FilePermissionFormat - :param file_permission_key: Key of the permission to be set for the directory/file. Note: Only - one of the x-ms-file-permission or x-ms-file-permission-key should be specified. Default value - is None. - :type file_permission_key: str - :param file_attributes: If specified, the provided file attributes shall be set. Default value: - ‘Archive’ for file and ‘Directory’ for directory. ‘None’ can also be specified as default. - Default value is "none". - :type file_attributes: str - :param file_creation_time: Creation time for the file/directory. Default value: Now. Default - value is "now". - :type file_creation_time: str - :param file_last_write_time: Last write time for the file/directory. Default value: Now. - Default value is "now". - :type file_last_write_time: str - :param file_change_time: Change time for the file/directory. Default value: Now. Default value - is None. - :type file_change_time: str - :param owner: Optional, NFS only. The owner of the file or directory. Default value is None. - :type owner: str - :param group: Optional, NFS only. The owning group of the file or directory. Default value is - None. - :type group: str - :param file_mode: Optional, NFS only. The file mode of the file or directory. Default value is - None. - :type file_mode: str - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - restype: Literal["directory"] = kwargs.pop("restype", _params.pop("restype", "directory")) - comp: Literal["properties"] = kwargs.pop("comp", _params.pop("comp", "properties")) - cls: ClsType[None] = kwargs.pop("cls", None) - - _request = build_set_properties_request( - url=self._config.url, - version=self._config.version, - timeout=timeout, - file_permission=file_permission, - file_permission_format=file_permission_format, - file_permission_key=file_permission_key, - file_attributes=file_attributes, - file_creation_time=file_creation_time, - file_last_write_time=file_last_write_time, - file_change_time=file_change_time, - owner=owner, - group=group, - file_mode=file_mode, - allow_trailing_dot=self._config.allow_trailing_dot, - file_request_intent=self._config.file_request_intent, - restype=restype, - comp=comp, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - response_headers["x-ms-request-server-encrypted"] = self._deserialize( - "bool", response.headers.get("x-ms-request-server-encrypted") - ) - response_headers["x-ms-file-permission-key"] = self._deserialize( - "str", response.headers.get("x-ms-file-permission-key") - ) - response_headers["x-ms-file-attributes"] = self._deserialize( - "str", response.headers.get("x-ms-file-attributes") - ) - response_headers["x-ms-file-creation-time"] = self._deserialize( - "str", response.headers.get("x-ms-file-creation-time") - ) - response_headers["x-ms-file-last-write-time"] = self._deserialize( - "str", response.headers.get("x-ms-file-last-write-time") - ) - response_headers["x-ms-file-change-time"] = self._deserialize( - "str", response.headers.get("x-ms-file-change-time") - ) - response_headers["x-ms-file-id"] = self._deserialize("str", response.headers.get("x-ms-file-id")) - response_headers["x-ms-file-parent-id"] = self._deserialize("str", response.headers.get("x-ms-file-parent-id")) - response_headers["x-ms-mode"] = self._deserialize("str", response.headers.get("x-ms-mode")) - response_headers["x-ms-owner"] = self._deserialize("str", response.headers.get("x-ms-owner")) - response_headers["x-ms-group"] = self._deserialize("str", response.headers.get("x-ms-group")) - - if cls: - return cls(pipeline_response, None, response_headers) # type: ignore - - @distributed_trace_async - async def set_metadata( - self, timeout: Optional[int] = None, metadata: Optional[dict[str, str]] = None, **kwargs: Any - ) -> None: - """Updates user defined metadata for the specified directory. - - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param metadata: A name-value pair to associate with a file storage object. Default value is - None. - :type metadata: dict[str, str] - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - restype: Literal["directory"] = kwargs.pop("restype", _params.pop("restype", "directory")) - comp: Literal["metadata"] = kwargs.pop("comp", _params.pop("comp", "metadata")) - cls: ClsType[None] = kwargs.pop("cls", None) - - _request = build_set_metadata_request( - url=self._config.url, - version=self._config.version, - timeout=timeout, - metadata=metadata, - allow_trailing_dot=self._config.allow_trailing_dot, - file_request_intent=self._config.file_request_intent, - restype=restype, - comp=comp, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - response_headers["x-ms-request-server-encrypted"] = self._deserialize( - "bool", response.headers.get("x-ms-request-server-encrypted") - ) - - if cls: - return cls(pipeline_response, None, response_headers) # type: ignore - - @distributed_trace_async - async def list_files_and_directories_segment( - self, - prefix: Optional[str] = None, - sharesnapshot: Optional[str] = None, - marker: Optional[str] = None, - maxresults: Optional[int] = None, - timeout: Optional[int] = None, - include: Optional[list[Union[str, _models.ListFilesIncludeType]]] = None, - include_extended_info: Optional[bool] = None, - **kwargs: Any - ) -> _models.ListFilesAndDirectoriesSegmentResponse: - """Returns a list of files or directories under the specified share or directory. It lists the - contents only for a single level of the directory hierarchy. - - :param prefix: Filters the results to return only entries whose name begins with the specified - prefix. Default value is None. - :type prefix: str - :param sharesnapshot: The snapshot parameter is an opaque DateTime value that, when present, - specifies the share snapshot to query. Default value is None. - :type sharesnapshot: str - :param marker: A string value that identifies the portion of the list to be returned with the - next list operation. The operation returns a marker value within the response body if the list - returned was not complete. The marker value may then be used in a subsequent call to request - the next set of list items. The marker value is opaque to the client. Default value is None. - :type marker: str - :param maxresults: Specifies the maximum number of entries to return. If the request does not - specify maxresults, or specifies a value greater than 5,000, the server will return up to 5,000 - items. Default value is None. - :type maxresults: int - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param include: Include this parameter to specify one or more datasets to include in the - response. Default value is None. - :type include: list[str or ~azure.storage.fileshare.models.ListFilesIncludeType] - :param include_extended_info: Include extended information. Default value is None. - :type include_extended_info: bool - :return: ListFilesAndDirectoriesSegmentResponse or the result of cls(response) - :rtype: ~azure.storage.fileshare.models.ListFilesAndDirectoriesSegmentResponse - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - restype: Literal["directory"] = kwargs.pop("restype", _params.pop("restype", "directory")) - comp: Literal["list"] = kwargs.pop("comp", _params.pop("comp", "list")) - cls: ClsType[_models.ListFilesAndDirectoriesSegmentResponse] = kwargs.pop("cls", None) - - _request = build_list_files_and_directories_segment_request( - url=self._config.url, - version=self._config.version, - prefix=prefix, - sharesnapshot=sharesnapshot, - marker=marker, - maxresults=maxresults, - timeout=timeout, - include=include, - include_extended_info=include_extended_info, - allow_trailing_dot=self._config.allow_trailing_dot, - file_request_intent=self._config.file_request_intent, - restype=restype, - comp=comp, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["Content-Type"] = self._deserialize("str", response.headers.get("Content-Type")) - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - - deserialized = self._deserialize("ListFilesAndDirectoriesSegmentResponse", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @distributed_trace_async - async def list_handles( - self, - marker: Optional[str] = None, - maxresults: Optional[int] = None, - timeout: Optional[int] = None, - sharesnapshot: Optional[str] = None, - recursive: Optional[bool] = None, - **kwargs: Any - ) -> _models.ListHandlesResponse: - """Lists handles for directory. - - :param marker: A string value that identifies the portion of the list to be returned with the - next list operation. The operation returns a marker value within the response body if the list - returned was not complete. The marker value may then be used in a subsequent call to request - the next set of list items. The marker value is opaque to the client. Default value is None. - :type marker: str - :param maxresults: Specifies the maximum number of entries to return. If the request does not - specify maxresults, or specifies a value greater than 5,000, the server will return up to 5,000 - items. Default value is None. - :type maxresults: int - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param sharesnapshot: The snapshot parameter is an opaque DateTime value that, when present, - specifies the share snapshot to query. Default value is None. - :type sharesnapshot: str - :param recursive: Specifies operation should apply to the directory specified in the URI, its - files, its subdirectories and their files. Default value is None. - :type recursive: bool - :return: ListHandlesResponse or the result of cls(response) - :rtype: ~azure.storage.fileshare.models.ListHandlesResponse - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - comp: Literal["listhandles"] = kwargs.pop("comp", _params.pop("comp", "listhandles")) - cls: ClsType[_models.ListHandlesResponse] = kwargs.pop("cls", None) - - _request = build_list_handles_request( - url=self._config.url, - version=self._config.version, - marker=marker, - maxresults=maxresults, - timeout=timeout, - sharesnapshot=sharesnapshot, - recursive=recursive, - allow_trailing_dot=self._config.allow_trailing_dot, - file_request_intent=self._config.file_request_intent, - comp=comp, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["Content-Type"] = self._deserialize("str", response.headers.get("Content-Type")) - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - - deserialized = self._deserialize("ListHandlesResponse", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @distributed_trace_async - async def force_close_handles( - self, - handle_id: str, - timeout: Optional[int] = None, - marker: Optional[str] = None, - sharesnapshot: Optional[str] = None, - recursive: Optional[bool] = None, - **kwargs: Any - ) -> None: - """Closes all handles open for given directory. - - :param handle_id: Specifies handle ID opened on the file or directory to be closed. Asterisk - (‘*’) is a wildcard that specifies all handles. Required. - :type handle_id: str - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param marker: A string value that identifies the portion of the list to be returned with the - next list operation. The operation returns a marker value within the response body if the list - returned was not complete. The marker value may then be used in a subsequent call to request - the next set of list items. The marker value is opaque to the client. Default value is None. - :type marker: str - :param sharesnapshot: The snapshot parameter is an opaque DateTime value that, when present, - specifies the share snapshot to query. Default value is None. - :type sharesnapshot: str - :param recursive: Specifies operation should apply to the directory specified in the URI, its - files, its subdirectories and their files. Default value is None. - :type recursive: bool - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - comp: Literal["forceclosehandles"] = kwargs.pop("comp", _params.pop("comp", "forceclosehandles")) - cls: ClsType[None] = kwargs.pop("cls", None) - - _request = build_force_close_handles_request( - url=self._config.url, - handle_id=handle_id, - version=self._config.version, - timeout=timeout, - marker=marker, - sharesnapshot=sharesnapshot, - recursive=recursive, - allow_trailing_dot=self._config.allow_trailing_dot, - file_request_intent=self._config.file_request_intent, - comp=comp, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - response_headers["x-ms-marker"] = self._deserialize("str", response.headers.get("x-ms-marker")) - response_headers["x-ms-number-of-handles-closed"] = self._deserialize( - "int", response.headers.get("x-ms-number-of-handles-closed") - ) - response_headers["x-ms-number-of-handles-failed"] = self._deserialize( - "int", response.headers.get("x-ms-number-of-handles-failed") - ) - - if cls: - return cls(pipeline_response, None, response_headers) # type: ignore - - @distributed_trace_async - async def rename( # pylint: disable=too-many-locals - self, - rename_source: str, - timeout: Optional[int] = None, - replace_if_exists: Optional[bool] = None, - ignore_read_only: Optional[bool] = None, - file_permission: str = "inherit", - file_permission_format: Optional[Union[str, _models.FilePermissionFormat]] = None, - file_permission_key: Optional[str] = None, - metadata: Optional[dict[str, str]] = None, - source_lease_access_conditions: Optional[_models.SourceLeaseAccessConditions] = None, - destination_lease_access_conditions: Optional[_models.DestinationLeaseAccessConditions] = None, - copy_file_smb_info: Optional[_models.CopyFileSmbInfo] = None, - **kwargs: Any - ) -> None: - """Renames a directory. - - :param rename_source: Required. Specifies the URI-style path of the source file, up to 2 KB in - length. Required. - :type rename_source: str - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param replace_if_exists: Optional. A boolean value for if the destination file already exists, - whether this request will overwrite the file or not. If true, the rename will succeed and will - overwrite the destination file. If not provided or if false and the destination file does - exist, the request will not overwrite the destination file. If provided and the destination - file doesn’t exist, the rename will succeed. Note: This value does not override the - x-ms-file-copy-ignore-read-only header value. Default value is None. - :type replace_if_exists: bool - :param ignore_read_only: Optional. A boolean value that specifies whether the ReadOnly - attribute on a preexisting destination file should be respected. If true, the rename will - succeed, otherwise, a previous file at the destination with the ReadOnly attribute set will - cause the rename to fail. Default value is None. - :type ignore_read_only: bool - :param file_permission: If specified the permission (security descriptor) shall be set for the - directory/file. This header can be used if Permission size is <= 8KB, else - x-ms-file-permission-key header shall be used. Default value: Inherit. If SDDL is specified as - input, it must have owner, group and dacl. Note: Only one of the x-ms-file-permission or - x-ms-file-permission-key should be specified. Default value is "inherit". - :type file_permission: str - :param file_permission_format: Optional. Available for version 2023-06-01 and later. Specifies - the format in which the permission is returned. Acceptable values are SDDL or binary. If - x-ms-file-permission-format is unspecified or explicitly set to SDDL, the permission is - returned in SDDL format. If x-ms-file-permission-format is explicitly set to binary, the - permission is returned as a base64 string representing the binary encoding of the permission. - Known values are: "Sddl" and "Binary". Default value is None. - :type file_permission_format: str or ~azure.storage.fileshare.models.FilePermissionFormat - :param file_permission_key: Key of the permission to be set for the directory/file. Note: Only - one of the x-ms-file-permission or x-ms-file-permission-key should be specified. Default value - is None. - :type file_permission_key: str - :param metadata: A name-value pair to associate with a file storage object. Default value is - None. - :type metadata: dict[str, str] - :param source_lease_access_conditions: Parameter group. Default value is None. - :type source_lease_access_conditions: - ~azure.storage.fileshare.models.SourceLeaseAccessConditions - :param destination_lease_access_conditions: Parameter group. Default value is None. - :type destination_lease_access_conditions: - ~azure.storage.fileshare.models.DestinationLeaseAccessConditions - :param copy_file_smb_info: Parameter group. Default value is None. - :type copy_file_smb_info: ~azure.storage.fileshare.models.CopyFileSmbInfo - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - restype: Literal["directory"] = kwargs.pop("restype", _params.pop("restype", "directory")) - comp: Literal["rename"] = kwargs.pop("comp", _params.pop("comp", "rename")) - cls: ClsType[None] = kwargs.pop("cls", None) - - _source_lease_id = None - _destination_lease_id = None - _file_attributes = None - _file_creation_time = None - _file_last_write_time = None - _file_change_time = None - if source_lease_access_conditions is not None: - _source_lease_id = source_lease_access_conditions.source_lease_id - if destination_lease_access_conditions is not None: - _destination_lease_id = destination_lease_access_conditions.destination_lease_id - if copy_file_smb_info is not None: - _file_attributes = copy_file_smb_info.file_attributes - _file_change_time = copy_file_smb_info.file_change_time - _file_creation_time = copy_file_smb_info.file_creation_time - _file_last_write_time = copy_file_smb_info.file_last_write_time - - _request = build_rename_request( - url=self._config.url, - rename_source=rename_source, - version=self._config.version, - timeout=timeout, - replace_if_exists=replace_if_exists, - ignore_read_only=ignore_read_only, - source_lease_id=_source_lease_id, - destination_lease_id=_destination_lease_id, - file_attributes=_file_attributes, - file_creation_time=_file_creation_time, - file_last_write_time=_file_last_write_time, - file_change_time=_file_change_time, - file_permission=file_permission, - file_permission_format=file_permission_format, - file_permission_key=file_permission_key, - metadata=metadata, - allow_trailing_dot=self._config.allow_trailing_dot, - allow_source_trailing_dot=self._config.allow_source_trailing_dot, - file_request_intent=self._config.file_request_intent, - restype=restype, - comp=comp, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) - response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - response_headers["x-ms-request-server-encrypted"] = self._deserialize( - "bool", response.headers.get("x-ms-request-server-encrypted") - ) - response_headers["x-ms-file-permission-key"] = self._deserialize( - "str", response.headers.get("x-ms-file-permission-key") - ) - response_headers["x-ms-file-attributes"] = self._deserialize( - "str", response.headers.get("x-ms-file-attributes") - ) - response_headers["x-ms-file-creation-time"] = self._deserialize( - "str", response.headers.get("x-ms-file-creation-time") - ) - response_headers["x-ms-file-last-write-time"] = self._deserialize( - "str", response.headers.get("x-ms-file-last-write-time") - ) - response_headers["x-ms-file-change-time"] = self._deserialize( - "str", response.headers.get("x-ms-file-change-time") - ) - response_headers["x-ms-file-id"] = self._deserialize("str", response.headers.get("x-ms-file-id")) - response_headers["x-ms-file-parent-id"] = self._deserialize("str", response.headers.get("x-ms-file-parent-id")) - - if cls: - return cls(pipeline_response, None, response_headers) # type: ignore diff --git a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/aio/operations/_file_operations.py b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/aio/operations/_file_operations.py deleted file mode 100644 index 1f6bc63e53c0..000000000000 --- a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/aio/operations/_file_operations.py +++ /dev/null @@ -1,2605 +0,0 @@ -# pylint: disable=line-too-long,useless-suppression,too-many-lines -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -from collections.abc import MutableMapping -from typing import Any, AsyncIterator, Callable, IO, Literal, Optional, TypeVar, Union - -from azure.core import AsyncPipelineClient -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - StreamClosedError, - StreamConsumedError, - map_error, -) -from azure.core.pipeline import PipelineResponse -from azure.core.rest import AsyncHttpResponse, HttpRequest -from azure.core.tracing.decorator_async import distributed_trace_async -from azure.core.utils import case_insensitive_dict - -from ... import models as _models -from ..._utils.serialization import Deserializer, Serializer -from ...operations._file_operations import ( - build_abort_copy_request, - build_acquire_lease_request, - build_break_lease_request, - build_change_lease_request, - build_create_hard_link_request, - build_create_request, - build_create_symbolic_link_request, - build_delete_request, - build_download_request, - build_force_close_handles_request, - build_get_properties_request, - build_get_range_list_request, - build_get_symbolic_link_request, - build_list_handles_request, - build_release_lease_request, - build_rename_request, - build_set_http_headers_request, - build_set_metadata_request, - build_start_copy_request, - build_upload_range_from_url_request, - build_upload_range_request, -) -from .._configuration import AzureFileStorageConfiguration - -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, dict[str, Any]], Any]] - - -class FileOperations: # pylint: disable=too-many-public-methods - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.storage.fileshare.aio.AzureFileStorage`'s - :attr:`file` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs) -> None: - input_args = list(args) - self._client: AsyncPipelineClient = input_args.pop(0) if input_args else kwargs.pop("client") - self._config: AzureFileStorageConfiguration = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize: Serializer = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize: Deserializer = input_args.pop(0) if input_args else kwargs.pop("deserializer") - - @distributed_trace_async - async def create( # pylint: disable=too-many-locals - self, - file_content_length: int, - timeout: Optional[int] = None, - metadata: Optional[dict[str, str]] = None, - file_permission: str = "inherit", - file_permission_format: Optional[Union[str, _models.FilePermissionFormat]] = None, - file_permission_key: Optional[str] = None, - file_attributes: str = "none", - file_creation_time: str = "now", - file_last_write_time: str = "now", - file_change_time: Optional[str] = None, - owner: Optional[str] = None, - group: Optional[str] = None, - file_mode: Optional[str] = None, - nfs_file_type: Optional[Union[str, _models.NfsFileType]] = None, - content_md5: Optional[bytes] = None, - file_property_semantics: Optional[Union[str, _models.FilePropertySemantics]] = None, - content_length: Optional[int] = None, - structured_body_type: Optional[str] = None, - structured_content_length: Optional[int] = None, - file_http_headers: Optional[_models.FileHTTPHeaders] = None, - lease_access_conditions: Optional[_models.LeaseAccessConditions] = None, - optionalbody: Optional[IO[bytes]] = None, - **kwargs: Any - ) -> None: - """Creates a new file or replaces a file. Can also initialize the file with content. - - :param file_content_length: Specifies the maximum size for the file, up to 4 TB. Required. - :type file_content_length: int - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param metadata: A name-value pair to associate with a file storage object. Default value is - None. - :type metadata: dict[str, str] - :param file_permission: If specified the permission (security descriptor) shall be set for the - directory/file. This header can be used if Permission size is <= 8KB, else - x-ms-file-permission-key header shall be used. Default value: Inherit. If SDDL is specified as - input, it must have owner, group and dacl. Note: Only one of the x-ms-file-permission or - x-ms-file-permission-key should be specified. Default value is "inherit". - :type file_permission: str - :param file_permission_format: Optional. Available for version 2023-06-01 and later. Specifies - the format in which the permission is returned. Acceptable values are SDDL or binary. If - x-ms-file-permission-format is unspecified or explicitly set to SDDL, the permission is - returned in SDDL format. If x-ms-file-permission-format is explicitly set to binary, the - permission is returned as a base64 string representing the binary encoding of the permission. - Known values are: "Sddl" and "Binary". Default value is None. - :type file_permission_format: str or ~azure.storage.fileshare.models.FilePermissionFormat - :param file_permission_key: Key of the permission to be set for the directory/file. Note: Only - one of the x-ms-file-permission or x-ms-file-permission-key should be specified. Default value - is None. - :type file_permission_key: str - :param file_attributes: If specified, the provided file attributes shall be set. Default value: - ‘Archive’ for file and ‘Directory’ for directory. ‘None’ can also be specified as default. - Default value is "none". - :type file_attributes: str - :param file_creation_time: Creation time for the file/directory. Default value: Now. Default - value is "now". - :type file_creation_time: str - :param file_last_write_time: Last write time for the file/directory. Default value: Now. - Default value is "now". - :type file_last_write_time: str - :param file_change_time: Change time for the file/directory. Default value: Now. Default value - is None. - :type file_change_time: str - :param owner: Optional, NFS only. The owner of the file or directory. Default value is None. - :type owner: str - :param group: Optional, NFS only. The owning group of the file or directory. Default value is - None. - :type group: str - :param file_mode: Optional, NFS only. The file mode of the file or directory. Default value is - None. - :type file_mode: str - :param nfs_file_type: Optional, NFS only. Type of the file or directory. Known values are: - "Regular", "Directory", and "SymLink". Default value is None. - :type nfs_file_type: str or ~azure.storage.fileshare.models.NfsFileType - :param content_md5: An MD5 hash of the content. This hash is used to verify the integrity of - the data during transport. When the Content-MD5 header is specified, the File service compares - the hash of the content that has arrived with the header value that was sent. If the two hashes - do not match, the operation will fail with error code 400 (Bad Request). Default value is None. - :type content_md5: bytes - :param file_property_semantics: SMB only, default value is New. New will forcefully add the - ARCHIVE attribute flag and alter the permissions specified in x-ms-file-permission to inherit - missing permissions from the parent. Restore will apply changes without further modification. - Known values are: "New" and "Restore". Default value is None. - :type file_property_semantics: str or ~azure.storage.fileshare.models.FilePropertySemantics - :param content_length: Specifies the number of bytes being transmitted in the request body. - When the x-ms-write header is set to clear, the value of this header must be set to zero. - Default value is None. - :type content_length: int - :param structured_body_type: Required if the request body is a structured message. Specifies - the message schema version and properties. Default value is None. - :type structured_body_type: str - :param structured_content_length: Required if the request body is a structured message. - Specifies the length of the blob/file content inside the message body. Will always be smaller - than Content-Length. Default value is None. - :type structured_content_length: int - :param file_http_headers: Parameter group. Default value is None. - :type file_http_headers: ~azure.storage.fileshare.models.FileHTTPHeaders - :param lease_access_conditions: Parameter group. Default value is None. - :type lease_access_conditions: ~azure.storage.fileshare.models.LeaseAccessConditions - :param optionalbody: Initial data. Default value is None. - :type optionalbody: IO[bytes] - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = kwargs.pop("params", {}) or {} - - file_type_constant: Literal["file"] = kwargs.pop("file_type_constant", _headers.pop("x-ms-type", "file")) - content_type: Optional[str] = kwargs.pop( - "content_type", _headers.pop("Content-Type", "application/octet-stream") - ) - content_type = content_type if optionalbody else None - cls: ClsType[None] = kwargs.pop("cls", None) - - _file_content_type = None - _file_content_encoding = None - _file_content_language = None - _file_cache_control = None - _file_content_md5 = None - _file_content_disposition = None - _lease_id = None - if file_http_headers is not None: - _file_cache_control = file_http_headers.file_cache_control - _file_content_disposition = file_http_headers.file_content_disposition - _file_content_encoding = file_http_headers.file_content_encoding - _file_content_language = file_http_headers.file_content_language - _file_content_md5 = file_http_headers.file_content_md5 - _file_content_type = file_http_headers.file_content_type - if lease_access_conditions is not None: - _lease_id = lease_access_conditions.lease_id - _content = optionalbody - - _request = build_create_request( - url=self._config.url, - file_content_length=file_content_length, - version=self._config.version, - timeout=timeout, - file_content_type=_file_content_type, - file_content_encoding=_file_content_encoding, - file_content_language=_file_content_language, - file_cache_control=_file_cache_control, - file_content_md5=_file_content_md5, - file_content_disposition=_file_content_disposition, - metadata=metadata, - file_permission=file_permission, - file_permission_format=file_permission_format, - file_permission_key=file_permission_key, - file_attributes=file_attributes, - file_creation_time=file_creation_time, - file_last_write_time=file_last_write_time, - file_change_time=file_change_time, - lease_id=_lease_id, - owner=owner, - group=group, - file_mode=file_mode, - nfs_file_type=nfs_file_type, - content_md5=content_md5, - file_property_semantics=file_property_semantics, - content_length=content_length, - structured_body_type=structured_body_type, - structured_content_length=structured_content_length, - allow_trailing_dot=self._config.allow_trailing_dot, - file_request_intent=self._config.file_request_intent, - file_type_constant=file_type_constant, - content_type=content_type, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [201]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) - response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - response_headers["x-ms-request-server-encrypted"] = self._deserialize( - "bool", response.headers.get("x-ms-request-server-encrypted") - ) - response_headers["x-ms-file-permission-key"] = self._deserialize( - "str", response.headers.get("x-ms-file-permission-key") - ) - response_headers["x-ms-file-attributes"] = self._deserialize( - "str", response.headers.get("x-ms-file-attributes") - ) - response_headers["x-ms-file-creation-time"] = self._deserialize( - "str", response.headers.get("x-ms-file-creation-time") - ) - response_headers["x-ms-file-last-write-time"] = self._deserialize( - "str", response.headers.get("x-ms-file-last-write-time") - ) - response_headers["x-ms-file-change-time"] = self._deserialize( - "str", response.headers.get("x-ms-file-change-time") - ) - response_headers["x-ms-file-id"] = self._deserialize("str", response.headers.get("x-ms-file-id")) - response_headers["x-ms-file-parent-id"] = self._deserialize("str", response.headers.get("x-ms-file-parent-id")) - response_headers["x-ms-mode"] = self._deserialize("str", response.headers.get("x-ms-mode")) - response_headers["x-ms-owner"] = self._deserialize("str", response.headers.get("x-ms-owner")) - response_headers["x-ms-group"] = self._deserialize("str", response.headers.get("x-ms-group")) - response_headers["x-ms-file-file-type"] = self._deserialize("str", response.headers.get("x-ms-file-file-type")) - response_headers["Content-MD5"] = self._deserialize("bytearray", response.headers.get("Content-MD5")) - response_headers["Content-Length"] = self._deserialize("int", response.headers.get("Content-Length")) - response_headers["x-ms-structured-body"] = self._deserialize( - "str", response.headers.get("x-ms-structured-body") - ) - - if cls: - return cls(pipeline_response, None, response_headers) # type: ignore - - @distributed_trace_async - async def download( - self, - timeout: Optional[int] = None, - range: Optional[str] = None, - range_get_content_md5: Optional[bool] = None, - structured_body_type: Optional[str] = None, - lease_access_conditions: Optional[_models.LeaseAccessConditions] = None, - **kwargs: Any - ) -> AsyncIterator[bytes]: - """Reads or downloads a file from the system, including its metadata and properties. - - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param range: Return file data only from the specified byte range. Default value is None. - :type range: str - :param range_get_content_md5: When this header is set to true and specified together with the - Range header, the service returns the MD5 hash for the range, as long as the range is less than - or equal to 4 MB in size. Default value is None. - :type range_get_content_md5: bool - :param structured_body_type: Specifies the response content should be returned as a structured - message and specifies the message schema version and properties. Default value is None. - :type structured_body_type: str - :param lease_access_conditions: Parameter group. Default value is None. - :type lease_access_conditions: ~azure.storage.fileshare.models.LeaseAccessConditions - :return: AsyncIterator[bytes] or the result of cls(response) - :rtype: AsyncIterator[bytes] - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = kwargs.pop("params", {}) or {} - - cls: ClsType[AsyncIterator[bytes]] = kwargs.pop("cls", None) - - _lease_id = None - if lease_access_conditions is not None: - _lease_id = lease_access_conditions.lease_id - - _request = build_download_request( - url=self._config.url, - version=self._config.version, - timeout=timeout, - range=range, - range_get_content_md5=range_get_content_md5, - structured_body_type=structured_body_type, - lease_id=_lease_id, - allow_trailing_dot=self._config.allow_trailing_dot, - file_request_intent=self._config.file_request_intent, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _decompress = kwargs.pop("decompress", True) - _stream = True - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 206]: - try: - await response.read() # Load the body in memory and close the socket - except (StreamConsumedError, StreamClosedError): - pass - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) - response_headers["x-ms-meta"] = self._deserialize("{str}", response.headers.get("x-ms-meta")) - response_headers["Content-Length"] = self._deserialize("int", response.headers.get("Content-Length")) - response_headers["Content-Type"] = self._deserialize("str", response.headers.get("Content-Type")) - response_headers["Content-Range"] = self._deserialize("str", response.headers.get("Content-Range")) - response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) - response_headers["Content-MD5"] = self._deserialize("bytearray", response.headers.get("Content-MD5")) - response_headers["Content-Encoding"] = self._deserialize("str", response.headers.get("Content-Encoding")) - response_headers["Cache-Control"] = self._deserialize("str", response.headers.get("Cache-Control")) - response_headers["Content-Disposition"] = self._deserialize("str", response.headers.get("Content-Disposition")) - response_headers["Content-Language"] = self._deserialize("str", response.headers.get("Content-Language")) - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Accept-Ranges"] = self._deserialize("str", response.headers.get("Accept-Ranges")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - response_headers["x-ms-copy-completion-time"] = self._deserialize( - "rfc-1123", response.headers.get("x-ms-copy-completion-time") - ) - response_headers["x-ms-copy-status-description"] = self._deserialize( - "str", response.headers.get("x-ms-copy-status-description") - ) - response_headers["x-ms-copy-id"] = self._deserialize("str", response.headers.get("x-ms-copy-id")) - response_headers["x-ms-copy-progress"] = self._deserialize("str", response.headers.get("x-ms-copy-progress")) - response_headers["x-ms-copy-source"] = self._deserialize("str", response.headers.get("x-ms-copy-source")) - response_headers["x-ms-copy-status"] = self._deserialize("str", response.headers.get("x-ms-copy-status")) - response_headers["x-ms-content-md5"] = self._deserialize("bytearray", response.headers.get("x-ms-content-md5")) - response_headers["x-ms-server-encrypted"] = self._deserialize( - "bool", response.headers.get("x-ms-server-encrypted") - ) - response_headers["x-ms-file-attributes"] = self._deserialize( - "str", response.headers.get("x-ms-file-attributes") - ) - response_headers["x-ms-file-creation-time"] = self._deserialize( - "str", response.headers.get("x-ms-file-creation-time") - ) - response_headers["x-ms-file-last-write-time"] = self._deserialize( - "str", response.headers.get("x-ms-file-last-write-time") - ) - response_headers["x-ms-file-change-time"] = self._deserialize( - "str", response.headers.get("x-ms-file-change-time") - ) - response_headers["x-ms-file-permission-key"] = self._deserialize( - "str", response.headers.get("x-ms-file-permission-key") - ) - response_headers["x-ms-file-id"] = self._deserialize("str", response.headers.get("x-ms-file-id")) - response_headers["x-ms-file-parent-id"] = self._deserialize("str", response.headers.get("x-ms-file-parent-id")) - response_headers["x-ms-lease-duration"] = self._deserialize("str", response.headers.get("x-ms-lease-duration")) - response_headers["x-ms-lease-state"] = self._deserialize("str", response.headers.get("x-ms-lease-state")) - response_headers["x-ms-lease-status"] = self._deserialize("str", response.headers.get("x-ms-lease-status")) - response_headers["x-ms-structured-body"] = self._deserialize( - "str", response.headers.get("x-ms-structured-body") - ) - response_headers["x-ms-structured-content-length"] = self._deserialize( - "int", response.headers.get("x-ms-structured-content-length") - ) - response_headers["x-ms-mode"] = self._deserialize("str", response.headers.get("x-ms-mode")) - response_headers["x-ms-owner"] = self._deserialize("str", response.headers.get("x-ms-owner")) - response_headers["x-ms-group"] = self._deserialize("str", response.headers.get("x-ms-group")) - response_headers["x-ms-link-count"] = self._deserialize("int", response.headers.get("x-ms-link-count")) - - deserialized = response.stream_download(self._client._pipeline, decompress=_decompress) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @distributed_trace_async - async def get_properties( - self, - sharesnapshot: Optional[str] = None, - timeout: Optional[int] = None, - lease_access_conditions: Optional[_models.LeaseAccessConditions] = None, - **kwargs: Any - ) -> None: - """Returns all user-defined metadata, standard HTTP properties, and system properties for the - file. It does not return the content of the file. - - :param sharesnapshot: The snapshot parameter is an opaque DateTime value that, when present, - specifies the share snapshot to query. Default value is None. - :type sharesnapshot: str - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param lease_access_conditions: Parameter group. Default value is None. - :type lease_access_conditions: ~azure.storage.fileshare.models.LeaseAccessConditions - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = kwargs.pop("params", {}) or {} - - cls: ClsType[None] = kwargs.pop("cls", None) - - _lease_id = None - if lease_access_conditions is not None: - _lease_id = lease_access_conditions.lease_id - - _request = build_get_properties_request( - url=self._config.url, - version=self._config.version, - sharesnapshot=sharesnapshot, - timeout=timeout, - lease_id=_lease_id, - allow_trailing_dot=self._config.allow_trailing_dot, - file_request_intent=self._config.file_request_intent, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) - response_headers["x-ms-meta"] = self._deserialize("{str}", response.headers.get("x-ms-meta")) - response_headers["x-ms-type"] = self._deserialize("str", response.headers.get("x-ms-type")) - response_headers["Content-Length"] = self._deserialize("int", response.headers.get("Content-Length")) - response_headers["Content-Type"] = self._deserialize("str", response.headers.get("Content-Type")) - response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) - response_headers["Content-MD5"] = self._deserialize("bytearray", response.headers.get("Content-MD5")) - response_headers["Content-Encoding"] = self._deserialize("str", response.headers.get("Content-Encoding")) - response_headers["Cache-Control"] = self._deserialize("str", response.headers.get("Cache-Control")) - response_headers["Content-Disposition"] = self._deserialize("str", response.headers.get("Content-Disposition")) - response_headers["Content-Language"] = self._deserialize("str", response.headers.get("Content-Language")) - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - response_headers["x-ms-copy-completion-time"] = self._deserialize( - "rfc-1123", response.headers.get("x-ms-copy-completion-time") - ) - response_headers["x-ms-copy-status-description"] = self._deserialize( - "str", response.headers.get("x-ms-copy-status-description") - ) - response_headers["x-ms-copy-id"] = self._deserialize("str", response.headers.get("x-ms-copy-id")) - response_headers["x-ms-copy-progress"] = self._deserialize("str", response.headers.get("x-ms-copy-progress")) - response_headers["x-ms-copy-source"] = self._deserialize("str", response.headers.get("x-ms-copy-source")) - response_headers["x-ms-copy-status"] = self._deserialize("str", response.headers.get("x-ms-copy-status")) - response_headers["x-ms-server-encrypted"] = self._deserialize( - "bool", response.headers.get("x-ms-server-encrypted") - ) - response_headers["x-ms-file-attributes"] = self._deserialize( - "str", response.headers.get("x-ms-file-attributes") - ) - response_headers["x-ms-file-creation-time"] = self._deserialize( - "str", response.headers.get("x-ms-file-creation-time") - ) - response_headers["x-ms-file-last-write-time"] = self._deserialize( - "str", response.headers.get("x-ms-file-last-write-time") - ) - response_headers["x-ms-file-change-time"] = self._deserialize( - "str", response.headers.get("x-ms-file-change-time") - ) - response_headers["x-ms-file-permission-key"] = self._deserialize( - "str", response.headers.get("x-ms-file-permission-key") - ) - response_headers["x-ms-file-id"] = self._deserialize("str", response.headers.get("x-ms-file-id")) - response_headers["x-ms-file-parent-id"] = self._deserialize("str", response.headers.get("x-ms-file-parent-id")) - response_headers["x-ms-lease-duration"] = self._deserialize("str", response.headers.get("x-ms-lease-duration")) - response_headers["x-ms-lease-state"] = self._deserialize("str", response.headers.get("x-ms-lease-state")) - response_headers["x-ms-lease-status"] = self._deserialize("str", response.headers.get("x-ms-lease-status")) - response_headers["x-ms-mode"] = self._deserialize("str", response.headers.get("x-ms-mode")) - response_headers["x-ms-owner"] = self._deserialize("str", response.headers.get("x-ms-owner")) - response_headers["x-ms-group"] = self._deserialize("str", response.headers.get("x-ms-group")) - response_headers["x-ms-link-count"] = self._deserialize("int", response.headers.get("x-ms-link-count")) - response_headers["x-ms-file-file-type"] = self._deserialize("str", response.headers.get("x-ms-file-file-type")) - - if cls: - return cls(pipeline_response, None, response_headers) # type: ignore - - @distributed_trace_async - async def delete( - self, - timeout: Optional[int] = None, - lease_access_conditions: Optional[_models.LeaseAccessConditions] = None, - **kwargs: Any - ) -> None: - """removes the file from the storage account. - - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param lease_access_conditions: Parameter group. Default value is None. - :type lease_access_conditions: ~azure.storage.fileshare.models.LeaseAccessConditions - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = kwargs.pop("params", {}) or {} - - cls: ClsType[None] = kwargs.pop("cls", None) - - _lease_id = None - if lease_access_conditions is not None: - _lease_id = lease_access_conditions.lease_id - - _request = build_delete_request( - url=self._config.url, - version=self._config.version, - timeout=timeout, - lease_id=_lease_id, - allow_trailing_dot=self._config.allow_trailing_dot, - file_request_intent=self._config.file_request_intent, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [202]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - response_headers["x-ms-link-count"] = self._deserialize("int", response.headers.get("x-ms-link-count")) - - if cls: - return cls(pipeline_response, None, response_headers) # type: ignore - - @distributed_trace_async - async def set_http_headers( # pylint: disable=too-many-locals - self, - timeout: Optional[int] = None, - file_content_length: Optional[int] = None, - file_permission: str = "inherit", - file_permission_format: Optional[Union[str, _models.FilePermissionFormat]] = None, - file_permission_key: Optional[str] = None, - file_attributes: str = "none", - file_creation_time: str = "now", - file_last_write_time: str = "now", - file_change_time: Optional[str] = None, - owner: Optional[str] = None, - group: Optional[str] = None, - file_mode: Optional[str] = None, - file_http_headers: Optional[_models.FileHTTPHeaders] = None, - lease_access_conditions: Optional[_models.LeaseAccessConditions] = None, - **kwargs: Any - ) -> None: - """Sets HTTP headers on the file. - - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param file_content_length: Resizes a file to the specified size. If the specified byte value - is less than the current size of the file, then all ranges above the specified byte value are - cleared. Default value is None. - :type file_content_length: int - :param file_permission: If specified the permission (security descriptor) shall be set for the - directory/file. This header can be used if Permission size is <= 8KB, else - x-ms-file-permission-key header shall be used. Default value: Inherit. If SDDL is specified as - input, it must have owner, group and dacl. Note: Only one of the x-ms-file-permission or - x-ms-file-permission-key should be specified. Default value is "inherit". - :type file_permission: str - :param file_permission_format: Optional. Available for version 2023-06-01 and later. Specifies - the format in which the permission is returned. Acceptable values are SDDL or binary. If - x-ms-file-permission-format is unspecified or explicitly set to SDDL, the permission is - returned in SDDL format. If x-ms-file-permission-format is explicitly set to binary, the - permission is returned as a base64 string representing the binary encoding of the permission. - Known values are: "Sddl" and "Binary". Default value is None. - :type file_permission_format: str or ~azure.storage.fileshare.models.FilePermissionFormat - :param file_permission_key: Key of the permission to be set for the directory/file. Note: Only - one of the x-ms-file-permission or x-ms-file-permission-key should be specified. Default value - is None. - :type file_permission_key: str - :param file_attributes: If specified, the provided file attributes shall be set. Default value: - ‘Archive’ for file and ‘Directory’ for directory. ‘None’ can also be specified as default. - Default value is "none". - :type file_attributes: str - :param file_creation_time: Creation time for the file/directory. Default value: Now. Default - value is "now". - :type file_creation_time: str - :param file_last_write_time: Last write time for the file/directory. Default value: Now. - Default value is "now". - :type file_last_write_time: str - :param file_change_time: Change time for the file/directory. Default value: Now. Default value - is None. - :type file_change_time: str - :param owner: Optional, NFS only. The owner of the file or directory. Default value is None. - :type owner: str - :param group: Optional, NFS only. The owning group of the file or directory. Default value is - None. - :type group: str - :param file_mode: Optional, NFS only. The file mode of the file or directory. Default value is - None. - :type file_mode: str - :param file_http_headers: Parameter group. Default value is None. - :type file_http_headers: ~azure.storage.fileshare.models.FileHTTPHeaders - :param lease_access_conditions: Parameter group. Default value is None. - :type lease_access_conditions: ~azure.storage.fileshare.models.LeaseAccessConditions - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - comp: Literal["properties"] = kwargs.pop("comp", _params.pop("comp", "properties")) - cls: ClsType[None] = kwargs.pop("cls", None) - - _file_content_type = None - _file_content_encoding = None - _file_content_language = None - _file_cache_control = None - _file_content_md5 = None - _file_content_disposition = None - _lease_id = None - if file_http_headers is not None: - _file_cache_control = file_http_headers.file_cache_control - _file_content_disposition = file_http_headers.file_content_disposition - _file_content_encoding = file_http_headers.file_content_encoding - _file_content_language = file_http_headers.file_content_language - _file_content_md5 = file_http_headers.file_content_md5 - _file_content_type = file_http_headers.file_content_type - if lease_access_conditions is not None: - _lease_id = lease_access_conditions.lease_id - - _request = build_set_http_headers_request( - url=self._config.url, - version=self._config.version, - timeout=timeout, - file_content_length=file_content_length, - file_content_type=_file_content_type, - file_content_encoding=_file_content_encoding, - file_content_language=_file_content_language, - file_cache_control=_file_cache_control, - file_content_md5=_file_content_md5, - file_content_disposition=_file_content_disposition, - file_permission=file_permission, - file_permission_format=file_permission_format, - file_permission_key=file_permission_key, - file_attributes=file_attributes, - file_creation_time=file_creation_time, - file_last_write_time=file_last_write_time, - file_change_time=file_change_time, - lease_id=_lease_id, - owner=owner, - group=group, - file_mode=file_mode, - allow_trailing_dot=self._config.allow_trailing_dot, - file_request_intent=self._config.file_request_intent, - comp=comp, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) - response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - response_headers["x-ms-request-server-encrypted"] = self._deserialize( - "bool", response.headers.get("x-ms-request-server-encrypted") - ) - response_headers["x-ms-file-permission-key"] = self._deserialize( - "str", response.headers.get("x-ms-file-permission-key") - ) - response_headers["x-ms-file-attributes"] = self._deserialize( - "str", response.headers.get("x-ms-file-attributes") - ) - response_headers["x-ms-file-creation-time"] = self._deserialize( - "str", response.headers.get("x-ms-file-creation-time") - ) - response_headers["x-ms-file-last-write-time"] = self._deserialize( - "str", response.headers.get("x-ms-file-last-write-time") - ) - response_headers["x-ms-file-change-time"] = self._deserialize( - "str", response.headers.get("x-ms-file-change-time") - ) - response_headers["x-ms-file-id"] = self._deserialize("str", response.headers.get("x-ms-file-id")) - response_headers["x-ms-file-parent-id"] = self._deserialize("str", response.headers.get("x-ms-file-parent-id")) - response_headers["x-ms-mode"] = self._deserialize("str", response.headers.get("x-ms-mode")) - response_headers["x-ms-owner"] = self._deserialize("str", response.headers.get("x-ms-owner")) - response_headers["x-ms-group"] = self._deserialize("str", response.headers.get("x-ms-group")) - response_headers["x-ms-link-count"] = self._deserialize("int", response.headers.get("x-ms-link-count")) - - if cls: - return cls(pipeline_response, None, response_headers) # type: ignore - - @distributed_trace_async - async def set_metadata( - self, - timeout: Optional[int] = None, - metadata: Optional[dict[str, str]] = None, - lease_access_conditions: Optional[_models.LeaseAccessConditions] = None, - **kwargs: Any - ) -> None: - """Updates user-defined metadata for the specified file. - - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param metadata: A name-value pair to associate with a file storage object. Default value is - None. - :type metadata: dict[str, str] - :param lease_access_conditions: Parameter group. Default value is None. - :type lease_access_conditions: ~azure.storage.fileshare.models.LeaseAccessConditions - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - comp: Literal["metadata"] = kwargs.pop("comp", _params.pop("comp", "metadata")) - cls: ClsType[None] = kwargs.pop("cls", None) - - _lease_id = None - if lease_access_conditions is not None: - _lease_id = lease_access_conditions.lease_id - - _request = build_set_metadata_request( - url=self._config.url, - version=self._config.version, - timeout=timeout, - metadata=metadata, - lease_id=_lease_id, - allow_trailing_dot=self._config.allow_trailing_dot, - file_request_intent=self._config.file_request_intent, - comp=comp, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - response_headers["x-ms-request-server-encrypted"] = self._deserialize( - "bool", response.headers.get("x-ms-request-server-encrypted") - ) - - if cls: - return cls(pipeline_response, None, response_headers) # type: ignore - - @distributed_trace_async - async def acquire_lease( - self, - timeout: Optional[int] = None, - duration: Optional[int] = None, - proposed_lease_id: Optional[str] = None, - request_id_parameter: Optional[str] = None, - **kwargs: Any - ) -> None: - """[Update] The Lease File operation establishes and manages a lock on a file for write and delete - operations. - - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param duration: Specifies the duration of the lease, in seconds, or negative one (-1) for a - lease that never expires. A non-infinite lease can be between 15 and 60 seconds. A lease - duration cannot be changed using renew or change. Default value is None. - :type duration: int - :param proposed_lease_id: Proposed lease ID, in a GUID string format. The File service returns - 400 (Invalid request) if the proposed lease ID is not in the correct format. See Guid - Constructor (String) for a list of valid GUID string formats. Default value is None. - :type proposed_lease_id: str - :param request_id_parameter: Provides a client-generated, opaque value with a 1 KB character - limit that is recorded in the analytics logs when storage analytics logging is enabled. Default - value is None. - :type request_id_parameter: str - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - comp: Literal["lease"] = kwargs.pop("comp", _params.pop("comp", "lease")) - action: Literal["acquire"] = kwargs.pop("action", _headers.pop("x-ms-lease-action", "acquire")) - cls: ClsType[None] = kwargs.pop("cls", None) - - _request = build_acquire_lease_request( - url=self._config.url, - version=self._config.version, - timeout=timeout, - duration=duration, - proposed_lease_id=proposed_lease_id, - request_id_parameter=request_id_parameter, - allow_trailing_dot=self._config.allow_trailing_dot, - file_request_intent=self._config.file_request_intent, - comp=comp, - action=action, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [201]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) - response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) - response_headers["x-ms-lease-id"] = self._deserialize("str", response.headers.get("x-ms-lease-id")) - response_headers["x-ms-client-request-id"] = self._deserialize( - "str", response.headers.get("x-ms-client-request-id") - ) - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - - if cls: - return cls(pipeline_response, None, response_headers) # type: ignore - - @distributed_trace_async - async def release_lease( - self, lease_id: str, timeout: Optional[int] = None, request_id_parameter: Optional[str] = None, **kwargs: Any - ) -> None: - """[Update] The Lease File operation establishes and manages a lock on a file for write and delete - operations. - - :param lease_id: Specifies the current lease ID on the resource. Required. - :type lease_id: str - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param request_id_parameter: Provides a client-generated, opaque value with a 1 KB character - limit that is recorded in the analytics logs when storage analytics logging is enabled. Default - value is None. - :type request_id_parameter: str - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - comp: Literal["lease"] = kwargs.pop("comp", _params.pop("comp", "lease")) - action: Literal["release"] = kwargs.pop("action", _headers.pop("x-ms-lease-action", "release")) - cls: ClsType[None] = kwargs.pop("cls", None) - - _request = build_release_lease_request( - url=self._config.url, - lease_id=lease_id, - version=self._config.version, - timeout=timeout, - request_id_parameter=request_id_parameter, - allow_trailing_dot=self._config.allow_trailing_dot, - file_request_intent=self._config.file_request_intent, - comp=comp, - action=action, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) - response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) - response_headers["x-ms-client-request-id"] = self._deserialize( - "str", response.headers.get("x-ms-client-request-id") - ) - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - - if cls: - return cls(pipeline_response, None, response_headers) # type: ignore - - @distributed_trace_async - async def change_lease( - self, - lease_id: str, - timeout: Optional[int] = None, - proposed_lease_id: Optional[str] = None, - request_id_parameter: Optional[str] = None, - **kwargs: Any - ) -> None: - """[Update] The Lease File operation establishes and manages a lock on a file for write and delete - operations. - - :param lease_id: Specifies the current lease ID on the resource. Required. - :type lease_id: str - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param proposed_lease_id: Proposed lease ID, in a GUID string format. The File service returns - 400 (Invalid request) if the proposed lease ID is not in the correct format. See Guid - Constructor (String) for a list of valid GUID string formats. Default value is None. - :type proposed_lease_id: str - :param request_id_parameter: Provides a client-generated, opaque value with a 1 KB character - limit that is recorded in the analytics logs when storage analytics logging is enabled. Default - value is None. - :type request_id_parameter: str - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - comp: Literal["lease"] = kwargs.pop("comp", _params.pop("comp", "lease")) - action: Literal["change"] = kwargs.pop("action", _headers.pop("x-ms-lease-action", "change")) - cls: ClsType[None] = kwargs.pop("cls", None) - - _request = build_change_lease_request( - url=self._config.url, - lease_id=lease_id, - version=self._config.version, - timeout=timeout, - proposed_lease_id=proposed_lease_id, - request_id_parameter=request_id_parameter, - allow_trailing_dot=self._config.allow_trailing_dot, - file_request_intent=self._config.file_request_intent, - comp=comp, - action=action, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) - response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) - response_headers["x-ms-lease-id"] = self._deserialize("str", response.headers.get("x-ms-lease-id")) - response_headers["x-ms-client-request-id"] = self._deserialize( - "str", response.headers.get("x-ms-client-request-id") - ) - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - - if cls: - return cls(pipeline_response, None, response_headers) # type: ignore - - @distributed_trace_async - async def break_lease( - self, - timeout: Optional[int] = None, - request_id_parameter: Optional[str] = None, - lease_access_conditions: Optional[_models.LeaseAccessConditions] = None, - **kwargs: Any - ) -> None: - """[Update] The Lease File operation establishes and manages a lock on a file for write and delete - operations. - - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param request_id_parameter: Provides a client-generated, opaque value with a 1 KB character - limit that is recorded in the analytics logs when storage analytics logging is enabled. Default - value is None. - :type request_id_parameter: str - :param lease_access_conditions: Parameter group. Default value is None. - :type lease_access_conditions: ~azure.storage.fileshare.models.LeaseAccessConditions - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - comp: Literal["lease"] = kwargs.pop("comp", _params.pop("comp", "lease")) - action: Literal["break"] = kwargs.pop("action", _headers.pop("x-ms-lease-action", "break")) - cls: ClsType[None] = kwargs.pop("cls", None) - - _lease_id = None - if lease_access_conditions is not None: - _lease_id = lease_access_conditions.lease_id - - _request = build_break_lease_request( - url=self._config.url, - version=self._config.version, - timeout=timeout, - lease_id=_lease_id, - request_id_parameter=request_id_parameter, - allow_trailing_dot=self._config.allow_trailing_dot, - file_request_intent=self._config.file_request_intent, - comp=comp, - action=action, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [202]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) - response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) - response_headers["x-ms-lease-id"] = self._deserialize("str", response.headers.get("x-ms-lease-id")) - response_headers["x-ms-client-request-id"] = self._deserialize( - "str", response.headers.get("x-ms-client-request-id") - ) - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - - if cls: - return cls(pipeline_response, None, response_headers) # type: ignore - - @distributed_trace_async - async def upload_range( # pylint: disable=too-many-locals - self, - range: str, - content_length: int, - timeout: Optional[int] = None, - file_range_write: Union[str, _models.FileRangeWriteType] = "update", - content_md5: Optional[bytes] = None, - file_last_written_mode: Optional[Union[str, _models.FileLastWrittenMode]] = None, - structured_body_type: Optional[str] = None, - structured_content_length: Optional[int] = None, - lease_access_conditions: Optional[_models.LeaseAccessConditions] = None, - optionalbody: Optional[IO[bytes]] = None, - **kwargs: Any - ) -> None: - """Upload a range of bytes to a file. - - :param range: Specifies the range of bytes to be written. Both the start and end of the range - must be specified. For an update operation, the range can be up to 4 MB in size. For a clear - operation, the range can be up to the value of the file's full size. The File service accepts - only a single byte range for the Range and 'x-ms-range' headers, and the byte range must be - specified in the following format: bytes=startByte-endByte. Required. - :type range: str - :param content_length: Specifies the number of bytes being transmitted in the request body. - When the x-ms-write header is set to clear, the value of this header must be set to zero. - Required. - :type content_length: int - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param file_range_write: Specify one of the following options: - Update: Writes the bytes - specified by the request body into the specified range. The Range and Content-Length headers - must match to perform the update. - Clear: Clears the specified range and releases the space - used in storage for that range. To clear a range, set the Content-Length header to zero, and - set the Range header to a value that indicates the range to clear, up to maximum file size. - Known values are: "update" and "clear". Default value is "update". - :type file_range_write: str or ~azure.storage.fileshare.models.FileRangeWriteType - :param content_md5: An MD5 hash of the content. This hash is used to verify the integrity of - the data during transport. When the Content-MD5 header is specified, the File service compares - the hash of the content that has arrived with the header value that was sent. If the two hashes - do not match, the operation will fail with error code 400 (Bad Request). Default value is None. - :type content_md5: bytes - :param file_last_written_mode: If the file last write time should be preserved or overwritten. - Known values are: "Now" and "Preserve". Default value is None. - :type file_last_written_mode: str or ~azure.storage.fileshare.models.FileLastWrittenMode - :param structured_body_type: Required if the request body is a structured message. Specifies - the message schema version and properties. Default value is None. - :type structured_body_type: str - :param structured_content_length: Required if the request body is a structured message. - Specifies the length of the blob/file content inside the message body. Will always be smaller - than Content-Length. Default value is None. - :type structured_content_length: int - :param lease_access_conditions: Parameter group. Default value is None. - :type lease_access_conditions: ~azure.storage.fileshare.models.LeaseAccessConditions - :param optionalbody: Initial data. Default value is None. - :type optionalbody: IO[bytes] - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - comp: Literal["range"] = kwargs.pop("comp", _params.pop("comp", "range")) - content_type: Optional[str] = kwargs.pop( - "content_type", _headers.pop("Content-Type", "application/octet-stream") - ) - content_type = content_type if optionalbody else None - cls: ClsType[None] = kwargs.pop("cls", None) - - _lease_id = None - if lease_access_conditions is not None: - _lease_id = lease_access_conditions.lease_id - _content = optionalbody - - _request = build_upload_range_request( - url=self._config.url, - range=range, - content_length=content_length, - version=self._config.version, - timeout=timeout, - file_range_write=file_range_write, - content_md5=content_md5, - lease_id=_lease_id, - file_last_written_mode=file_last_written_mode, - structured_body_type=structured_body_type, - structured_content_length=structured_content_length, - allow_trailing_dot=self._config.allow_trailing_dot, - file_request_intent=self._config.file_request_intent, - comp=comp, - content_type=content_type, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [201]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) - response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) - response_headers["Content-MD5"] = self._deserialize("bytearray", response.headers.get("Content-MD5")) - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - response_headers["x-ms-request-server-encrypted"] = self._deserialize( - "bool", response.headers.get("x-ms-request-server-encrypted") - ) - response_headers["x-ms-file-last-write-time"] = self._deserialize( - "str", response.headers.get("x-ms-file-last-write-time") - ) - response_headers["x-ms-structured-body"] = self._deserialize( - "str", response.headers.get("x-ms-structured-body") - ) - - if cls: - return cls(pipeline_response, None, response_headers) # type: ignore - - @distributed_trace_async - async def upload_range_from_url( - self, - range: str, - copy_source: str, - content_length: int, - timeout: Optional[int] = None, - source_range: Optional[str] = None, - source_content_crc64: Optional[bytes] = None, - copy_source_authorization: Optional[str] = None, - file_last_written_mode: Optional[Union[str, _models.FileLastWrittenMode]] = None, - source_modified_access_conditions: Optional[_models.SourceModifiedAccessConditions] = None, - lease_access_conditions: Optional[_models.LeaseAccessConditions] = None, - **kwargs: Any - ) -> None: - """Upload a range of bytes to a file where the contents are read from a URL. - - :param range: Writes data to the specified byte range in the file. Required. - :type range: str - :param copy_source: Specifies the URL of the source file or blob, up to 2 KB in length. To copy - a file to another file within the same storage account, you may use Shared Key to authenticate - the source file. If you are copying a file from another storage account, or if you are copying - a blob from the same storage account or another storage account, then you must authenticate the - source file or blob using a shared access signature. If the source is a public blob, no - authentication is required to perform the copy operation. A file in a share snapshot can also - be specified as a copy source. Required. - :type copy_source: str - :param content_length: Specifies the number of bytes being transmitted in the request body. - When the x-ms-write header is set to clear, the value of this header must be set to zero. - Required. - :type content_length: int - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param source_range: Bytes of source data in the specified range. Default value is None. - :type source_range: str - :param source_content_crc64: Specify the crc64 calculated for the range of bytes that must be - read from the copy source. Default value is None. - :type source_content_crc64: bytes - :param copy_source_authorization: Only Bearer type is supported. Credentials should be a valid - OAuth access token to copy source. Default value is None. - :type copy_source_authorization: str - :param file_last_written_mode: If the file last write time should be preserved or overwritten. - Known values are: "Now" and "Preserve". Default value is None. - :type file_last_written_mode: str or ~azure.storage.fileshare.models.FileLastWrittenMode - :param source_modified_access_conditions: Parameter group. Default value is None. - :type source_modified_access_conditions: - ~azure.storage.fileshare.models.SourceModifiedAccessConditions - :param lease_access_conditions: Parameter group. Default value is None. - :type lease_access_conditions: ~azure.storage.fileshare.models.LeaseAccessConditions - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - comp: Literal["range"] = kwargs.pop("comp", _params.pop("comp", "range")) - cls: ClsType[None] = kwargs.pop("cls", None) - - _source_if_match_crc64 = None - _source_if_none_match_crc64 = None - _lease_id = None - if source_modified_access_conditions is not None: - _source_if_match_crc64 = source_modified_access_conditions.source_if_match_crc64 - _source_if_none_match_crc64 = source_modified_access_conditions.source_if_none_match_crc64 - if lease_access_conditions is not None: - _lease_id = lease_access_conditions.lease_id - - _request = build_upload_range_from_url_request( - url=self._config.url, - range=range, - copy_source=copy_source, - content_length=content_length, - version=self._config.version, - timeout=timeout, - source_range=source_range, - source_content_crc64=source_content_crc64, - source_if_match_crc64=_source_if_match_crc64, - source_if_none_match_crc64=_source_if_none_match_crc64, - lease_id=_lease_id, - copy_source_authorization=copy_source_authorization, - file_last_written_mode=file_last_written_mode, - allow_trailing_dot=self._config.allow_trailing_dot, - allow_source_trailing_dot=self._config.allow_source_trailing_dot, - file_request_intent=self._config.file_request_intent, - comp=comp, - file_range_write_from_url=self._config.file_range_write_from_url, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [201]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) - response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) - response_headers["x-ms-content-crc64"] = self._deserialize( - "bytearray", response.headers.get("x-ms-content-crc64") - ) - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - response_headers["x-ms-request-server-encrypted"] = self._deserialize( - "bool", response.headers.get("x-ms-request-server-encrypted") - ) - response_headers["x-ms-file-last-write-time"] = self._deserialize( - "str", response.headers.get("x-ms-file-last-write-time") - ) - - if cls: - return cls(pipeline_response, None, response_headers) # type: ignore - - @distributed_trace_async - async def get_range_list( - self, - sharesnapshot: Optional[str] = None, - prevsharesnapshot: Optional[str] = None, - timeout: Optional[int] = None, - range: Optional[str] = None, - support_rename: Optional[bool] = None, - lease_access_conditions: Optional[_models.LeaseAccessConditions] = None, - **kwargs: Any - ) -> _models.ShareFileRangeList: - """Returns the list of valid ranges for a file. - - :param sharesnapshot: The snapshot parameter is an opaque DateTime value that, when present, - specifies the share snapshot to query. Default value is None. - :type sharesnapshot: str - :param prevsharesnapshot: The previous snapshot parameter is an opaque DateTime value that, - when present, specifies the previous snapshot. Default value is None. - :type prevsharesnapshot: str - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param range: Specifies the range of bytes over which to list ranges, inclusively. Default - value is None. - :type range: str - :param support_rename: This header is allowed only when PrevShareSnapshot query parameter is - set. Determines whether the changed ranges for a file that has been renamed or moved between - the target snapshot (or the live file) and the previous snapshot should be listed. If the value - is true, the valid changed ranges for the file will be returned. If the value is false, the - operation will result in a failure with 409 (Conflict) response. The default value is false. - Default value is None. - :type support_rename: bool - :param lease_access_conditions: Parameter group. Default value is None. - :type lease_access_conditions: ~azure.storage.fileshare.models.LeaseAccessConditions - :return: ShareFileRangeList or the result of cls(response) - :rtype: ~azure.storage.fileshare.models.ShareFileRangeList - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - comp: Literal["rangelist"] = kwargs.pop("comp", _params.pop("comp", "rangelist")) - cls: ClsType[_models.ShareFileRangeList] = kwargs.pop("cls", None) - - _lease_id = None - if lease_access_conditions is not None: - _lease_id = lease_access_conditions.lease_id - - _request = build_get_range_list_request( - url=self._config.url, - version=self._config.version, - sharesnapshot=sharesnapshot, - prevsharesnapshot=prevsharesnapshot, - timeout=timeout, - range=range, - lease_id=_lease_id, - support_rename=support_rename, - allow_trailing_dot=self._config.allow_trailing_dot, - file_request_intent=self._config.file_request_intent, - comp=comp, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) - response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) - response_headers["x-ms-content-length"] = self._deserialize("int", response.headers.get("x-ms-content-length")) - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - - deserialized = self._deserialize("ShareFileRangeList", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @distributed_trace_async - async def start_copy( # pylint: disable=too-many-locals - self, - copy_source: str, - timeout: Optional[int] = None, - metadata: Optional[dict[str, str]] = None, - file_permission: str = "inherit", - file_permission_format: Optional[Union[str, _models.FilePermissionFormat]] = None, - file_permission_key: Optional[str] = None, - owner: Optional[str] = None, - group: Optional[str] = None, - file_mode: Optional[str] = None, - file_mode_copy_mode: Optional[Union[str, _models.ModeCopyMode]] = None, - file_owner_copy_mode: Optional[Union[str, _models.OwnerCopyMode]] = None, - copy_file_smb_info: Optional[_models.CopyFileSmbInfo] = None, - lease_access_conditions: Optional[_models.LeaseAccessConditions] = None, - **kwargs: Any - ) -> None: - """Copies a blob or file to a destination file within the storage account. - - :param copy_source: Specifies the URL of the source file or blob, up to 2 KB in length. To copy - a file to another file within the same storage account, you may use Shared Key to authenticate - the source file. If you are copying a file from another storage account, or if you are copying - a blob from the same storage account or another storage account, then you must authenticate the - source file or blob using a shared access signature. If the source is a public blob, no - authentication is required to perform the copy operation. A file in a share snapshot can also - be specified as a copy source. Required. - :type copy_source: str - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param metadata: A name-value pair to associate with a file storage object. Default value is - None. - :type metadata: dict[str, str] - :param file_permission: If specified the permission (security descriptor) shall be set for the - directory/file. This header can be used if Permission size is <= 8KB, else - x-ms-file-permission-key header shall be used. Default value: Inherit. If SDDL is specified as - input, it must have owner, group and dacl. Note: Only one of the x-ms-file-permission or - x-ms-file-permission-key should be specified. Default value is "inherit". - :type file_permission: str - :param file_permission_format: Optional. Available for version 2023-06-01 and later. Specifies - the format in which the permission is returned. Acceptable values are SDDL or binary. If - x-ms-file-permission-format is unspecified or explicitly set to SDDL, the permission is - returned in SDDL format. If x-ms-file-permission-format is explicitly set to binary, the - permission is returned as a base64 string representing the binary encoding of the permission. - Known values are: "Sddl" and "Binary". Default value is None. - :type file_permission_format: str or ~azure.storage.fileshare.models.FilePermissionFormat - :param file_permission_key: Key of the permission to be set for the directory/file. Note: Only - one of the x-ms-file-permission or x-ms-file-permission-key should be specified. Default value - is None. - :type file_permission_key: str - :param owner: Optional, NFS only. The owner of the file or directory. Default value is None. - :type owner: str - :param group: Optional, NFS only. The owning group of the file or directory. Default value is - None. - :type group: str - :param file_mode: Optional, NFS only. The file mode of the file or directory. Default value is - None. - :type file_mode: str - :param file_mode_copy_mode: NFS only. Applicable only when the copy source is a File. - Determines the copy behavior of the mode bits of the file. source: The mode on the destination - file is copied from the source file. override: The mode on the destination file is determined - via the x-ms-mode header. Known values are: "source" and "override". Default value is None. - :type file_mode_copy_mode: str or ~azure.storage.fileshare.models.ModeCopyMode - :param file_owner_copy_mode: NFS only. Determines the copy behavior of the owner user - identifier (UID) and group identifier (GID) of the file. source: The owner user identifier - (UID) and group identifier (GID) on the destination file is copied from the source file. - override: The owner user identifier (UID) and group identifier (GID) on the destination file is - determined via the x-ms-owner and x-ms-group headers. Known values are: "source" and - "override". Default value is None. - :type file_owner_copy_mode: str or ~azure.storage.fileshare.models.OwnerCopyMode - :param copy_file_smb_info: Parameter group. Default value is None. - :type copy_file_smb_info: ~azure.storage.fileshare.models.CopyFileSmbInfo - :param lease_access_conditions: Parameter group. Default value is None. - :type lease_access_conditions: ~azure.storage.fileshare.models.LeaseAccessConditions - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = kwargs.pop("params", {}) or {} - - cls: ClsType[None] = kwargs.pop("cls", None) - - _file_permission_copy_mode = None - _ignore_read_only = None - _file_attributes = None - _file_creation_time = None - _file_last_write_time = None - _file_change_time = None - _set_archive_attribute = None - _lease_id = None - if copy_file_smb_info is not None: - _file_attributes = copy_file_smb_info.file_attributes - _file_change_time = copy_file_smb_info.file_change_time - _file_creation_time = copy_file_smb_info.file_creation_time - _file_last_write_time = copy_file_smb_info.file_last_write_time - _file_permission_copy_mode = copy_file_smb_info.file_permission_copy_mode - _ignore_read_only = copy_file_smb_info.ignore_read_only - _set_archive_attribute = copy_file_smb_info.set_archive_attribute - if lease_access_conditions is not None: - _lease_id = lease_access_conditions.lease_id - - _request = build_start_copy_request( - url=self._config.url, - copy_source=copy_source, - version=self._config.version, - timeout=timeout, - metadata=metadata, - file_permission=file_permission, - file_permission_format=file_permission_format, - file_permission_key=file_permission_key, - file_permission_copy_mode=_file_permission_copy_mode, - ignore_read_only=_ignore_read_only, - file_attributes=_file_attributes, - file_creation_time=_file_creation_time, - file_last_write_time=_file_last_write_time, - file_change_time=_file_change_time, - set_archive_attribute=_set_archive_attribute, - lease_id=_lease_id, - owner=owner, - group=group, - file_mode=file_mode, - file_mode_copy_mode=file_mode_copy_mode, - file_owner_copy_mode=file_owner_copy_mode, - allow_trailing_dot=self._config.allow_trailing_dot, - allow_source_trailing_dot=self._config.allow_source_trailing_dot, - file_request_intent=self._config.file_request_intent, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [202]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) - response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - response_headers["x-ms-copy-id"] = self._deserialize("str", response.headers.get("x-ms-copy-id")) - response_headers["x-ms-copy-status"] = self._deserialize("str", response.headers.get("x-ms-copy-status")) - - if cls: - return cls(pipeline_response, None, response_headers) # type: ignore - - @distributed_trace_async - async def abort_copy( - self, - copy_id: str, - timeout: Optional[int] = None, - lease_access_conditions: Optional[_models.LeaseAccessConditions] = None, - **kwargs: Any - ) -> None: - """Aborts a pending Copy File operation, and leaves a destination file with zero length and full - metadata. - - :param copy_id: The copy identifier provided in the x-ms-copy-id header of the original Copy - File operation. Required. - :type copy_id: str - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param lease_access_conditions: Parameter group. Default value is None. - :type lease_access_conditions: ~azure.storage.fileshare.models.LeaseAccessConditions - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - comp: Literal["copy"] = kwargs.pop("comp", _params.pop("comp", "copy")) - copy_action_abort_constant: Literal["abort"] = kwargs.pop( - "copy_action_abort_constant", _headers.pop("x-ms-copy-action", "abort") - ) - cls: ClsType[None] = kwargs.pop("cls", None) - - _lease_id = None - if lease_access_conditions is not None: - _lease_id = lease_access_conditions.lease_id - - _request = build_abort_copy_request( - url=self._config.url, - copy_id=copy_id, - version=self._config.version, - timeout=timeout, - lease_id=_lease_id, - allow_trailing_dot=self._config.allow_trailing_dot, - file_request_intent=self._config.file_request_intent, - comp=comp, - copy_action_abort_constant=copy_action_abort_constant, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [204]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - - if cls: - return cls(pipeline_response, None, response_headers) # type: ignore - - @distributed_trace_async - async def list_handles( - self, - marker: Optional[str] = None, - maxresults: Optional[int] = None, - timeout: Optional[int] = None, - sharesnapshot: Optional[str] = None, - **kwargs: Any - ) -> _models.ListHandlesResponse: - """Lists handles for file. - - :param marker: A string value that identifies the portion of the list to be returned with the - next list operation. The operation returns a marker value within the response body if the list - returned was not complete. The marker value may then be used in a subsequent call to request - the next set of list items. The marker value is opaque to the client. Default value is None. - :type marker: str - :param maxresults: Specifies the maximum number of entries to return. If the request does not - specify maxresults, or specifies a value greater than 5,000, the server will return up to 5,000 - items. Default value is None. - :type maxresults: int - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param sharesnapshot: The snapshot parameter is an opaque DateTime value that, when present, - specifies the share snapshot to query. Default value is None. - :type sharesnapshot: str - :return: ListHandlesResponse or the result of cls(response) - :rtype: ~azure.storage.fileshare.models.ListHandlesResponse - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - comp: Literal["listhandles"] = kwargs.pop("comp", _params.pop("comp", "listhandles")) - cls: ClsType[_models.ListHandlesResponse] = kwargs.pop("cls", None) - - _request = build_list_handles_request( - url=self._config.url, - version=self._config.version, - marker=marker, - maxresults=maxresults, - timeout=timeout, - sharesnapshot=sharesnapshot, - allow_trailing_dot=self._config.allow_trailing_dot, - file_request_intent=self._config.file_request_intent, - comp=comp, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["Content-Type"] = self._deserialize("str", response.headers.get("Content-Type")) - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - - deserialized = self._deserialize("ListHandlesResponse", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @distributed_trace_async - async def force_close_handles( - self, - handle_id: str, - timeout: Optional[int] = None, - marker: Optional[str] = None, - sharesnapshot: Optional[str] = None, - **kwargs: Any - ) -> None: - """Closes all handles open for given file. - - :param handle_id: Specifies handle ID opened on the file or directory to be closed. Asterisk - (‘*’) is a wildcard that specifies all handles. Required. - :type handle_id: str - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param marker: A string value that identifies the portion of the list to be returned with the - next list operation. The operation returns a marker value within the response body if the list - returned was not complete. The marker value may then be used in a subsequent call to request - the next set of list items. The marker value is opaque to the client. Default value is None. - :type marker: str - :param sharesnapshot: The snapshot parameter is an opaque DateTime value that, when present, - specifies the share snapshot to query. Default value is None. - :type sharesnapshot: str - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - comp: Literal["forceclosehandles"] = kwargs.pop("comp", _params.pop("comp", "forceclosehandles")) - cls: ClsType[None] = kwargs.pop("cls", None) - - _request = build_force_close_handles_request( - url=self._config.url, - handle_id=handle_id, - version=self._config.version, - timeout=timeout, - marker=marker, - sharesnapshot=sharesnapshot, - allow_trailing_dot=self._config.allow_trailing_dot, - file_request_intent=self._config.file_request_intent, - comp=comp, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - response_headers["x-ms-marker"] = self._deserialize("str", response.headers.get("x-ms-marker")) - response_headers["x-ms-number-of-handles-closed"] = self._deserialize( - "int", response.headers.get("x-ms-number-of-handles-closed") - ) - response_headers["x-ms-number-of-handles-failed"] = self._deserialize( - "int", response.headers.get("x-ms-number-of-handles-failed") - ) - - if cls: - return cls(pipeline_response, None, response_headers) # type: ignore - - @distributed_trace_async - async def rename( # pylint: disable=too-many-locals - self, - rename_source: str, - timeout: Optional[int] = None, - replace_if_exists: Optional[bool] = None, - ignore_read_only: Optional[bool] = None, - file_permission: str = "inherit", - file_permission_format: Optional[Union[str, _models.FilePermissionFormat]] = None, - file_permission_key: Optional[str] = None, - metadata: Optional[dict[str, str]] = None, - source_lease_access_conditions: Optional[_models.SourceLeaseAccessConditions] = None, - destination_lease_access_conditions: Optional[_models.DestinationLeaseAccessConditions] = None, - copy_file_smb_info: Optional[_models.CopyFileSmbInfo] = None, - file_http_headers: Optional[_models.FileHTTPHeaders] = None, - **kwargs: Any - ) -> None: - """Renames a file. - - :param rename_source: Required. Specifies the URI-style path of the source file, up to 2 KB in - length. Required. - :type rename_source: str - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param replace_if_exists: Optional. A boolean value for if the destination file already exists, - whether this request will overwrite the file or not. If true, the rename will succeed and will - overwrite the destination file. If not provided or if false and the destination file does - exist, the request will not overwrite the destination file. If provided and the destination - file doesn’t exist, the rename will succeed. Note: This value does not override the - x-ms-file-copy-ignore-read-only header value. Default value is None. - :type replace_if_exists: bool - :param ignore_read_only: Optional. A boolean value that specifies whether the ReadOnly - attribute on a preexisting destination file should be respected. If true, the rename will - succeed, otherwise, a previous file at the destination with the ReadOnly attribute set will - cause the rename to fail. Default value is None. - :type ignore_read_only: bool - :param file_permission: If specified the permission (security descriptor) shall be set for the - directory/file. This header can be used if Permission size is <= 8KB, else - x-ms-file-permission-key header shall be used. Default value: Inherit. If SDDL is specified as - input, it must have owner, group and dacl. Note: Only one of the x-ms-file-permission or - x-ms-file-permission-key should be specified. Default value is "inherit". - :type file_permission: str - :param file_permission_format: Optional. Available for version 2023-06-01 and later. Specifies - the format in which the permission is returned. Acceptable values are SDDL or binary. If - x-ms-file-permission-format is unspecified or explicitly set to SDDL, the permission is - returned in SDDL format. If x-ms-file-permission-format is explicitly set to binary, the - permission is returned as a base64 string representing the binary encoding of the permission. - Known values are: "Sddl" and "Binary". Default value is None. - :type file_permission_format: str or ~azure.storage.fileshare.models.FilePermissionFormat - :param file_permission_key: Key of the permission to be set for the directory/file. Note: Only - one of the x-ms-file-permission or x-ms-file-permission-key should be specified. Default value - is None. - :type file_permission_key: str - :param metadata: A name-value pair to associate with a file storage object. Default value is - None. - :type metadata: dict[str, str] - :param source_lease_access_conditions: Parameter group. Default value is None. - :type source_lease_access_conditions: - ~azure.storage.fileshare.models.SourceLeaseAccessConditions - :param destination_lease_access_conditions: Parameter group. Default value is None. - :type destination_lease_access_conditions: - ~azure.storage.fileshare.models.DestinationLeaseAccessConditions - :param copy_file_smb_info: Parameter group. Default value is None. - :type copy_file_smb_info: ~azure.storage.fileshare.models.CopyFileSmbInfo - :param file_http_headers: Parameter group. Default value is None. - :type file_http_headers: ~azure.storage.fileshare.models.FileHTTPHeaders - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - comp: Literal["rename"] = kwargs.pop("comp", _params.pop("comp", "rename")) - cls: ClsType[None] = kwargs.pop("cls", None) - - _source_lease_id = None - _destination_lease_id = None - _file_attributes = None - _file_creation_time = None - _file_last_write_time = None - _file_change_time = None - _file_content_type = None - if source_lease_access_conditions is not None: - _source_lease_id = source_lease_access_conditions.source_lease_id - if destination_lease_access_conditions is not None: - _destination_lease_id = destination_lease_access_conditions.destination_lease_id - if copy_file_smb_info is not None: - _file_attributes = copy_file_smb_info.file_attributes - _file_change_time = copy_file_smb_info.file_change_time - _file_creation_time = copy_file_smb_info.file_creation_time - _file_last_write_time = copy_file_smb_info.file_last_write_time - if file_http_headers is not None: - _file_content_type = file_http_headers.file_content_type - - _request = build_rename_request( - url=self._config.url, - rename_source=rename_source, - version=self._config.version, - timeout=timeout, - replace_if_exists=replace_if_exists, - ignore_read_only=ignore_read_only, - source_lease_id=_source_lease_id, - destination_lease_id=_destination_lease_id, - file_attributes=_file_attributes, - file_creation_time=_file_creation_time, - file_last_write_time=_file_last_write_time, - file_change_time=_file_change_time, - file_permission=file_permission, - file_permission_format=file_permission_format, - file_permission_key=file_permission_key, - metadata=metadata, - file_content_type=_file_content_type, - allow_trailing_dot=self._config.allow_trailing_dot, - allow_source_trailing_dot=self._config.allow_source_trailing_dot, - file_request_intent=self._config.file_request_intent, - comp=comp, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) - response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - response_headers["x-ms-request-server-encrypted"] = self._deserialize( - "bool", response.headers.get("x-ms-request-server-encrypted") - ) - response_headers["x-ms-file-permission-key"] = self._deserialize( - "str", response.headers.get("x-ms-file-permission-key") - ) - response_headers["x-ms-file-attributes"] = self._deserialize( - "str", response.headers.get("x-ms-file-attributes") - ) - response_headers["x-ms-file-creation-time"] = self._deserialize( - "str", response.headers.get("x-ms-file-creation-time") - ) - response_headers["x-ms-file-last-write-time"] = self._deserialize( - "str", response.headers.get("x-ms-file-last-write-time") - ) - response_headers["x-ms-file-change-time"] = self._deserialize( - "str", response.headers.get("x-ms-file-change-time") - ) - response_headers["x-ms-file-id"] = self._deserialize("str", response.headers.get("x-ms-file-id")) - response_headers["x-ms-file-parent-id"] = self._deserialize("str", response.headers.get("x-ms-file-parent-id")) - - if cls: - return cls(pipeline_response, None, response_headers) # type: ignore - - @distributed_trace_async - async def create_symbolic_link( - self, - link_text: str, - timeout: Optional[int] = None, - metadata: Optional[dict[str, str]] = None, - file_creation_time: str = "now", - file_last_write_time: str = "now", - request_id_parameter: Optional[str] = None, - owner: Optional[str] = None, - group: Optional[str] = None, - lease_access_conditions: Optional[_models.LeaseAccessConditions] = None, - **kwargs: Any - ) -> None: - """Creates a symbolic link. - - :param link_text: NFS only. Required. The path to the original file, the symbolic link is - pointing to. The path is of type string which is not resolved and is stored as is. The path can - be absolute path or the relative path depending on the content stored in the symbolic link - file. Required. - :type link_text: str - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param metadata: A name-value pair to associate with a file storage object. Default value is - None. - :type metadata: dict[str, str] - :param file_creation_time: Creation time for the file/directory. Default value: Now. Default - value is "now". - :type file_creation_time: str - :param file_last_write_time: Last write time for the file/directory. Default value: Now. - Default value is "now". - :type file_last_write_time: str - :param request_id_parameter: Provides a client-generated, opaque value with a 1 KB character - limit that is recorded in the analytics logs when storage analytics logging is enabled. Default - value is None. - :type request_id_parameter: str - :param owner: Optional, NFS only. The owner of the file or directory. Default value is None. - :type owner: str - :param group: Optional, NFS only. The owning group of the file or directory. Default value is - None. - :type group: str - :param lease_access_conditions: Parameter group. Default value is None. - :type lease_access_conditions: ~azure.storage.fileshare.models.LeaseAccessConditions - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - restype: Literal["symboliclink"] = kwargs.pop("restype", _params.pop("restype", "symboliclink")) - cls: ClsType[None] = kwargs.pop("cls", None) - - _lease_id = None - if lease_access_conditions is not None: - _lease_id = lease_access_conditions.lease_id - - _request = build_create_symbolic_link_request( - url=self._config.url, - link_text=link_text, - version=self._config.version, - timeout=timeout, - metadata=metadata, - file_creation_time=file_creation_time, - file_last_write_time=file_last_write_time, - request_id_parameter=request_id_parameter, - lease_id=_lease_id, - owner=owner, - group=group, - file_request_intent=self._config.file_request_intent, - restype=restype, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [201]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) - response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - response_headers["x-ms-file-creation-time"] = self._deserialize( - "str", response.headers.get("x-ms-file-creation-time") - ) - response_headers["x-ms-file-last-write-time"] = self._deserialize( - "str", response.headers.get("x-ms-file-last-write-time") - ) - response_headers["x-ms-file-change-time"] = self._deserialize( - "str", response.headers.get("x-ms-file-change-time") - ) - response_headers["x-ms-file-id"] = self._deserialize("str", response.headers.get("x-ms-file-id")) - response_headers["x-ms-file-parent-id"] = self._deserialize("str", response.headers.get("x-ms-file-parent-id")) - response_headers["x-ms-client-request-id"] = self._deserialize( - "str", response.headers.get("x-ms-client-request-id") - ) - response_headers["x-ms-mode"] = self._deserialize("str", response.headers.get("x-ms-mode")) - response_headers["x-ms-owner"] = self._deserialize("str", response.headers.get("x-ms-owner")) - response_headers["x-ms-group"] = self._deserialize("str", response.headers.get("x-ms-group")) - response_headers["x-ms-file-file-type"] = self._deserialize("str", response.headers.get("x-ms-file-file-type")) - - if cls: - return cls(pipeline_response, None, response_headers) # type: ignore - - @distributed_trace_async - async def get_symbolic_link( - self, - timeout: Optional[int] = None, - sharesnapshot: Optional[str] = None, - request_id_parameter: Optional[str] = None, - **kwargs: Any - ) -> None: - """get_symbolic_link. - - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param sharesnapshot: The snapshot parameter is an opaque DateTime value that, when present, - specifies the share snapshot to query. Default value is None. - :type sharesnapshot: str - :param request_id_parameter: Provides a client-generated, opaque value with a 1 KB character - limit that is recorded in the analytics logs when storage analytics logging is enabled. Default - value is None. - :type request_id_parameter: str - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - restype: Literal["symboliclink"] = kwargs.pop("restype", _params.pop("restype", "symboliclink")) - cls: ClsType[None] = kwargs.pop("cls", None) - - _request = build_get_symbolic_link_request( - url=self._config.url, - version=self._config.version, - timeout=timeout, - sharesnapshot=sharesnapshot, - request_id_parameter=request_id_parameter, - file_request_intent=self._config.file_request_intent, - restype=restype, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) - response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - response_headers["x-ms-link-text"] = self._deserialize("str", response.headers.get("x-ms-link-text")) - response_headers["x-ms-client-request-id"] = self._deserialize( - "str", response.headers.get("x-ms-client-request-id") - ) - - if cls: - return cls(pipeline_response, None, response_headers) # type: ignore - - @distributed_trace_async - async def create_hard_link( - self, - target_file: str, - timeout: Optional[int] = None, - request_id_parameter: Optional[str] = None, - lease_access_conditions: Optional[_models.LeaseAccessConditions] = None, - **kwargs: Any - ) -> None: - """Creates a hard link. - - :param target_file: NFS only. Required. Specifies the path of the target file to which the link - will be created, up to 2 KiB in length. It should be full path of the target from the root.The - target file must be in the same share and hence the same storage account. Required. - :type target_file: str - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param request_id_parameter: Provides a client-generated, opaque value with a 1 KB character - limit that is recorded in the analytics logs when storage analytics logging is enabled. Default - value is None. - :type request_id_parameter: str - :param lease_access_conditions: Parameter group. Default value is None. - :type lease_access_conditions: ~azure.storage.fileshare.models.LeaseAccessConditions - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - restype: Literal["hardlink"] = kwargs.pop("restype", _params.pop("restype", "hardlink")) - file_type_constant: Literal["file"] = kwargs.pop("file_type_constant", _headers.pop("x-ms-type", "file")) - cls: ClsType[None] = kwargs.pop("cls", None) - - _lease_id = None - if lease_access_conditions is not None: - _lease_id = lease_access_conditions.lease_id - - _request = build_create_hard_link_request( - url=self._config.url, - target_file=target_file, - version=self._config.version, - timeout=timeout, - request_id_parameter=request_id_parameter, - lease_id=_lease_id, - file_request_intent=self._config.file_request_intent, - restype=restype, - file_type_constant=file_type_constant, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [201]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) - response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - response_headers["x-ms-file-creation-time"] = self._deserialize( - "str", response.headers.get("x-ms-file-creation-time") - ) - response_headers["x-ms-file-last-write-time"] = self._deserialize( - "str", response.headers.get("x-ms-file-last-write-time") - ) - response_headers["x-ms-file-change-time"] = self._deserialize( - "str", response.headers.get("x-ms-file-change-time") - ) - response_headers["x-ms-file-id"] = self._deserialize("str", response.headers.get("x-ms-file-id")) - response_headers["x-ms-file-parent-id"] = self._deserialize("str", response.headers.get("x-ms-file-parent-id")) - response_headers["x-ms-client-request-id"] = self._deserialize( - "str", response.headers.get("x-ms-client-request-id") - ) - response_headers["x-ms-link-count"] = self._deserialize("int", response.headers.get("x-ms-link-count")) - response_headers["x-ms-mode"] = self._deserialize("str", response.headers.get("x-ms-mode")) - response_headers["x-ms-owner"] = self._deserialize("str", response.headers.get("x-ms-owner")) - response_headers["x-ms-group"] = self._deserialize("str", response.headers.get("x-ms-group")) - response_headers["x-ms-file-file-type"] = self._deserialize("str", response.headers.get("x-ms-file-file-type")) - - if cls: - return cls(pipeline_response, None, response_headers) # type: ignore diff --git a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/aio/operations/_operations.py b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/aio/operations/_operations.py new file mode 100644 index 000000000000..79d9adc0c19d --- /dev/null +++ b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/aio/operations/_operations.py @@ -0,0 +1,5909 @@ +# pylint: disable=too-many-lines +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) Python Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- +from collections.abc import MutableMapping +from io import IOBase +import json +from typing import Any, AsyncIterator, Callable, IO, Literal, Optional, TypeVar, Union, overload + +from azure.core import AsyncPipelineClient +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + StreamClosedError, + StreamConsumedError, + map_error, +) +from azure.core.pipeline import PipelineResponse +from azure.core.rest import AsyncHttpResponse, HttpRequest +from azure.core.tracing.decorator_async import distributed_trace_async +from azure.core.utils import case_insensitive_dict + +from ... import models as _models +from ..._utils.model_base import SdkJSONEncoder, _deserialize, _deserialize_xml, _failsafe_deserialize_xml, _get_element +from ..._utils.serialization import Deserializer, Serializer +from ...operations._operations import ( + build_directory_create_request, + build_directory_delete_request, + build_directory_force_close_handles_request, + build_directory_get_properties_request, + build_directory_list_files_and_directories_segment_request, + build_directory_list_handles_request, + build_directory_rename_request, + build_directory_set_metadata_request, + build_directory_set_properties_request, + build_file_abort_copy_request, + build_file_acquire_lease_request, + build_file_break_lease_request, + build_file_change_lease_request, + build_file_create_hard_link_request, + build_file_create_request, + build_file_create_symbolic_link_request, + build_file_delete_request, + build_file_download_request, + build_file_force_close_handles_request, + build_file_get_properties_request, + build_file_get_range_list_request, + build_file_get_symbolic_link_request, + build_file_list_handles_request, + build_file_release_lease_request, + build_file_rename_request, + build_file_set_http_headers_request, + build_file_set_metadata_request, + build_file_start_copy_request, + build_file_upload_range_from_url_request, + build_file_upload_range_request, + build_service_get_properties_request, + build_service_get_user_delegation_key_request, + build_service_list_shares_segment_request, + build_service_set_properties_request, + build_share_acquire_lease_request, + build_share_break_lease_request, + build_share_change_lease_request, + build_share_create_permission_request, + build_share_create_request, + build_share_create_snapshot_request, + build_share_delete_request, + build_share_get_access_policy_request, + build_share_get_permission_request, + build_share_get_properties_request, + build_share_get_statistics_request, + build_share_release_lease_request, + build_share_renew_lease_request, + build_share_restore_request, + build_share_set_access_policy_request, + build_share_set_metadata_request, + build_share_set_properties_request, +) +from .._configuration import FileClientConfiguration + +T = TypeVar("T") +ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, dict[str, Any]], Any]] +JSON = MutableMapping[str, Any] + + +class DirectoryOperations: + """ + .. warning:: + **DO NOT** instantiate this class directly. + + Instead, you should access the following operations through + :class:`~azure.storage.fileshare.aio.FileClient`'s + :attr:`directory` attribute. + """ + + def __init__(self, *args, **kwargs) -> None: + input_args = list(args) + self._client: AsyncPipelineClient = input_args.pop(0) if input_args else kwargs.pop("client") + self._config: FileClientConfiguration = input_args.pop(0) if input_args else kwargs.pop("config") + self._serialize: Serializer = input_args.pop(0) if input_args else kwargs.pop("serializer") + self._deserialize: Deserializer = input_args.pop(0) if input_args else kwargs.pop("deserializer") + + @distributed_trace_async + async def create( # pylint: disable=too-many-locals + self, + *, + timeout: Optional[int] = None, + metadata: Optional[dict[str, str]] = None, + file_permission: Optional[str] = None, + file_permission_key: Optional[str] = None, + file_attributes: Optional[str] = None, + file_creation_time: Optional[str] = None, + file_last_write_time: Optional[str] = None, + file_change_time: Optional[str] = None, + file_permission_format: Optional[Union[str, _models.FilePermissionFormat]] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + owner: Optional[str] = None, + group: Optional[str] = None, + file_mode: Optional[str] = None, + file_property_semantics: Optional[Union[str, _models.FilePropertySemantics]] = None, + allow_trailing_dot: Optional[bool] = None, + **kwargs: Any + ) -> None: + """Creates a new directory under the specified share or parent directory. + + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword metadata: Optional. User-defined metadata for the resource. Default value is None. + :paramtype metadata: dict[str, str] + :keyword file_permission: If specified the permission (security descriptor) shall be set for + the directory/file. This header can be used if Permission size is <= 8KB, else + x-ms-file-permission-key header shall be used. Default value: Inherit. If SDDL is specified as + input, it must have owner, group and dacl. Note: Only one of the x-ms-file-permission or + x-ms-file-permission-key should be specified. Default value is None. + :paramtype file_permission: str + :keyword file_permission_key: Key of the permission to be set for the directory/file. Note: + Only one of the x-ms-file-permission or x-ms-file-permission-key should be specified. Default + value is None. + :paramtype file_permission_key: str + :keyword file_attributes: If specified, the provided file attributes shall be set. Default + value: 'Archive' for file and 'Directory' for directory. 'None' can also be specified as + default. Default value is None. + :paramtype file_attributes: str + :keyword file_creation_time: Creation time for the file/directory. Default value: Now. Default + value is None. + :paramtype file_creation_time: str + :keyword file_last_write_time: Last write time for the file/directory. Default value: Now. + Default value is None. + :paramtype file_last_write_time: str + :keyword file_change_time: Change time for the file/directory. Default value: Now. Default + value is None. + :paramtype file_change_time: str + :keyword file_permission_format: Optional. Used to set permission format. Known values are: + "Sddl" and "Binary". Default value is None. + :paramtype file_permission_format: str or ~azure.storage.fileshare.models.FilePermissionFormat + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :keyword owner: Optional, NFS only. The owner of the file or directory. Default value is None. + :paramtype owner: str + :keyword group: Optional, NFS only. The owning group of the file or directory. Default value is + None. + :paramtype group: str + :keyword file_mode: Optional, NFS only. The file mode of the file or directory. Default value + is None. + :paramtype file_mode: str + :keyword file_property_semantics: SMB only. Default value is New. Known values are: "New" and + "Restore". Default value is None. + :paramtype file_property_semantics: str or + ~azure.storage.fileshare.models.FilePropertySemantics + :keyword allow_trailing_dot: If true, the trailing dot will not be trimmed from the target + file/directory path. Default value is None. + :paramtype allow_trailing_dot: bool + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls: ClsType[None] = kwargs.pop("cls", None) + + _request = build_directory_create_request( + timeout=timeout, + metadata=metadata, + file_permission=file_permission, + file_permission_key=file_permission_key, + file_attributes=file_attributes, + file_creation_time=file_creation_time, + file_last_write_time=file_last_write_time, + file_change_time=file_change_time, + file_permission_format=file_permission_format, + file_request_intent=file_request_intent, + owner=owner, + group=group, + file_mode=file_mode, + file_property_semantics=file_property_semantics, + allow_trailing_dot=allow_trailing_dot, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [201]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) + response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) + response_headers["x-ms-request-server-encrypted"] = self._deserialize( + "bool", response.headers.get("x-ms-request-server-encrypted") + ) + response_headers["x-ms-file-permission-key"] = self._deserialize( + "str", response.headers.get("x-ms-file-permission-key") + ) + response_headers["x-ms-file-attributes"] = self._deserialize( + "str", response.headers.get("x-ms-file-attributes") + ) + response_headers["x-ms-file-creation-time"] = self._deserialize( + "str", response.headers.get("x-ms-file-creation-time") + ) + response_headers["x-ms-file-last-write-time"] = self._deserialize( + "str", response.headers.get("x-ms-file-last-write-time") + ) + response_headers["x-ms-file-change-time"] = self._deserialize( + "str", response.headers.get("x-ms-file-change-time") + ) + response_headers["x-ms-file-id"] = self._deserialize("str", response.headers.get("x-ms-file-id")) + response_headers["x-ms-file-parent-id"] = self._deserialize("str", response.headers.get("x-ms-file-parent-id")) + response_headers["x-ms-mode"] = self._deserialize("str", response.headers.get("x-ms-mode")) + response_headers["x-ms-owner"] = self._deserialize("str", response.headers.get("x-ms-owner")) + response_headers["x-ms-group"] = self._deserialize("str", response.headers.get("x-ms-group")) + response_headers["x-ms-file-file-type"] = self._deserialize("str", response.headers.get("x-ms-file-file-type")) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + + if cls: + return cls(pipeline_response, None, response_headers) # type: ignore + + @distributed_trace_async + async def get_properties( + self, + *, + sharesnapshot: Optional[str] = None, + timeout: Optional[int] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + allow_trailing_dot: Optional[bool] = None, + **kwargs: Any + ) -> None: + """Returns all system properties for the specified directory, and can also be used to check the + existence of a directory. + + :keyword sharesnapshot: The snapshot parameter is an opaque DateTime value that specifies a + share snapshot. Default value is None. + :paramtype sharesnapshot: str + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :keyword allow_trailing_dot: If true, the trailing dot will not be trimmed from the target + file/directory path. Default value is None. + :paramtype allow_trailing_dot: bool + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls: ClsType[None] = kwargs.pop("cls", None) + + _request = build_directory_get_properties_request( + sharesnapshot=sharesnapshot, + timeout=timeout, + file_request_intent=file_request_intent, + allow_trailing_dot=allow_trailing_dot, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["x-ms-meta"] = self._deserialize("{str}", response.headers.get("x-ms-meta")) + response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) + response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) + response_headers["x-ms-file-permission-key"] = self._deserialize( + "str", response.headers.get("x-ms-file-permission-key") + ) + response_headers["x-ms-file-attributes"] = self._deserialize( + "str", response.headers.get("x-ms-file-attributes") + ) + response_headers["x-ms-file-creation-time"] = self._deserialize( + "str", response.headers.get("x-ms-file-creation-time") + ) + response_headers["x-ms-file-last-write-time"] = self._deserialize( + "str", response.headers.get("x-ms-file-last-write-time") + ) + response_headers["x-ms-file-change-time"] = self._deserialize( + "str", response.headers.get("x-ms-file-change-time") + ) + response_headers["x-ms-file-id"] = self._deserialize("str", response.headers.get("x-ms-file-id")) + response_headers["x-ms-file-parent-id"] = self._deserialize("str", response.headers.get("x-ms-file-parent-id")) + response_headers["x-ms-server-encrypted"] = self._deserialize( + "bool", response.headers.get("x-ms-server-encrypted") + ) + response_headers["x-ms-mode"] = self._deserialize("str", response.headers.get("x-ms-mode")) + response_headers["x-ms-owner"] = self._deserialize("str", response.headers.get("x-ms-owner")) + response_headers["x-ms-group"] = self._deserialize("str", response.headers.get("x-ms-group")) + response_headers["x-ms-file-file-type"] = self._deserialize("str", response.headers.get("x-ms-file-file-type")) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + + if cls: + return cls(pipeline_response, None, response_headers) # type: ignore + + @distributed_trace_async + async def delete( + self, + *, + timeout: Optional[int] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + allow_trailing_dot: Optional[bool] = None, + **kwargs: Any + ) -> None: + """Removes the specified empty directory. Note that the directory must be empty before it can be + deleted. + + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :keyword allow_trailing_dot: If true, the trailing dot will not be trimmed from the target + file/directory path. Default value is None. + :paramtype allow_trailing_dot: bool + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls: ClsType[None] = kwargs.pop("cls", None) + + _request = build_directory_delete_request( + timeout=timeout, + file_request_intent=file_request_intent, + allow_trailing_dot=allow_trailing_dot, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [202]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + + if cls: + return cls(pipeline_response, None, response_headers) # type: ignore + + @distributed_trace_async + async def set_properties( # pylint: disable=too-many-locals + self, + *, + timeout: Optional[int] = None, + file_permission: Optional[str] = None, + file_permission_key: Optional[str] = None, + file_attributes: Optional[str] = None, + file_creation_time: Optional[str] = None, + file_last_write_time: Optional[str] = None, + file_change_time: Optional[str] = None, + file_permission_format: Optional[Union[str, _models.FilePermissionFormat]] = None, + allow_trailing_dot: Optional[bool] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + owner: Optional[str] = None, + group: Optional[str] = None, + file_mode: Optional[str] = None, + **kwargs: Any + ) -> None: + """Sets properties for the specified directory. + + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword file_permission: If specified the permission (security descriptor) shall be set for + the directory/file. This header can be used if Permission size is <= 8KB, else + x-ms-file-permission-key header shall be used. Default value: Inherit. If SDDL is specified as + input, it must have owner, group and dacl. Note: Only one of the x-ms-file-permission or + x-ms-file-permission-key should be specified. Default value is None. + :paramtype file_permission: str + :keyword file_permission_key: Key of the permission to be set for the directory/file. Note: + Only one of the x-ms-file-permission or x-ms-file-permission-key should be specified. Default + value is None. + :paramtype file_permission_key: str + :keyword file_attributes: If specified, the provided file attributes shall be set. Default + value: 'Archive' for file and 'Directory' for directory. 'None' can also be specified as + default. Default value is None. + :paramtype file_attributes: str + :keyword file_creation_time: Creation time for the file/directory. Default value: Now. Default + value is None. + :paramtype file_creation_time: str + :keyword file_last_write_time: Last write time for the file/directory. Default value: Now. + Default value is None. + :paramtype file_last_write_time: str + :keyword file_change_time: Change time for the file/directory. Default value: Now. Default + value is None. + :paramtype file_change_time: str + :keyword file_permission_format: Optional. Used to set permission format. Known values are: + "Sddl" and "Binary". Default value is None. + :paramtype file_permission_format: str or ~azure.storage.fileshare.models.FilePermissionFormat + :keyword allow_trailing_dot: If true, the trailing dot will not be trimmed from the target + file/directory path. Default value is None. + :paramtype allow_trailing_dot: bool + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :keyword owner: Optional, NFS only. The owner of the file or directory. Default value is None. + :paramtype owner: str + :keyword group: Optional, NFS only. The owning group of the file or directory. Default value is + None. + :paramtype group: str + :keyword file_mode: Optional, NFS only. The file mode of the file or directory. Default value + is None. + :paramtype file_mode: str + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls: ClsType[None] = kwargs.pop("cls", None) + + _request = build_directory_set_properties_request( + timeout=timeout, + file_permission=file_permission, + file_permission_key=file_permission_key, + file_attributes=file_attributes, + file_creation_time=file_creation_time, + file_last_write_time=file_last_write_time, + file_change_time=file_change_time, + file_permission_format=file_permission_format, + allow_trailing_dot=allow_trailing_dot, + file_request_intent=file_request_intent, + owner=owner, + group=group, + file_mode=file_mode, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) + response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) + response_headers["x-ms-request-server-encrypted"] = self._deserialize( + "bool", response.headers.get("x-ms-request-server-encrypted") + ) + response_headers["x-ms-file-permission-key"] = self._deserialize( + "str", response.headers.get("x-ms-file-permission-key") + ) + response_headers["x-ms-file-attributes"] = self._deserialize( + "str", response.headers.get("x-ms-file-attributes") + ) + response_headers["x-ms-file-creation-time"] = self._deserialize( + "str", response.headers.get("x-ms-file-creation-time") + ) + response_headers["x-ms-file-last-write-time"] = self._deserialize( + "str", response.headers.get("x-ms-file-last-write-time") + ) + response_headers["x-ms-file-change-time"] = self._deserialize( + "str", response.headers.get("x-ms-file-change-time") + ) + response_headers["x-ms-file-id"] = self._deserialize("str", response.headers.get("x-ms-file-id")) + response_headers["x-ms-file-parent-id"] = self._deserialize("str", response.headers.get("x-ms-file-parent-id")) + response_headers["x-ms-mode"] = self._deserialize("str", response.headers.get("x-ms-mode")) + response_headers["x-ms-owner"] = self._deserialize("str", response.headers.get("x-ms-owner")) + response_headers["x-ms-group"] = self._deserialize("str", response.headers.get("x-ms-group")) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + + if cls: + return cls(pipeline_response, None, response_headers) # type: ignore + + @distributed_trace_async + async def set_metadata( + self, + *, + timeout: Optional[int] = None, + metadata: Optional[dict[str, str]] = None, + allow_trailing_dot: Optional[bool] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any + ) -> None: + """Sets one or more user-defined name-value pairs for the specified directory. + + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword metadata: Optional. User-defined metadata for the resource. Default value is None. + :paramtype metadata: dict[str, str] + :keyword allow_trailing_dot: If true, the trailing dot will not be trimmed from the target + file/directory path. Default value is None. + :paramtype allow_trailing_dot: bool + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls: ClsType[None] = kwargs.pop("cls", None) + + _request = build_directory_set_metadata_request( + timeout=timeout, + metadata=metadata, + allow_trailing_dot=allow_trailing_dot, + file_request_intent=file_request_intent, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) + response_headers["x-ms-request-server-encrypted"] = self._deserialize( + "bool", response.headers.get("x-ms-request-server-encrypted") + ) + response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + + if cls: + return cls(pipeline_response, None, response_headers) # type: ignore + + @distributed_trace_async + async def list_files_and_directories_segment( + self, + *, + prefix: Optional[str] = None, + sharesnapshot: Optional[str] = None, + marker: Optional[str] = None, + maxresults: Optional[int] = None, + include: Optional[list[Union[str, _models.ListFilesIncludeType]]] = None, + timeout: Optional[int] = None, + include_extended_info: Optional[bool] = None, + allow_trailing_dot: Optional[bool] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any + ) -> _models.ListFilesAndDirectoriesSegmentResponse: + """Returns a list of files and directories under the specified share or directory. It lists the + contents only for a single level of the directory hierarchy. + + :keyword prefix: Filters the results to return only items whose name begins with the specified + prefix. Default value is None. + :paramtype prefix: str + :keyword sharesnapshot: The snapshot parameter is an opaque DateTime value that specifies a + share snapshot. Default value is None. + :paramtype sharesnapshot: str + :keyword marker: A string value that identifies the portion of the list to be returned with the + next listing operation. Default value is None. + :paramtype marker: str + :keyword maxresults: Specifies the maximum number of items to return. Default value is None. + :paramtype maxresults: int + :keyword include: Include this parameter to specify one or more datasets to include in the + response. Default value is None. + :paramtype include: list[str or ~azure.storage.fileshare.models.ListFilesIncludeType] + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword include_extended_info: Include extended information. Default value is None. + :paramtype include_extended_info: bool + :keyword allow_trailing_dot: If true, the trailing dot will not be trimmed from the target + file/directory path. Default value is None. + :paramtype allow_trailing_dot: bool + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :return: ListFilesAndDirectoriesSegmentResponse. The ListFilesAndDirectoriesSegmentResponse is + compatible with MutableMapping + :rtype: ~azure.storage.fileshare._generated.models.ListFilesAndDirectoriesSegmentResponse + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls: ClsType[_models.ListFilesAndDirectoriesSegmentResponse] = kwargs.pop("cls", None) + + _request = build_directory_list_files_and_directories_segment_request( + prefix=prefix, + sharesnapshot=sharesnapshot, + marker=marker, + maxresults=maxresults, + include=include, + timeout=timeout, + include_extended_info=include_extended_info, + allow_trailing_dot=allow_trailing_dot, + file_request_intent=file_request_intent, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _decompress = kwargs.pop("decompress", True) + _stream = kwargs.pop("stream", False) + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + if _stream: + try: + await response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + response_headers["Content-Type"] = self._deserialize("str", response.headers.get("Content-Type")) + + if _stream: + deserialized = response.iter_bytes() if _decompress else response.iter_raw() + else: + deserialized = _deserialize_xml(_models.ListFilesAndDirectoriesSegmentResponse, response.text()) + + if cls: + return cls(pipeline_response, deserialized, response_headers) # type: ignore + + return deserialized # type: ignore + + @distributed_trace_async + async def list_handles( + self, + *, + marker: Optional[str] = None, + maxresults: Optional[int] = None, + timeout: Optional[int] = None, + sharesnapshot: Optional[str] = None, + recursive: Optional[bool] = None, + allow_trailing_dot: Optional[bool] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any + ) -> _models.ListHandlesResponse: + """Lists handles for directory. + + :keyword marker: A string value that identifies the portion of the list to be returned with the + next listing operation. Default value is None. + :paramtype marker: str + :keyword maxresults: Specifies the maximum number of items to return. Default value is None. + :paramtype maxresults: int + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword sharesnapshot: The snapshot parameter is an opaque DateTime value that specifies a + share snapshot. Default value is None. + :paramtype sharesnapshot: str + :keyword recursive: Specifies operation should apply to the directory specified in the URI, its + files, its subdirectories and their files. Default value is None. + :paramtype recursive: bool + :keyword allow_trailing_dot: If true, the trailing dot will not be trimmed from the target + file/directory path. Default value is None. + :paramtype allow_trailing_dot: bool + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :return: ListHandlesResponse. The ListHandlesResponse is compatible with MutableMapping + :rtype: ~azure.storage.fileshare._generated.models.ListHandlesResponse + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls: ClsType[_models.ListHandlesResponse] = kwargs.pop("cls", None) + + _request = build_directory_list_handles_request( + marker=marker, + maxresults=maxresults, + timeout=timeout, + sharesnapshot=sharesnapshot, + recursive=recursive, + allow_trailing_dot=allow_trailing_dot, + file_request_intent=file_request_intent, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _decompress = kwargs.pop("decompress", True) + _stream = kwargs.pop("stream", False) + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + if _stream: + try: + await response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + response_headers["Content-Type"] = self._deserialize("str", response.headers.get("Content-Type")) + + if _stream: + deserialized = response.iter_bytes() if _decompress else response.iter_raw() + else: + deserialized = _deserialize_xml(_models.ListHandlesResponse, response.text()) + + if cls: + return cls(pipeline_response, deserialized, response_headers) # type: ignore + + return deserialized # type: ignore + + @distributed_trace_async + async def force_close_handles( + self, + *, + handle_id: str, + timeout: Optional[int] = None, + marker: Optional[str] = None, + sharesnapshot: Optional[str] = None, + recursive: Optional[bool] = None, + allow_trailing_dot: Optional[bool] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any + ) -> None: + """Closes all handles open for given directory. + + :keyword handle_id: Specifies handle ID opened on the file or directory to be closed. Asterisk + ('*') is a wildcard that specifies all handles. Required. + :paramtype handle_id: str + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword marker: A string value that identifies the portion of the list to be returned with the + next listing operation. Default value is None. + :paramtype marker: str + :keyword sharesnapshot: The snapshot parameter is an opaque DateTime value that specifies a + share snapshot. Default value is None. + :paramtype sharesnapshot: str + :keyword recursive: Specifies operation should apply to the directory specified in the URI, its + files, its subdirectories and their files. Default value is None. + :paramtype recursive: bool + :keyword allow_trailing_dot: If true, the trailing dot will not be trimmed from the target + file/directory path. Default value is None. + :paramtype allow_trailing_dot: bool + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls: ClsType[None] = kwargs.pop("cls", None) + + _request = build_directory_force_close_handles_request( + handle_id=handle_id, + timeout=timeout, + marker=marker, + sharesnapshot=sharesnapshot, + recursive=recursive, + allow_trailing_dot=allow_trailing_dot, + file_request_intent=file_request_intent, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["x-ms-marker"] = self._deserialize("str", response.headers.get("x-ms-marker")) + response_headers["x-ms-number-of-handles-closed"] = self._deserialize( + "int", response.headers.get("x-ms-number-of-handles-closed") + ) + response_headers["x-ms-number-of-handles-failed"] = self._deserialize( + "int", response.headers.get("x-ms-number-of-handles-failed") + ) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + + if cls: + return cls(pipeline_response, None, response_headers) # type: ignore + + @distributed_trace_async + async def rename( # pylint: disable=too-many-locals + self, + *, + rename_source: str, + timeout: Optional[int] = None, + replace_if_exists: Optional[bool] = None, + ignore_read_only: Optional[bool] = None, + source_lease_id: Optional[str] = None, + destination_lease_id: Optional[str] = None, + file_attributes: Optional[str] = None, + file_creation_time: Optional[str] = None, + file_last_write_time: Optional[str] = None, + file_change_time: Optional[str] = None, + file_permission: Optional[str] = None, + file_permission_format: Optional[Union[str, _models.FilePermissionFormat]] = None, + file_permission_key: Optional[str] = None, + metadata: Optional[dict[str, str]] = None, + allow_trailing_dot: Optional[bool] = None, + allow_source_trailing_dot: Optional[bool] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any + ) -> None: + """Renames a directory. By default, the destination is overwritten and if the destination already + exists and has a read-only attribute set, the operation will fail. + + :keyword rename_source: Required. Specifies the URI-style path of the source file, up to 2 KB + in length. Required. + :paramtype rename_source: str + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword replace_if_exists: Boolean. Default value is false. Set to true to indicate that the + destination should be overwritten. Default value is None. + :paramtype replace_if_exists: bool + :keyword ignore_read_only: Boolean. Default value is false. Set to true to overwrite the + destination even if it has the read-only attribute set. Default value is None. + :paramtype ignore_read_only: bool + :keyword source_lease_id: Required if the source file has an active lease. Default value is + None. + :paramtype source_lease_id: str + :keyword destination_lease_id: Required if the destination has an active lease. Default value + is None. + :paramtype destination_lease_id: str + :keyword file_attributes: If specified, the provided file attributes shall be set. Default + value is None. + :paramtype file_attributes: str + :keyword file_creation_time: Creation time for the directory. Default value is None. + :paramtype file_creation_time: str + :keyword file_last_write_time: Last write time for the directory. Default value is None. + :paramtype file_last_write_time: str + :keyword file_change_time: Change time for the directory. Default value is None. + :paramtype file_change_time: str + :keyword file_permission: If specified the permission shall be set for the directory. Default + value is None. + :paramtype file_permission: str + :keyword file_permission_format: Optional. Used to set permission format. Known values are: + "Sddl" and "Binary". Default value is None. + :paramtype file_permission_format: str or ~azure.storage.fileshare.models.FilePermissionFormat + :keyword file_permission_key: Key of the permission to be set. Default value is None. + :paramtype file_permission_key: str + :keyword metadata: Optional. User-defined metadata for the resource. Default value is None. + :paramtype metadata: dict[str, str] + :keyword allow_trailing_dot: If true, the trailing dot will not be trimmed from the target + file/directory path. Default value is None. + :paramtype allow_trailing_dot: bool + :keyword allow_source_trailing_dot: If true, the trailing dot will not be trimmed from the + source URI. Default value is None. + :paramtype allow_source_trailing_dot: bool + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls: ClsType[None] = kwargs.pop("cls", None) + + _request = build_directory_rename_request( + rename_source=rename_source, + timeout=timeout, + replace_if_exists=replace_if_exists, + ignore_read_only=ignore_read_only, + source_lease_id=source_lease_id, + destination_lease_id=destination_lease_id, + file_attributes=file_attributes, + file_creation_time=file_creation_time, + file_last_write_time=file_last_write_time, + file_change_time=file_change_time, + file_permission=file_permission, + file_permission_format=file_permission_format, + file_permission_key=file_permission_key, + metadata=metadata, + allow_trailing_dot=allow_trailing_dot, + allow_source_trailing_dot=allow_source_trailing_dot, + file_request_intent=file_request_intent, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) + response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) + response_headers["x-ms-request-server-encrypted"] = self._deserialize( + "bool", response.headers.get("x-ms-request-server-encrypted") + ) + response_headers["x-ms-file-permission-key"] = self._deserialize( + "str", response.headers.get("x-ms-file-permission-key") + ) + response_headers["x-ms-file-attributes"] = self._deserialize( + "str", response.headers.get("x-ms-file-attributes") + ) + response_headers["x-ms-file-creation-time"] = self._deserialize( + "str", response.headers.get("x-ms-file-creation-time") + ) + response_headers["x-ms-file-last-write-time"] = self._deserialize( + "str", response.headers.get("x-ms-file-last-write-time") + ) + response_headers["x-ms-file-change-time"] = self._deserialize( + "str", response.headers.get("x-ms-file-change-time") + ) + response_headers["x-ms-file-id"] = self._deserialize("str", response.headers.get("x-ms-file-id")) + response_headers["x-ms-file-parent-id"] = self._deserialize("str", response.headers.get("x-ms-file-parent-id")) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + + if cls: + return cls(pipeline_response, None, response_headers) # type: ignore + + +class FileOperations: # pylint: disable=too-many-public-methods + """ + .. warning:: + **DO NOT** instantiate this class directly. + + Instead, you should access the following operations through + :class:`~azure.storage.fileshare.aio.FileClient`'s + :attr:`file` attribute. + """ + + def __init__(self, *args, **kwargs) -> None: + input_args = list(args) + self._client: AsyncPipelineClient = input_args.pop(0) if input_args else kwargs.pop("client") + self._config: FileClientConfiguration = input_args.pop(0) if input_args else kwargs.pop("config") + self._serialize: Serializer = input_args.pop(0) if input_args else kwargs.pop("serializer") + self._deserialize: Deserializer = input_args.pop(0) if input_args else kwargs.pop("deserializer") + + @distributed_trace_async + async def create( # pylint: disable=too-many-locals + self, + optional_body: Optional[bytes] = None, + *, + file_content_length: int, + timeout: Optional[int] = None, + file_content_type: Optional[str] = None, + file_content_encoding: Optional[str] = None, + file_content_language: Optional[str] = None, + file_cache_control: Optional[str] = None, + file_content_md5: Optional[bytes] = None, + file_content_disposition: Optional[str] = None, + metadata: Optional[dict[str, str]] = None, + file_permission: Optional[str] = None, + file_permission_key: Optional[str] = None, + file_attributes: Optional[str] = None, + file_creation_time: Optional[str] = None, + file_last_write_time: Optional[str] = None, + file_change_time: Optional[str] = None, + file_permission_format: Optional[Union[str, _models.FilePermissionFormat]] = None, + lease_id: Optional[str] = None, + allow_trailing_dot: Optional[bool] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + owner: Optional[str] = None, + group: Optional[str] = None, + file_mode: Optional[str] = None, + nfs_file_type: Optional[Union[str, _models.NfsFileType]] = None, + content_md5: Optional[bytes] = None, + file_property_semantics: Optional[Union[str, _models.FilePropertySemantics]] = None, + content_length: Optional[int] = None, + structured_body_type: Optional[str] = None, + structured_content_length: Optional[int] = None, + **kwargs: Any + ) -> None: + """Creates a new file or replaces a file. Note it only initializes the file with no content. + + :param optional_body: Initial data. Default value is None. + :type optional_body: bytes + :keyword file_content_length: Specifies the maximum size for the file, up to 4 TB. Required. + :paramtype file_content_length: int + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword file_content_type: Sets the MIME content type of the file. The default type is + 'application/octet-stream'. Default value is None. + :paramtype file_content_type: str + :keyword file_content_encoding: Specifies which content encodings have been applied to the + file. Default value is None. + :paramtype file_content_encoding: str + :keyword file_content_language: Specifies the natural languages used by this resource. Default + value is None. + :paramtype file_content_language: str + :keyword file_cache_control: Sets the file's cache control. The File service stores this value + but does not use or modify it. Default value is None. + :paramtype file_cache_control: str + :keyword file_content_md5: An MD5 hash of the file content. This hash is used to verify the + integrity of the file during transport. Default value is None. + :paramtype file_content_md5: bytes + :keyword file_content_disposition: Sets the file's Content-Disposition header. Default value is + None. + :paramtype file_content_disposition: str + :keyword metadata: Optional. User-defined metadata for the resource. Default value is None. + :paramtype metadata: dict[str, str] + :keyword file_permission: If specified the permission (security descriptor) shall be set for + the directory/file. This header can be used if Permission size is <= 8KB, else + x-ms-file-permission-key header shall be used. Default value: Inherit. If SDDL is specified as + input, it must have owner, group and dacl. Note: Only one of the x-ms-file-permission or + x-ms-file-permission-key should be specified. Default value is None. + :paramtype file_permission: str + :keyword file_permission_key: Key of the permission to be set for the directory/file. Note: + Only one of the x-ms-file-permission or x-ms-file-permission-key should be specified. Default + value is None. + :paramtype file_permission_key: str + :keyword file_attributes: If specified, the provided file attributes shall be set. Default + value: 'Archive' for file and 'Directory' for directory. 'None' can also be specified as + default. Default value is None. + :paramtype file_attributes: str + :keyword file_creation_time: Creation time for the file/directory. Default value: Now. Default + value is None. + :paramtype file_creation_time: str + :keyword file_last_write_time: Last write time for the file/directory. Default value: Now. + Default value is None. + :paramtype file_last_write_time: str + :keyword file_change_time: Change time for the file/directory. Default value: Now. Default + value is None. + :paramtype file_change_time: str + :keyword file_permission_format: Optional. Used to set permission format. Known values are: + "Sddl" and "Binary". Default value is None. + :paramtype file_permission_format: str or ~azure.storage.fileshare.models.FilePermissionFormat + :keyword lease_id: If specified, the lease ID must match the lease ID of the file. Default + value is None. + :paramtype lease_id: str + :keyword allow_trailing_dot: If true, the trailing dot will not be trimmed from the target + file/directory path. Default value is None. + :paramtype allow_trailing_dot: bool + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :keyword owner: Optional, NFS only. The owner of the file or directory. Default value is None. + :paramtype owner: str + :keyword group: Optional, NFS only. The owning group of the file or directory. Default value is + None. + :paramtype group: str + :keyword file_mode: Optional, NFS only. The file mode of the file or directory. Default value + is None. + :paramtype file_mode: str + :keyword nfs_file_type: Optional, NFS only. Type of the file or directory. Known values are: + "Regular", "Directory", and "SymLink". Default value is None. + :paramtype nfs_file_type: str or ~azure.storage.fileshare.models.NfsFileType + :keyword content_md5: An MD5 hash of the content. This hash is used to verify the integrity of + the data during transport. Default value is None. + :paramtype content_md5: bytes + :keyword file_property_semantics: SMB only. Default value is New. Known values are: "New" and + "Restore". Default value is None. + :paramtype file_property_semantics: str or + ~azure.storage.fileshare.models.FilePropertySemantics + :keyword content_length: Specifies the number of bytes being transmitted in the request body. + When the x-ms-write header is set to clear, the value of this header must be set to zero.". + Default value is None. + :paramtype content_length: int + :keyword structured_body_type: Specifies the response content should be returned as a + structured message and specifies the message schema version and properties. Default value is + None. + :paramtype structured_body_type: str + :keyword structured_content_length: Required if the request body is a structured message. + Specifies the length of the blob/file content inside the message body. Will always be smaller + than Content-Length. Default value is None. + :paramtype structured_content_length: int + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = kwargs.pop("params", {}) or {} + + file_type: Literal["file"] = kwargs.pop("file_type", _headers.pop("x-ms-type", "file")) + content_type: Optional[str] = kwargs.pop( + "content_type", _headers.pop("Content-Type", "application/octet-stream") + ) + content_type = content_type if optional_body else None + cls: ClsType[None] = kwargs.pop("cls", None) + + _content = optional_body + + _request = build_file_create_request( + file_content_length=file_content_length, + timeout=timeout, + file_content_type=file_content_type, + file_content_encoding=file_content_encoding, + file_content_language=file_content_language, + file_cache_control=file_cache_control, + file_content_md5=file_content_md5, + file_content_disposition=file_content_disposition, + metadata=metadata, + file_permission=file_permission, + file_permission_key=file_permission_key, + file_attributes=file_attributes, + file_creation_time=file_creation_time, + file_last_write_time=file_last_write_time, + file_change_time=file_change_time, + file_permission_format=file_permission_format, + lease_id=lease_id, + allow_trailing_dot=allow_trailing_dot, + file_request_intent=file_request_intent, + owner=owner, + group=group, + file_mode=file_mode, + nfs_file_type=nfs_file_type, + content_md5=content_md5, + file_property_semantics=file_property_semantics, + content_length=content_length, + structured_body_type=structured_body_type, + structured_content_length=structured_content_length, + file_type=file_type, + content_type=content_type, + version=self._config.version, + content=_content, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [201]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) + response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) + response_headers["x-ms-request-server-encrypted"] = self._deserialize( + "bool", response.headers.get("x-ms-request-server-encrypted") + ) + response_headers["x-ms-file-permission-key"] = self._deserialize( + "str", response.headers.get("x-ms-file-permission-key") + ) + response_headers["x-ms-file-attributes"] = self._deserialize( + "str", response.headers.get("x-ms-file-attributes") + ) + response_headers["x-ms-file-creation-time"] = self._deserialize( + "str", response.headers.get("x-ms-file-creation-time") + ) + response_headers["x-ms-file-last-write-time"] = self._deserialize( + "str", response.headers.get("x-ms-file-last-write-time") + ) + response_headers["x-ms-file-change-time"] = self._deserialize( + "str", response.headers.get("x-ms-file-change-time") + ) + response_headers["x-ms-file-id"] = self._deserialize("str", response.headers.get("x-ms-file-id")) + response_headers["x-ms-file-parent-id"] = self._deserialize("str", response.headers.get("x-ms-file-parent-id")) + response_headers["x-ms-mode"] = self._deserialize("str", response.headers.get("x-ms-mode")) + response_headers["x-ms-owner"] = self._deserialize("str", response.headers.get("x-ms-owner")) + response_headers["x-ms-group"] = self._deserialize("str", response.headers.get("x-ms-group")) + response_headers["x-ms-file-file-type"] = self._deserialize("str", response.headers.get("x-ms-file-file-type")) + response_headers["Content-MD5"] = self._deserialize("bytearray", response.headers.get("Content-MD5")) + response_headers["Content-Length"] = self._deserialize("int", response.headers.get("Content-Length")) + response_headers["x-ms-structured-body"] = self._deserialize( + "str", response.headers.get("x-ms-structured-body") + ) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + + if cls: + return cls(pipeline_response, None, response_headers) # type: ignore + + @distributed_trace_async + async def download( + self, + *, + timeout: Optional[int] = None, + range: Optional[str] = None, + range_get_content_md5: Optional[bool] = None, + lease_id: Optional[str] = None, + allow_trailing_dot: Optional[bool] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + structured_body_type: Optional[str] = None, + **kwargs: Any + ) -> AsyncIterator[bytes]: + """Reads or downloads a file from the system, including its metadata and properties. + + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword range: Return file data only from the specified byte range. Default value is None. + :paramtype range: str + :keyword range_get_content_md5: When this header is set to true and specified together with the + Range header, the service returns the MD5 hash for the range, as long as the range is less than + or equal to 4 MB in size. Default value is None. + :paramtype range_get_content_md5: bool + :keyword lease_id: If specified, the lease ID must match the lease ID of the file. Default + value is None. + :paramtype lease_id: str + :keyword allow_trailing_dot: If true, the trailing dot will not be trimmed from the target + file/directory path. Default value is None. + :paramtype allow_trailing_dot: bool + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :keyword structured_body_type: Specifies the response content should be returned as a + structured message and specifies the message schema version and properties. Default value is + None. + :paramtype structured_body_type: str + :return: AsyncIterator[bytes] + :rtype: AsyncIterator[bytes] + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls: ClsType[AsyncIterator[bytes]] = kwargs.pop("cls", None) + + _request = build_file_download_request( + timeout=timeout, + range=range, + range_get_content_md5=range_get_content_md5, + lease_id=lease_id, + allow_trailing_dot=allow_trailing_dot, + file_request_intent=file_request_intent, + structured_body_type=structured_body_type, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _decompress = kwargs.pop("decompress", True) + _stream = kwargs.pop("stream", True) + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200, 206]: + if _stream: + try: + await response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) + response_headers["x-ms-meta"] = self._deserialize("{str}", response.headers.get("x-ms-meta")) + response_headers["Content-Length"] = self._deserialize("int", response.headers.get("Content-Length")) + response_headers["Content-Range"] = self._deserialize("str", response.headers.get("Content-Range")) + response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) + response_headers["Content-MD5"] = self._deserialize("bytearray", response.headers.get("Content-MD5")) + response_headers["Content-Encoding"] = self._deserialize("str", response.headers.get("Content-Encoding")) + response_headers["Cache-Control"] = self._deserialize("str", response.headers.get("Cache-Control")) + response_headers["Content-Disposition"] = self._deserialize("str", response.headers.get("Content-Disposition")) + response_headers["Content-Language"] = self._deserialize("str", response.headers.get("Content-Language")) + response_headers["Accept-Ranges"] = self._deserialize("str", response.headers.get("Accept-Ranges")) + response_headers["x-ms-copy-completion-time"] = self._deserialize( + "rfc-1123", response.headers.get("x-ms-copy-completion-time") + ) + response_headers["x-ms-copy-status-description"] = self._deserialize( + "str", response.headers.get("x-ms-copy-status-description") + ) + response_headers["x-ms-copy-id"] = self._deserialize("str", response.headers.get("x-ms-copy-id")) + response_headers["x-ms-copy-progress"] = self._deserialize("str", response.headers.get("x-ms-copy-progress")) + response_headers["x-ms-copy-source"] = self._deserialize("str", response.headers.get("x-ms-copy-source")) + response_headers["x-ms-copy-status"] = self._deserialize("str", response.headers.get("x-ms-copy-status")) + response_headers["x-ms-content-md5"] = self._deserialize("bytearray", response.headers.get("x-ms-content-md5")) + response_headers["x-ms-server-encrypted"] = self._deserialize( + "bool", response.headers.get("x-ms-server-encrypted") + ) + response_headers["x-ms-file-permission-key"] = self._deserialize( + "str", response.headers.get("x-ms-file-permission-key") + ) + response_headers["x-ms-file-attributes"] = self._deserialize( + "str", response.headers.get("x-ms-file-attributes") + ) + response_headers["x-ms-file-creation-time"] = self._deserialize( + "str", response.headers.get("x-ms-file-creation-time") + ) + response_headers["x-ms-file-last-write-time"] = self._deserialize( + "str", response.headers.get("x-ms-file-last-write-time") + ) + response_headers["x-ms-file-change-time"] = self._deserialize( + "str", response.headers.get("x-ms-file-change-time") + ) + response_headers["x-ms-file-id"] = self._deserialize("str", response.headers.get("x-ms-file-id")) + response_headers["x-ms-file-parent-id"] = self._deserialize("str", response.headers.get("x-ms-file-parent-id")) + response_headers["x-ms-lease-duration"] = self._deserialize("str", response.headers.get("x-ms-lease-duration")) + response_headers["x-ms-lease-state"] = self._deserialize("str", response.headers.get("x-ms-lease-state")) + response_headers["x-ms-lease-status"] = self._deserialize("str", response.headers.get("x-ms-lease-status")) + response_headers["x-ms-structured-body"] = self._deserialize( + "str", response.headers.get("x-ms-structured-body") + ) + response_headers["x-ms-structured-content-length"] = self._deserialize( + "int", response.headers.get("x-ms-structured-content-length") + ) + response_headers["x-ms-mode"] = self._deserialize("str", response.headers.get("x-ms-mode")) + response_headers["x-ms-owner"] = self._deserialize("str", response.headers.get("x-ms-owner")) + response_headers["x-ms-group"] = self._deserialize("str", response.headers.get("x-ms-group")) + response_headers["x-ms-link-count"] = self._deserialize("int", response.headers.get("x-ms-link-count")) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + response_headers["Content-Type"] = self._deserialize("str", response.headers.get("Content-Type")) + + deserialized = response.iter_bytes() if _decompress else response.iter_raw() + + if cls: + return cls(pipeline_response, deserialized, response_headers) # type: ignore + + return deserialized # type: ignore + + @distributed_trace_async + async def get_properties( + self, + *, + sharesnapshot: Optional[str] = None, + timeout: Optional[int] = None, + lease_id: Optional[str] = None, + allow_trailing_dot: Optional[bool] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any + ) -> bool: + """Returns all user-defined metadata, standard HTTP properties, and system properties for the + file. + + :keyword sharesnapshot: The snapshot parameter is an opaque DateTime value that specifies a + share snapshot. Default value is None. + :paramtype sharesnapshot: str + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword lease_id: If specified, the lease ID must match the lease ID of the file. Default + value is None. + :paramtype lease_id: str + :keyword allow_trailing_dot: If true, the trailing dot will not be trimmed from the target + file/directory path. Default value is None. + :paramtype allow_trailing_dot: bool + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :return: bool + :rtype: bool + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls: ClsType[None] = kwargs.pop("cls", None) + + _request = build_file_get_properties_request( + sharesnapshot=sharesnapshot, + timeout=timeout, + lease_id=lease_id, + allow_trailing_dot=allow_trailing_dot, + file_request_intent=file_request_intent, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) + response_headers["x-ms-meta"] = self._deserialize("{str}", response.headers.get("x-ms-meta")) + response_headers["x-ms-type"] = self._deserialize("str", response.headers.get("x-ms-type")) + response_headers["Content-Length"] = self._deserialize("int", response.headers.get("Content-Length")) + response_headers["Content-Type"] = self._deserialize("str", response.headers.get("Content-Type")) + response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) + response_headers["Content-MD5"] = self._deserialize("bytearray", response.headers.get("Content-MD5")) + response_headers["Content-Encoding"] = self._deserialize("str", response.headers.get("Content-Encoding")) + response_headers["Cache-Control"] = self._deserialize("str", response.headers.get("Cache-Control")) + response_headers["Content-Disposition"] = self._deserialize("str", response.headers.get("Content-Disposition")) + response_headers["Content-Language"] = self._deserialize("str", response.headers.get("Content-Language")) + response_headers["x-ms-copy-completion-time"] = self._deserialize( + "rfc-1123", response.headers.get("x-ms-copy-completion-time") + ) + response_headers["x-ms-copy-status-description"] = self._deserialize( + "str", response.headers.get("x-ms-copy-status-description") + ) + response_headers["x-ms-copy-id"] = self._deserialize("str", response.headers.get("x-ms-copy-id")) + response_headers["x-ms-copy-progress"] = self._deserialize("str", response.headers.get("x-ms-copy-progress")) + response_headers["x-ms-copy-source"] = self._deserialize("str", response.headers.get("x-ms-copy-source")) + response_headers["x-ms-copy-status"] = self._deserialize("str", response.headers.get("x-ms-copy-status")) + response_headers["x-ms-server-encrypted"] = self._deserialize( + "bool", response.headers.get("x-ms-server-encrypted") + ) + response_headers["x-ms-file-permission-key"] = self._deserialize( + "str", response.headers.get("x-ms-file-permission-key") + ) + response_headers["x-ms-file-attributes"] = self._deserialize( + "str", response.headers.get("x-ms-file-attributes") + ) + response_headers["x-ms-file-creation-time"] = self._deserialize( + "str", response.headers.get("x-ms-file-creation-time") + ) + response_headers["x-ms-file-last-write-time"] = self._deserialize( + "str", response.headers.get("x-ms-file-last-write-time") + ) + response_headers["x-ms-file-change-time"] = self._deserialize( + "str", response.headers.get("x-ms-file-change-time") + ) + response_headers["x-ms-file-id"] = self._deserialize("str", response.headers.get("x-ms-file-id")) + response_headers["x-ms-file-parent-id"] = self._deserialize("str", response.headers.get("x-ms-file-parent-id")) + response_headers["x-ms-lease-duration"] = self._deserialize("str", response.headers.get("x-ms-lease-duration")) + response_headers["x-ms-lease-state"] = self._deserialize("str", response.headers.get("x-ms-lease-state")) + response_headers["x-ms-lease-status"] = self._deserialize("str", response.headers.get("x-ms-lease-status")) + response_headers["x-ms-mode"] = self._deserialize("str", response.headers.get("x-ms-mode")) + response_headers["x-ms-owner"] = self._deserialize("str", response.headers.get("x-ms-owner")) + response_headers["x-ms-group"] = self._deserialize("str", response.headers.get("x-ms-group")) + response_headers["x-ms-file-file-type"] = self._deserialize("str", response.headers.get("x-ms-file-file-type")) + response_headers["x-ms-link-count"] = self._deserialize("int", response.headers.get("x-ms-link-count")) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + + if cls: + return cls(pipeline_response, None, response_headers) # type: ignore + return 200 <= response.status_code <= 299 + + @distributed_trace_async + async def delete( + self, + *, + timeout: Optional[int] = None, + lease_id: Optional[str] = None, + allow_trailing_dot: Optional[bool] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any + ) -> None: + """Removes the file from the storage account. + + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword lease_id: If specified, the lease ID must match the lease ID of the file. Default + value is None. + :paramtype lease_id: str + :keyword allow_trailing_dot: If true, the trailing dot will not be trimmed from the target + file/directory path. Default value is None. + :paramtype allow_trailing_dot: bool + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls: ClsType[None] = kwargs.pop("cls", None) + + _request = build_file_delete_request( + timeout=timeout, + lease_id=lease_id, + allow_trailing_dot=allow_trailing_dot, + file_request_intent=file_request_intent, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [202]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["x-ms-link-count"] = self._deserialize("int", response.headers.get("x-ms-link-count")) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + + if cls: + return cls(pipeline_response, None, response_headers) # type: ignore + + @distributed_trace_async + async def set_http_headers( # pylint: disable=too-many-locals + self, + *, + timeout: Optional[int] = None, + file_content_length: Optional[int] = None, + file_content_type: Optional[str] = None, + file_content_encoding: Optional[str] = None, + file_content_language: Optional[str] = None, + file_cache_control: Optional[str] = None, + file_content_md5: Optional[bytes] = None, + file_content_disposition: Optional[str] = None, + file_permission: Optional[str] = None, + file_permission_key: Optional[str] = None, + file_attributes: Optional[str] = None, + file_creation_time: Optional[str] = None, + file_last_write_time: Optional[str] = None, + file_change_time: Optional[str] = None, + file_permission_format: Optional[Union[str, _models.FilePermissionFormat]] = None, + lease_id: Optional[str] = None, + allow_trailing_dot: Optional[bool] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + owner: Optional[str] = None, + group: Optional[str] = None, + file_mode: Optional[str] = None, + **kwargs: Any + ) -> None: + """Sets HTTP headers on a file. + + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword file_content_length: Specifies the number of bytes being transmitted. Default value is + None. + :paramtype file_content_length: int + :keyword file_content_type: Sets the MIME content type of the file. The default type is + 'application/octet-stream'. Default value is None. + :paramtype file_content_type: str + :keyword file_content_encoding: Specifies which content encodings have been applied to the + file. Default value is None. + :paramtype file_content_encoding: str + :keyword file_content_language: Specifies the natural languages used by this resource. Default + value is None. + :paramtype file_content_language: str + :keyword file_cache_control: Sets the file's cache control. The File service stores this value + but does not use or modify it. Default value is None. + :paramtype file_cache_control: str + :keyword file_content_md5: An MD5 hash of the file content. This hash is used to verify the + integrity of the file during transport. Default value is None. + :paramtype file_content_md5: bytes + :keyword file_content_disposition: Sets the file's Content-Disposition header. Default value is + None. + :paramtype file_content_disposition: str + :keyword file_permission: If specified the permission (security descriptor) shall be set for + the directory/file. This header can be used if Permission size is <= 8KB, else + x-ms-file-permission-key header shall be used. Default value: Inherit. If SDDL is specified as + input, it must have owner, group and dacl. Note: Only one of the x-ms-file-permission or + x-ms-file-permission-key should be specified. Default value is None. + :paramtype file_permission: str + :keyword file_permission_key: Key of the permission to be set for the directory/file. Note: + Only one of the x-ms-file-permission or x-ms-file-permission-key should be specified. Default + value is None. + :paramtype file_permission_key: str + :keyword file_attributes: If specified, the provided file attributes shall be set. Default + value: 'Archive' for file and 'Directory' for directory. 'None' can also be specified as + default. Default value is None. + :paramtype file_attributes: str + :keyword file_creation_time: Creation time for the file/directory. Default value: Now. Default + value is None. + :paramtype file_creation_time: str + :keyword file_last_write_time: Last write time for the file/directory. Default value: Now. + Default value is None. + :paramtype file_last_write_time: str + :keyword file_change_time: Change time for the file/directory. Default value: Now. Default + value is None. + :paramtype file_change_time: str + :keyword file_permission_format: Optional. Used to set permission format. Known values are: + "Sddl" and "Binary". Default value is None. + :paramtype file_permission_format: str or ~azure.storage.fileshare.models.FilePermissionFormat + :keyword lease_id: If specified, the lease ID must match the lease ID of the file. Default + value is None. + :paramtype lease_id: str + :keyword allow_trailing_dot: If true, the trailing dot will not be trimmed from the target + file/directory path. Default value is None. + :paramtype allow_trailing_dot: bool + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :keyword owner: Optional, NFS only. The owner of the file or directory. Default value is None. + :paramtype owner: str + :keyword group: Optional, NFS only. The owning group of the file or directory. Default value is + None. + :paramtype group: str + :keyword file_mode: Optional, NFS only. The file mode of the file or directory. Default value + is None. + :paramtype file_mode: str + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls: ClsType[None] = kwargs.pop("cls", None) + + _request = build_file_set_http_headers_request( + timeout=timeout, + file_content_length=file_content_length, + file_content_type=file_content_type, + file_content_encoding=file_content_encoding, + file_content_language=file_content_language, + file_cache_control=file_cache_control, + file_content_md5=file_content_md5, + file_content_disposition=file_content_disposition, + file_permission=file_permission, + file_permission_key=file_permission_key, + file_attributes=file_attributes, + file_creation_time=file_creation_time, + file_last_write_time=file_last_write_time, + file_change_time=file_change_time, + file_permission_format=file_permission_format, + lease_id=lease_id, + allow_trailing_dot=allow_trailing_dot, + file_request_intent=file_request_intent, + owner=owner, + group=group, + file_mode=file_mode, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) + response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) + response_headers["x-ms-request-server-encrypted"] = self._deserialize( + "bool", response.headers.get("x-ms-request-server-encrypted") + ) + response_headers["x-ms-file-permission-key"] = self._deserialize( + "str", response.headers.get("x-ms-file-permission-key") + ) + response_headers["x-ms-file-attributes"] = self._deserialize( + "str", response.headers.get("x-ms-file-attributes") + ) + response_headers["x-ms-file-creation-time"] = self._deserialize( + "str", response.headers.get("x-ms-file-creation-time") + ) + response_headers["x-ms-file-last-write-time"] = self._deserialize( + "str", response.headers.get("x-ms-file-last-write-time") + ) + response_headers["x-ms-file-change-time"] = self._deserialize( + "str", response.headers.get("x-ms-file-change-time") + ) + response_headers["x-ms-file-id"] = self._deserialize("str", response.headers.get("x-ms-file-id")) + response_headers["x-ms-file-parent-id"] = self._deserialize("str", response.headers.get("x-ms-file-parent-id")) + response_headers["x-ms-mode"] = self._deserialize("str", response.headers.get("x-ms-mode")) + response_headers["x-ms-owner"] = self._deserialize("str", response.headers.get("x-ms-owner")) + response_headers["x-ms-group"] = self._deserialize("str", response.headers.get("x-ms-group")) + response_headers["x-ms-link-count"] = self._deserialize("int", response.headers.get("x-ms-link-count")) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + + if cls: + return cls(pipeline_response, None, response_headers) # type: ignore + + @distributed_trace_async + async def set_metadata( + self, + *, + timeout: Optional[int] = None, + metadata: Optional[dict[str, str]] = None, + lease_id: Optional[str] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + allow_trailing_dot: Optional[bool] = None, + **kwargs: Any + ) -> None: + """Sets one or more user-defined name-value pairs for the specified file. + + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword metadata: Optional. User-defined metadata for the resource. Default value is None. + :paramtype metadata: dict[str, str] + :keyword lease_id: If specified, the lease ID must match the lease ID of the file. Default + value is None. + :paramtype lease_id: str + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :keyword allow_trailing_dot: If true, the trailing dot will not be trimmed from the target + file/directory path. Default value is None. + :paramtype allow_trailing_dot: bool + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls: ClsType[None] = kwargs.pop("cls", None) + + _request = build_file_set_metadata_request( + timeout=timeout, + metadata=metadata, + lease_id=lease_id, + file_request_intent=file_request_intent, + allow_trailing_dot=allow_trailing_dot, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) + response_headers["x-ms-request-server-encrypted"] = self._deserialize( + "bool", response.headers.get("x-ms-request-server-encrypted") + ) + response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + + if cls: + return cls(pipeline_response, None, response_headers) # type: ignore + + @distributed_trace_async + async def acquire_lease( + self, + *, + timeout: Optional[int] = None, + lease_duration: Optional[int] = None, + proposed_lease_id: Optional[str] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + allow_trailing_dot: Optional[bool] = None, + **kwargs: Any + ) -> None: + """The Lease File operation establishes and manages a lock on a file for write and delete + operations. + + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword lease_duration: Specifies the duration of the lease, in seconds, or negative one (-1) + for a lease that never expires. A non-infinite lease can be between 15 and 60 seconds. A lease + duration cannot be changed using renew or change. Default value is None. + :paramtype lease_duration: int + :keyword proposed_lease_id: Proposed lease ID, in a GUID string format. The File service + returns 400 (Invalid request) if the proposed lease ID is not in the correct format. See Guid + Constructor (String) for a list of valid GUID string formats. Default value is None. + :paramtype proposed_lease_id: str + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :keyword allow_trailing_dot: If true, the trailing dot will not be trimmed from the target + file/directory path. Default value is None. + :paramtype allow_trailing_dot: bool + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + action: Literal["acquire"] = kwargs.pop("action", _headers.pop("x-ms-lease-action", "acquire")) + cls: ClsType[None] = kwargs.pop("cls", None) + + _request = build_file_acquire_lease_request( + timeout=timeout, + lease_duration=lease_duration, + proposed_lease_id=proposed_lease_id, + file_request_intent=file_request_intent, + allow_trailing_dot=allow_trailing_dot, + action=action, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [201]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) + response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) + response_headers["x-ms-lease-id"] = self._deserialize("str", response.headers.get("x-ms-lease-id")) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + + if cls: + return cls(pipeline_response, None, response_headers) # type: ignore + + @distributed_trace_async + async def release_lease( + self, + *, + lease_id: str, + timeout: Optional[int] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + allow_trailing_dot: Optional[bool] = None, + **kwargs: Any + ) -> None: + """The Lease File operation establishes and manages a lock on a file for write and delete + operations. + + :keyword lease_id: Specifies the current lease ID on the resource. Required. + :paramtype lease_id: str + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :keyword allow_trailing_dot: If true, the trailing dot will not be trimmed from the target + file/directory path. Default value is None. + :paramtype allow_trailing_dot: bool + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + action: Literal["release"] = kwargs.pop("action", _headers.pop("x-ms-lease-action", "release")) + cls: ClsType[None] = kwargs.pop("cls", None) + + _request = build_file_release_lease_request( + lease_id=lease_id, + timeout=timeout, + file_request_intent=file_request_intent, + allow_trailing_dot=allow_trailing_dot, + action=action, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) + response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + + if cls: + return cls(pipeline_response, None, response_headers) # type: ignore + + @distributed_trace_async + async def change_lease( + self, + *, + lease_id: str, + timeout: Optional[int] = None, + proposed_lease_id: Optional[str] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + allow_trailing_dot: Optional[bool] = None, + **kwargs: Any + ) -> None: + """The Lease File operation establishes and manages a lock on a file for write and delete + operations. + + :keyword lease_id: Specifies the current lease ID on the resource. Required. + :paramtype lease_id: str + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword proposed_lease_id: Proposed lease ID, in a GUID string format. The File service + returns 400 (Invalid request) if the proposed lease ID is not in the correct format. See Guid + Constructor (String) for a list of valid GUID string formats. Default value is None. + :paramtype proposed_lease_id: str + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :keyword allow_trailing_dot: If true, the trailing dot will not be trimmed from the target + file/directory path. Default value is None. + :paramtype allow_trailing_dot: bool + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + action: Literal["change"] = kwargs.pop("action", _headers.pop("x-ms-lease-action", "change")) + cls: ClsType[None] = kwargs.pop("cls", None) + + _request = build_file_change_lease_request( + lease_id=lease_id, + timeout=timeout, + proposed_lease_id=proposed_lease_id, + file_request_intent=file_request_intent, + allow_trailing_dot=allow_trailing_dot, + action=action, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) + response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) + response_headers["x-ms-lease-id"] = self._deserialize("str", response.headers.get("x-ms-lease-id")) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + + if cls: + return cls(pipeline_response, None, response_headers) # type: ignore + + @distributed_trace_async + async def break_lease( + self, + *, + timeout: Optional[int] = None, + lease_id: Optional[str] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + allow_trailing_dot: Optional[bool] = None, + **kwargs: Any + ) -> None: + """The Lease File operation establishes and manages a lock on a file for write and delete + operations. + + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword lease_id: If specified, the lease ID must match the lease ID of the file. Default + value is None. + :paramtype lease_id: str + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :keyword allow_trailing_dot: If true, the trailing dot will not be trimmed from the target + file/directory path. Default value is None. + :paramtype allow_trailing_dot: bool + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + action: Literal["break"] = kwargs.pop("action", _headers.pop("x-ms-lease-action", "break")) + cls: ClsType[None] = kwargs.pop("cls", None) + + _request = build_file_break_lease_request( + timeout=timeout, + lease_id=lease_id, + file_request_intent=file_request_intent, + allow_trailing_dot=allow_trailing_dot, + action=action, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [202]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) + response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) + response_headers["x-ms-lease-time"] = self._deserialize("int", response.headers.get("x-ms-lease-time")) + response_headers["x-ms-lease-id"] = self._deserialize("str", response.headers.get("x-ms-lease-id")) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + + if cls: + return cls(pipeline_response, None, response_headers) # type: ignore + + @distributed_trace_async + async def upload_range( # pylint: disable=too-many-locals + self, + optional_body: Optional[bytes] = None, + *, + range: str, + file_range_write: Union[str, _models.FileRangeWriteType], + content_length: int, + timeout: Optional[int] = None, + content_md5: Optional[bytes] = None, + lease_id: Optional[str] = None, + file_last_written_mode: Optional[Union[str, _models.FileLastWrittenMode]] = None, + allow_trailing_dot: Optional[bool] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + structured_body_type: Optional[str] = None, + structured_content_length: Optional[int] = None, + **kwargs: Any + ) -> None: + """Upload a range of bytes to a file. + + :param optional_body: Initial data. Default value is None. + :type optional_body: bytes + :keyword range: Specifies the range of bytes to be written. Both the start and end of the range + must be specified. Required. + :paramtype range: str + :keyword file_range_write: Specify one of the following options: - Update: Writes the bytes + specified by the request body into the specified range. - Clear: Clears the specified range and + releases the space used in storage for that range. Known values are: "update" and "clear". + Required. + :paramtype file_range_write: str or ~azure.storage.fileshare.models.FileRangeWriteType + :keyword content_length: The number of bytes being transmitted in the request body. Required. + :paramtype content_length: int + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword content_md5: An MD5 hash of the content. This hash is used to verify the integrity of + the data during transport. Default value is None. + :paramtype content_md5: bytes + :keyword lease_id: If specified, the lease ID must match the lease ID of the file. Default + value is None. + :paramtype lease_id: str + :keyword file_last_written_mode: If the file last write time should be preserved or + overwritten. Known values are: "Now" and "Preserve". Default value is None. + :paramtype file_last_written_mode: str or ~azure.storage.fileshare.models.FileLastWrittenMode + :keyword allow_trailing_dot: If true, the trailing dot will not be trimmed from the target + file/directory path. Default value is None. + :paramtype allow_trailing_dot: bool + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :keyword structured_body_type: Specifies the response content should be returned as a + structured message and specifies the message schema version and properties. Default value is + None. + :paramtype structured_body_type: str + :keyword structured_content_length: Required if the request body is a structured message. + Specifies the length of the blob/file content inside the message body. Will always be smaller + than Content-Length. Default value is None. + :paramtype structured_content_length: int + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = kwargs.pop("params", {}) or {} + + content_type: Optional[str] = kwargs.pop( + "content_type", _headers.pop("Content-Type", "application/octet-stream") + ) + content_type = content_type if optional_body else None + cls: ClsType[None] = kwargs.pop("cls", None) + + _content = optional_body + + _request = build_file_upload_range_request( + range=range, + file_range_write=file_range_write, + content_length=content_length, + timeout=timeout, + content_md5=content_md5, + lease_id=lease_id, + file_last_written_mode=file_last_written_mode, + allow_trailing_dot=allow_trailing_dot, + file_request_intent=file_request_intent, + structured_body_type=structured_body_type, + structured_content_length=structured_content_length, + content_type=content_type, + version=self._config.version, + content=_content, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [201]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) + response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) + response_headers["Content-MD5"] = self._deserialize("bytearray", response.headers.get("Content-MD5")) + response_headers["x-ms-request-server-encrypted"] = self._deserialize( + "bool", response.headers.get("x-ms-request-server-encrypted") + ) + response_headers["x-ms-file-last-write-time"] = self._deserialize( + "str", response.headers.get("x-ms-file-last-write-time") + ) + response_headers["x-ms-structured-body"] = self._deserialize( + "str", response.headers.get("x-ms-structured-body") + ) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + + if cls: + return cls(pipeline_response, None, response_headers) # type: ignore + + @distributed_trace_async + async def upload_range_from_url( # pylint: disable=too-many-locals + self, + *, + range: str, + copy_source: str, + file_range_write_from_url: Union[str, _models.FileRangeWriteFromUrlType], + content_length: int, + source_range: Optional[str] = None, + timeout: Optional[int] = None, + source_content_crc64: Optional[bytes] = None, + source_if_match_crc64: Optional[bytes] = None, + source_if_none_match_crc64: Optional[bytes] = None, + lease_id: Optional[str] = None, + copy_source_authorization: Optional[str] = None, + file_last_written_mode: Optional[Union[str, _models.FileLastWrittenMode]] = None, + allow_trailing_dot: Optional[bool] = None, + allow_source_trailing_dot: Optional[bool] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any + ) -> None: + """Upload a range of bytes to a file where the contents are read from a URL. + + :keyword range: Specifies the range of bytes to be written. Both the start and end of the range + must be specified. Required. + :paramtype range: str + :keyword copy_source: Specifies the URL of the source file or blob, up to 2 KB in length. + Required. + :paramtype copy_source: str + :keyword file_range_write_from_url: Only update is supported. "update" Required. + :paramtype file_range_write_from_url: str or + ~azure.storage.fileshare.models.FileRangeWriteFromUrlType + :keyword content_length: The number of bytes being transmitted in the request body. Required. + :paramtype content_length: int + :keyword source_range: Bytes of source data in the specified range. Default value is None. + :paramtype source_range: str + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword source_content_crc64: Specify the CRC64 hash of the source content. Default value is + None. + :paramtype source_content_crc64: bytes + :keyword source_if_match_crc64: Specify the CRC64 hash value to check for source content + integrity. Default value is None. + :paramtype source_if_match_crc64: bytes + :keyword source_if_none_match_crc64: Specify the CRC64 hash value to check for source content + mismatch. Default value is None. + :paramtype source_if_none_match_crc64: bytes + :keyword lease_id: If specified, the lease ID must match the lease ID of the file. Default + value is None. + :paramtype lease_id: str + :keyword copy_source_authorization: Only Bearer type is supported. Credentials should be a + valid OAuth access token to copy source. Default value is None. + :paramtype copy_source_authorization: str + :keyword file_last_written_mode: If the file last write time should be preserved or + overwritten. Known values are: "Now" and "Preserve". Default value is None. + :paramtype file_last_written_mode: str or ~azure.storage.fileshare.models.FileLastWrittenMode + :keyword allow_trailing_dot: If true, the trailing dot will not be trimmed from the target + file/directory path. Default value is None. + :paramtype allow_trailing_dot: bool + :keyword allow_source_trailing_dot: If true, the trailing dot will not be trimmed from the + source URI. Default value is None. + :paramtype allow_source_trailing_dot: bool + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls: ClsType[None] = kwargs.pop("cls", None) + + _request = build_file_upload_range_from_url_request( + range=range, + copy_source=copy_source, + file_range_write_from_url=file_range_write_from_url, + content_length=content_length, + source_range=source_range, + timeout=timeout, + source_content_crc64=source_content_crc64, + source_if_match_crc64=source_if_match_crc64, + source_if_none_match_crc64=source_if_none_match_crc64, + lease_id=lease_id, + copy_source_authorization=copy_source_authorization, + file_last_written_mode=file_last_written_mode, + allow_trailing_dot=allow_trailing_dot, + allow_source_trailing_dot=allow_source_trailing_dot, + file_request_intent=file_request_intent, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [201]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) + response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) + response_headers["Content-MD5"] = self._deserialize("bytearray", response.headers.get("Content-MD5")) + response_headers["x-ms-content-crc64"] = self._deserialize( + "bytearray", response.headers.get("x-ms-content-crc64") + ) + response_headers["x-ms-request-server-encrypted"] = self._deserialize( + "bool", response.headers.get("x-ms-request-server-encrypted") + ) + response_headers["x-ms-file-last-write-time"] = self._deserialize( + "str", response.headers.get("x-ms-file-last-write-time") + ) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + + if cls: + return cls(pipeline_response, None, response_headers) # type: ignore + + @distributed_trace_async + async def get_range_list( + self, + *, + sharesnapshot: Optional[str] = None, + prevsharesnapshot: Optional[str] = None, + timeout: Optional[int] = None, + range: Optional[str] = None, + lease_id: Optional[str] = None, + allow_trailing_dot: Optional[bool] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + support_rename: Optional[bool] = None, + **kwargs: Any + ) -> _models.ShareFileRangeList: + """Returns the list of valid page ranges for a file or snapshot of a file. + + :keyword sharesnapshot: The snapshot parameter is an opaque DateTime value that specifies a + share snapshot. Default value is None. + :paramtype sharesnapshot: str + :keyword prevsharesnapshot: The previous snapshot parameter is an opaque DateTime value that + specifies a previous file snapshot to compare against. Default value is None. + :paramtype prevsharesnapshot: str + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword range: Return file data only from the specified byte range. Default value is None. + :paramtype range: str + :keyword lease_id: If specified, the lease ID must match the lease ID of the file. Default + value is None. + :paramtype lease_id: str + :keyword allow_trailing_dot: If true, the trailing dot will not be trimmed from the target + file/directory path. Default value is None. + :paramtype allow_trailing_dot: bool + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :keyword support_rename: This header is allowed only when PrevShareSnapshot query parameter is + set. Determines whether the changed ranges for a file that has been renamed or moved should be + listed. Default value is None. + :paramtype support_rename: bool + :return: ShareFileRangeList. The ShareFileRangeList is compatible with MutableMapping + :rtype: ~azure.storage.fileshare._generated.models.ShareFileRangeList + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls: ClsType[_models.ShareFileRangeList] = kwargs.pop("cls", None) + + _request = build_file_get_range_list_request( + sharesnapshot=sharesnapshot, + prevsharesnapshot=prevsharesnapshot, + timeout=timeout, + range=range, + lease_id=lease_id, + allow_trailing_dot=allow_trailing_dot, + file_request_intent=file_request_intent, + support_rename=support_rename, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _decompress = kwargs.pop("decompress", True) + _stream = kwargs.pop("stream", False) + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + if _stream: + try: + await response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) + response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) + response_headers["x-ms-content-length"] = self._deserialize("int", response.headers.get("x-ms-content-length")) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + response_headers["Content-Type"] = self._deserialize("str", response.headers.get("Content-Type")) + + if _stream: + deserialized = response.iter_bytes() if _decompress else response.iter_raw() + else: + deserialized = _deserialize_xml(_models.ShareFileRangeList, response.text()) + + if cls: + return cls(pipeline_response, deserialized, response_headers) # type: ignore + + return deserialized # type: ignore + + @distributed_trace_async + async def start_copy( # pylint: disable=too-many-locals + self, + *, + copy_source: str, + timeout: Optional[int] = None, + metadata: Optional[dict[str, str]] = None, + file_permission: Optional[str] = None, + file_permission_format: Optional[Union[str, _models.FilePermissionFormat]] = None, + file_permission_key: Optional[str] = None, + file_permission_copy_mode: Optional[Union[str, _models.PermissionCopyModeType]] = None, + ignore_read_only: Optional[bool] = None, + file_attributes: Optional[str] = None, + file_creation_time: Optional[str] = None, + file_last_write_time: Optional[str] = None, + file_change_time: Optional[str] = None, + set_archive_attribute: Optional[bool] = None, + lease_id: Optional[str] = None, + allow_trailing_dot: Optional[bool] = None, + allow_source_trailing_dot: Optional[bool] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + owner: Optional[str] = None, + group: Optional[str] = None, + file_mode: Optional[str] = None, + file_mode_copy_mode: Optional[Union[str, _models.ModeCopyMode]] = None, + file_owner_copy_mode: Optional[Union[str, _models.OwnerCopyMode]] = None, + **kwargs: Any + ) -> None: + """Copies a blob or file to a destination file within the storage account. + + :keyword copy_source: Specifies the URL of the source file or blob, up to 2 KB in length. + Required. + :paramtype copy_source: str + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword metadata: Optional. User-defined metadata for the resource. Default value is None. + :paramtype metadata: dict[str, str] + :keyword file_permission: If specified the permission shall be set for the file. Default value + is None. + :paramtype file_permission: str + :keyword file_permission_format: Optional. Used to set permission format. Known values are: + "Sddl" and "Binary". Default value is None. + :paramtype file_permission_format: str or ~azure.storage.fileshare.models.FilePermissionFormat + :keyword file_permission_key: Key of the permission to be set. Default value is None. + :paramtype file_permission_key: str + :keyword file_permission_copy_mode: Specifies the option to copy file security descriptor from + source file or to set it using the value which is defined by the header value of + x-ms-file-permission or x-ms-file-permission-key. Known values are: "source" and "override". + Default value is None. + :paramtype file_permission_copy_mode: str or + ~azure.storage.fileshare.models.PermissionCopyModeType + :keyword ignore_read_only: A boolean value that specifies whether the ReadOnly attribute on a + preexisting destination file should be respected or overridden. Default value is None. + :paramtype ignore_read_only: bool + :keyword file_attributes: If specified, the provided file attributes shall be set. Default + value is None. + :paramtype file_attributes: str + :keyword file_creation_time: Creation time for the file. Default value is None. + :paramtype file_creation_time: str + :keyword file_last_write_time: Last write time for the file. Default value is None. + :paramtype file_last_write_time: str + :keyword file_change_time: Change time for the file. Default value is None. + :paramtype file_change_time: str + :keyword set_archive_attribute: Optional. Sets the archive attribute on the destination file. + Default value is None. + :paramtype set_archive_attribute: bool + :keyword lease_id: If specified, the lease ID must match the lease ID of the file. Default + value is None. + :paramtype lease_id: str + :keyword allow_trailing_dot: If true, the trailing dot will not be trimmed from the target + file/directory path. Default value is None. + :paramtype allow_trailing_dot: bool + :keyword allow_source_trailing_dot: If true, the trailing dot will not be trimmed from the + source URI. Default value is None. + :paramtype allow_source_trailing_dot: bool + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :keyword owner: Optional, NFS only. The owner of the file or directory. Default value is None. + :paramtype owner: str + :keyword group: Optional, NFS only. The owning group of the file or directory. Default value is + None. + :paramtype group: str + :keyword file_mode: Optional, NFS only. The file mode of the file or directory. Default value + is None. + :paramtype file_mode: str + :keyword file_mode_copy_mode: Specifies mode copy option for the file. Known values are: + "source" and "override". Default value is None. + :paramtype file_mode_copy_mode: str or ~azure.storage.fileshare.models.ModeCopyMode + :keyword file_owner_copy_mode: Specifies owner copy option for the file. Known values are: + "source" and "override". Default value is None. + :paramtype file_owner_copy_mode: str or ~azure.storage.fileshare.models.OwnerCopyMode + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls: ClsType[None] = kwargs.pop("cls", None) + + _request = build_file_start_copy_request( + copy_source=copy_source, + timeout=timeout, + metadata=metadata, + file_permission=file_permission, + file_permission_format=file_permission_format, + file_permission_key=file_permission_key, + file_permission_copy_mode=file_permission_copy_mode, + ignore_read_only=ignore_read_only, + file_attributes=file_attributes, + file_creation_time=file_creation_time, + file_last_write_time=file_last_write_time, + file_change_time=file_change_time, + set_archive_attribute=set_archive_attribute, + lease_id=lease_id, + allow_trailing_dot=allow_trailing_dot, + allow_source_trailing_dot=allow_source_trailing_dot, + file_request_intent=file_request_intent, + owner=owner, + group=group, + file_mode=file_mode, + file_mode_copy_mode=file_mode_copy_mode, + file_owner_copy_mode=file_owner_copy_mode, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [202]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) + response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) + response_headers["x-ms-copy-id"] = self._deserialize("str", response.headers.get("x-ms-copy-id")) + response_headers["x-ms-copy-status"] = self._deserialize("str", response.headers.get("x-ms-copy-status")) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + + if cls: + return cls(pipeline_response, None, response_headers) # type: ignore + + @distributed_trace_async + async def abort_copy( + self, + *, + copyid: str, + timeout: Optional[int] = None, + lease_id: Optional[str] = None, + allow_trailing_dot: Optional[bool] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any + ) -> None: + """Aborts a pending Copy File operation, and leaves a destination file with zero length and full + metadata. + + :keyword copyid: The copy identifier provided in the x-ms-copy-id header of the original Copy + File operation. Required. + :paramtype copyid: str + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword lease_id: If specified, the lease ID must match the lease ID of the file. Default + value is None. + :paramtype lease_id: str + :keyword allow_trailing_dot: If true, the trailing dot will not be trimmed from the target + file/directory path. Default value is None. + :paramtype allow_trailing_dot: bool + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + copy_action_abort_constant: Literal["abort"] = kwargs.pop( + "copy_action_abort_constant", _headers.pop("x-ms-copy-action", "abort") + ) + cls: ClsType[None] = kwargs.pop("cls", None) + + _request = build_file_abort_copy_request( + copyid=copyid, + timeout=timeout, + lease_id=lease_id, + allow_trailing_dot=allow_trailing_dot, + file_request_intent=file_request_intent, + copy_action_abort_constant=copy_action_abort_constant, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [204]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + + if cls: + return cls(pipeline_response, None, response_headers) # type: ignore + + @distributed_trace_async + async def list_handles( + self, + *, + marker: Optional[str] = None, + maxresults: Optional[int] = None, + timeout: Optional[int] = None, + sharesnapshot: Optional[str] = None, + allow_trailing_dot: Optional[bool] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any + ) -> _models.ListHandlesResponse: + """Lists handles for file. + + :keyword marker: A string value that identifies the portion of the list to be returned with the + next listing operation. Default value is None. + :paramtype marker: str + :keyword maxresults: Specifies the maximum number of items to return. Default value is None. + :paramtype maxresults: int + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword sharesnapshot: The snapshot parameter is an opaque DateTime value that specifies a + share snapshot. Default value is None. + :paramtype sharesnapshot: str + :keyword allow_trailing_dot: If true, the trailing dot will not be trimmed from the target + file/directory path. Default value is None. + :paramtype allow_trailing_dot: bool + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :return: ListHandlesResponse. The ListHandlesResponse is compatible with MutableMapping + :rtype: ~azure.storage.fileshare._generated.models.ListHandlesResponse + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls: ClsType[_models.ListHandlesResponse] = kwargs.pop("cls", None) + + _request = build_file_list_handles_request( + marker=marker, + maxresults=maxresults, + timeout=timeout, + sharesnapshot=sharesnapshot, + allow_trailing_dot=allow_trailing_dot, + file_request_intent=file_request_intent, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _decompress = kwargs.pop("decompress", True) + _stream = kwargs.pop("stream", False) + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + if _stream: + try: + await response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + response_headers["Content-Type"] = self._deserialize("str", response.headers.get("Content-Type")) + + if _stream: + deserialized = response.iter_bytes() if _decompress else response.iter_raw() + else: + deserialized = _deserialize_xml(_models.ListHandlesResponse, response.text()) + + if cls: + return cls(pipeline_response, deserialized, response_headers) # type: ignore + + return deserialized # type: ignore + + @distributed_trace_async + async def force_close_handles( + self, + *, + handle_id: str, + timeout: Optional[int] = None, + marker: Optional[str] = None, + sharesnapshot: Optional[str] = None, + allow_trailing_dot: Optional[bool] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any + ) -> None: + """Closes all handles open for given file. + + :keyword handle_id: Specifies handle ID opened on the file or directory to be closed. Asterisk + ('*') is a wildcard that specifies all handles. Required. + :paramtype handle_id: str + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword marker: A string value that identifies the portion of the list to be returned with the + next listing operation. Default value is None. + :paramtype marker: str + :keyword sharesnapshot: The snapshot parameter is an opaque DateTime value that specifies a + share snapshot. Default value is None. + :paramtype sharesnapshot: str + :keyword allow_trailing_dot: If true, the trailing dot will not be trimmed from the target + file/directory path. Default value is None. + :paramtype allow_trailing_dot: bool + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls: ClsType[None] = kwargs.pop("cls", None) + + _request = build_file_force_close_handles_request( + handle_id=handle_id, + timeout=timeout, + marker=marker, + sharesnapshot=sharesnapshot, + allow_trailing_dot=allow_trailing_dot, + file_request_intent=file_request_intent, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["x-ms-marker"] = self._deserialize("str", response.headers.get("x-ms-marker")) + response_headers["x-ms-number-of-handles-closed"] = self._deserialize( + "int", response.headers.get("x-ms-number-of-handles-closed") + ) + response_headers["x-ms-number-of-handles-failed"] = self._deserialize( + "int", response.headers.get("x-ms-number-of-handles-failed") + ) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + + if cls: + return cls(pipeline_response, None, response_headers) # type: ignore + + @distributed_trace_async + async def rename( # pylint: disable=too-many-locals + self, + *, + rename_source: str, + timeout: Optional[int] = None, + replace_if_exists: Optional[bool] = None, + ignore_read_only: Optional[bool] = None, + source_lease_id: Optional[str] = None, + destination_lease_id: Optional[str] = None, + file_attributes: Optional[str] = None, + file_creation_time: Optional[str] = None, + file_last_write_time: Optional[str] = None, + file_change_time: Optional[str] = None, + file_permission: Optional[str] = None, + file_permission_format: Optional[Union[str, _models.FilePermissionFormat]] = None, + file_permission_key: Optional[str] = None, + metadata: Optional[dict[str, str]] = None, + file_content_type: Optional[str] = None, + allow_trailing_dot: Optional[bool] = None, + allow_source_trailing_dot: Optional[bool] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any + ) -> None: + """Renames a file. By default, the destination is overwritten and if the destination already + exists and has a read-only attribute set, the operation will fail. + + :keyword rename_source: Required. Specifies the URI-style path of the source file, up to 2 KB + in length. Required. + :paramtype rename_source: str + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword replace_if_exists: Boolean. Default value is false. Set to true to indicate that the + destination should be overwritten. Default value is None. + :paramtype replace_if_exists: bool + :keyword ignore_read_only: Boolean. Default value is false. Set to true to overwrite the + destination even if it has the read-only attribute set. Default value is None. + :paramtype ignore_read_only: bool + :keyword source_lease_id: Required if the source file has an active lease. Default value is + None. + :paramtype source_lease_id: str + :keyword destination_lease_id: Required if the destination has an active lease. Default value + is None. + :paramtype destination_lease_id: str + :keyword file_attributes: If specified, the provided file attributes shall be set. Default + value is None. + :paramtype file_attributes: str + :keyword file_creation_time: Creation time for the file. Default value is None. + :paramtype file_creation_time: str + :keyword file_last_write_time: Last write time for the file. Default value is None. + :paramtype file_last_write_time: str + :keyword file_change_time: Change time for the file. Default value is None. + :paramtype file_change_time: str + :keyword file_permission: If specified the permission shall be set for the file. Default value + is None. + :paramtype file_permission: str + :keyword file_permission_format: Optional. Used to set permission format. Known values are: + "Sddl" and "Binary". Default value is None. + :paramtype file_permission_format: str or ~azure.storage.fileshare.models.FilePermissionFormat + :keyword file_permission_key: Key of the permission to be set. Default value is None. + :paramtype file_permission_key: str + :keyword metadata: Optional. User-defined metadata for the resource. Default value is None. + :paramtype metadata: dict[str, str] + :keyword file_content_type: Sets the MIME content type of the file. Default value is None. + :paramtype file_content_type: str + :keyword allow_trailing_dot: If true, the trailing dot will not be trimmed from the target + file/directory path. Default value is None. + :paramtype allow_trailing_dot: bool + :keyword allow_source_trailing_dot: If true, the trailing dot will not be trimmed from the + source URI. Default value is None. + :paramtype allow_source_trailing_dot: bool + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls: ClsType[None] = kwargs.pop("cls", None) + + _request = build_file_rename_request( + rename_source=rename_source, + timeout=timeout, + replace_if_exists=replace_if_exists, + ignore_read_only=ignore_read_only, + source_lease_id=source_lease_id, + destination_lease_id=destination_lease_id, + file_attributes=file_attributes, + file_creation_time=file_creation_time, + file_last_write_time=file_last_write_time, + file_change_time=file_change_time, + file_permission=file_permission, + file_permission_format=file_permission_format, + file_permission_key=file_permission_key, + metadata=metadata, + file_content_type=file_content_type, + allow_trailing_dot=allow_trailing_dot, + allow_source_trailing_dot=allow_source_trailing_dot, + file_request_intent=file_request_intent, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) + response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) + response_headers["x-ms-request-server-encrypted"] = self._deserialize( + "bool", response.headers.get("x-ms-request-server-encrypted") + ) + response_headers["x-ms-file-permission-key"] = self._deserialize( + "str", response.headers.get("x-ms-file-permission-key") + ) + response_headers["x-ms-file-attributes"] = self._deserialize( + "str", response.headers.get("x-ms-file-attributes") + ) + response_headers["x-ms-file-creation-time"] = self._deserialize( + "str", response.headers.get("x-ms-file-creation-time") + ) + response_headers["x-ms-file-last-write-time"] = self._deserialize( + "str", response.headers.get("x-ms-file-last-write-time") + ) + response_headers["x-ms-file-change-time"] = self._deserialize( + "str", response.headers.get("x-ms-file-change-time") + ) + response_headers["x-ms-file-id"] = self._deserialize("str", response.headers.get("x-ms-file-id")) + response_headers["x-ms-file-parent-id"] = self._deserialize("str", response.headers.get("x-ms-file-parent-id")) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + + if cls: + return cls(pipeline_response, None, response_headers) # type: ignore + + @distributed_trace_async + async def create_symbolic_link( + self, + *, + link_text: str, + timeout: Optional[int] = None, + metadata: Optional[dict[str, str]] = None, + file_creation_time: Optional[str] = None, + file_last_write_time: Optional[str] = None, + lease_id: Optional[str] = None, + owner: Optional[str] = None, + group: Optional[str] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any + ) -> None: + """Creates a symbolic link to a target file. NFS only. + + :keyword link_text: NFS only. The path to the original file, the symbolic link is pointing to. + Required. + :paramtype link_text: str + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword metadata: Optional. User-defined metadata for the resource. Default value is None. + :paramtype metadata: dict[str, str] + :keyword file_creation_time: Creation time for the file. Default value is None. + :paramtype file_creation_time: str + :keyword file_last_write_time: Last write time for the file. Default value is None. + :paramtype file_last_write_time: str + :keyword lease_id: If specified, the lease ID must match the lease ID of the file. Default + value is None. + :paramtype lease_id: str + :keyword owner: Optional, NFS only. The owner of the file or directory. Default value is None. + :paramtype owner: str + :keyword group: Optional, NFS only. The owning group of the file or directory. Default value is + None. + :paramtype group: str + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls: ClsType[None] = kwargs.pop("cls", None) + + _request = build_file_create_symbolic_link_request( + link_text=link_text, + timeout=timeout, + metadata=metadata, + file_creation_time=file_creation_time, + file_last_write_time=file_last_write_time, + lease_id=lease_id, + owner=owner, + group=group, + file_request_intent=file_request_intent, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [201]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) + response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) + response_headers["x-ms-file-creation-time"] = self._deserialize( + "str", response.headers.get("x-ms-file-creation-time") + ) + response_headers["x-ms-file-last-write-time"] = self._deserialize( + "str", response.headers.get("x-ms-file-last-write-time") + ) + response_headers["x-ms-file-change-time"] = self._deserialize( + "str", response.headers.get("x-ms-file-change-time") + ) + response_headers["x-ms-file-id"] = self._deserialize("str", response.headers.get("x-ms-file-id")) + response_headers["x-ms-file-parent-id"] = self._deserialize("str", response.headers.get("x-ms-file-parent-id")) + response_headers["x-ms-mode"] = self._deserialize("str", response.headers.get("x-ms-mode")) + response_headers["x-ms-owner"] = self._deserialize("str", response.headers.get("x-ms-owner")) + response_headers["x-ms-group"] = self._deserialize("str", response.headers.get("x-ms-group")) + response_headers["x-ms-file-file-type"] = self._deserialize("str", response.headers.get("x-ms-file-file-type")) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + + if cls: + return cls(pipeline_response, None, response_headers) # type: ignore + + @distributed_trace_async + async def get_symbolic_link( + self, + *, + timeout: Optional[int] = None, + sharesnapshot: Optional[str] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any + ) -> None: + """Returns the target of a symbolic link. NFS only. + + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword sharesnapshot: The snapshot parameter is an opaque DateTime value that specifies a + share snapshot. Default value is None. + :paramtype sharesnapshot: str + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls: ClsType[None] = kwargs.pop("cls", None) + + _request = build_file_get_symbolic_link_request( + timeout=timeout, + sharesnapshot=sharesnapshot, + file_request_intent=file_request_intent, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) + response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) + response_headers["x-ms-link-text"] = self._deserialize("str", response.headers.get("x-ms-link-text")) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + + if cls: + return cls(pipeline_response, None, response_headers) # type: ignore + + @distributed_trace_async + async def create_hard_link( + self, + *, + target_file: str, + timeout: Optional[int] = None, + lease_id: Optional[str] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any + ) -> None: + """Creates a hard link to a target file. NFS only. + + :keyword target_file: NFS only. Required. Specifies the path of the target file to which the + link will be created, up to 2 KiB in length. Required. + :paramtype target_file: str + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword lease_id: If specified, the lease ID must match the lease ID of the file. Default + value is None. + :paramtype lease_id: str + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + file_type: Literal["file"] = kwargs.pop("file_type", _headers.pop("x-ms-type", "file")) + cls: ClsType[None] = kwargs.pop("cls", None) + + _request = build_file_create_hard_link_request( + target_file=target_file, + timeout=timeout, + lease_id=lease_id, + file_request_intent=file_request_intent, + file_type=file_type, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [201]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) + response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) + response_headers["x-ms-file-creation-time"] = self._deserialize( + "str", response.headers.get("x-ms-file-creation-time") + ) + response_headers["x-ms-file-last-write-time"] = self._deserialize( + "str", response.headers.get("x-ms-file-last-write-time") + ) + response_headers["x-ms-file-change-time"] = self._deserialize( + "str", response.headers.get("x-ms-file-change-time") + ) + response_headers["x-ms-file-id"] = self._deserialize("str", response.headers.get("x-ms-file-id")) + response_headers["x-ms-file-parent-id"] = self._deserialize("str", response.headers.get("x-ms-file-parent-id")) + response_headers["x-ms-link-count"] = self._deserialize("int", response.headers.get("x-ms-link-count")) + response_headers["x-ms-mode"] = self._deserialize("str", response.headers.get("x-ms-mode")) + response_headers["x-ms-owner"] = self._deserialize("str", response.headers.get("x-ms-owner")) + response_headers["x-ms-group"] = self._deserialize("str", response.headers.get("x-ms-group")) + response_headers["x-ms-file-file-type"] = self._deserialize("str", response.headers.get("x-ms-file-file-type")) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + + if cls: + return cls(pipeline_response, None, response_headers) # type: ignore + + +class ServiceOperations: + """ + .. warning:: + **DO NOT** instantiate this class directly. + + Instead, you should access the following operations through + :class:`~azure.storage.fileshare.aio.FileClient`'s + :attr:`service` attribute. + """ + + def __init__(self, *args, **kwargs) -> None: + input_args = list(args) + self._client: AsyncPipelineClient = input_args.pop(0) if input_args else kwargs.pop("client") + self._config: FileClientConfiguration = input_args.pop(0) if input_args else kwargs.pop("config") + self._serialize: Serializer = input_args.pop(0) if input_args else kwargs.pop("serializer") + self._deserialize: Deserializer = input_args.pop(0) if input_args else kwargs.pop("deserializer") + + @distributed_trace_async + async def set_properties( + self, + storage_service_properties: _models.StorageServiceProperties, + *, + timeout: Optional[int] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any + ) -> None: + """Sets properties for a storage account's File service endpoint, including properties for Storage + Analytics metrics and CORS (Cross-Origin Resource Sharing) rules. + + :param storage_service_properties: Storage service properties. Required. + :type storage_service_properties: + ~azure.storage.fileshare._generated.models.StorageServiceProperties + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = kwargs.pop("params", {}) or {} + + content_type: str = kwargs.pop("content_type", _headers.pop("Content-Type", "application/xml")) + cls: ClsType[None] = kwargs.pop("cls", None) + + _content = _get_element(storage_service_properties) + + _request = build_service_set_properties_request( + timeout=timeout, + file_request_intent=file_request_intent, + content_type=content_type, + version=self._config.version, + content=_content, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [202]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + + if cls: + return cls(pipeline_response, None, response_headers) # type: ignore + + @distributed_trace_async + async def get_properties( + self, + *, + timeout: Optional[int] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any + ) -> _models.StorageServiceProperties: + """Gets the properties of a storage account's File service, including properties for Storage + Analytics metrics and CORS (Cross-Origin Resource Sharing) rules. + + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :return: StorageServiceProperties. The StorageServiceProperties is compatible with + MutableMapping + :rtype: ~azure.storage.fileshare._generated.models.StorageServiceProperties + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls: ClsType[_models.StorageServiceProperties] = kwargs.pop("cls", None) + + _request = build_service_get_properties_request( + timeout=timeout, + file_request_intent=file_request_intent, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _decompress = kwargs.pop("decompress", True) + _stream = kwargs.pop("stream", False) + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + if _stream: + try: + await response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + response_headers["Content-Type"] = self._deserialize("str", response.headers.get("Content-Type")) + + if _stream: + deserialized = response.iter_bytes() if _decompress else response.iter_raw() + else: + deserialized = _deserialize_xml(_models.StorageServiceProperties, response.text()) + + if cls: + return cls(pipeline_response, deserialized, response_headers) # type: ignore + + return deserialized # type: ignore + + @distributed_trace_async + async def list_shares_segment( + self, + *, + prefix: Optional[str] = None, + marker: Optional[str] = None, + maxresults: Optional[int] = None, + timeout: Optional[int] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + include: Optional[list[Union[str, _models.ListSharesIncludeType]]] = None, + **kwargs: Any + ) -> _models.ListSharesResponse: + """The List Shares Segment operation returns a list of the shares and share snapshots under the + specified account. + + :keyword prefix: Filters the results to return only items whose name begins with the specified + prefix. Default value is None. + :paramtype prefix: str + :keyword marker: A string value that identifies the portion of the list to be returned with the + next listing operation. Default value is None. + :paramtype marker: str + :keyword maxresults: Specifies the maximum number of items to return. Default value is None. + :paramtype maxresults: int + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :keyword include: Include this parameter to specify one or more datasets to include in the + response. Default value is None. + :paramtype include: list[str or ~azure.storage.fileshare.models.ListSharesIncludeType] + :return: ListSharesResponse. The ListSharesResponse is compatible with MutableMapping + :rtype: ~azure.storage.fileshare._generated.models.ListSharesResponse + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls: ClsType[_models.ListSharesResponse] = kwargs.pop("cls", None) + + _request = build_service_list_shares_segment_request( + prefix=prefix, + marker=marker, + maxresults=maxresults, + timeout=timeout, + file_request_intent=file_request_intent, + include=include, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _decompress = kwargs.pop("decompress", True) + _stream = kwargs.pop("stream", False) + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + if _stream: + try: + await response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + response_headers["Content-Type"] = self._deserialize("str", response.headers.get("Content-Type")) + + if _stream: + deserialized = response.iter_bytes() if _decompress else response.iter_raw() + else: + deserialized = _deserialize_xml(_models.ListSharesResponse, response.text()) + + if cls: + return cls(pipeline_response, deserialized, response_headers) # type: ignore + + return deserialized # type: ignore + + @distributed_trace_async + async def get_user_delegation_key( + self, key_info: _models.KeyInfo, *, timeout: Optional[int] = None, **kwargs: Any + ) -> _models.UserDelegationKey: + """Retrieves a user delegation key for the File service. This can be used to generate a user + delegation SAS. + + :param key_info: Key information. Required. + :type key_info: ~azure.storage.fileshare._generated.models.KeyInfo + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :return: UserDelegationKey. The UserDelegationKey is compatible with MutableMapping + :rtype: ~azure.storage.fileshare._generated.models.UserDelegationKey + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = kwargs.pop("params", {}) or {} + + content_type: str = kwargs.pop("content_type", _headers.pop("Content-Type", "application/xml")) + cls: ClsType[_models.UserDelegationKey] = kwargs.pop("cls", None) + + _content = _get_element(key_info) + + _request = build_service_get_user_delegation_key_request( + timeout=timeout, + content_type=content_type, + version=self._config.version, + content=_content, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _decompress = kwargs.pop("decompress", True) + _stream = kwargs.pop("stream", False) + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + if _stream: + try: + await response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + response_headers["Content-Type"] = self._deserialize("str", response.headers.get("Content-Type")) + + if _stream: + deserialized = response.iter_bytes() if _decompress else response.iter_raw() + else: + deserialized = _deserialize_xml(_models.UserDelegationKey, response.text()) + + if cls: + return cls(pipeline_response, deserialized, response_headers) # type: ignore + + return deserialized # type: ignore + + +class ShareOperations: + """ + .. warning:: + **DO NOT** instantiate this class directly. + + Instead, you should access the following operations through + :class:`~azure.storage.fileshare.aio.FileClient`'s + :attr:`share` attribute. + """ + + def __init__(self, *args, **kwargs) -> None: + input_args = list(args) + self._client: AsyncPipelineClient = input_args.pop(0) if input_args else kwargs.pop("client") + self._config: FileClientConfiguration = input_args.pop(0) if input_args else kwargs.pop("config") + self._serialize: Serializer = input_args.pop(0) if input_args else kwargs.pop("serializer") + self._deserialize: Deserializer = input_args.pop(0) if input_args else kwargs.pop("deserializer") + + @distributed_trace_async + async def create( # pylint: disable=too-many-locals + self, + *, + timeout: Optional[int] = None, + metadata: Optional[dict[str, str]] = None, + quota: Optional[int] = None, + access_tier: Optional[Union[str, _models.ShareAccessTier]] = None, + enabled_protocols: Optional[str] = None, + root_squash: Optional[Union[str, _models.ShareRootSquash]] = None, + enable_snapshot_virtual_directory_access: Optional[bool] = None, + paid_bursting_enabled: Optional[bool] = None, + paid_bursting_max_iops: Optional[int] = None, + paid_bursting_max_bandwidth_mibps: Optional[int] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + share_provisioned_iops: Optional[int] = None, + share_provisioned_bandwidth_mibps: Optional[int] = None, + enable_smb_directory_lease: Optional[bool] = None, + **kwargs: Any + ) -> None: + """Creates a new share under the specified account. If the share with the same name already + exists, the operation fails. + + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword metadata: Optional. User-defined metadata for the resource. Default value is None. + :paramtype metadata: dict[str, str] + :keyword quota: Specifies the maximum size of the share, in gigabytes. Default value is None. + :paramtype quota: int + :keyword access_tier: Specifies the access tier of the share. Known values are: + "TransactionOptimized", "Hot", "Cool", and "Premium". Default value is None. + :paramtype access_tier: str or ~azure.storage.fileshare.models.ShareAccessTier + :keyword enabled_protocols: Protocols to enable on the share. Default value is None. + :paramtype enabled_protocols: str + :keyword root_squash: Root squash to set on the share. Only valid for NFS shares. Known values + are: "NoRootSquash", "RootSquash", and "AllSquash". Default value is None. + :paramtype root_squash: str or ~azure.storage.fileshare.models.ShareRootSquash + :keyword enable_snapshot_virtual_directory_access: Optional. Used to enable snapshot virtual + directory access. Default value is None. + :paramtype enable_snapshot_virtual_directory_access: bool + :keyword paid_bursting_enabled: Optional. Boolean. Default if not specified is false. This + property enables paid bursting. Default value is None. + :paramtype paid_bursting_enabled: bool + :keyword paid_bursting_max_iops: Optional. Integer. Default if not specified is the maximum + IOPS the file share can support. Current maximum for a file share is 102,400 IOPS. Default + value is None. + :paramtype paid_bursting_max_iops: int + :keyword paid_bursting_max_bandwidth_mibps: Optional. Integer. Default if not specified is the + maximum throughput the file share can support. Current maximum for a file share is 10,340 + MiB/sec. Default value is None. + :paramtype paid_bursting_max_bandwidth_mibps: int + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :keyword share_provisioned_iops: Optional. Specifies the provisioned IOPS of the share. Default + value is None. + :paramtype share_provisioned_iops: int + :keyword share_provisioned_bandwidth_mibps: Optional. Specifies the provisioned bandwidth of + the share, in MiBps. Default value is None. + :paramtype share_provisioned_bandwidth_mibps: int + :keyword enable_smb_directory_lease: Optional. Used to enable SMB directory lease. Default + value is None. + :paramtype enable_smb_directory_lease: bool + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls: ClsType[None] = kwargs.pop("cls", None) + + _request = build_share_create_request( + timeout=timeout, + metadata=metadata, + quota=quota, + access_tier=access_tier, + enabled_protocols=enabled_protocols, + root_squash=root_squash, + enable_snapshot_virtual_directory_access=enable_snapshot_virtual_directory_access, + paid_bursting_enabled=paid_bursting_enabled, + paid_bursting_max_iops=paid_bursting_max_iops, + paid_bursting_max_bandwidth_mibps=paid_bursting_max_bandwidth_mibps, + file_request_intent=file_request_intent, + share_provisioned_iops=share_provisioned_iops, + share_provisioned_bandwidth_mibps=share_provisioned_bandwidth_mibps, + enable_smb_directory_lease=enable_smb_directory_lease, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [201]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) + response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) + response_headers["x-ms-share-quota"] = self._deserialize("int", response.headers.get("x-ms-share-quota")) + response_headers["x-ms-share-provisioned-iops"] = self._deserialize( + "int", response.headers.get("x-ms-share-provisioned-iops") + ) + response_headers["x-ms-share-provisioned-bandwidth-mibps"] = self._deserialize( + "int", response.headers.get("x-ms-share-provisioned-bandwidth-mibps") + ) + response_headers["x-ms-share-included-burst-iops"] = self._deserialize( + "int", response.headers.get("x-ms-share-included-burst-iops") + ) + response_headers["x-ms-share-max-burst-credits-for-iops"] = self._deserialize( + "int", response.headers.get("x-ms-share-max-burst-credits-for-iops") + ) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + + if cls: + return cls(pipeline_response, None, response_headers) # type: ignore + + @distributed_trace_async + async def get_properties( + self, + *, + sharesnapshot: Optional[str] = None, + timeout: Optional[int] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + lease_id: Optional[str] = None, + **kwargs: Any + ) -> None: + """Returns all user-defined metadata and system properties for the specified share or share + snapshot. + + :keyword sharesnapshot: The snapshot parameter is an opaque DateTime value that specifies a + share snapshot. Default value is None. + :paramtype sharesnapshot: str + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :keyword lease_id: If specified, the lease ID must match the lease ID of the file. Default + value is None. + :paramtype lease_id: str + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls: ClsType[None] = kwargs.pop("cls", None) + + _request = build_share_get_properties_request( + sharesnapshot=sharesnapshot, + timeout=timeout, + file_request_intent=file_request_intent, + lease_id=lease_id, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["x-ms-meta"] = self._deserialize("{str}", response.headers.get("x-ms-meta")) + response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) + response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) + response_headers["x-ms-share-quota"] = self._deserialize("int", response.headers.get("x-ms-share-quota")) + response_headers["x-ms-share-provisioned-iops"] = self._deserialize( + "int", response.headers.get("x-ms-share-provisioned-iops") + ) + response_headers["x-ms-share-provisioned-ingress-mbps"] = self._deserialize( + "int", response.headers.get("x-ms-share-provisioned-ingress-mbps") + ) + response_headers["x-ms-share-provisioned-egress-mbps"] = self._deserialize( + "int", response.headers.get("x-ms-share-provisioned-egress-mbps") + ) + response_headers["x-ms-share-next-allowed-quota-downgrade-time"] = self._deserialize( + "rfc-1123", response.headers.get("x-ms-share-next-allowed-quota-downgrade-time") + ) + response_headers["x-ms-share-provisioned-bandwidth-mibps"] = self._deserialize( + "int", response.headers.get("x-ms-share-provisioned-bandwidth-mibps") + ) + response_headers["x-ms-lease-duration"] = self._deserialize("str", response.headers.get("x-ms-lease-duration")) + response_headers["x-ms-lease-state"] = self._deserialize("str", response.headers.get("x-ms-lease-state")) + response_headers["x-ms-lease-status"] = self._deserialize("str", response.headers.get("x-ms-lease-status")) + response_headers["x-ms-access-tier"] = self._deserialize("str", response.headers.get("x-ms-access-tier")) + response_headers["x-ms-access-tier-change-time"] = self._deserialize( + "rfc-1123", response.headers.get("x-ms-access-tier-change-time") + ) + response_headers["x-ms-access-tier-transition-state"] = self._deserialize( + "str", response.headers.get("x-ms-access-tier-transition-state") + ) + response_headers["x-ms-enabled-protocols"] = self._deserialize( + "str", response.headers.get("x-ms-enabled-protocols") + ) + response_headers["x-ms-root-squash"] = self._deserialize("str", response.headers.get("x-ms-root-squash")) + response_headers["x-ms-enable-snapshot-virtual-directory-access"] = self._deserialize( + "bool", response.headers.get("x-ms-enable-snapshot-virtual-directory-access") + ) + response_headers["x-ms-share-paid-bursting-enabled"] = self._deserialize( + "bool", response.headers.get("x-ms-share-paid-bursting-enabled") + ) + response_headers["x-ms-share-paid-bursting-max-iops"] = self._deserialize( + "int", response.headers.get("x-ms-share-paid-bursting-max-iops") + ) + response_headers["x-ms-share-paid-bursting-max-bandwidth-mibps"] = self._deserialize( + "int", response.headers.get("x-ms-share-paid-bursting-max-bandwidth-mibps") + ) + response_headers["x-ms-share-included-burst-iops"] = self._deserialize( + "int", response.headers.get("x-ms-share-included-burst-iops") + ) + response_headers["x-ms-share-max-burst-credits-for-iops"] = self._deserialize( + "int", response.headers.get("x-ms-share-max-burst-credits-for-iops") + ) + response_headers["x-ms-share-next-allowed-provisioned-iops-downgrade-time"] = self._deserialize( + "rfc-1123", response.headers.get("x-ms-share-next-allowed-provisioned-iops-downgrade-time") + ) + response_headers["x-ms-share-next-allowed-provisioned-bandwidth-downgrade-time"] = self._deserialize( + "rfc-1123", response.headers.get("x-ms-share-next-allowed-provisioned-bandwidth-downgrade-time") + ) + response_headers["x-ms-enable-smb-directory-lease"] = self._deserialize( + "bool", response.headers.get("x-ms-enable-smb-directory-lease") + ) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + + if cls: + return cls(pipeline_response, None, response_headers) # type: ignore + + @distributed_trace_async + async def delete( + self, + *, + sharesnapshot: Optional[str] = None, + timeout: Optional[int] = None, + delete_snapshots: Optional[Union[str, _models.DeleteSnapshotsOptionType]] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + lease_id: Optional[str] = None, + **kwargs: Any + ) -> None: + """Operation marks the specified share or share snapshot for deletion. The share or share snapshot + and any files contained within it are later deleted during garbage collection. + + :keyword sharesnapshot: The snapshot parameter is an opaque DateTime value that specifies a + share snapshot. Default value is None. + :paramtype sharesnapshot: str + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword delete_snapshots: Specifies the option include to delete the base share and all of its + snapshots. Known values are: "include" and "include-leased". Default value is None. + :paramtype delete_snapshots: str or ~azure.storage.fileshare.models.DeleteSnapshotsOptionType + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :keyword lease_id: If specified, the lease ID must match the lease ID of the file. Default + value is None. + :paramtype lease_id: str + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls: ClsType[None] = kwargs.pop("cls", None) + + _request = build_share_delete_request( + sharesnapshot=sharesnapshot, + timeout=timeout, + delete_snapshots=delete_snapshots, + file_request_intent=file_request_intent, + lease_id=lease_id, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [202]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["x-ms-file-share-usage-bytes"] = self._deserialize( + "int", response.headers.get("x-ms-file-share-usage-bytes") + ) + response_headers["x-ms-file-share-snapshot-usage-bytes"] = self._deserialize( + "int", response.headers.get("x-ms-file-share-snapshot-usage-bytes") + ) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + + if cls: + return cls(pipeline_response, None, response_headers) # type: ignore + + @distributed_trace_async + async def acquire_lease( + self, + *, + timeout: Optional[int] = None, + lease_duration: Optional[int] = None, + proposed_lease_id: Optional[str] = None, + sharesnapshot: Optional[str] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any + ) -> None: + """The Lease Share operation establishes and manages a lock on a share for delete operations. The + lock duration can be 15 to 60 seconds, or can be infinite. + + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword lease_duration: Specifies the duration of the lease, in seconds, or negative one (-1) + for a lease that never expires. A non-infinite lease can be between 15 and 60 seconds. A lease + duration cannot be changed using renew or change. Default value is None. + :paramtype lease_duration: int + :keyword proposed_lease_id: Proposed lease ID, in a GUID string format. The File service + returns 400 (Invalid request) if the proposed lease ID is not in the correct format. See Guid + Constructor (String) for a list of valid GUID string formats. Default value is None. + :paramtype proposed_lease_id: str + :keyword sharesnapshot: The snapshot parameter is an opaque DateTime value that specifies a + share snapshot. Default value is None. + :paramtype sharesnapshot: str + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + action: Literal["acquire"] = kwargs.pop("action", _headers.pop("x-ms-lease-action", "acquire")) + cls: ClsType[None] = kwargs.pop("cls", None) + + _request = build_share_acquire_lease_request( + timeout=timeout, + lease_duration=lease_duration, + proposed_lease_id=proposed_lease_id, + sharesnapshot=sharesnapshot, + file_request_intent=file_request_intent, + action=action, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [201]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) + response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) + response_headers["x-ms-lease-id"] = self._deserialize("str", response.headers.get("x-ms-lease-id")) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + + if cls: + return cls(pipeline_response, None, response_headers) # type: ignore + + @distributed_trace_async + async def release_lease( + self, + *, + lease_id: str, + timeout: Optional[int] = None, + sharesnapshot: Optional[str] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any + ) -> None: + """The Lease Share operation establishes and manages a lock on a share for delete operations. The + lock duration can be 15 to 60 seconds, or can be infinite. + + :keyword lease_id: Specifies the current lease ID on the resource. Required. + :paramtype lease_id: str + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword sharesnapshot: The snapshot parameter is an opaque DateTime value that specifies a + share snapshot. Default value is None. + :paramtype sharesnapshot: str + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + action: Literal["release"] = kwargs.pop("action", _headers.pop("x-ms-lease-action", "release")) + cls: ClsType[None] = kwargs.pop("cls", None) + + _request = build_share_release_lease_request( + lease_id=lease_id, + timeout=timeout, + sharesnapshot=sharesnapshot, + file_request_intent=file_request_intent, + action=action, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) + response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + + if cls: + return cls(pipeline_response, None, response_headers) # type: ignore + + @distributed_trace_async + async def change_lease( + self, + *, + lease_id: str, + proposed_lease_id: Optional[str] = None, + timeout: Optional[int] = None, + sharesnapshot: Optional[str] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any + ) -> None: + """The Lease Share operation establishes and manages a lock on a share for delete operations. The + lock duration can be 15 to 60 seconds, or can be infinite. + + :keyword lease_id: Specifies the current lease ID on the resource. Required. + :paramtype lease_id: str + :keyword proposed_lease_id: Proposed lease ID, in a GUID string format. The File service + returns 400 (Invalid request) if the proposed lease ID is not in the correct format. See Guid + Constructor (String) for a list of valid GUID string formats. Default value is None. + :paramtype proposed_lease_id: str + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword sharesnapshot: The snapshot parameter is an opaque DateTime value that specifies a + share snapshot. Default value is None. + :paramtype sharesnapshot: str + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + action: Literal["change"] = kwargs.pop("action", _headers.pop("x-ms-lease-action", "change")) + cls: ClsType[None] = kwargs.pop("cls", None) + + _request = build_share_change_lease_request( + lease_id=lease_id, + proposed_lease_id=proposed_lease_id, + timeout=timeout, + sharesnapshot=sharesnapshot, + file_request_intent=file_request_intent, + action=action, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) + response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) + response_headers["x-ms-lease-id"] = self._deserialize("str", response.headers.get("x-ms-lease-id")) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + + if cls: + return cls(pipeline_response, None, response_headers) # type: ignore + + @distributed_trace_async + async def renew_lease( + self, + *, + lease_id: str, + timeout: Optional[int] = None, + sharesnapshot: Optional[str] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any + ) -> None: + """The Lease Share operation establishes and manages a lock on a share for delete operations. The + lock duration can be 15 to 60 seconds, or can be infinite. + + :keyword lease_id: Specifies the current lease ID on the resource. Required. + :paramtype lease_id: str + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword sharesnapshot: The snapshot parameter is an opaque DateTime value that specifies a + share snapshot. Default value is None. + :paramtype sharesnapshot: str + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + action: Literal["renew"] = kwargs.pop("action", _headers.pop("x-ms-lease-action", "renew")) + cls: ClsType[None] = kwargs.pop("cls", None) + + _request = build_share_renew_lease_request( + lease_id=lease_id, + timeout=timeout, + sharesnapshot=sharesnapshot, + file_request_intent=file_request_intent, + action=action, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) + response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) + response_headers["x-ms-lease-id"] = self._deserialize("str", response.headers.get("x-ms-lease-id")) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + + if cls: + return cls(pipeline_response, None, response_headers) # type: ignore + + @distributed_trace_async + async def break_lease( + self, + *, + timeout: Optional[int] = None, + break_period: Optional[int] = None, + lease_id: Optional[str] = None, + sharesnapshot: Optional[str] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any + ) -> None: + """The Lease Share operation establishes and manages a lock on a share for delete operations. The + lock duration can be 15 to 60 seconds, or can be infinite. + + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword break_period: For a break operation, proposed duration the lease should continue + before it is broken, in seconds, between 0 and 60. This break period is only used if it is + shorter than the time remaining on the lease. If longer, the time remaining on the lease is + used. A new lease will not be available before the break period has expired, but the lease may + be held for longer than the break period. If this header does not appear with a break + operation, a fixed-duration lease breaks after the remaining lease period elapses, and an + infinite lease breaks immediately. Default value is None. + :paramtype break_period: int + :keyword lease_id: If specified, the lease ID must match the lease ID of the file. Default + value is None. + :paramtype lease_id: str + :keyword sharesnapshot: The snapshot parameter is an opaque DateTime value that specifies a + share snapshot. Default value is None. + :paramtype sharesnapshot: str + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + action: Literal["break"] = kwargs.pop("action", _headers.pop("x-ms-lease-action", "break")) + cls: ClsType[None] = kwargs.pop("cls", None) + + _request = build_share_break_lease_request( + timeout=timeout, + break_period=break_period, + lease_id=lease_id, + sharesnapshot=sharesnapshot, + file_request_intent=file_request_intent, + action=action, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [202]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) + response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) + response_headers["x-ms-lease-time"] = self._deserialize("int", response.headers.get("x-ms-lease-time")) + response_headers["x-ms-lease-id"] = self._deserialize("str", response.headers.get("x-ms-lease-id")) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + + if cls: + return cls(pipeline_response, None, response_headers) # type: ignore + + @distributed_trace_async + async def create_snapshot( + self, + *, + timeout: Optional[int] = None, + metadata: Optional[dict[str, str]] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any + ) -> None: + """Creates a read-only snapshot of a share. + + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword metadata: Optional. User-defined metadata for the resource. Default value is None. + :paramtype metadata: dict[str, str] + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls: ClsType[None] = kwargs.pop("cls", None) + + _request = build_share_create_snapshot_request( + timeout=timeout, + metadata=metadata, + file_request_intent=file_request_intent, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [201]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) + response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) + response_headers["x-ms-snapshot"] = self._deserialize("str", response.headers.get("x-ms-snapshot")) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + + if cls: + return cls(pipeline_response, None, response_headers) # type: ignore + + @overload + async def create_permission( + self, + permission: _models.SharePermission, + *, + content_type: str = "application/json", + timeout: Optional[int] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any + ) -> None: + """Create a permission (a security descriptor). This is used to support file level ACLs for SMB + shares. + + :param permission: A permission (a security descriptor) at the share level. Required. + :type permission: ~azure.storage.fileshare._generated.models.SharePermission + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + async def create_permission( + self, + permission: JSON, + *, + content_type: str = "application/json", + timeout: Optional[int] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any + ) -> None: + """Create a permission (a security descriptor). This is used to support file level ACLs for SMB + shares. + + :param permission: A permission (a security descriptor) at the share level. Required. + :type permission: JSON + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + async def create_permission( + self, + permission: IO[bytes], + *, + content_type: str = "application/json", + timeout: Optional[int] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any + ) -> None: + """Create a permission (a security descriptor). This is used to support file level ACLs for SMB + shares. + + :param permission: A permission (a security descriptor) at the share level. Required. + :type permission: IO[bytes] + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace_async + async def create_permission( + self, + permission: Union[_models.SharePermission, JSON, IO[bytes]], + *, + timeout: Optional[int] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any + ) -> None: + """Create a permission (a security descriptor). This is used to support file level ACLs for SMB + shares. + + :param permission: A permission (a security descriptor) at the share level. Is one of the + following types: SharePermission, JSON, IO[bytes] Required. + :type permission: ~azure.storage.fileshare._generated.models.SharePermission or JSON or + IO[bytes] + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = kwargs.pop("params", {}) or {} + + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[None] = kwargs.pop("cls", None) + + content_type = content_type or "application/json" + _content = None + if isinstance(permission, (IOBase, bytes)): + _content = permission + else: + _content = json.dumps(permission, cls=SdkJSONEncoder, exclude_readonly=True) # type: ignore + + _request = build_share_create_permission_request( + timeout=timeout, + file_request_intent=file_request_intent, + content_type=content_type, + version=self._config.version, + content=_content, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [201]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["x-ms-file-permission-key"] = self._deserialize( + "str", response.headers.get("x-ms-file-permission-key") + ) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + + if cls: + return cls(pipeline_response, None, response_headers) # type: ignore + + @distributed_trace_async + async def get_permission( + self, + *, + file_permission_key: str, + timeout: Optional[int] = None, + file_permission_format: Optional[Union[str, _models.FilePermissionFormat]] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any + ) -> _models.SharePermission: + """Returns the permission (security descriptor) for a given permission key. This is used to + support file level ACLs for SMB shares. + + :keyword file_permission_key: Key of the permission to be set for the directory/file. Note: + Only one of the x-ms-file-permission or x-ms-file-permission-key should be specified. Required. + :paramtype file_permission_key: str + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword file_permission_format: Optional. Specifies the format in which the permission is + returned. Acceptable values are SDDL or binary. Known values are: "Sddl" and "Binary". Default + value is None. + :paramtype file_permission_format: str or ~azure.storage.fileshare.models.FilePermissionFormat + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :return: SharePermission. The SharePermission is compatible with MutableMapping + :rtype: ~azure.storage.fileshare._generated.models.SharePermission + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls: ClsType[_models.SharePermission] = kwargs.pop("cls", None) + + _request = build_share_get_permission_request( + file_permission_key=file_permission_key, + timeout=timeout, + file_permission_format=file_permission_format, + file_request_intent=file_request_intent, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _decompress = kwargs.pop("decompress", True) + _stream = kwargs.pop("stream", False) + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + if _stream: + try: + await response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + response_headers["Content-Type"] = self._deserialize("str", response.headers.get("Content-Type")) + + if _stream: + deserialized = response.iter_bytes() if _decompress else response.iter_raw() + else: + deserialized = _deserialize(_models.SharePermission, response.json()) + + if cls: + return cls(pipeline_response, deserialized, response_headers) # type: ignore + + return deserialized # type: ignore + + @distributed_trace_async + async def set_properties( # pylint: disable=too-many-locals + self, + *, + timeout: Optional[int] = None, + quota: Optional[int] = None, + access_tier: Optional[Union[str, _models.ShareAccessTier]] = None, + lease_id: Optional[str] = None, + root_squash: Optional[Union[str, _models.ShareRootSquash]] = None, + enable_snapshot_virtual_directory_access: Optional[bool] = None, + paid_bursting_enabled: Optional[bool] = None, + paid_bursting_max_iops: Optional[int] = None, + paid_bursting_max_bandwidth_mibps: Optional[int] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + share_provisioned_iops: Optional[int] = None, + share_provisioned_bandwidth_mibps: Optional[int] = None, + enable_smb_directory_lease: Optional[bool] = None, + **kwargs: Any + ) -> None: + """Sets properties for the specified share. + + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword quota: Specifies the maximum size of the share, in gigabytes. Default value is None. + :paramtype quota: int + :keyword access_tier: Specifies the access tier of the share. Known values are: + "TransactionOptimized", "Hot", "Cool", and "Premium". Default value is None. + :paramtype access_tier: str or ~azure.storage.fileshare.models.ShareAccessTier + :keyword lease_id: If specified, the lease ID must match the lease ID of the file. Default + value is None. + :paramtype lease_id: str + :keyword root_squash: Root squash to set on the share. Only valid for NFS shares. Known values + are: "NoRootSquash", "RootSquash", and "AllSquash". Default value is None. + :paramtype root_squash: str or ~azure.storage.fileshare.models.ShareRootSquash + :keyword enable_snapshot_virtual_directory_access: Optional. Used to enable snapshot virtual + directory access. Default value is None. + :paramtype enable_snapshot_virtual_directory_access: bool + :keyword paid_bursting_enabled: Optional. Boolean. Default if not specified is false. This + property enables paid bursting. Default value is None. + :paramtype paid_bursting_enabled: bool + :keyword paid_bursting_max_iops: Optional. Integer. Default if not specified is the maximum + IOPS the file share can support. Current maximum for a file share is 102,400 IOPS. Default + value is None. + :paramtype paid_bursting_max_iops: int + :keyword paid_bursting_max_bandwidth_mibps: Optional. Integer. Default if not specified is the + maximum throughput the file share can support. Current maximum for a file share is 10,340 + MiB/sec. Default value is None. + :paramtype paid_bursting_max_bandwidth_mibps: int + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :keyword share_provisioned_iops: Optional. Specifies the provisioned IOPS of the share. Default + value is None. + :paramtype share_provisioned_iops: int + :keyword share_provisioned_bandwidth_mibps: Optional. Specifies the provisioned bandwidth of + the share, in MiBps. Default value is None. + :paramtype share_provisioned_bandwidth_mibps: int + :keyword enable_smb_directory_lease: Optional. Used to enable SMB directory lease. Default + value is None. + :paramtype enable_smb_directory_lease: bool + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls: ClsType[None] = kwargs.pop("cls", None) + + _request = build_share_set_properties_request( + timeout=timeout, + quota=quota, + access_tier=access_tier, + lease_id=lease_id, + root_squash=root_squash, + enable_snapshot_virtual_directory_access=enable_snapshot_virtual_directory_access, + paid_bursting_enabled=paid_bursting_enabled, + paid_bursting_max_iops=paid_bursting_max_iops, + paid_bursting_max_bandwidth_mibps=paid_bursting_max_bandwidth_mibps, + file_request_intent=file_request_intent, + share_provisioned_iops=share_provisioned_iops, + share_provisioned_bandwidth_mibps=share_provisioned_bandwidth_mibps, + enable_smb_directory_lease=enable_smb_directory_lease, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) + response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) + response_headers["x-ms-share-quota"] = self._deserialize("int", response.headers.get("x-ms-share-quota")) + response_headers["x-ms-share-provisioned-iops"] = self._deserialize( + "int", response.headers.get("x-ms-share-provisioned-iops") + ) + response_headers["x-ms-share-provisioned-bandwidth-mibps"] = self._deserialize( + "int", response.headers.get("x-ms-share-provisioned-bandwidth-mibps") + ) + response_headers["x-ms-share-included-burst-iops"] = self._deserialize( + "int", response.headers.get("x-ms-share-included-burst-iops") + ) + response_headers["x-ms-share-max-burst-credits-for-iops"] = self._deserialize( + "int", response.headers.get("x-ms-share-max-burst-credits-for-iops") + ) + response_headers["x-ms-share-next-allowed-quota-downgrade-time"] = self._deserialize( + "rfc-1123", response.headers.get("x-ms-share-next-allowed-quota-downgrade-time") + ) + response_headers["x-ms-share-next-allowed-provisioned-iops-downgrade-time"] = self._deserialize( + "rfc-1123", response.headers.get("x-ms-share-next-allowed-provisioned-iops-downgrade-time") + ) + response_headers["x-ms-share-next-allowed-provisioned-bandwidth-downgrade-time"] = self._deserialize( + "rfc-1123", response.headers.get("x-ms-share-next-allowed-provisioned-bandwidth-downgrade-time") + ) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + + if cls: + return cls(pipeline_response, None, response_headers) # type: ignore + + @distributed_trace_async + async def set_metadata( + self, + *, + timeout: Optional[int] = None, + metadata: Optional[dict[str, str]] = None, + lease_id: Optional[str] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any + ) -> None: + """Sets one or more user-defined name-value pairs for the specified share. + + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword metadata: Optional. User-defined metadata for the resource. Default value is None. + :paramtype metadata: dict[str, str] + :keyword lease_id: If specified, the lease ID must match the lease ID of the file. Default + value is None. + :paramtype lease_id: str + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls: ClsType[None] = kwargs.pop("cls", None) + + _request = build_share_set_metadata_request( + timeout=timeout, + metadata=metadata, + lease_id=lease_id, + file_request_intent=file_request_intent, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) + response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + + if cls: + return cls(pipeline_response, None, response_headers) # type: ignore + + @distributed_trace_async + async def get_access_policy( + self, + *, + timeout: Optional[int] = None, + lease_id: Optional[str] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any + ) -> _models.SignedIdentifiers: + """Returns information about stored access policies specified on the share that may be used with + Shared Access Signatures. + + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword lease_id: If specified, the lease ID must match the lease ID of the file. Default + value is None. + :paramtype lease_id: str + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :return: SignedIdentifiers. The SignedIdentifiers is compatible with MutableMapping + :rtype: ~azure.storage.fileshare._generated.models.SignedIdentifiers + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls: ClsType[_models.SignedIdentifiers] = kwargs.pop("cls", None) + + _request = build_share_get_access_policy_request( + timeout=timeout, + lease_id=lease_id, + file_request_intent=file_request_intent, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _decompress = kwargs.pop("decompress", True) + _stream = kwargs.pop("stream", False) + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + if _stream: + try: + await response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) + response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + response_headers["Content-Type"] = self._deserialize("str", response.headers.get("Content-Type")) + + if _stream: + deserialized = response.iter_bytes() if _decompress else response.iter_raw() + else: + deserialized = _deserialize_xml(_models.SignedIdentifiers, response.text()) + + if cls: + return cls(pipeline_response, deserialized, response_headers) # type: ignore + + return deserialized # type: ignore + + @distributed_trace_async + async def set_access_policy( + self, + share_acl: Optional[_models.SignedIdentifiers] = None, + *, + timeout: Optional[int] = None, + lease_id: Optional[str] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any + ) -> None: + """Sets stored access policies for the share that may be used with Shared Access Signatures. + + :param share_acl: The ACL for the share. Default value is None. + :type share_acl: ~azure.storage.fileshare._generated.models.SignedIdentifiers + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword lease_id: If specified, the lease ID must match the lease ID of the file. Default + value is None. + :paramtype lease_id: str + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = kwargs.pop("params", {}) or {} + + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", "application/xml")) + content_type = content_type if share_acl else None + cls: ClsType[None] = kwargs.pop("cls", None) + + if share_acl is not None: + _content = _get_element(share_acl) + else: + _content = None + + _request = build_share_set_access_policy_request( + timeout=timeout, + lease_id=lease_id, + file_request_intent=file_request_intent, + content_type=content_type, + version=self._config.version, + content=_content, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) + response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + + if cls: + return cls(pipeline_response, None, response_headers) # type: ignore + + @distributed_trace_async + async def get_statistics( + self, + *, + timeout: Optional[int] = None, + lease_id: Optional[str] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any + ) -> _models.ShareStats: + """Retrieves statistics related to the share. + + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword lease_id: If specified, the lease ID must match the lease ID of the file. Default + value is None. + :paramtype lease_id: str + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :return: ShareStats. The ShareStats is compatible with MutableMapping + :rtype: ~azure.storage.fileshare._generated.models.ShareStats + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls: ClsType[_models.ShareStats] = kwargs.pop("cls", None) + + _request = build_share_get_statistics_request( + timeout=timeout, + lease_id=lease_id, + file_request_intent=file_request_intent, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _decompress = kwargs.pop("decompress", True) + _stream = kwargs.pop("stream", False) + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + if _stream: + try: + await response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) + response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + response_headers["Content-Type"] = self._deserialize("str", response.headers.get("Content-Type")) + + if _stream: + deserialized = response.iter_bytes() if _decompress else response.iter_raw() + else: + deserialized = _deserialize_xml(_models.ShareStats, response.text()) + + if cls: + return cls(pipeline_response, deserialized, response_headers) # type: ignore + + return deserialized # type: ignore + + @distributed_trace_async + async def restore( + self, + *, + timeout: Optional[int] = None, + deleted_share_name: Optional[str] = None, + deleted_share_version: Optional[str] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any + ) -> None: + """Restores a previously deleted share. + + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword deleted_share_name: Specifies the name of the previously-deleted share. Default value + is None. + :paramtype deleted_share_name: str + :keyword deleted_share_version: Specifies the version of the previously-deleted share. Default + value is None. + :paramtype deleted_share_version: str + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls: ClsType[None] = kwargs.pop("cls", None) + + _request = build_share_restore_request( + timeout=timeout, + deleted_share_name=deleted_share_name, + deleted_share_version=deleted_share_version, + file_request_intent=file_request_intent, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [201]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) + response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) + response_headers["x-ms-share-quota"] = self._deserialize("int", response.headers.get("x-ms-share-quota")) + response_headers["x-ms-share-provisioned-iops"] = self._deserialize( + "int", response.headers.get("x-ms-share-provisioned-iops") + ) + response_headers["x-ms-share-provisioned-bandwidth-mibps"] = self._deserialize( + "int", response.headers.get("x-ms-share-provisioned-bandwidth-mibps") + ) + response_headers["x-ms-share-included-burst-iops"] = self._deserialize( + "int", response.headers.get("x-ms-share-included-burst-iops") + ) + response_headers["x-ms-share-max-burst-credits-for-iops"] = self._deserialize( + "int", response.headers.get("x-ms-share-max-burst-credits-for-iops") + ) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + + if cls: + return cls(pipeline_response, None, response_headers) # type: ignore diff --git a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/aio/operations/_patch.py b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/aio/operations/_patch.py index f7dd32510333..ea765788358a 100644 --- a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/aio/operations/_patch.py +++ b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/aio/operations/_patch.py @@ -1,14 +1,14 @@ -# ------------------------------------ -# Copyright (c) Microsoft Corporation. -# Licensed under the MIT License. -# ------------------------------------ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# -------------------------------------------------------------------------- """Customize generated code here. Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize """ -from typing import List -__all__: List[str] = [] # Add all objects you want publicly available to users at this package level +__all__: list[str] = [] # Add all objects you want publicly available to users at this package level def patch_sdk(): diff --git a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/aio/operations/_service_operations.py b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/aio/operations/_service_operations.py deleted file mode 100644 index 4d7dafcf5895..000000000000 --- a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/aio/operations/_service_operations.py +++ /dev/null @@ -1,376 +0,0 @@ -# pylint: disable=line-too-long,useless-suppression -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -from collections.abc import MutableMapping -from typing import Any, Callable, Literal, Optional, TypeVar, Union - -from azure.core import AsyncPipelineClient -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.pipeline import PipelineResponse -from azure.core.rest import AsyncHttpResponse, HttpRequest -from azure.core.tracing.decorator_async import distributed_trace_async -from azure.core.utils import case_insensitive_dict - -from ... import models as _models -from ..._utils.serialization import Deserializer, Serializer -from ...operations._service_operations import ( - build_get_properties_request, - build_get_user_delegation_key_request, - build_list_shares_segment_request, - build_set_properties_request, -) -from .._configuration import AzureFileStorageConfiguration - -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, dict[str, Any]], Any]] - - -class ServiceOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.storage.fileshare.aio.AzureFileStorage`'s - :attr:`service` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs) -> None: - input_args = list(args) - self._client: AsyncPipelineClient = input_args.pop(0) if input_args else kwargs.pop("client") - self._config: AzureFileStorageConfiguration = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize: Serializer = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize: Deserializer = input_args.pop(0) if input_args else kwargs.pop("deserializer") - - @distributed_trace_async - async def set_properties( - self, storage_service_properties: _models.StorageServiceProperties, timeout: Optional[int] = None, **kwargs: Any - ) -> None: - """Sets properties for a storage account's File service endpoint, including properties for Storage - Analytics metrics and CORS (Cross-Origin Resource Sharing) rules. - - :param storage_service_properties: The StorageService properties. Required. - :type storage_service_properties: ~azure.storage.fileshare.models.StorageServiceProperties - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - restype: Literal["service"] = kwargs.pop("restype", _params.pop("restype", "service")) - comp: Literal["properties"] = kwargs.pop("comp", _params.pop("comp", "properties")) - content_type: str = kwargs.pop("content_type", _headers.pop("Content-Type", "application/xml")) - cls: ClsType[None] = kwargs.pop("cls", None) - - _content = self._serialize.body(storage_service_properties, "StorageServiceProperties", is_xml=True) - - _request = build_set_properties_request( - url=self._config.url, - version=self._config.version, - timeout=timeout, - file_request_intent=self._config.file_request_intent, - restype=restype, - comp=comp, - content_type=content_type, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [202]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - - if cls: - return cls(pipeline_response, None, response_headers) # type: ignore - - @distributed_trace_async - async def get_properties(self, timeout: Optional[int] = None, **kwargs: Any) -> _models.StorageServiceProperties: - """Gets the properties of a storage account's File service, including properties for Storage - Analytics metrics and CORS (Cross-Origin Resource Sharing) rules. - - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :return: StorageServiceProperties or the result of cls(response) - :rtype: ~azure.storage.fileshare.models.StorageServiceProperties - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - restype: Literal["service"] = kwargs.pop("restype", _params.pop("restype", "service")) - comp: Literal["properties"] = kwargs.pop("comp", _params.pop("comp", "properties")) - cls: ClsType[_models.StorageServiceProperties] = kwargs.pop("cls", None) - - _request = build_get_properties_request( - url=self._config.url, - version=self._config.version, - timeout=timeout, - file_request_intent=self._config.file_request_intent, - restype=restype, - comp=comp, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - - deserialized = self._deserialize("StorageServiceProperties", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @distributed_trace_async - async def list_shares_segment( - self, - prefix: Optional[str] = None, - marker: Optional[str] = None, - maxresults: Optional[int] = None, - include: Optional[list[Union[str, _models.ListSharesIncludeType]]] = None, - timeout: Optional[int] = None, - **kwargs: Any - ) -> _models.ListSharesResponse: - """The List Shares Segment operation returns a list of the shares and share snapshots under the - specified account. - - :param prefix: Filters the results to return only entries whose name begins with the specified - prefix. Default value is None. - :type prefix: str - :param marker: A string value that identifies the portion of the list to be returned with the - next list operation. The operation returns a marker value within the response body if the list - returned was not complete. The marker value may then be used in a subsequent call to request - the next set of list items. The marker value is opaque to the client. Default value is None. - :type marker: str - :param maxresults: Specifies the maximum number of entries to return. If the request does not - specify maxresults, or specifies a value greater than 5,000, the server will return up to 5,000 - items. Default value is None. - :type maxresults: int - :param include: Include this parameter to specify one or more datasets to include in the - response. Default value is None. - :type include: list[str or ~azure.storage.fileshare.models.ListSharesIncludeType] - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :return: ListSharesResponse or the result of cls(response) - :rtype: ~azure.storage.fileshare.models.ListSharesResponse - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - comp: Literal["list"] = kwargs.pop("comp", _params.pop("comp", "list")) - cls: ClsType[_models.ListSharesResponse] = kwargs.pop("cls", None) - - _request = build_list_shares_segment_request( - url=self._config.url, - version=self._config.version, - prefix=prefix, - marker=marker, - maxresults=maxresults, - include=include, - timeout=timeout, - file_request_intent=self._config.file_request_intent, - comp=comp, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - - deserialized = self._deserialize("ListSharesResponse", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @distributed_trace_async - async def get_user_delegation_key( - self, - key_info: _models.KeyInfo, - timeout: Optional[int] = None, - request_id_parameter: Optional[str] = None, - **kwargs: Any - ) -> _models.UserDelegationKey: - """Retrieves a user delegation key for the File service. This is only a valid operation when using - bearer token authentication. - - :param key_info: Key information. Required. - :type key_info: ~azure.storage.fileshare.models.KeyInfo - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param request_id_parameter: Provides a client-generated, opaque value with a 1 KB character - limit that is recorded in the analytics logs when storage analytics logging is enabled. Default - value is None. - :type request_id_parameter: str - :return: UserDelegationKey or the result of cls(response) - :rtype: ~azure.storage.fileshare.models.UserDelegationKey - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - restype: Literal["service"] = kwargs.pop("restype", _params.pop("restype", "service")) - comp: Literal["userdelegationkey"] = kwargs.pop("comp", _params.pop("comp", "userdelegationkey")) - content_type: str = kwargs.pop("content_type", _headers.pop("Content-Type", "application/xml")) - cls: ClsType[_models.UserDelegationKey] = kwargs.pop("cls", None) - - _content = self._serialize.body(key_info, "KeyInfo", is_xml=True) - - _request = build_get_user_delegation_key_request( - url=self._config.url, - version=self._config.version, - timeout=timeout, - request_id_parameter=request_id_parameter, - restype=restype, - comp=comp, - content_type=content_type, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["x-ms-client-request-id"] = self._deserialize( - "str", response.headers.get("x-ms-client-request-id") - ) - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - - deserialized = self._deserialize("UserDelegationKey", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore diff --git a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/aio/operations/_share_operations.py b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/aio/operations/_share_operations.py deleted file mode 100644 index 39daa0cfeb65..000000000000 --- a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/aio/operations/_share_operations.py +++ /dev/null @@ -1,1811 +0,0 @@ -# pylint: disable=line-too-long,useless-suppression,too-many-lines -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -from collections.abc import MutableMapping -from io import IOBase -from typing import Any, Callable, IO, Literal, Optional, TypeVar, Union, overload - -from azure.core import AsyncPipelineClient -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.pipeline import PipelineResponse -from azure.core.rest import AsyncHttpResponse, HttpRequest -from azure.core.tracing.decorator_async import distributed_trace_async -from azure.core.utils import case_insensitive_dict - -from ... import models as _models -from ..._utils.serialization import Deserializer, Serializer -from ...operations._share_operations import ( - build_acquire_lease_request, - build_break_lease_request, - build_change_lease_request, - build_create_permission_request, - build_create_request, - build_create_snapshot_request, - build_delete_request, - build_get_access_policy_request, - build_get_permission_request, - build_get_properties_request, - build_get_statistics_request, - build_release_lease_request, - build_renew_lease_request, - build_restore_request, - build_set_access_policy_request, - build_set_metadata_request, - build_set_properties_request, -) -from .._configuration import AzureFileStorageConfiguration - -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, AsyncHttpResponse], T, dict[str, Any]], Any]] - - -class ShareOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.storage.fileshare.aio.AzureFileStorage`'s - :attr:`share` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs) -> None: - input_args = list(args) - self._client: AsyncPipelineClient = input_args.pop(0) if input_args else kwargs.pop("client") - self._config: AzureFileStorageConfiguration = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize: Serializer = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize: Deserializer = input_args.pop(0) if input_args else kwargs.pop("deserializer") - - @distributed_trace_async - async def create( # pylint: disable=too-many-locals - self, - timeout: Optional[int] = None, - metadata: Optional[dict[str, str]] = None, - quota: Optional[int] = None, - access_tier: Optional[Union[str, _models.ShareAccessTier]] = None, - enabled_protocols: Optional[str] = None, - root_squash: Optional[Union[str, _models.ShareRootSquash]] = None, - enable_snapshot_virtual_directory_access: Optional[bool] = None, - paid_bursting_enabled: Optional[bool] = None, - paid_bursting_max_bandwidth_mibps: Optional[int] = None, - paid_bursting_max_iops: Optional[int] = None, - share_provisioned_iops: Optional[int] = None, - share_provisioned_bandwidth_mibps: Optional[int] = None, - enable_smb_directory_lease: Optional[bool] = None, - **kwargs: Any - ) -> None: - """Creates a new share under the specified account. If the share with the same name already - exists, the operation fails. - - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param metadata: A name-value pair to associate with a file storage object. Default value is - None. - :type metadata: dict[str, str] - :param quota: Specifies the maximum size of the share, in gigabytes. Default value is None. - :type quota: int - :param access_tier: Specifies the access tier of the share. Known values are: - "TransactionOptimized", "Hot", "Cool", and "Premium". Default value is None. - :type access_tier: str or ~azure.storage.fileshare.models.ShareAccessTier - :param enabled_protocols: Protocols to enable on the share. Default value is None. - :type enabled_protocols: str - :param root_squash: Root squash to set on the share. Only valid for NFS shares. Known values - are: "NoRootSquash", "RootSquash", and "AllSquash". Default value is None. - :type root_squash: str or ~azure.storage.fileshare.models.ShareRootSquash - :param enable_snapshot_virtual_directory_access: Default value is None. - :type enable_snapshot_virtual_directory_access: bool - :param paid_bursting_enabled: Optional. Boolean. Default if not specified is false. This - property enables paid bursting. Default value is None. - :type paid_bursting_enabled: bool - :param paid_bursting_max_bandwidth_mibps: Optional. Integer. Default if not specified is the - maximum throughput the file share can support. Current maximum for a file share is 10,340 - MiB/sec. Default value is None. - :type paid_bursting_max_bandwidth_mibps: int - :param paid_bursting_max_iops: Optional. Integer. Default if not specified is the maximum IOPS - the file share can support. Current maximum for a file share is 102,400 IOPS. Default value is - None. - :type paid_bursting_max_iops: int - :param share_provisioned_iops: Optional. Supported in version 2025-01-05 and later. Only - allowed for provisioned v2 file shares. Specifies the provisioned number of input/output - operations per second (IOPS) of the share. If this is not specified, the provisioned IOPS is - set to value calculated based on recommendation formula. Default value is None. - :type share_provisioned_iops: int - :param share_provisioned_bandwidth_mibps: Optional. Supported in version 2025-01-05 and later. - Only allowed for provisioned v2 file shares. Specifies the provisioned bandwidth of the share, - in mebibytes per second (MiBps). If this is not specified, the provisioned bandwidth is set to - value calculated based on recommendation formula. Default value is None. - :type share_provisioned_bandwidth_mibps: int - :param enable_smb_directory_lease: SMB only, default is true. Specifies whether granting of - new directory leases for directories present in a share are to be enabled or disabled. An input - of true specifies that granting of new directory leases is to be allowed. An input of false - specifies that granting of new directory leases is to be blocked. Default value is None. - :type enable_smb_directory_lease: bool - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - restype: Literal["share"] = kwargs.pop("restype", _params.pop("restype", "share")) - cls: ClsType[None] = kwargs.pop("cls", None) - - _request = build_create_request( - url=self._config.url, - version=self._config.version, - timeout=timeout, - metadata=metadata, - quota=quota, - access_tier=access_tier, - enabled_protocols=enabled_protocols, - root_squash=root_squash, - enable_snapshot_virtual_directory_access=enable_snapshot_virtual_directory_access, - paid_bursting_enabled=paid_bursting_enabled, - paid_bursting_max_bandwidth_mibps=paid_bursting_max_bandwidth_mibps, - paid_bursting_max_iops=paid_bursting_max_iops, - share_provisioned_iops=share_provisioned_iops, - share_provisioned_bandwidth_mibps=share_provisioned_bandwidth_mibps, - enable_smb_directory_lease=enable_smb_directory_lease, - file_request_intent=self._config.file_request_intent, - restype=restype, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [201]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) - response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - response_headers["x-ms-share-quota"] = self._deserialize("int", response.headers.get("x-ms-share-quota")) - response_headers["x-ms-share-provisioned-iops"] = self._deserialize( - "int", response.headers.get("x-ms-share-provisioned-iops") - ) - response_headers["x-ms-share-provisioned-bandwidth-mibps"] = self._deserialize( - "int", response.headers.get("x-ms-share-provisioned-bandwidth-mibps") - ) - response_headers["x-ms-share-included-burst-iops"] = self._deserialize( - "int", response.headers.get("x-ms-share-included-burst-iops") - ) - response_headers["x-ms-share-max-burst-credits-for-iops"] = self._deserialize( - "int", response.headers.get("x-ms-share-max-burst-credits-for-iops") - ) - - if cls: - return cls(pipeline_response, None, response_headers) # type: ignore - - @distributed_trace_async - async def get_properties( - self, - sharesnapshot: Optional[str] = None, - timeout: Optional[int] = None, - lease_access_conditions: Optional[_models.LeaseAccessConditions] = None, - **kwargs: Any - ) -> None: - """Returns all user-defined metadata and system properties for the specified share or share - snapshot. The data returned does not include the share's list of files. - - :param sharesnapshot: The snapshot parameter is an opaque DateTime value that, when present, - specifies the share snapshot to query. Default value is None. - :type sharesnapshot: str - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param lease_access_conditions: Parameter group. Default value is None. - :type lease_access_conditions: ~azure.storage.fileshare.models.LeaseAccessConditions - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - restype: Literal["share"] = kwargs.pop("restype", _params.pop("restype", "share")) - cls: ClsType[None] = kwargs.pop("cls", None) - - _lease_id = None - if lease_access_conditions is not None: - _lease_id = lease_access_conditions.lease_id - - _request = build_get_properties_request( - url=self._config.url, - version=self._config.version, - sharesnapshot=sharesnapshot, - timeout=timeout, - lease_id=_lease_id, - file_request_intent=self._config.file_request_intent, - restype=restype, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["x-ms-meta"] = self._deserialize("{str}", response.headers.get("x-ms-meta")) - response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) - response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - response_headers["x-ms-share-quota"] = self._deserialize("int", response.headers.get("x-ms-share-quota")) - response_headers["x-ms-share-provisioned-iops"] = self._deserialize( - "int", response.headers.get("x-ms-share-provisioned-iops") - ) - response_headers["x-ms-share-provisioned-ingress-mbps"] = self._deserialize( - "int", response.headers.get("x-ms-share-provisioned-ingress-mbps") - ) - response_headers["x-ms-share-provisioned-egress-mbps"] = self._deserialize( - "int", response.headers.get("x-ms-share-provisioned-egress-mbps") - ) - response_headers["x-ms-share-next-allowed-quota-downgrade-time"] = self._deserialize( - "rfc-1123", response.headers.get("x-ms-share-next-allowed-quota-downgrade-time") - ) - response_headers["x-ms-share-provisioned-bandwidth-mibps"] = self._deserialize( - "int", response.headers.get("x-ms-share-provisioned-bandwidth-mibps") - ) - response_headers["x-ms-lease-duration"] = self._deserialize("str", response.headers.get("x-ms-lease-duration")) - response_headers["x-ms-lease-state"] = self._deserialize("str", response.headers.get("x-ms-lease-state")) - response_headers["x-ms-lease-status"] = self._deserialize("str", response.headers.get("x-ms-lease-status")) - response_headers["x-ms-access-tier"] = self._deserialize("str", response.headers.get("x-ms-access-tier")) - response_headers["x-ms-access-tier-change-time"] = self._deserialize( - "rfc-1123", response.headers.get("x-ms-access-tier-change-time") - ) - response_headers["x-ms-access-tier-transition-state"] = self._deserialize( - "str", response.headers.get("x-ms-access-tier-transition-state") - ) - response_headers["x-ms-enabled-protocols"] = self._deserialize( - "str", response.headers.get("x-ms-enabled-protocols") - ) - response_headers["x-ms-root-squash"] = self._deserialize("str", response.headers.get("x-ms-root-squash")) - response_headers["x-ms-enable-snapshot-virtual-directory-access"] = self._deserialize( - "bool", response.headers.get("x-ms-enable-snapshot-virtual-directory-access") - ) - response_headers["x-ms-share-paid-bursting-enabled"] = self._deserialize( - "bool", response.headers.get("x-ms-share-paid-bursting-enabled") - ) - response_headers["x-ms-share-paid-bursting-max-iops"] = self._deserialize( - "int", response.headers.get("x-ms-share-paid-bursting-max-iops") - ) - response_headers["x-ms-share-paid-bursting-max-bandwidth-mibps"] = self._deserialize( - "int", response.headers.get("x-ms-share-paid-bursting-max-bandwidth-mibps") - ) - response_headers["x-ms-share-included-burst-iops"] = self._deserialize( - "int", response.headers.get("x-ms-share-included-burst-iops") - ) - response_headers["x-ms-share-max-burst-credits-for-iops"] = self._deserialize( - "int", response.headers.get("x-ms-share-max-burst-credits-for-iops") - ) - response_headers["x-ms-share-next-allowed-provisioned-iops-downgrade-time"] = self._deserialize( - "rfc-1123", response.headers.get("x-ms-share-next-allowed-provisioned-iops-downgrade-time") - ) - response_headers["x-ms-share-next-allowed-provisioned-bandwidth-downgrade-time"] = self._deserialize( - "rfc-1123", response.headers.get("x-ms-share-next-allowed-provisioned-bandwidth-downgrade-time") - ) - response_headers["x-ms-enable-smb-directory-lease"] = self._deserialize( - "bool", response.headers.get("x-ms-enable-smb-directory-lease") - ) - - if cls: - return cls(pipeline_response, None, response_headers) # type: ignore - - @distributed_trace_async - async def delete( - self, - sharesnapshot: Optional[str] = None, - timeout: Optional[int] = None, - delete_snapshots: Optional[Union[str, _models.DeleteSnapshotsOptionType]] = None, - lease_access_conditions: Optional[_models.LeaseAccessConditions] = None, - **kwargs: Any - ) -> None: - """Operation marks the specified share or share snapshot for deletion. The share or share snapshot - and any files contained within it are later deleted during garbage collection. - - :param sharesnapshot: The snapshot parameter is an opaque DateTime value that, when present, - specifies the share snapshot to query. Default value is None. - :type sharesnapshot: str - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param delete_snapshots: Specifies the option include to delete the base share and all of its - snapshots. Known values are: "include" and "include-leased". Default value is None. - :type delete_snapshots: str or ~azure.storage.fileshare.models.DeleteSnapshotsOptionType - :param lease_access_conditions: Parameter group. Default value is None. - :type lease_access_conditions: ~azure.storage.fileshare.models.LeaseAccessConditions - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - restype: Literal["share"] = kwargs.pop("restype", _params.pop("restype", "share")) - cls: ClsType[None] = kwargs.pop("cls", None) - - _lease_id = None - if lease_access_conditions is not None: - _lease_id = lease_access_conditions.lease_id - - _request = build_delete_request( - url=self._config.url, - version=self._config.version, - sharesnapshot=sharesnapshot, - timeout=timeout, - delete_snapshots=delete_snapshots, - lease_id=_lease_id, - file_request_intent=self._config.file_request_intent, - restype=restype, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [202]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - response_headers["x-ms-file-share-usage-bytes"] = self._deserialize( - "int", response.headers.get("x-ms-file-share-usage-bytes") - ) - response_headers["x-ms-file-share-snapshot-usage-bytes"] = self._deserialize( - "int", response.headers.get("x-ms-file-share-snapshot-usage-bytes") - ) - - if cls: - return cls(pipeline_response, None, response_headers) # type: ignore - - @distributed_trace_async - async def acquire_lease( - self, - timeout: Optional[int] = None, - duration: Optional[int] = None, - proposed_lease_id: Optional[str] = None, - sharesnapshot: Optional[str] = None, - request_id_parameter: Optional[str] = None, - **kwargs: Any - ) -> None: - """The Lease Share operation establishes and manages a lock on a share, or the specified snapshot - for set and delete share operations. - - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param duration: Specifies the duration of the lease, in seconds, or negative one (-1) for a - lease that never expires. A non-infinite lease can be between 15 and 60 seconds. A lease - duration cannot be changed using renew or change. Default value is None. - :type duration: int - :param proposed_lease_id: Proposed lease ID, in a GUID string format. The File service returns - 400 (Invalid request) if the proposed lease ID is not in the correct format. See Guid - Constructor (String) for a list of valid GUID string formats. Default value is None. - :type proposed_lease_id: str - :param sharesnapshot: The snapshot parameter is an opaque DateTime value that, when present, - specifies the share snapshot to query. Default value is None. - :type sharesnapshot: str - :param request_id_parameter: Provides a client-generated, opaque value with a 1 KB character - limit that is recorded in the analytics logs when storage analytics logging is enabled. Default - value is None. - :type request_id_parameter: str - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - comp: Literal["lease"] = kwargs.pop("comp", _params.pop("comp", "lease")) - action: Literal["acquire"] = kwargs.pop("action", _headers.pop("x-ms-lease-action", "acquire")) - restype: Literal["share"] = kwargs.pop("restype", _params.pop("restype", "share")) - cls: ClsType[None] = kwargs.pop("cls", None) - - _request = build_acquire_lease_request( - url=self._config.url, - version=self._config.version, - timeout=timeout, - duration=duration, - proposed_lease_id=proposed_lease_id, - sharesnapshot=sharesnapshot, - request_id_parameter=request_id_parameter, - file_request_intent=self._config.file_request_intent, - comp=comp, - action=action, - restype=restype, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [201]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) - response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) - response_headers["x-ms-lease-id"] = self._deserialize("str", response.headers.get("x-ms-lease-id")) - response_headers["x-ms-client-request-id"] = self._deserialize( - "str", response.headers.get("x-ms-client-request-id") - ) - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - - if cls: - return cls(pipeline_response, None, response_headers) # type: ignore - - @distributed_trace_async - async def release_lease( - self, - lease_id: str, - timeout: Optional[int] = None, - sharesnapshot: Optional[str] = None, - request_id_parameter: Optional[str] = None, - **kwargs: Any - ) -> None: - """The Lease Share operation establishes and manages a lock on a share, or the specified snapshot - for set and delete share operations. - - :param lease_id: Specifies the current lease ID on the resource. Required. - :type lease_id: str - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param sharesnapshot: The snapshot parameter is an opaque DateTime value that, when present, - specifies the share snapshot to query. Default value is None. - :type sharesnapshot: str - :param request_id_parameter: Provides a client-generated, opaque value with a 1 KB character - limit that is recorded in the analytics logs when storage analytics logging is enabled. Default - value is None. - :type request_id_parameter: str - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - comp: Literal["lease"] = kwargs.pop("comp", _params.pop("comp", "lease")) - action: Literal["release"] = kwargs.pop("action", _headers.pop("x-ms-lease-action", "release")) - restype: Literal["share"] = kwargs.pop("restype", _params.pop("restype", "share")) - cls: ClsType[None] = kwargs.pop("cls", None) - - _request = build_release_lease_request( - url=self._config.url, - lease_id=lease_id, - version=self._config.version, - timeout=timeout, - sharesnapshot=sharesnapshot, - request_id_parameter=request_id_parameter, - file_request_intent=self._config.file_request_intent, - comp=comp, - action=action, - restype=restype, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) - response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) - response_headers["x-ms-client-request-id"] = self._deserialize( - "str", response.headers.get("x-ms-client-request-id") - ) - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - - if cls: - return cls(pipeline_response, None, response_headers) # type: ignore - - @distributed_trace_async - async def change_lease( - self, - lease_id: str, - timeout: Optional[int] = None, - proposed_lease_id: Optional[str] = None, - sharesnapshot: Optional[str] = None, - request_id_parameter: Optional[str] = None, - **kwargs: Any - ) -> None: - """The Lease Share operation establishes and manages a lock on a share, or the specified snapshot - for set and delete share operations. - - :param lease_id: Specifies the current lease ID on the resource. Required. - :type lease_id: str - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param proposed_lease_id: Proposed lease ID, in a GUID string format. The File service returns - 400 (Invalid request) if the proposed lease ID is not in the correct format. See Guid - Constructor (String) for a list of valid GUID string formats. Default value is None. - :type proposed_lease_id: str - :param sharesnapshot: The snapshot parameter is an opaque DateTime value that, when present, - specifies the share snapshot to query. Default value is None. - :type sharesnapshot: str - :param request_id_parameter: Provides a client-generated, opaque value with a 1 KB character - limit that is recorded in the analytics logs when storage analytics logging is enabled. Default - value is None. - :type request_id_parameter: str - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - comp: Literal["lease"] = kwargs.pop("comp", _params.pop("comp", "lease")) - action: Literal["change"] = kwargs.pop("action", _headers.pop("x-ms-lease-action", "change")) - restype: Literal["share"] = kwargs.pop("restype", _params.pop("restype", "share")) - cls: ClsType[None] = kwargs.pop("cls", None) - - _request = build_change_lease_request( - url=self._config.url, - lease_id=lease_id, - version=self._config.version, - timeout=timeout, - proposed_lease_id=proposed_lease_id, - sharesnapshot=sharesnapshot, - request_id_parameter=request_id_parameter, - file_request_intent=self._config.file_request_intent, - comp=comp, - action=action, - restype=restype, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) - response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) - response_headers["x-ms-lease-id"] = self._deserialize("str", response.headers.get("x-ms-lease-id")) - response_headers["x-ms-client-request-id"] = self._deserialize( - "str", response.headers.get("x-ms-client-request-id") - ) - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - - if cls: - return cls(pipeline_response, None, response_headers) # type: ignore - - @distributed_trace_async - async def renew_lease( - self, - lease_id: str, - timeout: Optional[int] = None, - sharesnapshot: Optional[str] = None, - request_id_parameter: Optional[str] = None, - **kwargs: Any - ) -> None: - """The Lease Share operation establishes and manages a lock on a share, or the specified snapshot - for set and delete share operations. - - :param lease_id: Specifies the current lease ID on the resource. Required. - :type lease_id: str - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param sharesnapshot: The snapshot parameter is an opaque DateTime value that, when present, - specifies the share snapshot to query. Default value is None. - :type sharesnapshot: str - :param request_id_parameter: Provides a client-generated, opaque value with a 1 KB character - limit that is recorded in the analytics logs when storage analytics logging is enabled. Default - value is None. - :type request_id_parameter: str - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - comp: Literal["lease"] = kwargs.pop("comp", _params.pop("comp", "lease")) - action: Literal["renew"] = kwargs.pop("action", _headers.pop("x-ms-lease-action", "renew")) - restype: Literal["share"] = kwargs.pop("restype", _params.pop("restype", "share")) - cls: ClsType[None] = kwargs.pop("cls", None) - - _request = build_renew_lease_request( - url=self._config.url, - lease_id=lease_id, - version=self._config.version, - timeout=timeout, - sharesnapshot=sharesnapshot, - request_id_parameter=request_id_parameter, - file_request_intent=self._config.file_request_intent, - comp=comp, - action=action, - restype=restype, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) - response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) - response_headers["x-ms-lease-id"] = self._deserialize("str", response.headers.get("x-ms-lease-id")) - response_headers["x-ms-client-request-id"] = self._deserialize( - "str", response.headers.get("x-ms-client-request-id") - ) - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - - if cls: - return cls(pipeline_response, None, response_headers) # type: ignore - - @distributed_trace_async - async def break_lease( - self, - timeout: Optional[int] = None, - break_period: Optional[int] = None, - request_id_parameter: Optional[str] = None, - sharesnapshot: Optional[str] = None, - lease_access_conditions: Optional[_models.LeaseAccessConditions] = None, - **kwargs: Any - ) -> None: - """The Lease Share operation establishes and manages a lock on a share, or the specified snapshot - for set and delete share operations. - - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param break_period: For a break operation, proposed duration the lease should continue before - it is broken, in seconds, between 0 and 60. This break period is only used if it is shorter - than the time remaining on the lease. If longer, the time remaining on the lease is used. A new - lease will not be available before the break period has expired, but the lease may be held for - longer than the break period. If this header does not appear with a break operation, a - fixed-duration lease breaks after the remaining lease period elapses, and an infinite lease - breaks immediately. Default value is None. - :type break_period: int - :param request_id_parameter: Provides a client-generated, opaque value with a 1 KB character - limit that is recorded in the analytics logs when storage analytics logging is enabled. Default - value is None. - :type request_id_parameter: str - :param sharesnapshot: The snapshot parameter is an opaque DateTime value that, when present, - specifies the share snapshot to query. Default value is None. - :type sharesnapshot: str - :param lease_access_conditions: Parameter group. Default value is None. - :type lease_access_conditions: ~azure.storage.fileshare.models.LeaseAccessConditions - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - comp: Literal["lease"] = kwargs.pop("comp", _params.pop("comp", "lease")) - action: Literal["break"] = kwargs.pop("action", _headers.pop("x-ms-lease-action", "break")) - restype: Literal["share"] = kwargs.pop("restype", _params.pop("restype", "share")) - cls: ClsType[None] = kwargs.pop("cls", None) - - _lease_id = None - if lease_access_conditions is not None: - _lease_id = lease_access_conditions.lease_id - - _request = build_break_lease_request( - url=self._config.url, - version=self._config.version, - timeout=timeout, - break_period=break_period, - lease_id=_lease_id, - request_id_parameter=request_id_parameter, - sharesnapshot=sharesnapshot, - file_request_intent=self._config.file_request_intent, - comp=comp, - action=action, - restype=restype, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [202]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) - response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) - response_headers["x-ms-lease-time"] = self._deserialize("int", response.headers.get("x-ms-lease-time")) - response_headers["x-ms-lease-id"] = self._deserialize("str", response.headers.get("x-ms-lease-id")) - response_headers["x-ms-client-request-id"] = self._deserialize( - "str", response.headers.get("x-ms-client-request-id") - ) - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - - if cls: - return cls(pipeline_response, None, response_headers) # type: ignore - - @distributed_trace_async - async def create_snapshot( - self, timeout: Optional[int] = None, metadata: Optional[dict[str, str]] = None, **kwargs: Any - ) -> None: - """Creates a read-only snapshot of a share. - - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param metadata: A name-value pair to associate with a file storage object. Default value is - None. - :type metadata: dict[str, str] - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - restype: Literal["share"] = kwargs.pop("restype", _params.pop("restype", "share")) - comp: Literal["snapshot"] = kwargs.pop("comp", _params.pop("comp", "snapshot")) - cls: ClsType[None] = kwargs.pop("cls", None) - - _request = build_create_snapshot_request( - url=self._config.url, - version=self._config.version, - timeout=timeout, - metadata=metadata, - file_request_intent=self._config.file_request_intent, - restype=restype, - comp=comp, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [201]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["x-ms-snapshot"] = self._deserialize("str", response.headers.get("x-ms-snapshot")) - response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) - response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - - if cls: - return cls(pipeline_response, None, response_headers) # type: ignore - - @overload - async def create_permission( - self, - share_permission: _models.SharePermission, - timeout: Optional[int] = None, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> None: - """Create a permission (a security descriptor). - - :param share_permission: A permission (a security descriptor) at the share level. Required. - :type share_permission: ~azure.storage.fileshare.models.SharePermission - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - async def create_permission( - self, - share_permission: IO[bytes], - timeout: Optional[int] = None, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> None: - """Create a permission (a security descriptor). - - :param share_permission: A permission (a security descriptor) at the share level. Required. - :type share_permission: IO[bytes] - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace_async - async def create_permission( - self, share_permission: Union[_models.SharePermission, IO[bytes]], timeout: Optional[int] = None, **kwargs: Any - ) -> None: - """Create a permission (a security descriptor). - - :param share_permission: A permission (a security descriptor) at the share level. Is either a - SharePermission type or a IO[bytes] type. Required. - :type share_permission: ~azure.storage.fileshare.models.SharePermission or IO[bytes] - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - restype: Literal["share"] = kwargs.pop("restype", _params.pop("restype", "share")) - comp: Literal["filepermission"] = kwargs.pop("comp", _params.pop("comp", "filepermission")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[None] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(share_permission, (IOBase, bytes)): - _content = share_permission - else: - _json = self._serialize.body(share_permission, "SharePermission") - - _request = build_create_permission_request( - url=self._config.url, - version=self._config.version, - timeout=timeout, - file_request_intent=self._config.file_request_intent, - restype=restype, - comp=comp, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [201]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - response_headers["x-ms-file-permission-key"] = self._deserialize( - "str", response.headers.get("x-ms-file-permission-key") - ) - - if cls: - return cls(pipeline_response, None, response_headers) # type: ignore - - @distributed_trace_async - async def get_permission( - self, - file_permission_key: str, - file_permission_format: Optional[Union[str, _models.FilePermissionFormat]] = None, - timeout: Optional[int] = None, - **kwargs: Any - ) -> _models.SharePermission: - """Returns the permission (security descriptor) for a given key. - - :param file_permission_key: Key of the permission to be set for the directory/file. Required. - :type file_permission_key: str - :param file_permission_format: Optional. Available for version 2023-06-01 and later. Specifies - the format in which the permission is returned. Acceptable values are SDDL or binary. If - x-ms-file-permission-format is unspecified or explicitly set to SDDL, the permission is - returned in SDDL format. If x-ms-file-permission-format is explicitly set to binary, the - permission is returned as a base64 string representing the binary encoding of the permission. - Known values are: "Sddl" and "Binary". Default value is None. - :type file_permission_format: str or ~azure.storage.fileshare.models.FilePermissionFormat - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :return: SharePermission or the result of cls(response) - :rtype: ~azure.storage.fileshare.models.SharePermission - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - restype: Literal["share"] = kwargs.pop("restype", _params.pop("restype", "share")) - comp: Literal["filepermission"] = kwargs.pop("comp", _params.pop("comp", "filepermission")) - cls: ClsType[_models.SharePermission] = kwargs.pop("cls", None) - - _request = build_get_permission_request( - url=self._config.url, - file_permission_key=file_permission_key, - version=self._config.version, - file_permission_format=file_permission_format, - timeout=timeout, - file_request_intent=self._config.file_request_intent, - restype=restype, - comp=comp, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - - deserialized = self._deserialize("SharePermission", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @distributed_trace_async - async def set_properties( # pylint: disable=too-many-locals - self, - timeout: Optional[int] = None, - quota: Optional[int] = None, - access_tier: Optional[Union[str, _models.ShareAccessTier]] = None, - root_squash: Optional[Union[str, _models.ShareRootSquash]] = None, - enable_snapshot_virtual_directory_access: Optional[bool] = None, - paid_bursting_enabled: Optional[bool] = None, - paid_bursting_max_bandwidth_mibps: Optional[int] = None, - paid_bursting_max_iops: Optional[int] = None, - share_provisioned_iops: Optional[int] = None, - share_provisioned_bandwidth_mibps: Optional[int] = None, - enable_smb_directory_lease: Optional[bool] = None, - lease_access_conditions: Optional[_models.LeaseAccessConditions] = None, - **kwargs: Any - ) -> None: - """Sets properties for the specified share. - - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param quota: Specifies the maximum size of the share, in gigabytes. Default value is None. - :type quota: int - :param access_tier: Specifies the access tier of the share. Known values are: - "TransactionOptimized", "Hot", "Cool", and "Premium". Default value is None. - :type access_tier: str or ~azure.storage.fileshare.models.ShareAccessTier - :param root_squash: Root squash to set on the share. Only valid for NFS shares. Known values - are: "NoRootSquash", "RootSquash", and "AllSquash". Default value is None. - :type root_squash: str or ~azure.storage.fileshare.models.ShareRootSquash - :param enable_snapshot_virtual_directory_access: Default value is None. - :type enable_snapshot_virtual_directory_access: bool - :param paid_bursting_enabled: Optional. Boolean. Default if not specified is false. This - property enables paid bursting. Default value is None. - :type paid_bursting_enabled: bool - :param paid_bursting_max_bandwidth_mibps: Optional. Integer. Default if not specified is the - maximum throughput the file share can support. Current maximum for a file share is 10,340 - MiB/sec. Default value is None. - :type paid_bursting_max_bandwidth_mibps: int - :param paid_bursting_max_iops: Optional. Integer. Default if not specified is the maximum IOPS - the file share can support. Current maximum for a file share is 102,400 IOPS. Default value is - None. - :type paid_bursting_max_iops: int - :param share_provisioned_iops: Optional. Supported in version 2025-01-05 and later. Only - allowed for provisioned v2 file shares. Specifies the provisioned number of input/output - operations per second (IOPS) of the share. If this is not specified, the provisioned IOPS is - set to value calculated based on recommendation formula. Default value is None. - :type share_provisioned_iops: int - :param share_provisioned_bandwidth_mibps: Optional. Supported in version 2025-01-05 and later. - Only allowed for provisioned v2 file shares. Specifies the provisioned bandwidth of the share, - in mebibytes per second (MiBps). If this is not specified, the provisioned bandwidth is set to - value calculated based on recommendation formula. Default value is None. - :type share_provisioned_bandwidth_mibps: int - :param enable_smb_directory_lease: SMB only, default is true. Specifies whether granting of - new directory leases for directories present in a share are to be enabled or disabled. An input - of true specifies that granting of new directory leases is to be allowed. An input of false - specifies that granting of new directory leases is to be blocked. Default value is None. - :type enable_smb_directory_lease: bool - :param lease_access_conditions: Parameter group. Default value is None. - :type lease_access_conditions: ~azure.storage.fileshare.models.LeaseAccessConditions - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - restype: Literal["share"] = kwargs.pop("restype", _params.pop("restype", "share")) - comp: Literal["properties"] = kwargs.pop("comp", _params.pop("comp", "properties")) - cls: ClsType[None] = kwargs.pop("cls", None) - - _lease_id = None - if lease_access_conditions is not None: - _lease_id = lease_access_conditions.lease_id - - _request = build_set_properties_request( - url=self._config.url, - version=self._config.version, - timeout=timeout, - quota=quota, - access_tier=access_tier, - lease_id=_lease_id, - root_squash=root_squash, - enable_snapshot_virtual_directory_access=enable_snapshot_virtual_directory_access, - paid_bursting_enabled=paid_bursting_enabled, - paid_bursting_max_bandwidth_mibps=paid_bursting_max_bandwidth_mibps, - paid_bursting_max_iops=paid_bursting_max_iops, - share_provisioned_iops=share_provisioned_iops, - share_provisioned_bandwidth_mibps=share_provisioned_bandwidth_mibps, - enable_smb_directory_lease=enable_smb_directory_lease, - file_request_intent=self._config.file_request_intent, - restype=restype, - comp=comp, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) - response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - response_headers["x-ms-share-quota"] = self._deserialize("int", response.headers.get("x-ms-share-quota")) - response_headers["x-ms-share-provisioned-iops"] = self._deserialize( - "int", response.headers.get("x-ms-share-provisioned-iops") - ) - response_headers["x-ms-share-provisioned-bandwidth-mibps"] = self._deserialize( - "int", response.headers.get("x-ms-share-provisioned-bandwidth-mibps") - ) - response_headers["x-ms-share-included-burst-iops"] = self._deserialize( - "int", response.headers.get("x-ms-share-included-burst-iops") - ) - response_headers["x-ms-share-max-burst-credits-for-iops"] = self._deserialize( - "int", response.headers.get("x-ms-share-max-burst-credits-for-iops") - ) - response_headers["x-ms-share-next-allowed-quota-downgrade-time"] = self._deserialize( - "rfc-1123", response.headers.get("x-ms-share-next-allowed-quota-downgrade-time") - ) - response_headers["x-ms-share-next-allowed-provisioned-iops-downgrade-time"] = self._deserialize( - "rfc-1123", response.headers.get("x-ms-share-next-allowed-provisioned-iops-downgrade-time") - ) - response_headers["x-ms-share-next-allowed-provisioned-bandwidth-downgrade-time"] = self._deserialize( - "rfc-1123", response.headers.get("x-ms-share-next-allowed-provisioned-bandwidth-downgrade-time") - ) - - if cls: - return cls(pipeline_response, None, response_headers) # type: ignore - - @distributed_trace_async - async def set_metadata( - self, - timeout: Optional[int] = None, - metadata: Optional[dict[str, str]] = None, - lease_access_conditions: Optional[_models.LeaseAccessConditions] = None, - **kwargs: Any - ) -> None: - """Sets one or more user-defined name-value pairs for the specified share. - - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param metadata: A name-value pair to associate with a file storage object. Default value is - None. - :type metadata: dict[str, str] - :param lease_access_conditions: Parameter group. Default value is None. - :type lease_access_conditions: ~azure.storage.fileshare.models.LeaseAccessConditions - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - restype: Literal["share"] = kwargs.pop("restype", _params.pop("restype", "share")) - comp: Literal["metadata"] = kwargs.pop("comp", _params.pop("comp", "metadata")) - cls: ClsType[None] = kwargs.pop("cls", None) - - _lease_id = None - if lease_access_conditions is not None: - _lease_id = lease_access_conditions.lease_id - - _request = build_set_metadata_request( - url=self._config.url, - version=self._config.version, - timeout=timeout, - metadata=metadata, - lease_id=_lease_id, - file_request_intent=self._config.file_request_intent, - restype=restype, - comp=comp, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) - response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - - if cls: - return cls(pipeline_response, None, response_headers) # type: ignore - - @distributed_trace_async - async def get_access_policy( - self, - timeout: Optional[int] = None, - lease_access_conditions: Optional[_models.LeaseAccessConditions] = None, - **kwargs: Any - ) -> list[_models.SignedIdentifier]: - """Returns information about stored access policies specified on the share. - - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param lease_access_conditions: Parameter group. Default value is None. - :type lease_access_conditions: ~azure.storage.fileshare.models.LeaseAccessConditions - :return: list of SignedIdentifier or the result of cls(response) - :rtype: list[~azure.storage.fileshare.models.SignedIdentifier] - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - restype: Literal["share"] = kwargs.pop("restype", _params.pop("restype", "share")) - comp: Literal["acl"] = kwargs.pop("comp", _params.pop("comp", "acl")) - cls: ClsType[list[_models.SignedIdentifier]] = kwargs.pop("cls", None) - - _lease_id = None - if lease_access_conditions is not None: - _lease_id = lease_access_conditions.lease_id - - _request = build_get_access_policy_request( - url=self._config.url, - version=self._config.version, - timeout=timeout, - lease_id=_lease_id, - file_request_intent=self._config.file_request_intent, - restype=restype, - comp=comp, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) - response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - - deserialized = self._deserialize("[SignedIdentifier]", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @distributed_trace_async - async def set_access_policy( - self, - timeout: Optional[int] = None, - lease_access_conditions: Optional[_models.LeaseAccessConditions] = None, - share_acl: Optional[list[_models.SignedIdentifier]] = None, - **kwargs: Any - ) -> None: - """Sets a stored access policy for use with shared access signatures. - - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param lease_access_conditions: Parameter group. Default value is None. - :type lease_access_conditions: ~azure.storage.fileshare.models.LeaseAccessConditions - :param share_acl: The ACL for the share. Default value is None. - :type share_acl: list[~azure.storage.fileshare.models.SignedIdentifier] - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - restype: Literal["share"] = kwargs.pop("restype", _params.pop("restype", "share")) - comp: Literal["acl"] = kwargs.pop("comp", _params.pop("comp", "acl")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", "application/xml")) - content_type = content_type if share_acl else None - cls: ClsType[None] = kwargs.pop("cls", None) - - _lease_id = None - if lease_access_conditions is not None: - _lease_id = lease_access_conditions.lease_id - serialization_ctxt = {"xml": {"name": "SignedIdentifiers", "wrapped": True}} - if share_acl is not None: - _content = self._serialize.body( - share_acl, "[SignedIdentifier]", is_xml=True, serialization_ctxt=serialization_ctxt - ) - else: - _content = None - - _request = build_set_access_policy_request( - url=self._config.url, - version=self._config.version, - timeout=timeout, - lease_id=_lease_id, - file_request_intent=self._config.file_request_intent, - restype=restype, - comp=comp, - content_type=content_type, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) - response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - - if cls: - return cls(pipeline_response, None, response_headers) # type: ignore - - @distributed_trace_async - async def get_statistics( - self, - timeout: Optional[int] = None, - lease_access_conditions: Optional[_models.LeaseAccessConditions] = None, - **kwargs: Any - ) -> _models.ShareStats: - """Retrieves statistics related to the share. - - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param lease_access_conditions: Parameter group. Default value is None. - :type lease_access_conditions: ~azure.storage.fileshare.models.LeaseAccessConditions - :return: ShareStats or the result of cls(response) - :rtype: ~azure.storage.fileshare.models.ShareStats - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - restype: Literal["share"] = kwargs.pop("restype", _params.pop("restype", "share")) - comp: Literal["stats"] = kwargs.pop("comp", _params.pop("comp", "stats")) - cls: ClsType[_models.ShareStats] = kwargs.pop("cls", None) - - _lease_id = None - if lease_access_conditions is not None: - _lease_id = lease_access_conditions.lease_id - - _request = build_get_statistics_request( - url=self._config.url, - version=self._config.version, - timeout=timeout, - lease_id=_lease_id, - file_request_intent=self._config.file_request_intent, - restype=restype, - comp=comp, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) - response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - - deserialized = self._deserialize("ShareStats", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @distributed_trace_async - async def restore( - self, - timeout: Optional[int] = None, - request_id_parameter: Optional[str] = None, - deleted_share_name: Optional[str] = None, - deleted_share_version: Optional[str] = None, - **kwargs: Any - ) -> None: - """Restores a previously deleted Share. - - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param request_id_parameter: Provides a client-generated, opaque value with a 1 KB character - limit that is recorded in the analytics logs when storage analytics logging is enabled. Default - value is None. - :type request_id_parameter: str - :param deleted_share_name: Specifies the name of the previously-deleted share. Default value is - None. - :type deleted_share_name: str - :param deleted_share_version: Specifies the version of the previously-deleted share. Default - value is None. - :type deleted_share_version: str - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - restype: Literal["share"] = kwargs.pop("restype", _params.pop("restype", "share")) - comp: Literal["undelete"] = kwargs.pop("comp", _params.pop("comp", "undelete")) - cls: ClsType[None] = kwargs.pop("cls", None) - - _request = build_restore_request( - url=self._config.url, - version=self._config.version, - timeout=timeout, - request_id_parameter=request_id_parameter, - deleted_share_name=deleted_share_name, - deleted_share_version=deleted_share_version, - file_request_intent=self._config.file_request_intent, - restype=restype, - comp=comp, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = await self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [201]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) - response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-client-request-id"] = self._deserialize( - "str", response.headers.get("x-ms-client-request-id") - ) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - response_headers["x-ms-share-quota"] = self._deserialize("int", response.headers.get("x-ms-share-quota")) - response_headers["x-ms-share-provisioned-iops"] = self._deserialize( - "int", response.headers.get("x-ms-share-provisioned-iops") - ) - response_headers["x-ms-share-provisioned-bandwidth-mibps"] = self._deserialize( - "int", response.headers.get("x-ms-share-provisioned-bandwidth-mibps") - ) - response_headers["x-ms-share-included-burst-iops"] = self._deserialize( - "int", response.headers.get("x-ms-share-included-burst-iops") - ) - response_headers["x-ms-share-max-burst-credits-for-iops"] = self._deserialize( - "int", response.headers.get("x-ms-share-max-burst-credits-for-iops") - ) - - if cls: - return cls(pipeline_response, None, response_headers) # type: ignore diff --git a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/models/__init__.py b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/models/__init__.py index bb6fe56afaca..9a1f11643f63 100644 --- a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/models/__init__.py +++ b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/models/__init__.py @@ -2,7 +2,7 @@ # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. +# Code generated by Microsoft (R) Python Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- # pylint: disable=wrong-import-position @@ -13,21 +13,18 @@ from ._patch import * # pylint: disable=unused-wildcard-import -from ._models_py3 import ( # type: ignore +from ._models import ( # type: ignore AccessPolicy, ClearRange, - CopyFileSmbInfo, CorsRule, - DestinationLeaseAccessConditions, DirectoryItem, - FileHTTPHeaders, + Error, FileItem, FileProperty, FileRange, FilesAndDirectoriesListSegment, HandleItem, KeyInfo, - LeaseAccessConditions, ListFilesAndDirectoriesSegmentResponse, ListHandlesResponse, ListSharesResponse, @@ -44,22 +41,21 @@ ShareSmbSettingsEncryptionInTransit, ShareStats, SignedIdentifier, + SignedIdentifiers, SmbMultichannel, - SourceLeaseAccessConditions, - SourceModifiedAccessConditions, - StorageError, StorageServiceProperties, StringEncoded, UserDelegationKey, ) -from ._azure_file_storage_enums import ( # type: ignore +from ._enums import ( # type: ignore AccessRight, - CopyStatusType, + CopyStatus, DeleteSnapshotsOptionType, FileLastWrittenMode, FilePermissionFormat, FilePropertySemantics, + FileRangeWriteFromUrlType, FileRangeWriteType, LeaseDurationType, LeaseStateType, @@ -82,18 +78,15 @@ __all__ = [ "AccessPolicy", "ClearRange", - "CopyFileSmbInfo", "CorsRule", - "DestinationLeaseAccessConditions", "DirectoryItem", - "FileHTTPHeaders", + "Error", "FileItem", "FileProperty", "FileRange", "FilesAndDirectoriesListSegment", "HandleItem", "KeyInfo", - "LeaseAccessConditions", "ListFilesAndDirectoriesSegmentResponse", "ListHandlesResponse", "ListSharesResponse", @@ -110,19 +103,18 @@ "ShareSmbSettingsEncryptionInTransit", "ShareStats", "SignedIdentifier", + "SignedIdentifiers", "SmbMultichannel", - "SourceLeaseAccessConditions", - "SourceModifiedAccessConditions", - "StorageError", "StorageServiceProperties", "StringEncoded", "UserDelegationKey", "AccessRight", - "CopyStatusType", + "CopyStatus", "DeleteSnapshotsOptionType", "FileLastWrittenMode", "FilePermissionFormat", "FilePropertySemantics", + "FileRangeWriteFromUrlType", "FileRangeWriteType", "LeaseDurationType", "LeaseStateType", diff --git a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/models/_azure_file_storage_enums.py b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/models/_enums.py similarity index 60% rename from sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/models/_azure_file_storage_enums.py rename to sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/models/_enums.py index 34c21387336a..a2732c2608da 100644 --- a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/models/_azure_file_storage_enums.py +++ b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/models/_enums.py @@ -2,7 +2,7 @@ # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. +# Code generated by Microsoft (R) Python Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- @@ -14,224 +14,363 @@ class AccessRight(str, Enum, metaclass=CaseInsensitiveEnumMeta): """Access rights of the access policy.""" READ = "Read" + """Read.""" WRITE = "Write" + """Write.""" DELETE = "Delete" + """Delete.""" -class CopyStatusType(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """CopyStatusType.""" +class CopyStatus(str, Enum, metaclass=CaseInsensitiveEnumMeta): + """The copy status.""" PENDING = "pending" + """The copy operation is pending.""" SUCCESS = "success" + """The copy operation succeeded.""" ABORTED = "aborted" + """The copy operation was aborted.""" FAILED = "failed" + """The copy operation failed.""" class DeleteSnapshotsOptionType(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """DeleteSnapshotsOptionType.""" + """The delete snapshots option type.""" INCLUDE = "include" + """include.""" INCLUDE_LEASED = "include-leased" + """include-leased.""" class FileLastWrittenMode(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """FileLastWrittenMode.""" + """The file last written mode.""" NOW = "Now" + """Now.""" PRESERVE = "Preserve" + """Preserve.""" class FilePermissionFormat(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """FilePermissionFormat.""" + """The file permission format.""" SDDL = "Sddl" + """Sddl.""" BINARY = "Binary" + """Binary.""" class FilePropertySemantics(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """FilePropertySemantics.""" + """The file property semantics.""" NEW = "New" + """New.""" RESTORE = "Restore" + """Restore.""" + + +class FileRangeWriteFromUrlType(str, Enum, metaclass=CaseInsensitiveEnumMeta): + """Only update is supported: - Update: Writes the bytes downloaded from the source url into the + specified range. + """ + + UPDATE = "update" + """Writes the bytes specified by the source URL into the specified range.""" class FileRangeWriteType(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """FileRangeWriteType.""" + """Specify one of the following options: - Update: Writes the bytes specified by the request body + into the specified range. - Clear: Clears the specified range and releases the space used in + storage for that range. + """ UPDATE = "update" + """Writes the bytes specified by the request body into the specified range.""" CLEAR = "clear" + """Clears the specified range and releases the space used in storage for that range.""" class LeaseDurationType(str, Enum, metaclass=CaseInsensitiveEnumMeta): """When a share is leased, specifies whether the lease is of infinite or fixed duration.""" INFINITE = "infinite" + """infinite.""" FIXED = "fixed" + """fixed.""" class LeaseStateType(str, Enum, metaclass=CaseInsensitiveEnumMeta): """Lease state of the share.""" AVAILABLE = "available" + """available.""" LEASED = "leased" + """leased.""" EXPIRED = "expired" + """expired.""" BREAKING = "breaking" + """breaking.""" BROKEN = "broken" + """broken.""" class LeaseStatusType(str, Enum, metaclass=CaseInsensitiveEnumMeta): """The current lease status of the share.""" LOCKED = "locked" + """locked.""" UNLOCKED = "unlocked" + """unlocked.""" class ListFilesIncludeType(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """ListFilesIncludeType.""" + """The type of file information to include in the listing.""" TIMESTAMPS = "Timestamps" + """Timestamps.""" ETAG = "Etag" + """Etag.""" ATTRIBUTES = "Attributes" + """Attributes.""" PERMISSION_KEY = "PermissionKey" + """PermissionKey.""" class ListSharesIncludeType(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """ListSharesIncludeType.""" + """The type of share information to include in the listing.""" SNAPSHOTS = "snapshots" + """snapshots.""" METADATA = "metadata" + """metadata.""" DELETED = "deleted" + """deleted.""" class ModeCopyMode(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """ModeCopyMode.""" + """The mode copy mode.""" SOURCE = "source" + """source.""" OVERRIDE = "override" + """override.""" class NfsFileType(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """NfsFileType.""" + """The NFS file type.""" REGULAR = "Regular" + """Regular.""" DIRECTORY = "Directory" + """Directory.""" SYM_LINK = "SymLink" + """SymLink.""" class OwnerCopyMode(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """OwnerCopyMode.""" + """The owner copy mode.""" SOURCE = "source" + """source.""" OVERRIDE = "override" + """override.""" class PermissionCopyModeType(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """PermissionCopyModeType.""" + """The permission copy mode type.""" SOURCE = "source" + """source.""" OVERRIDE = "override" + """override.""" class ShareAccessTier(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """ShareAccessTier.""" + """The access tier of the share.""" TRANSACTION_OPTIMIZED = "TransactionOptimized" + """TransactionOptimized.""" HOT = "Hot" + """Hot.""" COOL = "Cool" + """Cool.""" PREMIUM = "Premium" + """Premium.""" class ShareRootSquash(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """ShareRootSquash.""" + """The root squash setting for the share.""" NO_ROOT_SQUASH = "NoRootSquash" + """NoRootSquash.""" ROOT_SQUASH = "RootSquash" + """RootSquash.""" ALL_SQUASH = "AllSquash" + """AllSquash.""" class ShareTokenIntent(str, Enum, metaclass=CaseInsensitiveEnumMeta): - """ShareTokenIntent.""" + """The share token intent.""" BACKUP = "backup" + """backup.""" class StorageErrorCode(str, Enum, metaclass=CaseInsensitiveEnumMeta): """Error codes returned by the service.""" ACCOUNT_ALREADY_EXISTS = "AccountAlreadyExists" + """AccountAlreadyExists.""" ACCOUNT_BEING_CREATED = "AccountBeingCreated" + """AccountBeingCreated.""" ACCOUNT_IS_DISABLED = "AccountIsDisabled" + """AccountIsDisabled.""" AUTHENTICATION_FAILED = "AuthenticationFailed" + """AuthenticationFailed.""" AUTHORIZATION_FAILURE = "AuthorizationFailure" + """AuthorizationFailure.""" CONDITION_HEADERS_NOT_SUPPORTED = "ConditionHeadersNotSupported" + """ConditionHeadersNotSupported.""" CONDITION_NOT_MET = "ConditionNotMet" + """ConditionNotMet.""" EMPTY_METADATA_KEY = "EmptyMetadataKey" + """EmptyMetadataKey.""" FILE_SHARE_PROVISIONED_BANDWIDTH_DOWNGRADE_NOT_ALLOWED = "FileShareProvisionedBandwidthDowngradeNotAllowed" + """FileShareProvisionedBandwidthDowngradeNotAllowed.""" FILE_SHARE_PROVISIONED_IOPS_DOWNGRADE_NOT_ALLOWED = "FileShareProvisionedIopsDowngradeNotAllowed" + """FileShareProvisionedIopsDowngradeNotAllowed.""" INSUFFICIENT_ACCOUNT_PERMISSIONS = "InsufficientAccountPermissions" + """InsufficientAccountPermissions.""" INTERNAL_ERROR = "InternalError" + """InternalError.""" INVALID_AUTHENTICATION_INFO = "InvalidAuthenticationInfo" + """InvalidAuthenticationInfo.""" INVALID_HEADER_VALUE = "InvalidHeaderValue" + """InvalidHeaderValue.""" INVALID_HTTP_VERB = "InvalidHttpVerb" + """InvalidHttpVerb.""" INVALID_INPUT = "InvalidInput" + """InvalidInput.""" INVALID_MD5 = "InvalidMd5" + """InvalidMd5.""" INVALID_METADATA = "InvalidMetadata" + """InvalidMetadata.""" INVALID_QUERY_PARAMETER_VALUE = "InvalidQueryParameterValue" + """InvalidQueryParameterValue.""" INVALID_RANGE = "InvalidRange" + """InvalidRange.""" INVALID_RESOURCE_NAME = "InvalidResourceName" + """InvalidResourceName.""" INVALID_URI = "InvalidUri" + """InvalidUri.""" INVALID_XML_DOCUMENT = "InvalidXmlDocument" + """InvalidXmlDocument.""" INVALID_XML_NODE_VALUE = "InvalidXmlNodeValue" + """InvalidXmlNodeValue.""" MD5_MISMATCH = "Md5Mismatch" + """Md5Mismatch.""" METADATA_TOO_LARGE = "MetadataTooLarge" + """MetadataTooLarge.""" MISSING_CONTENT_LENGTH_HEADER = "MissingContentLengthHeader" + """MissingContentLengthHeader.""" MISSING_REQUIRED_QUERY_PARAMETER = "MissingRequiredQueryParameter" + """MissingRequiredQueryParameter.""" MISSING_REQUIRED_HEADER = "MissingRequiredHeader" + """MissingRequiredHeader.""" MISSING_REQUIRED_XML_NODE = "MissingRequiredXmlNode" + """MissingRequiredXmlNode.""" MULTIPLE_CONDITION_HEADERS_NOT_SUPPORTED = "MultipleConditionHeadersNotSupported" + """MultipleConditionHeadersNotSupported.""" OPERATION_TIMED_OUT = "OperationTimedOut" + """OperationTimedOut.""" OUT_OF_RANGE_INPUT = "OutOfRangeInput" + """OutOfRangeInput.""" OUT_OF_RANGE_QUERY_PARAMETER_VALUE = "OutOfRangeQueryParameterValue" + """OutOfRangeQueryParameterValue.""" REQUEST_BODY_TOO_LARGE = "RequestBodyTooLarge" + """RequestBodyTooLarge.""" RESOURCE_TYPE_MISMATCH = "ResourceTypeMismatch" + """ResourceTypeMismatch.""" REQUEST_URL_FAILED_TO_PARSE = "RequestUrlFailedToParse" + """RequestUrlFailedToParse.""" RESOURCE_ALREADY_EXISTS = "ResourceAlreadyExists" + """ResourceAlreadyExists.""" RESOURCE_NOT_FOUND = "ResourceNotFound" + """ResourceNotFound.""" SERVER_BUSY = "ServerBusy" + """ServerBusy.""" UNSUPPORTED_HEADER = "UnsupportedHeader" + """UnsupportedHeader.""" UNSUPPORTED_XML_NODE = "UnsupportedXmlNode" + """UnsupportedXmlNode.""" UNSUPPORTED_QUERY_PARAMETER = "UnsupportedQueryParameter" + """UnsupportedQueryParameter.""" UNSUPPORTED_HTTP_VERB = "UnsupportedHttpVerb" + """UnsupportedHttpVerb.""" CANNOT_DELETE_FILE_OR_DIRECTORY = "CannotDeleteFileOrDirectory" + """CannotDeleteFileOrDirectory.""" CLIENT_CACHE_FLUSH_DELAY = "ClientCacheFlushDelay" + """ClientCacheFlushDelay.""" DELETE_PENDING = "DeletePending" + """DeletePending.""" DIRECTORY_NOT_EMPTY = "DirectoryNotEmpty" + """DirectoryNotEmpty.""" FILE_LOCK_CONFLICT = "FileLockConflict" + """FileLockConflict.""" INVALID_FILE_OR_DIRECTORY_PATH_NAME = "InvalidFileOrDirectoryPathName" + """InvalidFileOrDirectoryPathName.""" PARENT_NOT_FOUND = "ParentNotFound" + """ParentNotFound.""" READ_ONLY_ATTRIBUTE = "ReadOnlyAttribute" + """ReadOnlyAttribute.""" SHARE_ALREADY_EXISTS = "ShareAlreadyExists" + """ShareAlreadyExists.""" SHARE_BEING_DELETED = "ShareBeingDeleted" + """ShareBeingDeleted.""" SHARE_DISABLED = "ShareDisabled" + """ShareDisabled.""" SHARE_NOT_FOUND = "ShareNotFound" + """ShareNotFound.""" SHARING_VIOLATION = "SharingViolation" + """SharingViolation.""" SHARE_SNAPSHOT_IN_PROGRESS = "ShareSnapshotInProgress" + """ShareSnapshotInProgress.""" SHARE_SNAPSHOT_COUNT_EXCEEDED = "ShareSnapshotCountExceeded" + """ShareSnapshotCountExceeded.""" SHARE_SNAPSHOT_OPERATION_NOT_SUPPORTED = "ShareSnapshotOperationNotSupported" + """ShareSnapshotOperationNotSupported.""" SHARE_HAS_SNAPSHOTS = "ShareHasSnapshots" + """ShareHasSnapshots.""" PREVIOUS_SNAPSHOT_NOT_FOUND = "PreviousSnapshotNotFound" + """PreviousSnapshotNotFound.""" CONTAINER_QUOTA_DOWNGRADE_NOT_ALLOWED = "ContainerQuotaDowngradeNotAllowed" + """ContainerQuotaDowngradeNotAllowed.""" AUTHORIZATION_SOURCE_IP_MISMATCH = "AuthorizationSourceIPMismatch" + """AuthorizationSourceIPMismatch.""" AUTHORIZATION_PROTOCOL_MISMATCH = "AuthorizationProtocolMismatch" + """AuthorizationProtocolMismatch.""" AUTHORIZATION_PERMISSION_MISMATCH = "AuthorizationPermissionMismatch" + """AuthorizationPermissionMismatch.""" AUTHORIZATION_SERVICE_MISMATCH = "AuthorizationServiceMismatch" + """AuthorizationServiceMismatch.""" AUTHORIZATION_RESOURCE_TYPE_MISMATCH = "AuthorizationResourceTypeMismatch" + """AuthorizationResourceTypeMismatch.""" FEATURE_VERSION_MISMATCH = "FeatureVersionMismatch" + """FeatureVersionMismatch.""" SHARE_SNAPSHOT_NOT_FOUND = "ShareSnapshotNotFound" + """ShareSnapshotNotFound.""" FILE_SHARE_PROVISIONED_IOPS_INVALID = "FileShareProvisionedIopsInvalid" + """FileShareProvisionedIopsInvalid.""" FILE_SHARE_PROVISIONED_BANDWIDTH_INVALID = "FileShareProvisionedBandwidthInvalid" + """FileShareProvisionedBandwidthInvalid.""" FILE_SHARE_PROVISIONED_STORAGE_INVALID = "FileShareProvisionedStorageInvalid" + """FileShareProvisionedStorageInvalid.""" TOTAL_SHARES_PROVISIONED_CAPACITY_EXCEEDS_ACCOUNT_LIMIT = "TotalSharesProvisionedCapacityExceedsAccountLimit" + """TotalSharesProvisionedCapacityExceedsAccountLimit.""" TOTAL_SHARES_PROVISIONED_IOPS_EXCEEDS_ACCOUNT_LIMIT = "TotalSharesProvisionedIopsExceedsAccountLimit" + """TotalSharesProvisionedIopsExceedsAccountLimit.""" TOTAL_SHARES_PROVISIONED_BANDWIDTH_EXCEEDS_ACCOUNT_LIMIT = "TotalSharesProvisionedBandwidthExceedsAccountLimit" + """TotalSharesProvisionedBandwidthExceedsAccountLimit.""" TOTAL_SHARES_COUNT_EXCEEDS_ACCOUNT_LIMIT = "TotalSharesCountExceedsAccountLimit" + """TotalSharesCountExceedsAccountLimit.""" diff --git a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/models/_models.py b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/models/_models.py new file mode 100644 index 000000000000..190731d9d6d3 --- /dev/null +++ b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/models/_models.py @@ -0,0 +1,2242 @@ +# pylint: disable=too-many-lines +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) Python Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- +# pylint: disable=useless-super-delegation + +import datetime +import functools +from typing import Any, Mapping, Optional, TYPE_CHECKING, Union, overload + +from .._utils.model_base import ( + Model as _Model, + _xml_deser_bool, + _xml_deser_datetime_rfc7231, + _xml_deser_enum_or_str, + _xml_deser_int, + _xml_deser_str, + rest_field, +) +from ._enums import LeaseDurationType, LeaseStateType, LeaseStatusType, ShareRootSquash, StorageErrorCode + +if TYPE_CHECKING: + from .. import models as _models + + +class AccessPolicy(_Model): + """An Access policy. + + :ivar start: The date-time the policy is active. + :vartype start: str + :ivar expiry: The date-time the policy expires. + :vartype expiry: str + :ivar permission: The permissions for the ACL policy. + :vartype permission: str + """ + + start: Optional[str] = rest_field( + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "Start", "text": False, "unwrapped": False}, + deserializer=_xml_deser_str, + ) + """The date-time the policy is active.""" + expiry: Optional[str] = rest_field( + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "Expiry", "text": False, "unwrapped": False}, + deserializer=_xml_deser_str, + ) + """The date-time the policy expires.""" + permission: Optional[str] = rest_field( + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "Permission", "text": False, "unwrapped": False}, + deserializer=_xml_deser_str, + ) + """The permissions for the ACL policy.""" + + _xml = {"attribute": False, "name": "AccessPolicy", "text": False, "unwrapped": False} + + @overload + def __init__( + self, + *, + start: Optional[str] = None, + expiry: Optional[str] = None, + permission: Optional[str] = None, + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: + """ + :param mapping: raw JSON to initialize the model. + :type mapping: Mapping[str, Any] + """ + + def __init__(self, *args: Any, **kwargs: Any) -> None: + super().__init__(*args, **kwargs) + + +class ClearRange(_Model): + """A clear range. + + :ivar start: Start of the range. Required. + :vartype start: int + :ivar end: End of the range. Required. + :vartype end: int + """ + + start: int = rest_field( + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "Start", "text": False, "unwrapped": False}, + deserializer=_xml_deser_int, + ) + """Start of the range. Required.""" + end: int = rest_field( + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "End", "text": False, "unwrapped": False}, + deserializer=_xml_deser_int, + ) + """End of the range. Required.""" + + _xml = {"attribute": False, "name": "ClearRange", "text": False, "unwrapped": False} + + @overload + def __init__( + self, + *, + start: int, + end: int, + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: + """ + :param mapping: raw JSON to initialize the model. + :type mapping: Mapping[str, Any] + """ + + def __init__(self, *args: Any, **kwargs: Any) -> None: + super().__init__(*args, **kwargs) + + +class CorsRule(_Model): + """CORS is an HTTP feature that enables a web application running under one domain to access + resources in another domain. Web browsers implement a security restriction known as same-origin + policy that prevents a web page from calling APIs in a different domain; CORS provides a secure + way to allow one domain (the origin domain) to call APIs in another domain. + + :ivar allowed_origins: The origin domains that are permitted to make a request against the + storage service via CORS. The origin domain is the domain from which the request originates. + Note that the origin must be an exact case-sensitive match with the origin that the user age + sends to the service. You can also use the wildcard character '*' to allow all origin domains + to make requests via CORS. Required. + :vartype allowed_origins: str + :ivar allowed_methods: The methods (HTTP request verbs) that the origin domain may use for a + CORS request. (comma separated). Required. + :vartype allowed_methods: str + :ivar allowed_headers: The request headers that the origin domain may specify on the CORS + request. Required. + :vartype allowed_headers: str + :ivar exposed_headers: The response headers that may be sent in the response to the CORS + request and exposed by the browser to the request issuer. Required. + :vartype exposed_headers: str + :ivar max_age_in_seconds: The maximum amount time that a browser should cache the preflight + OPTIONS request. Required. + :vartype max_age_in_seconds: int + """ + + allowed_origins: str = rest_field( + name="allowedOrigins", + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "AllowedOrigins", "text": False, "unwrapped": False}, + deserializer=_xml_deser_str, + ) + """The origin domains that are permitted to make a request against the storage service via CORS. + The origin domain is the domain from which the request originates. Note that the origin must be + an exact case-sensitive match with the origin that the user age sends to the service. You can + also use the wildcard character '*' to allow all origin domains to make requests via CORS. + Required.""" + allowed_methods: str = rest_field( + name="allowedMethods", + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "AllowedMethods", "text": False, "unwrapped": False}, + deserializer=_xml_deser_str, + ) + """The methods (HTTP request verbs) that the origin domain may use for a CORS request. (comma + separated). Required.""" + allowed_headers: str = rest_field( + name="allowedHeaders", + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "AllowedHeaders", "text": False, "unwrapped": False}, + deserializer=_xml_deser_str, + ) + """The request headers that the origin domain may specify on the CORS request. Required.""" + exposed_headers: str = rest_field( + name="exposedHeaders", + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "ExposedHeaders", "text": False, "unwrapped": False}, + deserializer=_xml_deser_str, + ) + """The response headers that may be sent in the response to the CORS request and exposed by the + browser to the request issuer. Required.""" + max_age_in_seconds: int = rest_field( + name="maxAgeInSeconds", + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "MaxAgeInSeconds", "text": False, "unwrapped": False}, + deserializer=_xml_deser_int, + ) + """The maximum amount time that a browser should cache the preflight OPTIONS request. Required.""" + + _xml = {"attribute": False, "name": "CorsRule", "text": False, "unwrapped": False} + + @overload + def __init__( + self, + *, + allowed_origins: str, + allowed_methods: str, + allowed_headers: str, + exposed_headers: str, + max_age_in_seconds: int, + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: + """ + :param mapping: raw JSON to initialize the model. + :type mapping: Mapping[str, Any] + """ + + def __init__(self, *args: Any, **kwargs: Any) -> None: + super().__init__(*args, **kwargs) + + +class DirectoryItem(_Model): + """A listed directory item. + + :ivar name: The directory name. Required. + :vartype name: ~azure.storage.fileshare._generated.models.StringEncoded + :ivar file_id: The file ID. + :vartype file_id: str + :ivar properties: File properties. + :vartype properties: ~azure.storage.fileshare._generated.models.FileProperty + :ivar attributes: The file attributes. + :vartype attributes: str + :ivar permission_key: The permission key. + :vartype permission_key: str + """ + + name: "_models.StringEncoded" = rest_field( + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "Name", "text": False, "unwrapped": False}, + ) + """The directory name. Required.""" + file_id: Optional[str] = rest_field( + name="fileId", + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "FileId", "text": False, "unwrapped": False}, + deserializer=_xml_deser_str, + ) + """The file ID.""" + properties: Optional["_models.FileProperty"] = rest_field( + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "Properties", "text": False, "unwrapped": False}, + ) + """File properties.""" + attributes: Optional[str] = rest_field( + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "Attributes", "text": False, "unwrapped": False}, + deserializer=_xml_deser_str, + ) + """The file attributes.""" + permission_key: Optional[str] = rest_field( + name="permissionKey", + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "PermissionKey", "text": False, "unwrapped": False}, + deserializer=_xml_deser_str, + ) + """The permission key.""" + + _xml = {"attribute": False, "name": "Directory", "text": False, "unwrapped": False} + + @overload + def __init__( + self, + *, + name: "_models.StringEncoded", + file_id: Optional[str] = None, + properties: Optional["_models.FileProperty"] = None, + attributes: Optional[str] = None, + permission_key: Optional[str] = None, + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: + """ + :param mapping: raw JSON to initialize the model. + :type mapping: Mapping[str, Any] + """ + + def __init__(self, *args: Any, **kwargs: Any) -> None: + super().__init__(*args, **kwargs) + + +class Error(_Model): + """The error response. + + This defines the wire format only. Language SDKs wrap this in idiomatic error types. + + :ivar code: The error code. Known values are: "AccountAlreadyExists", "AccountBeingCreated", + "AccountIsDisabled", "AuthenticationFailed", "AuthorizationFailure", + "ConditionHeadersNotSupported", "ConditionNotMet", "EmptyMetadataKey", + "FileShareProvisionedBandwidthDowngradeNotAllowed", + "FileShareProvisionedIopsDowngradeNotAllowed", "InsufficientAccountPermissions", + "InternalError", "InvalidAuthenticationInfo", "InvalidHeaderValue", "InvalidHttpVerb", + "InvalidInput", "InvalidMd5", "InvalidMetadata", "InvalidQueryParameterValue", "InvalidRange", + "InvalidResourceName", "InvalidUri", "InvalidXmlDocument", "InvalidXmlNodeValue", + "Md5Mismatch", "MetadataTooLarge", "MissingContentLengthHeader", + "MissingRequiredQueryParameter", "MissingRequiredHeader", "MissingRequiredXmlNode", + "MultipleConditionHeadersNotSupported", "OperationTimedOut", "OutOfRangeInput", + "OutOfRangeQueryParameterValue", "RequestBodyTooLarge", "ResourceTypeMismatch", + "RequestUrlFailedToParse", "ResourceAlreadyExists", "ResourceNotFound", "ServerBusy", + "UnsupportedHeader", "UnsupportedXmlNode", "UnsupportedQueryParameter", "UnsupportedHttpVerb", + "CannotDeleteFileOrDirectory", "ClientCacheFlushDelay", "DeletePending", "DirectoryNotEmpty", + "FileLockConflict", "InvalidFileOrDirectoryPathName", "ParentNotFound", "ReadOnlyAttribute", + "ShareAlreadyExists", "ShareBeingDeleted", "ShareDisabled", "ShareNotFound", + "SharingViolation", "ShareSnapshotInProgress", "ShareSnapshotCountExceeded", + "ShareSnapshotOperationNotSupported", "ShareHasSnapshots", "PreviousSnapshotNotFound", + "ContainerQuotaDowngradeNotAllowed", "AuthorizationSourceIPMismatch", + "AuthorizationProtocolMismatch", "AuthorizationPermissionMismatch", + "AuthorizationServiceMismatch", "AuthorizationResourceTypeMismatch", "FeatureVersionMismatch", + "ShareSnapshotNotFound", "FileShareProvisionedIopsInvalid", + "FileShareProvisionedBandwidthInvalid", "FileShareProvisionedStorageInvalid", + "TotalSharesProvisionedCapacityExceedsAccountLimit", + "TotalSharesProvisionedIopsExceedsAccountLimit", + "TotalSharesProvisionedBandwidthExceedsAccountLimit", and + "TotalSharesCountExceedsAccountLimit". + :vartype code: str or ~azure.storage.fileshare.models.StorageErrorCode + :ivar message: The error message. + :vartype message: str + :ivar copy_source_status_code: Copy source status code. + :vartype copy_source_status_code: int + :ivar copy_source_error_code: Copy source error code. + :vartype copy_source_error_code: str + :ivar copy_source_error_message: Copy source error message. + :vartype copy_source_error_message: str + """ + + code: Optional[Union[str, "_models.StorageErrorCode"]] = rest_field( + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "Code", "text": False, "unwrapped": False}, + deserializer=functools.partial(_xml_deser_enum_or_str, StorageErrorCode), + ) + """The error code. Known values are: \"AccountAlreadyExists\", \"AccountBeingCreated\", + \"AccountIsDisabled\", \"AuthenticationFailed\", \"AuthorizationFailure\", + \"ConditionHeadersNotSupported\", \"ConditionNotMet\", \"EmptyMetadataKey\", + \"FileShareProvisionedBandwidthDowngradeNotAllowed\", + \"FileShareProvisionedIopsDowngradeNotAllowed\", \"InsufficientAccountPermissions\", + \"InternalError\", \"InvalidAuthenticationInfo\", \"InvalidHeaderValue\", \"InvalidHttpVerb\", + \"InvalidInput\", \"InvalidMd5\", \"InvalidMetadata\", \"InvalidQueryParameterValue\", + \"InvalidRange\", \"InvalidResourceName\", \"InvalidUri\", \"InvalidXmlDocument\", + \"InvalidXmlNodeValue\", \"Md5Mismatch\", \"MetadataTooLarge\", \"MissingContentLengthHeader\", + \"MissingRequiredQueryParameter\", \"MissingRequiredHeader\", \"MissingRequiredXmlNode\", + \"MultipleConditionHeadersNotSupported\", \"OperationTimedOut\", \"OutOfRangeInput\", + \"OutOfRangeQueryParameterValue\", \"RequestBodyTooLarge\", \"ResourceTypeMismatch\", + \"RequestUrlFailedToParse\", \"ResourceAlreadyExists\", \"ResourceNotFound\", \"ServerBusy\", + \"UnsupportedHeader\", \"UnsupportedXmlNode\", \"UnsupportedQueryParameter\", + \"UnsupportedHttpVerb\", \"CannotDeleteFileOrDirectory\", \"ClientCacheFlushDelay\", + \"DeletePending\", \"DirectoryNotEmpty\", \"FileLockConflict\", + \"InvalidFileOrDirectoryPathName\", \"ParentNotFound\", \"ReadOnlyAttribute\", + \"ShareAlreadyExists\", \"ShareBeingDeleted\", \"ShareDisabled\", \"ShareNotFound\", + \"SharingViolation\", \"ShareSnapshotInProgress\", \"ShareSnapshotCountExceeded\", + \"ShareSnapshotOperationNotSupported\", \"ShareHasSnapshots\", \"PreviousSnapshotNotFound\", + \"ContainerQuotaDowngradeNotAllowed\", \"AuthorizationSourceIPMismatch\", + \"AuthorizationProtocolMismatch\", \"AuthorizationPermissionMismatch\", + \"AuthorizationServiceMismatch\", \"AuthorizationResourceTypeMismatch\", + \"FeatureVersionMismatch\", \"ShareSnapshotNotFound\", \"FileShareProvisionedIopsInvalid\", + \"FileShareProvisionedBandwidthInvalid\", \"FileShareProvisionedStorageInvalid\", + \"TotalSharesProvisionedCapacityExceedsAccountLimit\", + \"TotalSharesProvisionedIopsExceedsAccountLimit\", + \"TotalSharesProvisionedBandwidthExceedsAccountLimit\", and + \"TotalSharesCountExceedsAccountLimit\".""" + message: Optional[str] = rest_field( + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "Message", "text": False, "unwrapped": False}, + deserializer=_xml_deser_str, + ) + """The error message.""" + copy_source_status_code: Optional[int] = rest_field( + name="copySourceStatusCode", + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "CopySourceStatusCode", "text": False, "unwrapped": False}, + deserializer=_xml_deser_int, + ) + """Copy source status code.""" + copy_source_error_code: Optional[str] = rest_field( + name="copySourceErrorCode", + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "CopySourceErrorCode", "text": False, "unwrapped": False}, + deserializer=_xml_deser_str, + ) + """Copy source error code.""" + copy_source_error_message: Optional[str] = rest_field( + name="copySourceErrorMessage", + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "CopySourceErrorMessage", "text": False, "unwrapped": False}, + deserializer=_xml_deser_str, + ) + """Copy source error message.""" + + _xml = {"attribute": False, "name": "Error", "text": False, "unwrapped": False} + + @overload + def __init__( + self, + *, + code: Optional[Union[str, "_models.StorageErrorCode"]] = None, + message: Optional[str] = None, + copy_source_status_code: Optional[int] = None, + copy_source_error_code: Optional[str] = None, + copy_source_error_message: Optional[str] = None, + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: + """ + :param mapping: raw JSON to initialize the model. + :type mapping: Mapping[str, Any] + """ + + def __init__(self, *args: Any, **kwargs: Any) -> None: + super().__init__(*args, **kwargs) + + +class FileItem(_Model): + """A listed file item. + + :ivar name: The file name. Required. + :vartype name: ~azure.storage.fileshare._generated.models.StringEncoded + :ivar file_id: The file ID. + :vartype file_id: str + :ivar properties: File properties. Required. + :vartype properties: ~azure.storage.fileshare._generated.models.FileProperty + :ivar attributes: The file attributes. + :vartype attributes: str + :ivar permission_key: The permission key. + :vartype permission_key: str + """ + + name: "_models.StringEncoded" = rest_field( + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "Name", "text": False, "unwrapped": False}, + ) + """The file name. Required.""" + file_id: Optional[str] = rest_field( + name="fileId", + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "FileId", "text": False, "unwrapped": False}, + deserializer=_xml_deser_str, + ) + """The file ID.""" + properties: "_models.FileProperty" = rest_field( + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "Properties", "text": False, "unwrapped": False}, + ) + """File properties. Required.""" + attributes: Optional[str] = rest_field( + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "Attributes", "text": False, "unwrapped": False}, + deserializer=_xml_deser_str, + ) + """The file attributes.""" + permission_key: Optional[str] = rest_field( + name="permissionKey", + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "PermissionKey", "text": False, "unwrapped": False}, + deserializer=_xml_deser_str, + ) + """The permission key.""" + + _xml = {"attribute": False, "name": "File", "text": False, "unwrapped": False} + + @overload + def __init__( + self, + *, + name: "_models.StringEncoded", + properties: "_models.FileProperty", + file_id: Optional[str] = None, + attributes: Optional[str] = None, + permission_key: Optional[str] = None, + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: + """ + :param mapping: raw JSON to initialize the model. + :type mapping: Mapping[str, Any] + """ + + def __init__(self, *args: Any, **kwargs: Any) -> None: + super().__init__(*args, **kwargs) + + +class FileProperty(_Model): + """File properties. + + :ivar content_length: Content length of the file. This value may not be up-to-date since an SMB + client may have modified the file locally. The value of Content-Length may not reflect that + fact until the handle is closed or the op-lock is broken. To retrieve current property values, + call Get File Properties. Required. + :vartype content_length: int + :ivar creation_time: The creation time. + :vartype creation_time: str + :ivar last_access_time: The last access time. + :vartype last_access_time: str + :ivar last_write_time: The last write time. + :vartype last_write_time: str + :ivar change_time: The change time. + :vartype change_time: str + :ivar last_modified: The last modified time. + :vartype last_modified: ~datetime.datetime + :ivar etag: The ETag of the file. + :vartype etag: str + """ + + content_length: int = rest_field( + name="contentLength", + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "Content-Length", "text": False, "unwrapped": False}, + deserializer=_xml_deser_int, + ) + """Content length of the file. This value may not be up-to-date since an SMB client may have + modified the file locally. The value of Content-Length may not reflect that fact until the + handle is closed or the op-lock is broken. To retrieve current property values, call Get File + Properties. Required.""" + creation_time: Optional[str] = rest_field( + name="creationTime", + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "CreationTime", "text": False, "unwrapped": False}, + deserializer=_xml_deser_str, + ) + """The creation time.""" + last_access_time: Optional[str] = rest_field( + name="lastAccessTime", + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "LastAccessTime", "text": False, "unwrapped": False}, + deserializer=_xml_deser_str, + ) + """The last access time.""" + last_write_time: Optional[str] = rest_field( + name="lastWriteTime", + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "LastWriteTime", "text": False, "unwrapped": False}, + deserializer=_xml_deser_str, + ) + """The last write time.""" + change_time: Optional[str] = rest_field( + name="changeTime", + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "ChangeTime", "text": False, "unwrapped": False}, + deserializer=_xml_deser_str, + ) + """The change time.""" + last_modified: Optional[datetime.datetime] = rest_field( + name="lastModified", + visibility=["read", "create", "update", "delete", "query"], + format="rfc7231", + xml={"attribute": False, "name": "Last-Modified", "text": False, "unwrapped": False}, + deserializer=_xml_deser_datetime_rfc7231, + ) + """The last modified time.""" + etag: Optional[str] = rest_field( + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "Etag", "text": False, "unwrapped": False}, + deserializer=_xml_deser_str, + ) + """The ETag of the file.""" + + _xml = {"attribute": False, "name": "FileProperty", "text": False, "unwrapped": False} + + @overload + def __init__( + self, + *, + content_length: int, + creation_time: Optional[str] = None, + last_access_time: Optional[str] = None, + last_write_time: Optional[str] = None, + change_time: Optional[str] = None, + last_modified: Optional[datetime.datetime] = None, + etag: Optional[str] = None, + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: + """ + :param mapping: raw JSON to initialize the model. + :type mapping: Mapping[str, Any] + """ + + def __init__(self, *args: Any, **kwargs: Any) -> None: + super().__init__(*args, **kwargs) + + +class FileRange(_Model): + """An Azure Storage file range. + + :ivar start: Start of the range. Required. + :vartype start: int + :ivar end: End of the range. Required. + :vartype end: int + """ + + start: int = rest_field( + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "Start", "text": False, "unwrapped": False}, + deserializer=_xml_deser_int, + ) + """Start of the range. Required.""" + end: int = rest_field( + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "End", "text": False, "unwrapped": False}, + deserializer=_xml_deser_int, + ) + """End of the range. Required.""" + + _xml = {"attribute": False, "name": "Range", "text": False, "unwrapped": False} + + @overload + def __init__( + self, + *, + start: int, + end: int, + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: + """ + :param mapping: raw JSON to initialize the model. + :type mapping: Mapping[str, Any] + """ + + def __init__(self, *args: Any, **kwargs: Any) -> None: + super().__init__(*args, **kwargs) + + +class FilesAndDirectoriesListSegment(_Model): + """Abstract for entries that can be listed from Directory. + + :ivar directory_items: The directory items. Required. + :vartype directory_items: ~azure.storage.fileshare._generated.models.DirectoryItem + :ivar file_items: The file items. Required. + :vartype file_items: ~azure.storage.fileshare._generated.models.FileItem + """ + + directory_items: list["_models.DirectoryItem"] = rest_field( + name="directoryItems", + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "itemsName": "Directory", "name": "Directory", "text": False, "unwrapped": True}, + ) + """The directory items. Required.""" + file_items: list["_models.FileItem"] = rest_field( + name="fileItems", + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "itemsName": "File", "name": "File", "text": False, "unwrapped": True}, + ) + """The file items. Required.""" + + _xml = {"attribute": False, "name": "FilesAndDirectoriesListSegment", "text": False, "unwrapped": False} + + @overload + def __init__( + self, + *, + directory_items: list["_models.DirectoryItem"], + file_items: list["_models.FileItem"], + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: + """ + :param mapping: raw JSON to initialize the model. + :type mapping: Mapping[str, Any] + """ + + def __init__(self, *args: Any, **kwargs: Any) -> None: + super().__init__(*args, **kwargs) + + +class HandleItem(_Model): + """A listed Azure Storage handle item. + + :ivar handle_id: XSMB service handle ID. Required. + :vartype handle_id: str + :ivar path: The path. Required. + :vartype path: ~azure.storage.fileshare._generated.models.StringEncoded + :ivar file_id: FileId uniquely identifies the file or directory. Required. + :vartype file_id: str + :ivar parent_id: ParentId uniquely identifies the parent directory of the object. + :vartype parent_id: str + :ivar session_id: SMB session ID in context of which the file handle was opened. Required. + :vartype session_id: str + :ivar client_ip: Client IP that opened the handle. Required. + :vartype client_ip: str + :ivar client_name: Name of the client machine where the share is being mounted. Required. + :vartype client_name: str + :ivar open_time: Time when the session that previously opened the handle has last been + reconnected. (UTC). Required. + :vartype open_time: ~datetime.datetime + :ivar last_reconnect_time: Time handle was last connected to (UTC). + :vartype last_reconnect_time: ~datetime.datetime + :ivar access_right_list: The access rights. + :vartype access_right_list: list[str or ~azure.storage.fileshare.models.AccessRight] + """ + + handle_id: str = rest_field( + name="handleId", + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "HandleId", "text": False, "unwrapped": False}, + deserializer=_xml_deser_str, + ) + """XSMB service handle ID. Required.""" + path: "_models.StringEncoded" = rest_field( + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "Path", "text": False, "unwrapped": False}, + ) + """The path. Required.""" + file_id: str = rest_field( + name="fileId", + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "FileId", "text": False, "unwrapped": False}, + deserializer=_xml_deser_str, + ) + """FileId uniquely identifies the file or directory. Required.""" + parent_id: Optional[str] = rest_field( + name="parentId", + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "ParentId", "text": False, "unwrapped": False}, + deserializer=_xml_deser_str, + ) + """ParentId uniquely identifies the parent directory of the object.""" + session_id: str = rest_field( + name="sessionId", + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "SessionId", "text": False, "unwrapped": False}, + deserializer=_xml_deser_str, + ) + """SMB session ID in context of which the file handle was opened. Required.""" + client_ip: str = rest_field( + name="clientIp", + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "ClientIp", "text": False, "unwrapped": False}, + deserializer=_xml_deser_str, + ) + """Client IP that opened the handle. Required.""" + client_name: str = rest_field( + name="clientName", + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "ClientName", "text": False, "unwrapped": False}, + deserializer=_xml_deser_str, + ) + """Name of the client machine where the share is being mounted. Required.""" + open_time: datetime.datetime = rest_field( + name="openTime", + visibility=["read", "create", "update", "delete", "query"], + format="rfc7231", + xml={"attribute": False, "name": "OpenTime", "text": False, "unwrapped": False}, + deserializer=_xml_deser_datetime_rfc7231, + ) + """Time when the session that previously opened the handle has last been reconnected. (UTC). + Required.""" + last_reconnect_time: Optional[datetime.datetime] = rest_field( + name="lastReconnectTime", + visibility=["read", "create", "update", "delete", "query"], + format="rfc7231", + xml={"attribute": False, "name": "LastReconnectTime", "text": False, "unwrapped": False}, + deserializer=_xml_deser_datetime_rfc7231, + ) + """Time handle was last connected to (UTC).""" + access_right_list: Optional[list[Union[str, "_models.AccessRight"]]] = rest_field( + name="accessRightList", + visibility=["read", "create", "update", "delete", "query"], + xml={ + "attribute": False, + "itemsName": "AccessRight", + "name": "AccessRightList", + "text": False, + "unwrapped": False, + }, + ) + """The access rights.""" + + _xml = {"attribute": False, "name": "Handle", "text": False, "unwrapped": False} + + @overload + def __init__( + self, + *, + handle_id: str, + path: "_models.StringEncoded", + file_id: str, + session_id: str, + client_ip: str, + client_name: str, + open_time: datetime.datetime, + parent_id: Optional[str] = None, + last_reconnect_time: Optional[datetime.datetime] = None, + access_right_list: Optional[list[Union[str, "_models.AccessRight"]]] = None, + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: + """ + :param mapping: raw JSON to initialize the model. + :type mapping: Mapping[str, Any] + """ + + def __init__(self, *args: Any, **kwargs: Any) -> None: + super().__init__(*args, **kwargs) + + +class KeyInfo(_Model): + """Key information. + + :ivar start: The date-time the key is active in ISO 8601 UTC time. + :vartype start: str + :ivar expiry: The date-time the key expires in ISO 8601 UTC time. Required. + :vartype expiry: str + :ivar delegated_user_tid: The delegated user tenant id in Azure AD. + :vartype delegated_user_tid: str + """ + + start: Optional[str] = rest_field( + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "Start", "text": False, "unwrapped": False}, + deserializer=_xml_deser_str, + ) + """The date-time the key is active in ISO 8601 UTC time.""" + expiry: str = rest_field( + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "Expiry", "text": False, "unwrapped": False}, + deserializer=_xml_deser_str, + ) + """The date-time the key expires in ISO 8601 UTC time. Required.""" + delegated_user_tid: Optional[str] = rest_field( + name="delegatedUserTid", + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "DelegatedUserTid", "text": False, "unwrapped": False}, + deserializer=_xml_deser_str, + ) + """The delegated user tenant id in Azure AD.""" + + _xml = {"attribute": False, "name": "KeyInfo", "text": False, "unwrapped": False} + + @overload + def __init__( + self, + *, + expiry: str, + start: Optional[str] = None, + delegated_user_tid: Optional[str] = None, + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: + """ + :param mapping: raw JSON to initialize the model. + :type mapping: Mapping[str, Any] + """ + + def __init__(self, *args: Any, **kwargs: Any) -> None: + super().__init__(*args, **kwargs) + + +class ListFilesAndDirectoriesSegmentResponse(_Model): + """An enumeration of directories and files. + + :ivar service_endpoint: The service endpoint. Required. + :vartype service_endpoint: str + :ivar share_name: The share name. Required. + :vartype share_name: str + :ivar share_snapshot: The share snapshot. + :vartype share_snapshot: str + :ivar encoded: Whether the listing is encoded. + :vartype encoded: bool + :ivar directory_path: The directory path. Required. + :vartype directory_path: str + :ivar prefix: The prefix. Required. + :vartype prefix: ~azure.storage.fileshare._generated.models.StringEncoded + :ivar marker: The marker. + :vartype marker: str + :ivar max_results: The max results. + :vartype max_results: int + :ivar segment: Abstract for entries that can be listed from Directory. Required. + :vartype segment: ~azure.storage.fileshare._generated.models.FilesAndDirectoriesListSegment + :ivar next_marker: The next marker. Required. + :vartype next_marker: str + :ivar directory_id: The directory ID. + :vartype directory_id: str + """ + + service_endpoint: str = rest_field( + name="serviceEndpoint", + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": True, "name": "ServiceEndpoint", "text": False, "unwrapped": False}, + deserializer=_xml_deser_str, + ) + """The service endpoint. Required.""" + share_name: str = rest_field( + name="shareName", + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": True, "name": "ShareName", "text": False, "unwrapped": False}, + deserializer=_xml_deser_str, + ) + """The share name. Required.""" + share_snapshot: Optional[str] = rest_field( + name="shareSnapshot", + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": True, "name": "ShareSnapshot", "text": False, "unwrapped": False}, + deserializer=_xml_deser_str, + ) + """The share snapshot.""" + encoded: Optional[bool] = rest_field( + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": True, "name": "Encoded", "text": False, "unwrapped": False}, + deserializer=_xml_deser_bool, + ) + """Whether the listing is encoded.""" + directory_path: str = rest_field( + name="directoryPath", + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": True, "name": "DirectoryPath", "text": False, "unwrapped": False}, + deserializer=_xml_deser_str, + ) + """The directory path. Required.""" + prefix: "_models.StringEncoded" = rest_field( + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "Prefix", "text": False, "unwrapped": False}, + ) + """The prefix. Required.""" + marker: Optional[str] = rest_field( + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "Marker", "text": False, "unwrapped": False}, + deserializer=_xml_deser_str, + ) + """The marker.""" + max_results: Optional[int] = rest_field( + name="maxResults", + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "MaxResults", "text": False, "unwrapped": False}, + deserializer=_xml_deser_int, + ) + """The max results.""" + segment: "_models.FilesAndDirectoriesListSegment" = rest_field( + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "Entries", "text": False, "unwrapped": False}, + ) + """Abstract for entries that can be listed from Directory. Required.""" + next_marker: str = rest_field( + name="nextMarker", + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "NextMarker", "text": False, "unwrapped": False}, + deserializer=_xml_deser_str, + ) + """The next marker. Required.""" + directory_id: Optional[str] = rest_field( + name="directoryId", + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "DirectoryId", "text": False, "unwrapped": False}, + deserializer=_xml_deser_str, + ) + """The directory ID.""" + + _xml = {"attribute": False, "name": "EnumerationResults", "text": False, "unwrapped": False} + + @overload + def __init__( + self, + *, + service_endpoint: str, + share_name: str, + directory_path: str, + prefix: "_models.StringEncoded", + segment: "_models.FilesAndDirectoriesListSegment", + next_marker: str, + share_snapshot: Optional[str] = None, + encoded: Optional[bool] = None, + marker: Optional[str] = None, + max_results: Optional[int] = None, + directory_id: Optional[str] = None, + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: + """ + :param mapping: raw JSON to initialize the model. + :type mapping: Mapping[str, Any] + """ + + def __init__(self, *args: Any, **kwargs: Any) -> None: + super().__init__(*args, **kwargs) + + +class ListHandlesResponse(_Model): + """An enumeration of handles. + + :ivar handle_list: The handle list. + :vartype handle_list: ~azure.storage.fileshare._generated.models.HandleItem + :ivar next_marker: The next marker. Required. + :vartype next_marker: str + """ + + handle_list: Optional[list["_models.HandleItem"]] = rest_field( + name="handleList", + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "itemsName": "Handle", "name": "Entries", "text": False, "unwrapped": False}, + ) + """The handle list.""" + next_marker: str = rest_field( + name="nextMarker", + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "NextMarker", "text": False, "unwrapped": False}, + deserializer=_xml_deser_str, + ) + """The next marker. Required.""" + + _xml = {"attribute": False, "name": "EnumerationResults", "text": False, "unwrapped": False} + + @overload + def __init__( + self, + *, + next_marker: str, + handle_list: Optional[list["_models.HandleItem"]] = None, + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: + """ + :param mapping: raw JSON to initialize the model. + :type mapping: Mapping[str, Any] + """ + + def __init__(self, *args: Any, **kwargs: Any) -> None: + super().__init__(*args, **kwargs) + + +class ListSharesResponse(_Model): + """An enumeration of shares. + + :ivar service_endpoint: The service endpoint. Required. + :vartype service_endpoint: str + :ivar prefix: The prefix. + :vartype prefix: str + :ivar marker: The marker. + :vartype marker: str + :ivar max_results: The max results. + :vartype max_results: int + :ivar share_items: The share items. + :vartype share_items: ~azure.storage.fileshare._generated.models.ShareItemInternal + :ivar next_marker: The next marker. Required. + :vartype next_marker: str + """ + + service_endpoint: str = rest_field( + name="serviceEndpoint", + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": True, "name": "ServiceEndpoint", "text": False, "unwrapped": False}, + deserializer=_xml_deser_str, + ) + """The service endpoint. Required.""" + prefix: Optional[str] = rest_field( + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "Prefix", "text": False, "unwrapped": False}, + deserializer=_xml_deser_str, + ) + """The prefix.""" + marker: Optional[str] = rest_field( + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "Marker", "text": False, "unwrapped": False}, + deserializer=_xml_deser_str, + ) + """The marker.""" + max_results: Optional[int] = rest_field( + name="maxResults", + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "MaxResults", "text": False, "unwrapped": False}, + deserializer=_xml_deser_int, + ) + """The max results.""" + share_items: Optional[list["_models.ShareItemInternal"]] = rest_field( + name="shareItems", + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "itemsName": "Share", "name": "Shares", "text": False, "unwrapped": False}, + ) + """The share items.""" + next_marker: str = rest_field( + name="nextMarker", + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "NextMarker", "text": False, "unwrapped": False}, + deserializer=_xml_deser_str, + ) + """The next marker. Required.""" + + _xml = {"attribute": False, "name": "EnumerationResults", "text": False, "unwrapped": False} + + @overload + def __init__( + self, + *, + service_endpoint: str, + next_marker: str, + prefix: Optional[str] = None, + marker: Optional[str] = None, + max_results: Optional[int] = None, + share_items: Optional[list["_models.ShareItemInternal"]] = None, + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: + """ + :param mapping: raw JSON to initialize the model. + :type mapping: Mapping[str, Any] + """ + + def __init__(self, *args: Any, **kwargs: Any) -> None: + super().__init__(*args, **kwargs) + + +class Metrics(_Model): + """Storage Analytics metrics for file service. + + :ivar version: The version of Storage Analytics to configure. Required. + :vartype version: str + :ivar enabled: Indicates whether metrics are enabled for the File service. Required. + :vartype enabled: bool + :ivar include_apis: Indicates whether metrics should generate summary statistics for called API + operations. + :vartype include_apis: bool + :ivar retention_policy: The retention policy. + :vartype retention_policy: ~azure.storage.fileshare._generated.models.RetentionPolicy + """ + + version: str = rest_field( + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "Version", "text": False, "unwrapped": False}, + deserializer=_xml_deser_str, + ) + """The version of Storage Analytics to configure. Required.""" + enabled: bool = rest_field( + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "Enabled", "text": False, "unwrapped": False}, + deserializer=_xml_deser_bool, + ) + """Indicates whether metrics are enabled for the File service. Required.""" + include_apis: Optional[bool] = rest_field( + name="includeApis", + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "IncludeAPIs", "text": False, "unwrapped": False}, + deserializer=_xml_deser_bool, + ) + """Indicates whether metrics should generate summary statistics for called API operations.""" + retention_policy: Optional["_models.RetentionPolicy"] = rest_field( + name="retentionPolicy", + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "RetentionPolicy", "text": False, "unwrapped": False}, + ) + """The retention policy.""" + + _xml = {"attribute": False, "name": "Metrics", "text": False, "unwrapped": False} + + @overload + def __init__( + self, + *, + version: str, + enabled: bool, + include_apis: Optional[bool] = None, + retention_policy: Optional["_models.RetentionPolicy"] = None, + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: + """ + :param mapping: raw JSON to initialize the model. + :type mapping: Mapping[str, Any] + """ + + def __init__(self, *args: Any, **kwargs: Any) -> None: + super().__init__(*args, **kwargs) + + +class RetentionPolicy(_Model): + """The retention policy. + + :ivar enabled: Indicates whether a retention policy is enabled for the File service. If false, + metrics data is retained, and the user is responsible for deleting it. Required. + :vartype enabled: bool + :ivar days: Indicates the number of days that metrics data should be retained. All data older + than this value will be deleted. Metrics data is deleted on a best-effort basis after the + retention period expires. + :vartype days: int + """ + + enabled: bool = rest_field( + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "Enabled", "text": False, "unwrapped": False}, + deserializer=_xml_deser_bool, + ) + """Indicates whether a retention policy is enabled for the File service. If false, metrics data is + retained, and the user is responsible for deleting it. Required.""" + days: Optional[int] = rest_field( + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "Days", "text": False, "unwrapped": False}, + deserializer=_xml_deser_int, + ) + """Indicates the number of days that metrics data should be retained. All data older than this + value will be deleted. Metrics data is deleted on a best-effort basis after the retention + period expires.""" + + _xml = {"attribute": False, "name": "RetentionPolicy", "text": False, "unwrapped": False} + + @overload + def __init__( + self, + *, + enabled: bool, + days: Optional[int] = None, + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: + """ + :param mapping: raw JSON to initialize the model. + :type mapping: Mapping[str, Any] + """ + + def __init__(self, *args: Any, **kwargs: Any) -> None: + super().__init__(*args, **kwargs) + + +class ShareFileRangeList(_Model): + """The list of file ranges. + + :ivar ranges: The file ranges. + :vartype ranges: ~azure.storage.fileshare._generated.models.FileRange + :ivar clear_ranges: The clear ranges. + :vartype clear_ranges: ~azure.storage.fileshare._generated.models.ClearRange + """ + + ranges: Optional[list["_models.FileRange"]] = rest_field( + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "itemsName": "Range", "name": "Range", "text": False, "unwrapped": True}, + ) + """The file ranges.""" + clear_ranges: Optional[list["_models.ClearRange"]] = rest_field( + name="clearRanges", + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "itemsName": "ClearRange", "name": "ClearRange", "text": False, "unwrapped": True}, + ) + """The clear ranges.""" + + _xml = {"attribute": False, "name": "Ranges", "text": False, "unwrapped": False} + + @overload + def __init__( + self, + *, + ranges: Optional[list["_models.FileRange"]] = None, + clear_ranges: Optional[list["_models.ClearRange"]] = None, + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: + """ + :param mapping: raw JSON to initialize the model. + :type mapping: Mapping[str, Any] + """ + + def __init__(self, *args: Any, **kwargs: Any) -> None: + super().__init__(*args, **kwargs) + + +class ShareItemInternal(_Model): + """A listed Azure Storage share item. + + :ivar name: The share name. Required. + :vartype name: str + :ivar snapshot: The share snapshot. + :vartype snapshot: str + :ivar deleted: Whether the share is deleted. + :vartype deleted: bool + :ivar version: The share version. + :vartype version: str + :ivar properties: Properties of a share. Required. + :vartype properties: ~azure.storage.fileshare._generated.models.SharePropertiesInternal + :ivar metadata: Dictionary of . + :vartype metadata: dict[str, str] + """ + + name: str = rest_field( + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "Name", "text": False, "unwrapped": False}, + deserializer=_xml_deser_str, + ) + """The share name. Required.""" + snapshot: Optional[str] = rest_field( + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "Snapshot", "text": False, "unwrapped": False}, + deserializer=_xml_deser_str, + ) + """The share snapshot.""" + deleted: Optional[bool] = rest_field( + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "Deleted", "text": False, "unwrapped": False}, + deserializer=_xml_deser_bool, + ) + """Whether the share is deleted.""" + version: Optional[str] = rest_field( + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "Version", "text": False, "unwrapped": False}, + deserializer=_xml_deser_str, + ) + """The share version.""" + properties: "_models.SharePropertiesInternal" = rest_field( + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "Properties", "text": False, "unwrapped": False}, + ) + """Properties of a share. Required.""" + metadata: Optional[dict[str, str]] = rest_field( + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "Metadata", "text": False, "unwrapped": False}, + ) + """Dictionary of .""" + + _xml = {"attribute": False, "name": "Share", "text": False, "unwrapped": False} + + @overload + def __init__( + self, + *, + name: str, + properties: "_models.SharePropertiesInternal", + snapshot: Optional[str] = None, + deleted: Optional[bool] = None, + version: Optional[str] = None, + metadata: Optional[dict[str, str]] = None, + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: + """ + :param mapping: raw JSON to initialize the model. + :type mapping: Mapping[str, Any] + """ + + def __init__(self, *args: Any, **kwargs: Any) -> None: + super().__init__(*args, **kwargs) + + +class ShareNfsSettings(_Model): + """Settings for SMB protocol. + + :ivar encryption_in_transit: Enable or disable encryption in transit. + :vartype encryption_in_transit: + ~azure.storage.fileshare._generated.models.ShareNfsSettingsEncryptionInTransit + """ + + encryption_in_transit: Optional["_models.ShareNfsSettingsEncryptionInTransit"] = rest_field( + name="encryptionInTransit", + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "EncryptionInTransit", "text": False, "unwrapped": False}, + ) + """Enable or disable encryption in transit.""" + + _xml = {"attribute": False, "name": "NFS", "text": False, "unwrapped": False} + + @overload + def __init__( + self, + *, + encryption_in_transit: Optional["_models.ShareNfsSettingsEncryptionInTransit"] = None, + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: + """ + :param mapping: raw JSON to initialize the model. + :type mapping: Mapping[str, Any] + """ + + def __init__(self, *args: Any, **kwargs: Any) -> None: + super().__init__(*args, **kwargs) + + +class ShareNfsSettingsEncryptionInTransit(_Model): + """Enable or disable encryption in transit. + + :ivar required: If encryption in transit is required. + :vartype required: bool + """ + + required: Optional[bool] = rest_field( + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "Required", "text": False, "unwrapped": False}, + deserializer=_xml_deser_bool, + ) + """If encryption in transit is required.""" + + _xml = {"attribute": False, "name": "ShareNfsSettingsEncryptionInTransit", "text": False, "unwrapped": False} + + @overload + def __init__( + self, + *, + required: Optional[bool] = None, + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: + """ + :param mapping: raw JSON to initialize the model. + :type mapping: Mapping[str, Any] + """ + + def __init__(self, *args: Any, **kwargs: Any) -> None: + super().__init__(*args, **kwargs) + + +class SharePermission(_Model): + """A permission (a security descriptor) at the share level. + + :ivar permission: The permission in the Security Descriptor Definition Language (SDDL). + Required. + :vartype permission: str + :ivar format: The permission format. Known values are: "Sddl" and "Binary". + :vartype format: str or ~azure.storage.fileshare.models.FilePermissionFormat + """ + + permission: str = rest_field(visibility=["read", "create", "update", "delete", "query"]) + """The permission in the Security Descriptor Definition Language (SDDL). Required.""" + format: Optional[Union[str, "_models.FilePermissionFormat"]] = rest_field( + visibility=["read", "create", "update", "delete", "query"] + ) + """The permission format. Known values are: \"Sddl\" and \"Binary\".""" + + @overload + def __init__( + self, + *, + permission: str, + format: Optional[Union[str, "_models.FilePermissionFormat"]] = None, + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: + """ + :param mapping: raw JSON to initialize the model. + :type mapping: Mapping[str, Any] + """ + + def __init__(self, *args: Any, **kwargs: Any) -> None: + super().__init__(*args, **kwargs) + + +class SharePropertiesInternal(_Model): + """Properties of a share. + + :ivar last_modified: The last modified time. Required. + :vartype last_modified: ~datetime.datetime + :ivar etag: The ETag of the share. Required. + :vartype etag: str + :ivar quota: The share quota. Required. + :vartype quota: int + :ivar provisioned_iops: The provisioned IOPS. + :vartype provisioned_iops: int + :ivar provisioned_ingress_m_bps: The provisioned ingress in MBps. + :vartype provisioned_ingress_m_bps: int + :ivar provisioned_egress_m_bps: The provisioned egress in MBps. + :vartype provisioned_egress_m_bps: int + :ivar provisioned_bandwidth_mi_bps: The provisioned bandwidth in MiBps. + :vartype provisioned_bandwidth_mi_bps: int + :ivar next_allowed_quota_downgrade_time: The next allowed quota downgrade time. + :vartype next_allowed_quota_downgrade_time: ~datetime.datetime + :ivar deleted_time: The deleted time. + :vartype deleted_time: ~datetime.datetime + :ivar remaining_retention_days: The remaining retention days. + :vartype remaining_retention_days: int + :ivar access_tier: The access tier. + :vartype access_tier: str + :ivar access_tier_change_time: The access tier change time. + :vartype access_tier_change_time: ~datetime.datetime + :ivar access_tier_transition_state: The access tier transition state. + :vartype access_tier_transition_state: str + :ivar lease_status: The current lease status of the share. Known values are: "locked" and + "unlocked". + :vartype lease_status: str or ~azure.storage.fileshare.models.LeaseStatusType + :ivar lease_state: Lease state of the share. Known values are: "available", "leased", + "expired", "breaking", and "broken". + :vartype lease_state: str or ~azure.storage.fileshare.models.LeaseStateType + :ivar lease_duration: When a share is leased, specifies whether the lease is of infinite or + fixed duration. Known values are: "infinite" and "fixed". + :vartype lease_duration: str or ~azure.storage.fileshare.models.LeaseDurationType + :ivar enabled_protocols: The enabled protocols. + :vartype enabled_protocols: str + :ivar root_squash: The root squash setting. Known values are: "NoRootSquash", "RootSquash", and + "AllSquash". + :vartype root_squash: str or ~azure.storage.fileshare.models.ShareRootSquash + :ivar enable_snapshot_virtual_directory_access: Whether snapshot virtual directory access is + enabled. + :vartype enable_snapshot_virtual_directory_access: bool + :ivar paid_bursting_enabled: Whether paid bursting is enabled. + :vartype paid_bursting_enabled: bool + :ivar paid_bursting_max_iops: The maximum IOPS for paid bursting. + :vartype paid_bursting_max_iops: int + :ivar paid_bursting_max_bandwidth_mibps: The maximum bandwidth for paid bursting in MiBps. + :vartype paid_bursting_max_bandwidth_mibps: int + :ivar included_burst_iops: The included burst IOPS. + :vartype included_burst_iops: int + :ivar max_burst_credits_for_iops: The maximum burst credits for IOPS. + :vartype max_burst_credits_for_iops: int + :ivar next_allowed_provisioned_iops_downgrade_time: The next allowed provisioned IOPS downgrade + time. + :vartype next_allowed_provisioned_iops_downgrade_time: ~datetime.datetime + :ivar next_allowed_provisioned_bandwidth_downgrade_time: The next allowed provisioned bandwidth + downgrade time. + :vartype next_allowed_provisioned_bandwidth_downgrade_time: ~datetime.datetime + :ivar enable_smb_directory_lease: Whether SMB directory lease is enabled. + :vartype enable_smb_directory_lease: bool + """ + + last_modified: datetime.datetime = rest_field( + name="lastModified", + visibility=["read", "create", "update", "delete", "query"], + format="rfc7231", + xml={"attribute": False, "name": "Last-Modified", "text": False, "unwrapped": False}, + deserializer=_xml_deser_datetime_rfc7231, + ) + """The last modified time. Required.""" + etag: str = rest_field( + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "Etag", "text": False, "unwrapped": False}, + deserializer=_xml_deser_str, + ) + """The ETag of the share. Required.""" + quota: int = rest_field( + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "Quota", "text": False, "unwrapped": False}, + deserializer=_xml_deser_int, + ) + """The share quota. Required.""" + provisioned_iops: Optional[int] = rest_field( + name="provisionedIops", + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "ProvisionedIops", "text": False, "unwrapped": False}, + deserializer=_xml_deser_int, + ) + """The provisioned IOPS.""" + provisioned_ingress_m_bps: Optional[int] = rest_field( + name="provisionedIngressMBps", + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "ProvisionedIngressMBps", "text": False, "unwrapped": False}, + deserializer=_xml_deser_int, + ) + """The provisioned ingress in MBps.""" + provisioned_egress_m_bps: Optional[int] = rest_field( + name="provisionedEgressMBps", + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "ProvisionedEgressMBps", "text": False, "unwrapped": False}, + deserializer=_xml_deser_int, + ) + """The provisioned egress in MBps.""" + provisioned_bandwidth_mi_bps: Optional[int] = rest_field( + name="provisionedBandwidthMiBps", + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "ProvisionedBandwidthMiBps", "text": False, "unwrapped": False}, + deserializer=_xml_deser_int, + ) + """The provisioned bandwidth in MiBps.""" + next_allowed_quota_downgrade_time: Optional[datetime.datetime] = rest_field( + name="nextAllowedQuotaDowngradeTime", + visibility=["read", "create", "update", "delete", "query"], + format="rfc7231", + xml={"attribute": False, "name": "NextAllowedQuotaDowngradeTime", "text": False, "unwrapped": False}, + deserializer=_xml_deser_datetime_rfc7231, + ) + """The next allowed quota downgrade time.""" + deleted_time: Optional[datetime.datetime] = rest_field( + name="deletedTime", + visibility=["read", "create", "update", "delete", "query"], + format="rfc7231", + xml={"attribute": False, "name": "DeletedTime", "text": False, "unwrapped": False}, + deserializer=_xml_deser_datetime_rfc7231, + ) + """The deleted time.""" + remaining_retention_days: Optional[int] = rest_field( + name="remainingRetentionDays", + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "RemainingRetentionDays", "text": False, "unwrapped": False}, + deserializer=_xml_deser_int, + ) + """The remaining retention days.""" + access_tier: Optional[str] = rest_field( + name="accessTier", + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "AccessTier", "text": False, "unwrapped": False}, + deserializer=_xml_deser_str, + ) + """The access tier.""" + access_tier_change_time: Optional[datetime.datetime] = rest_field( + name="accessTierChangeTime", + visibility=["read", "create", "update", "delete", "query"], + format="rfc7231", + xml={"attribute": False, "name": "AccessTierChangeTime", "text": False, "unwrapped": False}, + deserializer=_xml_deser_datetime_rfc7231, + ) + """The access tier change time.""" + access_tier_transition_state: Optional[str] = rest_field( + name="accessTierTransitionState", + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "AccessTierTransitionState", "text": False, "unwrapped": False}, + deserializer=_xml_deser_str, + ) + """The access tier transition state.""" + lease_status: Optional[Union[str, "_models.LeaseStatusType"]] = rest_field( + name="leaseStatus", + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "LeaseStatus", "text": False, "unwrapped": False}, + deserializer=functools.partial(_xml_deser_enum_or_str, LeaseStatusType), + ) + """The current lease status of the share. Known values are: \"locked\" and \"unlocked\".""" + lease_state: Optional[Union[str, "_models.LeaseStateType"]] = rest_field( + name="leaseState", + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "LeaseState", "text": False, "unwrapped": False}, + deserializer=functools.partial(_xml_deser_enum_or_str, LeaseStateType), + ) + """Lease state of the share. Known values are: \"available\", \"leased\", \"expired\", + \"breaking\", and \"broken\".""" + lease_duration: Optional[Union[str, "_models.LeaseDurationType"]] = rest_field( + name="leaseDuration", + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "LeaseDuration", "text": False, "unwrapped": False}, + deserializer=functools.partial(_xml_deser_enum_or_str, LeaseDurationType), + ) + """When a share is leased, specifies whether the lease is of infinite or fixed duration. Known + values are: \"infinite\" and \"fixed\".""" + enabled_protocols: Optional[str] = rest_field( + name="enabledProtocols", + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "EnabledProtocols", "text": False, "unwrapped": False}, + deserializer=_xml_deser_str, + ) + """The enabled protocols.""" + root_squash: Optional[Union[str, "_models.ShareRootSquash"]] = rest_field( + name="rootSquash", + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "RootSquash", "text": False, "unwrapped": False}, + deserializer=functools.partial(_xml_deser_enum_or_str, ShareRootSquash), + ) + """The root squash setting. Known values are: \"NoRootSquash\", \"RootSquash\", and \"AllSquash\".""" + enable_snapshot_virtual_directory_access: Optional[bool] = rest_field( + name="enableSnapshotVirtualDirectoryAccess", + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "EnableSnapshotVirtualDirectoryAccess", "text": False, "unwrapped": False}, + deserializer=_xml_deser_bool, + ) + """Whether snapshot virtual directory access is enabled.""" + paid_bursting_enabled: Optional[bool] = rest_field( + name="paidBurstingEnabled", + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "PaidBurstingEnabled", "text": False, "unwrapped": False}, + deserializer=_xml_deser_bool, + ) + """Whether paid bursting is enabled.""" + paid_bursting_max_iops: Optional[int] = rest_field( + name="paidBurstingMaxIops", + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "PaidBurstingMaxIops", "text": False, "unwrapped": False}, + deserializer=_xml_deser_int, + ) + """The maximum IOPS for paid bursting.""" + paid_bursting_max_bandwidth_mibps: Optional[int] = rest_field( + name="paidBurstingMaxBandwidthMibps", + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "PaidBurstingMaxBandwidthMibps", "text": False, "unwrapped": False}, + deserializer=_xml_deser_int, + ) + """The maximum bandwidth for paid bursting in MiBps.""" + included_burst_iops: Optional[int] = rest_field( + name="includedBurstIops", + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "IncludedBurstIops", "text": False, "unwrapped": False}, + deserializer=_xml_deser_int, + ) + """The included burst IOPS.""" + max_burst_credits_for_iops: Optional[int] = rest_field( + name="maxBurstCreditsForIops", + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "MaxBurstCreditsForIops", "text": False, "unwrapped": False}, + deserializer=_xml_deser_int, + ) + """The maximum burst credits for IOPS.""" + next_allowed_provisioned_iops_downgrade_time: Optional[datetime.datetime] = rest_field( + name="nextAllowedProvisionedIopsDowngradeTime", + visibility=["read", "create", "update", "delete", "query"], + format="rfc7231", + xml={"attribute": False, "name": "NextAllowedProvisionedIopsDowngradeTime", "text": False, "unwrapped": False}, + deserializer=_xml_deser_datetime_rfc7231, + ) + """The next allowed provisioned IOPS downgrade time.""" + next_allowed_provisioned_bandwidth_downgrade_time: Optional[datetime.datetime] = rest_field( + name="nextAllowedProvisionedBandwidthDowngradeTime", + visibility=["read", "create", "update", "delete", "query"], + format="rfc7231", + xml={ + "attribute": False, + "name": "NextAllowedProvisionedBandwidthDowngradeTime", + "text": False, + "unwrapped": False, + }, + deserializer=_xml_deser_datetime_rfc7231, + ) + """The next allowed provisioned bandwidth downgrade time.""" + enable_smb_directory_lease: Optional[bool] = rest_field( + name="enableSmbDirectoryLease", + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "EnableSmbDirectoryLease", "text": False, "unwrapped": False}, + deserializer=_xml_deser_bool, + ) + """Whether SMB directory lease is enabled.""" + + _xml = {"attribute": False, "name": "SharePropertiesInternal", "text": False, "unwrapped": False} + + @overload + def __init__( # pylint: disable=too-many-locals + self, + *, + last_modified: datetime.datetime, + etag: str, + quota: int, + provisioned_iops: Optional[int] = None, + provisioned_ingress_m_bps: Optional[int] = None, + provisioned_egress_m_bps: Optional[int] = None, + provisioned_bandwidth_mi_bps: Optional[int] = None, + next_allowed_quota_downgrade_time: Optional[datetime.datetime] = None, + deleted_time: Optional[datetime.datetime] = None, + remaining_retention_days: Optional[int] = None, + access_tier: Optional[str] = None, + access_tier_change_time: Optional[datetime.datetime] = None, + access_tier_transition_state: Optional[str] = None, + lease_status: Optional[Union[str, "_models.LeaseStatusType"]] = None, + lease_state: Optional[Union[str, "_models.LeaseStateType"]] = None, + lease_duration: Optional[Union[str, "_models.LeaseDurationType"]] = None, + enabled_protocols: Optional[str] = None, + root_squash: Optional[Union[str, "_models.ShareRootSquash"]] = None, + enable_snapshot_virtual_directory_access: Optional[bool] = None, + paid_bursting_enabled: Optional[bool] = None, + paid_bursting_max_iops: Optional[int] = None, + paid_bursting_max_bandwidth_mibps: Optional[int] = None, + included_burst_iops: Optional[int] = None, + max_burst_credits_for_iops: Optional[int] = None, + next_allowed_provisioned_iops_downgrade_time: Optional[datetime.datetime] = None, + next_allowed_provisioned_bandwidth_downgrade_time: Optional[datetime.datetime] = None, + enable_smb_directory_lease: Optional[bool] = None, + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: + """ + :param mapping: raw JSON to initialize the model. + :type mapping: Mapping[str, Any] + """ + + def __init__(self, *args: Any, **kwargs: Any) -> None: + super().__init__(*args, **kwargs) + + +class ShareProtocolSettings(_Model): + """Protocol settings. + + :ivar smb: Settings for SMB protocol. + :vartype smb: ~azure.storage.fileshare._generated.models.ShareSmbSettings + :ivar nfs: Settings for NFS protocol. + :vartype nfs: ~azure.storage.fileshare._generated.models.ShareNfsSettings + """ + + smb: Optional["_models.ShareSmbSettings"] = rest_field( + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "SMB", "text": False, "unwrapped": False}, + ) + """Settings for SMB protocol.""" + nfs: Optional["_models.ShareNfsSettings"] = rest_field( + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "NFS", "text": False, "unwrapped": False}, + ) + """Settings for NFS protocol.""" + + _xml = {"attribute": False, "name": "ProtocolSettings", "text": False, "unwrapped": False} + + @overload + def __init__( + self, + *, + smb: Optional["_models.ShareSmbSettings"] = None, + nfs: Optional["_models.ShareNfsSettings"] = None, + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: + """ + :param mapping: raw JSON to initialize the model. + :type mapping: Mapping[str, Any] + """ + + def __init__(self, *args: Any, **kwargs: Any) -> None: + super().__init__(*args, **kwargs) + + +class ShareSmbSettings(_Model): + """Settings for SMB protocol. + + :ivar multichannel: Settings for SMB Multichannel. + :vartype multichannel: ~azure.storage.fileshare._generated.models.SmbMultichannel + :ivar encryption_in_transit: Enable or disable encryption in transit. + :vartype encryption_in_transit: + ~azure.storage.fileshare._generated.models.ShareSmbSettingsEncryptionInTransit + """ + + multichannel: Optional["_models.SmbMultichannel"] = rest_field( + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "Multichannel", "text": False, "unwrapped": False}, + ) + """Settings for SMB Multichannel.""" + encryption_in_transit: Optional["_models.ShareSmbSettingsEncryptionInTransit"] = rest_field( + name="encryptionInTransit", + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "EncryptionInTransit", "text": False, "unwrapped": False}, + ) + """Enable or disable encryption in transit.""" + + _xml = {"attribute": False, "name": "SMB", "text": False, "unwrapped": False} + + @overload + def __init__( + self, + *, + multichannel: Optional["_models.SmbMultichannel"] = None, + encryption_in_transit: Optional["_models.ShareSmbSettingsEncryptionInTransit"] = None, + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: + """ + :param mapping: raw JSON to initialize the model. + :type mapping: Mapping[str, Any] + """ + + def __init__(self, *args: Any, **kwargs: Any) -> None: + super().__init__(*args, **kwargs) + + +class ShareSmbSettingsEncryptionInTransit(_Model): + """Enable or disable encryption in transit. + + :ivar required: If encryption in transit is required. + :vartype required: bool + """ + + required: Optional[bool] = rest_field( + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "Required", "text": False, "unwrapped": False}, + deserializer=_xml_deser_bool, + ) + """If encryption in transit is required.""" + + _xml = {"attribute": False, "name": "ShareSmbSettingsEncryptionInTransit", "text": False, "unwrapped": False} + + @overload + def __init__( + self, + *, + required: Optional[bool] = None, + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: + """ + :param mapping: raw JSON to initialize the model. + :type mapping: Mapping[str, Any] + """ + + def __init__(self, *args: Any, **kwargs: Any) -> None: + super().__init__(*args, **kwargs) + + +class ShareStats(_Model): + """Stats for the share. + + :ivar share_usage_bytes: The approximate size of the data stored in bytes. Note that this value + may not include all recently created or recently resized files. Required. + :vartype share_usage_bytes: int + """ + + share_usage_bytes: int = rest_field( + name="shareUsageBytes", + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "ShareUsageBytes", "text": False, "unwrapped": False}, + deserializer=_xml_deser_int, + ) + """The approximate size of the data stored in bytes. Note that this value may not include all + recently created or recently resized files. Required.""" + + _xml = {"attribute": False, "name": "ShareStats", "text": False, "unwrapped": False} + + @overload + def __init__( + self, + *, + share_usage_bytes: int, + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: + """ + :param mapping: raw JSON to initialize the model. + :type mapping: Mapping[str, Any] + """ + + def __init__(self, *args: Any, **kwargs: Any) -> None: + super().__init__(*args, **kwargs) + + +class SignedIdentifier(_Model): + """Signed identifier. + + :ivar id: A unique id. Required. + :vartype id: str + :ivar access_policy: The access policy. + :vartype access_policy: ~azure.storage.fileshare._generated.models.AccessPolicy + """ + + id: str = rest_field( + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "Id", "text": False, "unwrapped": False}, + deserializer=_xml_deser_str, + ) + """A unique id. Required.""" + access_policy: Optional["_models.AccessPolicy"] = rest_field( + name="accessPolicy", + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "AccessPolicy", "text": False, "unwrapped": False}, + ) + """The access policy.""" + + _xml = {"attribute": False, "name": "SignedIdentifier", "text": False, "unwrapped": False} + + @overload + def __init__( + self, + *, + id: str, # pylint: disable=redefined-builtin + access_policy: Optional["_models.AccessPolicy"] = None, + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: + """ + :param mapping: raw JSON to initialize the model. + :type mapping: Mapping[str, Any] + """ + + def __init__(self, *args: Any, **kwargs: Any) -> None: + super().__init__(*args, **kwargs) + + +class SignedIdentifiers(_Model): + """Represents an array of signed identifiers. + + :ivar items_property: The array of signed identifiers. Required. + :vartype items_property: ~azure.storage.fileshare._generated.models.SignedIdentifier + """ + + items_property: list["_models.SignedIdentifier"] = rest_field( + name="items", + visibility=["read", "create", "update", "delete", "query"], + xml={ + "attribute": False, + "itemsName": "SignedIdentifier", + "name": "SignedIdentifier", + "text": False, + "unwrapped": True, + }, + original_tsp_name="items", + ) + """The array of signed identifiers. Required.""" + + _xml = {"attribute": False, "name": "SignedIdentifiers", "text": False, "unwrapped": False} + + @overload + def __init__( + self, + *, + items_property: list["_models.SignedIdentifier"], + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: + """ + :param mapping: raw JSON to initialize the model. + :type mapping: Mapping[str, Any] + """ + + def __init__(self, *args: Any, **kwargs: Any) -> None: + super().__init__(*args, **kwargs) + + +class SmbMultichannel(_Model): + """Settings for SMB multichannel. + + :ivar enabled: If SMB multichannel is enabled. + :vartype enabled: bool + """ + + enabled: Optional[bool] = rest_field( + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "Enabled", "text": False, "unwrapped": False}, + deserializer=_xml_deser_bool, + ) + """If SMB multichannel is enabled.""" + + _xml = {"attribute": False, "name": "Multichannel", "text": False, "unwrapped": False} + + @overload + def __init__( + self, + *, + enabled: Optional[bool] = None, + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: + """ + :param mapping: raw JSON to initialize the model. + :type mapping: Mapping[str, Any] + """ + + def __init__(self, *args: Any, **kwargs: Any) -> None: + super().__init__(*args, **kwargs) + + +class StorageServiceProperties(_Model): + """Storage service properties. + + :ivar hour_metrics: A summary of request statistics grouped by API in hourly aggregates for + files. + :vartype hour_metrics: ~azure.storage.fileshare._generated.models.Metrics + :ivar minute_metrics: A summary of request statistics grouped by API in minute aggregates for + files. + :vartype minute_metrics: ~azure.storage.fileshare._generated.models.Metrics + :ivar protocol: Protocol settings. + :vartype protocol: ~azure.storage.fileshare._generated.models.ShareProtocolSettings + :ivar cors: The set of CORS rules. + :vartype cors: ~azure.storage.fileshare._generated.models.CorsRule + """ + + hour_metrics: Optional["_models.Metrics"] = rest_field( + name="hourMetrics", + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "HourMetrics", "text": False, "unwrapped": False}, + ) + """A summary of request statistics grouped by API in hourly aggregates for files.""" + minute_metrics: Optional["_models.Metrics"] = rest_field( + name="minuteMetrics", + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "MinuteMetrics", "text": False, "unwrapped": False}, + ) + """A summary of request statistics grouped by API in minute aggregates for files.""" + protocol: Optional["_models.ShareProtocolSettings"] = rest_field( + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "ProtocolSettings", "text": False, "unwrapped": False}, + ) + """Protocol settings.""" + cors: Optional[list["_models.CorsRule"]] = rest_field( + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "itemsName": "CorsRule", "name": "Cors", "text": False, "unwrapped": False}, + ) + """The set of CORS rules.""" + + _xml = {"attribute": False, "name": "StorageServiceProperties", "text": False, "unwrapped": False} + + @overload + def __init__( + self, + *, + hour_metrics: Optional["_models.Metrics"] = None, + minute_metrics: Optional["_models.Metrics"] = None, + protocol: Optional["_models.ShareProtocolSettings"] = None, + cors: Optional[list["_models.CorsRule"]] = None, + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: + """ + :param mapping: raw JSON to initialize the model. + :type mapping: Mapping[str, Any] + """ + + def __init__(self, *args: Any, **kwargs: Any) -> None: + super().__init__(*args, **kwargs) + + +class StringEncoded(_Model): + """An encoded string value. + + :ivar encoded: Whether the value is encoded. + :vartype encoded: bool + :ivar content: The string content. + :vartype content: str + """ + + encoded: Optional[bool] = rest_field( + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": True, "name": "Encoded", "text": False, "unwrapped": False}, + deserializer=_xml_deser_bool, + ) + """Whether the value is encoded.""" + content: Optional[str] = rest_field( + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "content", "text": True, "unwrapped": False}, + deserializer=_xml_deser_str, + ) + """The string content.""" + + _xml = {"attribute": False, "name": "StringEncoded", "text": False, "unwrapped": False} + + @overload + def __init__( + self, + *, + encoded: Optional[bool] = None, + content: Optional[str] = None, + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: + """ + :param mapping: raw JSON to initialize the model. + :type mapping: Mapping[str, Any] + """ + + def __init__(self, *args: Any, **kwargs: Any) -> None: + super().__init__(*args, **kwargs) + + +class UserDelegationKey(_Model): + """A user delegation key. + + :ivar signed_oid: The Azure Active Directory object ID in GUID format. Required. + :vartype signed_oid: str + :ivar signed_tid: The Azure Active Directory tenant ID in GUID format. Required. + :vartype signed_tid: str + :ivar signed_start: The date-time the key is active. Required. + :vartype signed_start: str + :ivar signed_expiry: The date-time the key expires. Required. + :vartype signed_expiry: str + :ivar signed_service: Abbreviation of the Azure Storage service that accepts the key. Required. + :vartype signed_service: str + :ivar signed_version: The service version that created the key. Required. + :vartype signed_version: str + :ivar signed_delegated_user_tid: The delegated user tenant id in Azure AD. Return if + DelegatedUserTid is specified. + :vartype signed_delegated_user_tid: str + :ivar value: The key as a base64 string. Required. + :vartype value: str + """ + + signed_oid: str = rest_field( + name="signedOid", + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "SignedOid", "text": False, "unwrapped": False}, + deserializer=_xml_deser_str, + ) + """The Azure Active Directory object ID in GUID format. Required.""" + signed_tid: str = rest_field( + name="signedTid", + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "SignedTid", "text": False, "unwrapped": False}, + deserializer=_xml_deser_str, + ) + """The Azure Active Directory tenant ID in GUID format. Required.""" + signed_start: str = rest_field( + name="signedStart", + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "SignedStart", "text": False, "unwrapped": False}, + deserializer=_xml_deser_str, + ) + """The date-time the key is active. Required.""" + signed_expiry: str = rest_field( + name="signedExpiry", + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "SignedExpiry", "text": False, "unwrapped": False}, + deserializer=_xml_deser_str, + ) + """The date-time the key expires. Required.""" + signed_service: str = rest_field( + name="signedService", + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "SignedService", "text": False, "unwrapped": False}, + deserializer=_xml_deser_str, + ) + """Abbreviation of the Azure Storage service that accepts the key. Required.""" + signed_version: str = rest_field( + name="signedVersion", + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "SignedVersion", "text": False, "unwrapped": False}, + deserializer=_xml_deser_str, + ) + """The service version that created the key. Required.""" + signed_delegated_user_tid: Optional[str] = rest_field( + name="signedDelegatedUserTid", + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "SignedDelegatedUserTid", "text": False, "unwrapped": False}, + deserializer=_xml_deser_str, + ) + """The delegated user tenant id in Azure AD. Return if DelegatedUserTid is specified.""" + value: str = rest_field( + visibility=["read", "create", "update", "delete", "query"], + xml={"attribute": False, "name": "Value", "text": False, "unwrapped": False}, + deserializer=_xml_deser_str, + ) + """The key as a base64 string. Required.""" + + _xml = {"attribute": False, "name": "UserDelegationKey", "text": False, "unwrapped": False} + + @overload + def __init__( + self, + *, + signed_oid: str, + signed_tid: str, + signed_start: str, + signed_expiry: str, + signed_service: str, + signed_version: str, + value: str, + signed_delegated_user_tid: Optional[str] = None, + ) -> None: ... + + @overload + def __init__(self, mapping: Mapping[str, Any]) -> None: + """ + :param mapping: raw JSON to initialize the model. + :type mapping: Mapping[str, Any] + """ + + def __init__(self, *args: Any, **kwargs: Any) -> None: + super().__init__(*args, **kwargs) diff --git a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/models/_models_py3.py b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/models/_models_py3.py deleted file mode 100644 index 14572ebc405a..000000000000 --- a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/models/_models_py3.py +++ /dev/null @@ -1,1963 +0,0 @@ -# pylint: disable=too-many-lines -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- - -import datetime -from typing import Any, Optional, TYPE_CHECKING, Union - -from .._utils import serialization as _serialization - -if TYPE_CHECKING: - from .. import models as _models - - -class AccessPolicy(_serialization.Model): - """An Access policy. - - :ivar start: The date-time the policy is active. - :vartype start: str - :ivar expiry: The date-time the policy expires. - :vartype expiry: str - :ivar permission: The permissions for the ACL policy. - :vartype permission: str - """ - - _attribute_map = { - "start": {"key": "Start", "type": "str"}, - "expiry": {"key": "Expiry", "type": "str"}, - "permission": {"key": "Permission", "type": "str"}, - } - - def __init__( - self, - *, - start: Optional[str] = None, - expiry: Optional[str] = None, - permission: Optional[str] = None, - **kwargs: Any - ) -> None: - """ - :keyword start: The date-time the policy is active. - :paramtype start: str - :keyword expiry: The date-time the policy expires. - :paramtype expiry: str - :keyword permission: The permissions for the ACL policy. - :paramtype permission: str - """ - super().__init__(**kwargs) - self.start = start - self.expiry = expiry - self.permission = permission - - -class ClearRange(_serialization.Model): - """ClearRange. - - All required parameters must be populated in order to send to server. - - :ivar start: Required. - :vartype start: int - :ivar end: Required. - :vartype end: int - """ - - _validation = { - "start": {"required": True}, - "end": {"required": True}, - } - - _attribute_map = { - "start": {"key": "Start", "type": "int", "xml": {"name": "Start"}}, - "end": {"key": "End", "type": "int", "xml": {"name": "End"}}, - } - _xml_map = {"name": "ClearRange"} - - def __init__(self, *, start: int, end: int, **kwargs: Any) -> None: - """ - :keyword start: Required. - :paramtype start: int - :keyword end: Required. - :paramtype end: int - """ - super().__init__(**kwargs) - self.start = start - self.end = end - - -class CopyFileSmbInfo(_serialization.Model): - """Parameter group. - - :ivar file_attributes: Specifies either the option to copy file attributes from a source - file(source) to a target file or a list of attributes to set on a target file. - :vartype file_attributes: str - :ivar file_creation_time: Specifies either the option to copy file creation time from a source - file(source) to a target file or a time value in ISO 8601 format to set as creation time on a - target file. - :vartype file_creation_time: str - :ivar file_last_write_time: Specifies either the option to copy file last write time from a - source file(source) to a target file or a time value in ISO 8601 format to set as last write - time on a target file. - :vartype file_last_write_time: str - :ivar file_change_time: Specifies either the option to copy file last write time from a source - file(source) to a target file or a time value in ISO 8601 format to set as last write time on a - target file. - :vartype file_change_time: str - :ivar file_permission_copy_mode: Specifies the option to copy file security descriptor from - source file or to set it using the value which is defined by the header value of - x-ms-file-permission or x-ms-file-permission-key. Known values are: "source" and "override". - :vartype file_permission_copy_mode: str or - ~azure.storage.fileshare.models.PermissionCopyModeType - :ivar ignore_read_only: Specifies the option to overwrite the target file if it already exists - and has read-only attribute set. - :vartype ignore_read_only: bool - :ivar set_archive_attribute: Specifies the option to set archive attribute on a target file. - True means archive attribute will be set on a target file despite attribute overrides or a - source file state. - :vartype set_archive_attribute: bool - """ - - _attribute_map = { - "file_attributes": {"key": "fileAttributes", "type": "str"}, - "file_creation_time": {"key": "fileCreationTime", "type": "str"}, - "file_last_write_time": {"key": "fileLastWriteTime", "type": "str"}, - "file_change_time": {"key": "fileChangeTime", "type": "str"}, - "file_permission_copy_mode": {"key": "filePermissionCopyMode", "type": "str"}, - "ignore_read_only": {"key": "ignoreReadOnly", "type": "bool"}, - "set_archive_attribute": {"key": "setArchiveAttribute", "type": "bool"}, - } - - def __init__( - self, - *, - file_attributes: Optional[str] = None, - file_creation_time: Optional[str] = None, - file_last_write_time: Optional[str] = None, - file_change_time: Optional[str] = None, - file_permission_copy_mode: Optional[Union[str, "_models.PermissionCopyModeType"]] = None, - ignore_read_only: Optional[bool] = None, - set_archive_attribute: Optional[bool] = None, - **kwargs: Any - ) -> None: - """ - :keyword file_attributes: Specifies either the option to copy file attributes from a source - file(source) to a target file or a list of attributes to set on a target file. - :paramtype file_attributes: str - :keyword file_creation_time: Specifies either the option to copy file creation time from a - source file(source) to a target file or a time value in ISO 8601 format to set as creation time - on a target file. - :paramtype file_creation_time: str - :keyword file_last_write_time: Specifies either the option to copy file last write time from a - source file(source) to a target file or a time value in ISO 8601 format to set as last write - time on a target file. - :paramtype file_last_write_time: str - :keyword file_change_time: Specifies either the option to copy file last write time from a - source file(source) to a target file or a time value in ISO 8601 format to set as last write - time on a target file. - :paramtype file_change_time: str - :keyword file_permission_copy_mode: Specifies the option to copy file security descriptor from - source file or to set it using the value which is defined by the header value of - x-ms-file-permission or x-ms-file-permission-key. Known values are: "source" and "override". - :paramtype file_permission_copy_mode: str or - ~azure.storage.fileshare.models.PermissionCopyModeType - :keyword ignore_read_only: Specifies the option to overwrite the target file if it already - exists and has read-only attribute set. - :paramtype ignore_read_only: bool - :keyword set_archive_attribute: Specifies the option to set archive attribute on a target file. - True means archive attribute will be set on a target file despite attribute overrides or a - source file state. - :paramtype set_archive_attribute: bool - """ - super().__init__(**kwargs) - self.file_attributes = file_attributes - self.file_creation_time = file_creation_time - self.file_last_write_time = file_last_write_time - self.file_change_time = file_change_time - self.file_permission_copy_mode = file_permission_copy_mode - self.ignore_read_only = ignore_read_only - self.set_archive_attribute = set_archive_attribute - - -class CorsRule(_serialization.Model): - """CORS is an HTTP feature that enables a web application running under one domain to access - resources in another domain. Web browsers implement a security restriction known as same-origin - policy that prevents a web page from calling APIs in a different domain; CORS provides a secure - way to allow one domain (the origin domain) to call APIs in another domain. - - All required parameters must be populated in order to send to server. - - :ivar allowed_origins: The origin domains that are permitted to make a request against the - storage service via CORS. The origin domain is the domain from which the request originates. - Note that the origin must be an exact case-sensitive match with the origin that the user age - sends to the service. You can also use the wildcard character '*' to allow all origin domains - to make requests via CORS. Required. - :vartype allowed_origins: str - :ivar allowed_methods: The methods (HTTP request verbs) that the origin domain may use for a - CORS request. (comma separated). Required. - :vartype allowed_methods: str - :ivar allowed_headers: The request headers that the origin domain may specify on the CORS - request. Required. - :vartype allowed_headers: str - :ivar exposed_headers: The response headers that may be sent in the response to the CORS - request and exposed by the browser to the request issuer. Required. - :vartype exposed_headers: str - :ivar max_age_in_seconds: The maximum amount time that a browser should cache the preflight - OPTIONS request. Required. - :vartype max_age_in_seconds: int - """ - - _validation = { - "allowed_origins": {"required": True}, - "allowed_methods": {"required": True}, - "allowed_headers": {"required": True}, - "exposed_headers": {"required": True}, - "max_age_in_seconds": {"required": True, "minimum": 0}, - } - - _attribute_map = { - "allowed_origins": {"key": "AllowedOrigins", "type": "str"}, - "allowed_methods": {"key": "AllowedMethods", "type": "str"}, - "allowed_headers": {"key": "AllowedHeaders", "type": "str"}, - "exposed_headers": {"key": "ExposedHeaders", "type": "str"}, - "max_age_in_seconds": {"key": "MaxAgeInSeconds", "type": "int"}, - } - - def __init__( - self, - *, - allowed_origins: str, - allowed_methods: str, - allowed_headers: str, - exposed_headers: str, - max_age_in_seconds: int, - **kwargs: Any - ) -> None: - """ - :keyword allowed_origins: The origin domains that are permitted to make a request against the - storage service via CORS. The origin domain is the domain from which the request originates. - Note that the origin must be an exact case-sensitive match with the origin that the user age - sends to the service. You can also use the wildcard character '*' to allow all origin domains - to make requests via CORS. Required. - :paramtype allowed_origins: str - :keyword allowed_methods: The methods (HTTP request verbs) that the origin domain may use for a - CORS request. (comma separated). Required. - :paramtype allowed_methods: str - :keyword allowed_headers: The request headers that the origin domain may specify on the CORS - request. Required. - :paramtype allowed_headers: str - :keyword exposed_headers: The response headers that may be sent in the response to the CORS - request and exposed by the browser to the request issuer. Required. - :paramtype exposed_headers: str - :keyword max_age_in_seconds: The maximum amount time that a browser should cache the preflight - OPTIONS request. Required. - :paramtype max_age_in_seconds: int - """ - super().__init__(**kwargs) - self.allowed_origins = allowed_origins - self.allowed_methods = allowed_methods - self.allowed_headers = allowed_headers - self.exposed_headers = exposed_headers - self.max_age_in_seconds = max_age_in_seconds - - -class DestinationLeaseAccessConditions(_serialization.Model): - """Parameter group. - - :ivar destination_lease_id: Required if the destination file has an active infinite lease. The - lease ID specified for this header must match the lease ID of the destination file. If the - request does not include the lease ID or it is not valid, the operation fails with status code - 412 (Precondition Failed). If this header is specified and the destination file does not - currently have an active lease, the operation will also fail with status code 412 (Precondition - Failed). - :vartype destination_lease_id: str - """ - - _attribute_map = { - "destination_lease_id": {"key": "destinationLeaseId", "type": "str"}, - } - - def __init__(self, *, destination_lease_id: Optional[str] = None, **kwargs: Any) -> None: - """ - :keyword destination_lease_id: Required if the destination file has an active infinite lease. - The lease ID specified for this header must match the lease ID of the destination file. If the - request does not include the lease ID or it is not valid, the operation fails with status code - 412 (Precondition Failed). If this header is specified and the destination file does not - currently have an active lease, the operation will also fail with status code 412 (Precondition - Failed). - :paramtype destination_lease_id: str - """ - super().__init__(**kwargs) - self.destination_lease_id = destination_lease_id - - -class DirectoryItem(_serialization.Model): - """A listed directory item. - - All required parameters must be populated in order to send to server. - - :ivar name: Required. - :vartype name: ~azure.storage.fileshare.models.StringEncoded - :ivar file_id: - :vartype file_id: str - :ivar properties: File properties. - :vartype properties: ~azure.storage.fileshare.models.FileProperty - :ivar attributes: - :vartype attributes: str - :ivar permission_key: - :vartype permission_key: str - """ - - _validation = { - "name": {"required": True}, - } - - _attribute_map = { - "name": {"key": "Name", "type": "StringEncoded"}, - "file_id": {"key": "FileId", "type": "str"}, - "properties": {"key": "Properties", "type": "FileProperty"}, - "attributes": {"key": "Attributes", "type": "str"}, - "permission_key": {"key": "PermissionKey", "type": "str"}, - } - _xml_map = {"name": "Directory"} - - def __init__( - self, - *, - name: "_models.StringEncoded", - file_id: Optional[str] = None, - properties: Optional["_models.FileProperty"] = None, - attributes: Optional[str] = None, - permission_key: Optional[str] = None, - **kwargs: Any - ) -> None: - """ - :keyword name: Required. - :paramtype name: ~azure.storage.fileshare.models.StringEncoded - :keyword file_id: - :paramtype file_id: str - :keyword properties: File properties. - :paramtype properties: ~azure.storage.fileshare.models.FileProperty - :keyword attributes: - :paramtype attributes: str - :keyword permission_key: - :paramtype permission_key: str - """ - super().__init__(**kwargs) - self.name = name - self.file_id = file_id - self.properties = properties - self.attributes = attributes - self.permission_key = permission_key - - -class FileHTTPHeaders(_serialization.Model): - """Parameter group. - - :ivar file_content_type: Sets the MIME content type of the file. The default type is - 'application/octet-stream'. - :vartype file_content_type: str - :ivar file_content_encoding: Specifies which content encodings have been applied to the file. - :vartype file_content_encoding: str - :ivar file_content_language: Specifies the natural languages used by this resource. - :vartype file_content_language: str - :ivar file_cache_control: Sets the file's cache control. The File service stores this value but - does not use or modify it. - :vartype file_cache_control: str - :ivar file_content_md5: Sets the file's MD5 hash. - :vartype file_content_md5: bytes - :ivar file_content_disposition: Sets the file's Content-Disposition header. - :vartype file_content_disposition: str - """ - - _attribute_map = { - "file_content_type": {"key": "fileContentType", "type": "str"}, - "file_content_encoding": {"key": "fileContentEncoding", "type": "str"}, - "file_content_language": {"key": "fileContentLanguage", "type": "str"}, - "file_cache_control": {"key": "fileCacheControl", "type": "str"}, - "file_content_md5": {"key": "fileContentMD5", "type": "bytearray"}, - "file_content_disposition": {"key": "fileContentDisposition", "type": "str"}, - } - - def __init__( - self, - *, - file_content_type: Optional[str] = None, - file_content_encoding: Optional[str] = None, - file_content_language: Optional[str] = None, - file_cache_control: Optional[str] = None, - file_content_md5: Optional[bytes] = None, - file_content_disposition: Optional[str] = None, - **kwargs: Any - ) -> None: - """ - :keyword file_content_type: Sets the MIME content type of the file. The default type is - 'application/octet-stream'. - :paramtype file_content_type: str - :keyword file_content_encoding: Specifies which content encodings have been applied to the - file. - :paramtype file_content_encoding: str - :keyword file_content_language: Specifies the natural languages used by this resource. - :paramtype file_content_language: str - :keyword file_cache_control: Sets the file's cache control. The File service stores this value - but does not use or modify it. - :paramtype file_cache_control: str - :keyword file_content_md5: Sets the file's MD5 hash. - :paramtype file_content_md5: bytes - :keyword file_content_disposition: Sets the file's Content-Disposition header. - :paramtype file_content_disposition: str - """ - super().__init__(**kwargs) - self.file_content_type = file_content_type - self.file_content_encoding = file_content_encoding - self.file_content_language = file_content_language - self.file_cache_control = file_cache_control - self.file_content_md5 = file_content_md5 - self.file_content_disposition = file_content_disposition - - -class FileItem(_serialization.Model): - """A listed file item. - - All required parameters must be populated in order to send to server. - - :ivar name: Required. - :vartype name: ~azure.storage.fileshare.models.StringEncoded - :ivar file_id: - :vartype file_id: str - :ivar properties: File properties. Required. - :vartype properties: ~azure.storage.fileshare.models.FileProperty - :ivar attributes: - :vartype attributes: str - :ivar permission_key: - :vartype permission_key: str - """ - - _validation = { - "name": {"required": True}, - "properties": {"required": True}, - } - - _attribute_map = { - "name": {"key": "Name", "type": "StringEncoded"}, - "file_id": {"key": "FileId", "type": "str"}, - "properties": {"key": "Properties", "type": "FileProperty"}, - "attributes": {"key": "Attributes", "type": "str"}, - "permission_key": {"key": "PermissionKey", "type": "str"}, - } - _xml_map = {"name": "File"} - - def __init__( - self, - *, - name: "_models.StringEncoded", - properties: "_models.FileProperty", - file_id: Optional[str] = None, - attributes: Optional[str] = None, - permission_key: Optional[str] = None, - **kwargs: Any - ) -> None: - """ - :keyword name: Required. - :paramtype name: ~azure.storage.fileshare.models.StringEncoded - :keyword file_id: - :paramtype file_id: str - :keyword properties: File properties. Required. - :paramtype properties: ~azure.storage.fileshare.models.FileProperty - :keyword attributes: - :paramtype attributes: str - :keyword permission_key: - :paramtype permission_key: str - """ - super().__init__(**kwargs) - self.name = name - self.file_id = file_id - self.properties = properties - self.attributes = attributes - self.permission_key = permission_key - - -class FileProperty(_serialization.Model): - """File properties. - - All required parameters must be populated in order to send to server. - - :ivar content_length: Content length of the file. This value may not be up-to-date since an SMB - client may have modified the file locally. The value of Content-Length may not reflect that - fact until the handle is closed or the op-lock is broken. To retrieve current property values, - call Get File Properties. Required. - :vartype content_length: int - :ivar creation_time: - :vartype creation_time: ~datetime.datetime - :ivar last_access_time: - :vartype last_access_time: ~datetime.datetime - :ivar last_write_time: - :vartype last_write_time: ~datetime.datetime - :ivar change_time: - :vartype change_time: ~datetime.datetime - :ivar last_modified: - :vartype last_modified: ~datetime.datetime - :ivar etag: - :vartype etag: str - """ - - _validation = { - "content_length": {"required": True}, - } - - _attribute_map = { - "content_length": {"key": "Content-Length", "type": "int"}, - "creation_time": {"key": "CreationTime", "type": "iso-8601"}, - "last_access_time": {"key": "LastAccessTime", "type": "iso-8601"}, - "last_write_time": {"key": "LastWriteTime", "type": "iso-8601"}, - "change_time": {"key": "ChangeTime", "type": "iso-8601"}, - "last_modified": {"key": "Last-Modified", "type": "rfc-1123"}, - "etag": {"key": "Etag", "type": "str"}, - } - - def __init__( - self, - *, - content_length: int, - creation_time: Optional[datetime.datetime] = None, - last_access_time: Optional[datetime.datetime] = None, - last_write_time: Optional[datetime.datetime] = None, - change_time: Optional[datetime.datetime] = None, - last_modified: Optional[datetime.datetime] = None, - etag: Optional[str] = None, - **kwargs: Any - ) -> None: - """ - :keyword content_length: Content length of the file. This value may not be up-to-date since an - SMB client may have modified the file locally. The value of Content-Length may not reflect that - fact until the handle is closed or the op-lock is broken. To retrieve current property values, - call Get File Properties. Required. - :paramtype content_length: int - :keyword creation_time: - :paramtype creation_time: ~datetime.datetime - :keyword last_access_time: - :paramtype last_access_time: ~datetime.datetime - :keyword last_write_time: - :paramtype last_write_time: ~datetime.datetime - :keyword change_time: - :paramtype change_time: ~datetime.datetime - :keyword last_modified: - :paramtype last_modified: ~datetime.datetime - :keyword etag: - :paramtype etag: str - """ - super().__init__(**kwargs) - self.content_length = content_length - self.creation_time = creation_time - self.last_access_time = last_access_time - self.last_write_time = last_write_time - self.change_time = change_time - self.last_modified = last_modified - self.etag = etag - - -class FileRange(_serialization.Model): - """An Azure Storage file range. - - All required parameters must be populated in order to send to server. - - :ivar start: Start of the range. Required. - :vartype start: int - :ivar end: End of the range. Required. - :vartype end: int - """ - - _validation = { - "start": {"required": True}, - "end": {"required": True}, - } - - _attribute_map = { - "start": {"key": "Start", "type": "int"}, - "end": {"key": "End", "type": "int"}, - } - _xml_map = {"name": "Range"} - - def __init__(self, *, start: int, end: int, **kwargs: Any) -> None: - """ - :keyword start: Start of the range. Required. - :paramtype start: int - :keyword end: End of the range. Required. - :paramtype end: int - """ - super().__init__(**kwargs) - self.start = start - self.end = end - - -class FilesAndDirectoriesListSegment(_serialization.Model): - """Abstract for entries that can be listed from Directory. - - All required parameters must be populated in order to send to server. - - :ivar directory_items: Required. - :vartype directory_items: list[~azure.storage.fileshare.models.DirectoryItem] - :ivar file_items: Required. - :vartype file_items: list[~azure.storage.fileshare.models.FileItem] - """ - - _validation = { - "directory_items": {"required": True}, - "file_items": {"required": True}, - } - - _attribute_map = { - "directory_items": {"key": "DirectoryItems", "type": "[DirectoryItem]", "xml": {"itemsName": "Directory"}}, - "file_items": {"key": "FileItems", "type": "[FileItem]", "xml": {"itemsName": "File"}}, - } - _xml_map = {"name": "Entries"} - - def __init__( - self, *, directory_items: list["_models.DirectoryItem"], file_items: list["_models.FileItem"], **kwargs: Any - ) -> None: - """ - :keyword directory_items: Required. - :paramtype directory_items: list[~azure.storage.fileshare.models.DirectoryItem] - :keyword file_items: Required. - :paramtype file_items: list[~azure.storage.fileshare.models.FileItem] - """ - super().__init__(**kwargs) - self.directory_items = directory_items - self.file_items = file_items - - -class HandleItem(_serialization.Model): - """A listed Azure Storage handle item. - - All required parameters must be populated in order to send to server. - - :ivar handle_id: XSMB service handle ID. Required. - :vartype handle_id: str - :ivar path: Required. - :vartype path: ~azure.storage.fileshare.models.StringEncoded - :ivar file_id: FileId uniquely identifies the file or directory. Required. - :vartype file_id: str - :ivar parent_id: ParentId uniquely identifies the parent directory of the object. - :vartype parent_id: str - :ivar session_id: SMB session ID in context of which the file handle was opened. Required. - :vartype session_id: str - :ivar client_ip: Client IP that opened the handle. Required. - :vartype client_ip: str - :ivar client_name: Name of the client machine where the share is being mounted. Required. - :vartype client_name: str - :ivar open_time: Time when the session that previously opened the handle has last been - reconnected. (UTC). Required. - :vartype open_time: ~datetime.datetime - :ivar last_reconnect_time: Time handle was last connected to (UTC). - :vartype last_reconnect_time: ~datetime.datetime - :ivar access_right_list: - :vartype access_right_list: list[str or ~azure.storage.fileshare.models.AccessRight] - """ - - _validation = { - "handle_id": {"required": True}, - "path": {"required": True}, - "file_id": {"required": True}, - "session_id": {"required": True}, - "client_ip": {"required": True}, - "client_name": {"required": True}, - "open_time": {"required": True}, - } - - _attribute_map = { - "handle_id": {"key": "HandleId", "type": "str"}, - "path": {"key": "Path", "type": "StringEncoded"}, - "file_id": {"key": "FileId", "type": "str"}, - "parent_id": {"key": "ParentId", "type": "str"}, - "session_id": {"key": "SessionId", "type": "str"}, - "client_ip": {"key": "ClientIp", "type": "str"}, - "client_name": {"key": "ClientName", "type": "str"}, - "open_time": {"key": "OpenTime", "type": "rfc-1123"}, - "last_reconnect_time": {"key": "LastReconnectTime", "type": "rfc-1123"}, - "access_right_list": {"key": "AccessRightList", "type": "[str]", "xml": {"wrapped": True}}, - } - _xml_map = {"name": "Handle"} - - def __init__( - self, - *, - handle_id: str, - path: "_models.StringEncoded", - file_id: str, - session_id: str, - client_ip: str, - client_name: str, - open_time: datetime.datetime, - parent_id: Optional[str] = None, - last_reconnect_time: Optional[datetime.datetime] = None, - access_right_list: Optional[list[Union[str, "_models.AccessRight"]]] = None, - **kwargs: Any - ) -> None: - """ - :keyword handle_id: XSMB service handle ID. Required. - :paramtype handle_id: str - :keyword path: Required. - :paramtype path: ~azure.storage.fileshare.models.StringEncoded - :keyword file_id: FileId uniquely identifies the file or directory. Required. - :paramtype file_id: str - :keyword parent_id: ParentId uniquely identifies the parent directory of the object. - :paramtype parent_id: str - :keyword session_id: SMB session ID in context of which the file handle was opened. Required. - :paramtype session_id: str - :keyword client_ip: Client IP that opened the handle. Required. - :paramtype client_ip: str - :keyword client_name: Name of the client machine where the share is being mounted. Required. - :paramtype client_name: str - :keyword open_time: Time when the session that previously opened the handle has last been - reconnected. (UTC). Required. - :paramtype open_time: ~datetime.datetime - :keyword last_reconnect_time: Time handle was last connected to (UTC). - :paramtype last_reconnect_time: ~datetime.datetime - :keyword access_right_list: - :paramtype access_right_list: list[str or ~azure.storage.fileshare.models.AccessRight] - """ - super().__init__(**kwargs) - self.handle_id = handle_id - self.path = path - self.file_id = file_id - self.parent_id = parent_id - self.session_id = session_id - self.client_ip = client_ip - self.client_name = client_name - self.open_time = open_time - self.last_reconnect_time = last_reconnect_time - self.access_right_list = access_right_list - - -class KeyInfo(_serialization.Model): - """Key information. - - All required parameters must be populated in order to send to server. - - :ivar start: The date-time the key is active in ISO 8601 UTC time. - :vartype start: str - :ivar expiry: The date-time the key expires in ISO 8601 UTC time. Required. - :vartype expiry: str - :ivar delegated_user_tid: The delegated user tenant id in Azure AD. - :vartype delegated_user_tid: str - """ - - _validation = { - "expiry": {"required": True}, - } - - _attribute_map = { - "start": {"key": "Start", "type": "str"}, - "expiry": {"key": "Expiry", "type": "str"}, - "delegated_user_tid": {"key": "DelegatedUserTid", "type": "str"}, - } - - def __init__( - self, *, expiry: str, start: Optional[str] = None, delegated_user_tid: Optional[str] = None, **kwargs: Any - ) -> None: - """ - :keyword start: The date-time the key is active in ISO 8601 UTC time. - :paramtype start: str - :keyword expiry: The date-time the key expires in ISO 8601 UTC time. Required. - :paramtype expiry: str - :keyword delegated_user_tid: The delegated user tenant id in Azure AD. - :paramtype delegated_user_tid: str - """ - super().__init__(**kwargs) - self.start = start - self.expiry = expiry - self.delegated_user_tid = delegated_user_tid - - -class LeaseAccessConditions(_serialization.Model): - """Parameter group. - - :ivar lease_id: If specified, the operation only succeeds if the resource's lease is active and - matches this ID. - :vartype lease_id: str - """ - - _attribute_map = { - "lease_id": {"key": "leaseId", "type": "str"}, - } - - def __init__(self, *, lease_id: Optional[str] = None, **kwargs: Any) -> None: - """ - :keyword lease_id: If specified, the operation only succeeds if the resource's lease is active - and matches this ID. - :paramtype lease_id: str - """ - super().__init__(**kwargs) - self.lease_id = lease_id - - -class ListFilesAndDirectoriesSegmentResponse(_serialization.Model): - """An enumeration of directories and files. - - All required parameters must be populated in order to send to server. - - :ivar service_endpoint: Required. - :vartype service_endpoint: str - :ivar share_name: Required. - :vartype share_name: str - :ivar share_snapshot: - :vartype share_snapshot: str - :ivar encoded: - :vartype encoded: bool - :ivar directory_path: Required. - :vartype directory_path: str - :ivar prefix: Required. - :vartype prefix: ~azure.storage.fileshare.models.StringEncoded - :ivar marker: - :vartype marker: str - :ivar max_results: - :vartype max_results: int - :ivar segment: Abstract for entries that can be listed from Directory. Required. - :vartype segment: ~azure.storage.fileshare.models.FilesAndDirectoriesListSegment - :ivar next_marker: Required. - :vartype next_marker: str - :ivar directory_id: - :vartype directory_id: str - """ - - _validation = { - "service_endpoint": {"required": True}, - "share_name": {"required": True}, - "directory_path": {"required": True}, - "prefix": {"required": True}, - "segment": {"required": True}, - "next_marker": {"required": True}, - } - - _attribute_map = { - "service_endpoint": {"key": "ServiceEndpoint", "type": "str", "xml": {"attr": True}}, - "share_name": {"key": "ShareName", "type": "str", "xml": {"attr": True}}, - "share_snapshot": {"key": "ShareSnapshot", "type": "str", "xml": {"attr": True}}, - "encoded": {"key": "Encoded", "type": "bool", "xml": {"attr": True}}, - "directory_path": {"key": "DirectoryPath", "type": "str", "xml": {"attr": True}}, - "prefix": {"key": "Prefix", "type": "StringEncoded"}, - "marker": {"key": "Marker", "type": "str"}, - "max_results": {"key": "MaxResults", "type": "int"}, - "segment": {"key": "Segment", "type": "FilesAndDirectoriesListSegment"}, - "next_marker": {"key": "NextMarker", "type": "str"}, - "directory_id": {"key": "DirectoryId", "type": "str"}, - } - _xml_map = {"name": "EnumerationResults"} - - def __init__( - self, - *, - service_endpoint: str, - share_name: str, - directory_path: str, - prefix: "_models.StringEncoded", - segment: "_models.FilesAndDirectoriesListSegment", - next_marker: str, - share_snapshot: Optional[str] = None, - encoded: Optional[bool] = None, - marker: Optional[str] = None, - max_results: Optional[int] = None, - directory_id: Optional[str] = None, - **kwargs: Any - ) -> None: - """ - :keyword service_endpoint: Required. - :paramtype service_endpoint: str - :keyword share_name: Required. - :paramtype share_name: str - :keyword share_snapshot: - :paramtype share_snapshot: str - :keyword encoded: - :paramtype encoded: bool - :keyword directory_path: Required. - :paramtype directory_path: str - :keyword prefix: Required. - :paramtype prefix: ~azure.storage.fileshare.models.StringEncoded - :keyword marker: - :paramtype marker: str - :keyword max_results: - :paramtype max_results: int - :keyword segment: Abstract for entries that can be listed from Directory. Required. - :paramtype segment: ~azure.storage.fileshare.models.FilesAndDirectoriesListSegment - :keyword next_marker: Required. - :paramtype next_marker: str - :keyword directory_id: - :paramtype directory_id: str - """ - super().__init__(**kwargs) - self.service_endpoint = service_endpoint - self.share_name = share_name - self.share_snapshot = share_snapshot - self.encoded = encoded - self.directory_path = directory_path - self.prefix = prefix - self.marker = marker - self.max_results = max_results - self.segment = segment - self.next_marker = next_marker - self.directory_id = directory_id - - -class ListHandlesResponse(_serialization.Model): - """An enumeration of handles. - - All required parameters must be populated in order to send to server. - - :ivar handle_list: - :vartype handle_list: list[~azure.storage.fileshare.models.HandleItem] - :ivar next_marker: Required. - :vartype next_marker: str - """ - - _validation = { - "next_marker": {"required": True}, - } - - _attribute_map = { - "handle_list": { - "key": "HandleList", - "type": "[HandleItem]", - "xml": {"name": "Entries", "wrapped": True, "itemsName": "Handle"}, - }, - "next_marker": {"key": "NextMarker", "type": "str"}, - } - _xml_map = {"name": "EnumerationResults"} - - def __init__( - self, *, next_marker: str, handle_list: Optional[list["_models.HandleItem"]] = None, **kwargs: Any - ) -> None: - """ - :keyword handle_list: - :paramtype handle_list: list[~azure.storage.fileshare.models.HandleItem] - :keyword next_marker: Required. - :paramtype next_marker: str - """ - super().__init__(**kwargs) - self.handle_list = handle_list - self.next_marker = next_marker - - -class ListSharesResponse(_serialization.Model): - """An enumeration of shares. - - All required parameters must be populated in order to send to server. - - :ivar service_endpoint: Required. - :vartype service_endpoint: str - :ivar prefix: - :vartype prefix: str - :ivar marker: - :vartype marker: str - :ivar max_results: - :vartype max_results: int - :ivar share_items: - :vartype share_items: list[~azure.storage.fileshare.models.ShareItemInternal] - :ivar next_marker: Required. - :vartype next_marker: str - """ - - _validation = { - "service_endpoint": {"required": True}, - "next_marker": {"required": True}, - } - - _attribute_map = { - "service_endpoint": {"key": "ServiceEndpoint", "type": "str", "xml": {"attr": True}}, - "prefix": {"key": "Prefix", "type": "str"}, - "marker": {"key": "Marker", "type": "str"}, - "max_results": {"key": "MaxResults", "type": "int"}, - "share_items": { - "key": "ShareItems", - "type": "[ShareItemInternal]", - "xml": {"name": "Shares", "wrapped": True, "itemsName": "Share"}, - }, - "next_marker": {"key": "NextMarker", "type": "str"}, - } - _xml_map = {"name": "EnumerationResults"} - - def __init__( - self, - *, - service_endpoint: str, - next_marker: str, - prefix: Optional[str] = None, - marker: Optional[str] = None, - max_results: Optional[int] = None, - share_items: Optional[list["_models.ShareItemInternal"]] = None, - **kwargs: Any - ) -> None: - """ - :keyword service_endpoint: Required. - :paramtype service_endpoint: str - :keyword prefix: - :paramtype prefix: str - :keyword marker: - :paramtype marker: str - :keyword max_results: - :paramtype max_results: int - :keyword share_items: - :paramtype share_items: list[~azure.storage.fileshare.models.ShareItemInternal] - :keyword next_marker: Required. - :paramtype next_marker: str - """ - super().__init__(**kwargs) - self.service_endpoint = service_endpoint - self.prefix = prefix - self.marker = marker - self.max_results = max_results - self.share_items = share_items - self.next_marker = next_marker - - -class Metrics(_serialization.Model): - """Storage Analytics metrics for file service. - - All required parameters must be populated in order to send to server. - - :ivar version: The version of Storage Analytics to configure. Required. - :vartype version: str - :ivar enabled: Indicates whether metrics are enabled for the File service. Required. - :vartype enabled: bool - :ivar include_apis: Indicates whether metrics should generate summary statistics for called API - operations. - :vartype include_apis: bool - :ivar retention_policy: The retention policy. - :vartype retention_policy: ~azure.storage.fileshare.models.RetentionPolicy - """ - - _validation = { - "version": {"required": True}, - "enabled": {"required": True}, - } - - _attribute_map = { - "version": {"key": "Version", "type": "str"}, - "enabled": {"key": "Enabled", "type": "bool"}, - "include_apis": {"key": "IncludeAPIs", "type": "bool"}, - "retention_policy": {"key": "RetentionPolicy", "type": "RetentionPolicy"}, - } - - def __init__( - self, - *, - version: str, - enabled: bool, - include_apis: Optional[bool] = None, - retention_policy: Optional["_models.RetentionPolicy"] = None, - **kwargs: Any - ) -> None: - """ - :keyword version: The version of Storage Analytics to configure. Required. - :paramtype version: str - :keyword enabled: Indicates whether metrics are enabled for the File service. Required. - :paramtype enabled: bool - :keyword include_apis: Indicates whether metrics should generate summary statistics for called - API operations. - :paramtype include_apis: bool - :keyword retention_policy: The retention policy. - :paramtype retention_policy: ~azure.storage.fileshare.models.RetentionPolicy - """ - super().__init__(**kwargs) - self.version = version - self.enabled = enabled - self.include_apis = include_apis - self.retention_policy = retention_policy - - -class RetentionPolicy(_serialization.Model): - """The retention policy. - - All required parameters must be populated in order to send to server. - - :ivar enabled: Indicates whether a retention policy is enabled for the File service. If false, - metrics data is retained, and the user is responsible for deleting it. Required. - :vartype enabled: bool - :ivar days: Indicates the number of days that metrics data should be retained. All data older - than this value will be deleted. Metrics data is deleted on a best-effort basis after the - retention period expires. - :vartype days: int - """ - - _validation = { - "enabled": {"required": True}, - "days": {"maximum": 365, "minimum": 1}, - } - - _attribute_map = { - "enabled": {"key": "Enabled", "type": "bool"}, - "days": {"key": "Days", "type": "int"}, - } - - def __init__(self, *, enabled: bool, days: Optional[int] = None, **kwargs: Any) -> None: - """ - :keyword enabled: Indicates whether a retention policy is enabled for the File service. If - false, metrics data is retained, and the user is responsible for deleting it. Required. - :paramtype enabled: bool - :keyword days: Indicates the number of days that metrics data should be retained. All data - older than this value will be deleted. Metrics data is deleted on a best-effort basis after the - retention period expires. - :paramtype days: int - """ - super().__init__(**kwargs) - self.enabled = enabled - self.days = days - - -class ShareFileRangeList(_serialization.Model): - """The list of file ranges. - - :ivar ranges: - :vartype ranges: list[~azure.storage.fileshare.models.FileRange] - :ivar clear_ranges: - :vartype clear_ranges: list[~azure.storage.fileshare.models.ClearRange] - """ - - _attribute_map = { - "ranges": {"key": "Ranges", "type": "[FileRange]", "xml": {"itemsName": "Range"}}, - "clear_ranges": {"key": "ClearRanges", "type": "[ClearRange]", "xml": {"itemsName": "ClearRange"}}, - } - - def __init__( - self, - *, - ranges: Optional[list["_models.FileRange"]] = None, - clear_ranges: Optional[list["_models.ClearRange"]] = None, - **kwargs: Any - ) -> None: - """ - :keyword ranges: - :paramtype ranges: list[~azure.storage.fileshare.models.FileRange] - :keyword clear_ranges: - :paramtype clear_ranges: list[~azure.storage.fileshare.models.ClearRange] - """ - super().__init__(**kwargs) - self.ranges = ranges - self.clear_ranges = clear_ranges - - -class ShareItemInternal(_serialization.Model): - """A listed Azure Storage share item. - - All required parameters must be populated in order to send to server. - - :ivar name: Required. - :vartype name: str - :ivar snapshot: - :vartype snapshot: str - :ivar deleted: - :vartype deleted: bool - :ivar version: - :vartype version: str - :ivar properties: Properties of a share. Required. - :vartype properties: ~azure.storage.fileshare.models.SharePropertiesInternal - :ivar metadata: Dictionary of :code:``. - :vartype metadata: dict[str, str] - """ - - _validation = { - "name": {"required": True}, - "properties": {"required": True}, - } - - _attribute_map = { - "name": {"key": "Name", "type": "str"}, - "snapshot": {"key": "Snapshot", "type": "str"}, - "deleted": {"key": "Deleted", "type": "bool"}, - "version": {"key": "Version", "type": "str"}, - "properties": {"key": "Properties", "type": "SharePropertiesInternal"}, - "metadata": {"key": "Metadata", "type": "{str}"}, - } - _xml_map = {"name": "Share"} - - def __init__( - self, - *, - name: str, - properties: "_models.SharePropertiesInternal", - snapshot: Optional[str] = None, - deleted: Optional[bool] = None, - version: Optional[str] = None, - metadata: Optional[dict[str, str]] = None, - **kwargs: Any - ) -> None: - """ - :keyword name: Required. - :paramtype name: str - :keyword snapshot: - :paramtype snapshot: str - :keyword deleted: - :paramtype deleted: bool - :keyword version: - :paramtype version: str - :keyword properties: Properties of a share. Required. - :paramtype properties: ~azure.storage.fileshare.models.SharePropertiesInternal - :keyword metadata: Dictionary of :code:``. - :paramtype metadata: dict[str, str] - """ - super().__init__(**kwargs) - self.name = name - self.snapshot = snapshot - self.deleted = deleted - self.version = version - self.properties = properties - self.metadata = metadata - - -class ShareNfsSettings(_serialization.Model): - """Settings for SMB protocol. - - :ivar encryption_in_transit: Enable or disable encryption in transit. - :vartype encryption_in_transit: - ~azure.storage.fileshare.models.ShareNfsSettingsEncryptionInTransit - """ - - _attribute_map = { - "encryption_in_transit": {"key": "EncryptionInTransit", "type": "ShareNfsSettingsEncryptionInTransit"}, - } - _xml_map = {"name": "NFS"} - - def __init__( - self, *, encryption_in_transit: Optional["_models.ShareNfsSettingsEncryptionInTransit"] = None, **kwargs: Any - ) -> None: - """ - :keyword encryption_in_transit: Enable or disable encryption in transit. - :paramtype encryption_in_transit: - ~azure.storage.fileshare.models.ShareNfsSettingsEncryptionInTransit - """ - super().__init__(**kwargs) - self.encryption_in_transit = encryption_in_transit - - -class ShareNfsSettingsEncryptionInTransit(_serialization.Model): - """Enable or disable encryption in transit. - - :ivar required: If encryption in transit is required. - :vartype required: bool - """ - - _attribute_map = { - "required": {"key": "Required", "type": "bool"}, - } - - def __init__(self, *, required: Optional[bool] = None, **kwargs: Any) -> None: - """ - :keyword required: If encryption in transit is required. - :paramtype required: bool - """ - super().__init__(**kwargs) - self.required = required - - -class SharePermission(_serialization.Model): - """A permission (a security descriptor) at the share level. - - All required parameters must be populated in order to send to server. - - :ivar permission: The permission in the Security Descriptor Definition Language (SDDL). - Required. - :vartype permission: str - :ivar format: Known values are: "Sddl" and "Binary". - :vartype format: str or ~azure.storage.fileshare.models.FilePermissionFormat - """ - - _validation = { - "permission": {"required": True}, - } - - _attribute_map = { - "permission": {"key": "permission", "type": "str"}, - "format": {"key": "format", "type": "str"}, - } - - def __init__( - self, *, permission: str, format: Optional[Union[str, "_models.FilePermissionFormat"]] = None, **kwargs: Any - ) -> None: - """ - :keyword permission: The permission in the Security Descriptor Definition Language (SDDL). - Required. - :paramtype permission: str - :keyword format: Known values are: "Sddl" and "Binary". - :paramtype format: str or ~azure.storage.fileshare.models.FilePermissionFormat - """ - super().__init__(**kwargs) - self.permission = permission - self.format = format - - -class SharePropertiesInternal(_serialization.Model): - """Properties of a share. - - All required parameters must be populated in order to send to server. - - :ivar last_modified: Required. - :vartype last_modified: ~datetime.datetime - :ivar etag: Required. - :vartype etag: str - :ivar quota: Required. - :vartype quota: int - :ivar provisioned_iops: - :vartype provisioned_iops: int - :ivar provisioned_ingress_m_bps: - :vartype provisioned_ingress_m_bps: int - :ivar provisioned_egress_m_bps: - :vartype provisioned_egress_m_bps: int - :ivar provisioned_bandwidth_mi_bps: - :vartype provisioned_bandwidth_mi_bps: int - :ivar next_allowed_quota_downgrade_time: - :vartype next_allowed_quota_downgrade_time: ~datetime.datetime - :ivar deleted_time: - :vartype deleted_time: ~datetime.datetime - :ivar remaining_retention_days: - :vartype remaining_retention_days: int - :ivar access_tier: - :vartype access_tier: str - :ivar access_tier_change_time: - :vartype access_tier_change_time: ~datetime.datetime - :ivar access_tier_transition_state: - :vartype access_tier_transition_state: str - :ivar lease_status: The current lease status of the share. Known values are: "locked" and - "unlocked". - :vartype lease_status: str or ~azure.storage.fileshare.models.LeaseStatusType - :ivar lease_state: Lease state of the share. Known values are: "available", "leased", - "expired", "breaking", and "broken". - :vartype lease_state: str or ~azure.storage.fileshare.models.LeaseStateType - :ivar lease_duration: When a share is leased, specifies whether the lease is of infinite or - fixed duration. Known values are: "infinite" and "fixed". - :vartype lease_duration: str or ~azure.storage.fileshare.models.LeaseDurationType - :ivar enabled_protocols: - :vartype enabled_protocols: str - :ivar root_squash: Known values are: "NoRootSquash", "RootSquash", and "AllSquash". - :vartype root_squash: str or ~azure.storage.fileshare.models.ShareRootSquash - :ivar enable_snapshot_virtual_directory_access: - :vartype enable_snapshot_virtual_directory_access: bool - :ivar paid_bursting_enabled: - :vartype paid_bursting_enabled: bool - :ivar paid_bursting_max_iops: - :vartype paid_bursting_max_iops: int - :ivar paid_bursting_max_bandwidth_mibps: - :vartype paid_bursting_max_bandwidth_mibps: int - :ivar included_burst_iops: - :vartype included_burst_iops: int - :ivar max_burst_credits_for_iops: - :vartype max_burst_credits_for_iops: int - :ivar next_allowed_provisioned_iops_downgrade_time: - :vartype next_allowed_provisioned_iops_downgrade_time: ~datetime.datetime - :ivar next_allowed_provisioned_bandwidth_downgrade_time: - :vartype next_allowed_provisioned_bandwidth_downgrade_time: ~datetime.datetime - :ivar enable_smb_directory_lease: - :vartype enable_smb_directory_lease: bool - """ - - _validation = { - "last_modified": {"required": True}, - "etag": {"required": True}, - "quota": {"required": True}, - } - - _attribute_map = { - "last_modified": {"key": "Last-Modified", "type": "rfc-1123"}, - "etag": {"key": "Etag", "type": "str"}, - "quota": {"key": "Quota", "type": "int"}, - "provisioned_iops": {"key": "ProvisionedIops", "type": "int"}, - "provisioned_ingress_m_bps": {"key": "ProvisionedIngressMBps", "type": "int"}, - "provisioned_egress_m_bps": {"key": "ProvisionedEgressMBps", "type": "int"}, - "provisioned_bandwidth_mi_bps": {"key": "ProvisionedBandwidthMiBps", "type": "int"}, - "next_allowed_quota_downgrade_time": {"key": "NextAllowedQuotaDowngradeTime", "type": "rfc-1123"}, - "deleted_time": {"key": "DeletedTime", "type": "rfc-1123"}, - "remaining_retention_days": {"key": "RemainingRetentionDays", "type": "int"}, - "access_tier": {"key": "AccessTier", "type": "str"}, - "access_tier_change_time": {"key": "AccessTierChangeTime", "type": "rfc-1123"}, - "access_tier_transition_state": {"key": "AccessTierTransitionState", "type": "str"}, - "lease_status": {"key": "LeaseStatus", "type": "str"}, - "lease_state": {"key": "LeaseState", "type": "str"}, - "lease_duration": {"key": "LeaseDuration", "type": "str"}, - "enabled_protocols": {"key": "EnabledProtocols", "type": "str"}, - "root_squash": {"key": "RootSquash", "type": "str"}, - "enable_snapshot_virtual_directory_access": {"key": "EnableSnapshotVirtualDirectoryAccess", "type": "bool"}, - "paid_bursting_enabled": {"key": "PaidBurstingEnabled", "type": "bool"}, - "paid_bursting_max_iops": {"key": "PaidBurstingMaxIops", "type": "int"}, - "paid_bursting_max_bandwidth_mibps": {"key": "PaidBurstingMaxBandwidthMibps", "type": "int"}, - "included_burst_iops": {"key": "IncludedBurstIops", "type": "int"}, - "max_burst_credits_for_iops": {"key": "MaxBurstCreditsForIops", "type": "int"}, - "next_allowed_provisioned_iops_downgrade_time": { - "key": "NextAllowedProvisionedIopsDowngradeTime", - "type": "rfc-1123", - }, - "next_allowed_provisioned_bandwidth_downgrade_time": { - "key": "NextAllowedProvisionedBandwidthDowngradeTime", - "type": "rfc-1123", - }, - "enable_smb_directory_lease": {"key": "EnableSmbDirectoryLease", "type": "bool"}, - } - - def __init__( # pylint: disable=too-many-locals - self, - *, - last_modified: datetime.datetime, - etag: str, - quota: int, - provisioned_iops: Optional[int] = None, - provisioned_ingress_m_bps: Optional[int] = None, - provisioned_egress_m_bps: Optional[int] = None, - provisioned_bandwidth_mi_bps: Optional[int] = None, - next_allowed_quota_downgrade_time: Optional[datetime.datetime] = None, - deleted_time: Optional[datetime.datetime] = None, - remaining_retention_days: Optional[int] = None, - access_tier: Optional[str] = None, - access_tier_change_time: Optional[datetime.datetime] = None, - access_tier_transition_state: Optional[str] = None, - lease_status: Optional[Union[str, "_models.LeaseStatusType"]] = None, - lease_state: Optional[Union[str, "_models.LeaseStateType"]] = None, - lease_duration: Optional[Union[str, "_models.LeaseDurationType"]] = None, - enabled_protocols: Optional[str] = None, - root_squash: Optional[Union[str, "_models.ShareRootSquash"]] = None, - enable_snapshot_virtual_directory_access: Optional[bool] = None, - paid_bursting_enabled: Optional[bool] = None, - paid_bursting_max_iops: Optional[int] = None, - paid_bursting_max_bandwidth_mibps: Optional[int] = None, - included_burst_iops: Optional[int] = None, - max_burst_credits_for_iops: Optional[int] = None, - next_allowed_provisioned_iops_downgrade_time: Optional[datetime.datetime] = None, - next_allowed_provisioned_bandwidth_downgrade_time: Optional[datetime.datetime] = None, - enable_smb_directory_lease: Optional[bool] = None, - **kwargs: Any - ) -> None: - """ - :keyword last_modified: Required. - :paramtype last_modified: ~datetime.datetime - :keyword etag: Required. - :paramtype etag: str - :keyword quota: Required. - :paramtype quota: int - :keyword provisioned_iops: - :paramtype provisioned_iops: int - :keyword provisioned_ingress_m_bps: - :paramtype provisioned_ingress_m_bps: int - :keyword provisioned_egress_m_bps: - :paramtype provisioned_egress_m_bps: int - :keyword provisioned_bandwidth_mi_bps: - :paramtype provisioned_bandwidth_mi_bps: int - :keyword next_allowed_quota_downgrade_time: - :paramtype next_allowed_quota_downgrade_time: ~datetime.datetime - :keyword deleted_time: - :paramtype deleted_time: ~datetime.datetime - :keyword remaining_retention_days: - :paramtype remaining_retention_days: int - :keyword access_tier: - :paramtype access_tier: str - :keyword access_tier_change_time: - :paramtype access_tier_change_time: ~datetime.datetime - :keyword access_tier_transition_state: - :paramtype access_tier_transition_state: str - :keyword lease_status: The current lease status of the share. Known values are: "locked" and - "unlocked". - :paramtype lease_status: str or ~azure.storage.fileshare.models.LeaseStatusType - :keyword lease_state: Lease state of the share. Known values are: "available", "leased", - "expired", "breaking", and "broken". - :paramtype lease_state: str or ~azure.storage.fileshare.models.LeaseStateType - :keyword lease_duration: When a share is leased, specifies whether the lease is of infinite or - fixed duration. Known values are: "infinite" and "fixed". - :paramtype lease_duration: str or ~azure.storage.fileshare.models.LeaseDurationType - :keyword enabled_protocols: - :paramtype enabled_protocols: str - :keyword root_squash: Known values are: "NoRootSquash", "RootSquash", and "AllSquash". - :paramtype root_squash: str or ~azure.storage.fileshare.models.ShareRootSquash - :keyword enable_snapshot_virtual_directory_access: - :paramtype enable_snapshot_virtual_directory_access: bool - :keyword paid_bursting_enabled: - :paramtype paid_bursting_enabled: bool - :keyword paid_bursting_max_iops: - :paramtype paid_bursting_max_iops: int - :keyword paid_bursting_max_bandwidth_mibps: - :paramtype paid_bursting_max_bandwidth_mibps: int - :keyword included_burst_iops: - :paramtype included_burst_iops: int - :keyword max_burst_credits_for_iops: - :paramtype max_burst_credits_for_iops: int - :keyword next_allowed_provisioned_iops_downgrade_time: - :paramtype next_allowed_provisioned_iops_downgrade_time: ~datetime.datetime - :keyword next_allowed_provisioned_bandwidth_downgrade_time: - :paramtype next_allowed_provisioned_bandwidth_downgrade_time: ~datetime.datetime - :keyword enable_smb_directory_lease: - :paramtype enable_smb_directory_lease: bool - """ - super().__init__(**kwargs) - self.last_modified = last_modified - self.etag = etag - self.quota = quota - self.provisioned_iops = provisioned_iops - self.provisioned_ingress_m_bps = provisioned_ingress_m_bps - self.provisioned_egress_m_bps = provisioned_egress_m_bps - self.provisioned_bandwidth_mi_bps = provisioned_bandwidth_mi_bps - self.next_allowed_quota_downgrade_time = next_allowed_quota_downgrade_time - self.deleted_time = deleted_time - self.remaining_retention_days = remaining_retention_days - self.access_tier = access_tier - self.access_tier_change_time = access_tier_change_time - self.access_tier_transition_state = access_tier_transition_state - self.lease_status = lease_status - self.lease_state = lease_state - self.lease_duration = lease_duration - self.enabled_protocols = enabled_protocols - self.root_squash = root_squash - self.enable_snapshot_virtual_directory_access = enable_snapshot_virtual_directory_access - self.paid_bursting_enabled = paid_bursting_enabled - self.paid_bursting_max_iops = paid_bursting_max_iops - self.paid_bursting_max_bandwidth_mibps = paid_bursting_max_bandwidth_mibps - self.included_burst_iops = included_burst_iops - self.max_burst_credits_for_iops = max_burst_credits_for_iops - self.next_allowed_provisioned_iops_downgrade_time = next_allowed_provisioned_iops_downgrade_time - self.next_allowed_provisioned_bandwidth_downgrade_time = next_allowed_provisioned_bandwidth_downgrade_time - self.enable_smb_directory_lease = enable_smb_directory_lease - - -class ShareProtocolSettings(_serialization.Model): - """Protocol settings. - - :ivar smb: Settings for SMB protocol. - :vartype smb: ~azure.storage.fileshare.models.ShareSmbSettings - :ivar nfs: Settings for NFS protocol. - :vartype nfs: ~azure.storage.fileshare.models.ShareNfsSettings - """ - - _attribute_map = { - "smb": {"key": "Smb", "type": "ShareSmbSettings"}, - "nfs": {"key": "Nfs", "type": "ShareNfsSettings"}, - } - _xml_map = {"name": "ProtocolSettings"} - - def __init__( - self, - *, - smb: Optional["_models.ShareSmbSettings"] = None, - nfs: Optional["_models.ShareNfsSettings"] = None, - **kwargs: Any - ) -> None: - """ - :keyword smb: Settings for SMB protocol. - :paramtype smb: ~azure.storage.fileshare.models.ShareSmbSettings - :keyword nfs: Settings for NFS protocol. - :paramtype nfs: ~azure.storage.fileshare.models.ShareNfsSettings - """ - super().__init__(**kwargs) - self.smb = smb - self.nfs = nfs - - -class ShareSmbSettings(_serialization.Model): - """Settings for SMB protocol. - - :ivar multichannel: Settings for SMB Multichannel. - :vartype multichannel: ~azure.storage.fileshare.models.SmbMultichannel - :ivar encryption_in_transit: Enable or disable encryption in transit. - :vartype encryption_in_transit: - ~azure.storage.fileshare.models.ShareSmbSettingsEncryptionInTransit - """ - - _attribute_map = { - "multichannel": {"key": "Multichannel", "type": "SmbMultichannel"}, - "encryption_in_transit": {"key": "EncryptionInTransit", "type": "ShareSmbSettingsEncryptionInTransit"}, - } - _xml_map = {"name": "SMB"} - - def __init__( - self, - *, - multichannel: Optional["_models.SmbMultichannel"] = None, - encryption_in_transit: Optional["_models.ShareSmbSettingsEncryptionInTransit"] = None, - **kwargs: Any - ) -> None: - """ - :keyword multichannel: Settings for SMB Multichannel. - :paramtype multichannel: ~azure.storage.fileshare.models.SmbMultichannel - :keyword encryption_in_transit: Enable or disable encryption in transit. - :paramtype encryption_in_transit: - ~azure.storage.fileshare.models.ShareSmbSettingsEncryptionInTransit - """ - super().__init__(**kwargs) - self.multichannel = multichannel - self.encryption_in_transit = encryption_in_transit - - -class ShareSmbSettingsEncryptionInTransit(_serialization.Model): - """Enable or disable encryption in transit. - - :ivar required: If encryption in transit is required. - :vartype required: bool - """ - - _attribute_map = { - "required": {"key": "Required", "type": "bool"}, - } - - def __init__(self, *, required: Optional[bool] = None, **kwargs: Any) -> None: - """ - :keyword required: If encryption in transit is required. - :paramtype required: bool - """ - super().__init__(**kwargs) - self.required = required - - -class ShareStats(_serialization.Model): - """Stats for the share. - - All required parameters must be populated in order to send to server. - - :ivar share_usage_bytes: The approximate size of the data stored in bytes. Note that this value - may not include all recently created or recently resized files. Required. - :vartype share_usage_bytes: int - """ - - _validation = { - "share_usage_bytes": {"required": True}, - } - - _attribute_map = { - "share_usage_bytes": {"key": "ShareUsageBytes", "type": "int"}, - } - - def __init__(self, *, share_usage_bytes: int, **kwargs: Any) -> None: - """ - :keyword share_usage_bytes: The approximate size of the data stored in bytes. Note that this - value may not include all recently created or recently resized files. Required. - :paramtype share_usage_bytes: int - """ - super().__init__(**kwargs) - self.share_usage_bytes = share_usage_bytes - - -class SignedIdentifier(_serialization.Model): - """Signed identifier. - - All required parameters must be populated in order to send to server. - - :ivar id: A unique id. Required. - :vartype id: str - :ivar access_policy: The access policy. - :vartype access_policy: ~azure.storage.fileshare.models.AccessPolicy - """ - - _validation = { - "id": {"required": True}, - } - - _attribute_map = { - "id": {"key": "Id", "type": "str"}, - "access_policy": {"key": "AccessPolicy", "type": "AccessPolicy"}, - } - - def __init__( - self, - *, - id: str, # pylint: disable=redefined-builtin - access_policy: Optional["_models.AccessPolicy"] = None, - **kwargs: Any - ) -> None: - """ - :keyword id: A unique id. Required. - :paramtype id: str - :keyword access_policy: The access policy. - :paramtype access_policy: ~azure.storage.fileshare.models.AccessPolicy - """ - super().__init__(**kwargs) - self.id = id - self.access_policy = access_policy - - -class SmbMultichannel(_serialization.Model): - """Settings for SMB multichannel. - - :ivar enabled: If SMB multichannel is enabled. - :vartype enabled: bool - """ - - _attribute_map = { - "enabled": {"key": "Enabled", "type": "bool"}, - } - _xml_map = {"name": "Multichannel"} - - def __init__(self, *, enabled: Optional[bool] = None, **kwargs: Any) -> None: - """ - :keyword enabled: If SMB multichannel is enabled. - :paramtype enabled: bool - """ - super().__init__(**kwargs) - self.enabled = enabled - - -class SourceLeaseAccessConditions(_serialization.Model): - """Parameter group. - - :ivar source_lease_id: Required if the source file has an active infinite lease. - :vartype source_lease_id: str - """ - - _attribute_map = { - "source_lease_id": {"key": "sourceLeaseId", "type": "str"}, - } - - def __init__(self, *, source_lease_id: Optional[str] = None, **kwargs: Any) -> None: - """ - :keyword source_lease_id: Required if the source file has an active infinite lease. - :paramtype source_lease_id: str - """ - super().__init__(**kwargs) - self.source_lease_id = source_lease_id - - -class SourceModifiedAccessConditions(_serialization.Model): - """Parameter group. - - :ivar source_if_match_crc64: Specify the crc64 value to operate only on range with a matching - crc64 checksum. - :vartype source_if_match_crc64: bytes - :ivar source_if_none_match_crc64: Specify the crc64 value to operate only on range without a - matching crc64 checksum. - :vartype source_if_none_match_crc64: bytes - """ - - _attribute_map = { - "source_if_match_crc64": {"key": "sourceIfMatchCrc64", "type": "bytearray"}, - "source_if_none_match_crc64": {"key": "sourceIfNoneMatchCrc64", "type": "bytearray"}, - } - - def __init__( - self, - *, - source_if_match_crc64: Optional[bytes] = None, - source_if_none_match_crc64: Optional[bytes] = None, - **kwargs: Any - ) -> None: - """ - :keyword source_if_match_crc64: Specify the crc64 value to operate only on range with a - matching crc64 checksum. - :paramtype source_if_match_crc64: bytes - :keyword source_if_none_match_crc64: Specify the crc64 value to operate only on range without a - matching crc64 checksum. - :paramtype source_if_none_match_crc64: bytes - """ - super().__init__(**kwargs) - self.source_if_match_crc64 = source_if_match_crc64 - self.source_if_none_match_crc64 = source_if_none_match_crc64 - - -class StorageError(_serialization.Model): - """StorageError. - - :ivar message: - :vartype message: str - :ivar copy_source_status_code: - :vartype copy_source_status_code: int - :ivar copy_source_error_code: - :vartype copy_source_error_code: str - :ivar copy_source_error_message: - :vartype copy_source_error_message: str - :ivar authentication_error_detail: - :vartype authentication_error_detail: str - """ - - _attribute_map = { - "message": {"key": "Message", "type": "str"}, - "copy_source_status_code": {"key": "CopySourceStatusCode", "type": "int"}, - "copy_source_error_code": {"key": "CopySourceErrorCode", "type": "str"}, - "copy_source_error_message": {"key": "CopySourceErrorMessage", "type": "str"}, - "authentication_error_detail": {"key": "AuthenticationErrorDetail", "type": "str"}, - } - - def __init__( - self, - *, - message: Optional[str] = None, - copy_source_status_code: Optional[int] = None, - copy_source_error_code: Optional[str] = None, - copy_source_error_message: Optional[str] = None, - authentication_error_detail: Optional[str] = None, - **kwargs: Any - ) -> None: - """ - :keyword message: - :paramtype message: str - :keyword copy_source_status_code: - :paramtype copy_source_status_code: int - :keyword copy_source_error_code: - :paramtype copy_source_error_code: str - :keyword copy_source_error_message: - :paramtype copy_source_error_message: str - :keyword authentication_error_detail: - :paramtype authentication_error_detail: str - """ - super().__init__(**kwargs) - self.message = message - self.copy_source_status_code = copy_source_status_code - self.copy_source_error_code = copy_source_error_code - self.copy_source_error_message = copy_source_error_message - self.authentication_error_detail = authentication_error_detail - - -class StorageServiceProperties(_serialization.Model): - """Storage service properties. - - :ivar hour_metrics: A summary of request statistics grouped by API in hourly aggregates for - files. - :vartype hour_metrics: ~azure.storage.fileshare.models.Metrics - :ivar minute_metrics: A summary of request statistics grouped by API in minute aggregates for - files. - :vartype minute_metrics: ~azure.storage.fileshare.models.Metrics - :ivar cors: The set of CORS rules. - :vartype cors: list[~azure.storage.fileshare.models.CorsRule] - :ivar protocol: Protocol settings. - :vartype protocol: ~azure.storage.fileshare.models.ShareProtocolSettings - """ - - _attribute_map = { - "hour_metrics": {"key": "HourMetrics", "type": "Metrics"}, - "minute_metrics": {"key": "MinuteMetrics", "type": "Metrics"}, - "cors": {"key": "Cors", "type": "[CorsRule]", "xml": {"wrapped": True}}, - "protocol": {"key": "Protocol", "type": "ShareProtocolSettings"}, - } - - def __init__( - self, - *, - hour_metrics: Optional["_models.Metrics"] = None, - minute_metrics: Optional["_models.Metrics"] = None, - cors: Optional[list["_models.CorsRule"]] = None, - protocol: Optional["_models.ShareProtocolSettings"] = None, - **kwargs: Any - ) -> None: - """ - :keyword hour_metrics: A summary of request statistics grouped by API in hourly aggregates for - files. - :paramtype hour_metrics: ~azure.storage.fileshare.models.Metrics - :keyword minute_metrics: A summary of request statistics grouped by API in minute aggregates - for files. - :paramtype minute_metrics: ~azure.storage.fileshare.models.Metrics - :keyword cors: The set of CORS rules. - :paramtype cors: list[~azure.storage.fileshare.models.CorsRule] - :keyword protocol: Protocol settings. - :paramtype protocol: ~azure.storage.fileshare.models.ShareProtocolSettings - """ - super().__init__(**kwargs) - self.hour_metrics = hour_metrics - self.minute_metrics = minute_metrics - self.cors = cors - self.protocol = protocol - - -class StringEncoded(_serialization.Model): - """StringEncoded. - - :ivar encoded: - :vartype encoded: bool - :ivar content: - :vartype content: str - """ - - _attribute_map = { - "encoded": {"key": "Encoded", "type": "bool", "xml": {"name": "Encoded", "attr": True}}, - "content": {"key": "content", "type": "str", "xml": {"text": True}}, - } - - def __init__(self, *, encoded: Optional[bool] = None, content: Optional[str] = None, **kwargs: Any) -> None: - """ - :keyword encoded: - :paramtype encoded: bool - :keyword content: - :paramtype content: str - """ - super().__init__(**kwargs) - self.encoded = encoded - self.content = content - - -class UserDelegationKey(_serialization.Model): - """A user delegation key. - - All required parameters must be populated in order to send to server. - - :ivar signed_oid: The Azure Active Directory object ID in GUID format. Required. - :vartype signed_oid: str - :ivar signed_tid: The Azure Active Directory tenant ID in GUID format. Required. - :vartype signed_tid: str - :ivar signed_start: The date-time the key is active. Required. - :vartype signed_start: ~datetime.datetime - :ivar signed_expiry: The date-time the key expires. Required. - :vartype signed_expiry: ~datetime.datetime - :ivar signed_service: Abbreviation of the Azure Storage service that accepts the key. Required. - :vartype signed_service: str - :ivar signed_version: The service version that created the key. Required. - :vartype signed_version: str - :ivar signed_delegated_user_tid: The delegated user tenant id in Azure AD. Return if - DelegatedUserTid is specified. - :vartype signed_delegated_user_tid: str - :ivar value: The key as a base64 string. Required. - :vartype value: str - """ - - _validation = { - "signed_oid": {"required": True}, - "signed_tid": {"required": True}, - "signed_start": {"required": True}, - "signed_expiry": {"required": True}, - "signed_service": {"required": True}, - "signed_version": {"required": True}, - "value": {"required": True}, - } - - _attribute_map = { - "signed_oid": {"key": "SignedOid", "type": "str"}, - "signed_tid": {"key": "SignedTid", "type": "str"}, - "signed_start": {"key": "SignedStart", "type": "iso-8601"}, - "signed_expiry": {"key": "SignedExpiry", "type": "iso-8601"}, - "signed_service": {"key": "SignedService", "type": "str"}, - "signed_version": {"key": "SignedVersion", "type": "str"}, - "signed_delegated_user_tid": {"key": "SignedDelegatedUserTid", "type": "str"}, - "value": {"key": "Value", "type": "str"}, - } - - def __init__( - self, - *, - signed_oid: str, - signed_tid: str, - signed_start: datetime.datetime, - signed_expiry: datetime.datetime, - signed_service: str, - signed_version: str, - value: str, - signed_delegated_user_tid: Optional[str] = None, - **kwargs: Any - ) -> None: - """ - :keyword signed_oid: The Azure Active Directory object ID in GUID format. Required. - :paramtype signed_oid: str - :keyword signed_tid: The Azure Active Directory tenant ID in GUID format. Required. - :paramtype signed_tid: str - :keyword signed_start: The date-time the key is active. Required. - :paramtype signed_start: ~datetime.datetime - :keyword signed_expiry: The date-time the key expires. Required. - :paramtype signed_expiry: ~datetime.datetime - :keyword signed_service: Abbreviation of the Azure Storage service that accepts the key. - Required. - :paramtype signed_service: str - :keyword signed_version: The service version that created the key. Required. - :paramtype signed_version: str - :keyword signed_delegated_user_tid: The delegated user tenant id in Azure AD. Return if - DelegatedUserTid is specified. - :paramtype signed_delegated_user_tid: str - :keyword value: The key as a base64 string. Required. - :paramtype value: str - """ - super().__init__(**kwargs) - self.signed_oid = signed_oid - self.signed_tid = signed_tid - self.signed_start = signed_start - self.signed_expiry = signed_expiry - self.signed_service = signed_service - self.signed_version = signed_version - self.signed_delegated_user_tid = signed_delegated_user_tid - self.value = value diff --git a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/models/_patch.py b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/models/_patch.py index f7dd32510333..671984cb89d8 100644 --- a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/models/_patch.py +++ b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/models/_patch.py @@ -1,14 +1,109 @@ -# ------------------------------------ -# Copyright (c) Microsoft Corporation. -# Licensed under the MIT License. -# ------------------------------------ +# pylint: disable=line-too-long,useless-suppression +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# -------------------------------------------------------------------------- """Customize generated code here. Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize """ -from typing import List -__all__: List[str] = [] # Add all objects you want publicly available to users at this package level +# TODO: Waiting for emitter release with perf improvements before editing the patch +import xml.etree.ElementTree as ET +from typing import Any, Callable, Dict, List, Optional + +from .._utils.model_base import Model as _deserialize +from azure.core.serialization import as_attribute_dict + +# --------------------------------------------------------------------------- +# Backcompat shims for public methods that existed on the old autorest msrest models. +# The TypeSpec-generated models inherit from ``_Model`` (a ``MutableMapping`` subclass) which does not +# expose ``serialize``/``deserialize``/``from_dict``/``validate``/ +# ``is_xml_model``/``enable_additional_properties_sending``. Re-adding them +# here preserves backward compatibility for users. +# --------------------------------------------------------------------------- + + +def as_dict( + self, + keep_readonly: bool = True, + key_transformer: Optional[Callable[[str, dict, Any], Any]] = None, # pylint: disable=unused-argument + **kwargs: Any, +) -> Dict[str, Any]: + """Backcompat wrapper that returns Python attribute names (snake_case). + + Accepts both the old autorest signature (``keep_readonly``, + ``key_transformer``) and the new TypeSpec keyword-only + ``exclude_readonly`` parameter. ``key_transformer`` is accepted for + signature compatibility but ignored; keys are always remapped to + Python attribute names. + """ + result = as_attribute_dict(self, exclude_readonly=not keep_readonly) + return result + + +class _ModelBackCompatMixin: + + def serialize(self, keep_readonly: bool = False, **kwargs: Any) -> Dict[str, Any]: + """Backcompat alias for the old autorest ``Model.serialize``. + + Equivalent to ``as_dict(keep_readonly=keep_readonly)`` with REST wire + names (camelCase) as keys — matching what the old autorest serializer + sent to the server. + """ + return as_attribute_dict(self, exclude_readonly=not keep_readonly) + + @classmethod + def deserialize(cls, data: Any, content_type: Optional[str] = None) -> Any: + """Backcompat classmethod for the old autorest ``Model.deserialize``. + + Accepts either a JSON-compatible dict/str or (when ``content_type`` is + XML) an XML string or ``ElementTree.Element``. + """ + if content_type and "xml" in content_type.lower(): + if isinstance(data, (bytes, str)): + data = ET.fromstring(data) # nosec + return cls(data) + return _deserialize(cls, data) + + @classmethod + def from_dict( + cls, + data: Any, + key_extractors: Optional[Callable[[str, dict[str, Any], Any], Any]] = None, # pylint: disable=unused-argument + content_type: Optional[str] = None, + ) -> Any: + """Backcompat classmethod for the old autorest ``Model.from_dict``. + + ``key_extractors`` is accepted for signature compatibility but ignored; + the TypeSpec deserializer always uses REST-key mapping. + """ + if content_type and "xml" in content_type.lower(): + if isinstance(data, (bytes, str)): + data = ET.fromstring(data) # nosec + return cls(data) + return _deserialize(cls, data) + + @classmethod + def enable_additional_properties_sending(cls) -> None: # pylint: disable=unused-argument + """Backcompat no-op for the old autorest ``Model.enable_additional_properties_sending``. + + TypeSpec models already round-trip unknown properties through ``_data``. + """ + return None + + @classmethod + def is_xml_model(cls) -> bool: + """Backcompat classmethod for the old autorest ``Model.is_xml_model``. + + Returns True when the model has an ``_xml`` class attribute (set by the + generator for models that serialize to/from XML). + """ + return bool(getattr(cls, "_xml", None)) + + +__all__: List[str] = [] def patch_sdk(): diff --git a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/operations/__init__.py b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/operations/__init__.py index 092b7efde334..9599ab012f5e 100644 --- a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/operations/__init__.py +++ b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/operations/__init__.py @@ -2,7 +2,7 @@ # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. +# Code generated by Microsoft (R) Python Code Generator. # Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- # pylint: disable=wrong-import-position @@ -12,20 +12,20 @@ if TYPE_CHECKING: from ._patch import * # pylint: disable=unused-wildcard-import -from ._service_operations import ServiceOperations # type: ignore -from ._share_operations import ShareOperations # type: ignore -from ._directory_operations import DirectoryOperations # type: ignore -from ._file_operations import FileOperations # type: ignore +from ._operations import DirectoryOperations # type: ignore +from ._operations import FileOperations # type: ignore +from ._operations import ServiceOperations # type: ignore +from ._operations import ShareOperations # type: ignore from ._patch import __all__ as _patch_all from ._patch import * from ._patch import patch_sdk as _patch_sdk __all__ = [ - "ServiceOperations", - "ShareOperations", "DirectoryOperations", "FileOperations", + "ServiceOperations", + "ShareOperations", ] __all__.extend([p for p in _patch_all if p not in __all__]) # pyright: ignore _patch_sdk() diff --git a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/operations/_directory_operations.py b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/operations/_directory_operations.py deleted file mode 100644 index 157426b206fe..000000000000 --- a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/operations/_directory_operations.py +++ /dev/null @@ -1,1596 +0,0 @@ -# pylint: disable=line-too-long,useless-suppression,too-many-lines -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -from collections.abc import MutableMapping -from typing import Any, Callable, Literal, Optional, TypeVar, Union - -from azure.core import PipelineClient -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.pipeline import PipelineResponse -from azure.core.rest import HttpRequest, HttpResponse -from azure.core.tracing.decorator import distributed_trace -from azure.core.utils import case_insensitive_dict - -from .. import models as _models -from .._configuration import AzureFileStorageConfiguration -from .._utils.serialization import Deserializer, Serializer - -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, dict[str, Any]], Any]] - -_SERIALIZER = Serializer() -_SERIALIZER.client_side_validation = False - - -def build_create_request( - url: str, - *, - version: str, - timeout: Optional[int] = None, - metadata: Optional[dict[str, str]] = None, - file_permission: str = "inherit", - file_permission_format: Optional[Union[str, _models.FilePermissionFormat]] = None, - file_permission_key: Optional[str] = None, - file_attributes: str = "none", - file_creation_time: str = "now", - file_last_write_time: str = "now", - file_change_time: Optional[str] = None, - owner: Optional[str] = None, - group: Optional[str] = None, - file_mode: Optional[str] = None, - file_property_semantics: Optional[Union[str, _models.FilePropertySemantics]] = None, - allow_trailing_dot: Optional[bool] = None, - file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - restype: Literal["directory"] = kwargs.pop("restype", _params.pop("restype", "directory")) - accept = _headers.pop("Accept", "application/xml") - - # Construct URL - _url = kwargs.pop("template_url", "{url}") - path_format_arguments = { - "url": _SERIALIZER.url("url", url, "str", skip_quote=True), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["restype"] = _SERIALIZER.query("restype", restype, "str") - if timeout is not None: - _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int", minimum=0) - - # Construct headers - if allow_trailing_dot is not None: - _headers["x-ms-allow-trailing-dot"] = _SERIALIZER.header("allow_trailing_dot", allow_trailing_dot, "bool") - if metadata is not None: - _headers["x-ms-meta"] = _SERIALIZER.header("metadata", metadata, "{str}") - _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") - if file_permission is not None: - _headers["x-ms-file-permission"] = _SERIALIZER.header("file_permission", file_permission, "str") - if file_permission_format is not None: - _headers["x-ms-file-permission-format"] = _SERIALIZER.header( - "file_permission_format", file_permission_format, "str" - ) - if file_permission_key is not None: - _headers["x-ms-file-permission-key"] = _SERIALIZER.header("file_permission_key", file_permission_key, "str") - if file_attributes is not None: - _headers["x-ms-file-attributes"] = _SERIALIZER.header("file_attributes", file_attributes, "str") - if file_creation_time is not None: - _headers["x-ms-file-creation-time"] = _SERIALIZER.header("file_creation_time", file_creation_time, "str") - if file_last_write_time is not None: - _headers["x-ms-file-last-write-time"] = _SERIALIZER.header("file_last_write_time", file_last_write_time, "str") - if file_change_time is not None: - _headers["x-ms-file-change-time"] = _SERIALIZER.header("file_change_time", file_change_time, "str") - if file_request_intent is not None: - _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") - if owner is not None: - _headers["x-ms-owner"] = _SERIALIZER.header("owner", owner, "str") - if group is not None: - _headers["x-ms-group"] = _SERIALIZER.header("group", group, "str") - if file_mode is not None: - _headers["x-ms-mode"] = _SERIALIZER.header("file_mode", file_mode, "str") - if file_property_semantics is not None: - _headers["x-ms-file-property-semantics"] = _SERIALIZER.header( - "file_property_semantics", file_property_semantics, "str" - ) - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_get_properties_request( - url: str, - *, - version: str, - sharesnapshot: Optional[str] = None, - timeout: Optional[int] = None, - allow_trailing_dot: Optional[bool] = None, - file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - restype: Literal["directory"] = kwargs.pop("restype", _params.pop("restype", "directory")) - accept = _headers.pop("Accept", "application/xml") - - # Construct URL - _url = kwargs.pop("template_url", "{url}") - path_format_arguments = { - "url": _SERIALIZER.url("url", url, "str", skip_quote=True), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["restype"] = _SERIALIZER.query("restype", restype, "str") - if sharesnapshot is not None: - _params["sharesnapshot"] = _SERIALIZER.query("sharesnapshot", sharesnapshot, "str") - if timeout is not None: - _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int", minimum=0) - - # Construct headers - if allow_trailing_dot is not None: - _headers["x-ms-allow-trailing-dot"] = _SERIALIZER.header("allow_trailing_dot", allow_trailing_dot, "bool") - _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") - if file_request_intent is not None: - _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_delete_request( - url: str, - *, - version: str, - timeout: Optional[int] = None, - allow_trailing_dot: Optional[bool] = None, - file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - restype: Literal["directory"] = kwargs.pop("restype", _params.pop("restype", "directory")) - accept = _headers.pop("Accept", "application/xml") - - # Construct URL - _url = kwargs.pop("template_url", "{url}") - path_format_arguments = { - "url": _SERIALIZER.url("url", url, "str", skip_quote=True), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["restype"] = _SERIALIZER.query("restype", restype, "str") - if timeout is not None: - _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int", minimum=0) - - # Construct headers - if allow_trailing_dot is not None: - _headers["x-ms-allow-trailing-dot"] = _SERIALIZER.header("allow_trailing_dot", allow_trailing_dot, "bool") - _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") - if file_request_intent is not None: - _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_set_properties_request( - url: str, - *, - version: str, - timeout: Optional[int] = None, - file_permission: str = "inherit", - file_permission_format: Optional[Union[str, _models.FilePermissionFormat]] = None, - file_permission_key: Optional[str] = None, - file_attributes: str = "none", - file_creation_time: str = "now", - file_last_write_time: str = "now", - file_change_time: Optional[str] = None, - owner: Optional[str] = None, - group: Optional[str] = None, - file_mode: Optional[str] = None, - allow_trailing_dot: Optional[bool] = None, - file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - restype: Literal["directory"] = kwargs.pop("restype", _params.pop("restype", "directory")) - comp: Literal["properties"] = kwargs.pop("comp", _params.pop("comp", "properties")) - accept = _headers.pop("Accept", "application/xml") - - # Construct URL - _url = kwargs.pop("template_url", "{url}") - path_format_arguments = { - "url": _SERIALIZER.url("url", url, "str", skip_quote=True), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["restype"] = _SERIALIZER.query("restype", restype, "str") - _params["comp"] = _SERIALIZER.query("comp", comp, "str") - if timeout is not None: - _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int", minimum=0) - - # Construct headers - _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") - if file_permission is not None: - _headers["x-ms-file-permission"] = _SERIALIZER.header("file_permission", file_permission, "str") - if file_permission_format is not None: - _headers["x-ms-file-permission-format"] = _SERIALIZER.header( - "file_permission_format", file_permission_format, "str" - ) - if file_permission_key is not None: - _headers["x-ms-file-permission-key"] = _SERIALIZER.header("file_permission_key", file_permission_key, "str") - if file_attributes is not None: - _headers["x-ms-file-attributes"] = _SERIALIZER.header("file_attributes", file_attributes, "str") - if file_creation_time is not None: - _headers["x-ms-file-creation-time"] = _SERIALIZER.header("file_creation_time", file_creation_time, "str") - if file_last_write_time is not None: - _headers["x-ms-file-last-write-time"] = _SERIALIZER.header("file_last_write_time", file_last_write_time, "str") - if file_change_time is not None: - _headers["x-ms-file-change-time"] = _SERIALIZER.header("file_change_time", file_change_time, "str") - if allow_trailing_dot is not None: - _headers["x-ms-allow-trailing-dot"] = _SERIALIZER.header("allow_trailing_dot", allow_trailing_dot, "bool") - if file_request_intent is not None: - _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") - if owner is not None: - _headers["x-ms-owner"] = _SERIALIZER.header("owner", owner, "str") - if group is not None: - _headers["x-ms-group"] = _SERIALIZER.header("group", group, "str") - if file_mode is not None: - _headers["x-ms-mode"] = _SERIALIZER.header("file_mode", file_mode, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_set_metadata_request( - url: str, - *, - version: str, - timeout: Optional[int] = None, - metadata: Optional[dict[str, str]] = None, - allow_trailing_dot: Optional[bool] = None, - file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - restype: Literal["directory"] = kwargs.pop("restype", _params.pop("restype", "directory")) - comp: Literal["metadata"] = kwargs.pop("comp", _params.pop("comp", "metadata")) - accept = _headers.pop("Accept", "application/xml") - - # Construct URL - _url = kwargs.pop("template_url", "{url}") - path_format_arguments = { - "url": _SERIALIZER.url("url", url, "str", skip_quote=True), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["restype"] = _SERIALIZER.query("restype", restype, "str") - _params["comp"] = _SERIALIZER.query("comp", comp, "str") - if timeout is not None: - _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int", minimum=0) - - # Construct headers - if metadata is not None: - _headers["x-ms-meta"] = _SERIALIZER.header("metadata", metadata, "{str}") - _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") - if allow_trailing_dot is not None: - _headers["x-ms-allow-trailing-dot"] = _SERIALIZER.header("allow_trailing_dot", allow_trailing_dot, "bool") - if file_request_intent is not None: - _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_list_files_and_directories_segment_request( # pylint: disable=name-too-long - url: str, - *, - version: str, - prefix: Optional[str] = None, - sharesnapshot: Optional[str] = None, - marker: Optional[str] = None, - maxresults: Optional[int] = None, - timeout: Optional[int] = None, - include: Optional[list[Union[str, _models.ListFilesIncludeType]]] = None, - include_extended_info: Optional[bool] = None, - allow_trailing_dot: Optional[bool] = None, - file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - restype: Literal["directory"] = kwargs.pop("restype", _params.pop("restype", "directory")) - comp: Literal["list"] = kwargs.pop("comp", _params.pop("comp", "list")) - accept = _headers.pop("Accept", "application/xml") - - # Construct URL - _url = kwargs.pop("template_url", "{url}") - path_format_arguments = { - "url": _SERIALIZER.url("url", url, "str", skip_quote=True), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["restype"] = _SERIALIZER.query("restype", restype, "str") - _params["comp"] = _SERIALIZER.query("comp", comp, "str") - if prefix is not None: - _params["prefix"] = _SERIALIZER.query("prefix", prefix, "str") - if sharesnapshot is not None: - _params["sharesnapshot"] = _SERIALIZER.query("sharesnapshot", sharesnapshot, "str") - if marker is not None: - _params["marker"] = _SERIALIZER.query("marker", marker, "str") - if maxresults is not None: - _params["maxresults"] = _SERIALIZER.query("maxresults", maxresults, "int", minimum=1) - if timeout is not None: - _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int", minimum=0) - if include is not None: - _params["include"] = _SERIALIZER.query("include", include, "[str]", div=",") - - # Construct headers - _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") - if include_extended_info is not None: - _headers["x-ms-file-extended-info"] = _SERIALIZER.header("include_extended_info", include_extended_info, "bool") - if allow_trailing_dot is not None: - _headers["x-ms-allow-trailing-dot"] = _SERIALIZER.header("allow_trailing_dot", allow_trailing_dot, "bool") - if file_request_intent is not None: - _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_list_handles_request( - url: str, - *, - version: str, - marker: Optional[str] = None, - maxresults: Optional[int] = None, - timeout: Optional[int] = None, - sharesnapshot: Optional[str] = None, - recursive: Optional[bool] = None, - allow_trailing_dot: Optional[bool] = None, - file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - comp: Literal["listhandles"] = kwargs.pop("comp", _params.pop("comp", "listhandles")) - accept = _headers.pop("Accept", "application/xml") - - # Construct URL - _url = kwargs.pop("template_url", "{url}") - path_format_arguments = { - "url": _SERIALIZER.url("url", url, "str", skip_quote=True), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["comp"] = _SERIALIZER.query("comp", comp, "str") - if marker is not None: - _params["marker"] = _SERIALIZER.query("marker", marker, "str") - if maxresults is not None: - _params["maxresults"] = _SERIALIZER.query("maxresults", maxresults, "int", minimum=1) - if timeout is not None: - _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int", minimum=0) - if sharesnapshot is not None: - _params["sharesnapshot"] = _SERIALIZER.query("sharesnapshot", sharesnapshot, "str") - - # Construct headers - if recursive is not None: - _headers["x-ms-recursive"] = _SERIALIZER.header("recursive", recursive, "bool") - _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") - if allow_trailing_dot is not None: - _headers["x-ms-allow-trailing-dot"] = _SERIALIZER.header("allow_trailing_dot", allow_trailing_dot, "bool") - if file_request_intent is not None: - _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_force_close_handles_request( - url: str, - *, - handle_id: str, - version: str, - timeout: Optional[int] = None, - marker: Optional[str] = None, - sharesnapshot: Optional[str] = None, - recursive: Optional[bool] = None, - allow_trailing_dot: Optional[bool] = None, - file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - comp: Literal["forceclosehandles"] = kwargs.pop("comp", _params.pop("comp", "forceclosehandles")) - accept = _headers.pop("Accept", "application/xml") - - # Construct URL - _url = kwargs.pop("template_url", "{url}") - path_format_arguments = { - "url": _SERIALIZER.url("url", url, "str", skip_quote=True), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["comp"] = _SERIALIZER.query("comp", comp, "str") - if timeout is not None: - _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int", minimum=0) - if marker is not None: - _params["marker"] = _SERIALIZER.query("marker", marker, "str") - if sharesnapshot is not None: - _params["sharesnapshot"] = _SERIALIZER.query("sharesnapshot", sharesnapshot, "str") - - # Construct headers - _headers["x-ms-handle-id"] = _SERIALIZER.header("handle_id", handle_id, "str") - if recursive is not None: - _headers["x-ms-recursive"] = _SERIALIZER.header("recursive", recursive, "bool") - _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") - if allow_trailing_dot is not None: - _headers["x-ms-allow-trailing-dot"] = _SERIALIZER.header("allow_trailing_dot", allow_trailing_dot, "bool") - if file_request_intent is not None: - _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_rename_request( # pylint: disable=too-many-locals - url: str, - *, - rename_source: str, - version: str, - timeout: Optional[int] = None, - replace_if_exists: Optional[bool] = None, - ignore_read_only: Optional[bool] = None, - source_lease_id: Optional[str] = None, - destination_lease_id: Optional[str] = None, - file_attributes: Optional[str] = None, - file_creation_time: Optional[str] = None, - file_last_write_time: Optional[str] = None, - file_change_time: Optional[str] = None, - file_permission: str = "inherit", - file_permission_format: Optional[Union[str, _models.FilePermissionFormat]] = None, - file_permission_key: Optional[str] = None, - metadata: Optional[dict[str, str]] = None, - allow_trailing_dot: Optional[bool] = None, - allow_source_trailing_dot: Optional[bool] = None, - file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - restype: Literal["directory"] = kwargs.pop("restype", _params.pop("restype", "directory")) - comp: Literal["rename"] = kwargs.pop("comp", _params.pop("comp", "rename")) - accept = _headers.pop("Accept", "application/xml") - - # Construct URL - _url = kwargs.pop("template_url", "{url}") - path_format_arguments = { - "url": _SERIALIZER.url("url", url, "str", skip_quote=True), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["restype"] = _SERIALIZER.query("restype", restype, "str") - _params["comp"] = _SERIALIZER.query("comp", comp, "str") - if timeout is not None: - _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int", minimum=0) - - # Construct headers - _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") - _headers["x-ms-file-rename-source"] = _SERIALIZER.header("rename_source", rename_source, "str") - if replace_if_exists is not None: - _headers["x-ms-file-rename-replace-if-exists"] = _SERIALIZER.header( - "replace_if_exists", replace_if_exists, "bool" - ) - if ignore_read_only is not None: - _headers["x-ms-file-rename-ignore-readonly"] = _SERIALIZER.header("ignore_read_only", ignore_read_only, "bool") - if source_lease_id is not None: - _headers["x-ms-source-lease-id"] = _SERIALIZER.header("source_lease_id", source_lease_id, "str") - if destination_lease_id is not None: - _headers["x-ms-destination-lease-id"] = _SERIALIZER.header("destination_lease_id", destination_lease_id, "str") - if file_attributes is not None: - _headers["x-ms-file-attributes"] = _SERIALIZER.header("file_attributes", file_attributes, "str") - if file_creation_time is not None: - _headers["x-ms-file-creation-time"] = _SERIALIZER.header("file_creation_time", file_creation_time, "str") - if file_last_write_time is not None: - _headers["x-ms-file-last-write-time"] = _SERIALIZER.header("file_last_write_time", file_last_write_time, "str") - if file_change_time is not None: - _headers["x-ms-file-change-time"] = _SERIALIZER.header("file_change_time", file_change_time, "str") - if file_permission is not None: - _headers["x-ms-file-permission"] = _SERIALIZER.header("file_permission", file_permission, "str") - if file_permission_format is not None: - _headers["x-ms-file-permission-format"] = _SERIALIZER.header( - "file_permission_format", file_permission_format, "str" - ) - if file_permission_key is not None: - _headers["x-ms-file-permission-key"] = _SERIALIZER.header("file_permission_key", file_permission_key, "str") - if metadata is not None: - _headers["x-ms-meta"] = _SERIALIZER.header("metadata", metadata, "{str}") - if allow_trailing_dot is not None: - _headers["x-ms-allow-trailing-dot"] = _SERIALIZER.header("allow_trailing_dot", allow_trailing_dot, "bool") - if allow_source_trailing_dot is not None: - _headers["x-ms-source-allow-trailing-dot"] = _SERIALIZER.header( - "allow_source_trailing_dot", allow_source_trailing_dot, "bool" - ) - if file_request_intent is not None: - _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) - - -class DirectoryOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.storage.fileshare.AzureFileStorage`'s - :attr:`directory` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs) -> None: - input_args = list(args) - self._client: PipelineClient = input_args.pop(0) if input_args else kwargs.pop("client") - self._config: AzureFileStorageConfiguration = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize: Serializer = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize: Deserializer = input_args.pop(0) if input_args else kwargs.pop("deserializer") - - @distributed_trace - def create( # pylint: disable=inconsistent-return-statements,too-many-locals - self, - timeout: Optional[int] = None, - metadata: Optional[dict[str, str]] = None, - file_permission: str = "inherit", - file_permission_format: Optional[Union[str, _models.FilePermissionFormat]] = None, - file_permission_key: Optional[str] = None, - file_attributes: str = "none", - file_creation_time: str = "now", - file_last_write_time: str = "now", - file_change_time: Optional[str] = None, - owner: Optional[str] = None, - group: Optional[str] = None, - file_mode: Optional[str] = None, - file_property_semantics: Optional[Union[str, _models.FilePropertySemantics]] = None, - **kwargs: Any - ) -> None: - """Creates a new directory under the specified share or parent directory. - - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param metadata: A name-value pair to associate with a file storage object. Default value is - None. - :type metadata: dict[str, str] - :param file_permission: If specified the permission (security descriptor) shall be set for the - directory/file. This header can be used if Permission size is <= 8KB, else - x-ms-file-permission-key header shall be used. Default value: Inherit. If SDDL is specified as - input, it must have owner, group and dacl. Note: Only one of the x-ms-file-permission or - x-ms-file-permission-key should be specified. Default value is "inherit". - :type file_permission: str - :param file_permission_format: Optional. Available for version 2023-06-01 and later. Specifies - the format in which the permission is returned. Acceptable values are SDDL or binary. If - x-ms-file-permission-format is unspecified or explicitly set to SDDL, the permission is - returned in SDDL format. If x-ms-file-permission-format is explicitly set to binary, the - permission is returned as a base64 string representing the binary encoding of the permission. - Known values are: "Sddl" and "Binary". Default value is None. - :type file_permission_format: str or ~azure.storage.fileshare.models.FilePermissionFormat - :param file_permission_key: Key of the permission to be set for the directory/file. Note: Only - one of the x-ms-file-permission or x-ms-file-permission-key should be specified. Default value - is None. - :type file_permission_key: str - :param file_attributes: If specified, the provided file attributes shall be set. Default value: - ‘Archive’ for file and ‘Directory’ for directory. ‘None’ can also be specified as default. - Default value is "none". - :type file_attributes: str - :param file_creation_time: Creation time for the file/directory. Default value: Now. Default - value is "now". - :type file_creation_time: str - :param file_last_write_time: Last write time for the file/directory. Default value: Now. - Default value is "now". - :type file_last_write_time: str - :param file_change_time: Change time for the file/directory. Default value: Now. Default value - is None. - :type file_change_time: str - :param owner: Optional, NFS only. The owner of the file or directory. Default value is None. - :type owner: str - :param group: Optional, NFS only. The owning group of the file or directory. Default value is - None. - :type group: str - :param file_mode: Optional, NFS only. The file mode of the file or directory. Default value is - None. - :type file_mode: str - :param file_property_semantics: SMB only, default value is New. New will forcefully add the - ARCHIVE attribute flag and alter the permissions specified in x-ms-file-permission to inherit - missing permissions from the parent. Restore will apply changes without further modification. - Known values are: "New" and "Restore". Default value is None. - :type file_property_semantics: str or ~azure.storage.fileshare.models.FilePropertySemantics - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - restype: Literal["directory"] = kwargs.pop("restype", _params.pop("restype", "directory")) - cls: ClsType[None] = kwargs.pop("cls", None) - - _request = build_create_request( - url=self._config.url, - version=self._config.version, - timeout=timeout, - metadata=metadata, - file_permission=file_permission, - file_permission_format=file_permission_format, - file_permission_key=file_permission_key, - file_attributes=file_attributes, - file_creation_time=file_creation_time, - file_last_write_time=file_last_write_time, - file_change_time=file_change_time, - owner=owner, - group=group, - file_mode=file_mode, - file_property_semantics=file_property_semantics, - allow_trailing_dot=self._config.allow_trailing_dot, - file_request_intent=self._config.file_request_intent, - restype=restype, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [201]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) - response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - response_headers["x-ms-request-server-encrypted"] = self._deserialize( - "bool", response.headers.get("x-ms-request-server-encrypted") - ) - response_headers["x-ms-file-permission-key"] = self._deserialize( - "str", response.headers.get("x-ms-file-permission-key") - ) - response_headers["x-ms-file-attributes"] = self._deserialize( - "str", response.headers.get("x-ms-file-attributes") - ) - response_headers["x-ms-file-creation-time"] = self._deserialize( - "str", response.headers.get("x-ms-file-creation-time") - ) - response_headers["x-ms-file-last-write-time"] = self._deserialize( - "str", response.headers.get("x-ms-file-last-write-time") - ) - response_headers["x-ms-file-change-time"] = self._deserialize( - "str", response.headers.get("x-ms-file-change-time") - ) - response_headers["x-ms-file-id"] = self._deserialize("str", response.headers.get("x-ms-file-id")) - response_headers["x-ms-file-parent-id"] = self._deserialize("str", response.headers.get("x-ms-file-parent-id")) - response_headers["x-ms-mode"] = self._deserialize("str", response.headers.get("x-ms-mode")) - response_headers["x-ms-owner"] = self._deserialize("str", response.headers.get("x-ms-owner")) - response_headers["x-ms-group"] = self._deserialize("str", response.headers.get("x-ms-group")) - response_headers["x-ms-file-file-type"] = self._deserialize("str", response.headers.get("x-ms-file-file-type")) - - if cls: - return cls(pipeline_response, None, response_headers) # type: ignore - - @distributed_trace - def get_properties( # pylint: disable=inconsistent-return-statements - self, sharesnapshot: Optional[str] = None, timeout: Optional[int] = None, **kwargs: Any - ) -> None: - """Returns all system properties for the specified directory, and can also be used to check the - existence of a directory. The data returned does not include the files in the directory or any - subdirectories. - - :param sharesnapshot: The snapshot parameter is an opaque DateTime value that, when present, - specifies the share snapshot to query. Default value is None. - :type sharesnapshot: str - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - restype: Literal["directory"] = kwargs.pop("restype", _params.pop("restype", "directory")) - cls: ClsType[None] = kwargs.pop("cls", None) - - _request = build_get_properties_request( - url=self._config.url, - version=self._config.version, - sharesnapshot=sharesnapshot, - timeout=timeout, - allow_trailing_dot=self._config.allow_trailing_dot, - file_request_intent=self._config.file_request_intent, - restype=restype, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["x-ms-meta"] = self._deserialize("{str}", response.headers.get("x-ms-meta")) - response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) - response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - response_headers["x-ms-server-encrypted"] = self._deserialize( - "bool", response.headers.get("x-ms-server-encrypted") - ) - response_headers["x-ms-file-attributes"] = self._deserialize( - "str", response.headers.get("x-ms-file-attributes") - ) - response_headers["x-ms-file-creation-time"] = self._deserialize( - "str", response.headers.get("x-ms-file-creation-time") - ) - response_headers["x-ms-file-last-write-time"] = self._deserialize( - "str", response.headers.get("x-ms-file-last-write-time") - ) - response_headers["x-ms-file-change-time"] = self._deserialize( - "str", response.headers.get("x-ms-file-change-time") - ) - response_headers["x-ms-file-permission-key"] = self._deserialize( - "str", response.headers.get("x-ms-file-permission-key") - ) - response_headers["x-ms-file-id"] = self._deserialize("str", response.headers.get("x-ms-file-id")) - response_headers["x-ms-file-parent-id"] = self._deserialize("str", response.headers.get("x-ms-file-parent-id")) - response_headers["x-ms-mode"] = self._deserialize("str", response.headers.get("x-ms-mode")) - response_headers["x-ms-owner"] = self._deserialize("str", response.headers.get("x-ms-owner")) - response_headers["x-ms-group"] = self._deserialize("str", response.headers.get("x-ms-group")) - response_headers["x-ms-file-file-type"] = self._deserialize("str", response.headers.get("x-ms-file-file-type")) - - if cls: - return cls(pipeline_response, None, response_headers) # type: ignore - - @distributed_trace - def delete( # pylint: disable=inconsistent-return-statements - self, timeout: Optional[int] = None, **kwargs: Any - ) -> None: - """Removes the specified empty directory. Note that the directory must be empty before it can be - deleted. - - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - restype: Literal["directory"] = kwargs.pop("restype", _params.pop("restype", "directory")) - cls: ClsType[None] = kwargs.pop("cls", None) - - _request = build_delete_request( - url=self._config.url, - version=self._config.version, - timeout=timeout, - allow_trailing_dot=self._config.allow_trailing_dot, - file_request_intent=self._config.file_request_intent, - restype=restype, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [202]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - - if cls: - return cls(pipeline_response, None, response_headers) # type: ignore - - @distributed_trace - def set_properties( # pylint: disable=inconsistent-return-statements,too-many-locals - self, - timeout: Optional[int] = None, - file_permission: str = "inherit", - file_permission_format: Optional[Union[str, _models.FilePermissionFormat]] = None, - file_permission_key: Optional[str] = None, - file_attributes: str = "none", - file_creation_time: str = "now", - file_last_write_time: str = "now", - file_change_time: Optional[str] = None, - owner: Optional[str] = None, - group: Optional[str] = None, - file_mode: Optional[str] = None, - **kwargs: Any - ) -> None: - """Sets properties on the directory. - - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param file_permission: If specified the permission (security descriptor) shall be set for the - directory/file. This header can be used if Permission size is <= 8KB, else - x-ms-file-permission-key header shall be used. Default value: Inherit. If SDDL is specified as - input, it must have owner, group and dacl. Note: Only one of the x-ms-file-permission or - x-ms-file-permission-key should be specified. Default value is "inherit". - :type file_permission: str - :param file_permission_format: Optional. Available for version 2023-06-01 and later. Specifies - the format in which the permission is returned. Acceptable values are SDDL or binary. If - x-ms-file-permission-format is unspecified or explicitly set to SDDL, the permission is - returned in SDDL format. If x-ms-file-permission-format is explicitly set to binary, the - permission is returned as a base64 string representing the binary encoding of the permission. - Known values are: "Sddl" and "Binary". Default value is None. - :type file_permission_format: str or ~azure.storage.fileshare.models.FilePermissionFormat - :param file_permission_key: Key of the permission to be set for the directory/file. Note: Only - one of the x-ms-file-permission or x-ms-file-permission-key should be specified. Default value - is None. - :type file_permission_key: str - :param file_attributes: If specified, the provided file attributes shall be set. Default value: - ‘Archive’ for file and ‘Directory’ for directory. ‘None’ can also be specified as default. - Default value is "none". - :type file_attributes: str - :param file_creation_time: Creation time for the file/directory. Default value: Now. Default - value is "now". - :type file_creation_time: str - :param file_last_write_time: Last write time for the file/directory. Default value: Now. - Default value is "now". - :type file_last_write_time: str - :param file_change_time: Change time for the file/directory. Default value: Now. Default value - is None. - :type file_change_time: str - :param owner: Optional, NFS only. The owner of the file or directory. Default value is None. - :type owner: str - :param group: Optional, NFS only. The owning group of the file or directory. Default value is - None. - :type group: str - :param file_mode: Optional, NFS only. The file mode of the file or directory. Default value is - None. - :type file_mode: str - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - restype: Literal["directory"] = kwargs.pop("restype", _params.pop("restype", "directory")) - comp: Literal["properties"] = kwargs.pop("comp", _params.pop("comp", "properties")) - cls: ClsType[None] = kwargs.pop("cls", None) - - _request = build_set_properties_request( - url=self._config.url, - version=self._config.version, - timeout=timeout, - file_permission=file_permission, - file_permission_format=file_permission_format, - file_permission_key=file_permission_key, - file_attributes=file_attributes, - file_creation_time=file_creation_time, - file_last_write_time=file_last_write_time, - file_change_time=file_change_time, - owner=owner, - group=group, - file_mode=file_mode, - allow_trailing_dot=self._config.allow_trailing_dot, - file_request_intent=self._config.file_request_intent, - restype=restype, - comp=comp, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - response_headers["x-ms-request-server-encrypted"] = self._deserialize( - "bool", response.headers.get("x-ms-request-server-encrypted") - ) - response_headers["x-ms-file-permission-key"] = self._deserialize( - "str", response.headers.get("x-ms-file-permission-key") - ) - response_headers["x-ms-file-attributes"] = self._deserialize( - "str", response.headers.get("x-ms-file-attributes") - ) - response_headers["x-ms-file-creation-time"] = self._deserialize( - "str", response.headers.get("x-ms-file-creation-time") - ) - response_headers["x-ms-file-last-write-time"] = self._deserialize( - "str", response.headers.get("x-ms-file-last-write-time") - ) - response_headers["x-ms-file-change-time"] = self._deserialize( - "str", response.headers.get("x-ms-file-change-time") - ) - response_headers["x-ms-file-id"] = self._deserialize("str", response.headers.get("x-ms-file-id")) - response_headers["x-ms-file-parent-id"] = self._deserialize("str", response.headers.get("x-ms-file-parent-id")) - response_headers["x-ms-mode"] = self._deserialize("str", response.headers.get("x-ms-mode")) - response_headers["x-ms-owner"] = self._deserialize("str", response.headers.get("x-ms-owner")) - response_headers["x-ms-group"] = self._deserialize("str", response.headers.get("x-ms-group")) - - if cls: - return cls(pipeline_response, None, response_headers) # type: ignore - - @distributed_trace - def set_metadata( # pylint: disable=inconsistent-return-statements - self, timeout: Optional[int] = None, metadata: Optional[dict[str, str]] = None, **kwargs: Any - ) -> None: - """Updates user defined metadata for the specified directory. - - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param metadata: A name-value pair to associate with a file storage object. Default value is - None. - :type metadata: dict[str, str] - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - restype: Literal["directory"] = kwargs.pop("restype", _params.pop("restype", "directory")) - comp: Literal["metadata"] = kwargs.pop("comp", _params.pop("comp", "metadata")) - cls: ClsType[None] = kwargs.pop("cls", None) - - _request = build_set_metadata_request( - url=self._config.url, - version=self._config.version, - timeout=timeout, - metadata=metadata, - allow_trailing_dot=self._config.allow_trailing_dot, - file_request_intent=self._config.file_request_intent, - restype=restype, - comp=comp, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - response_headers["x-ms-request-server-encrypted"] = self._deserialize( - "bool", response.headers.get("x-ms-request-server-encrypted") - ) - - if cls: - return cls(pipeline_response, None, response_headers) # type: ignore - - @distributed_trace - def list_files_and_directories_segment( - self, - prefix: Optional[str] = None, - sharesnapshot: Optional[str] = None, - marker: Optional[str] = None, - maxresults: Optional[int] = None, - timeout: Optional[int] = None, - include: Optional[list[Union[str, _models.ListFilesIncludeType]]] = None, - include_extended_info: Optional[bool] = None, - **kwargs: Any - ) -> _models.ListFilesAndDirectoriesSegmentResponse: - """Returns a list of files or directories under the specified share or directory. It lists the - contents only for a single level of the directory hierarchy. - - :param prefix: Filters the results to return only entries whose name begins with the specified - prefix. Default value is None. - :type prefix: str - :param sharesnapshot: The snapshot parameter is an opaque DateTime value that, when present, - specifies the share snapshot to query. Default value is None. - :type sharesnapshot: str - :param marker: A string value that identifies the portion of the list to be returned with the - next list operation. The operation returns a marker value within the response body if the list - returned was not complete. The marker value may then be used in a subsequent call to request - the next set of list items. The marker value is opaque to the client. Default value is None. - :type marker: str - :param maxresults: Specifies the maximum number of entries to return. If the request does not - specify maxresults, or specifies a value greater than 5,000, the server will return up to 5,000 - items. Default value is None. - :type maxresults: int - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param include: Include this parameter to specify one or more datasets to include in the - response. Default value is None. - :type include: list[str or ~azure.storage.fileshare.models.ListFilesIncludeType] - :param include_extended_info: Include extended information. Default value is None. - :type include_extended_info: bool - :return: ListFilesAndDirectoriesSegmentResponse or the result of cls(response) - :rtype: ~azure.storage.fileshare.models.ListFilesAndDirectoriesSegmentResponse - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - restype: Literal["directory"] = kwargs.pop("restype", _params.pop("restype", "directory")) - comp: Literal["list"] = kwargs.pop("comp", _params.pop("comp", "list")) - cls: ClsType[_models.ListFilesAndDirectoriesSegmentResponse] = kwargs.pop("cls", None) - - _request = build_list_files_and_directories_segment_request( - url=self._config.url, - version=self._config.version, - prefix=prefix, - sharesnapshot=sharesnapshot, - marker=marker, - maxresults=maxresults, - timeout=timeout, - include=include, - include_extended_info=include_extended_info, - allow_trailing_dot=self._config.allow_trailing_dot, - file_request_intent=self._config.file_request_intent, - restype=restype, - comp=comp, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["Content-Type"] = self._deserialize("str", response.headers.get("Content-Type")) - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - - deserialized = self._deserialize("ListFilesAndDirectoriesSegmentResponse", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def list_handles( - self, - marker: Optional[str] = None, - maxresults: Optional[int] = None, - timeout: Optional[int] = None, - sharesnapshot: Optional[str] = None, - recursive: Optional[bool] = None, - **kwargs: Any - ) -> _models.ListHandlesResponse: - """Lists handles for directory. - - :param marker: A string value that identifies the portion of the list to be returned with the - next list operation. The operation returns a marker value within the response body if the list - returned was not complete. The marker value may then be used in a subsequent call to request - the next set of list items. The marker value is opaque to the client. Default value is None. - :type marker: str - :param maxresults: Specifies the maximum number of entries to return. If the request does not - specify maxresults, or specifies a value greater than 5,000, the server will return up to 5,000 - items. Default value is None. - :type maxresults: int - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param sharesnapshot: The snapshot parameter is an opaque DateTime value that, when present, - specifies the share snapshot to query. Default value is None. - :type sharesnapshot: str - :param recursive: Specifies operation should apply to the directory specified in the URI, its - files, its subdirectories and their files. Default value is None. - :type recursive: bool - :return: ListHandlesResponse or the result of cls(response) - :rtype: ~azure.storage.fileshare.models.ListHandlesResponse - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - comp: Literal["listhandles"] = kwargs.pop("comp", _params.pop("comp", "listhandles")) - cls: ClsType[_models.ListHandlesResponse] = kwargs.pop("cls", None) - - _request = build_list_handles_request( - url=self._config.url, - version=self._config.version, - marker=marker, - maxresults=maxresults, - timeout=timeout, - sharesnapshot=sharesnapshot, - recursive=recursive, - allow_trailing_dot=self._config.allow_trailing_dot, - file_request_intent=self._config.file_request_intent, - comp=comp, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["Content-Type"] = self._deserialize("str", response.headers.get("Content-Type")) - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - - deserialized = self._deserialize("ListHandlesResponse", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def force_close_handles( # pylint: disable=inconsistent-return-statements - self, - handle_id: str, - timeout: Optional[int] = None, - marker: Optional[str] = None, - sharesnapshot: Optional[str] = None, - recursive: Optional[bool] = None, - **kwargs: Any - ) -> None: - """Closes all handles open for given directory. - - :param handle_id: Specifies handle ID opened on the file or directory to be closed. Asterisk - (‘*’) is a wildcard that specifies all handles. Required. - :type handle_id: str - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param marker: A string value that identifies the portion of the list to be returned with the - next list operation. The operation returns a marker value within the response body if the list - returned was not complete. The marker value may then be used in a subsequent call to request - the next set of list items. The marker value is opaque to the client. Default value is None. - :type marker: str - :param sharesnapshot: The snapshot parameter is an opaque DateTime value that, when present, - specifies the share snapshot to query. Default value is None. - :type sharesnapshot: str - :param recursive: Specifies operation should apply to the directory specified in the URI, its - files, its subdirectories and their files. Default value is None. - :type recursive: bool - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - comp: Literal["forceclosehandles"] = kwargs.pop("comp", _params.pop("comp", "forceclosehandles")) - cls: ClsType[None] = kwargs.pop("cls", None) - - _request = build_force_close_handles_request( - url=self._config.url, - handle_id=handle_id, - version=self._config.version, - timeout=timeout, - marker=marker, - sharesnapshot=sharesnapshot, - recursive=recursive, - allow_trailing_dot=self._config.allow_trailing_dot, - file_request_intent=self._config.file_request_intent, - comp=comp, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - response_headers["x-ms-marker"] = self._deserialize("str", response.headers.get("x-ms-marker")) - response_headers["x-ms-number-of-handles-closed"] = self._deserialize( - "int", response.headers.get("x-ms-number-of-handles-closed") - ) - response_headers["x-ms-number-of-handles-failed"] = self._deserialize( - "int", response.headers.get("x-ms-number-of-handles-failed") - ) - - if cls: - return cls(pipeline_response, None, response_headers) # type: ignore - - @distributed_trace - def rename( # pylint: disable=inconsistent-return-statements,too-many-locals - self, - rename_source: str, - timeout: Optional[int] = None, - replace_if_exists: Optional[bool] = None, - ignore_read_only: Optional[bool] = None, - file_permission: str = "inherit", - file_permission_format: Optional[Union[str, _models.FilePermissionFormat]] = None, - file_permission_key: Optional[str] = None, - metadata: Optional[dict[str, str]] = None, - source_lease_access_conditions: Optional[_models.SourceLeaseAccessConditions] = None, - destination_lease_access_conditions: Optional[_models.DestinationLeaseAccessConditions] = None, - copy_file_smb_info: Optional[_models.CopyFileSmbInfo] = None, - **kwargs: Any - ) -> None: - """Renames a directory. - - :param rename_source: Required. Specifies the URI-style path of the source file, up to 2 KB in - length. Required. - :type rename_source: str - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param replace_if_exists: Optional. A boolean value for if the destination file already exists, - whether this request will overwrite the file or not. If true, the rename will succeed and will - overwrite the destination file. If not provided or if false and the destination file does - exist, the request will not overwrite the destination file. If provided and the destination - file doesn’t exist, the rename will succeed. Note: This value does not override the - x-ms-file-copy-ignore-read-only header value. Default value is None. - :type replace_if_exists: bool - :param ignore_read_only: Optional. A boolean value that specifies whether the ReadOnly - attribute on a preexisting destination file should be respected. If true, the rename will - succeed, otherwise, a previous file at the destination with the ReadOnly attribute set will - cause the rename to fail. Default value is None. - :type ignore_read_only: bool - :param file_permission: If specified the permission (security descriptor) shall be set for the - directory/file. This header can be used if Permission size is <= 8KB, else - x-ms-file-permission-key header shall be used. Default value: Inherit. If SDDL is specified as - input, it must have owner, group and dacl. Note: Only one of the x-ms-file-permission or - x-ms-file-permission-key should be specified. Default value is "inherit". - :type file_permission: str - :param file_permission_format: Optional. Available for version 2023-06-01 and later. Specifies - the format in which the permission is returned. Acceptable values are SDDL or binary. If - x-ms-file-permission-format is unspecified or explicitly set to SDDL, the permission is - returned in SDDL format. If x-ms-file-permission-format is explicitly set to binary, the - permission is returned as a base64 string representing the binary encoding of the permission. - Known values are: "Sddl" and "Binary". Default value is None. - :type file_permission_format: str or ~azure.storage.fileshare.models.FilePermissionFormat - :param file_permission_key: Key of the permission to be set for the directory/file. Note: Only - one of the x-ms-file-permission or x-ms-file-permission-key should be specified. Default value - is None. - :type file_permission_key: str - :param metadata: A name-value pair to associate with a file storage object. Default value is - None. - :type metadata: dict[str, str] - :param source_lease_access_conditions: Parameter group. Default value is None. - :type source_lease_access_conditions: - ~azure.storage.fileshare.models.SourceLeaseAccessConditions - :param destination_lease_access_conditions: Parameter group. Default value is None. - :type destination_lease_access_conditions: - ~azure.storage.fileshare.models.DestinationLeaseAccessConditions - :param copy_file_smb_info: Parameter group. Default value is None. - :type copy_file_smb_info: ~azure.storage.fileshare.models.CopyFileSmbInfo - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - restype: Literal["directory"] = kwargs.pop("restype", _params.pop("restype", "directory")) - comp: Literal["rename"] = kwargs.pop("comp", _params.pop("comp", "rename")) - cls: ClsType[None] = kwargs.pop("cls", None) - - _source_lease_id = None - _destination_lease_id = None - _file_attributes = None - _file_creation_time = None - _file_last_write_time = None - _file_change_time = None - if source_lease_access_conditions is not None: - _source_lease_id = source_lease_access_conditions.source_lease_id - if destination_lease_access_conditions is not None: - _destination_lease_id = destination_lease_access_conditions.destination_lease_id - if copy_file_smb_info is not None: - _file_attributes = copy_file_smb_info.file_attributes - _file_change_time = copy_file_smb_info.file_change_time - _file_creation_time = copy_file_smb_info.file_creation_time - _file_last_write_time = copy_file_smb_info.file_last_write_time - - _request = build_rename_request( - url=self._config.url, - rename_source=rename_source, - version=self._config.version, - timeout=timeout, - replace_if_exists=replace_if_exists, - ignore_read_only=ignore_read_only, - source_lease_id=_source_lease_id, - destination_lease_id=_destination_lease_id, - file_attributes=_file_attributes, - file_creation_time=_file_creation_time, - file_last_write_time=_file_last_write_time, - file_change_time=_file_change_time, - file_permission=file_permission, - file_permission_format=file_permission_format, - file_permission_key=file_permission_key, - metadata=metadata, - allow_trailing_dot=self._config.allow_trailing_dot, - allow_source_trailing_dot=self._config.allow_source_trailing_dot, - file_request_intent=self._config.file_request_intent, - restype=restype, - comp=comp, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) - response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - response_headers["x-ms-request-server-encrypted"] = self._deserialize( - "bool", response.headers.get("x-ms-request-server-encrypted") - ) - response_headers["x-ms-file-permission-key"] = self._deserialize( - "str", response.headers.get("x-ms-file-permission-key") - ) - response_headers["x-ms-file-attributes"] = self._deserialize( - "str", response.headers.get("x-ms-file-attributes") - ) - response_headers["x-ms-file-creation-time"] = self._deserialize( - "str", response.headers.get("x-ms-file-creation-time") - ) - response_headers["x-ms-file-last-write-time"] = self._deserialize( - "str", response.headers.get("x-ms-file-last-write-time") - ) - response_headers["x-ms-file-change-time"] = self._deserialize( - "str", response.headers.get("x-ms-file-change-time") - ) - response_headers["x-ms-file-id"] = self._deserialize("str", response.headers.get("x-ms-file-id")) - response_headers["x-ms-file-parent-id"] = self._deserialize("str", response.headers.get("x-ms-file-parent-id")) - - if cls: - return cls(pipeline_response, None, response_headers) # type: ignore diff --git a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/operations/_file_operations.py b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/operations/_file_operations.py deleted file mode 100644 index 22ca6948e8b4..000000000000 --- a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/operations/_file_operations.py +++ /dev/null @@ -1,3865 +0,0 @@ -# pylint: disable=line-too-long,useless-suppression,too-many-lines -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -from collections.abc import MutableMapping -from typing import Any, Callable, IO, Iterator, Literal, Optional, TypeVar, Union - -from azure.core import PipelineClient -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - StreamClosedError, - StreamConsumedError, - map_error, -) -from azure.core.pipeline import PipelineResponse -from azure.core.rest import HttpRequest, HttpResponse -from azure.core.tracing.decorator import distributed_trace -from azure.core.utils import case_insensitive_dict - -from .. import models as _models -from .._configuration import AzureFileStorageConfiguration -from .._utils.serialization import Deserializer, Serializer - -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, dict[str, Any]], Any]] - -_SERIALIZER = Serializer() -_SERIALIZER.client_side_validation = False - - -def build_create_request( # pylint: disable=too-many-locals,too-many-statements,too-many-branches - url: str, - *, - file_content_length: int, - version: str, - timeout: Optional[int] = None, - file_content_type: Optional[str] = None, - file_content_encoding: Optional[str] = None, - file_content_language: Optional[str] = None, - file_cache_control: Optional[str] = None, - file_content_md5: Optional[bytes] = None, - file_content_disposition: Optional[str] = None, - metadata: Optional[dict[str, str]] = None, - file_permission: str = "inherit", - file_permission_format: Optional[Union[str, _models.FilePermissionFormat]] = None, - file_permission_key: Optional[str] = None, - file_attributes: str = "none", - file_creation_time: str = "now", - file_last_write_time: str = "now", - file_change_time: Optional[str] = None, - lease_id: Optional[str] = None, - owner: Optional[str] = None, - group: Optional[str] = None, - file_mode: Optional[str] = None, - nfs_file_type: Optional[Union[str, _models.NfsFileType]] = None, - content_md5: Optional[bytes] = None, - file_property_semantics: Optional[Union[str, _models.FilePropertySemantics]] = None, - content_length: Optional[int] = None, - structured_body_type: Optional[str] = None, - structured_content_length: Optional[int] = None, - content: Optional[IO[bytes]] = None, - allow_trailing_dot: Optional[bool] = None, - file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - file_type_constant: Literal["file"] = kwargs.pop("file_type_constant", _headers.pop("x-ms-type", "file")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - accept = _headers.pop("Accept", "application/xml") - - # Construct URL - _url = kwargs.pop("template_url", "{url}") - path_format_arguments = { - "url": _SERIALIZER.url("url", url, "str", skip_quote=True), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - if timeout is not None: - _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int", minimum=0) - - # Construct headers - if allow_trailing_dot is not None: - _headers["x-ms-allow-trailing-dot"] = _SERIALIZER.header("allow_trailing_dot", allow_trailing_dot, "bool") - _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") - _headers["x-ms-content-length"] = _SERIALIZER.header("file_content_length", file_content_length, "int") - _headers["x-ms-type"] = _SERIALIZER.header("file_type_constant", file_type_constant, "str") - if file_content_type is not None: - _headers["x-ms-content-type"] = _SERIALIZER.header("file_content_type", file_content_type, "str") - if file_content_encoding is not None: - _headers["x-ms-content-encoding"] = _SERIALIZER.header("file_content_encoding", file_content_encoding, "str") - if file_content_language is not None: - _headers["x-ms-content-language"] = _SERIALIZER.header("file_content_language", file_content_language, "str") - if file_cache_control is not None: - _headers["x-ms-cache-control"] = _SERIALIZER.header("file_cache_control", file_cache_control, "str") - if file_content_md5 is not None: - _headers["x-ms-content-md5"] = _SERIALIZER.header("file_content_md5", file_content_md5, "bytearray") - if file_content_disposition is not None: - _headers["x-ms-content-disposition"] = _SERIALIZER.header( - "file_content_disposition", file_content_disposition, "str" - ) - if metadata is not None: - _headers["x-ms-meta"] = _SERIALIZER.header("metadata", metadata, "{str}") - if file_permission is not None: - _headers["x-ms-file-permission"] = _SERIALIZER.header("file_permission", file_permission, "str") - if file_permission_format is not None: - _headers["x-ms-file-permission-format"] = _SERIALIZER.header( - "file_permission_format", file_permission_format, "str" - ) - if file_permission_key is not None: - _headers["x-ms-file-permission-key"] = _SERIALIZER.header("file_permission_key", file_permission_key, "str") - if file_attributes is not None: - _headers["x-ms-file-attributes"] = _SERIALIZER.header("file_attributes", file_attributes, "str") - if file_creation_time is not None: - _headers["x-ms-file-creation-time"] = _SERIALIZER.header("file_creation_time", file_creation_time, "str") - if file_last_write_time is not None: - _headers["x-ms-file-last-write-time"] = _SERIALIZER.header("file_last_write_time", file_last_write_time, "str") - if file_change_time is not None: - _headers["x-ms-file-change-time"] = _SERIALIZER.header("file_change_time", file_change_time, "str") - if lease_id is not None: - _headers["x-ms-lease-id"] = _SERIALIZER.header("lease_id", lease_id, "str") - if file_request_intent is not None: - _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") - if owner is not None: - _headers["x-ms-owner"] = _SERIALIZER.header("owner", owner, "str") - if group is not None: - _headers["x-ms-group"] = _SERIALIZER.header("group", group, "str") - if file_mode is not None: - _headers["x-ms-mode"] = _SERIALIZER.header("file_mode", file_mode, "str") - if nfs_file_type is not None: - _headers["x-ms-file-file-type"] = _SERIALIZER.header("nfs_file_type", nfs_file_type, "str") - if content_md5 is not None: - _headers["Content-MD5"] = _SERIALIZER.header("content_md5", content_md5, "bytearray") - if file_property_semantics is not None: - _headers["x-ms-file-property-semantics"] = _SERIALIZER.header( - "file_property_semantics", file_property_semantics, "str" - ) - if content_length is not None: - _headers["Content-Length"] = _SERIALIZER.header("content_length", content_length, "int") - if structured_body_type is not None: - _headers["x-ms-structured-body"] = _SERIALIZER.header("structured_body_type", structured_body_type, "str") - if structured_content_length is not None: - _headers["x-ms-structured-content-length"] = _SERIALIZER.header( - "structured_content_length", structured_content_length, "int" - ) - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, content=content, **kwargs) - - -def build_download_request( - url: str, - *, - version: str, - timeout: Optional[int] = None, - range: Optional[str] = None, - range_get_content_md5: Optional[bool] = None, - structured_body_type: Optional[str] = None, - lease_id: Optional[str] = None, - allow_trailing_dot: Optional[bool] = None, - file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - accept = _headers.pop("Accept", "application/xml") - - # Construct URL - _url = kwargs.pop("template_url", "{url}") - path_format_arguments = { - "url": _SERIALIZER.url("url", url, "str", skip_quote=True), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - if timeout is not None: - _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int", minimum=0) - - # Construct headers - if allow_trailing_dot is not None: - _headers["x-ms-allow-trailing-dot"] = _SERIALIZER.header("allow_trailing_dot", allow_trailing_dot, "bool") - _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") - if range is not None: - _headers["x-ms-range"] = _SERIALIZER.header("range", range, "str") - if range_get_content_md5 is not None: - _headers["x-ms-range-get-content-md5"] = _SERIALIZER.header( - "range_get_content_md5", range_get_content_md5, "bool" - ) - if structured_body_type is not None: - _headers["x-ms-structured-body"] = _SERIALIZER.header("structured_body_type", structured_body_type, "str") - if lease_id is not None: - _headers["x-ms-lease-id"] = _SERIALIZER.header("lease_id", lease_id, "str") - if file_request_intent is not None: - _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_get_properties_request( - url: str, - *, - version: str, - sharesnapshot: Optional[str] = None, - timeout: Optional[int] = None, - lease_id: Optional[str] = None, - allow_trailing_dot: Optional[bool] = None, - file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - accept = _headers.pop("Accept", "application/xml") - - # Construct URL - _url = kwargs.pop("template_url", "{url}") - path_format_arguments = { - "url": _SERIALIZER.url("url", url, "str", skip_quote=True), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - if sharesnapshot is not None: - _params["sharesnapshot"] = _SERIALIZER.query("sharesnapshot", sharesnapshot, "str") - if timeout is not None: - _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int", minimum=0) - - # Construct headers - if allow_trailing_dot is not None: - _headers["x-ms-allow-trailing-dot"] = _SERIALIZER.header("allow_trailing_dot", allow_trailing_dot, "bool") - _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") - if lease_id is not None: - _headers["x-ms-lease-id"] = _SERIALIZER.header("lease_id", lease_id, "str") - if file_request_intent is not None: - _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="HEAD", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_delete_request( - url: str, - *, - version: str, - timeout: Optional[int] = None, - lease_id: Optional[str] = None, - allow_trailing_dot: Optional[bool] = None, - file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - accept = _headers.pop("Accept", "application/xml") - - # Construct URL - _url = kwargs.pop("template_url", "{url}") - path_format_arguments = { - "url": _SERIALIZER.url("url", url, "str", skip_quote=True), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - if timeout is not None: - _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int", minimum=0) - - # Construct headers - if allow_trailing_dot is not None: - _headers["x-ms-allow-trailing-dot"] = _SERIALIZER.header("allow_trailing_dot", allow_trailing_dot, "bool") - _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") - if lease_id is not None: - _headers["x-ms-lease-id"] = _SERIALIZER.header("lease_id", lease_id, "str") - if file_request_intent is not None: - _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_set_http_headers_request( # pylint: disable=too-many-locals - url: str, - *, - version: str, - timeout: Optional[int] = None, - file_content_length: Optional[int] = None, - file_content_type: Optional[str] = None, - file_content_encoding: Optional[str] = None, - file_content_language: Optional[str] = None, - file_cache_control: Optional[str] = None, - file_content_md5: Optional[bytes] = None, - file_content_disposition: Optional[str] = None, - file_permission: str = "inherit", - file_permission_format: Optional[Union[str, _models.FilePermissionFormat]] = None, - file_permission_key: Optional[str] = None, - file_attributes: str = "none", - file_creation_time: str = "now", - file_last_write_time: str = "now", - file_change_time: Optional[str] = None, - lease_id: Optional[str] = None, - owner: Optional[str] = None, - group: Optional[str] = None, - file_mode: Optional[str] = None, - allow_trailing_dot: Optional[bool] = None, - file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - comp: Literal["properties"] = kwargs.pop("comp", _params.pop("comp", "properties")) - accept = _headers.pop("Accept", "application/xml") - - # Construct URL - _url = kwargs.pop("template_url", "{url}") - path_format_arguments = { - "url": _SERIALIZER.url("url", url, "str", skip_quote=True), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["comp"] = _SERIALIZER.query("comp", comp, "str") - if timeout is not None: - _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int", minimum=0) - - # Construct headers - _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") - if file_content_length is not None: - _headers["x-ms-content-length"] = _SERIALIZER.header("file_content_length", file_content_length, "int") - if file_content_type is not None: - _headers["x-ms-content-type"] = _SERIALIZER.header("file_content_type", file_content_type, "str") - if file_content_encoding is not None: - _headers["x-ms-content-encoding"] = _SERIALIZER.header("file_content_encoding", file_content_encoding, "str") - if file_content_language is not None: - _headers["x-ms-content-language"] = _SERIALIZER.header("file_content_language", file_content_language, "str") - if file_cache_control is not None: - _headers["x-ms-cache-control"] = _SERIALIZER.header("file_cache_control", file_cache_control, "str") - if file_content_md5 is not None: - _headers["x-ms-content-md5"] = _SERIALIZER.header("file_content_md5", file_content_md5, "bytearray") - if file_content_disposition is not None: - _headers["x-ms-content-disposition"] = _SERIALIZER.header( - "file_content_disposition", file_content_disposition, "str" - ) - if file_permission is not None: - _headers["x-ms-file-permission"] = _SERIALIZER.header("file_permission", file_permission, "str") - if file_permission_format is not None: - _headers["x-ms-file-permission-format"] = _SERIALIZER.header( - "file_permission_format", file_permission_format, "str" - ) - if file_permission_key is not None: - _headers["x-ms-file-permission-key"] = _SERIALIZER.header("file_permission_key", file_permission_key, "str") - if file_attributes is not None: - _headers["x-ms-file-attributes"] = _SERIALIZER.header("file_attributes", file_attributes, "str") - if file_creation_time is not None: - _headers["x-ms-file-creation-time"] = _SERIALIZER.header("file_creation_time", file_creation_time, "str") - if file_last_write_time is not None: - _headers["x-ms-file-last-write-time"] = _SERIALIZER.header("file_last_write_time", file_last_write_time, "str") - if file_change_time is not None: - _headers["x-ms-file-change-time"] = _SERIALIZER.header("file_change_time", file_change_time, "str") - if lease_id is not None: - _headers["x-ms-lease-id"] = _SERIALIZER.header("lease_id", lease_id, "str") - if allow_trailing_dot is not None: - _headers["x-ms-allow-trailing-dot"] = _SERIALIZER.header("allow_trailing_dot", allow_trailing_dot, "bool") - if file_request_intent is not None: - _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") - if owner is not None: - _headers["x-ms-owner"] = _SERIALIZER.header("owner", owner, "str") - if group is not None: - _headers["x-ms-group"] = _SERIALIZER.header("group", group, "str") - if file_mode is not None: - _headers["x-ms-mode"] = _SERIALIZER.header("file_mode", file_mode, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_set_metadata_request( - url: str, - *, - version: str, - timeout: Optional[int] = None, - metadata: Optional[dict[str, str]] = None, - lease_id: Optional[str] = None, - allow_trailing_dot: Optional[bool] = None, - file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - comp: Literal["metadata"] = kwargs.pop("comp", _params.pop("comp", "metadata")) - accept = _headers.pop("Accept", "application/xml") - - # Construct URL - _url = kwargs.pop("template_url", "{url}") - path_format_arguments = { - "url": _SERIALIZER.url("url", url, "str", skip_quote=True), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["comp"] = _SERIALIZER.query("comp", comp, "str") - if timeout is not None: - _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int", minimum=0) - - # Construct headers - if metadata is not None: - _headers["x-ms-meta"] = _SERIALIZER.header("metadata", metadata, "{str}") - _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") - if lease_id is not None: - _headers["x-ms-lease-id"] = _SERIALIZER.header("lease_id", lease_id, "str") - if allow_trailing_dot is not None: - _headers["x-ms-allow-trailing-dot"] = _SERIALIZER.header("allow_trailing_dot", allow_trailing_dot, "bool") - if file_request_intent is not None: - _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_acquire_lease_request( - url: str, - *, - version: str, - timeout: Optional[int] = None, - duration: Optional[int] = None, - proposed_lease_id: Optional[str] = None, - request_id_parameter: Optional[str] = None, - allow_trailing_dot: Optional[bool] = None, - file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - comp: Literal["lease"] = kwargs.pop("comp", _params.pop("comp", "lease")) - action: Literal["acquire"] = kwargs.pop("action", _headers.pop("x-ms-lease-action", "acquire")) - accept = _headers.pop("Accept", "application/xml") - - # Construct URL - _url = kwargs.pop("template_url", "{url}") - path_format_arguments = { - "url": _SERIALIZER.url("url", url, "str", skip_quote=True), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["comp"] = _SERIALIZER.query("comp", comp, "str") - if timeout is not None: - _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int", minimum=0) - - # Construct headers - _headers["x-ms-lease-action"] = _SERIALIZER.header("action", action, "str") - if duration is not None: - _headers["x-ms-lease-duration"] = _SERIALIZER.header("duration", duration, "int") - if proposed_lease_id is not None: - _headers["x-ms-proposed-lease-id"] = _SERIALIZER.header("proposed_lease_id", proposed_lease_id, "str") - _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") - if request_id_parameter is not None: - _headers["x-ms-client-request-id"] = _SERIALIZER.header("request_id_parameter", request_id_parameter, "str") - if allow_trailing_dot is not None: - _headers["x-ms-allow-trailing-dot"] = _SERIALIZER.header("allow_trailing_dot", allow_trailing_dot, "bool") - if file_request_intent is not None: - _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_release_lease_request( - url: str, - *, - lease_id: str, - version: str, - timeout: Optional[int] = None, - request_id_parameter: Optional[str] = None, - allow_trailing_dot: Optional[bool] = None, - file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - comp: Literal["lease"] = kwargs.pop("comp", _params.pop("comp", "lease")) - action: Literal["release"] = kwargs.pop("action", _headers.pop("x-ms-lease-action", "release")) - accept = _headers.pop("Accept", "application/xml") - - # Construct URL - _url = kwargs.pop("template_url", "{url}") - path_format_arguments = { - "url": _SERIALIZER.url("url", url, "str", skip_quote=True), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["comp"] = _SERIALIZER.query("comp", comp, "str") - if timeout is not None: - _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int", minimum=0) - - # Construct headers - _headers["x-ms-lease-action"] = _SERIALIZER.header("action", action, "str") - _headers["x-ms-lease-id"] = _SERIALIZER.header("lease_id", lease_id, "str") - _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") - if request_id_parameter is not None: - _headers["x-ms-client-request-id"] = _SERIALIZER.header("request_id_parameter", request_id_parameter, "str") - if allow_trailing_dot is not None: - _headers["x-ms-allow-trailing-dot"] = _SERIALIZER.header("allow_trailing_dot", allow_trailing_dot, "bool") - if file_request_intent is not None: - _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_change_lease_request( - url: str, - *, - lease_id: str, - version: str, - timeout: Optional[int] = None, - proposed_lease_id: Optional[str] = None, - request_id_parameter: Optional[str] = None, - allow_trailing_dot: Optional[bool] = None, - file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - comp: Literal["lease"] = kwargs.pop("comp", _params.pop("comp", "lease")) - action: Literal["change"] = kwargs.pop("action", _headers.pop("x-ms-lease-action", "change")) - accept = _headers.pop("Accept", "application/xml") - - # Construct URL - _url = kwargs.pop("template_url", "{url}") - path_format_arguments = { - "url": _SERIALIZER.url("url", url, "str", skip_quote=True), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["comp"] = _SERIALIZER.query("comp", comp, "str") - if timeout is not None: - _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int", minimum=0) - - # Construct headers - _headers["x-ms-lease-action"] = _SERIALIZER.header("action", action, "str") - _headers["x-ms-lease-id"] = _SERIALIZER.header("lease_id", lease_id, "str") - if proposed_lease_id is not None: - _headers["x-ms-proposed-lease-id"] = _SERIALIZER.header("proposed_lease_id", proposed_lease_id, "str") - _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") - if request_id_parameter is not None: - _headers["x-ms-client-request-id"] = _SERIALIZER.header("request_id_parameter", request_id_parameter, "str") - if allow_trailing_dot is not None: - _headers["x-ms-allow-trailing-dot"] = _SERIALIZER.header("allow_trailing_dot", allow_trailing_dot, "bool") - if file_request_intent is not None: - _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_break_lease_request( - url: str, - *, - version: str, - timeout: Optional[int] = None, - lease_id: Optional[str] = None, - request_id_parameter: Optional[str] = None, - allow_trailing_dot: Optional[bool] = None, - file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - comp: Literal["lease"] = kwargs.pop("comp", _params.pop("comp", "lease")) - action: Literal["break"] = kwargs.pop("action", _headers.pop("x-ms-lease-action", "break")) - accept = _headers.pop("Accept", "application/xml") - - # Construct URL - _url = kwargs.pop("template_url", "{url}") - path_format_arguments = { - "url": _SERIALIZER.url("url", url, "str", skip_quote=True), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["comp"] = _SERIALIZER.query("comp", comp, "str") - if timeout is not None: - _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int", minimum=0) - - # Construct headers - _headers["x-ms-lease-action"] = _SERIALIZER.header("action", action, "str") - if lease_id is not None: - _headers["x-ms-lease-id"] = _SERIALIZER.header("lease_id", lease_id, "str") - _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") - if request_id_parameter is not None: - _headers["x-ms-client-request-id"] = _SERIALIZER.header("request_id_parameter", request_id_parameter, "str") - if allow_trailing_dot is not None: - _headers["x-ms-allow-trailing-dot"] = _SERIALIZER.header("allow_trailing_dot", allow_trailing_dot, "bool") - if file_request_intent is not None: - _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_upload_range_request( - url: str, - *, - range: str, - content_length: int, - version: str, - timeout: Optional[int] = None, - file_range_write: Union[str, _models.FileRangeWriteType] = "update", - content_md5: Optional[bytes] = None, - lease_id: Optional[str] = None, - file_last_written_mode: Optional[Union[str, _models.FileLastWrittenMode]] = None, - structured_body_type: Optional[str] = None, - structured_content_length: Optional[int] = None, - content: Optional[IO[bytes]] = None, - allow_trailing_dot: Optional[bool] = None, - file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - comp: Literal["range"] = kwargs.pop("comp", _params.pop("comp", "range")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - accept = _headers.pop("Accept", "application/xml") - - # Construct URL - _url = kwargs.pop("template_url", "{url}") - path_format_arguments = { - "url": _SERIALIZER.url("url", url, "str", skip_quote=True), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["comp"] = _SERIALIZER.query("comp", comp, "str") - if timeout is not None: - _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int", minimum=0) - - # Construct headers - _headers["x-ms-range"] = _SERIALIZER.header("range", range, "str") - _headers["x-ms-write"] = _SERIALIZER.header("file_range_write", file_range_write, "str") - _headers["Content-Length"] = _SERIALIZER.header("content_length", content_length, "int") - if content_md5 is not None: - _headers["Content-MD5"] = _SERIALIZER.header("content_md5", content_md5, "bytearray") - _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") - if lease_id is not None: - _headers["x-ms-lease-id"] = _SERIALIZER.header("lease_id", lease_id, "str") - if file_last_written_mode is not None: - _headers["x-ms-file-last-write-time"] = _SERIALIZER.header( - "file_last_written_mode", file_last_written_mode, "str" - ) - if allow_trailing_dot is not None: - _headers["x-ms-allow-trailing-dot"] = _SERIALIZER.header("allow_trailing_dot", allow_trailing_dot, "bool") - if file_request_intent is not None: - _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") - if structured_body_type is not None: - _headers["x-ms-structured-body"] = _SERIALIZER.header("structured_body_type", structured_body_type, "str") - if structured_content_length is not None: - _headers["x-ms-structured-content-length"] = _SERIALIZER.header( - "structured_content_length", structured_content_length, "int" - ) - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, content=content, **kwargs) - - -def build_upload_range_from_url_request( - url: str, - *, - range: str, - copy_source: str, - content_length: int, - version: str, - timeout: Optional[int] = None, - source_range: Optional[str] = None, - source_content_crc64: Optional[bytes] = None, - source_if_match_crc64: Optional[bytes] = None, - source_if_none_match_crc64: Optional[bytes] = None, - lease_id: Optional[str] = None, - copy_source_authorization: Optional[str] = None, - file_last_written_mode: Optional[Union[str, _models.FileLastWrittenMode]] = None, - allow_trailing_dot: Optional[bool] = None, - allow_source_trailing_dot: Optional[bool] = None, - file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - comp: Literal["range"] = kwargs.pop("comp", _params.pop("comp", "range")) - file_range_write_from_url: Literal["update"] = kwargs.pop( - "file_range_write_from_url", _headers.pop("x-ms-write", "update") - ) - accept = _headers.pop("Accept", "application/xml") - - # Construct URL - _url = kwargs.pop("template_url", "{url}") - path_format_arguments = { - "url": _SERIALIZER.url("url", url, "str", skip_quote=True), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["comp"] = _SERIALIZER.query("comp", comp, "str") - if timeout is not None: - _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int", minimum=0) - - # Construct headers - _headers["x-ms-range"] = _SERIALIZER.header("range", range, "str") - _headers["x-ms-copy-source"] = _SERIALIZER.header("copy_source", copy_source, "str") - if source_range is not None: - _headers["x-ms-source-range"] = _SERIALIZER.header("source_range", source_range, "str") - _headers["x-ms-write"] = _SERIALIZER.header("file_range_write_from_url", file_range_write_from_url, "str") - _headers["Content-Length"] = _SERIALIZER.header("content_length", content_length, "int") - if source_content_crc64 is not None: - _headers["x-ms-source-content-crc64"] = _SERIALIZER.header( - "source_content_crc64", source_content_crc64, "bytearray" - ) - if source_if_match_crc64 is not None: - _headers["x-ms-source-if-match-crc64"] = _SERIALIZER.header( - "source_if_match_crc64", source_if_match_crc64, "bytearray" - ) - if source_if_none_match_crc64 is not None: - _headers["x-ms-source-if-none-match-crc64"] = _SERIALIZER.header( - "source_if_none_match_crc64", source_if_none_match_crc64, "bytearray" - ) - _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") - if lease_id is not None: - _headers["x-ms-lease-id"] = _SERIALIZER.header("lease_id", lease_id, "str") - if copy_source_authorization is not None: - _headers["x-ms-copy-source-authorization"] = _SERIALIZER.header( - "copy_source_authorization", copy_source_authorization, "str" - ) - if file_last_written_mode is not None: - _headers["x-ms-file-last-write-time"] = _SERIALIZER.header( - "file_last_written_mode", file_last_written_mode, "str" - ) - if allow_trailing_dot is not None: - _headers["x-ms-allow-trailing-dot"] = _SERIALIZER.header("allow_trailing_dot", allow_trailing_dot, "bool") - if allow_source_trailing_dot is not None: - _headers["x-ms-source-allow-trailing-dot"] = _SERIALIZER.header( - "allow_source_trailing_dot", allow_source_trailing_dot, "bool" - ) - if file_request_intent is not None: - _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_get_range_list_request( - url: str, - *, - version: str, - sharesnapshot: Optional[str] = None, - prevsharesnapshot: Optional[str] = None, - timeout: Optional[int] = None, - range: Optional[str] = None, - lease_id: Optional[str] = None, - support_rename: Optional[bool] = None, - allow_trailing_dot: Optional[bool] = None, - file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - comp: Literal["rangelist"] = kwargs.pop("comp", _params.pop("comp", "rangelist")) - accept = _headers.pop("Accept", "application/xml") - - # Construct URL - _url = kwargs.pop("template_url", "{url}") - path_format_arguments = { - "url": _SERIALIZER.url("url", url, "str", skip_quote=True), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["comp"] = _SERIALIZER.query("comp", comp, "str") - if sharesnapshot is not None: - _params["sharesnapshot"] = _SERIALIZER.query("sharesnapshot", sharesnapshot, "str") - if prevsharesnapshot is not None: - _params["prevsharesnapshot"] = _SERIALIZER.query("prevsharesnapshot", prevsharesnapshot, "str") - if timeout is not None: - _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int", minimum=0) - - # Construct headers - _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") - if range is not None: - _headers["x-ms-range"] = _SERIALIZER.header("range", range, "str") - if lease_id is not None: - _headers["x-ms-lease-id"] = _SERIALIZER.header("lease_id", lease_id, "str") - if allow_trailing_dot is not None: - _headers["x-ms-allow-trailing-dot"] = _SERIALIZER.header("allow_trailing_dot", allow_trailing_dot, "bool") - if file_request_intent is not None: - _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") - if support_rename is not None: - _headers["x-ms-file-support-rename"] = _SERIALIZER.header("support_rename", support_rename, "bool") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_start_copy_request( # pylint: disable=too-many-locals - url: str, - *, - copy_source: str, - version: str, - timeout: Optional[int] = None, - metadata: Optional[dict[str, str]] = None, - file_permission: str = "inherit", - file_permission_format: Optional[Union[str, _models.FilePermissionFormat]] = None, - file_permission_key: Optional[str] = None, - file_permission_copy_mode: Optional[Union[str, _models.PermissionCopyModeType]] = None, - ignore_read_only: Optional[bool] = None, - file_attributes: Optional[str] = None, - file_creation_time: Optional[str] = None, - file_last_write_time: Optional[str] = None, - file_change_time: Optional[str] = None, - set_archive_attribute: Optional[bool] = None, - lease_id: Optional[str] = None, - owner: Optional[str] = None, - group: Optional[str] = None, - file_mode: Optional[str] = None, - file_mode_copy_mode: Optional[Union[str, _models.ModeCopyMode]] = None, - file_owner_copy_mode: Optional[Union[str, _models.OwnerCopyMode]] = None, - allow_trailing_dot: Optional[bool] = None, - allow_source_trailing_dot: Optional[bool] = None, - file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - accept = _headers.pop("Accept", "application/xml") - - # Construct URL - _url = kwargs.pop("template_url", "{url}") - path_format_arguments = { - "url": _SERIALIZER.url("url", url, "str", skip_quote=True), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - if timeout is not None: - _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int", minimum=0) - - # Construct headers - _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") - if metadata is not None: - _headers["x-ms-meta"] = _SERIALIZER.header("metadata", metadata, "{str}") - _headers["x-ms-copy-source"] = _SERIALIZER.header("copy_source", copy_source, "str") - if file_permission is not None: - _headers["x-ms-file-permission"] = _SERIALIZER.header("file_permission", file_permission, "str") - if file_permission_format is not None: - _headers["x-ms-file-permission-format"] = _SERIALIZER.header( - "file_permission_format", file_permission_format, "str" - ) - if file_permission_key is not None: - _headers["x-ms-file-permission-key"] = _SERIALIZER.header("file_permission_key", file_permission_key, "str") - if file_permission_copy_mode is not None: - _headers["x-ms-file-permission-copy-mode"] = _SERIALIZER.header( - "file_permission_copy_mode", file_permission_copy_mode, "str" - ) - if ignore_read_only is not None: - _headers["x-ms-file-copy-ignore-readonly"] = _SERIALIZER.header("ignore_read_only", ignore_read_only, "bool") - if file_attributes is not None: - _headers["x-ms-file-attributes"] = _SERIALIZER.header("file_attributes", file_attributes, "str") - if file_creation_time is not None: - _headers["x-ms-file-creation-time"] = _SERIALIZER.header("file_creation_time", file_creation_time, "str") - if file_last_write_time is not None: - _headers["x-ms-file-last-write-time"] = _SERIALIZER.header("file_last_write_time", file_last_write_time, "str") - if file_change_time is not None: - _headers["x-ms-file-change-time"] = _SERIALIZER.header("file_change_time", file_change_time, "str") - if set_archive_attribute is not None: - _headers["x-ms-file-copy-set-archive"] = _SERIALIZER.header( - "set_archive_attribute", set_archive_attribute, "bool" - ) - if lease_id is not None: - _headers["x-ms-lease-id"] = _SERIALIZER.header("lease_id", lease_id, "str") - if allow_trailing_dot is not None: - _headers["x-ms-allow-trailing-dot"] = _SERIALIZER.header("allow_trailing_dot", allow_trailing_dot, "bool") - if allow_source_trailing_dot is not None: - _headers["x-ms-source-allow-trailing-dot"] = _SERIALIZER.header( - "allow_source_trailing_dot", allow_source_trailing_dot, "bool" - ) - if file_request_intent is not None: - _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") - if owner is not None: - _headers["x-ms-owner"] = _SERIALIZER.header("owner", owner, "str") - if group is not None: - _headers["x-ms-group"] = _SERIALIZER.header("group", group, "str") - if file_mode is not None: - _headers["x-ms-mode"] = _SERIALIZER.header("file_mode", file_mode, "str") - if file_mode_copy_mode is not None: - _headers["x-ms-file-mode-copy-mode"] = _SERIALIZER.header("file_mode_copy_mode", file_mode_copy_mode, "str") - if file_owner_copy_mode is not None: - _headers["x-ms-file-owner-copy-mode"] = _SERIALIZER.header("file_owner_copy_mode", file_owner_copy_mode, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_abort_copy_request( - url: str, - *, - copy_id: str, - version: str, - timeout: Optional[int] = None, - lease_id: Optional[str] = None, - allow_trailing_dot: Optional[bool] = None, - file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - comp: Literal["copy"] = kwargs.pop("comp", _params.pop("comp", "copy")) - copy_action_abort_constant: Literal["abort"] = kwargs.pop( - "copy_action_abort_constant", _headers.pop("x-ms-copy-action", "abort") - ) - accept = _headers.pop("Accept", "application/xml") - - # Construct URL - _url = kwargs.pop("template_url", "{url}") - path_format_arguments = { - "url": _SERIALIZER.url("url", url, "str", skip_quote=True), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["comp"] = _SERIALIZER.query("comp", comp, "str") - _params["copyid"] = _SERIALIZER.query("copy_id", copy_id, "str") - if timeout is not None: - _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int", minimum=0) - - # Construct headers - _headers["x-ms-copy-action"] = _SERIALIZER.header("copy_action_abort_constant", copy_action_abort_constant, "str") - _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") - if lease_id is not None: - _headers["x-ms-lease-id"] = _SERIALIZER.header("lease_id", lease_id, "str") - if allow_trailing_dot is not None: - _headers["x-ms-allow-trailing-dot"] = _SERIALIZER.header("allow_trailing_dot", allow_trailing_dot, "bool") - if file_request_intent is not None: - _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_list_handles_request( - url: str, - *, - version: str, - marker: Optional[str] = None, - maxresults: Optional[int] = None, - timeout: Optional[int] = None, - sharesnapshot: Optional[str] = None, - allow_trailing_dot: Optional[bool] = None, - file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - comp: Literal["listhandles"] = kwargs.pop("comp", _params.pop("comp", "listhandles")) - accept = _headers.pop("Accept", "application/xml") - - # Construct URL - _url = kwargs.pop("template_url", "{url}") - path_format_arguments = { - "url": _SERIALIZER.url("url", url, "str", skip_quote=True), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["comp"] = _SERIALIZER.query("comp", comp, "str") - if marker is not None: - _params["marker"] = _SERIALIZER.query("marker", marker, "str") - if maxresults is not None: - _params["maxresults"] = _SERIALIZER.query("maxresults", maxresults, "int", minimum=1) - if timeout is not None: - _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int", minimum=0) - if sharesnapshot is not None: - _params["sharesnapshot"] = _SERIALIZER.query("sharesnapshot", sharesnapshot, "str") - - # Construct headers - _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") - if allow_trailing_dot is not None: - _headers["x-ms-allow-trailing-dot"] = _SERIALIZER.header("allow_trailing_dot", allow_trailing_dot, "bool") - if file_request_intent is not None: - _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_force_close_handles_request( - url: str, - *, - handle_id: str, - version: str, - timeout: Optional[int] = None, - marker: Optional[str] = None, - sharesnapshot: Optional[str] = None, - allow_trailing_dot: Optional[bool] = None, - file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - comp: Literal["forceclosehandles"] = kwargs.pop("comp", _params.pop("comp", "forceclosehandles")) - accept = _headers.pop("Accept", "application/xml") - - # Construct URL - _url = kwargs.pop("template_url", "{url}") - path_format_arguments = { - "url": _SERIALIZER.url("url", url, "str", skip_quote=True), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["comp"] = _SERIALIZER.query("comp", comp, "str") - if timeout is not None: - _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int", minimum=0) - if marker is not None: - _params["marker"] = _SERIALIZER.query("marker", marker, "str") - if sharesnapshot is not None: - _params["sharesnapshot"] = _SERIALIZER.query("sharesnapshot", sharesnapshot, "str") - - # Construct headers - _headers["x-ms-handle-id"] = _SERIALIZER.header("handle_id", handle_id, "str") - _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") - if allow_trailing_dot is not None: - _headers["x-ms-allow-trailing-dot"] = _SERIALIZER.header("allow_trailing_dot", allow_trailing_dot, "bool") - if file_request_intent is not None: - _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_rename_request( # pylint: disable=too-many-locals - url: str, - *, - rename_source: str, - version: str, - timeout: Optional[int] = None, - replace_if_exists: Optional[bool] = None, - ignore_read_only: Optional[bool] = None, - source_lease_id: Optional[str] = None, - destination_lease_id: Optional[str] = None, - file_attributes: Optional[str] = None, - file_creation_time: Optional[str] = None, - file_last_write_time: Optional[str] = None, - file_change_time: Optional[str] = None, - file_permission: str = "inherit", - file_permission_format: Optional[Union[str, _models.FilePermissionFormat]] = None, - file_permission_key: Optional[str] = None, - metadata: Optional[dict[str, str]] = None, - file_content_type: Optional[str] = None, - allow_trailing_dot: Optional[bool] = None, - allow_source_trailing_dot: Optional[bool] = None, - file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - comp: Literal["rename"] = kwargs.pop("comp", _params.pop("comp", "rename")) - accept = _headers.pop("Accept", "application/xml") - - # Construct URL - _url = kwargs.pop("template_url", "{url}") - path_format_arguments = { - "url": _SERIALIZER.url("url", url, "str", skip_quote=True), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["comp"] = _SERIALIZER.query("comp", comp, "str") - if timeout is not None: - _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int", minimum=0) - - # Construct headers - _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") - _headers["x-ms-file-rename-source"] = _SERIALIZER.header("rename_source", rename_source, "str") - if replace_if_exists is not None: - _headers["x-ms-file-rename-replace-if-exists"] = _SERIALIZER.header( - "replace_if_exists", replace_if_exists, "bool" - ) - if ignore_read_only is not None: - _headers["x-ms-file-rename-ignore-readonly"] = _SERIALIZER.header("ignore_read_only", ignore_read_only, "bool") - if source_lease_id is not None: - _headers["x-ms-source-lease-id"] = _SERIALIZER.header("source_lease_id", source_lease_id, "str") - if destination_lease_id is not None: - _headers["x-ms-destination-lease-id"] = _SERIALIZER.header("destination_lease_id", destination_lease_id, "str") - if file_attributes is not None: - _headers["x-ms-file-attributes"] = _SERIALIZER.header("file_attributes", file_attributes, "str") - if file_creation_time is not None: - _headers["x-ms-file-creation-time"] = _SERIALIZER.header("file_creation_time", file_creation_time, "str") - if file_last_write_time is not None: - _headers["x-ms-file-last-write-time"] = _SERIALIZER.header("file_last_write_time", file_last_write_time, "str") - if file_change_time is not None: - _headers["x-ms-file-change-time"] = _SERIALIZER.header("file_change_time", file_change_time, "str") - if file_permission is not None: - _headers["x-ms-file-permission"] = _SERIALIZER.header("file_permission", file_permission, "str") - if file_permission_format is not None: - _headers["x-ms-file-permission-format"] = _SERIALIZER.header( - "file_permission_format", file_permission_format, "str" - ) - if file_permission_key is not None: - _headers["x-ms-file-permission-key"] = _SERIALIZER.header("file_permission_key", file_permission_key, "str") - if metadata is not None: - _headers["x-ms-meta"] = _SERIALIZER.header("metadata", metadata, "{str}") - if file_content_type is not None: - _headers["x-ms-content-type"] = _SERIALIZER.header("file_content_type", file_content_type, "str") - if allow_trailing_dot is not None: - _headers["x-ms-allow-trailing-dot"] = _SERIALIZER.header("allow_trailing_dot", allow_trailing_dot, "bool") - if allow_source_trailing_dot is not None: - _headers["x-ms-source-allow-trailing-dot"] = _SERIALIZER.header( - "allow_source_trailing_dot", allow_source_trailing_dot, "bool" - ) - if file_request_intent is not None: - _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_create_symbolic_link_request( - url: str, - *, - link_text: str, - version: str, - timeout: Optional[int] = None, - metadata: Optional[dict[str, str]] = None, - file_creation_time: str = "now", - file_last_write_time: str = "now", - request_id_parameter: Optional[str] = None, - lease_id: Optional[str] = None, - owner: Optional[str] = None, - group: Optional[str] = None, - file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - restype: Literal["symboliclink"] = kwargs.pop("restype", _params.pop("restype", "symboliclink")) - accept = _headers.pop("Accept", "application/xml") - - # Construct URL - _url = kwargs.pop("template_url", "{url}") - path_format_arguments = { - "url": _SERIALIZER.url("url", url, "str", skip_quote=True), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["restype"] = _SERIALIZER.query("restype", restype, "str") - if timeout is not None: - _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int", minimum=0) - - # Construct headers - _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") - if metadata is not None: - _headers["x-ms-meta"] = _SERIALIZER.header("metadata", metadata, "{str}") - if file_creation_time is not None: - _headers["x-ms-file-creation-time"] = _SERIALIZER.header("file_creation_time", file_creation_time, "str") - if file_last_write_time is not None: - _headers["x-ms-file-last-write-time"] = _SERIALIZER.header("file_last_write_time", file_last_write_time, "str") - if request_id_parameter is not None: - _headers["x-ms-client-request-id"] = _SERIALIZER.header("request_id_parameter", request_id_parameter, "str") - if lease_id is not None: - _headers["x-ms-lease-id"] = _SERIALIZER.header("lease_id", lease_id, "str") - if owner is not None: - _headers["x-ms-owner"] = _SERIALIZER.header("owner", owner, "str") - if group is not None: - _headers["x-ms-group"] = _SERIALIZER.header("group", group, "str") - _headers["x-ms-link-text"] = _SERIALIZER.header("link_text", link_text, "str") - if file_request_intent is not None: - _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_get_symbolic_link_request( - url: str, - *, - version: str, - timeout: Optional[int] = None, - sharesnapshot: Optional[str] = None, - request_id_parameter: Optional[str] = None, - file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - restype: Literal["symboliclink"] = kwargs.pop("restype", _params.pop("restype", "symboliclink")) - accept = _headers.pop("Accept", "application/xml") - - # Construct URL - _url = kwargs.pop("template_url", "{url}") - path_format_arguments = { - "url": _SERIALIZER.url("url", url, "str", skip_quote=True), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["restype"] = _SERIALIZER.query("restype", restype, "str") - if timeout is not None: - _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int", minimum=0) - if sharesnapshot is not None: - _params["sharesnapshot"] = _SERIALIZER.query("sharesnapshot", sharesnapshot, "str") - - # Construct headers - _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") - if request_id_parameter is not None: - _headers["x-ms-client-request-id"] = _SERIALIZER.header("request_id_parameter", request_id_parameter, "str") - if file_request_intent is not None: - _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_create_hard_link_request( - url: str, - *, - target_file: str, - version: str, - timeout: Optional[int] = None, - request_id_parameter: Optional[str] = None, - lease_id: Optional[str] = None, - file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - restype: Literal["hardlink"] = kwargs.pop("restype", _params.pop("restype", "hardlink")) - file_type_constant: Literal["file"] = kwargs.pop("file_type_constant", _headers.pop("x-ms-type", "file")) - accept = _headers.pop("Accept", "application/xml") - - # Construct URL - _url = kwargs.pop("template_url", "{url}") - path_format_arguments = { - "url": _SERIALIZER.url("url", url, "str", skip_quote=True), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["restype"] = _SERIALIZER.query("restype", restype, "str") - if timeout is not None: - _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int", minimum=0) - - # Construct headers - _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") - _headers["x-ms-type"] = _SERIALIZER.header("file_type_constant", file_type_constant, "str") - if request_id_parameter is not None: - _headers["x-ms-client-request-id"] = _SERIALIZER.header("request_id_parameter", request_id_parameter, "str") - if lease_id is not None: - _headers["x-ms-lease-id"] = _SERIALIZER.header("lease_id", lease_id, "str") - _headers["x-ms-file-target-file"] = _SERIALIZER.header("target_file", target_file, "str") - if file_request_intent is not None: - _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) - - -class FileOperations: # pylint: disable=too-many-public-methods - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.storage.fileshare.AzureFileStorage`'s - :attr:`file` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs) -> None: - input_args = list(args) - self._client: PipelineClient = input_args.pop(0) if input_args else kwargs.pop("client") - self._config: AzureFileStorageConfiguration = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize: Serializer = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize: Deserializer = input_args.pop(0) if input_args else kwargs.pop("deserializer") - - @distributed_trace - def create( # pylint: disable=inconsistent-return-statements,too-many-locals - self, - file_content_length: int, - timeout: Optional[int] = None, - metadata: Optional[dict[str, str]] = None, - file_permission: str = "inherit", - file_permission_format: Optional[Union[str, _models.FilePermissionFormat]] = None, - file_permission_key: Optional[str] = None, - file_attributes: str = "none", - file_creation_time: str = "now", - file_last_write_time: str = "now", - file_change_time: Optional[str] = None, - owner: Optional[str] = None, - group: Optional[str] = None, - file_mode: Optional[str] = None, - nfs_file_type: Optional[Union[str, _models.NfsFileType]] = None, - content_md5: Optional[bytes] = None, - file_property_semantics: Optional[Union[str, _models.FilePropertySemantics]] = None, - content_length: Optional[int] = None, - structured_body_type: Optional[str] = None, - structured_content_length: Optional[int] = None, - file_http_headers: Optional[_models.FileHTTPHeaders] = None, - lease_access_conditions: Optional[_models.LeaseAccessConditions] = None, - optionalbody: Optional[IO[bytes]] = None, - **kwargs: Any - ) -> None: - """Creates a new file or replaces a file. Can also initialize the file with content. - - :param file_content_length: Specifies the maximum size for the file, up to 4 TB. Required. - :type file_content_length: int - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param metadata: A name-value pair to associate with a file storage object. Default value is - None. - :type metadata: dict[str, str] - :param file_permission: If specified the permission (security descriptor) shall be set for the - directory/file. This header can be used if Permission size is <= 8KB, else - x-ms-file-permission-key header shall be used. Default value: Inherit. If SDDL is specified as - input, it must have owner, group and dacl. Note: Only one of the x-ms-file-permission or - x-ms-file-permission-key should be specified. Default value is "inherit". - :type file_permission: str - :param file_permission_format: Optional. Available for version 2023-06-01 and later. Specifies - the format in which the permission is returned. Acceptable values are SDDL or binary. If - x-ms-file-permission-format is unspecified or explicitly set to SDDL, the permission is - returned in SDDL format. If x-ms-file-permission-format is explicitly set to binary, the - permission is returned as a base64 string representing the binary encoding of the permission. - Known values are: "Sddl" and "Binary". Default value is None. - :type file_permission_format: str or ~azure.storage.fileshare.models.FilePermissionFormat - :param file_permission_key: Key of the permission to be set for the directory/file. Note: Only - one of the x-ms-file-permission or x-ms-file-permission-key should be specified. Default value - is None. - :type file_permission_key: str - :param file_attributes: If specified, the provided file attributes shall be set. Default value: - ‘Archive’ for file and ‘Directory’ for directory. ‘None’ can also be specified as default. - Default value is "none". - :type file_attributes: str - :param file_creation_time: Creation time for the file/directory. Default value: Now. Default - value is "now". - :type file_creation_time: str - :param file_last_write_time: Last write time for the file/directory. Default value: Now. - Default value is "now". - :type file_last_write_time: str - :param file_change_time: Change time for the file/directory. Default value: Now. Default value - is None. - :type file_change_time: str - :param owner: Optional, NFS only. The owner of the file or directory. Default value is None. - :type owner: str - :param group: Optional, NFS only. The owning group of the file or directory. Default value is - None. - :type group: str - :param file_mode: Optional, NFS only. The file mode of the file or directory. Default value is - None. - :type file_mode: str - :param nfs_file_type: Optional, NFS only. Type of the file or directory. Known values are: - "Regular", "Directory", and "SymLink". Default value is None. - :type nfs_file_type: str or ~azure.storage.fileshare.models.NfsFileType - :param content_md5: An MD5 hash of the content. This hash is used to verify the integrity of - the data during transport. When the Content-MD5 header is specified, the File service compares - the hash of the content that has arrived with the header value that was sent. If the two hashes - do not match, the operation will fail with error code 400 (Bad Request). Default value is None. - :type content_md5: bytes - :param file_property_semantics: SMB only, default value is New. New will forcefully add the - ARCHIVE attribute flag and alter the permissions specified in x-ms-file-permission to inherit - missing permissions from the parent. Restore will apply changes without further modification. - Known values are: "New" and "Restore". Default value is None. - :type file_property_semantics: str or ~azure.storage.fileshare.models.FilePropertySemantics - :param content_length: Specifies the number of bytes being transmitted in the request body. - When the x-ms-write header is set to clear, the value of this header must be set to zero. - Default value is None. - :type content_length: int - :param structured_body_type: Required if the request body is a structured message. Specifies - the message schema version and properties. Default value is None. - :type structured_body_type: str - :param structured_content_length: Required if the request body is a structured message. - Specifies the length of the blob/file content inside the message body. Will always be smaller - than Content-Length. Default value is None. - :type structured_content_length: int - :param file_http_headers: Parameter group. Default value is None. - :type file_http_headers: ~azure.storage.fileshare.models.FileHTTPHeaders - :param lease_access_conditions: Parameter group. Default value is None. - :type lease_access_conditions: ~azure.storage.fileshare.models.LeaseAccessConditions - :param optionalbody: Initial data. Default value is None. - :type optionalbody: IO[bytes] - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = kwargs.pop("params", {}) or {} - - file_type_constant: Literal["file"] = kwargs.pop("file_type_constant", _headers.pop("x-ms-type", "file")) - content_type: Optional[str] = kwargs.pop( - "content_type", _headers.pop("Content-Type", "application/octet-stream") - ) - content_type = content_type if optionalbody else None - cls: ClsType[None] = kwargs.pop("cls", None) - - _file_content_type = None - _file_content_encoding = None - _file_content_language = None - _file_cache_control = None - _file_content_md5 = None - _file_content_disposition = None - _lease_id = None - if file_http_headers is not None: - _file_cache_control = file_http_headers.file_cache_control - _file_content_disposition = file_http_headers.file_content_disposition - _file_content_encoding = file_http_headers.file_content_encoding - _file_content_language = file_http_headers.file_content_language - _file_content_md5 = file_http_headers.file_content_md5 - _file_content_type = file_http_headers.file_content_type - if lease_access_conditions is not None: - _lease_id = lease_access_conditions.lease_id - _content = optionalbody - - _request = build_create_request( - url=self._config.url, - file_content_length=file_content_length, - version=self._config.version, - timeout=timeout, - file_content_type=_file_content_type, - file_content_encoding=_file_content_encoding, - file_content_language=_file_content_language, - file_cache_control=_file_cache_control, - file_content_md5=_file_content_md5, - file_content_disposition=_file_content_disposition, - metadata=metadata, - file_permission=file_permission, - file_permission_format=file_permission_format, - file_permission_key=file_permission_key, - file_attributes=file_attributes, - file_creation_time=file_creation_time, - file_last_write_time=file_last_write_time, - file_change_time=file_change_time, - lease_id=_lease_id, - owner=owner, - group=group, - file_mode=file_mode, - nfs_file_type=nfs_file_type, - content_md5=content_md5, - file_property_semantics=file_property_semantics, - content_length=content_length, - structured_body_type=structured_body_type, - structured_content_length=structured_content_length, - allow_trailing_dot=self._config.allow_trailing_dot, - file_request_intent=self._config.file_request_intent, - file_type_constant=file_type_constant, - content_type=content_type, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [201]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) - response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - response_headers["x-ms-request-server-encrypted"] = self._deserialize( - "bool", response.headers.get("x-ms-request-server-encrypted") - ) - response_headers["x-ms-file-permission-key"] = self._deserialize( - "str", response.headers.get("x-ms-file-permission-key") - ) - response_headers["x-ms-file-attributes"] = self._deserialize( - "str", response.headers.get("x-ms-file-attributes") - ) - response_headers["x-ms-file-creation-time"] = self._deserialize( - "str", response.headers.get("x-ms-file-creation-time") - ) - response_headers["x-ms-file-last-write-time"] = self._deserialize( - "str", response.headers.get("x-ms-file-last-write-time") - ) - response_headers["x-ms-file-change-time"] = self._deserialize( - "str", response.headers.get("x-ms-file-change-time") - ) - response_headers["x-ms-file-id"] = self._deserialize("str", response.headers.get("x-ms-file-id")) - response_headers["x-ms-file-parent-id"] = self._deserialize("str", response.headers.get("x-ms-file-parent-id")) - response_headers["x-ms-mode"] = self._deserialize("str", response.headers.get("x-ms-mode")) - response_headers["x-ms-owner"] = self._deserialize("str", response.headers.get("x-ms-owner")) - response_headers["x-ms-group"] = self._deserialize("str", response.headers.get("x-ms-group")) - response_headers["x-ms-file-file-type"] = self._deserialize("str", response.headers.get("x-ms-file-file-type")) - response_headers["Content-MD5"] = self._deserialize("bytearray", response.headers.get("Content-MD5")) - response_headers["Content-Length"] = self._deserialize("int", response.headers.get("Content-Length")) - response_headers["x-ms-structured-body"] = self._deserialize( - "str", response.headers.get("x-ms-structured-body") - ) - - if cls: - return cls(pipeline_response, None, response_headers) # type: ignore - - @distributed_trace - def download( - self, - timeout: Optional[int] = None, - range: Optional[str] = None, - range_get_content_md5: Optional[bool] = None, - structured_body_type: Optional[str] = None, - lease_access_conditions: Optional[_models.LeaseAccessConditions] = None, - **kwargs: Any - ) -> Iterator[bytes]: - """Reads or downloads a file from the system, including its metadata and properties. - - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param range: Return file data only from the specified byte range. Default value is None. - :type range: str - :param range_get_content_md5: When this header is set to true and specified together with the - Range header, the service returns the MD5 hash for the range, as long as the range is less than - or equal to 4 MB in size. Default value is None. - :type range_get_content_md5: bool - :param structured_body_type: Specifies the response content should be returned as a structured - message and specifies the message schema version and properties. Default value is None. - :type structured_body_type: str - :param lease_access_conditions: Parameter group. Default value is None. - :type lease_access_conditions: ~azure.storage.fileshare.models.LeaseAccessConditions - :return: Iterator[bytes] or the result of cls(response) - :rtype: Iterator[bytes] - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = kwargs.pop("params", {}) or {} - - cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None) - - _lease_id = None - if lease_access_conditions is not None: - _lease_id = lease_access_conditions.lease_id - - _request = build_download_request( - url=self._config.url, - version=self._config.version, - timeout=timeout, - range=range, - range_get_content_md5=range_get_content_md5, - structured_body_type=structured_body_type, - lease_id=_lease_id, - allow_trailing_dot=self._config.allow_trailing_dot, - file_request_intent=self._config.file_request_intent, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _decompress = kwargs.pop("decompress", True) - _stream = True - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200, 206]: - try: - response.read() # Load the body in memory and close the socket - except (StreamConsumedError, StreamClosedError): - pass - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) - response_headers["x-ms-meta"] = self._deserialize("{str}", response.headers.get("x-ms-meta")) - response_headers["Content-Length"] = self._deserialize("int", response.headers.get("Content-Length")) - response_headers["Content-Type"] = self._deserialize("str", response.headers.get("Content-Type")) - response_headers["Content-Range"] = self._deserialize("str", response.headers.get("Content-Range")) - response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) - response_headers["Content-MD5"] = self._deserialize("bytearray", response.headers.get("Content-MD5")) - response_headers["Content-Encoding"] = self._deserialize("str", response.headers.get("Content-Encoding")) - response_headers["Cache-Control"] = self._deserialize("str", response.headers.get("Cache-Control")) - response_headers["Content-Disposition"] = self._deserialize("str", response.headers.get("Content-Disposition")) - response_headers["Content-Language"] = self._deserialize("str", response.headers.get("Content-Language")) - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Accept-Ranges"] = self._deserialize("str", response.headers.get("Accept-Ranges")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - response_headers["x-ms-copy-completion-time"] = self._deserialize( - "rfc-1123", response.headers.get("x-ms-copy-completion-time") - ) - response_headers["x-ms-copy-status-description"] = self._deserialize( - "str", response.headers.get("x-ms-copy-status-description") - ) - response_headers["x-ms-copy-id"] = self._deserialize("str", response.headers.get("x-ms-copy-id")) - response_headers["x-ms-copy-progress"] = self._deserialize("str", response.headers.get("x-ms-copy-progress")) - response_headers["x-ms-copy-source"] = self._deserialize("str", response.headers.get("x-ms-copy-source")) - response_headers["x-ms-copy-status"] = self._deserialize("str", response.headers.get("x-ms-copy-status")) - response_headers["x-ms-content-md5"] = self._deserialize("bytearray", response.headers.get("x-ms-content-md5")) - response_headers["x-ms-server-encrypted"] = self._deserialize( - "bool", response.headers.get("x-ms-server-encrypted") - ) - response_headers["x-ms-file-attributes"] = self._deserialize( - "str", response.headers.get("x-ms-file-attributes") - ) - response_headers["x-ms-file-creation-time"] = self._deserialize( - "str", response.headers.get("x-ms-file-creation-time") - ) - response_headers["x-ms-file-last-write-time"] = self._deserialize( - "str", response.headers.get("x-ms-file-last-write-time") - ) - response_headers["x-ms-file-change-time"] = self._deserialize( - "str", response.headers.get("x-ms-file-change-time") - ) - response_headers["x-ms-file-permission-key"] = self._deserialize( - "str", response.headers.get("x-ms-file-permission-key") - ) - response_headers["x-ms-file-id"] = self._deserialize("str", response.headers.get("x-ms-file-id")) - response_headers["x-ms-file-parent-id"] = self._deserialize("str", response.headers.get("x-ms-file-parent-id")) - response_headers["x-ms-lease-duration"] = self._deserialize("str", response.headers.get("x-ms-lease-duration")) - response_headers["x-ms-lease-state"] = self._deserialize("str", response.headers.get("x-ms-lease-state")) - response_headers["x-ms-lease-status"] = self._deserialize("str", response.headers.get("x-ms-lease-status")) - response_headers["x-ms-structured-body"] = self._deserialize( - "str", response.headers.get("x-ms-structured-body") - ) - response_headers["x-ms-structured-content-length"] = self._deserialize( - "int", response.headers.get("x-ms-structured-content-length") - ) - response_headers["x-ms-mode"] = self._deserialize("str", response.headers.get("x-ms-mode")) - response_headers["x-ms-owner"] = self._deserialize("str", response.headers.get("x-ms-owner")) - response_headers["x-ms-group"] = self._deserialize("str", response.headers.get("x-ms-group")) - response_headers["x-ms-link-count"] = self._deserialize("int", response.headers.get("x-ms-link-count")) - - deserialized = response.stream_download(self._client._pipeline, decompress=_decompress) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def get_properties( # pylint: disable=inconsistent-return-statements - self, - sharesnapshot: Optional[str] = None, - timeout: Optional[int] = None, - lease_access_conditions: Optional[_models.LeaseAccessConditions] = None, - **kwargs: Any - ) -> None: - """Returns all user-defined metadata, standard HTTP properties, and system properties for the - file. It does not return the content of the file. - - :param sharesnapshot: The snapshot parameter is an opaque DateTime value that, when present, - specifies the share snapshot to query. Default value is None. - :type sharesnapshot: str - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param lease_access_conditions: Parameter group. Default value is None. - :type lease_access_conditions: ~azure.storage.fileshare.models.LeaseAccessConditions - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = kwargs.pop("params", {}) or {} - - cls: ClsType[None] = kwargs.pop("cls", None) - - _lease_id = None - if lease_access_conditions is not None: - _lease_id = lease_access_conditions.lease_id - - _request = build_get_properties_request( - url=self._config.url, - version=self._config.version, - sharesnapshot=sharesnapshot, - timeout=timeout, - lease_id=_lease_id, - allow_trailing_dot=self._config.allow_trailing_dot, - file_request_intent=self._config.file_request_intent, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) - response_headers["x-ms-meta"] = self._deserialize("{str}", response.headers.get("x-ms-meta")) - response_headers["x-ms-type"] = self._deserialize("str", response.headers.get("x-ms-type")) - response_headers["Content-Length"] = self._deserialize("int", response.headers.get("Content-Length")) - response_headers["Content-Type"] = self._deserialize("str", response.headers.get("Content-Type")) - response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) - response_headers["Content-MD5"] = self._deserialize("bytearray", response.headers.get("Content-MD5")) - response_headers["Content-Encoding"] = self._deserialize("str", response.headers.get("Content-Encoding")) - response_headers["Cache-Control"] = self._deserialize("str", response.headers.get("Cache-Control")) - response_headers["Content-Disposition"] = self._deserialize("str", response.headers.get("Content-Disposition")) - response_headers["Content-Language"] = self._deserialize("str", response.headers.get("Content-Language")) - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - response_headers["x-ms-copy-completion-time"] = self._deserialize( - "rfc-1123", response.headers.get("x-ms-copy-completion-time") - ) - response_headers["x-ms-copy-status-description"] = self._deserialize( - "str", response.headers.get("x-ms-copy-status-description") - ) - response_headers["x-ms-copy-id"] = self._deserialize("str", response.headers.get("x-ms-copy-id")) - response_headers["x-ms-copy-progress"] = self._deserialize("str", response.headers.get("x-ms-copy-progress")) - response_headers["x-ms-copy-source"] = self._deserialize("str", response.headers.get("x-ms-copy-source")) - response_headers["x-ms-copy-status"] = self._deserialize("str", response.headers.get("x-ms-copy-status")) - response_headers["x-ms-server-encrypted"] = self._deserialize( - "bool", response.headers.get("x-ms-server-encrypted") - ) - response_headers["x-ms-file-attributes"] = self._deserialize( - "str", response.headers.get("x-ms-file-attributes") - ) - response_headers["x-ms-file-creation-time"] = self._deserialize( - "str", response.headers.get("x-ms-file-creation-time") - ) - response_headers["x-ms-file-last-write-time"] = self._deserialize( - "str", response.headers.get("x-ms-file-last-write-time") - ) - response_headers["x-ms-file-change-time"] = self._deserialize( - "str", response.headers.get("x-ms-file-change-time") - ) - response_headers["x-ms-file-permission-key"] = self._deserialize( - "str", response.headers.get("x-ms-file-permission-key") - ) - response_headers["x-ms-file-id"] = self._deserialize("str", response.headers.get("x-ms-file-id")) - response_headers["x-ms-file-parent-id"] = self._deserialize("str", response.headers.get("x-ms-file-parent-id")) - response_headers["x-ms-lease-duration"] = self._deserialize("str", response.headers.get("x-ms-lease-duration")) - response_headers["x-ms-lease-state"] = self._deserialize("str", response.headers.get("x-ms-lease-state")) - response_headers["x-ms-lease-status"] = self._deserialize("str", response.headers.get("x-ms-lease-status")) - response_headers["x-ms-mode"] = self._deserialize("str", response.headers.get("x-ms-mode")) - response_headers["x-ms-owner"] = self._deserialize("str", response.headers.get("x-ms-owner")) - response_headers["x-ms-group"] = self._deserialize("str", response.headers.get("x-ms-group")) - response_headers["x-ms-link-count"] = self._deserialize("int", response.headers.get("x-ms-link-count")) - response_headers["x-ms-file-file-type"] = self._deserialize("str", response.headers.get("x-ms-file-file-type")) - - if cls: - return cls(pipeline_response, None, response_headers) # type: ignore - - @distributed_trace - def delete( # pylint: disable=inconsistent-return-statements - self, - timeout: Optional[int] = None, - lease_access_conditions: Optional[_models.LeaseAccessConditions] = None, - **kwargs: Any - ) -> None: - """removes the file from the storage account. - - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param lease_access_conditions: Parameter group. Default value is None. - :type lease_access_conditions: ~azure.storage.fileshare.models.LeaseAccessConditions - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = kwargs.pop("params", {}) or {} - - cls: ClsType[None] = kwargs.pop("cls", None) - - _lease_id = None - if lease_access_conditions is not None: - _lease_id = lease_access_conditions.lease_id - - _request = build_delete_request( - url=self._config.url, - version=self._config.version, - timeout=timeout, - lease_id=_lease_id, - allow_trailing_dot=self._config.allow_trailing_dot, - file_request_intent=self._config.file_request_intent, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [202]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - response_headers["x-ms-link-count"] = self._deserialize("int", response.headers.get("x-ms-link-count")) - - if cls: - return cls(pipeline_response, None, response_headers) # type: ignore - - @distributed_trace - def set_http_headers( # pylint: disable=inconsistent-return-statements,too-many-locals - self, - timeout: Optional[int] = None, - file_content_length: Optional[int] = None, - file_permission: str = "inherit", - file_permission_format: Optional[Union[str, _models.FilePermissionFormat]] = None, - file_permission_key: Optional[str] = None, - file_attributes: str = "none", - file_creation_time: str = "now", - file_last_write_time: str = "now", - file_change_time: Optional[str] = None, - owner: Optional[str] = None, - group: Optional[str] = None, - file_mode: Optional[str] = None, - file_http_headers: Optional[_models.FileHTTPHeaders] = None, - lease_access_conditions: Optional[_models.LeaseAccessConditions] = None, - **kwargs: Any - ) -> None: - """Sets HTTP headers on the file. - - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param file_content_length: Resizes a file to the specified size. If the specified byte value - is less than the current size of the file, then all ranges above the specified byte value are - cleared. Default value is None. - :type file_content_length: int - :param file_permission: If specified the permission (security descriptor) shall be set for the - directory/file. This header can be used if Permission size is <= 8KB, else - x-ms-file-permission-key header shall be used. Default value: Inherit. If SDDL is specified as - input, it must have owner, group and dacl. Note: Only one of the x-ms-file-permission or - x-ms-file-permission-key should be specified. Default value is "inherit". - :type file_permission: str - :param file_permission_format: Optional. Available for version 2023-06-01 and later. Specifies - the format in which the permission is returned. Acceptable values are SDDL or binary. If - x-ms-file-permission-format is unspecified or explicitly set to SDDL, the permission is - returned in SDDL format. If x-ms-file-permission-format is explicitly set to binary, the - permission is returned as a base64 string representing the binary encoding of the permission. - Known values are: "Sddl" and "Binary". Default value is None. - :type file_permission_format: str or ~azure.storage.fileshare.models.FilePermissionFormat - :param file_permission_key: Key of the permission to be set for the directory/file. Note: Only - one of the x-ms-file-permission or x-ms-file-permission-key should be specified. Default value - is None. - :type file_permission_key: str - :param file_attributes: If specified, the provided file attributes shall be set. Default value: - ‘Archive’ for file and ‘Directory’ for directory. ‘None’ can also be specified as default. - Default value is "none". - :type file_attributes: str - :param file_creation_time: Creation time for the file/directory. Default value: Now. Default - value is "now". - :type file_creation_time: str - :param file_last_write_time: Last write time for the file/directory. Default value: Now. - Default value is "now". - :type file_last_write_time: str - :param file_change_time: Change time for the file/directory. Default value: Now. Default value - is None. - :type file_change_time: str - :param owner: Optional, NFS only. The owner of the file or directory. Default value is None. - :type owner: str - :param group: Optional, NFS only. The owning group of the file or directory. Default value is - None. - :type group: str - :param file_mode: Optional, NFS only. The file mode of the file or directory. Default value is - None. - :type file_mode: str - :param file_http_headers: Parameter group. Default value is None. - :type file_http_headers: ~azure.storage.fileshare.models.FileHTTPHeaders - :param lease_access_conditions: Parameter group. Default value is None. - :type lease_access_conditions: ~azure.storage.fileshare.models.LeaseAccessConditions - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - comp: Literal["properties"] = kwargs.pop("comp", _params.pop("comp", "properties")) - cls: ClsType[None] = kwargs.pop("cls", None) - - _file_content_type = None - _file_content_encoding = None - _file_content_language = None - _file_cache_control = None - _file_content_md5 = None - _file_content_disposition = None - _lease_id = None - if file_http_headers is not None: - _file_cache_control = file_http_headers.file_cache_control - _file_content_disposition = file_http_headers.file_content_disposition - _file_content_encoding = file_http_headers.file_content_encoding - _file_content_language = file_http_headers.file_content_language - _file_content_md5 = file_http_headers.file_content_md5 - _file_content_type = file_http_headers.file_content_type - if lease_access_conditions is not None: - _lease_id = lease_access_conditions.lease_id - - _request = build_set_http_headers_request( - url=self._config.url, - version=self._config.version, - timeout=timeout, - file_content_length=file_content_length, - file_content_type=_file_content_type, - file_content_encoding=_file_content_encoding, - file_content_language=_file_content_language, - file_cache_control=_file_cache_control, - file_content_md5=_file_content_md5, - file_content_disposition=_file_content_disposition, - file_permission=file_permission, - file_permission_format=file_permission_format, - file_permission_key=file_permission_key, - file_attributes=file_attributes, - file_creation_time=file_creation_time, - file_last_write_time=file_last_write_time, - file_change_time=file_change_time, - lease_id=_lease_id, - owner=owner, - group=group, - file_mode=file_mode, - allow_trailing_dot=self._config.allow_trailing_dot, - file_request_intent=self._config.file_request_intent, - comp=comp, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) - response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - response_headers["x-ms-request-server-encrypted"] = self._deserialize( - "bool", response.headers.get("x-ms-request-server-encrypted") - ) - response_headers["x-ms-file-permission-key"] = self._deserialize( - "str", response.headers.get("x-ms-file-permission-key") - ) - response_headers["x-ms-file-attributes"] = self._deserialize( - "str", response.headers.get("x-ms-file-attributes") - ) - response_headers["x-ms-file-creation-time"] = self._deserialize( - "str", response.headers.get("x-ms-file-creation-time") - ) - response_headers["x-ms-file-last-write-time"] = self._deserialize( - "str", response.headers.get("x-ms-file-last-write-time") - ) - response_headers["x-ms-file-change-time"] = self._deserialize( - "str", response.headers.get("x-ms-file-change-time") - ) - response_headers["x-ms-file-id"] = self._deserialize("str", response.headers.get("x-ms-file-id")) - response_headers["x-ms-file-parent-id"] = self._deserialize("str", response.headers.get("x-ms-file-parent-id")) - response_headers["x-ms-mode"] = self._deserialize("str", response.headers.get("x-ms-mode")) - response_headers["x-ms-owner"] = self._deserialize("str", response.headers.get("x-ms-owner")) - response_headers["x-ms-group"] = self._deserialize("str", response.headers.get("x-ms-group")) - response_headers["x-ms-link-count"] = self._deserialize("int", response.headers.get("x-ms-link-count")) - - if cls: - return cls(pipeline_response, None, response_headers) # type: ignore - - @distributed_trace - def set_metadata( # pylint: disable=inconsistent-return-statements - self, - timeout: Optional[int] = None, - metadata: Optional[dict[str, str]] = None, - lease_access_conditions: Optional[_models.LeaseAccessConditions] = None, - **kwargs: Any - ) -> None: - """Updates user-defined metadata for the specified file. - - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param metadata: A name-value pair to associate with a file storage object. Default value is - None. - :type metadata: dict[str, str] - :param lease_access_conditions: Parameter group. Default value is None. - :type lease_access_conditions: ~azure.storage.fileshare.models.LeaseAccessConditions - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - comp: Literal["metadata"] = kwargs.pop("comp", _params.pop("comp", "metadata")) - cls: ClsType[None] = kwargs.pop("cls", None) - - _lease_id = None - if lease_access_conditions is not None: - _lease_id = lease_access_conditions.lease_id - - _request = build_set_metadata_request( - url=self._config.url, - version=self._config.version, - timeout=timeout, - metadata=metadata, - lease_id=_lease_id, - allow_trailing_dot=self._config.allow_trailing_dot, - file_request_intent=self._config.file_request_intent, - comp=comp, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - response_headers["x-ms-request-server-encrypted"] = self._deserialize( - "bool", response.headers.get("x-ms-request-server-encrypted") - ) - - if cls: - return cls(pipeline_response, None, response_headers) # type: ignore - - @distributed_trace - def acquire_lease( # pylint: disable=inconsistent-return-statements - self, - timeout: Optional[int] = None, - duration: Optional[int] = None, - proposed_lease_id: Optional[str] = None, - request_id_parameter: Optional[str] = None, - **kwargs: Any - ) -> None: - """[Update] The Lease File operation establishes and manages a lock on a file for write and delete - operations. - - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param duration: Specifies the duration of the lease, in seconds, or negative one (-1) for a - lease that never expires. A non-infinite lease can be between 15 and 60 seconds. A lease - duration cannot be changed using renew or change. Default value is None. - :type duration: int - :param proposed_lease_id: Proposed lease ID, in a GUID string format. The File service returns - 400 (Invalid request) if the proposed lease ID is not in the correct format. See Guid - Constructor (String) for a list of valid GUID string formats. Default value is None. - :type proposed_lease_id: str - :param request_id_parameter: Provides a client-generated, opaque value with a 1 KB character - limit that is recorded in the analytics logs when storage analytics logging is enabled. Default - value is None. - :type request_id_parameter: str - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - comp: Literal["lease"] = kwargs.pop("comp", _params.pop("comp", "lease")) - action: Literal["acquire"] = kwargs.pop("action", _headers.pop("x-ms-lease-action", "acquire")) - cls: ClsType[None] = kwargs.pop("cls", None) - - _request = build_acquire_lease_request( - url=self._config.url, - version=self._config.version, - timeout=timeout, - duration=duration, - proposed_lease_id=proposed_lease_id, - request_id_parameter=request_id_parameter, - allow_trailing_dot=self._config.allow_trailing_dot, - file_request_intent=self._config.file_request_intent, - comp=comp, - action=action, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [201]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) - response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) - response_headers["x-ms-lease-id"] = self._deserialize("str", response.headers.get("x-ms-lease-id")) - response_headers["x-ms-client-request-id"] = self._deserialize( - "str", response.headers.get("x-ms-client-request-id") - ) - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - - if cls: - return cls(pipeline_response, None, response_headers) # type: ignore - - @distributed_trace - def release_lease( # pylint: disable=inconsistent-return-statements - self, lease_id: str, timeout: Optional[int] = None, request_id_parameter: Optional[str] = None, **kwargs: Any - ) -> None: - """[Update] The Lease File operation establishes and manages a lock on a file for write and delete - operations. - - :param lease_id: Specifies the current lease ID on the resource. Required. - :type lease_id: str - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param request_id_parameter: Provides a client-generated, opaque value with a 1 KB character - limit that is recorded in the analytics logs when storage analytics logging is enabled. Default - value is None. - :type request_id_parameter: str - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - comp: Literal["lease"] = kwargs.pop("comp", _params.pop("comp", "lease")) - action: Literal["release"] = kwargs.pop("action", _headers.pop("x-ms-lease-action", "release")) - cls: ClsType[None] = kwargs.pop("cls", None) - - _request = build_release_lease_request( - url=self._config.url, - lease_id=lease_id, - version=self._config.version, - timeout=timeout, - request_id_parameter=request_id_parameter, - allow_trailing_dot=self._config.allow_trailing_dot, - file_request_intent=self._config.file_request_intent, - comp=comp, - action=action, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) - response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) - response_headers["x-ms-client-request-id"] = self._deserialize( - "str", response.headers.get("x-ms-client-request-id") - ) - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - - if cls: - return cls(pipeline_response, None, response_headers) # type: ignore - - @distributed_trace - def change_lease( # pylint: disable=inconsistent-return-statements - self, - lease_id: str, - timeout: Optional[int] = None, - proposed_lease_id: Optional[str] = None, - request_id_parameter: Optional[str] = None, - **kwargs: Any - ) -> None: - """[Update] The Lease File operation establishes and manages a lock on a file for write and delete - operations. - - :param lease_id: Specifies the current lease ID on the resource. Required. - :type lease_id: str - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param proposed_lease_id: Proposed lease ID, in a GUID string format. The File service returns - 400 (Invalid request) if the proposed lease ID is not in the correct format. See Guid - Constructor (String) for a list of valid GUID string formats. Default value is None. - :type proposed_lease_id: str - :param request_id_parameter: Provides a client-generated, opaque value with a 1 KB character - limit that is recorded in the analytics logs when storage analytics logging is enabled. Default - value is None. - :type request_id_parameter: str - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - comp: Literal["lease"] = kwargs.pop("comp", _params.pop("comp", "lease")) - action: Literal["change"] = kwargs.pop("action", _headers.pop("x-ms-lease-action", "change")) - cls: ClsType[None] = kwargs.pop("cls", None) - - _request = build_change_lease_request( - url=self._config.url, - lease_id=lease_id, - version=self._config.version, - timeout=timeout, - proposed_lease_id=proposed_lease_id, - request_id_parameter=request_id_parameter, - allow_trailing_dot=self._config.allow_trailing_dot, - file_request_intent=self._config.file_request_intent, - comp=comp, - action=action, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) - response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) - response_headers["x-ms-lease-id"] = self._deserialize("str", response.headers.get("x-ms-lease-id")) - response_headers["x-ms-client-request-id"] = self._deserialize( - "str", response.headers.get("x-ms-client-request-id") - ) - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - - if cls: - return cls(pipeline_response, None, response_headers) # type: ignore - - @distributed_trace - def break_lease( # pylint: disable=inconsistent-return-statements - self, - timeout: Optional[int] = None, - request_id_parameter: Optional[str] = None, - lease_access_conditions: Optional[_models.LeaseAccessConditions] = None, - **kwargs: Any - ) -> None: - """[Update] The Lease File operation establishes and manages a lock on a file for write and delete - operations. - - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param request_id_parameter: Provides a client-generated, opaque value with a 1 KB character - limit that is recorded in the analytics logs when storage analytics logging is enabled. Default - value is None. - :type request_id_parameter: str - :param lease_access_conditions: Parameter group. Default value is None. - :type lease_access_conditions: ~azure.storage.fileshare.models.LeaseAccessConditions - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - comp: Literal["lease"] = kwargs.pop("comp", _params.pop("comp", "lease")) - action: Literal["break"] = kwargs.pop("action", _headers.pop("x-ms-lease-action", "break")) - cls: ClsType[None] = kwargs.pop("cls", None) - - _lease_id = None - if lease_access_conditions is not None: - _lease_id = lease_access_conditions.lease_id - - _request = build_break_lease_request( - url=self._config.url, - version=self._config.version, - timeout=timeout, - lease_id=_lease_id, - request_id_parameter=request_id_parameter, - allow_trailing_dot=self._config.allow_trailing_dot, - file_request_intent=self._config.file_request_intent, - comp=comp, - action=action, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [202]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) - response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) - response_headers["x-ms-lease-id"] = self._deserialize("str", response.headers.get("x-ms-lease-id")) - response_headers["x-ms-client-request-id"] = self._deserialize( - "str", response.headers.get("x-ms-client-request-id") - ) - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - - if cls: - return cls(pipeline_response, None, response_headers) # type: ignore - - @distributed_trace - def upload_range( # pylint: disable=inconsistent-return-statements,too-many-locals - self, - range: str, - content_length: int, - timeout: Optional[int] = None, - file_range_write: Union[str, _models.FileRangeWriteType] = "update", - content_md5: Optional[bytes] = None, - file_last_written_mode: Optional[Union[str, _models.FileLastWrittenMode]] = None, - structured_body_type: Optional[str] = None, - structured_content_length: Optional[int] = None, - lease_access_conditions: Optional[_models.LeaseAccessConditions] = None, - optionalbody: Optional[IO[bytes]] = None, - **kwargs: Any - ) -> None: - """Upload a range of bytes to a file. - - :param range: Specifies the range of bytes to be written. Both the start and end of the range - must be specified. For an update operation, the range can be up to 4 MB in size. For a clear - operation, the range can be up to the value of the file's full size. The File service accepts - only a single byte range for the Range and 'x-ms-range' headers, and the byte range must be - specified in the following format: bytes=startByte-endByte. Required. - :type range: str - :param content_length: Specifies the number of bytes being transmitted in the request body. - When the x-ms-write header is set to clear, the value of this header must be set to zero. - Required. - :type content_length: int - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param file_range_write: Specify one of the following options: - Update: Writes the bytes - specified by the request body into the specified range. The Range and Content-Length headers - must match to perform the update. - Clear: Clears the specified range and releases the space - used in storage for that range. To clear a range, set the Content-Length header to zero, and - set the Range header to a value that indicates the range to clear, up to maximum file size. - Known values are: "update" and "clear". Default value is "update". - :type file_range_write: str or ~azure.storage.fileshare.models.FileRangeWriteType - :param content_md5: An MD5 hash of the content. This hash is used to verify the integrity of - the data during transport. When the Content-MD5 header is specified, the File service compares - the hash of the content that has arrived with the header value that was sent. If the two hashes - do not match, the operation will fail with error code 400 (Bad Request). Default value is None. - :type content_md5: bytes - :param file_last_written_mode: If the file last write time should be preserved or overwritten. - Known values are: "Now" and "Preserve". Default value is None. - :type file_last_written_mode: str or ~azure.storage.fileshare.models.FileLastWrittenMode - :param structured_body_type: Required if the request body is a structured message. Specifies - the message schema version and properties. Default value is None. - :type structured_body_type: str - :param structured_content_length: Required if the request body is a structured message. - Specifies the length of the blob/file content inside the message body. Will always be smaller - than Content-Length. Default value is None. - :type structured_content_length: int - :param lease_access_conditions: Parameter group. Default value is None. - :type lease_access_conditions: ~azure.storage.fileshare.models.LeaseAccessConditions - :param optionalbody: Initial data. Default value is None. - :type optionalbody: IO[bytes] - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - comp: Literal["range"] = kwargs.pop("comp", _params.pop("comp", "range")) - content_type: Optional[str] = kwargs.pop( - "content_type", _headers.pop("Content-Type", "application/octet-stream") - ) - content_type = content_type if optionalbody else None - cls: ClsType[None] = kwargs.pop("cls", None) - - _lease_id = None - if lease_access_conditions is not None: - _lease_id = lease_access_conditions.lease_id - _content = optionalbody - - _request = build_upload_range_request( - url=self._config.url, - range=range, - content_length=content_length, - version=self._config.version, - timeout=timeout, - file_range_write=file_range_write, - content_md5=content_md5, - lease_id=_lease_id, - file_last_written_mode=file_last_written_mode, - structured_body_type=structured_body_type, - structured_content_length=structured_content_length, - allow_trailing_dot=self._config.allow_trailing_dot, - file_request_intent=self._config.file_request_intent, - comp=comp, - content_type=content_type, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [201]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) - response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) - response_headers["Content-MD5"] = self._deserialize("bytearray", response.headers.get("Content-MD5")) - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - response_headers["x-ms-request-server-encrypted"] = self._deserialize( - "bool", response.headers.get("x-ms-request-server-encrypted") - ) - response_headers["x-ms-file-last-write-time"] = self._deserialize( - "str", response.headers.get("x-ms-file-last-write-time") - ) - response_headers["x-ms-structured-body"] = self._deserialize( - "str", response.headers.get("x-ms-structured-body") - ) - - if cls: - return cls(pipeline_response, None, response_headers) # type: ignore - - @distributed_trace - def upload_range_from_url( # pylint: disable=inconsistent-return-statements - self, - range: str, - copy_source: str, - content_length: int, - timeout: Optional[int] = None, - source_range: Optional[str] = None, - source_content_crc64: Optional[bytes] = None, - copy_source_authorization: Optional[str] = None, - file_last_written_mode: Optional[Union[str, _models.FileLastWrittenMode]] = None, - source_modified_access_conditions: Optional[_models.SourceModifiedAccessConditions] = None, - lease_access_conditions: Optional[_models.LeaseAccessConditions] = None, - **kwargs: Any - ) -> None: - """Upload a range of bytes to a file where the contents are read from a URL. - - :param range: Writes data to the specified byte range in the file. Required. - :type range: str - :param copy_source: Specifies the URL of the source file or blob, up to 2 KB in length. To copy - a file to another file within the same storage account, you may use Shared Key to authenticate - the source file. If you are copying a file from another storage account, or if you are copying - a blob from the same storage account or another storage account, then you must authenticate the - source file or blob using a shared access signature. If the source is a public blob, no - authentication is required to perform the copy operation. A file in a share snapshot can also - be specified as a copy source. Required. - :type copy_source: str - :param content_length: Specifies the number of bytes being transmitted in the request body. - When the x-ms-write header is set to clear, the value of this header must be set to zero. - Required. - :type content_length: int - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param source_range: Bytes of source data in the specified range. Default value is None. - :type source_range: str - :param source_content_crc64: Specify the crc64 calculated for the range of bytes that must be - read from the copy source. Default value is None. - :type source_content_crc64: bytes - :param copy_source_authorization: Only Bearer type is supported. Credentials should be a valid - OAuth access token to copy source. Default value is None. - :type copy_source_authorization: str - :param file_last_written_mode: If the file last write time should be preserved or overwritten. - Known values are: "Now" and "Preserve". Default value is None. - :type file_last_written_mode: str or ~azure.storage.fileshare.models.FileLastWrittenMode - :param source_modified_access_conditions: Parameter group. Default value is None. - :type source_modified_access_conditions: - ~azure.storage.fileshare.models.SourceModifiedAccessConditions - :param lease_access_conditions: Parameter group. Default value is None. - :type lease_access_conditions: ~azure.storage.fileshare.models.LeaseAccessConditions - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - comp: Literal["range"] = kwargs.pop("comp", _params.pop("comp", "range")) - cls: ClsType[None] = kwargs.pop("cls", None) - - _source_if_match_crc64 = None - _source_if_none_match_crc64 = None - _lease_id = None - if source_modified_access_conditions is not None: - _source_if_match_crc64 = source_modified_access_conditions.source_if_match_crc64 - _source_if_none_match_crc64 = source_modified_access_conditions.source_if_none_match_crc64 - if lease_access_conditions is not None: - _lease_id = lease_access_conditions.lease_id - - _request = build_upload_range_from_url_request( - url=self._config.url, - range=range, - copy_source=copy_source, - content_length=content_length, - version=self._config.version, - timeout=timeout, - source_range=source_range, - source_content_crc64=source_content_crc64, - source_if_match_crc64=_source_if_match_crc64, - source_if_none_match_crc64=_source_if_none_match_crc64, - lease_id=_lease_id, - copy_source_authorization=copy_source_authorization, - file_last_written_mode=file_last_written_mode, - allow_trailing_dot=self._config.allow_trailing_dot, - allow_source_trailing_dot=self._config.allow_source_trailing_dot, - file_request_intent=self._config.file_request_intent, - comp=comp, - file_range_write_from_url=self._config.file_range_write_from_url, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [201]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) - response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) - response_headers["x-ms-content-crc64"] = self._deserialize( - "bytearray", response.headers.get("x-ms-content-crc64") - ) - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - response_headers["x-ms-request-server-encrypted"] = self._deserialize( - "bool", response.headers.get("x-ms-request-server-encrypted") - ) - response_headers["x-ms-file-last-write-time"] = self._deserialize( - "str", response.headers.get("x-ms-file-last-write-time") - ) - - if cls: - return cls(pipeline_response, None, response_headers) # type: ignore - - @distributed_trace - def get_range_list( - self, - sharesnapshot: Optional[str] = None, - prevsharesnapshot: Optional[str] = None, - timeout: Optional[int] = None, - range: Optional[str] = None, - support_rename: Optional[bool] = None, - lease_access_conditions: Optional[_models.LeaseAccessConditions] = None, - **kwargs: Any - ) -> _models.ShareFileRangeList: - """Returns the list of valid ranges for a file. - - :param sharesnapshot: The snapshot parameter is an opaque DateTime value that, when present, - specifies the share snapshot to query. Default value is None. - :type sharesnapshot: str - :param prevsharesnapshot: The previous snapshot parameter is an opaque DateTime value that, - when present, specifies the previous snapshot. Default value is None. - :type prevsharesnapshot: str - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param range: Specifies the range of bytes over which to list ranges, inclusively. Default - value is None. - :type range: str - :param support_rename: This header is allowed only when PrevShareSnapshot query parameter is - set. Determines whether the changed ranges for a file that has been renamed or moved between - the target snapshot (or the live file) and the previous snapshot should be listed. If the value - is true, the valid changed ranges for the file will be returned. If the value is false, the - operation will result in a failure with 409 (Conflict) response. The default value is false. - Default value is None. - :type support_rename: bool - :param lease_access_conditions: Parameter group. Default value is None. - :type lease_access_conditions: ~azure.storage.fileshare.models.LeaseAccessConditions - :return: ShareFileRangeList or the result of cls(response) - :rtype: ~azure.storage.fileshare.models.ShareFileRangeList - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - comp: Literal["rangelist"] = kwargs.pop("comp", _params.pop("comp", "rangelist")) - cls: ClsType[_models.ShareFileRangeList] = kwargs.pop("cls", None) - - _lease_id = None - if lease_access_conditions is not None: - _lease_id = lease_access_conditions.lease_id - - _request = build_get_range_list_request( - url=self._config.url, - version=self._config.version, - sharesnapshot=sharesnapshot, - prevsharesnapshot=prevsharesnapshot, - timeout=timeout, - range=range, - lease_id=_lease_id, - support_rename=support_rename, - allow_trailing_dot=self._config.allow_trailing_dot, - file_request_intent=self._config.file_request_intent, - comp=comp, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) - response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) - response_headers["x-ms-content-length"] = self._deserialize("int", response.headers.get("x-ms-content-length")) - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - - deserialized = self._deserialize("ShareFileRangeList", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def start_copy( # pylint: disable=inconsistent-return-statements,too-many-locals - self, - copy_source: str, - timeout: Optional[int] = None, - metadata: Optional[dict[str, str]] = None, - file_permission: str = "inherit", - file_permission_format: Optional[Union[str, _models.FilePermissionFormat]] = None, - file_permission_key: Optional[str] = None, - owner: Optional[str] = None, - group: Optional[str] = None, - file_mode: Optional[str] = None, - file_mode_copy_mode: Optional[Union[str, _models.ModeCopyMode]] = None, - file_owner_copy_mode: Optional[Union[str, _models.OwnerCopyMode]] = None, - copy_file_smb_info: Optional[_models.CopyFileSmbInfo] = None, - lease_access_conditions: Optional[_models.LeaseAccessConditions] = None, - **kwargs: Any - ) -> None: - """Copies a blob or file to a destination file within the storage account. - - :param copy_source: Specifies the URL of the source file or blob, up to 2 KB in length. To copy - a file to another file within the same storage account, you may use Shared Key to authenticate - the source file. If you are copying a file from another storage account, or if you are copying - a blob from the same storage account or another storage account, then you must authenticate the - source file or blob using a shared access signature. If the source is a public blob, no - authentication is required to perform the copy operation. A file in a share snapshot can also - be specified as a copy source. Required. - :type copy_source: str - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param metadata: A name-value pair to associate with a file storage object. Default value is - None. - :type metadata: dict[str, str] - :param file_permission: If specified the permission (security descriptor) shall be set for the - directory/file. This header can be used if Permission size is <= 8KB, else - x-ms-file-permission-key header shall be used. Default value: Inherit. If SDDL is specified as - input, it must have owner, group and dacl. Note: Only one of the x-ms-file-permission or - x-ms-file-permission-key should be specified. Default value is "inherit". - :type file_permission: str - :param file_permission_format: Optional. Available for version 2023-06-01 and later. Specifies - the format in which the permission is returned. Acceptable values are SDDL or binary. If - x-ms-file-permission-format is unspecified or explicitly set to SDDL, the permission is - returned in SDDL format. If x-ms-file-permission-format is explicitly set to binary, the - permission is returned as a base64 string representing the binary encoding of the permission. - Known values are: "Sddl" and "Binary". Default value is None. - :type file_permission_format: str or ~azure.storage.fileshare.models.FilePermissionFormat - :param file_permission_key: Key of the permission to be set for the directory/file. Note: Only - one of the x-ms-file-permission or x-ms-file-permission-key should be specified. Default value - is None. - :type file_permission_key: str - :param owner: Optional, NFS only. The owner of the file or directory. Default value is None. - :type owner: str - :param group: Optional, NFS only. The owning group of the file or directory. Default value is - None. - :type group: str - :param file_mode: Optional, NFS only. The file mode of the file or directory. Default value is - None. - :type file_mode: str - :param file_mode_copy_mode: NFS only. Applicable only when the copy source is a File. - Determines the copy behavior of the mode bits of the file. source: The mode on the destination - file is copied from the source file. override: The mode on the destination file is determined - via the x-ms-mode header. Known values are: "source" and "override". Default value is None. - :type file_mode_copy_mode: str or ~azure.storage.fileshare.models.ModeCopyMode - :param file_owner_copy_mode: NFS only. Determines the copy behavior of the owner user - identifier (UID) and group identifier (GID) of the file. source: The owner user identifier - (UID) and group identifier (GID) on the destination file is copied from the source file. - override: The owner user identifier (UID) and group identifier (GID) on the destination file is - determined via the x-ms-owner and x-ms-group headers. Known values are: "source" and - "override". Default value is None. - :type file_owner_copy_mode: str or ~azure.storage.fileshare.models.OwnerCopyMode - :param copy_file_smb_info: Parameter group. Default value is None. - :type copy_file_smb_info: ~azure.storage.fileshare.models.CopyFileSmbInfo - :param lease_access_conditions: Parameter group. Default value is None. - :type lease_access_conditions: ~azure.storage.fileshare.models.LeaseAccessConditions - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = kwargs.pop("params", {}) or {} - - cls: ClsType[None] = kwargs.pop("cls", None) - - _file_permission_copy_mode = None - _ignore_read_only = None - _file_attributes = None - _file_creation_time = None - _file_last_write_time = None - _file_change_time = None - _set_archive_attribute = None - _lease_id = None - if copy_file_smb_info is not None: - _file_attributes = copy_file_smb_info.file_attributes - _file_change_time = copy_file_smb_info.file_change_time - _file_creation_time = copy_file_smb_info.file_creation_time - _file_last_write_time = copy_file_smb_info.file_last_write_time - _file_permission_copy_mode = copy_file_smb_info.file_permission_copy_mode - _ignore_read_only = copy_file_smb_info.ignore_read_only - _set_archive_attribute = copy_file_smb_info.set_archive_attribute - if lease_access_conditions is not None: - _lease_id = lease_access_conditions.lease_id - - _request = build_start_copy_request( - url=self._config.url, - copy_source=copy_source, - version=self._config.version, - timeout=timeout, - metadata=metadata, - file_permission=file_permission, - file_permission_format=file_permission_format, - file_permission_key=file_permission_key, - file_permission_copy_mode=_file_permission_copy_mode, - ignore_read_only=_ignore_read_only, - file_attributes=_file_attributes, - file_creation_time=_file_creation_time, - file_last_write_time=_file_last_write_time, - file_change_time=_file_change_time, - set_archive_attribute=_set_archive_attribute, - lease_id=_lease_id, - owner=owner, - group=group, - file_mode=file_mode, - file_mode_copy_mode=file_mode_copy_mode, - file_owner_copy_mode=file_owner_copy_mode, - allow_trailing_dot=self._config.allow_trailing_dot, - allow_source_trailing_dot=self._config.allow_source_trailing_dot, - file_request_intent=self._config.file_request_intent, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [202]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) - response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - response_headers["x-ms-copy-id"] = self._deserialize("str", response.headers.get("x-ms-copy-id")) - response_headers["x-ms-copy-status"] = self._deserialize("str", response.headers.get("x-ms-copy-status")) - - if cls: - return cls(pipeline_response, None, response_headers) # type: ignore - - @distributed_trace - def abort_copy( # pylint: disable=inconsistent-return-statements - self, - copy_id: str, - timeout: Optional[int] = None, - lease_access_conditions: Optional[_models.LeaseAccessConditions] = None, - **kwargs: Any - ) -> None: - """Aborts a pending Copy File operation, and leaves a destination file with zero length and full - metadata. - - :param copy_id: The copy identifier provided in the x-ms-copy-id header of the original Copy - File operation. Required. - :type copy_id: str - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param lease_access_conditions: Parameter group. Default value is None. - :type lease_access_conditions: ~azure.storage.fileshare.models.LeaseAccessConditions - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - comp: Literal["copy"] = kwargs.pop("comp", _params.pop("comp", "copy")) - copy_action_abort_constant: Literal["abort"] = kwargs.pop( - "copy_action_abort_constant", _headers.pop("x-ms-copy-action", "abort") - ) - cls: ClsType[None] = kwargs.pop("cls", None) - - _lease_id = None - if lease_access_conditions is not None: - _lease_id = lease_access_conditions.lease_id - - _request = build_abort_copy_request( - url=self._config.url, - copy_id=copy_id, - version=self._config.version, - timeout=timeout, - lease_id=_lease_id, - allow_trailing_dot=self._config.allow_trailing_dot, - file_request_intent=self._config.file_request_intent, - comp=comp, - copy_action_abort_constant=copy_action_abort_constant, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [204]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - - if cls: - return cls(pipeline_response, None, response_headers) # type: ignore - - @distributed_trace - def list_handles( - self, - marker: Optional[str] = None, - maxresults: Optional[int] = None, - timeout: Optional[int] = None, - sharesnapshot: Optional[str] = None, - **kwargs: Any - ) -> _models.ListHandlesResponse: - """Lists handles for file. - - :param marker: A string value that identifies the portion of the list to be returned with the - next list operation. The operation returns a marker value within the response body if the list - returned was not complete. The marker value may then be used in a subsequent call to request - the next set of list items. The marker value is opaque to the client. Default value is None. - :type marker: str - :param maxresults: Specifies the maximum number of entries to return. If the request does not - specify maxresults, or specifies a value greater than 5,000, the server will return up to 5,000 - items. Default value is None. - :type maxresults: int - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param sharesnapshot: The snapshot parameter is an opaque DateTime value that, when present, - specifies the share snapshot to query. Default value is None. - :type sharesnapshot: str - :return: ListHandlesResponse or the result of cls(response) - :rtype: ~azure.storage.fileshare.models.ListHandlesResponse - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - comp: Literal["listhandles"] = kwargs.pop("comp", _params.pop("comp", "listhandles")) - cls: ClsType[_models.ListHandlesResponse] = kwargs.pop("cls", None) - - _request = build_list_handles_request( - url=self._config.url, - version=self._config.version, - marker=marker, - maxresults=maxresults, - timeout=timeout, - sharesnapshot=sharesnapshot, - allow_trailing_dot=self._config.allow_trailing_dot, - file_request_intent=self._config.file_request_intent, - comp=comp, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["Content-Type"] = self._deserialize("str", response.headers.get("Content-Type")) - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - - deserialized = self._deserialize("ListHandlesResponse", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def force_close_handles( # pylint: disable=inconsistent-return-statements - self, - handle_id: str, - timeout: Optional[int] = None, - marker: Optional[str] = None, - sharesnapshot: Optional[str] = None, - **kwargs: Any - ) -> None: - """Closes all handles open for given file. - - :param handle_id: Specifies handle ID opened on the file or directory to be closed. Asterisk - (‘*’) is a wildcard that specifies all handles. Required. - :type handle_id: str - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param marker: A string value that identifies the portion of the list to be returned with the - next list operation. The operation returns a marker value within the response body if the list - returned was not complete. The marker value may then be used in a subsequent call to request - the next set of list items. The marker value is opaque to the client. Default value is None. - :type marker: str - :param sharesnapshot: The snapshot parameter is an opaque DateTime value that, when present, - specifies the share snapshot to query. Default value is None. - :type sharesnapshot: str - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - comp: Literal["forceclosehandles"] = kwargs.pop("comp", _params.pop("comp", "forceclosehandles")) - cls: ClsType[None] = kwargs.pop("cls", None) - - _request = build_force_close_handles_request( - url=self._config.url, - handle_id=handle_id, - version=self._config.version, - timeout=timeout, - marker=marker, - sharesnapshot=sharesnapshot, - allow_trailing_dot=self._config.allow_trailing_dot, - file_request_intent=self._config.file_request_intent, - comp=comp, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - response_headers["x-ms-marker"] = self._deserialize("str", response.headers.get("x-ms-marker")) - response_headers["x-ms-number-of-handles-closed"] = self._deserialize( - "int", response.headers.get("x-ms-number-of-handles-closed") - ) - response_headers["x-ms-number-of-handles-failed"] = self._deserialize( - "int", response.headers.get("x-ms-number-of-handles-failed") - ) - - if cls: - return cls(pipeline_response, None, response_headers) # type: ignore - - @distributed_trace - def rename( # pylint: disable=inconsistent-return-statements,too-many-locals - self, - rename_source: str, - timeout: Optional[int] = None, - replace_if_exists: Optional[bool] = None, - ignore_read_only: Optional[bool] = None, - file_permission: str = "inherit", - file_permission_format: Optional[Union[str, _models.FilePermissionFormat]] = None, - file_permission_key: Optional[str] = None, - metadata: Optional[dict[str, str]] = None, - source_lease_access_conditions: Optional[_models.SourceLeaseAccessConditions] = None, - destination_lease_access_conditions: Optional[_models.DestinationLeaseAccessConditions] = None, - copy_file_smb_info: Optional[_models.CopyFileSmbInfo] = None, - file_http_headers: Optional[_models.FileHTTPHeaders] = None, - **kwargs: Any - ) -> None: - """Renames a file. - - :param rename_source: Required. Specifies the URI-style path of the source file, up to 2 KB in - length. Required. - :type rename_source: str - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param replace_if_exists: Optional. A boolean value for if the destination file already exists, - whether this request will overwrite the file or not. If true, the rename will succeed and will - overwrite the destination file. If not provided or if false and the destination file does - exist, the request will not overwrite the destination file. If provided and the destination - file doesn’t exist, the rename will succeed. Note: This value does not override the - x-ms-file-copy-ignore-read-only header value. Default value is None. - :type replace_if_exists: bool - :param ignore_read_only: Optional. A boolean value that specifies whether the ReadOnly - attribute on a preexisting destination file should be respected. If true, the rename will - succeed, otherwise, a previous file at the destination with the ReadOnly attribute set will - cause the rename to fail. Default value is None. - :type ignore_read_only: bool - :param file_permission: If specified the permission (security descriptor) shall be set for the - directory/file. This header can be used if Permission size is <= 8KB, else - x-ms-file-permission-key header shall be used. Default value: Inherit. If SDDL is specified as - input, it must have owner, group and dacl. Note: Only one of the x-ms-file-permission or - x-ms-file-permission-key should be specified. Default value is "inherit". - :type file_permission: str - :param file_permission_format: Optional. Available for version 2023-06-01 and later. Specifies - the format in which the permission is returned. Acceptable values are SDDL or binary. If - x-ms-file-permission-format is unspecified or explicitly set to SDDL, the permission is - returned in SDDL format. If x-ms-file-permission-format is explicitly set to binary, the - permission is returned as a base64 string representing the binary encoding of the permission. - Known values are: "Sddl" and "Binary". Default value is None. - :type file_permission_format: str or ~azure.storage.fileshare.models.FilePermissionFormat - :param file_permission_key: Key of the permission to be set for the directory/file. Note: Only - one of the x-ms-file-permission or x-ms-file-permission-key should be specified. Default value - is None. - :type file_permission_key: str - :param metadata: A name-value pair to associate with a file storage object. Default value is - None. - :type metadata: dict[str, str] - :param source_lease_access_conditions: Parameter group. Default value is None. - :type source_lease_access_conditions: - ~azure.storage.fileshare.models.SourceLeaseAccessConditions - :param destination_lease_access_conditions: Parameter group. Default value is None. - :type destination_lease_access_conditions: - ~azure.storage.fileshare.models.DestinationLeaseAccessConditions - :param copy_file_smb_info: Parameter group. Default value is None. - :type copy_file_smb_info: ~azure.storage.fileshare.models.CopyFileSmbInfo - :param file_http_headers: Parameter group. Default value is None. - :type file_http_headers: ~azure.storage.fileshare.models.FileHTTPHeaders - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - comp: Literal["rename"] = kwargs.pop("comp", _params.pop("comp", "rename")) - cls: ClsType[None] = kwargs.pop("cls", None) - - _source_lease_id = None - _destination_lease_id = None - _file_attributes = None - _file_creation_time = None - _file_last_write_time = None - _file_change_time = None - _file_content_type = None - if source_lease_access_conditions is not None: - _source_lease_id = source_lease_access_conditions.source_lease_id - if destination_lease_access_conditions is not None: - _destination_lease_id = destination_lease_access_conditions.destination_lease_id - if copy_file_smb_info is not None: - _file_attributes = copy_file_smb_info.file_attributes - _file_change_time = copy_file_smb_info.file_change_time - _file_creation_time = copy_file_smb_info.file_creation_time - _file_last_write_time = copy_file_smb_info.file_last_write_time - if file_http_headers is not None: - _file_content_type = file_http_headers.file_content_type - - _request = build_rename_request( - url=self._config.url, - rename_source=rename_source, - version=self._config.version, - timeout=timeout, - replace_if_exists=replace_if_exists, - ignore_read_only=ignore_read_only, - source_lease_id=_source_lease_id, - destination_lease_id=_destination_lease_id, - file_attributes=_file_attributes, - file_creation_time=_file_creation_time, - file_last_write_time=_file_last_write_time, - file_change_time=_file_change_time, - file_permission=file_permission, - file_permission_format=file_permission_format, - file_permission_key=file_permission_key, - metadata=metadata, - file_content_type=_file_content_type, - allow_trailing_dot=self._config.allow_trailing_dot, - allow_source_trailing_dot=self._config.allow_source_trailing_dot, - file_request_intent=self._config.file_request_intent, - comp=comp, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) - response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - response_headers["x-ms-request-server-encrypted"] = self._deserialize( - "bool", response.headers.get("x-ms-request-server-encrypted") - ) - response_headers["x-ms-file-permission-key"] = self._deserialize( - "str", response.headers.get("x-ms-file-permission-key") - ) - response_headers["x-ms-file-attributes"] = self._deserialize( - "str", response.headers.get("x-ms-file-attributes") - ) - response_headers["x-ms-file-creation-time"] = self._deserialize( - "str", response.headers.get("x-ms-file-creation-time") - ) - response_headers["x-ms-file-last-write-time"] = self._deserialize( - "str", response.headers.get("x-ms-file-last-write-time") - ) - response_headers["x-ms-file-change-time"] = self._deserialize( - "str", response.headers.get("x-ms-file-change-time") - ) - response_headers["x-ms-file-id"] = self._deserialize("str", response.headers.get("x-ms-file-id")) - response_headers["x-ms-file-parent-id"] = self._deserialize("str", response.headers.get("x-ms-file-parent-id")) - - if cls: - return cls(pipeline_response, None, response_headers) # type: ignore - - @distributed_trace - def create_symbolic_link( # pylint: disable=inconsistent-return-statements - self, - link_text: str, - timeout: Optional[int] = None, - metadata: Optional[dict[str, str]] = None, - file_creation_time: str = "now", - file_last_write_time: str = "now", - request_id_parameter: Optional[str] = None, - owner: Optional[str] = None, - group: Optional[str] = None, - lease_access_conditions: Optional[_models.LeaseAccessConditions] = None, - **kwargs: Any - ) -> None: - """Creates a symbolic link. - - :param link_text: NFS only. Required. The path to the original file, the symbolic link is - pointing to. The path is of type string which is not resolved and is stored as is. The path can - be absolute path or the relative path depending on the content stored in the symbolic link - file. Required. - :type link_text: str - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param metadata: A name-value pair to associate with a file storage object. Default value is - None. - :type metadata: dict[str, str] - :param file_creation_time: Creation time for the file/directory. Default value: Now. Default - value is "now". - :type file_creation_time: str - :param file_last_write_time: Last write time for the file/directory. Default value: Now. - Default value is "now". - :type file_last_write_time: str - :param request_id_parameter: Provides a client-generated, opaque value with a 1 KB character - limit that is recorded in the analytics logs when storage analytics logging is enabled. Default - value is None. - :type request_id_parameter: str - :param owner: Optional, NFS only. The owner of the file or directory. Default value is None. - :type owner: str - :param group: Optional, NFS only. The owning group of the file or directory. Default value is - None. - :type group: str - :param lease_access_conditions: Parameter group. Default value is None. - :type lease_access_conditions: ~azure.storage.fileshare.models.LeaseAccessConditions - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - restype: Literal["symboliclink"] = kwargs.pop("restype", _params.pop("restype", "symboliclink")) - cls: ClsType[None] = kwargs.pop("cls", None) - - _lease_id = None - if lease_access_conditions is not None: - _lease_id = lease_access_conditions.lease_id - - _request = build_create_symbolic_link_request( - url=self._config.url, - link_text=link_text, - version=self._config.version, - timeout=timeout, - metadata=metadata, - file_creation_time=file_creation_time, - file_last_write_time=file_last_write_time, - request_id_parameter=request_id_parameter, - lease_id=_lease_id, - owner=owner, - group=group, - file_request_intent=self._config.file_request_intent, - restype=restype, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [201]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) - response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - response_headers["x-ms-file-creation-time"] = self._deserialize( - "str", response.headers.get("x-ms-file-creation-time") - ) - response_headers["x-ms-file-last-write-time"] = self._deserialize( - "str", response.headers.get("x-ms-file-last-write-time") - ) - response_headers["x-ms-file-change-time"] = self._deserialize( - "str", response.headers.get("x-ms-file-change-time") - ) - response_headers["x-ms-file-id"] = self._deserialize("str", response.headers.get("x-ms-file-id")) - response_headers["x-ms-file-parent-id"] = self._deserialize("str", response.headers.get("x-ms-file-parent-id")) - response_headers["x-ms-client-request-id"] = self._deserialize( - "str", response.headers.get("x-ms-client-request-id") - ) - response_headers["x-ms-mode"] = self._deserialize("str", response.headers.get("x-ms-mode")) - response_headers["x-ms-owner"] = self._deserialize("str", response.headers.get("x-ms-owner")) - response_headers["x-ms-group"] = self._deserialize("str", response.headers.get("x-ms-group")) - response_headers["x-ms-file-file-type"] = self._deserialize("str", response.headers.get("x-ms-file-file-type")) - - if cls: - return cls(pipeline_response, None, response_headers) # type: ignore - - @distributed_trace - def get_symbolic_link( # pylint: disable=inconsistent-return-statements - self, - timeout: Optional[int] = None, - sharesnapshot: Optional[str] = None, - request_id_parameter: Optional[str] = None, - **kwargs: Any - ) -> None: - """get_symbolic_link. - - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param sharesnapshot: The snapshot parameter is an opaque DateTime value that, when present, - specifies the share snapshot to query. Default value is None. - :type sharesnapshot: str - :param request_id_parameter: Provides a client-generated, opaque value with a 1 KB character - limit that is recorded in the analytics logs when storage analytics logging is enabled. Default - value is None. - :type request_id_parameter: str - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - restype: Literal["symboliclink"] = kwargs.pop("restype", _params.pop("restype", "symboliclink")) - cls: ClsType[None] = kwargs.pop("cls", None) - - _request = build_get_symbolic_link_request( - url=self._config.url, - version=self._config.version, - timeout=timeout, - sharesnapshot=sharesnapshot, - request_id_parameter=request_id_parameter, - file_request_intent=self._config.file_request_intent, - restype=restype, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) - response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - response_headers["x-ms-link-text"] = self._deserialize("str", response.headers.get("x-ms-link-text")) - response_headers["x-ms-client-request-id"] = self._deserialize( - "str", response.headers.get("x-ms-client-request-id") - ) - - if cls: - return cls(pipeline_response, None, response_headers) # type: ignore - - @distributed_trace - def create_hard_link( # pylint: disable=inconsistent-return-statements - self, - target_file: str, - timeout: Optional[int] = None, - request_id_parameter: Optional[str] = None, - lease_access_conditions: Optional[_models.LeaseAccessConditions] = None, - **kwargs: Any - ) -> None: - """Creates a hard link. - - :param target_file: NFS only. Required. Specifies the path of the target file to which the link - will be created, up to 2 KiB in length. It should be full path of the target from the root.The - target file must be in the same share and hence the same storage account. Required. - :type target_file: str - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param request_id_parameter: Provides a client-generated, opaque value with a 1 KB character - limit that is recorded in the analytics logs when storage analytics logging is enabled. Default - value is None. - :type request_id_parameter: str - :param lease_access_conditions: Parameter group. Default value is None. - :type lease_access_conditions: ~azure.storage.fileshare.models.LeaseAccessConditions - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - restype: Literal["hardlink"] = kwargs.pop("restype", _params.pop("restype", "hardlink")) - file_type_constant: Literal["file"] = kwargs.pop("file_type_constant", _headers.pop("x-ms-type", "file")) - cls: ClsType[None] = kwargs.pop("cls", None) - - _lease_id = None - if lease_access_conditions is not None: - _lease_id = lease_access_conditions.lease_id - - _request = build_create_hard_link_request( - url=self._config.url, - target_file=target_file, - version=self._config.version, - timeout=timeout, - request_id_parameter=request_id_parameter, - lease_id=_lease_id, - file_request_intent=self._config.file_request_intent, - restype=restype, - file_type_constant=file_type_constant, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [201]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) - response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - response_headers["x-ms-file-creation-time"] = self._deserialize( - "str", response.headers.get("x-ms-file-creation-time") - ) - response_headers["x-ms-file-last-write-time"] = self._deserialize( - "str", response.headers.get("x-ms-file-last-write-time") - ) - response_headers["x-ms-file-change-time"] = self._deserialize( - "str", response.headers.get("x-ms-file-change-time") - ) - response_headers["x-ms-file-id"] = self._deserialize("str", response.headers.get("x-ms-file-id")) - response_headers["x-ms-file-parent-id"] = self._deserialize("str", response.headers.get("x-ms-file-parent-id")) - response_headers["x-ms-client-request-id"] = self._deserialize( - "str", response.headers.get("x-ms-client-request-id") - ) - response_headers["x-ms-link-count"] = self._deserialize("int", response.headers.get("x-ms-link-count")) - response_headers["x-ms-mode"] = self._deserialize("str", response.headers.get("x-ms-mode")) - response_headers["x-ms-owner"] = self._deserialize("str", response.headers.get("x-ms-owner")) - response_headers["x-ms-group"] = self._deserialize("str", response.headers.get("x-ms-group")) - response_headers["x-ms-file-file-type"] = self._deserialize("str", response.headers.get("x-ms-file-file-type")) - - if cls: - return cls(pipeline_response, None, response_headers) # type: ignore diff --git a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/operations/_operations.py b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/operations/_operations.py new file mode 100644 index 000000000000..83f32b15d5d3 --- /dev/null +++ b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/operations/_operations.py @@ -0,0 +1,8077 @@ +# pylint: disable=too-many-lines +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) Python Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- +from collections.abc import MutableMapping +from io import IOBase +import json +from typing import Any, Callable, IO, Iterator, Literal, Optional, TypeVar, Union, overload + +from azure.core import PipelineClient +from azure.core.exceptions import ( + ClientAuthenticationError, + HttpResponseError, + ResourceExistsError, + ResourceNotFoundError, + ResourceNotModifiedError, + StreamClosedError, + StreamConsumedError, + map_error, +) +from azure.core.pipeline import PipelineResponse +from azure.core.rest import HttpRequest, HttpResponse +from azure.core.tracing.decorator import distributed_trace +from azure.core.utils import case_insensitive_dict + +from .. import models as _models +from .._configuration import FileClientConfiguration +from .._utils.model_base import SdkJSONEncoder, _deserialize, _deserialize_xml, _failsafe_deserialize_xml, _get_element +from .._utils.serialization import Deserializer, Serializer + +T = TypeVar("T") +ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, dict[str, Any]], Any]] +JSON = MutableMapping[str, Any] + +_SERIALIZER = Serializer() +_SERIALIZER.client_side_validation = False + + +def build_directory_create_request( + *, + timeout: Optional[int] = None, + metadata: Optional[dict[str, str]] = None, + file_permission: Optional[str] = None, + file_permission_key: Optional[str] = None, + file_attributes: Optional[str] = None, + file_creation_time: Optional[str] = None, + file_last_write_time: Optional[str] = None, + file_change_time: Optional[str] = None, + file_permission_format: Optional[Union[str, _models.FilePermissionFormat]] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + owner: Optional[str] = None, + group: Optional[str] = None, + file_mode: Optional[str] = None, + file_property_semantics: Optional[Union[str, _models.FilePropertySemantics]] = None, + allow_trailing_dot: Optional[bool] = None, + **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + version: str = kwargs.pop("version", _headers.pop("x-ms-version", "2026-06-06")) + # Construct URL + _url = "?restype=directory" + + # Construct parameters + if timeout is not None: + _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int") + + # Construct headers + _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") + if metadata is not None: + _headers["x-ms-meta"] = _SERIALIZER.header("metadata", metadata, "{str}") + if file_permission is not None: + _headers["x-ms-file-permission"] = _SERIALIZER.header("file_permission", file_permission, "str") + if file_permission_key is not None: + _headers["x-ms-file-permission-key"] = _SERIALIZER.header("file_permission_key", file_permission_key, "str") + if file_attributes is not None: + _headers["x-ms-file-attributes"] = _SERIALIZER.header("file_attributes", file_attributes, "str") + if file_creation_time is not None: + _headers["x-ms-file-creation-time"] = _SERIALIZER.header("file_creation_time", file_creation_time, "str") + if file_last_write_time is not None: + _headers["x-ms-file-last-write-time"] = _SERIALIZER.header("file_last_write_time", file_last_write_time, "str") + if file_change_time is not None: + _headers["x-ms-file-change-time"] = _SERIALIZER.header("file_change_time", file_change_time, "str") + if file_permission_format is not None: + _headers["x-ms-file-permission-format"] = _SERIALIZER.header( + "file_permission_format", file_permission_format, "str" + ) + if file_request_intent is not None: + _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") + if owner is not None: + _headers["x-ms-owner"] = _SERIALIZER.header("owner", owner, "str") + if group is not None: + _headers["x-ms-group"] = _SERIALIZER.header("group", group, "str") + if file_mode is not None: + _headers["x-ms-mode"] = _SERIALIZER.header("file_mode", file_mode, "str") + if file_property_semantics is not None: + _headers["x-ms-file-property-semantics"] = _SERIALIZER.header( + "file_property_semantics", file_property_semantics, "str" + ) + if allow_trailing_dot is not None: + _headers["x-ms-allow-trailing-dot"] = _SERIALIZER.header("allow_trailing_dot", allow_trailing_dot, "bool") + + return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_directory_get_properties_request( + *, + sharesnapshot: Optional[str] = None, + timeout: Optional[int] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + allow_trailing_dot: Optional[bool] = None, + **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + version: str = kwargs.pop("version", _headers.pop("x-ms-version", "2026-06-06")) + # Construct URL + _url = "?restype=directory" + + # Construct parameters + if sharesnapshot is not None: + _params["sharesnapshot"] = _SERIALIZER.query("sharesnapshot", sharesnapshot, "str") + if timeout is not None: + _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int") + + # Construct headers + _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") + if file_request_intent is not None: + _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") + if allow_trailing_dot is not None: + _headers["x-ms-allow-trailing-dot"] = _SERIALIZER.header("allow_trailing_dot", allow_trailing_dot, "bool") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_directory_delete_request( + *, + timeout: Optional[int] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + allow_trailing_dot: Optional[bool] = None, + **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + version: str = kwargs.pop("version", _headers.pop("x-ms-version", "2026-06-06")) + # Construct URL + _url = "?restype=directory" + + # Construct parameters + if timeout is not None: + _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int") + + # Construct headers + _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") + if file_request_intent is not None: + _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") + if allow_trailing_dot is not None: + _headers["x-ms-allow-trailing-dot"] = _SERIALIZER.header("allow_trailing_dot", allow_trailing_dot, "bool") + + return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_directory_set_properties_request( + *, + timeout: Optional[int] = None, + file_permission: Optional[str] = None, + file_permission_key: Optional[str] = None, + file_attributes: Optional[str] = None, + file_creation_time: Optional[str] = None, + file_last_write_time: Optional[str] = None, + file_change_time: Optional[str] = None, + file_permission_format: Optional[Union[str, _models.FilePermissionFormat]] = None, + allow_trailing_dot: Optional[bool] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + owner: Optional[str] = None, + group: Optional[str] = None, + file_mode: Optional[str] = None, + **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + version: str = kwargs.pop("version", _headers.pop("x-ms-version", "2026-06-06")) + # Construct URL + _url = "?restype=directory&comp=properties" + + # Construct parameters + if timeout is not None: + _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int") + + # Construct headers + _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") + if file_permission is not None: + _headers["x-ms-file-permission"] = _SERIALIZER.header("file_permission", file_permission, "str") + if file_permission_key is not None: + _headers["x-ms-file-permission-key"] = _SERIALIZER.header("file_permission_key", file_permission_key, "str") + if file_attributes is not None: + _headers["x-ms-file-attributes"] = _SERIALIZER.header("file_attributes", file_attributes, "str") + if file_creation_time is not None: + _headers["x-ms-file-creation-time"] = _SERIALIZER.header("file_creation_time", file_creation_time, "str") + if file_last_write_time is not None: + _headers["x-ms-file-last-write-time"] = _SERIALIZER.header("file_last_write_time", file_last_write_time, "str") + if file_change_time is not None: + _headers["x-ms-file-change-time"] = _SERIALIZER.header("file_change_time", file_change_time, "str") + if file_permission_format is not None: + _headers["x-ms-file-permission-format"] = _SERIALIZER.header( + "file_permission_format", file_permission_format, "str" + ) + if allow_trailing_dot is not None: + _headers["x-ms-allow-trailing-dot"] = _SERIALIZER.header("allow_trailing_dot", allow_trailing_dot, "bool") + if file_request_intent is not None: + _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") + if owner is not None: + _headers["x-ms-owner"] = _SERIALIZER.header("owner", owner, "str") + if group is not None: + _headers["x-ms-group"] = _SERIALIZER.header("group", group, "str") + if file_mode is not None: + _headers["x-ms-mode"] = _SERIALIZER.header("file_mode", file_mode, "str") + + return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_directory_set_metadata_request( + *, + timeout: Optional[int] = None, + metadata: Optional[dict[str, str]] = None, + allow_trailing_dot: Optional[bool] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + version: str = kwargs.pop("version", _headers.pop("x-ms-version", "2026-06-06")) + # Construct URL + _url = "?restype=directory&comp=metadata" + + # Construct parameters + if timeout is not None: + _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int") + + # Construct headers + _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") + if metadata is not None: + _headers["x-ms-meta"] = _SERIALIZER.header("metadata", metadata, "{str}") + if allow_trailing_dot is not None: + _headers["x-ms-allow-trailing-dot"] = _SERIALIZER.header("allow_trailing_dot", allow_trailing_dot, "bool") + if file_request_intent is not None: + _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") + + return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_directory_list_files_and_directories_segment_request( # pylint: disable=name-too-long + *, + prefix: Optional[str] = None, + sharesnapshot: Optional[str] = None, + marker: Optional[str] = None, + maxresults: Optional[int] = None, + include: Optional[list[Union[str, _models.ListFilesIncludeType]]] = None, + timeout: Optional[int] = None, + include_extended_info: Optional[bool] = None, + allow_trailing_dot: Optional[bool] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + version: str = kwargs.pop("version", _headers.pop("x-ms-version", "2026-06-06")) + accept = _headers.pop("Accept", "application/xml") + + # Construct URL + _url = "?restype=directory&comp=list" + + # Construct parameters + if prefix is not None: + _params["prefix"] = _SERIALIZER.query("prefix", prefix, "str") + if sharesnapshot is not None: + _params["sharesnapshot"] = _SERIALIZER.query("sharesnapshot", sharesnapshot, "str") + if marker is not None: + _params["marker"] = _SERIALIZER.query("marker", marker, "str") + if maxresults is not None: + _params["maxresults"] = _SERIALIZER.query("maxresults", maxresults, "int") + if include is not None: + _params["include"] = _SERIALIZER.query("include", include, "[str]", div=",") + if timeout is not None: + _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int") + + # Construct headers + _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") + if include_extended_info is not None: + _headers["x-ms-file-extended-info"] = _SERIALIZER.header("include_extended_info", include_extended_info, "bool") + if allow_trailing_dot is not None: + _headers["x-ms-allow-trailing-dot"] = _SERIALIZER.header("allow_trailing_dot", allow_trailing_dot, "bool") + if file_request_intent is not None: + _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_directory_list_handles_request( + *, + marker: Optional[str] = None, + maxresults: Optional[int] = None, + timeout: Optional[int] = None, + sharesnapshot: Optional[str] = None, + recursive: Optional[bool] = None, + allow_trailing_dot: Optional[bool] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + version: str = kwargs.pop("version", _headers.pop("x-ms-version", "2026-06-06")) + accept = _headers.pop("Accept", "application/xml") + + # Construct URL + _url = "?comp=listhandles" + + # Construct parameters + if marker is not None: + _params["marker"] = _SERIALIZER.query("marker", marker, "str") + if maxresults is not None: + _params["maxresults"] = _SERIALIZER.query("maxresults", maxresults, "int") + if timeout is not None: + _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int") + if sharesnapshot is not None: + _params["sharesnapshot"] = _SERIALIZER.query("sharesnapshot", sharesnapshot, "str") + + # Construct headers + _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") + if recursive is not None: + _headers["x-ms-recursive"] = _SERIALIZER.header("recursive", recursive, "bool") + if allow_trailing_dot is not None: + _headers["x-ms-allow-trailing-dot"] = _SERIALIZER.header("allow_trailing_dot", allow_trailing_dot, "bool") + if file_request_intent is not None: + _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_directory_force_close_handles_request( # pylint: disable=name-too-long + *, + handle_id: str, + timeout: Optional[int] = None, + marker: Optional[str] = None, + sharesnapshot: Optional[str] = None, + recursive: Optional[bool] = None, + allow_trailing_dot: Optional[bool] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + version: str = kwargs.pop("version", _headers.pop("x-ms-version", "2026-06-06")) + # Construct URL + _url = "?comp=forceclosehandles" + + # Construct parameters + if timeout is not None: + _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int") + if marker is not None: + _params["marker"] = _SERIALIZER.query("marker", marker, "str") + if sharesnapshot is not None: + _params["sharesnapshot"] = _SERIALIZER.query("sharesnapshot", sharesnapshot, "str") + + # Construct headers + _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") + _headers["x-ms-handle-id"] = _SERIALIZER.header("handle_id", handle_id, "str") + if recursive is not None: + _headers["x-ms-recursive"] = _SERIALIZER.header("recursive", recursive, "bool") + if allow_trailing_dot is not None: + _headers["x-ms-allow-trailing-dot"] = _SERIALIZER.header("allow_trailing_dot", allow_trailing_dot, "bool") + if file_request_intent is not None: + _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") + + return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_directory_rename_request( + *, + rename_source: str, + timeout: Optional[int] = None, + replace_if_exists: Optional[bool] = None, + ignore_read_only: Optional[bool] = None, + source_lease_id: Optional[str] = None, + destination_lease_id: Optional[str] = None, + file_attributes: Optional[str] = None, + file_creation_time: Optional[str] = None, + file_last_write_time: Optional[str] = None, + file_change_time: Optional[str] = None, + file_permission: Optional[str] = None, + file_permission_format: Optional[Union[str, _models.FilePermissionFormat]] = None, + file_permission_key: Optional[str] = None, + metadata: Optional[dict[str, str]] = None, + allow_trailing_dot: Optional[bool] = None, + allow_source_trailing_dot: Optional[bool] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + version: str = kwargs.pop("version", _headers.pop("x-ms-version", "2026-06-06")) + # Construct URL + _url = "?restype=directory&comp=rename" + + # Construct parameters + if timeout is not None: + _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int") + + # Construct headers + _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") + _headers["x-ms-file-rename-source"] = _SERIALIZER.header("rename_source", rename_source, "str") + if replace_if_exists is not None: + _headers["x-ms-file-rename-replace-if-exists"] = _SERIALIZER.header( + "replace_if_exists", replace_if_exists, "bool" + ) + if ignore_read_only is not None: + _headers["x-ms-file-rename-ignore-readonly"] = _SERIALIZER.header("ignore_read_only", ignore_read_only, "bool") + if source_lease_id is not None: + _headers["x-ms-source-lease-id"] = _SERIALIZER.header("source_lease_id", source_lease_id, "str") + if destination_lease_id is not None: + _headers["x-ms-destination-lease-id"] = _SERIALIZER.header("destination_lease_id", destination_lease_id, "str") + if file_attributes is not None: + _headers["x-ms-file-attributes"] = _SERIALIZER.header("file_attributes", file_attributes, "str") + if file_creation_time is not None: + _headers["x-ms-file-creation-time"] = _SERIALIZER.header("file_creation_time", file_creation_time, "str") + if file_last_write_time is not None: + _headers["x-ms-file-last-write-time"] = _SERIALIZER.header("file_last_write_time", file_last_write_time, "str") + if file_change_time is not None: + _headers["x-ms-file-change-time"] = _SERIALIZER.header("file_change_time", file_change_time, "str") + if file_permission is not None: + _headers["x-ms-file-permission"] = _SERIALIZER.header("file_permission", file_permission, "str") + if file_permission_format is not None: + _headers["x-ms-file-permission-format"] = _SERIALIZER.header( + "file_permission_format", file_permission_format, "str" + ) + if file_permission_key is not None: + _headers["x-ms-file-permission-key"] = _SERIALIZER.header("file_permission_key", file_permission_key, "str") + if metadata is not None: + _headers["x-ms-meta"] = _SERIALIZER.header("metadata", metadata, "{str}") + if allow_trailing_dot is not None: + _headers["x-ms-allow-trailing-dot"] = _SERIALIZER.header("allow_trailing_dot", allow_trailing_dot, "bool") + if allow_source_trailing_dot is not None: + _headers["x-ms-source-allow-trailing-dot"] = _SERIALIZER.header( + "allow_source_trailing_dot", allow_source_trailing_dot, "bool" + ) + if file_request_intent is not None: + _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") + + return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_file_create_request( # pylint: disable=too-many-locals,too-many-statements,too-many-branches + *, + file_content_length: int, + timeout: Optional[int] = None, + file_content_type: Optional[str] = None, + file_content_encoding: Optional[str] = None, + file_content_language: Optional[str] = None, + file_cache_control: Optional[str] = None, + file_content_md5: Optional[bytes] = None, + file_content_disposition: Optional[str] = None, + metadata: Optional[dict[str, str]] = None, + file_permission: Optional[str] = None, + file_permission_key: Optional[str] = None, + file_attributes: Optional[str] = None, + file_creation_time: Optional[str] = None, + file_last_write_time: Optional[str] = None, + file_change_time: Optional[str] = None, + file_permission_format: Optional[Union[str, _models.FilePermissionFormat]] = None, + lease_id: Optional[str] = None, + allow_trailing_dot: Optional[bool] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + owner: Optional[str] = None, + group: Optional[str] = None, + file_mode: Optional[str] = None, + nfs_file_type: Optional[Union[str, _models.NfsFileType]] = None, + content_md5: Optional[bytes] = None, + file_property_semantics: Optional[Union[str, _models.FilePropertySemantics]] = None, + content_length: Optional[int] = None, + structured_body_type: Optional[str] = None, + structured_content_length: Optional[int] = None, + **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + file_type: Literal["file"] = kwargs.pop("file_type", _headers.pop("x-ms-type", "file")) + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + version: str = kwargs.pop("version", _headers.pop("x-ms-version", "2026-06-06")) + # Construct URL + _url = "" + + # Construct parameters + if timeout is not None: + _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int") + + # Construct headers + _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") + if content_type is not None: + _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") + _headers["x-ms-content-length"] = _SERIALIZER.header("file_content_length", file_content_length, "int") + _headers["x-ms-type"] = _SERIALIZER.header("file_type", file_type, "str") + if file_content_type is not None: + _headers["x-ms-content-type"] = _SERIALIZER.header("file_content_type", file_content_type, "str") + if file_content_encoding is not None: + _headers["x-ms-content-encoding"] = _SERIALIZER.header("file_content_encoding", file_content_encoding, "str") + if file_content_language is not None: + _headers["x-ms-content-language"] = _SERIALIZER.header("file_content_language", file_content_language, "str") + if file_cache_control is not None: + _headers["x-ms-cache-control"] = _SERIALIZER.header("file_cache_control", file_cache_control, "str") + if file_content_md5 is not None: + _headers["x-ms-content-md5"] = _SERIALIZER.header("file_content_md5", file_content_md5, "bytearray") + if file_content_disposition is not None: + _headers["x-ms-content-disposition"] = _SERIALIZER.header( + "file_content_disposition", file_content_disposition, "str" + ) + if metadata is not None: + _headers["x-ms-meta"] = _SERIALIZER.header("metadata", metadata, "{str}") + if file_permission is not None: + _headers["x-ms-file-permission"] = _SERIALIZER.header("file_permission", file_permission, "str") + if file_permission_key is not None: + _headers["x-ms-file-permission-key"] = _SERIALIZER.header("file_permission_key", file_permission_key, "str") + if file_attributes is not None: + _headers["x-ms-file-attributes"] = _SERIALIZER.header("file_attributes", file_attributes, "str") + if file_creation_time is not None: + _headers["x-ms-file-creation-time"] = _SERIALIZER.header("file_creation_time", file_creation_time, "str") + if file_last_write_time is not None: + _headers["x-ms-file-last-write-time"] = _SERIALIZER.header("file_last_write_time", file_last_write_time, "str") + if file_change_time is not None: + _headers["x-ms-file-change-time"] = _SERIALIZER.header("file_change_time", file_change_time, "str") + if file_permission_format is not None: + _headers["x-ms-file-permission-format"] = _SERIALIZER.header( + "file_permission_format", file_permission_format, "str" + ) + if lease_id is not None: + _headers["x-ms-lease-id"] = _SERIALIZER.header("lease_id", lease_id, "str") + if allow_trailing_dot is not None: + _headers["x-ms-allow-trailing-dot"] = _SERIALIZER.header("allow_trailing_dot", allow_trailing_dot, "bool") + if file_request_intent is not None: + _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") + if owner is not None: + _headers["x-ms-owner"] = _SERIALIZER.header("owner", owner, "str") + if group is not None: + _headers["x-ms-group"] = _SERIALIZER.header("group", group, "str") + if file_mode is not None: + _headers["x-ms-mode"] = _SERIALIZER.header("file_mode", file_mode, "str") + if nfs_file_type is not None: + _headers["x-ms-file-file-type"] = _SERIALIZER.header("nfs_file_type", nfs_file_type, "str") + if content_md5 is not None: + _headers["Content-MD5"] = _SERIALIZER.header("content_md5", content_md5, "bytearray") + if file_property_semantics is not None: + _headers["x-ms-file-property-semantics"] = _SERIALIZER.header( + "file_property_semantics", file_property_semantics, "str" + ) + if content_length is not None: + _headers["Content-Length"] = _SERIALIZER.header("content_length", content_length, "int") + if structured_body_type is not None: + _headers["x-ms-structured-body"] = _SERIALIZER.header("structured_body_type", structured_body_type, "str") + if structured_content_length is not None: + _headers["x-ms-structured-content-length"] = _SERIALIZER.header( + "structured_content_length", structured_content_length, "int" + ) + + return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_file_download_request( + *, + timeout: Optional[int] = None, + range: Optional[str] = None, + range_get_content_md5: Optional[bool] = None, + lease_id: Optional[str] = None, + allow_trailing_dot: Optional[bool] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + structured_body_type: Optional[str] = None, + **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + version: str = kwargs.pop("version", _headers.pop("x-ms-version", "2026-06-06")) + accept = _headers.pop("Accept", "application/octet-stream") + + # Construct URL + _url = "" + + # Construct parameters + if timeout is not None: + _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int") + + # Construct headers + _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") + if range is not None: + _headers["Range"] = _SERIALIZER.header("range", range, "str") + if range_get_content_md5 is not None: + _headers["x-ms-range-get-content-md5"] = _SERIALIZER.header( + "range_get_content_md5", range_get_content_md5, "bool" + ) + if lease_id is not None: + _headers["x-ms-lease-id"] = _SERIALIZER.header("lease_id", lease_id, "str") + if allow_trailing_dot is not None: + _headers["x-ms-allow-trailing-dot"] = _SERIALIZER.header("allow_trailing_dot", allow_trailing_dot, "bool") + if file_request_intent is not None: + _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") + if structured_body_type is not None: + _headers["x-ms-structured-body"] = _SERIALIZER.header("structured_body_type", structured_body_type, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_file_get_properties_request( + *, + sharesnapshot: Optional[str] = None, + timeout: Optional[int] = None, + lease_id: Optional[str] = None, + allow_trailing_dot: Optional[bool] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + version: str = kwargs.pop("version", _headers.pop("x-ms-version", "2026-06-06")) + # Construct URL + _url = "" + + # Construct parameters + if sharesnapshot is not None: + _params["sharesnapshot"] = _SERIALIZER.query("sharesnapshot", sharesnapshot, "str") + if timeout is not None: + _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int") + + # Construct headers + _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") + if lease_id is not None: + _headers["x-ms-lease-id"] = _SERIALIZER.header("lease_id", lease_id, "str") + if allow_trailing_dot is not None: + _headers["x-ms-allow-trailing-dot"] = _SERIALIZER.header("allow_trailing_dot", allow_trailing_dot, "bool") + if file_request_intent is not None: + _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") + + return HttpRequest(method="HEAD", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_file_delete_request( + *, + timeout: Optional[int] = None, + lease_id: Optional[str] = None, + allow_trailing_dot: Optional[bool] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + version: str = kwargs.pop("version", _headers.pop("x-ms-version", "2026-06-06")) + # Construct URL + _url = "" + + # Construct parameters + if timeout is not None: + _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int") + + # Construct headers + _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") + if lease_id is not None: + _headers["x-ms-lease-id"] = _SERIALIZER.header("lease_id", lease_id, "str") + if allow_trailing_dot is not None: + _headers["x-ms-allow-trailing-dot"] = _SERIALIZER.header("allow_trailing_dot", allow_trailing_dot, "bool") + if file_request_intent is not None: + _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") + + return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_file_set_http_headers_request( # pylint: disable=too-many-locals + *, + timeout: Optional[int] = None, + file_content_length: Optional[int] = None, + file_content_type: Optional[str] = None, + file_content_encoding: Optional[str] = None, + file_content_language: Optional[str] = None, + file_cache_control: Optional[str] = None, + file_content_md5: Optional[bytes] = None, + file_content_disposition: Optional[str] = None, + file_permission: Optional[str] = None, + file_permission_key: Optional[str] = None, + file_attributes: Optional[str] = None, + file_creation_time: Optional[str] = None, + file_last_write_time: Optional[str] = None, + file_change_time: Optional[str] = None, + file_permission_format: Optional[Union[str, _models.FilePermissionFormat]] = None, + lease_id: Optional[str] = None, + allow_trailing_dot: Optional[bool] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + owner: Optional[str] = None, + group: Optional[str] = None, + file_mode: Optional[str] = None, + **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + version: str = kwargs.pop("version", _headers.pop("x-ms-version", "2026-06-06")) + # Construct URL + _url = "?comp=properties" + + # Construct parameters + if timeout is not None: + _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int") + + # Construct headers + _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") + if file_content_length is not None: + _headers["x-ms-content-length"] = _SERIALIZER.header("file_content_length", file_content_length, "int") + if file_content_type is not None: + _headers["x-ms-content-type"] = _SERIALIZER.header("file_content_type", file_content_type, "str") + if file_content_encoding is not None: + _headers["x-ms-content-encoding"] = _SERIALIZER.header("file_content_encoding", file_content_encoding, "str") + if file_content_language is not None: + _headers["x-ms-content-language"] = _SERIALIZER.header("file_content_language", file_content_language, "str") + if file_cache_control is not None: + _headers["x-ms-cache-control"] = _SERIALIZER.header("file_cache_control", file_cache_control, "str") + if file_content_md5 is not None: + _headers["x-ms-content-md5"] = _SERIALIZER.header("file_content_md5", file_content_md5, "bytearray") + if file_content_disposition is not None: + _headers["x-ms-content-disposition"] = _SERIALIZER.header( + "file_content_disposition", file_content_disposition, "str" + ) + if file_permission is not None: + _headers["x-ms-file-permission"] = _SERIALIZER.header("file_permission", file_permission, "str") + if file_permission_key is not None: + _headers["x-ms-file-permission-key"] = _SERIALIZER.header("file_permission_key", file_permission_key, "str") + if file_attributes is not None: + _headers["x-ms-file-attributes"] = _SERIALIZER.header("file_attributes", file_attributes, "str") + if file_creation_time is not None: + _headers["x-ms-file-creation-time"] = _SERIALIZER.header("file_creation_time", file_creation_time, "str") + if file_last_write_time is not None: + _headers["x-ms-file-last-write-time"] = _SERIALIZER.header("file_last_write_time", file_last_write_time, "str") + if file_change_time is not None: + _headers["x-ms-file-change-time"] = _SERIALIZER.header("file_change_time", file_change_time, "str") + if file_permission_format is not None: + _headers["x-ms-file-permission-format"] = _SERIALIZER.header( + "file_permission_format", file_permission_format, "str" + ) + if lease_id is not None: + _headers["x-ms-lease-id"] = _SERIALIZER.header("lease_id", lease_id, "str") + if allow_trailing_dot is not None: + _headers["x-ms-allow-trailing-dot"] = _SERIALIZER.header("allow_trailing_dot", allow_trailing_dot, "bool") + if file_request_intent is not None: + _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") + if owner is not None: + _headers["x-ms-owner"] = _SERIALIZER.header("owner", owner, "str") + if group is not None: + _headers["x-ms-group"] = _SERIALIZER.header("group", group, "str") + if file_mode is not None: + _headers["x-ms-mode"] = _SERIALIZER.header("file_mode", file_mode, "str") + + return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_file_set_metadata_request( + *, + timeout: Optional[int] = None, + metadata: Optional[dict[str, str]] = None, + lease_id: Optional[str] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + allow_trailing_dot: Optional[bool] = None, + **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + version: str = kwargs.pop("version", _headers.pop("x-ms-version", "2026-06-06")) + # Construct URL + _url = "?comp=metadata" + + # Construct parameters + if timeout is not None: + _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int") + + # Construct headers + _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") + if metadata is not None: + _headers["x-ms-meta"] = _SERIALIZER.header("metadata", metadata, "{str}") + if lease_id is not None: + _headers["x-ms-lease-id"] = _SERIALIZER.header("lease_id", lease_id, "str") + if file_request_intent is not None: + _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") + if allow_trailing_dot is not None: + _headers["x-ms-allow-trailing-dot"] = _SERIALIZER.header("allow_trailing_dot", allow_trailing_dot, "bool") + + return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_file_acquire_lease_request( + *, + timeout: Optional[int] = None, + lease_duration: Optional[int] = None, + proposed_lease_id: Optional[str] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + allow_trailing_dot: Optional[bool] = None, + **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + action: Literal["acquire"] = kwargs.pop("action", _headers.pop("x-ms-lease-action", "acquire")) + version: str = kwargs.pop("version", _headers.pop("x-ms-version", "2026-06-06")) + # Construct URL + _url = "?comp=lease" + + # Construct parameters + if timeout is not None: + _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int") + + # Construct headers + _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") + if lease_duration is not None: + _headers["x-ms-lease-duration"] = _SERIALIZER.header("lease_duration", lease_duration, "int") + if proposed_lease_id is not None: + _headers["x-ms-proposed-lease-id"] = _SERIALIZER.header("proposed_lease_id", proposed_lease_id, "str") + _headers["x-ms-lease-action"] = _SERIALIZER.header("action", action, "str") + if file_request_intent is not None: + _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") + if allow_trailing_dot is not None: + _headers["x-ms-allow-trailing-dot"] = _SERIALIZER.header("allow_trailing_dot", allow_trailing_dot, "bool") + + return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_file_release_lease_request( + *, + lease_id: str, + timeout: Optional[int] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + allow_trailing_dot: Optional[bool] = None, + **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + action: Literal["release"] = kwargs.pop("action", _headers.pop("x-ms-lease-action", "release")) + version: str = kwargs.pop("version", _headers.pop("x-ms-version", "2026-06-06")) + # Construct URL + _url = "?comp=lease" + + # Construct parameters + if timeout is not None: + _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int") + + # Construct headers + _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") + _headers["x-ms-lease-id"] = _SERIALIZER.header("lease_id", lease_id, "str") + _headers["x-ms-lease-action"] = _SERIALIZER.header("action", action, "str") + if file_request_intent is not None: + _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") + if allow_trailing_dot is not None: + _headers["x-ms-allow-trailing-dot"] = _SERIALIZER.header("allow_trailing_dot", allow_trailing_dot, "bool") + + return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_file_change_lease_request( + *, + lease_id: str, + timeout: Optional[int] = None, + proposed_lease_id: Optional[str] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + allow_trailing_dot: Optional[bool] = None, + **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + action: Literal["change"] = kwargs.pop("action", _headers.pop("x-ms-lease-action", "change")) + version: str = kwargs.pop("version", _headers.pop("x-ms-version", "2026-06-06")) + # Construct URL + _url = "?comp=lease" + + # Construct parameters + if timeout is not None: + _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int") + + # Construct headers + _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") + _headers["x-ms-lease-id"] = _SERIALIZER.header("lease_id", lease_id, "str") + if proposed_lease_id is not None: + _headers["x-ms-proposed-lease-id"] = _SERIALIZER.header("proposed_lease_id", proposed_lease_id, "str") + _headers["x-ms-lease-action"] = _SERIALIZER.header("action", action, "str") + if file_request_intent is not None: + _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") + if allow_trailing_dot is not None: + _headers["x-ms-allow-trailing-dot"] = _SERIALIZER.header("allow_trailing_dot", allow_trailing_dot, "bool") + + return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_file_break_lease_request( + *, + timeout: Optional[int] = None, + lease_id: Optional[str] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + allow_trailing_dot: Optional[bool] = None, + **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + action: Literal["break"] = kwargs.pop("action", _headers.pop("x-ms-lease-action", "break")) + version: str = kwargs.pop("version", _headers.pop("x-ms-version", "2026-06-06")) + # Construct URL + _url = "?comp=lease" + + # Construct parameters + if timeout is not None: + _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int") + + # Construct headers + _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") + if lease_id is not None: + _headers["x-ms-lease-id"] = _SERIALIZER.header("lease_id", lease_id, "str") + _headers["x-ms-lease-action"] = _SERIALIZER.header("action", action, "str") + if file_request_intent is not None: + _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") + if allow_trailing_dot is not None: + _headers["x-ms-allow-trailing-dot"] = _SERIALIZER.header("allow_trailing_dot", allow_trailing_dot, "bool") + + return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_file_upload_range_request( + *, + range: str, + file_range_write: Union[str, _models.FileRangeWriteType], + content_length: int, + timeout: Optional[int] = None, + content_md5: Optional[bytes] = None, + lease_id: Optional[str] = None, + file_last_written_mode: Optional[Union[str, _models.FileLastWrittenMode]] = None, + allow_trailing_dot: Optional[bool] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + structured_body_type: Optional[str] = None, + structured_content_length: Optional[int] = None, + **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + version: str = kwargs.pop("version", _headers.pop("x-ms-version", "2026-06-06")) + # Construct URL + _url = "?comp=range" + + # Construct parameters + if timeout is not None: + _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int") + + # Construct headers + _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") + if content_type is not None: + _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") + _headers["Range"] = _SERIALIZER.header("range", range, "str") + _headers["x-ms-write"] = _SERIALIZER.header("file_range_write", file_range_write, "str") + _headers["Content-Length"] = _SERIALIZER.header("content_length", content_length, "int") + if content_md5 is not None: + _headers["Content-MD5"] = _SERIALIZER.header("content_md5", content_md5, "bytearray") + if lease_id is not None: + _headers["x-ms-lease-id"] = _SERIALIZER.header("lease_id", lease_id, "str") + if file_last_written_mode is not None: + _headers["x-ms-file-last-write-time"] = _SERIALIZER.header( + "file_last_written_mode", file_last_written_mode, "str" + ) + if allow_trailing_dot is not None: + _headers["x-ms-allow-trailing-dot"] = _SERIALIZER.header("allow_trailing_dot", allow_trailing_dot, "bool") + if file_request_intent is not None: + _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") + if structured_body_type is not None: + _headers["x-ms-structured-body"] = _SERIALIZER.header("structured_body_type", structured_body_type, "str") + if structured_content_length is not None: + _headers["x-ms-structured-content-length"] = _SERIALIZER.header( + "structured_content_length", structured_content_length, "int" + ) + + return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_file_upload_range_from_url_request( + *, + range: str, + copy_source: str, + file_range_write_from_url: Union[str, _models.FileRangeWriteFromUrlType], + content_length: int, + source_range: Optional[str] = None, + timeout: Optional[int] = None, + source_content_crc64: Optional[bytes] = None, + source_if_match_crc64: Optional[bytes] = None, + source_if_none_match_crc64: Optional[bytes] = None, + lease_id: Optional[str] = None, + copy_source_authorization: Optional[str] = None, + file_last_written_mode: Optional[Union[str, _models.FileLastWrittenMode]] = None, + allow_trailing_dot: Optional[bool] = None, + allow_source_trailing_dot: Optional[bool] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + version: str = kwargs.pop("version", _headers.pop("x-ms-version", "2026-06-06")) + # Construct URL + _url = "?comp=range" + + # Construct parameters + if timeout is not None: + _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int") + + # Construct headers + _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") + _headers["Range"] = _SERIALIZER.header("range", range, "str") + _headers["x-ms-copy-source"] = _SERIALIZER.header("copy_source", copy_source, "str") + if source_range is not None: + _headers["x-ms-source-range"] = _SERIALIZER.header("source_range", source_range, "str") + _headers["x-ms-write"] = _SERIALIZER.header("file_range_write_from_url", file_range_write_from_url, "str") + _headers["Content-Length"] = _SERIALIZER.header("content_length", content_length, "int") + if source_content_crc64 is not None: + _headers["x-ms-source-content-crc64"] = _SERIALIZER.header( + "source_content_crc64", source_content_crc64, "bytearray" + ) + if source_if_match_crc64 is not None: + _headers["x-ms-source-if-match-crc64"] = _SERIALIZER.header( + "source_if_match_crc64", source_if_match_crc64, "bytearray" + ) + if source_if_none_match_crc64 is not None: + _headers["x-ms-source-if-none-match-crc64"] = _SERIALIZER.header( + "source_if_none_match_crc64", source_if_none_match_crc64, "bytearray" + ) + if lease_id is not None: + _headers["x-ms-lease-id"] = _SERIALIZER.header("lease_id", lease_id, "str") + if copy_source_authorization is not None: + _headers["x-ms-copy-source-authorization"] = _SERIALIZER.header( + "copy_source_authorization", copy_source_authorization, "str" + ) + if file_last_written_mode is not None: + _headers["x-ms-file-last-write-time"] = _SERIALIZER.header( + "file_last_written_mode", file_last_written_mode, "str" + ) + if allow_trailing_dot is not None: + _headers["x-ms-allow-trailing-dot"] = _SERIALIZER.header("allow_trailing_dot", allow_trailing_dot, "bool") + if allow_source_trailing_dot is not None: + _headers["x-ms-source-allow-trailing-dot"] = _SERIALIZER.header( + "allow_source_trailing_dot", allow_source_trailing_dot, "bool" + ) + if file_request_intent is not None: + _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") + + return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_file_get_range_list_request( + *, + sharesnapshot: Optional[str] = None, + prevsharesnapshot: Optional[str] = None, + timeout: Optional[int] = None, + range: Optional[str] = None, + lease_id: Optional[str] = None, + allow_trailing_dot: Optional[bool] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + support_rename: Optional[bool] = None, + **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + version: str = kwargs.pop("version", _headers.pop("x-ms-version", "2026-06-06")) + accept = _headers.pop("Accept", "application/xml") + + # Construct URL + _url = "?comp=rangelist" + + # Construct parameters + if sharesnapshot is not None: + _params["sharesnapshot"] = _SERIALIZER.query("sharesnapshot", sharesnapshot, "str") + if prevsharesnapshot is not None: + _params["prevsharesnapshot"] = _SERIALIZER.query("prevsharesnapshot", prevsharesnapshot, "str") + if timeout is not None: + _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int") + + # Construct headers + _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") + if range is not None: + _headers["Range"] = _SERIALIZER.header("range", range, "str") + if lease_id is not None: + _headers["x-ms-lease-id"] = _SERIALIZER.header("lease_id", lease_id, "str") + if allow_trailing_dot is not None: + _headers["x-ms-allow-trailing-dot"] = _SERIALIZER.header("allow_trailing_dot", allow_trailing_dot, "bool") + if file_request_intent is not None: + _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") + if support_rename is not None: + _headers["x-ms-file-support-rename"] = _SERIALIZER.header("support_rename", support_rename, "bool") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_file_start_copy_request( # pylint: disable=too-many-locals + *, + copy_source: str, + timeout: Optional[int] = None, + metadata: Optional[dict[str, str]] = None, + file_permission: Optional[str] = None, + file_permission_format: Optional[Union[str, _models.FilePermissionFormat]] = None, + file_permission_key: Optional[str] = None, + file_permission_copy_mode: Optional[Union[str, _models.PermissionCopyModeType]] = None, + ignore_read_only: Optional[bool] = None, + file_attributes: Optional[str] = None, + file_creation_time: Optional[str] = None, + file_last_write_time: Optional[str] = None, + file_change_time: Optional[str] = None, + set_archive_attribute: Optional[bool] = None, + lease_id: Optional[str] = None, + allow_trailing_dot: Optional[bool] = None, + allow_source_trailing_dot: Optional[bool] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + owner: Optional[str] = None, + group: Optional[str] = None, + file_mode: Optional[str] = None, + file_mode_copy_mode: Optional[Union[str, _models.ModeCopyMode]] = None, + file_owner_copy_mode: Optional[Union[str, _models.OwnerCopyMode]] = None, + **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + version: str = kwargs.pop("version", _headers.pop("x-ms-version", "2026-06-06")) + # Construct URL + _url = "" + + # Construct parameters + if timeout is not None: + _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int") + + # Construct headers + _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") + _headers["x-ms-copy-source"] = _SERIALIZER.header("copy_source", copy_source, "str") + if metadata is not None: + _headers["x-ms-meta"] = _SERIALIZER.header("metadata", metadata, "{str}") + if file_permission is not None: + _headers["x-ms-file-permission"] = _SERIALIZER.header("file_permission", file_permission, "str") + if file_permission_format is not None: + _headers["x-ms-file-permission-format"] = _SERIALIZER.header( + "file_permission_format", file_permission_format, "str" + ) + if file_permission_key is not None: + _headers["x-ms-file-permission-key"] = _SERIALIZER.header("file_permission_key", file_permission_key, "str") + if file_permission_copy_mode is not None: + _headers["x-ms-file-permission-copy-mode"] = _SERIALIZER.header( + "file_permission_copy_mode", file_permission_copy_mode, "str" + ) + if ignore_read_only is not None: + _headers["x-ms-file-copy-ignore-readonly"] = _SERIALIZER.header("ignore_read_only", ignore_read_only, "bool") + if file_attributes is not None: + _headers["x-ms-file-attributes"] = _SERIALIZER.header("file_attributes", file_attributes, "str") + if file_creation_time is not None: + _headers["x-ms-file-creation-time"] = _SERIALIZER.header("file_creation_time", file_creation_time, "str") + if file_last_write_time is not None: + _headers["x-ms-file-last-write-time"] = _SERIALIZER.header("file_last_write_time", file_last_write_time, "str") + if file_change_time is not None: + _headers["x-ms-file-change-time"] = _SERIALIZER.header("file_change_time", file_change_time, "str") + if set_archive_attribute is not None: + _headers["x-ms-file-copy-set-archive"] = _SERIALIZER.header( + "set_archive_attribute", set_archive_attribute, "bool" + ) + if lease_id is not None: + _headers["x-ms-lease-id"] = _SERIALIZER.header("lease_id", lease_id, "str") + if allow_trailing_dot is not None: + _headers["x-ms-allow-trailing-dot"] = _SERIALIZER.header("allow_trailing_dot", allow_trailing_dot, "bool") + if allow_source_trailing_dot is not None: + _headers["x-ms-source-allow-trailing-dot"] = _SERIALIZER.header( + "allow_source_trailing_dot", allow_source_trailing_dot, "bool" + ) + if file_request_intent is not None: + _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") + if owner is not None: + _headers["x-ms-owner"] = _SERIALIZER.header("owner", owner, "str") + if group is not None: + _headers["x-ms-group"] = _SERIALIZER.header("group", group, "str") + if file_mode is not None: + _headers["x-ms-mode"] = _SERIALIZER.header("file_mode", file_mode, "str") + if file_mode_copy_mode is not None: + _headers["x-ms-file-mode-copy-mode"] = _SERIALIZER.header("file_mode_copy_mode", file_mode_copy_mode, "str") + if file_owner_copy_mode is not None: + _headers["x-ms-file-owner-copy-mode"] = _SERIALIZER.header("file_owner_copy_mode", file_owner_copy_mode, "str") + + return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_file_abort_copy_request( + *, + copyid: str, + timeout: Optional[int] = None, + lease_id: Optional[str] = None, + allow_trailing_dot: Optional[bool] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + copy_action_abort_constant: Literal["abort"] = kwargs.pop( + "copy_action_abort_constant", _headers.pop("x-ms-copy-action", "abort") + ) + version: str = kwargs.pop("version", _headers.pop("x-ms-version", "2026-06-06")) + # Construct URL + _url = "?comp=copy" + + # Construct parameters + _params["copyid"] = _SERIALIZER.query("copyid", copyid, "str") + if timeout is not None: + _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int") + + # Construct headers + _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") + _headers["x-ms-copy-action"] = _SERIALIZER.header("copy_action_abort_constant", copy_action_abort_constant, "str") + if lease_id is not None: + _headers["x-ms-lease-id"] = _SERIALIZER.header("lease_id", lease_id, "str") + if allow_trailing_dot is not None: + _headers["x-ms-allow-trailing-dot"] = _SERIALIZER.header("allow_trailing_dot", allow_trailing_dot, "bool") + if file_request_intent is not None: + _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") + + return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_file_list_handles_request( + *, + marker: Optional[str] = None, + maxresults: Optional[int] = None, + timeout: Optional[int] = None, + sharesnapshot: Optional[str] = None, + allow_trailing_dot: Optional[bool] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + version: str = kwargs.pop("version", _headers.pop("x-ms-version", "2026-06-06")) + accept = _headers.pop("Accept", "application/xml") + + # Construct URL + _url = "?comp=listhandles" + + # Construct parameters + if marker is not None: + _params["marker"] = _SERIALIZER.query("marker", marker, "str") + if maxresults is not None: + _params["maxresults"] = _SERIALIZER.query("maxresults", maxresults, "int") + if timeout is not None: + _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int") + if sharesnapshot is not None: + _params["sharesnapshot"] = _SERIALIZER.query("sharesnapshot", sharesnapshot, "str") + + # Construct headers + _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") + if allow_trailing_dot is not None: + _headers["x-ms-allow-trailing-dot"] = _SERIALIZER.header("allow_trailing_dot", allow_trailing_dot, "bool") + if file_request_intent is not None: + _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_file_force_close_handles_request( + *, + handle_id: str, + timeout: Optional[int] = None, + marker: Optional[str] = None, + sharesnapshot: Optional[str] = None, + allow_trailing_dot: Optional[bool] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + version: str = kwargs.pop("version", _headers.pop("x-ms-version", "2026-06-06")) + # Construct URL + _url = "?comp=forceclosehandles" + + # Construct parameters + if timeout is not None: + _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int") + if marker is not None: + _params["marker"] = _SERIALIZER.query("marker", marker, "str") + if sharesnapshot is not None: + _params["sharesnapshot"] = _SERIALIZER.query("sharesnapshot", sharesnapshot, "str") + + # Construct headers + _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") + _headers["x-ms-handle-id"] = _SERIALIZER.header("handle_id", handle_id, "str") + if allow_trailing_dot is not None: + _headers["x-ms-allow-trailing-dot"] = _SERIALIZER.header("allow_trailing_dot", allow_trailing_dot, "bool") + if file_request_intent is not None: + _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") + + return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_file_rename_request( + *, + rename_source: str, + timeout: Optional[int] = None, + replace_if_exists: Optional[bool] = None, + ignore_read_only: Optional[bool] = None, + source_lease_id: Optional[str] = None, + destination_lease_id: Optional[str] = None, + file_attributes: Optional[str] = None, + file_creation_time: Optional[str] = None, + file_last_write_time: Optional[str] = None, + file_change_time: Optional[str] = None, + file_permission: Optional[str] = None, + file_permission_format: Optional[Union[str, _models.FilePermissionFormat]] = None, + file_permission_key: Optional[str] = None, + metadata: Optional[dict[str, str]] = None, + file_content_type: Optional[str] = None, + allow_trailing_dot: Optional[bool] = None, + allow_source_trailing_dot: Optional[bool] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + version: str = kwargs.pop("version", _headers.pop("x-ms-version", "2026-06-06")) + # Construct URL + _url = "?comp=rename" + + # Construct parameters + if timeout is not None: + _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int") + + # Construct headers + _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") + _headers["x-ms-file-rename-source"] = _SERIALIZER.header("rename_source", rename_source, "str") + if replace_if_exists is not None: + _headers["x-ms-file-rename-replace-if-exists"] = _SERIALIZER.header( + "replace_if_exists", replace_if_exists, "bool" + ) + if ignore_read_only is not None: + _headers["x-ms-file-rename-ignore-readonly"] = _SERIALIZER.header("ignore_read_only", ignore_read_only, "bool") + if source_lease_id is not None: + _headers["x-ms-source-lease-id"] = _SERIALIZER.header("source_lease_id", source_lease_id, "str") + if destination_lease_id is not None: + _headers["x-ms-destination-lease-id"] = _SERIALIZER.header("destination_lease_id", destination_lease_id, "str") + if file_attributes is not None: + _headers["x-ms-file-attributes"] = _SERIALIZER.header("file_attributes", file_attributes, "str") + if file_creation_time is not None: + _headers["x-ms-file-creation-time"] = _SERIALIZER.header("file_creation_time", file_creation_time, "str") + if file_last_write_time is not None: + _headers["x-ms-file-last-write-time"] = _SERIALIZER.header("file_last_write_time", file_last_write_time, "str") + if file_change_time is not None: + _headers["x-ms-file-change-time"] = _SERIALIZER.header("file_change_time", file_change_time, "str") + if file_permission is not None: + _headers["x-ms-file-permission"] = _SERIALIZER.header("file_permission", file_permission, "str") + if file_permission_format is not None: + _headers["x-ms-file-permission-format"] = _SERIALIZER.header( + "file_permission_format", file_permission_format, "str" + ) + if file_permission_key is not None: + _headers["x-ms-file-permission-key"] = _SERIALIZER.header("file_permission_key", file_permission_key, "str") + if metadata is not None: + _headers["x-ms-meta"] = _SERIALIZER.header("metadata", metadata, "{str}") + if file_content_type is not None: + _headers["x-ms-content-type"] = _SERIALIZER.header("file_content_type", file_content_type, "str") + if allow_trailing_dot is not None: + _headers["x-ms-allow-trailing-dot"] = _SERIALIZER.header("allow_trailing_dot", allow_trailing_dot, "bool") + if allow_source_trailing_dot is not None: + _headers["x-ms-source-allow-trailing-dot"] = _SERIALIZER.header( + "allow_source_trailing_dot", allow_source_trailing_dot, "bool" + ) + if file_request_intent is not None: + _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") + + return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_file_create_symbolic_link_request( + *, + link_text: str, + timeout: Optional[int] = None, + metadata: Optional[dict[str, str]] = None, + file_creation_time: Optional[str] = None, + file_last_write_time: Optional[str] = None, + lease_id: Optional[str] = None, + owner: Optional[str] = None, + group: Optional[str] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + version: str = kwargs.pop("version", _headers.pop("x-ms-version", "2026-06-06")) + # Construct URL + _url = "?restype=symboliclink" + + # Construct parameters + if timeout is not None: + _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int") + + # Construct headers + _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") + if metadata is not None: + _headers["x-ms-meta"] = _SERIALIZER.header("metadata", metadata, "{str}") + if file_creation_time is not None: + _headers["x-ms-file-creation-time"] = _SERIALIZER.header("file_creation_time", file_creation_time, "str") + if file_last_write_time is not None: + _headers["x-ms-file-last-write-time"] = _SERIALIZER.header("file_last_write_time", file_last_write_time, "str") + if lease_id is not None: + _headers["x-ms-lease-id"] = _SERIALIZER.header("lease_id", lease_id, "str") + if owner is not None: + _headers["x-ms-owner"] = _SERIALIZER.header("owner", owner, "str") + if group is not None: + _headers["x-ms-group"] = _SERIALIZER.header("group", group, "str") + _headers["x-ms-link-text"] = _SERIALIZER.header("link_text", link_text, "str") + if file_request_intent is not None: + _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") + + return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_file_get_symbolic_link_request( + *, + timeout: Optional[int] = None, + sharesnapshot: Optional[str] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + version: str = kwargs.pop("version", _headers.pop("x-ms-version", "2026-06-06")) + # Construct URL + _url = "?restype=symboliclink" + + # Construct parameters + if timeout is not None: + _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int") + if sharesnapshot is not None: + _params["sharesnapshot"] = _SERIALIZER.query("sharesnapshot", sharesnapshot, "str") + + # Construct headers + _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") + if file_request_intent is not None: + _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_file_create_hard_link_request( + *, + target_file: str, + timeout: Optional[int] = None, + lease_id: Optional[str] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + file_type: Literal["file"] = kwargs.pop("file_type", _headers.pop("x-ms-type", "file")) + version: str = kwargs.pop("version", _headers.pop("x-ms-version", "2026-06-06")) + # Construct URL + _url = "?restype=hardlink" + + # Construct parameters + if timeout is not None: + _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int") + + # Construct headers + _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") + _headers["x-ms-type"] = _SERIALIZER.header("file_type", file_type, "str") + if lease_id is not None: + _headers["x-ms-lease-id"] = _SERIALIZER.header("lease_id", lease_id, "str") + _headers["x-ms-file-target-file"] = _SERIALIZER.header("target_file", target_file, "str") + if file_request_intent is not None: + _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") + + return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_service_set_properties_request( + *, + timeout: Optional[int] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + content_type: str = kwargs.pop("content_type") + version: str = kwargs.pop("version", _headers.pop("x-ms-version", "2026-06-06")) + # Construct URL + _url = "/?restype=service&comp=properties" + + # Construct parameters + if timeout is not None: + _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int") + + # Construct headers + _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") + _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") + if file_request_intent is not None: + _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") + + return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_service_get_properties_request( + *, + timeout: Optional[int] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + version: str = kwargs.pop("version", _headers.pop("x-ms-version", "2026-06-06")) + accept = _headers.pop("Accept", "application/xml") + + # Construct URL + _url = "/?restype=service&comp=properties" + + # Construct parameters + if timeout is not None: + _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int") + + # Construct headers + _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") + if file_request_intent is not None: + _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_service_list_shares_segment_request( # pylint: disable=name-too-long + *, + prefix: Optional[str] = None, + marker: Optional[str] = None, + maxresults: Optional[int] = None, + timeout: Optional[int] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + include: Optional[list[Union[str, _models.ListSharesIncludeType]]] = None, + **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + version: str = kwargs.pop("version", _headers.pop("x-ms-version", "2026-06-06")) + accept = _headers.pop("Accept", "application/xml") + + # Construct URL + _url = "/?comp=list" + + # Construct parameters + if prefix is not None: + _params["prefix"] = _SERIALIZER.query("prefix", prefix, "str") + if marker is not None: + _params["marker"] = _SERIALIZER.query("marker", marker, "str") + if maxresults is not None: + _params["maxresults"] = _SERIALIZER.query("maxresults", maxresults, "int") + if timeout is not None: + _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int") + if include is not None: + _params["include"] = _SERIALIZER.query("include", include, "[str]", div=",") + + # Construct headers + _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") + if file_request_intent is not None: + _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_service_get_user_delegation_key_request( # pylint: disable=name-too-long + *, timeout: Optional[int] = None, **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + content_type: str = kwargs.pop("content_type") + version: str = kwargs.pop("version", _headers.pop("x-ms-version", "2026-06-06")) + accept = _headers.pop("Accept", "application/xml") + + # Construct URL + _url = "/?restype=service&comp=userdelegationkey" + + # Construct parameters + if timeout is not None: + _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int") + + # Construct headers + _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") + _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_share_create_request( + *, + timeout: Optional[int] = None, + metadata: Optional[dict[str, str]] = None, + quota: Optional[int] = None, + access_tier: Optional[Union[str, _models.ShareAccessTier]] = None, + enabled_protocols: Optional[str] = None, + root_squash: Optional[Union[str, _models.ShareRootSquash]] = None, + enable_snapshot_virtual_directory_access: Optional[bool] = None, + paid_bursting_enabled: Optional[bool] = None, + paid_bursting_max_iops: Optional[int] = None, + paid_bursting_max_bandwidth_mibps: Optional[int] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + share_provisioned_iops: Optional[int] = None, + share_provisioned_bandwidth_mibps: Optional[int] = None, + enable_smb_directory_lease: Optional[bool] = None, + **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + version: str = kwargs.pop("version", _headers.pop("x-ms-version", "2026-06-06")) + # Construct URL + _url = "?restype=share" + + # Construct parameters + if timeout is not None: + _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int") + + # Construct headers + _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") + if metadata is not None: + _headers["x-ms-meta"] = _SERIALIZER.header("metadata", metadata, "{str}") + if quota is not None: + _headers["x-ms-share-quota"] = _SERIALIZER.header("quota", quota, "int") + if access_tier is not None: + _headers["x-ms-access-tier"] = _SERIALIZER.header("access_tier", access_tier, "str") + if enabled_protocols is not None: + _headers["x-ms-enabled-protocols"] = _SERIALIZER.header("enabled_protocols", enabled_protocols, "str") + if root_squash is not None: + _headers["x-ms-root-squash"] = _SERIALIZER.header("root_squash", root_squash, "str") + if enable_snapshot_virtual_directory_access is not None: + _headers["x-ms-enable-snapshot-virtual-directory-access"] = _SERIALIZER.header( + "enable_snapshot_virtual_directory_access", enable_snapshot_virtual_directory_access, "bool" + ) + if paid_bursting_enabled is not None: + _headers["x-ms-share-paid-bursting-enabled"] = _SERIALIZER.header( + "paid_bursting_enabled", paid_bursting_enabled, "bool" + ) + if paid_bursting_max_iops is not None: + _headers["x-ms-share-paid-bursting-max-iops"] = _SERIALIZER.header( + "paid_bursting_max_iops", paid_bursting_max_iops, "int" + ) + if paid_bursting_max_bandwidth_mibps is not None: + _headers["x-ms-share-paid-bursting-max-bandwidth-mibps"] = _SERIALIZER.header( + "paid_bursting_max_bandwidth_mibps", paid_bursting_max_bandwidth_mibps, "int" + ) + if file_request_intent is not None: + _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") + if share_provisioned_iops is not None: + _headers["x-ms-share-provisioned-iops"] = _SERIALIZER.header( + "share_provisioned_iops", share_provisioned_iops, "int" + ) + if share_provisioned_bandwidth_mibps is not None: + _headers["x-ms-share-provisioned-bandwidth-mibps"] = _SERIALIZER.header( + "share_provisioned_bandwidth_mibps", share_provisioned_bandwidth_mibps, "int" + ) + if enable_smb_directory_lease is not None: + _headers["x-ms-enable-smb-directory-lease"] = _SERIALIZER.header( + "enable_smb_directory_lease", enable_smb_directory_lease, "bool" + ) + + return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_share_get_properties_request( + *, + sharesnapshot: Optional[str] = None, + timeout: Optional[int] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + lease_id: Optional[str] = None, + **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + version: str = kwargs.pop("version", _headers.pop("x-ms-version", "2026-06-06")) + # Construct URL + _url = "?restype=share" + + # Construct parameters + if sharesnapshot is not None: + _params["sharesnapshot"] = _SERIALIZER.query("sharesnapshot", sharesnapshot, "str") + if timeout is not None: + _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int") + + # Construct headers + _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") + if file_request_intent is not None: + _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") + if lease_id is not None: + _headers["x-ms-lease-id"] = _SERIALIZER.header("lease_id", lease_id, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_share_delete_request( + *, + sharesnapshot: Optional[str] = None, + timeout: Optional[int] = None, + delete_snapshots: Optional[Union[str, _models.DeleteSnapshotsOptionType]] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + lease_id: Optional[str] = None, + **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + version: str = kwargs.pop("version", _headers.pop("x-ms-version", "2026-06-06")) + # Construct URL + _url = "?restype=share" + + # Construct parameters + if sharesnapshot is not None: + _params["sharesnapshot"] = _SERIALIZER.query("sharesnapshot", sharesnapshot, "str") + if timeout is not None: + _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int") + + # Construct headers + _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") + if delete_snapshots is not None: + _headers["x-ms-delete-snapshots"] = _SERIALIZER.header("delete_snapshots", delete_snapshots, "str") + if file_request_intent is not None: + _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") + if lease_id is not None: + _headers["x-ms-lease-id"] = _SERIALIZER.header("lease_id", lease_id, "str") + + return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_share_acquire_lease_request( + *, + timeout: Optional[int] = None, + lease_duration: Optional[int] = None, + proposed_lease_id: Optional[str] = None, + sharesnapshot: Optional[str] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + action: Literal["acquire"] = kwargs.pop("action", _headers.pop("x-ms-lease-action", "acquire")) + version: str = kwargs.pop("version", _headers.pop("x-ms-version", "2026-06-06")) + # Construct URL + _url = "?restype=share&comp=lease" + + # Construct parameters + if timeout is not None: + _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int") + if sharesnapshot is not None: + _params["sharesnapshot"] = _SERIALIZER.query("sharesnapshot", sharesnapshot, "str") + + # Construct headers + _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") + if lease_duration is not None: + _headers["x-ms-lease-duration"] = _SERIALIZER.header("lease_duration", lease_duration, "int") + if proposed_lease_id is not None: + _headers["x-ms-proposed-lease-id"] = _SERIALIZER.header("proposed_lease_id", proposed_lease_id, "str") + _headers["x-ms-lease-action"] = _SERIALIZER.header("action", action, "str") + if file_request_intent is not None: + _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") + + return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_share_release_lease_request( + *, + lease_id: str, + timeout: Optional[int] = None, + sharesnapshot: Optional[str] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + action: Literal["release"] = kwargs.pop("action", _headers.pop("x-ms-lease-action", "release")) + version: str = kwargs.pop("version", _headers.pop("x-ms-version", "2026-06-06")) + # Construct URL + _url = "?restype=share&comp=lease" + + # Construct parameters + if timeout is not None: + _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int") + if sharesnapshot is not None: + _params["sharesnapshot"] = _SERIALIZER.query("sharesnapshot", sharesnapshot, "str") + + # Construct headers + _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") + _headers["x-ms-lease-id"] = _SERIALIZER.header("lease_id", lease_id, "str") + _headers["x-ms-lease-action"] = _SERIALIZER.header("action", action, "str") + if file_request_intent is not None: + _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") + + return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_share_change_lease_request( + *, + lease_id: str, + proposed_lease_id: Optional[str] = None, + timeout: Optional[int] = None, + sharesnapshot: Optional[str] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + action: Literal["change"] = kwargs.pop("action", _headers.pop("x-ms-lease-action", "change")) + version: str = kwargs.pop("version", _headers.pop("x-ms-version", "2026-06-06")) + # Construct URL + _url = "?restype=share&comp=lease" + + # Construct parameters + if timeout is not None: + _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int") + if sharesnapshot is not None: + _params["sharesnapshot"] = _SERIALIZER.query("sharesnapshot", sharesnapshot, "str") + + # Construct headers + _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") + _headers["x-ms-lease-id"] = _SERIALIZER.header("lease_id", lease_id, "str") + if proposed_lease_id is not None: + _headers["x-ms-proposed-lease-id"] = _SERIALIZER.header("proposed_lease_id", proposed_lease_id, "str") + _headers["x-ms-lease-action"] = _SERIALIZER.header("action", action, "str") + if file_request_intent is not None: + _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") + + return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_share_renew_lease_request( + *, + lease_id: str, + timeout: Optional[int] = None, + sharesnapshot: Optional[str] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + action: Literal["renew"] = kwargs.pop("action", _headers.pop("x-ms-lease-action", "renew")) + version: str = kwargs.pop("version", _headers.pop("x-ms-version", "2026-06-06")) + # Construct URL + _url = "?restype=share&comp=lease" + + # Construct parameters + if timeout is not None: + _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int") + if sharesnapshot is not None: + _params["sharesnapshot"] = _SERIALIZER.query("sharesnapshot", sharesnapshot, "str") + + # Construct headers + _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") + _headers["x-ms-lease-id"] = _SERIALIZER.header("lease_id", lease_id, "str") + _headers["x-ms-lease-action"] = _SERIALIZER.header("action", action, "str") + if file_request_intent is not None: + _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") + + return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_share_break_lease_request( + *, + timeout: Optional[int] = None, + break_period: Optional[int] = None, + lease_id: Optional[str] = None, + sharesnapshot: Optional[str] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + action: Literal["break"] = kwargs.pop("action", _headers.pop("x-ms-lease-action", "break")) + version: str = kwargs.pop("version", _headers.pop("x-ms-version", "2026-06-06")) + # Construct URL + _url = "?restype=share&comp=lease" + + # Construct parameters + if timeout is not None: + _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int") + if sharesnapshot is not None: + _params["sharesnapshot"] = _SERIALIZER.query("sharesnapshot", sharesnapshot, "str") + + # Construct headers + _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") + if break_period is not None: + _headers["x-ms-lease-break-period"] = _SERIALIZER.header("break_period", break_period, "int") + if lease_id is not None: + _headers["x-ms-lease-id"] = _SERIALIZER.header("lease_id", lease_id, "str") + _headers["x-ms-lease-action"] = _SERIALIZER.header("action", action, "str") + if file_request_intent is not None: + _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") + + return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_share_create_snapshot_request( + *, + timeout: Optional[int] = None, + metadata: Optional[dict[str, str]] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + version: str = kwargs.pop("version", _headers.pop("x-ms-version", "2026-06-06")) + # Construct URL + _url = "?restype=share&comp=snapshot" + + # Construct parameters + if timeout is not None: + _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int") + + # Construct headers + _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") + if metadata is not None: + _headers["x-ms-meta"] = _SERIALIZER.header("metadata", metadata, "{str}") + if file_request_intent is not None: + _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") + + return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_share_create_permission_request( + *, + timeout: Optional[int] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + version: str = kwargs.pop("version", _headers.pop("x-ms-version", "2026-06-06")) + # Construct URL + _url = "?restype=share&comp=filepermission" + + # Construct parameters + if timeout is not None: + _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int") + + # Construct headers + _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") + if content_type is not None: + _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") + if file_request_intent is not None: + _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") + + return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_share_get_permission_request( + *, + file_permission_key: str, + timeout: Optional[int] = None, + file_permission_format: Optional[Union[str, _models.FilePermissionFormat]] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + version: str = kwargs.pop("version", _headers.pop("x-ms-version", "2026-06-06")) + accept = _headers.pop("Accept", "application/json") + + # Construct URL + _url = "?restype=share&comp=filepermission" + + # Construct parameters + if timeout is not None: + _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int") + + # Construct headers + _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") + _headers["x-ms-file-permission-key"] = _SERIALIZER.header("file_permission_key", file_permission_key, "str") + if file_permission_format is not None: + _headers["x-ms-file-permission-format"] = _SERIALIZER.header( + "file_permission_format", file_permission_format, "str" + ) + if file_request_intent is not None: + _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_share_set_properties_request( + *, + timeout: Optional[int] = None, + quota: Optional[int] = None, + access_tier: Optional[Union[str, _models.ShareAccessTier]] = None, + lease_id: Optional[str] = None, + root_squash: Optional[Union[str, _models.ShareRootSquash]] = None, + enable_snapshot_virtual_directory_access: Optional[bool] = None, + paid_bursting_enabled: Optional[bool] = None, + paid_bursting_max_iops: Optional[int] = None, + paid_bursting_max_bandwidth_mibps: Optional[int] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + share_provisioned_iops: Optional[int] = None, + share_provisioned_bandwidth_mibps: Optional[int] = None, + enable_smb_directory_lease: Optional[bool] = None, + **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + version: str = kwargs.pop("version", _headers.pop("x-ms-version", "2026-06-06")) + # Construct URL + _url = "?restype=share&comp=properties" + + # Construct parameters + if timeout is not None: + _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int") + + # Construct headers + _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") + if quota is not None: + _headers["x-ms-share-quota"] = _SERIALIZER.header("quota", quota, "int") + if access_tier is not None: + _headers["x-ms-access-tier"] = _SERIALIZER.header("access_tier", access_tier, "str") + if lease_id is not None: + _headers["x-ms-lease-id"] = _SERIALIZER.header("lease_id", lease_id, "str") + if root_squash is not None: + _headers["x-ms-root-squash"] = _SERIALIZER.header("root_squash", root_squash, "str") + if enable_snapshot_virtual_directory_access is not None: + _headers["x-ms-enable-snapshot-virtual-directory-access"] = _SERIALIZER.header( + "enable_snapshot_virtual_directory_access", enable_snapshot_virtual_directory_access, "bool" + ) + if paid_bursting_enabled is not None: + _headers["x-ms-share-paid-bursting-enabled"] = _SERIALIZER.header( + "paid_bursting_enabled", paid_bursting_enabled, "bool" + ) + if paid_bursting_max_iops is not None: + _headers["x-ms-share-paid-bursting-max-iops"] = _SERIALIZER.header( + "paid_bursting_max_iops", paid_bursting_max_iops, "int" + ) + if paid_bursting_max_bandwidth_mibps is not None: + _headers["x-ms-share-paid-bursting-max-bandwidth-mibps"] = _SERIALIZER.header( + "paid_bursting_max_bandwidth_mibps", paid_bursting_max_bandwidth_mibps, "int" + ) + if file_request_intent is not None: + _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") + if share_provisioned_iops is not None: + _headers["x-ms-share-provisioned-iops"] = _SERIALIZER.header( + "share_provisioned_iops", share_provisioned_iops, "int" + ) + if share_provisioned_bandwidth_mibps is not None: + _headers["x-ms-share-provisioned-bandwidth-mibps"] = _SERIALIZER.header( + "share_provisioned_bandwidth_mibps", share_provisioned_bandwidth_mibps, "int" + ) + if enable_smb_directory_lease is not None: + _headers["x-ms-enable-smb-directory-lease"] = _SERIALIZER.header( + "enable_smb_directory_lease", enable_smb_directory_lease, "bool" + ) + + return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_share_set_metadata_request( + *, + timeout: Optional[int] = None, + metadata: Optional[dict[str, str]] = None, + lease_id: Optional[str] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + version: str = kwargs.pop("version", _headers.pop("x-ms-version", "2026-06-06")) + # Construct URL + _url = "?restype=share&comp=metadata" + + # Construct parameters + if timeout is not None: + _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int") + + # Construct headers + _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") + if metadata is not None: + _headers["x-ms-meta"] = _SERIALIZER.header("metadata", metadata, "{str}") + if lease_id is not None: + _headers["x-ms-lease-id"] = _SERIALIZER.header("lease_id", lease_id, "str") + if file_request_intent is not None: + _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") + + return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_share_get_access_policy_request( + *, + timeout: Optional[int] = None, + lease_id: Optional[str] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + version: str = kwargs.pop("version", _headers.pop("x-ms-version", "2026-06-06")) + accept = _headers.pop("Accept", "application/xml") + + # Construct URL + _url = "?restype=share&comp=acl" + + # Construct parameters + if timeout is not None: + _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int") + + # Construct headers + _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") + if lease_id is not None: + _headers["x-ms-lease-id"] = _SERIALIZER.header("lease_id", lease_id, "str") + if file_request_intent is not None: + _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_share_set_access_policy_request( + *, + timeout: Optional[int] = None, + lease_id: Optional[str] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + version: str = kwargs.pop("version", _headers.pop("x-ms-version", "2026-06-06")) + # Construct URL + _url = "?restype=share&comp=acl" + + # Construct parameters + if timeout is not None: + _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int") + + # Construct headers + _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") + if content_type is not None: + _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") + if lease_id is not None: + _headers["x-ms-lease-id"] = _SERIALIZER.header("lease_id", lease_id, "str") + if file_request_intent is not None: + _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") + + return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_share_get_statistics_request( + *, + timeout: Optional[int] = None, + lease_id: Optional[str] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + version: str = kwargs.pop("version", _headers.pop("x-ms-version", "2026-06-06")) + accept = _headers.pop("Accept", "application/xml") + + # Construct URL + _url = "?restype=share&comp=stats" + + # Construct parameters + if timeout is not None: + _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int") + + # Construct headers + _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") + if lease_id is not None: + _headers["x-ms-lease-id"] = _SERIALIZER.header("lease_id", lease_id, "str") + if file_request_intent is not None: + _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") + _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") + + return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) + + +def build_share_restore_request( + *, + timeout: Optional[int] = None, + deleted_share_name: Optional[str] = None, + deleted_share_version: Optional[str] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any +) -> HttpRequest: + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) + + version: str = kwargs.pop("version", _headers.pop("x-ms-version", "2026-06-06")) + # Construct URL + _url = "?restype=share&comp=undelete" + + # Construct parameters + if timeout is not None: + _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int") + + # Construct headers + _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") + if deleted_share_name is not None: + _headers["x-ms-deleted-share-name"] = _SERIALIZER.header("deleted_share_name", deleted_share_name, "str") + if deleted_share_version is not None: + _headers["x-ms-deleted-share-version"] = _SERIALIZER.header( + "deleted_share_version", deleted_share_version, "str" + ) + if file_request_intent is not None: + _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") + + return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) + + +class DirectoryOperations: + """ + .. warning:: + **DO NOT** instantiate this class directly. + + Instead, you should access the following operations through + :class:`~azure.storage.fileshare.FileClient`'s + :attr:`directory` attribute. + """ + + def __init__(self, *args, **kwargs) -> None: + input_args = list(args) + self._client: PipelineClient = input_args.pop(0) if input_args else kwargs.pop("client") + self._config: FileClientConfiguration = input_args.pop(0) if input_args else kwargs.pop("config") + self._serialize: Serializer = input_args.pop(0) if input_args else kwargs.pop("serializer") + self._deserialize: Deserializer = input_args.pop(0) if input_args else kwargs.pop("deserializer") + + @distributed_trace + def create( # pylint: disable=inconsistent-return-statements,too-many-locals + self, + *, + timeout: Optional[int] = None, + metadata: Optional[dict[str, str]] = None, + file_permission: Optional[str] = None, + file_permission_key: Optional[str] = None, + file_attributes: Optional[str] = None, + file_creation_time: Optional[str] = None, + file_last_write_time: Optional[str] = None, + file_change_time: Optional[str] = None, + file_permission_format: Optional[Union[str, _models.FilePermissionFormat]] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + owner: Optional[str] = None, + group: Optional[str] = None, + file_mode: Optional[str] = None, + file_property_semantics: Optional[Union[str, _models.FilePropertySemantics]] = None, + allow_trailing_dot: Optional[bool] = None, + **kwargs: Any + ) -> None: + """Creates a new directory under the specified share or parent directory. + + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword metadata: Optional. User-defined metadata for the resource. Default value is None. + :paramtype metadata: dict[str, str] + :keyword file_permission: If specified the permission (security descriptor) shall be set for + the directory/file. This header can be used if Permission size is <= 8KB, else + x-ms-file-permission-key header shall be used. Default value: Inherit. If SDDL is specified as + input, it must have owner, group and dacl. Note: Only one of the x-ms-file-permission or + x-ms-file-permission-key should be specified. Default value is None. + :paramtype file_permission: str + :keyword file_permission_key: Key of the permission to be set for the directory/file. Note: + Only one of the x-ms-file-permission or x-ms-file-permission-key should be specified. Default + value is None. + :paramtype file_permission_key: str + :keyword file_attributes: If specified, the provided file attributes shall be set. Default + value: 'Archive' for file and 'Directory' for directory. 'None' can also be specified as + default. Default value is None. + :paramtype file_attributes: str + :keyword file_creation_time: Creation time for the file/directory. Default value: Now. Default + value is None. + :paramtype file_creation_time: str + :keyword file_last_write_time: Last write time for the file/directory. Default value: Now. + Default value is None. + :paramtype file_last_write_time: str + :keyword file_change_time: Change time for the file/directory. Default value: Now. Default + value is None. + :paramtype file_change_time: str + :keyword file_permission_format: Optional. Used to set permission format. Known values are: + "Sddl" and "Binary". Default value is None. + :paramtype file_permission_format: str or ~azure.storage.fileshare.models.FilePermissionFormat + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :keyword owner: Optional, NFS only. The owner of the file or directory. Default value is None. + :paramtype owner: str + :keyword group: Optional, NFS only. The owning group of the file or directory. Default value is + None. + :paramtype group: str + :keyword file_mode: Optional, NFS only. The file mode of the file or directory. Default value + is None. + :paramtype file_mode: str + :keyword file_property_semantics: SMB only. Default value is New. Known values are: "New" and + "Restore". Default value is None. + :paramtype file_property_semantics: str or + ~azure.storage.fileshare.models.FilePropertySemantics + :keyword allow_trailing_dot: If true, the trailing dot will not be trimmed from the target + file/directory path. Default value is None. + :paramtype allow_trailing_dot: bool + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls: ClsType[None] = kwargs.pop("cls", None) + + _request = build_directory_create_request( + timeout=timeout, + metadata=metadata, + file_permission=file_permission, + file_permission_key=file_permission_key, + file_attributes=file_attributes, + file_creation_time=file_creation_time, + file_last_write_time=file_last_write_time, + file_change_time=file_change_time, + file_permission_format=file_permission_format, + file_request_intent=file_request_intent, + owner=owner, + group=group, + file_mode=file_mode, + file_property_semantics=file_property_semantics, + allow_trailing_dot=allow_trailing_dot, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [201]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) + response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) + response_headers["x-ms-request-server-encrypted"] = self._deserialize( + "bool", response.headers.get("x-ms-request-server-encrypted") + ) + response_headers["x-ms-file-permission-key"] = self._deserialize( + "str", response.headers.get("x-ms-file-permission-key") + ) + response_headers["x-ms-file-attributes"] = self._deserialize( + "str", response.headers.get("x-ms-file-attributes") + ) + response_headers["x-ms-file-creation-time"] = self._deserialize( + "str", response.headers.get("x-ms-file-creation-time") + ) + response_headers["x-ms-file-last-write-time"] = self._deserialize( + "str", response.headers.get("x-ms-file-last-write-time") + ) + response_headers["x-ms-file-change-time"] = self._deserialize( + "str", response.headers.get("x-ms-file-change-time") + ) + response_headers["x-ms-file-id"] = self._deserialize("str", response.headers.get("x-ms-file-id")) + response_headers["x-ms-file-parent-id"] = self._deserialize("str", response.headers.get("x-ms-file-parent-id")) + response_headers["x-ms-mode"] = self._deserialize("str", response.headers.get("x-ms-mode")) + response_headers["x-ms-owner"] = self._deserialize("str", response.headers.get("x-ms-owner")) + response_headers["x-ms-group"] = self._deserialize("str", response.headers.get("x-ms-group")) + response_headers["x-ms-file-file-type"] = self._deserialize("str", response.headers.get("x-ms-file-file-type")) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + + if cls: + return cls(pipeline_response, None, response_headers) # type: ignore + + @distributed_trace + def get_properties( # pylint: disable=inconsistent-return-statements + self, + *, + sharesnapshot: Optional[str] = None, + timeout: Optional[int] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + allow_trailing_dot: Optional[bool] = None, + **kwargs: Any + ) -> None: + """Returns all system properties for the specified directory, and can also be used to check the + existence of a directory. + + :keyword sharesnapshot: The snapshot parameter is an opaque DateTime value that specifies a + share snapshot. Default value is None. + :paramtype sharesnapshot: str + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :keyword allow_trailing_dot: If true, the trailing dot will not be trimmed from the target + file/directory path. Default value is None. + :paramtype allow_trailing_dot: bool + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls: ClsType[None] = kwargs.pop("cls", None) + + _request = build_directory_get_properties_request( + sharesnapshot=sharesnapshot, + timeout=timeout, + file_request_intent=file_request_intent, + allow_trailing_dot=allow_trailing_dot, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["x-ms-meta"] = self._deserialize("{str}", response.headers.get("x-ms-meta")) + response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) + response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) + response_headers["x-ms-file-permission-key"] = self._deserialize( + "str", response.headers.get("x-ms-file-permission-key") + ) + response_headers["x-ms-file-attributes"] = self._deserialize( + "str", response.headers.get("x-ms-file-attributes") + ) + response_headers["x-ms-file-creation-time"] = self._deserialize( + "str", response.headers.get("x-ms-file-creation-time") + ) + response_headers["x-ms-file-last-write-time"] = self._deserialize( + "str", response.headers.get("x-ms-file-last-write-time") + ) + response_headers["x-ms-file-change-time"] = self._deserialize( + "str", response.headers.get("x-ms-file-change-time") + ) + response_headers["x-ms-file-id"] = self._deserialize("str", response.headers.get("x-ms-file-id")) + response_headers["x-ms-file-parent-id"] = self._deserialize("str", response.headers.get("x-ms-file-parent-id")) + response_headers["x-ms-server-encrypted"] = self._deserialize( + "bool", response.headers.get("x-ms-server-encrypted") + ) + response_headers["x-ms-mode"] = self._deserialize("str", response.headers.get("x-ms-mode")) + response_headers["x-ms-owner"] = self._deserialize("str", response.headers.get("x-ms-owner")) + response_headers["x-ms-group"] = self._deserialize("str", response.headers.get("x-ms-group")) + response_headers["x-ms-file-file-type"] = self._deserialize("str", response.headers.get("x-ms-file-file-type")) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + + if cls: + return cls(pipeline_response, None, response_headers) # type: ignore + + @distributed_trace + def delete( # pylint: disable=inconsistent-return-statements + self, + *, + timeout: Optional[int] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + allow_trailing_dot: Optional[bool] = None, + **kwargs: Any + ) -> None: + """Removes the specified empty directory. Note that the directory must be empty before it can be + deleted. + + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :keyword allow_trailing_dot: If true, the trailing dot will not be trimmed from the target + file/directory path. Default value is None. + :paramtype allow_trailing_dot: bool + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls: ClsType[None] = kwargs.pop("cls", None) + + _request = build_directory_delete_request( + timeout=timeout, + file_request_intent=file_request_intent, + allow_trailing_dot=allow_trailing_dot, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [202]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + + if cls: + return cls(pipeline_response, None, response_headers) # type: ignore + + @distributed_trace + def set_properties( # pylint: disable=inconsistent-return-statements,too-many-locals + self, + *, + timeout: Optional[int] = None, + file_permission: Optional[str] = None, + file_permission_key: Optional[str] = None, + file_attributes: Optional[str] = None, + file_creation_time: Optional[str] = None, + file_last_write_time: Optional[str] = None, + file_change_time: Optional[str] = None, + file_permission_format: Optional[Union[str, _models.FilePermissionFormat]] = None, + allow_trailing_dot: Optional[bool] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + owner: Optional[str] = None, + group: Optional[str] = None, + file_mode: Optional[str] = None, + **kwargs: Any + ) -> None: + """Sets properties for the specified directory. + + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword file_permission: If specified the permission (security descriptor) shall be set for + the directory/file. This header can be used if Permission size is <= 8KB, else + x-ms-file-permission-key header shall be used. Default value: Inherit. If SDDL is specified as + input, it must have owner, group and dacl. Note: Only one of the x-ms-file-permission or + x-ms-file-permission-key should be specified. Default value is None. + :paramtype file_permission: str + :keyword file_permission_key: Key of the permission to be set for the directory/file. Note: + Only one of the x-ms-file-permission or x-ms-file-permission-key should be specified. Default + value is None. + :paramtype file_permission_key: str + :keyword file_attributes: If specified, the provided file attributes shall be set. Default + value: 'Archive' for file and 'Directory' for directory. 'None' can also be specified as + default. Default value is None. + :paramtype file_attributes: str + :keyword file_creation_time: Creation time for the file/directory. Default value: Now. Default + value is None. + :paramtype file_creation_time: str + :keyword file_last_write_time: Last write time for the file/directory. Default value: Now. + Default value is None. + :paramtype file_last_write_time: str + :keyword file_change_time: Change time for the file/directory. Default value: Now. Default + value is None. + :paramtype file_change_time: str + :keyword file_permission_format: Optional. Used to set permission format. Known values are: + "Sddl" and "Binary". Default value is None. + :paramtype file_permission_format: str or ~azure.storage.fileshare.models.FilePermissionFormat + :keyword allow_trailing_dot: If true, the trailing dot will not be trimmed from the target + file/directory path. Default value is None. + :paramtype allow_trailing_dot: bool + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :keyword owner: Optional, NFS only. The owner of the file or directory. Default value is None. + :paramtype owner: str + :keyword group: Optional, NFS only. The owning group of the file or directory. Default value is + None. + :paramtype group: str + :keyword file_mode: Optional, NFS only. The file mode of the file or directory. Default value + is None. + :paramtype file_mode: str + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls: ClsType[None] = kwargs.pop("cls", None) + + _request = build_directory_set_properties_request( + timeout=timeout, + file_permission=file_permission, + file_permission_key=file_permission_key, + file_attributes=file_attributes, + file_creation_time=file_creation_time, + file_last_write_time=file_last_write_time, + file_change_time=file_change_time, + file_permission_format=file_permission_format, + allow_trailing_dot=allow_trailing_dot, + file_request_intent=file_request_intent, + owner=owner, + group=group, + file_mode=file_mode, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) + response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) + response_headers["x-ms-request-server-encrypted"] = self._deserialize( + "bool", response.headers.get("x-ms-request-server-encrypted") + ) + response_headers["x-ms-file-permission-key"] = self._deserialize( + "str", response.headers.get("x-ms-file-permission-key") + ) + response_headers["x-ms-file-attributes"] = self._deserialize( + "str", response.headers.get("x-ms-file-attributes") + ) + response_headers["x-ms-file-creation-time"] = self._deserialize( + "str", response.headers.get("x-ms-file-creation-time") + ) + response_headers["x-ms-file-last-write-time"] = self._deserialize( + "str", response.headers.get("x-ms-file-last-write-time") + ) + response_headers["x-ms-file-change-time"] = self._deserialize( + "str", response.headers.get("x-ms-file-change-time") + ) + response_headers["x-ms-file-id"] = self._deserialize("str", response.headers.get("x-ms-file-id")) + response_headers["x-ms-file-parent-id"] = self._deserialize("str", response.headers.get("x-ms-file-parent-id")) + response_headers["x-ms-mode"] = self._deserialize("str", response.headers.get("x-ms-mode")) + response_headers["x-ms-owner"] = self._deserialize("str", response.headers.get("x-ms-owner")) + response_headers["x-ms-group"] = self._deserialize("str", response.headers.get("x-ms-group")) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + + if cls: + return cls(pipeline_response, None, response_headers) # type: ignore + + @distributed_trace + def set_metadata( # pylint: disable=inconsistent-return-statements + self, + *, + timeout: Optional[int] = None, + metadata: Optional[dict[str, str]] = None, + allow_trailing_dot: Optional[bool] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any + ) -> None: + """Sets one or more user-defined name-value pairs for the specified directory. + + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword metadata: Optional. User-defined metadata for the resource. Default value is None. + :paramtype metadata: dict[str, str] + :keyword allow_trailing_dot: If true, the trailing dot will not be trimmed from the target + file/directory path. Default value is None. + :paramtype allow_trailing_dot: bool + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls: ClsType[None] = kwargs.pop("cls", None) + + _request = build_directory_set_metadata_request( + timeout=timeout, + metadata=metadata, + allow_trailing_dot=allow_trailing_dot, + file_request_intent=file_request_intent, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) + response_headers["x-ms-request-server-encrypted"] = self._deserialize( + "bool", response.headers.get("x-ms-request-server-encrypted") + ) + response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + + if cls: + return cls(pipeline_response, None, response_headers) # type: ignore + + @distributed_trace + def list_files_and_directories_segment( + self, + *, + prefix: Optional[str] = None, + sharesnapshot: Optional[str] = None, + marker: Optional[str] = None, + maxresults: Optional[int] = None, + include: Optional[list[Union[str, _models.ListFilesIncludeType]]] = None, + timeout: Optional[int] = None, + include_extended_info: Optional[bool] = None, + allow_trailing_dot: Optional[bool] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any + ) -> _models.ListFilesAndDirectoriesSegmentResponse: + """Returns a list of files and directories under the specified share or directory. It lists the + contents only for a single level of the directory hierarchy. + + :keyword prefix: Filters the results to return only items whose name begins with the specified + prefix. Default value is None. + :paramtype prefix: str + :keyword sharesnapshot: The snapshot parameter is an opaque DateTime value that specifies a + share snapshot. Default value is None. + :paramtype sharesnapshot: str + :keyword marker: A string value that identifies the portion of the list to be returned with the + next listing operation. Default value is None. + :paramtype marker: str + :keyword maxresults: Specifies the maximum number of items to return. Default value is None. + :paramtype maxresults: int + :keyword include: Include this parameter to specify one or more datasets to include in the + response. Default value is None. + :paramtype include: list[str or ~azure.storage.fileshare.models.ListFilesIncludeType] + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword include_extended_info: Include extended information. Default value is None. + :paramtype include_extended_info: bool + :keyword allow_trailing_dot: If true, the trailing dot will not be trimmed from the target + file/directory path. Default value is None. + :paramtype allow_trailing_dot: bool + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :return: ListFilesAndDirectoriesSegmentResponse. The ListFilesAndDirectoriesSegmentResponse is + compatible with MutableMapping + :rtype: ~azure.storage.fileshare._generated.models.ListFilesAndDirectoriesSegmentResponse + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls: ClsType[_models.ListFilesAndDirectoriesSegmentResponse] = kwargs.pop("cls", None) + + _request = build_directory_list_files_and_directories_segment_request( + prefix=prefix, + sharesnapshot=sharesnapshot, + marker=marker, + maxresults=maxresults, + include=include, + timeout=timeout, + include_extended_info=include_extended_info, + allow_trailing_dot=allow_trailing_dot, + file_request_intent=file_request_intent, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _decompress = kwargs.pop("decompress", True) + _stream = kwargs.pop("stream", False) + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + if _stream: + try: + response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + response_headers["Content-Type"] = self._deserialize("str", response.headers.get("Content-Type")) + + if _stream: + deserialized = response.iter_bytes() if _decompress else response.iter_raw() + else: + deserialized = _deserialize_xml(_models.ListFilesAndDirectoriesSegmentResponse, response.text()) + + if cls: + return cls(pipeline_response, deserialized, response_headers) # type: ignore + + return deserialized # type: ignore + + @distributed_trace + def list_handles( + self, + *, + marker: Optional[str] = None, + maxresults: Optional[int] = None, + timeout: Optional[int] = None, + sharesnapshot: Optional[str] = None, + recursive: Optional[bool] = None, + allow_trailing_dot: Optional[bool] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any + ) -> _models.ListHandlesResponse: + """Lists handles for directory. + + :keyword marker: A string value that identifies the portion of the list to be returned with the + next listing operation. Default value is None. + :paramtype marker: str + :keyword maxresults: Specifies the maximum number of items to return. Default value is None. + :paramtype maxresults: int + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword sharesnapshot: The snapshot parameter is an opaque DateTime value that specifies a + share snapshot. Default value is None. + :paramtype sharesnapshot: str + :keyword recursive: Specifies operation should apply to the directory specified in the URI, its + files, its subdirectories and their files. Default value is None. + :paramtype recursive: bool + :keyword allow_trailing_dot: If true, the trailing dot will not be trimmed from the target + file/directory path. Default value is None. + :paramtype allow_trailing_dot: bool + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :return: ListHandlesResponse. The ListHandlesResponse is compatible with MutableMapping + :rtype: ~azure.storage.fileshare._generated.models.ListHandlesResponse + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls: ClsType[_models.ListHandlesResponse] = kwargs.pop("cls", None) + + _request = build_directory_list_handles_request( + marker=marker, + maxresults=maxresults, + timeout=timeout, + sharesnapshot=sharesnapshot, + recursive=recursive, + allow_trailing_dot=allow_trailing_dot, + file_request_intent=file_request_intent, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _decompress = kwargs.pop("decompress", True) + _stream = kwargs.pop("stream", False) + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + if _stream: + try: + response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + response_headers["Content-Type"] = self._deserialize("str", response.headers.get("Content-Type")) + + if _stream: + deserialized = response.iter_bytes() if _decompress else response.iter_raw() + else: + deserialized = _deserialize_xml(_models.ListHandlesResponse, response.text()) + + if cls: + return cls(pipeline_response, deserialized, response_headers) # type: ignore + + return deserialized # type: ignore + + @distributed_trace + def force_close_handles( # pylint: disable=inconsistent-return-statements + self, + *, + handle_id: str, + timeout: Optional[int] = None, + marker: Optional[str] = None, + sharesnapshot: Optional[str] = None, + recursive: Optional[bool] = None, + allow_trailing_dot: Optional[bool] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any + ) -> None: + """Closes all handles open for given directory. + + :keyword handle_id: Specifies handle ID opened on the file or directory to be closed. Asterisk + ('*') is a wildcard that specifies all handles. Required. + :paramtype handle_id: str + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword marker: A string value that identifies the portion of the list to be returned with the + next listing operation. Default value is None. + :paramtype marker: str + :keyword sharesnapshot: The snapshot parameter is an opaque DateTime value that specifies a + share snapshot. Default value is None. + :paramtype sharesnapshot: str + :keyword recursive: Specifies operation should apply to the directory specified in the URI, its + files, its subdirectories and their files. Default value is None. + :paramtype recursive: bool + :keyword allow_trailing_dot: If true, the trailing dot will not be trimmed from the target + file/directory path. Default value is None. + :paramtype allow_trailing_dot: bool + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls: ClsType[None] = kwargs.pop("cls", None) + + _request = build_directory_force_close_handles_request( + handle_id=handle_id, + timeout=timeout, + marker=marker, + sharesnapshot=sharesnapshot, + recursive=recursive, + allow_trailing_dot=allow_trailing_dot, + file_request_intent=file_request_intent, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["x-ms-marker"] = self._deserialize("str", response.headers.get("x-ms-marker")) + response_headers["x-ms-number-of-handles-closed"] = self._deserialize( + "int", response.headers.get("x-ms-number-of-handles-closed") + ) + response_headers["x-ms-number-of-handles-failed"] = self._deserialize( + "int", response.headers.get("x-ms-number-of-handles-failed") + ) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + + if cls: + return cls(pipeline_response, None, response_headers) # type: ignore + + @distributed_trace + def rename( # pylint: disable=inconsistent-return-statements,too-many-locals + self, + *, + rename_source: str, + timeout: Optional[int] = None, + replace_if_exists: Optional[bool] = None, + ignore_read_only: Optional[bool] = None, + source_lease_id: Optional[str] = None, + destination_lease_id: Optional[str] = None, + file_attributes: Optional[str] = None, + file_creation_time: Optional[str] = None, + file_last_write_time: Optional[str] = None, + file_change_time: Optional[str] = None, + file_permission: Optional[str] = None, + file_permission_format: Optional[Union[str, _models.FilePermissionFormat]] = None, + file_permission_key: Optional[str] = None, + metadata: Optional[dict[str, str]] = None, + allow_trailing_dot: Optional[bool] = None, + allow_source_trailing_dot: Optional[bool] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any + ) -> None: + """Renames a directory. By default, the destination is overwritten and if the destination already + exists and has a read-only attribute set, the operation will fail. + + :keyword rename_source: Required. Specifies the URI-style path of the source file, up to 2 KB + in length. Required. + :paramtype rename_source: str + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword replace_if_exists: Boolean. Default value is false. Set to true to indicate that the + destination should be overwritten. Default value is None. + :paramtype replace_if_exists: bool + :keyword ignore_read_only: Boolean. Default value is false. Set to true to overwrite the + destination even if it has the read-only attribute set. Default value is None. + :paramtype ignore_read_only: bool + :keyword source_lease_id: Required if the source file has an active lease. Default value is + None. + :paramtype source_lease_id: str + :keyword destination_lease_id: Required if the destination has an active lease. Default value + is None. + :paramtype destination_lease_id: str + :keyword file_attributes: If specified, the provided file attributes shall be set. Default + value is None. + :paramtype file_attributes: str + :keyword file_creation_time: Creation time for the directory. Default value is None. + :paramtype file_creation_time: str + :keyword file_last_write_time: Last write time for the directory. Default value is None. + :paramtype file_last_write_time: str + :keyword file_change_time: Change time for the directory. Default value is None. + :paramtype file_change_time: str + :keyword file_permission: If specified the permission shall be set for the directory. Default + value is None. + :paramtype file_permission: str + :keyword file_permission_format: Optional. Used to set permission format. Known values are: + "Sddl" and "Binary". Default value is None. + :paramtype file_permission_format: str or ~azure.storage.fileshare.models.FilePermissionFormat + :keyword file_permission_key: Key of the permission to be set. Default value is None. + :paramtype file_permission_key: str + :keyword metadata: Optional. User-defined metadata for the resource. Default value is None. + :paramtype metadata: dict[str, str] + :keyword allow_trailing_dot: If true, the trailing dot will not be trimmed from the target + file/directory path. Default value is None. + :paramtype allow_trailing_dot: bool + :keyword allow_source_trailing_dot: If true, the trailing dot will not be trimmed from the + source URI. Default value is None. + :paramtype allow_source_trailing_dot: bool + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls: ClsType[None] = kwargs.pop("cls", None) + + _request = build_directory_rename_request( + rename_source=rename_source, + timeout=timeout, + replace_if_exists=replace_if_exists, + ignore_read_only=ignore_read_only, + source_lease_id=source_lease_id, + destination_lease_id=destination_lease_id, + file_attributes=file_attributes, + file_creation_time=file_creation_time, + file_last_write_time=file_last_write_time, + file_change_time=file_change_time, + file_permission=file_permission, + file_permission_format=file_permission_format, + file_permission_key=file_permission_key, + metadata=metadata, + allow_trailing_dot=allow_trailing_dot, + allow_source_trailing_dot=allow_source_trailing_dot, + file_request_intent=file_request_intent, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) + response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) + response_headers["x-ms-request-server-encrypted"] = self._deserialize( + "bool", response.headers.get("x-ms-request-server-encrypted") + ) + response_headers["x-ms-file-permission-key"] = self._deserialize( + "str", response.headers.get("x-ms-file-permission-key") + ) + response_headers["x-ms-file-attributes"] = self._deserialize( + "str", response.headers.get("x-ms-file-attributes") + ) + response_headers["x-ms-file-creation-time"] = self._deserialize( + "str", response.headers.get("x-ms-file-creation-time") + ) + response_headers["x-ms-file-last-write-time"] = self._deserialize( + "str", response.headers.get("x-ms-file-last-write-time") + ) + response_headers["x-ms-file-change-time"] = self._deserialize( + "str", response.headers.get("x-ms-file-change-time") + ) + response_headers["x-ms-file-id"] = self._deserialize("str", response.headers.get("x-ms-file-id")) + response_headers["x-ms-file-parent-id"] = self._deserialize("str", response.headers.get("x-ms-file-parent-id")) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + + if cls: + return cls(pipeline_response, None, response_headers) # type: ignore + + +class FileOperations: # pylint: disable=too-many-public-methods + """ + .. warning:: + **DO NOT** instantiate this class directly. + + Instead, you should access the following operations through + :class:`~azure.storage.fileshare.FileClient`'s + :attr:`file` attribute. + """ + + def __init__(self, *args, **kwargs) -> None: + input_args = list(args) + self._client: PipelineClient = input_args.pop(0) if input_args else kwargs.pop("client") + self._config: FileClientConfiguration = input_args.pop(0) if input_args else kwargs.pop("config") + self._serialize: Serializer = input_args.pop(0) if input_args else kwargs.pop("serializer") + self._deserialize: Deserializer = input_args.pop(0) if input_args else kwargs.pop("deserializer") + + @distributed_trace + def create( # pylint: disable=inconsistent-return-statements,too-many-locals + self, + optional_body: Optional[bytes] = None, + *, + file_content_length: int, + timeout: Optional[int] = None, + file_content_type: Optional[str] = None, + file_content_encoding: Optional[str] = None, + file_content_language: Optional[str] = None, + file_cache_control: Optional[str] = None, + file_content_md5: Optional[bytes] = None, + file_content_disposition: Optional[str] = None, + metadata: Optional[dict[str, str]] = None, + file_permission: Optional[str] = None, + file_permission_key: Optional[str] = None, + file_attributes: Optional[str] = None, + file_creation_time: Optional[str] = None, + file_last_write_time: Optional[str] = None, + file_change_time: Optional[str] = None, + file_permission_format: Optional[Union[str, _models.FilePermissionFormat]] = None, + lease_id: Optional[str] = None, + allow_trailing_dot: Optional[bool] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + owner: Optional[str] = None, + group: Optional[str] = None, + file_mode: Optional[str] = None, + nfs_file_type: Optional[Union[str, _models.NfsFileType]] = None, + content_md5: Optional[bytes] = None, + file_property_semantics: Optional[Union[str, _models.FilePropertySemantics]] = None, + content_length: Optional[int] = None, + structured_body_type: Optional[str] = None, + structured_content_length: Optional[int] = None, + **kwargs: Any + ) -> None: + """Creates a new file or replaces a file. Note it only initializes the file with no content. + + :param optional_body: Initial data. Default value is None. + :type optional_body: bytes + :keyword file_content_length: Specifies the maximum size for the file, up to 4 TB. Required. + :paramtype file_content_length: int + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword file_content_type: Sets the MIME content type of the file. The default type is + 'application/octet-stream'. Default value is None. + :paramtype file_content_type: str + :keyword file_content_encoding: Specifies which content encodings have been applied to the + file. Default value is None. + :paramtype file_content_encoding: str + :keyword file_content_language: Specifies the natural languages used by this resource. Default + value is None. + :paramtype file_content_language: str + :keyword file_cache_control: Sets the file's cache control. The File service stores this value + but does not use or modify it. Default value is None. + :paramtype file_cache_control: str + :keyword file_content_md5: An MD5 hash of the file content. This hash is used to verify the + integrity of the file during transport. Default value is None. + :paramtype file_content_md5: bytes + :keyword file_content_disposition: Sets the file's Content-Disposition header. Default value is + None. + :paramtype file_content_disposition: str + :keyword metadata: Optional. User-defined metadata for the resource. Default value is None. + :paramtype metadata: dict[str, str] + :keyword file_permission: If specified the permission (security descriptor) shall be set for + the directory/file. This header can be used if Permission size is <= 8KB, else + x-ms-file-permission-key header shall be used. Default value: Inherit. If SDDL is specified as + input, it must have owner, group and dacl. Note: Only one of the x-ms-file-permission or + x-ms-file-permission-key should be specified. Default value is None. + :paramtype file_permission: str + :keyword file_permission_key: Key of the permission to be set for the directory/file. Note: + Only one of the x-ms-file-permission or x-ms-file-permission-key should be specified. Default + value is None. + :paramtype file_permission_key: str + :keyword file_attributes: If specified, the provided file attributes shall be set. Default + value: 'Archive' for file and 'Directory' for directory. 'None' can also be specified as + default. Default value is None. + :paramtype file_attributes: str + :keyword file_creation_time: Creation time for the file/directory. Default value: Now. Default + value is None. + :paramtype file_creation_time: str + :keyword file_last_write_time: Last write time for the file/directory. Default value: Now. + Default value is None. + :paramtype file_last_write_time: str + :keyword file_change_time: Change time for the file/directory. Default value: Now. Default + value is None. + :paramtype file_change_time: str + :keyword file_permission_format: Optional. Used to set permission format. Known values are: + "Sddl" and "Binary". Default value is None. + :paramtype file_permission_format: str or ~azure.storage.fileshare.models.FilePermissionFormat + :keyword lease_id: If specified, the lease ID must match the lease ID of the file. Default + value is None. + :paramtype lease_id: str + :keyword allow_trailing_dot: If true, the trailing dot will not be trimmed from the target + file/directory path. Default value is None. + :paramtype allow_trailing_dot: bool + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :keyword owner: Optional, NFS only. The owner of the file or directory. Default value is None. + :paramtype owner: str + :keyword group: Optional, NFS only. The owning group of the file or directory. Default value is + None. + :paramtype group: str + :keyword file_mode: Optional, NFS only. The file mode of the file or directory. Default value + is None. + :paramtype file_mode: str + :keyword nfs_file_type: Optional, NFS only. Type of the file or directory. Known values are: + "Regular", "Directory", and "SymLink". Default value is None. + :paramtype nfs_file_type: str or ~azure.storage.fileshare.models.NfsFileType + :keyword content_md5: An MD5 hash of the content. This hash is used to verify the integrity of + the data during transport. Default value is None. + :paramtype content_md5: bytes + :keyword file_property_semantics: SMB only. Default value is New. Known values are: "New" and + "Restore". Default value is None. + :paramtype file_property_semantics: str or + ~azure.storage.fileshare.models.FilePropertySemantics + :keyword content_length: Specifies the number of bytes being transmitted in the request body. + When the x-ms-write header is set to clear, the value of this header must be set to zero.". + Default value is None. + :paramtype content_length: int + :keyword structured_body_type: Specifies the response content should be returned as a + structured message and specifies the message schema version and properties. Default value is + None. + :paramtype structured_body_type: str + :keyword structured_content_length: Required if the request body is a structured message. + Specifies the length of the blob/file content inside the message body. Will always be smaller + than Content-Length. Default value is None. + :paramtype structured_content_length: int + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = kwargs.pop("params", {}) or {} + + file_type: Literal["file"] = kwargs.pop("file_type", _headers.pop("x-ms-type", "file")) + content_type: Optional[str] = kwargs.pop( + "content_type", _headers.pop("Content-Type", "application/octet-stream") + ) + content_type = content_type if optional_body else None + cls: ClsType[None] = kwargs.pop("cls", None) + + _content = optional_body + + _request = build_file_create_request( + file_content_length=file_content_length, + timeout=timeout, + file_content_type=file_content_type, + file_content_encoding=file_content_encoding, + file_content_language=file_content_language, + file_cache_control=file_cache_control, + file_content_md5=file_content_md5, + file_content_disposition=file_content_disposition, + metadata=metadata, + file_permission=file_permission, + file_permission_key=file_permission_key, + file_attributes=file_attributes, + file_creation_time=file_creation_time, + file_last_write_time=file_last_write_time, + file_change_time=file_change_time, + file_permission_format=file_permission_format, + lease_id=lease_id, + allow_trailing_dot=allow_trailing_dot, + file_request_intent=file_request_intent, + owner=owner, + group=group, + file_mode=file_mode, + nfs_file_type=nfs_file_type, + content_md5=content_md5, + file_property_semantics=file_property_semantics, + content_length=content_length, + structured_body_type=structured_body_type, + structured_content_length=structured_content_length, + file_type=file_type, + content_type=content_type, + version=self._config.version, + content=_content, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [201]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) + response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) + response_headers["x-ms-request-server-encrypted"] = self._deserialize( + "bool", response.headers.get("x-ms-request-server-encrypted") + ) + response_headers["x-ms-file-permission-key"] = self._deserialize( + "str", response.headers.get("x-ms-file-permission-key") + ) + response_headers["x-ms-file-attributes"] = self._deserialize( + "str", response.headers.get("x-ms-file-attributes") + ) + response_headers["x-ms-file-creation-time"] = self._deserialize( + "str", response.headers.get("x-ms-file-creation-time") + ) + response_headers["x-ms-file-last-write-time"] = self._deserialize( + "str", response.headers.get("x-ms-file-last-write-time") + ) + response_headers["x-ms-file-change-time"] = self._deserialize( + "str", response.headers.get("x-ms-file-change-time") + ) + response_headers["x-ms-file-id"] = self._deserialize("str", response.headers.get("x-ms-file-id")) + response_headers["x-ms-file-parent-id"] = self._deserialize("str", response.headers.get("x-ms-file-parent-id")) + response_headers["x-ms-mode"] = self._deserialize("str", response.headers.get("x-ms-mode")) + response_headers["x-ms-owner"] = self._deserialize("str", response.headers.get("x-ms-owner")) + response_headers["x-ms-group"] = self._deserialize("str", response.headers.get("x-ms-group")) + response_headers["x-ms-file-file-type"] = self._deserialize("str", response.headers.get("x-ms-file-file-type")) + response_headers["Content-MD5"] = self._deserialize("bytearray", response.headers.get("Content-MD5")) + response_headers["Content-Length"] = self._deserialize("int", response.headers.get("Content-Length")) + response_headers["x-ms-structured-body"] = self._deserialize( + "str", response.headers.get("x-ms-structured-body") + ) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + + if cls: + return cls(pipeline_response, None, response_headers) # type: ignore + + @distributed_trace + def download( + self, + *, + timeout: Optional[int] = None, + range: Optional[str] = None, + range_get_content_md5: Optional[bool] = None, + lease_id: Optional[str] = None, + allow_trailing_dot: Optional[bool] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + structured_body_type: Optional[str] = None, + **kwargs: Any + ) -> Iterator[bytes]: + """Reads or downloads a file from the system, including its metadata and properties. + + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword range: Return file data only from the specified byte range. Default value is None. + :paramtype range: str + :keyword range_get_content_md5: When this header is set to true and specified together with the + Range header, the service returns the MD5 hash for the range, as long as the range is less than + or equal to 4 MB in size. Default value is None. + :paramtype range_get_content_md5: bool + :keyword lease_id: If specified, the lease ID must match the lease ID of the file. Default + value is None. + :paramtype lease_id: str + :keyword allow_trailing_dot: If true, the trailing dot will not be trimmed from the target + file/directory path. Default value is None. + :paramtype allow_trailing_dot: bool + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :keyword structured_body_type: Specifies the response content should be returned as a + structured message and specifies the message schema version and properties. Default value is + None. + :paramtype structured_body_type: str + :return: Iterator[bytes] + :rtype: Iterator[bytes] + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None) + + _request = build_file_download_request( + timeout=timeout, + range=range, + range_get_content_md5=range_get_content_md5, + lease_id=lease_id, + allow_trailing_dot=allow_trailing_dot, + file_request_intent=file_request_intent, + structured_body_type=structured_body_type, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _decompress = kwargs.pop("decompress", True) + _stream = kwargs.pop("stream", True) + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200, 206]: + if _stream: + try: + response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) + response_headers["x-ms-meta"] = self._deserialize("{str}", response.headers.get("x-ms-meta")) + response_headers["Content-Length"] = self._deserialize("int", response.headers.get("Content-Length")) + response_headers["Content-Range"] = self._deserialize("str", response.headers.get("Content-Range")) + response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) + response_headers["Content-MD5"] = self._deserialize("bytearray", response.headers.get("Content-MD5")) + response_headers["Content-Encoding"] = self._deserialize("str", response.headers.get("Content-Encoding")) + response_headers["Cache-Control"] = self._deserialize("str", response.headers.get("Cache-Control")) + response_headers["Content-Disposition"] = self._deserialize("str", response.headers.get("Content-Disposition")) + response_headers["Content-Language"] = self._deserialize("str", response.headers.get("Content-Language")) + response_headers["Accept-Ranges"] = self._deserialize("str", response.headers.get("Accept-Ranges")) + response_headers["x-ms-copy-completion-time"] = self._deserialize( + "rfc-1123", response.headers.get("x-ms-copy-completion-time") + ) + response_headers["x-ms-copy-status-description"] = self._deserialize( + "str", response.headers.get("x-ms-copy-status-description") + ) + response_headers["x-ms-copy-id"] = self._deserialize("str", response.headers.get("x-ms-copy-id")) + response_headers["x-ms-copy-progress"] = self._deserialize("str", response.headers.get("x-ms-copy-progress")) + response_headers["x-ms-copy-source"] = self._deserialize("str", response.headers.get("x-ms-copy-source")) + response_headers["x-ms-copy-status"] = self._deserialize("str", response.headers.get("x-ms-copy-status")) + response_headers["x-ms-content-md5"] = self._deserialize("bytearray", response.headers.get("x-ms-content-md5")) + response_headers["x-ms-server-encrypted"] = self._deserialize( + "bool", response.headers.get("x-ms-server-encrypted") + ) + response_headers["x-ms-file-permission-key"] = self._deserialize( + "str", response.headers.get("x-ms-file-permission-key") + ) + response_headers["x-ms-file-attributes"] = self._deserialize( + "str", response.headers.get("x-ms-file-attributes") + ) + response_headers["x-ms-file-creation-time"] = self._deserialize( + "str", response.headers.get("x-ms-file-creation-time") + ) + response_headers["x-ms-file-last-write-time"] = self._deserialize( + "str", response.headers.get("x-ms-file-last-write-time") + ) + response_headers["x-ms-file-change-time"] = self._deserialize( + "str", response.headers.get("x-ms-file-change-time") + ) + response_headers["x-ms-file-id"] = self._deserialize("str", response.headers.get("x-ms-file-id")) + response_headers["x-ms-file-parent-id"] = self._deserialize("str", response.headers.get("x-ms-file-parent-id")) + response_headers["x-ms-lease-duration"] = self._deserialize("str", response.headers.get("x-ms-lease-duration")) + response_headers["x-ms-lease-state"] = self._deserialize("str", response.headers.get("x-ms-lease-state")) + response_headers["x-ms-lease-status"] = self._deserialize("str", response.headers.get("x-ms-lease-status")) + response_headers["x-ms-structured-body"] = self._deserialize( + "str", response.headers.get("x-ms-structured-body") + ) + response_headers["x-ms-structured-content-length"] = self._deserialize( + "int", response.headers.get("x-ms-structured-content-length") + ) + response_headers["x-ms-mode"] = self._deserialize("str", response.headers.get("x-ms-mode")) + response_headers["x-ms-owner"] = self._deserialize("str", response.headers.get("x-ms-owner")) + response_headers["x-ms-group"] = self._deserialize("str", response.headers.get("x-ms-group")) + response_headers["x-ms-link-count"] = self._deserialize("int", response.headers.get("x-ms-link-count")) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + response_headers["Content-Type"] = self._deserialize("str", response.headers.get("Content-Type")) + + deserialized = response.iter_bytes() if _decompress else response.iter_raw() + + if cls: + return cls(pipeline_response, deserialized, response_headers) # type: ignore + + return deserialized # type: ignore + + @distributed_trace + def get_properties( + self, + *, + sharesnapshot: Optional[str] = None, + timeout: Optional[int] = None, + lease_id: Optional[str] = None, + allow_trailing_dot: Optional[bool] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any + ) -> bool: + """Returns all user-defined metadata, standard HTTP properties, and system properties for the + file. + + :keyword sharesnapshot: The snapshot parameter is an opaque DateTime value that specifies a + share snapshot. Default value is None. + :paramtype sharesnapshot: str + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword lease_id: If specified, the lease ID must match the lease ID of the file. Default + value is None. + :paramtype lease_id: str + :keyword allow_trailing_dot: If true, the trailing dot will not be trimmed from the target + file/directory path. Default value is None. + :paramtype allow_trailing_dot: bool + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :return: bool + :rtype: bool + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls: ClsType[None] = kwargs.pop("cls", None) + + _request = build_file_get_properties_request( + sharesnapshot=sharesnapshot, + timeout=timeout, + lease_id=lease_id, + allow_trailing_dot=allow_trailing_dot, + file_request_intent=file_request_intent, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) + response_headers["x-ms-meta"] = self._deserialize("{str}", response.headers.get("x-ms-meta")) + response_headers["x-ms-type"] = self._deserialize("str", response.headers.get("x-ms-type")) + response_headers["Content-Length"] = self._deserialize("int", response.headers.get("Content-Length")) + response_headers["Content-Type"] = self._deserialize("str", response.headers.get("Content-Type")) + response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) + response_headers["Content-MD5"] = self._deserialize("bytearray", response.headers.get("Content-MD5")) + response_headers["Content-Encoding"] = self._deserialize("str", response.headers.get("Content-Encoding")) + response_headers["Cache-Control"] = self._deserialize("str", response.headers.get("Cache-Control")) + response_headers["Content-Disposition"] = self._deserialize("str", response.headers.get("Content-Disposition")) + response_headers["Content-Language"] = self._deserialize("str", response.headers.get("Content-Language")) + response_headers["x-ms-copy-completion-time"] = self._deserialize( + "rfc-1123", response.headers.get("x-ms-copy-completion-time") + ) + response_headers["x-ms-copy-status-description"] = self._deserialize( + "str", response.headers.get("x-ms-copy-status-description") + ) + response_headers["x-ms-copy-id"] = self._deserialize("str", response.headers.get("x-ms-copy-id")) + response_headers["x-ms-copy-progress"] = self._deserialize("str", response.headers.get("x-ms-copy-progress")) + response_headers["x-ms-copy-source"] = self._deserialize("str", response.headers.get("x-ms-copy-source")) + response_headers["x-ms-copy-status"] = self._deserialize("str", response.headers.get("x-ms-copy-status")) + response_headers["x-ms-server-encrypted"] = self._deserialize( + "bool", response.headers.get("x-ms-server-encrypted") + ) + response_headers["x-ms-file-permission-key"] = self._deserialize( + "str", response.headers.get("x-ms-file-permission-key") + ) + response_headers["x-ms-file-attributes"] = self._deserialize( + "str", response.headers.get("x-ms-file-attributes") + ) + response_headers["x-ms-file-creation-time"] = self._deserialize( + "str", response.headers.get("x-ms-file-creation-time") + ) + response_headers["x-ms-file-last-write-time"] = self._deserialize( + "str", response.headers.get("x-ms-file-last-write-time") + ) + response_headers["x-ms-file-change-time"] = self._deserialize( + "str", response.headers.get("x-ms-file-change-time") + ) + response_headers["x-ms-file-id"] = self._deserialize("str", response.headers.get("x-ms-file-id")) + response_headers["x-ms-file-parent-id"] = self._deserialize("str", response.headers.get("x-ms-file-parent-id")) + response_headers["x-ms-lease-duration"] = self._deserialize("str", response.headers.get("x-ms-lease-duration")) + response_headers["x-ms-lease-state"] = self._deserialize("str", response.headers.get("x-ms-lease-state")) + response_headers["x-ms-lease-status"] = self._deserialize("str", response.headers.get("x-ms-lease-status")) + response_headers["x-ms-mode"] = self._deserialize("str", response.headers.get("x-ms-mode")) + response_headers["x-ms-owner"] = self._deserialize("str", response.headers.get("x-ms-owner")) + response_headers["x-ms-group"] = self._deserialize("str", response.headers.get("x-ms-group")) + response_headers["x-ms-file-file-type"] = self._deserialize("str", response.headers.get("x-ms-file-file-type")) + response_headers["x-ms-link-count"] = self._deserialize("int", response.headers.get("x-ms-link-count")) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + + if cls: + return cls(pipeline_response, None, response_headers) # type: ignore + return 200 <= response.status_code <= 299 + + @distributed_trace + def delete( # pylint: disable=inconsistent-return-statements + self, + *, + timeout: Optional[int] = None, + lease_id: Optional[str] = None, + allow_trailing_dot: Optional[bool] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any + ) -> None: + """Removes the file from the storage account. + + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword lease_id: If specified, the lease ID must match the lease ID of the file. Default + value is None. + :paramtype lease_id: str + :keyword allow_trailing_dot: If true, the trailing dot will not be trimmed from the target + file/directory path. Default value is None. + :paramtype allow_trailing_dot: bool + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls: ClsType[None] = kwargs.pop("cls", None) + + _request = build_file_delete_request( + timeout=timeout, + lease_id=lease_id, + allow_trailing_dot=allow_trailing_dot, + file_request_intent=file_request_intent, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [202]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["x-ms-link-count"] = self._deserialize("int", response.headers.get("x-ms-link-count")) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + + if cls: + return cls(pipeline_response, None, response_headers) # type: ignore + + @distributed_trace + def set_http_headers( # pylint: disable=inconsistent-return-statements,too-many-locals + self, + *, + timeout: Optional[int] = None, + file_content_length: Optional[int] = None, + file_content_type: Optional[str] = None, + file_content_encoding: Optional[str] = None, + file_content_language: Optional[str] = None, + file_cache_control: Optional[str] = None, + file_content_md5: Optional[bytes] = None, + file_content_disposition: Optional[str] = None, + file_permission: Optional[str] = None, + file_permission_key: Optional[str] = None, + file_attributes: Optional[str] = None, + file_creation_time: Optional[str] = None, + file_last_write_time: Optional[str] = None, + file_change_time: Optional[str] = None, + file_permission_format: Optional[Union[str, _models.FilePermissionFormat]] = None, + lease_id: Optional[str] = None, + allow_trailing_dot: Optional[bool] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + owner: Optional[str] = None, + group: Optional[str] = None, + file_mode: Optional[str] = None, + **kwargs: Any + ) -> None: + """Sets HTTP headers on a file. + + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword file_content_length: Specifies the number of bytes being transmitted. Default value is + None. + :paramtype file_content_length: int + :keyword file_content_type: Sets the MIME content type of the file. The default type is + 'application/octet-stream'. Default value is None. + :paramtype file_content_type: str + :keyword file_content_encoding: Specifies which content encodings have been applied to the + file. Default value is None. + :paramtype file_content_encoding: str + :keyword file_content_language: Specifies the natural languages used by this resource. Default + value is None. + :paramtype file_content_language: str + :keyword file_cache_control: Sets the file's cache control. The File service stores this value + but does not use or modify it. Default value is None. + :paramtype file_cache_control: str + :keyword file_content_md5: An MD5 hash of the file content. This hash is used to verify the + integrity of the file during transport. Default value is None. + :paramtype file_content_md5: bytes + :keyword file_content_disposition: Sets the file's Content-Disposition header. Default value is + None. + :paramtype file_content_disposition: str + :keyword file_permission: If specified the permission (security descriptor) shall be set for + the directory/file. This header can be used if Permission size is <= 8KB, else + x-ms-file-permission-key header shall be used. Default value: Inherit. If SDDL is specified as + input, it must have owner, group and dacl. Note: Only one of the x-ms-file-permission or + x-ms-file-permission-key should be specified. Default value is None. + :paramtype file_permission: str + :keyword file_permission_key: Key of the permission to be set for the directory/file. Note: + Only one of the x-ms-file-permission or x-ms-file-permission-key should be specified. Default + value is None. + :paramtype file_permission_key: str + :keyword file_attributes: If specified, the provided file attributes shall be set. Default + value: 'Archive' for file and 'Directory' for directory. 'None' can also be specified as + default. Default value is None. + :paramtype file_attributes: str + :keyword file_creation_time: Creation time for the file/directory. Default value: Now. Default + value is None. + :paramtype file_creation_time: str + :keyword file_last_write_time: Last write time for the file/directory. Default value: Now. + Default value is None. + :paramtype file_last_write_time: str + :keyword file_change_time: Change time for the file/directory. Default value: Now. Default + value is None. + :paramtype file_change_time: str + :keyword file_permission_format: Optional. Used to set permission format. Known values are: + "Sddl" and "Binary". Default value is None. + :paramtype file_permission_format: str or ~azure.storage.fileshare.models.FilePermissionFormat + :keyword lease_id: If specified, the lease ID must match the lease ID of the file. Default + value is None. + :paramtype lease_id: str + :keyword allow_trailing_dot: If true, the trailing dot will not be trimmed from the target + file/directory path. Default value is None. + :paramtype allow_trailing_dot: bool + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :keyword owner: Optional, NFS only. The owner of the file or directory. Default value is None. + :paramtype owner: str + :keyword group: Optional, NFS only. The owning group of the file or directory. Default value is + None. + :paramtype group: str + :keyword file_mode: Optional, NFS only. The file mode of the file or directory. Default value + is None. + :paramtype file_mode: str + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls: ClsType[None] = kwargs.pop("cls", None) + + _request = build_file_set_http_headers_request( + timeout=timeout, + file_content_length=file_content_length, + file_content_type=file_content_type, + file_content_encoding=file_content_encoding, + file_content_language=file_content_language, + file_cache_control=file_cache_control, + file_content_md5=file_content_md5, + file_content_disposition=file_content_disposition, + file_permission=file_permission, + file_permission_key=file_permission_key, + file_attributes=file_attributes, + file_creation_time=file_creation_time, + file_last_write_time=file_last_write_time, + file_change_time=file_change_time, + file_permission_format=file_permission_format, + lease_id=lease_id, + allow_trailing_dot=allow_trailing_dot, + file_request_intent=file_request_intent, + owner=owner, + group=group, + file_mode=file_mode, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) + response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) + response_headers["x-ms-request-server-encrypted"] = self._deserialize( + "bool", response.headers.get("x-ms-request-server-encrypted") + ) + response_headers["x-ms-file-permission-key"] = self._deserialize( + "str", response.headers.get("x-ms-file-permission-key") + ) + response_headers["x-ms-file-attributes"] = self._deserialize( + "str", response.headers.get("x-ms-file-attributes") + ) + response_headers["x-ms-file-creation-time"] = self._deserialize( + "str", response.headers.get("x-ms-file-creation-time") + ) + response_headers["x-ms-file-last-write-time"] = self._deserialize( + "str", response.headers.get("x-ms-file-last-write-time") + ) + response_headers["x-ms-file-change-time"] = self._deserialize( + "str", response.headers.get("x-ms-file-change-time") + ) + response_headers["x-ms-file-id"] = self._deserialize("str", response.headers.get("x-ms-file-id")) + response_headers["x-ms-file-parent-id"] = self._deserialize("str", response.headers.get("x-ms-file-parent-id")) + response_headers["x-ms-mode"] = self._deserialize("str", response.headers.get("x-ms-mode")) + response_headers["x-ms-owner"] = self._deserialize("str", response.headers.get("x-ms-owner")) + response_headers["x-ms-group"] = self._deserialize("str", response.headers.get("x-ms-group")) + response_headers["x-ms-link-count"] = self._deserialize("int", response.headers.get("x-ms-link-count")) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + + if cls: + return cls(pipeline_response, None, response_headers) # type: ignore + + @distributed_trace + def set_metadata( # pylint: disable=inconsistent-return-statements + self, + *, + timeout: Optional[int] = None, + metadata: Optional[dict[str, str]] = None, + lease_id: Optional[str] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + allow_trailing_dot: Optional[bool] = None, + **kwargs: Any + ) -> None: + """Sets one or more user-defined name-value pairs for the specified file. + + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword metadata: Optional. User-defined metadata for the resource. Default value is None. + :paramtype metadata: dict[str, str] + :keyword lease_id: If specified, the lease ID must match the lease ID of the file. Default + value is None. + :paramtype lease_id: str + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :keyword allow_trailing_dot: If true, the trailing dot will not be trimmed from the target + file/directory path. Default value is None. + :paramtype allow_trailing_dot: bool + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls: ClsType[None] = kwargs.pop("cls", None) + + _request = build_file_set_metadata_request( + timeout=timeout, + metadata=metadata, + lease_id=lease_id, + file_request_intent=file_request_intent, + allow_trailing_dot=allow_trailing_dot, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) + response_headers["x-ms-request-server-encrypted"] = self._deserialize( + "bool", response.headers.get("x-ms-request-server-encrypted") + ) + response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + + if cls: + return cls(pipeline_response, None, response_headers) # type: ignore + + @distributed_trace + def acquire_lease( # pylint: disable=inconsistent-return-statements + self, + *, + timeout: Optional[int] = None, + lease_duration: Optional[int] = None, + proposed_lease_id: Optional[str] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + allow_trailing_dot: Optional[bool] = None, + **kwargs: Any + ) -> None: + """The Lease File operation establishes and manages a lock on a file for write and delete + operations. + + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword lease_duration: Specifies the duration of the lease, in seconds, or negative one (-1) + for a lease that never expires. A non-infinite lease can be between 15 and 60 seconds. A lease + duration cannot be changed using renew or change. Default value is None. + :paramtype lease_duration: int + :keyword proposed_lease_id: Proposed lease ID, in a GUID string format. The File service + returns 400 (Invalid request) if the proposed lease ID is not in the correct format. See Guid + Constructor (String) for a list of valid GUID string formats. Default value is None. + :paramtype proposed_lease_id: str + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :keyword allow_trailing_dot: If true, the trailing dot will not be trimmed from the target + file/directory path. Default value is None. + :paramtype allow_trailing_dot: bool + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + action: Literal["acquire"] = kwargs.pop("action", _headers.pop("x-ms-lease-action", "acquire")) + cls: ClsType[None] = kwargs.pop("cls", None) + + _request = build_file_acquire_lease_request( + timeout=timeout, + lease_duration=lease_duration, + proposed_lease_id=proposed_lease_id, + file_request_intent=file_request_intent, + allow_trailing_dot=allow_trailing_dot, + action=action, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [201]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) + response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) + response_headers["x-ms-lease-id"] = self._deserialize("str", response.headers.get("x-ms-lease-id")) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + + if cls: + return cls(pipeline_response, None, response_headers) # type: ignore + + @distributed_trace + def release_lease( # pylint: disable=inconsistent-return-statements + self, + *, + lease_id: str, + timeout: Optional[int] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + allow_trailing_dot: Optional[bool] = None, + **kwargs: Any + ) -> None: + """The Lease File operation establishes and manages a lock on a file for write and delete + operations. + + :keyword lease_id: Specifies the current lease ID on the resource. Required. + :paramtype lease_id: str + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :keyword allow_trailing_dot: If true, the trailing dot will not be trimmed from the target + file/directory path. Default value is None. + :paramtype allow_trailing_dot: bool + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + action: Literal["release"] = kwargs.pop("action", _headers.pop("x-ms-lease-action", "release")) + cls: ClsType[None] = kwargs.pop("cls", None) + + _request = build_file_release_lease_request( + lease_id=lease_id, + timeout=timeout, + file_request_intent=file_request_intent, + allow_trailing_dot=allow_trailing_dot, + action=action, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) + response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + + if cls: + return cls(pipeline_response, None, response_headers) # type: ignore + + @distributed_trace + def change_lease( # pylint: disable=inconsistent-return-statements + self, + *, + lease_id: str, + timeout: Optional[int] = None, + proposed_lease_id: Optional[str] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + allow_trailing_dot: Optional[bool] = None, + **kwargs: Any + ) -> None: + """The Lease File operation establishes and manages a lock on a file for write and delete + operations. + + :keyword lease_id: Specifies the current lease ID on the resource. Required. + :paramtype lease_id: str + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword proposed_lease_id: Proposed lease ID, in a GUID string format. The File service + returns 400 (Invalid request) if the proposed lease ID is not in the correct format. See Guid + Constructor (String) for a list of valid GUID string formats. Default value is None. + :paramtype proposed_lease_id: str + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :keyword allow_trailing_dot: If true, the trailing dot will not be trimmed from the target + file/directory path. Default value is None. + :paramtype allow_trailing_dot: bool + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + action: Literal["change"] = kwargs.pop("action", _headers.pop("x-ms-lease-action", "change")) + cls: ClsType[None] = kwargs.pop("cls", None) + + _request = build_file_change_lease_request( + lease_id=lease_id, + timeout=timeout, + proposed_lease_id=proposed_lease_id, + file_request_intent=file_request_intent, + allow_trailing_dot=allow_trailing_dot, + action=action, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) + response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) + response_headers["x-ms-lease-id"] = self._deserialize("str", response.headers.get("x-ms-lease-id")) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + + if cls: + return cls(pipeline_response, None, response_headers) # type: ignore + + @distributed_trace + def break_lease( # pylint: disable=inconsistent-return-statements + self, + *, + timeout: Optional[int] = None, + lease_id: Optional[str] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + allow_trailing_dot: Optional[bool] = None, + **kwargs: Any + ) -> None: + """The Lease File operation establishes and manages a lock on a file for write and delete + operations. + + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword lease_id: If specified, the lease ID must match the lease ID of the file. Default + value is None. + :paramtype lease_id: str + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :keyword allow_trailing_dot: If true, the trailing dot will not be trimmed from the target + file/directory path. Default value is None. + :paramtype allow_trailing_dot: bool + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + action: Literal["break"] = kwargs.pop("action", _headers.pop("x-ms-lease-action", "break")) + cls: ClsType[None] = kwargs.pop("cls", None) + + _request = build_file_break_lease_request( + timeout=timeout, + lease_id=lease_id, + file_request_intent=file_request_intent, + allow_trailing_dot=allow_trailing_dot, + action=action, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [202]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) + response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) + response_headers["x-ms-lease-time"] = self._deserialize("int", response.headers.get("x-ms-lease-time")) + response_headers["x-ms-lease-id"] = self._deserialize("str", response.headers.get("x-ms-lease-id")) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + + if cls: + return cls(pipeline_response, None, response_headers) # type: ignore + + @distributed_trace + def upload_range( # pylint: disable=inconsistent-return-statements,too-many-locals + self, + optional_body: Optional[bytes] = None, + *, + range: str, + file_range_write: Union[str, _models.FileRangeWriteType], + content_length: int, + timeout: Optional[int] = None, + content_md5: Optional[bytes] = None, + lease_id: Optional[str] = None, + file_last_written_mode: Optional[Union[str, _models.FileLastWrittenMode]] = None, + allow_trailing_dot: Optional[bool] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + structured_body_type: Optional[str] = None, + structured_content_length: Optional[int] = None, + **kwargs: Any + ) -> None: + """Upload a range of bytes to a file. + + :param optional_body: Initial data. Default value is None. + :type optional_body: bytes + :keyword range: Specifies the range of bytes to be written. Both the start and end of the range + must be specified. Required. + :paramtype range: str + :keyword file_range_write: Specify one of the following options: - Update: Writes the bytes + specified by the request body into the specified range. - Clear: Clears the specified range and + releases the space used in storage for that range. Known values are: "update" and "clear". + Required. + :paramtype file_range_write: str or ~azure.storage.fileshare.models.FileRangeWriteType + :keyword content_length: The number of bytes being transmitted in the request body. Required. + :paramtype content_length: int + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword content_md5: An MD5 hash of the content. This hash is used to verify the integrity of + the data during transport. Default value is None. + :paramtype content_md5: bytes + :keyword lease_id: If specified, the lease ID must match the lease ID of the file. Default + value is None. + :paramtype lease_id: str + :keyword file_last_written_mode: If the file last write time should be preserved or + overwritten. Known values are: "Now" and "Preserve". Default value is None. + :paramtype file_last_written_mode: str or ~azure.storage.fileshare.models.FileLastWrittenMode + :keyword allow_trailing_dot: If true, the trailing dot will not be trimmed from the target + file/directory path. Default value is None. + :paramtype allow_trailing_dot: bool + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :keyword structured_body_type: Specifies the response content should be returned as a + structured message and specifies the message schema version and properties. Default value is + None. + :paramtype structured_body_type: str + :keyword structured_content_length: Required if the request body is a structured message. + Specifies the length of the blob/file content inside the message body. Will always be smaller + than Content-Length. Default value is None. + :paramtype structured_content_length: int + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = kwargs.pop("params", {}) or {} + + content_type: Optional[str] = kwargs.pop( + "content_type", _headers.pop("Content-Type", "application/octet-stream") + ) + content_type = content_type if optional_body else None + cls: ClsType[None] = kwargs.pop("cls", None) + + _content = optional_body + + _request = build_file_upload_range_request( + range=range, + file_range_write=file_range_write, + content_length=content_length, + timeout=timeout, + content_md5=content_md5, + lease_id=lease_id, + file_last_written_mode=file_last_written_mode, + allow_trailing_dot=allow_trailing_dot, + file_request_intent=file_request_intent, + structured_body_type=structured_body_type, + structured_content_length=structured_content_length, + content_type=content_type, + version=self._config.version, + content=_content, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [201]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) + response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) + response_headers["Content-MD5"] = self._deserialize("bytearray", response.headers.get("Content-MD5")) + response_headers["x-ms-request-server-encrypted"] = self._deserialize( + "bool", response.headers.get("x-ms-request-server-encrypted") + ) + response_headers["x-ms-file-last-write-time"] = self._deserialize( + "str", response.headers.get("x-ms-file-last-write-time") + ) + response_headers["x-ms-structured-body"] = self._deserialize( + "str", response.headers.get("x-ms-structured-body") + ) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + + if cls: + return cls(pipeline_response, None, response_headers) # type: ignore + + @distributed_trace + def upload_range_from_url( # pylint: disable=inconsistent-return-statements,too-many-locals + self, + *, + range: str, + copy_source: str, + file_range_write_from_url: Union[str, _models.FileRangeWriteFromUrlType], + content_length: int, + source_range: Optional[str] = None, + timeout: Optional[int] = None, + source_content_crc64: Optional[bytes] = None, + source_if_match_crc64: Optional[bytes] = None, + source_if_none_match_crc64: Optional[bytes] = None, + lease_id: Optional[str] = None, + copy_source_authorization: Optional[str] = None, + file_last_written_mode: Optional[Union[str, _models.FileLastWrittenMode]] = None, + allow_trailing_dot: Optional[bool] = None, + allow_source_trailing_dot: Optional[bool] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any + ) -> None: + """Upload a range of bytes to a file where the contents are read from a URL. + + :keyword range: Specifies the range of bytes to be written. Both the start and end of the range + must be specified. Required. + :paramtype range: str + :keyword copy_source: Specifies the URL of the source file or blob, up to 2 KB in length. + Required. + :paramtype copy_source: str + :keyword file_range_write_from_url: Only update is supported. "update" Required. + :paramtype file_range_write_from_url: str or + ~azure.storage.fileshare.models.FileRangeWriteFromUrlType + :keyword content_length: The number of bytes being transmitted in the request body. Required. + :paramtype content_length: int + :keyword source_range: Bytes of source data in the specified range. Default value is None. + :paramtype source_range: str + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword source_content_crc64: Specify the CRC64 hash of the source content. Default value is + None. + :paramtype source_content_crc64: bytes + :keyword source_if_match_crc64: Specify the CRC64 hash value to check for source content + integrity. Default value is None. + :paramtype source_if_match_crc64: bytes + :keyword source_if_none_match_crc64: Specify the CRC64 hash value to check for source content + mismatch. Default value is None. + :paramtype source_if_none_match_crc64: bytes + :keyword lease_id: If specified, the lease ID must match the lease ID of the file. Default + value is None. + :paramtype lease_id: str + :keyword copy_source_authorization: Only Bearer type is supported. Credentials should be a + valid OAuth access token to copy source. Default value is None. + :paramtype copy_source_authorization: str + :keyword file_last_written_mode: If the file last write time should be preserved or + overwritten. Known values are: "Now" and "Preserve". Default value is None. + :paramtype file_last_written_mode: str or ~azure.storage.fileshare.models.FileLastWrittenMode + :keyword allow_trailing_dot: If true, the trailing dot will not be trimmed from the target + file/directory path. Default value is None. + :paramtype allow_trailing_dot: bool + :keyword allow_source_trailing_dot: If true, the trailing dot will not be trimmed from the + source URI. Default value is None. + :paramtype allow_source_trailing_dot: bool + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls: ClsType[None] = kwargs.pop("cls", None) + + _request = build_file_upload_range_from_url_request( + range=range, + copy_source=copy_source, + file_range_write_from_url=file_range_write_from_url, + content_length=content_length, + source_range=source_range, + timeout=timeout, + source_content_crc64=source_content_crc64, + source_if_match_crc64=source_if_match_crc64, + source_if_none_match_crc64=source_if_none_match_crc64, + lease_id=lease_id, + copy_source_authorization=copy_source_authorization, + file_last_written_mode=file_last_written_mode, + allow_trailing_dot=allow_trailing_dot, + allow_source_trailing_dot=allow_source_trailing_dot, + file_request_intent=file_request_intent, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [201]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) + response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) + response_headers["Content-MD5"] = self._deserialize("bytearray", response.headers.get("Content-MD5")) + response_headers["x-ms-content-crc64"] = self._deserialize( + "bytearray", response.headers.get("x-ms-content-crc64") + ) + response_headers["x-ms-request-server-encrypted"] = self._deserialize( + "bool", response.headers.get("x-ms-request-server-encrypted") + ) + response_headers["x-ms-file-last-write-time"] = self._deserialize( + "str", response.headers.get("x-ms-file-last-write-time") + ) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + + if cls: + return cls(pipeline_response, None, response_headers) # type: ignore + + @distributed_trace + def get_range_list( + self, + *, + sharesnapshot: Optional[str] = None, + prevsharesnapshot: Optional[str] = None, + timeout: Optional[int] = None, + range: Optional[str] = None, + lease_id: Optional[str] = None, + allow_trailing_dot: Optional[bool] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + support_rename: Optional[bool] = None, + **kwargs: Any + ) -> _models.ShareFileRangeList: + """Returns the list of valid page ranges for a file or snapshot of a file. + + :keyword sharesnapshot: The snapshot parameter is an opaque DateTime value that specifies a + share snapshot. Default value is None. + :paramtype sharesnapshot: str + :keyword prevsharesnapshot: The previous snapshot parameter is an opaque DateTime value that + specifies a previous file snapshot to compare against. Default value is None. + :paramtype prevsharesnapshot: str + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword range: Return file data only from the specified byte range. Default value is None. + :paramtype range: str + :keyword lease_id: If specified, the lease ID must match the lease ID of the file. Default + value is None. + :paramtype lease_id: str + :keyword allow_trailing_dot: If true, the trailing dot will not be trimmed from the target + file/directory path. Default value is None. + :paramtype allow_trailing_dot: bool + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :keyword support_rename: This header is allowed only when PrevShareSnapshot query parameter is + set. Determines whether the changed ranges for a file that has been renamed or moved should be + listed. Default value is None. + :paramtype support_rename: bool + :return: ShareFileRangeList. The ShareFileRangeList is compatible with MutableMapping + :rtype: ~azure.storage.fileshare._generated.models.ShareFileRangeList + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls: ClsType[_models.ShareFileRangeList] = kwargs.pop("cls", None) + + _request = build_file_get_range_list_request( + sharesnapshot=sharesnapshot, + prevsharesnapshot=prevsharesnapshot, + timeout=timeout, + range=range, + lease_id=lease_id, + allow_trailing_dot=allow_trailing_dot, + file_request_intent=file_request_intent, + support_rename=support_rename, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _decompress = kwargs.pop("decompress", True) + _stream = kwargs.pop("stream", False) + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + if _stream: + try: + response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) + response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) + response_headers["x-ms-content-length"] = self._deserialize("int", response.headers.get("x-ms-content-length")) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + response_headers["Content-Type"] = self._deserialize("str", response.headers.get("Content-Type")) + + if _stream: + deserialized = response.iter_bytes() if _decompress else response.iter_raw() + else: + deserialized = _deserialize_xml(_models.ShareFileRangeList, response.text()) + + if cls: + return cls(pipeline_response, deserialized, response_headers) # type: ignore + + return deserialized # type: ignore + + @distributed_trace + def start_copy( # pylint: disable=inconsistent-return-statements,too-many-locals + self, + *, + copy_source: str, + timeout: Optional[int] = None, + metadata: Optional[dict[str, str]] = None, + file_permission: Optional[str] = None, + file_permission_format: Optional[Union[str, _models.FilePermissionFormat]] = None, + file_permission_key: Optional[str] = None, + file_permission_copy_mode: Optional[Union[str, _models.PermissionCopyModeType]] = None, + ignore_read_only: Optional[bool] = None, + file_attributes: Optional[str] = None, + file_creation_time: Optional[str] = None, + file_last_write_time: Optional[str] = None, + file_change_time: Optional[str] = None, + set_archive_attribute: Optional[bool] = None, + lease_id: Optional[str] = None, + allow_trailing_dot: Optional[bool] = None, + allow_source_trailing_dot: Optional[bool] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + owner: Optional[str] = None, + group: Optional[str] = None, + file_mode: Optional[str] = None, + file_mode_copy_mode: Optional[Union[str, _models.ModeCopyMode]] = None, + file_owner_copy_mode: Optional[Union[str, _models.OwnerCopyMode]] = None, + **kwargs: Any + ) -> None: + """Copies a blob or file to a destination file within the storage account. + + :keyword copy_source: Specifies the URL of the source file or blob, up to 2 KB in length. + Required. + :paramtype copy_source: str + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword metadata: Optional. User-defined metadata for the resource. Default value is None. + :paramtype metadata: dict[str, str] + :keyword file_permission: If specified the permission shall be set for the file. Default value + is None. + :paramtype file_permission: str + :keyword file_permission_format: Optional. Used to set permission format. Known values are: + "Sddl" and "Binary". Default value is None. + :paramtype file_permission_format: str or ~azure.storage.fileshare.models.FilePermissionFormat + :keyword file_permission_key: Key of the permission to be set. Default value is None. + :paramtype file_permission_key: str + :keyword file_permission_copy_mode: Specifies the option to copy file security descriptor from + source file or to set it using the value which is defined by the header value of + x-ms-file-permission or x-ms-file-permission-key. Known values are: "source" and "override". + Default value is None. + :paramtype file_permission_copy_mode: str or + ~azure.storage.fileshare.models.PermissionCopyModeType + :keyword ignore_read_only: A boolean value that specifies whether the ReadOnly attribute on a + preexisting destination file should be respected or overridden. Default value is None. + :paramtype ignore_read_only: bool + :keyword file_attributes: If specified, the provided file attributes shall be set. Default + value is None. + :paramtype file_attributes: str + :keyword file_creation_time: Creation time for the file. Default value is None. + :paramtype file_creation_time: str + :keyword file_last_write_time: Last write time for the file. Default value is None. + :paramtype file_last_write_time: str + :keyword file_change_time: Change time for the file. Default value is None. + :paramtype file_change_time: str + :keyword set_archive_attribute: Optional. Sets the archive attribute on the destination file. + Default value is None. + :paramtype set_archive_attribute: bool + :keyword lease_id: If specified, the lease ID must match the lease ID of the file. Default + value is None. + :paramtype lease_id: str + :keyword allow_trailing_dot: If true, the trailing dot will not be trimmed from the target + file/directory path. Default value is None. + :paramtype allow_trailing_dot: bool + :keyword allow_source_trailing_dot: If true, the trailing dot will not be trimmed from the + source URI. Default value is None. + :paramtype allow_source_trailing_dot: bool + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :keyword owner: Optional, NFS only. The owner of the file or directory. Default value is None. + :paramtype owner: str + :keyword group: Optional, NFS only. The owning group of the file or directory. Default value is + None. + :paramtype group: str + :keyword file_mode: Optional, NFS only. The file mode of the file or directory. Default value + is None. + :paramtype file_mode: str + :keyword file_mode_copy_mode: Specifies mode copy option for the file. Known values are: + "source" and "override". Default value is None. + :paramtype file_mode_copy_mode: str or ~azure.storage.fileshare.models.ModeCopyMode + :keyword file_owner_copy_mode: Specifies owner copy option for the file. Known values are: + "source" and "override". Default value is None. + :paramtype file_owner_copy_mode: str or ~azure.storage.fileshare.models.OwnerCopyMode + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls: ClsType[None] = kwargs.pop("cls", None) + + _request = build_file_start_copy_request( + copy_source=copy_source, + timeout=timeout, + metadata=metadata, + file_permission=file_permission, + file_permission_format=file_permission_format, + file_permission_key=file_permission_key, + file_permission_copy_mode=file_permission_copy_mode, + ignore_read_only=ignore_read_only, + file_attributes=file_attributes, + file_creation_time=file_creation_time, + file_last_write_time=file_last_write_time, + file_change_time=file_change_time, + set_archive_attribute=set_archive_attribute, + lease_id=lease_id, + allow_trailing_dot=allow_trailing_dot, + allow_source_trailing_dot=allow_source_trailing_dot, + file_request_intent=file_request_intent, + owner=owner, + group=group, + file_mode=file_mode, + file_mode_copy_mode=file_mode_copy_mode, + file_owner_copy_mode=file_owner_copy_mode, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [202]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) + response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) + response_headers["x-ms-copy-id"] = self._deserialize("str", response.headers.get("x-ms-copy-id")) + response_headers["x-ms-copy-status"] = self._deserialize("str", response.headers.get("x-ms-copy-status")) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + + if cls: + return cls(pipeline_response, None, response_headers) # type: ignore + + @distributed_trace + def abort_copy( # pylint: disable=inconsistent-return-statements + self, + *, + copyid: str, + timeout: Optional[int] = None, + lease_id: Optional[str] = None, + allow_trailing_dot: Optional[bool] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any + ) -> None: + """Aborts a pending Copy File operation, and leaves a destination file with zero length and full + metadata. + + :keyword copyid: The copy identifier provided in the x-ms-copy-id header of the original Copy + File operation. Required. + :paramtype copyid: str + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword lease_id: If specified, the lease ID must match the lease ID of the file. Default + value is None. + :paramtype lease_id: str + :keyword allow_trailing_dot: If true, the trailing dot will not be trimmed from the target + file/directory path. Default value is None. + :paramtype allow_trailing_dot: bool + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + copy_action_abort_constant: Literal["abort"] = kwargs.pop( + "copy_action_abort_constant", _headers.pop("x-ms-copy-action", "abort") + ) + cls: ClsType[None] = kwargs.pop("cls", None) + + _request = build_file_abort_copy_request( + copyid=copyid, + timeout=timeout, + lease_id=lease_id, + allow_trailing_dot=allow_trailing_dot, + file_request_intent=file_request_intent, + copy_action_abort_constant=copy_action_abort_constant, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [204]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + + if cls: + return cls(pipeline_response, None, response_headers) # type: ignore + + @distributed_trace + def list_handles( + self, + *, + marker: Optional[str] = None, + maxresults: Optional[int] = None, + timeout: Optional[int] = None, + sharesnapshot: Optional[str] = None, + allow_trailing_dot: Optional[bool] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any + ) -> _models.ListHandlesResponse: + """Lists handles for file. + + :keyword marker: A string value that identifies the portion of the list to be returned with the + next listing operation. Default value is None. + :paramtype marker: str + :keyword maxresults: Specifies the maximum number of items to return. Default value is None. + :paramtype maxresults: int + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword sharesnapshot: The snapshot parameter is an opaque DateTime value that specifies a + share snapshot. Default value is None. + :paramtype sharesnapshot: str + :keyword allow_trailing_dot: If true, the trailing dot will not be trimmed from the target + file/directory path. Default value is None. + :paramtype allow_trailing_dot: bool + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :return: ListHandlesResponse. The ListHandlesResponse is compatible with MutableMapping + :rtype: ~azure.storage.fileshare._generated.models.ListHandlesResponse + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls: ClsType[_models.ListHandlesResponse] = kwargs.pop("cls", None) + + _request = build_file_list_handles_request( + marker=marker, + maxresults=maxresults, + timeout=timeout, + sharesnapshot=sharesnapshot, + allow_trailing_dot=allow_trailing_dot, + file_request_intent=file_request_intent, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _decompress = kwargs.pop("decompress", True) + _stream = kwargs.pop("stream", False) + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + if _stream: + try: + response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + response_headers["Content-Type"] = self._deserialize("str", response.headers.get("Content-Type")) + + if _stream: + deserialized = response.iter_bytes() if _decompress else response.iter_raw() + else: + deserialized = _deserialize_xml(_models.ListHandlesResponse, response.text()) + + if cls: + return cls(pipeline_response, deserialized, response_headers) # type: ignore + + return deserialized # type: ignore + + @distributed_trace + def force_close_handles( # pylint: disable=inconsistent-return-statements + self, + *, + handle_id: str, + timeout: Optional[int] = None, + marker: Optional[str] = None, + sharesnapshot: Optional[str] = None, + allow_trailing_dot: Optional[bool] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any + ) -> None: + """Closes all handles open for given file. + + :keyword handle_id: Specifies handle ID opened on the file or directory to be closed. Asterisk + ('*') is a wildcard that specifies all handles. Required. + :paramtype handle_id: str + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword marker: A string value that identifies the portion of the list to be returned with the + next listing operation. Default value is None. + :paramtype marker: str + :keyword sharesnapshot: The snapshot parameter is an opaque DateTime value that specifies a + share snapshot. Default value is None. + :paramtype sharesnapshot: str + :keyword allow_trailing_dot: If true, the trailing dot will not be trimmed from the target + file/directory path. Default value is None. + :paramtype allow_trailing_dot: bool + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls: ClsType[None] = kwargs.pop("cls", None) + + _request = build_file_force_close_handles_request( + handle_id=handle_id, + timeout=timeout, + marker=marker, + sharesnapshot=sharesnapshot, + allow_trailing_dot=allow_trailing_dot, + file_request_intent=file_request_intent, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["x-ms-marker"] = self._deserialize("str", response.headers.get("x-ms-marker")) + response_headers["x-ms-number-of-handles-closed"] = self._deserialize( + "int", response.headers.get("x-ms-number-of-handles-closed") + ) + response_headers["x-ms-number-of-handles-failed"] = self._deserialize( + "int", response.headers.get("x-ms-number-of-handles-failed") + ) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + + if cls: + return cls(pipeline_response, None, response_headers) # type: ignore + + @distributed_trace + def rename( # pylint: disable=inconsistent-return-statements,too-many-locals + self, + *, + rename_source: str, + timeout: Optional[int] = None, + replace_if_exists: Optional[bool] = None, + ignore_read_only: Optional[bool] = None, + source_lease_id: Optional[str] = None, + destination_lease_id: Optional[str] = None, + file_attributes: Optional[str] = None, + file_creation_time: Optional[str] = None, + file_last_write_time: Optional[str] = None, + file_change_time: Optional[str] = None, + file_permission: Optional[str] = None, + file_permission_format: Optional[Union[str, _models.FilePermissionFormat]] = None, + file_permission_key: Optional[str] = None, + metadata: Optional[dict[str, str]] = None, + file_content_type: Optional[str] = None, + allow_trailing_dot: Optional[bool] = None, + allow_source_trailing_dot: Optional[bool] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any + ) -> None: + """Renames a file. By default, the destination is overwritten and if the destination already + exists and has a read-only attribute set, the operation will fail. + + :keyword rename_source: Required. Specifies the URI-style path of the source file, up to 2 KB + in length. Required. + :paramtype rename_source: str + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword replace_if_exists: Boolean. Default value is false. Set to true to indicate that the + destination should be overwritten. Default value is None. + :paramtype replace_if_exists: bool + :keyword ignore_read_only: Boolean. Default value is false. Set to true to overwrite the + destination even if it has the read-only attribute set. Default value is None. + :paramtype ignore_read_only: bool + :keyword source_lease_id: Required if the source file has an active lease. Default value is + None. + :paramtype source_lease_id: str + :keyword destination_lease_id: Required if the destination has an active lease. Default value + is None. + :paramtype destination_lease_id: str + :keyword file_attributes: If specified, the provided file attributes shall be set. Default + value is None. + :paramtype file_attributes: str + :keyword file_creation_time: Creation time for the file. Default value is None. + :paramtype file_creation_time: str + :keyword file_last_write_time: Last write time for the file. Default value is None. + :paramtype file_last_write_time: str + :keyword file_change_time: Change time for the file. Default value is None. + :paramtype file_change_time: str + :keyword file_permission: If specified the permission shall be set for the file. Default value + is None. + :paramtype file_permission: str + :keyword file_permission_format: Optional. Used to set permission format. Known values are: + "Sddl" and "Binary". Default value is None. + :paramtype file_permission_format: str or ~azure.storage.fileshare.models.FilePermissionFormat + :keyword file_permission_key: Key of the permission to be set. Default value is None. + :paramtype file_permission_key: str + :keyword metadata: Optional. User-defined metadata for the resource. Default value is None. + :paramtype metadata: dict[str, str] + :keyword file_content_type: Sets the MIME content type of the file. Default value is None. + :paramtype file_content_type: str + :keyword allow_trailing_dot: If true, the trailing dot will not be trimmed from the target + file/directory path. Default value is None. + :paramtype allow_trailing_dot: bool + :keyword allow_source_trailing_dot: If true, the trailing dot will not be trimmed from the + source URI. Default value is None. + :paramtype allow_source_trailing_dot: bool + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls: ClsType[None] = kwargs.pop("cls", None) + + _request = build_file_rename_request( + rename_source=rename_source, + timeout=timeout, + replace_if_exists=replace_if_exists, + ignore_read_only=ignore_read_only, + source_lease_id=source_lease_id, + destination_lease_id=destination_lease_id, + file_attributes=file_attributes, + file_creation_time=file_creation_time, + file_last_write_time=file_last_write_time, + file_change_time=file_change_time, + file_permission=file_permission, + file_permission_format=file_permission_format, + file_permission_key=file_permission_key, + metadata=metadata, + file_content_type=file_content_type, + allow_trailing_dot=allow_trailing_dot, + allow_source_trailing_dot=allow_source_trailing_dot, + file_request_intent=file_request_intent, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) + response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) + response_headers["x-ms-request-server-encrypted"] = self._deserialize( + "bool", response.headers.get("x-ms-request-server-encrypted") + ) + response_headers["x-ms-file-permission-key"] = self._deserialize( + "str", response.headers.get("x-ms-file-permission-key") + ) + response_headers["x-ms-file-attributes"] = self._deserialize( + "str", response.headers.get("x-ms-file-attributes") + ) + response_headers["x-ms-file-creation-time"] = self._deserialize( + "str", response.headers.get("x-ms-file-creation-time") + ) + response_headers["x-ms-file-last-write-time"] = self._deserialize( + "str", response.headers.get("x-ms-file-last-write-time") + ) + response_headers["x-ms-file-change-time"] = self._deserialize( + "str", response.headers.get("x-ms-file-change-time") + ) + response_headers["x-ms-file-id"] = self._deserialize("str", response.headers.get("x-ms-file-id")) + response_headers["x-ms-file-parent-id"] = self._deserialize("str", response.headers.get("x-ms-file-parent-id")) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + + if cls: + return cls(pipeline_response, None, response_headers) # type: ignore + + @distributed_trace + def create_symbolic_link( # pylint: disable=inconsistent-return-statements + self, + *, + link_text: str, + timeout: Optional[int] = None, + metadata: Optional[dict[str, str]] = None, + file_creation_time: Optional[str] = None, + file_last_write_time: Optional[str] = None, + lease_id: Optional[str] = None, + owner: Optional[str] = None, + group: Optional[str] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any + ) -> None: + """Creates a symbolic link to a target file. NFS only. + + :keyword link_text: NFS only. The path to the original file, the symbolic link is pointing to. + Required. + :paramtype link_text: str + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword metadata: Optional. User-defined metadata for the resource. Default value is None. + :paramtype metadata: dict[str, str] + :keyword file_creation_time: Creation time for the file. Default value is None. + :paramtype file_creation_time: str + :keyword file_last_write_time: Last write time for the file. Default value is None. + :paramtype file_last_write_time: str + :keyword lease_id: If specified, the lease ID must match the lease ID of the file. Default + value is None. + :paramtype lease_id: str + :keyword owner: Optional, NFS only. The owner of the file or directory. Default value is None. + :paramtype owner: str + :keyword group: Optional, NFS only. The owning group of the file or directory. Default value is + None. + :paramtype group: str + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls: ClsType[None] = kwargs.pop("cls", None) + + _request = build_file_create_symbolic_link_request( + link_text=link_text, + timeout=timeout, + metadata=metadata, + file_creation_time=file_creation_time, + file_last_write_time=file_last_write_time, + lease_id=lease_id, + owner=owner, + group=group, + file_request_intent=file_request_intent, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [201]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) + response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) + response_headers["x-ms-file-creation-time"] = self._deserialize( + "str", response.headers.get("x-ms-file-creation-time") + ) + response_headers["x-ms-file-last-write-time"] = self._deserialize( + "str", response.headers.get("x-ms-file-last-write-time") + ) + response_headers["x-ms-file-change-time"] = self._deserialize( + "str", response.headers.get("x-ms-file-change-time") + ) + response_headers["x-ms-file-id"] = self._deserialize("str", response.headers.get("x-ms-file-id")) + response_headers["x-ms-file-parent-id"] = self._deserialize("str", response.headers.get("x-ms-file-parent-id")) + response_headers["x-ms-mode"] = self._deserialize("str", response.headers.get("x-ms-mode")) + response_headers["x-ms-owner"] = self._deserialize("str", response.headers.get("x-ms-owner")) + response_headers["x-ms-group"] = self._deserialize("str", response.headers.get("x-ms-group")) + response_headers["x-ms-file-file-type"] = self._deserialize("str", response.headers.get("x-ms-file-file-type")) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + + if cls: + return cls(pipeline_response, None, response_headers) # type: ignore + + @distributed_trace + def get_symbolic_link( # pylint: disable=inconsistent-return-statements + self, + *, + timeout: Optional[int] = None, + sharesnapshot: Optional[str] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any + ) -> None: + """Returns the target of a symbolic link. NFS only. + + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword sharesnapshot: The snapshot parameter is an opaque DateTime value that specifies a + share snapshot. Default value is None. + :paramtype sharesnapshot: str + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls: ClsType[None] = kwargs.pop("cls", None) + + _request = build_file_get_symbolic_link_request( + timeout=timeout, + sharesnapshot=sharesnapshot, + file_request_intent=file_request_intent, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) + response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) + response_headers["x-ms-link-text"] = self._deserialize("str", response.headers.get("x-ms-link-text")) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + + if cls: + return cls(pipeline_response, None, response_headers) # type: ignore + + @distributed_trace + def create_hard_link( # pylint: disable=inconsistent-return-statements + self, + *, + target_file: str, + timeout: Optional[int] = None, + lease_id: Optional[str] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any + ) -> None: + """Creates a hard link to a target file. NFS only. + + :keyword target_file: NFS only. Required. Specifies the path of the target file to which the + link will be created, up to 2 KiB in length. Required. + :paramtype target_file: str + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword lease_id: If specified, the lease ID must match the lease ID of the file. Default + value is None. + :paramtype lease_id: str + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + file_type: Literal["file"] = kwargs.pop("file_type", _headers.pop("x-ms-type", "file")) + cls: ClsType[None] = kwargs.pop("cls", None) + + _request = build_file_create_hard_link_request( + target_file=target_file, + timeout=timeout, + lease_id=lease_id, + file_request_intent=file_request_intent, + file_type=file_type, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [201]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) + response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) + response_headers["x-ms-file-creation-time"] = self._deserialize( + "str", response.headers.get("x-ms-file-creation-time") + ) + response_headers["x-ms-file-last-write-time"] = self._deserialize( + "str", response.headers.get("x-ms-file-last-write-time") + ) + response_headers["x-ms-file-change-time"] = self._deserialize( + "str", response.headers.get("x-ms-file-change-time") + ) + response_headers["x-ms-file-id"] = self._deserialize("str", response.headers.get("x-ms-file-id")) + response_headers["x-ms-file-parent-id"] = self._deserialize("str", response.headers.get("x-ms-file-parent-id")) + response_headers["x-ms-link-count"] = self._deserialize("int", response.headers.get("x-ms-link-count")) + response_headers["x-ms-mode"] = self._deserialize("str", response.headers.get("x-ms-mode")) + response_headers["x-ms-owner"] = self._deserialize("str", response.headers.get("x-ms-owner")) + response_headers["x-ms-group"] = self._deserialize("str", response.headers.get("x-ms-group")) + response_headers["x-ms-file-file-type"] = self._deserialize("str", response.headers.get("x-ms-file-file-type")) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + + if cls: + return cls(pipeline_response, None, response_headers) # type: ignore + + +class ServiceOperations: + """ + .. warning:: + **DO NOT** instantiate this class directly. + + Instead, you should access the following operations through + :class:`~azure.storage.fileshare.FileClient`'s + :attr:`service` attribute. + """ + + def __init__(self, *args, **kwargs) -> None: + input_args = list(args) + self._client: PipelineClient = input_args.pop(0) if input_args else kwargs.pop("client") + self._config: FileClientConfiguration = input_args.pop(0) if input_args else kwargs.pop("config") + self._serialize: Serializer = input_args.pop(0) if input_args else kwargs.pop("serializer") + self._deserialize: Deserializer = input_args.pop(0) if input_args else kwargs.pop("deserializer") + + @distributed_trace + def set_properties( # pylint: disable=inconsistent-return-statements + self, + storage_service_properties: _models.StorageServiceProperties, + *, + timeout: Optional[int] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any + ) -> None: + """Sets properties for a storage account's File service endpoint, including properties for Storage + Analytics metrics and CORS (Cross-Origin Resource Sharing) rules. + + :param storage_service_properties: Storage service properties. Required. + :type storage_service_properties: + ~azure.storage.fileshare._generated.models.StorageServiceProperties + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = kwargs.pop("params", {}) or {} + + content_type: str = kwargs.pop("content_type", _headers.pop("Content-Type", "application/xml")) + cls: ClsType[None] = kwargs.pop("cls", None) + + _content = _get_element(storage_service_properties) + + _request = build_service_set_properties_request( + timeout=timeout, + file_request_intent=file_request_intent, + content_type=content_type, + version=self._config.version, + content=_content, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [202]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + + if cls: + return cls(pipeline_response, None, response_headers) # type: ignore + + @distributed_trace + def get_properties( + self, + *, + timeout: Optional[int] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any + ) -> _models.StorageServiceProperties: + """Gets the properties of a storage account's File service, including properties for Storage + Analytics metrics and CORS (Cross-Origin Resource Sharing) rules. + + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :return: StorageServiceProperties. The StorageServiceProperties is compatible with + MutableMapping + :rtype: ~azure.storage.fileshare._generated.models.StorageServiceProperties + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls: ClsType[_models.StorageServiceProperties] = kwargs.pop("cls", None) + + _request = build_service_get_properties_request( + timeout=timeout, + file_request_intent=file_request_intent, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _decompress = kwargs.pop("decompress", True) + _stream = kwargs.pop("stream", False) + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + if _stream: + try: + response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + response_headers["Content-Type"] = self._deserialize("str", response.headers.get("Content-Type")) + + if _stream: + deserialized = response.iter_bytes() if _decompress else response.iter_raw() + else: + deserialized = _deserialize_xml(_models.StorageServiceProperties, response.text()) + + if cls: + return cls(pipeline_response, deserialized, response_headers) # type: ignore + + return deserialized # type: ignore + + @distributed_trace + def list_shares_segment( + self, + *, + prefix: Optional[str] = None, + marker: Optional[str] = None, + maxresults: Optional[int] = None, + timeout: Optional[int] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + include: Optional[list[Union[str, _models.ListSharesIncludeType]]] = None, + **kwargs: Any + ) -> _models.ListSharesResponse: + """The List Shares Segment operation returns a list of the shares and share snapshots under the + specified account. + + :keyword prefix: Filters the results to return only items whose name begins with the specified + prefix. Default value is None. + :paramtype prefix: str + :keyword marker: A string value that identifies the portion of the list to be returned with the + next listing operation. Default value is None. + :paramtype marker: str + :keyword maxresults: Specifies the maximum number of items to return. Default value is None. + :paramtype maxresults: int + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :keyword include: Include this parameter to specify one or more datasets to include in the + response. Default value is None. + :paramtype include: list[str or ~azure.storage.fileshare.models.ListSharesIncludeType] + :return: ListSharesResponse. The ListSharesResponse is compatible with MutableMapping + :rtype: ~azure.storage.fileshare._generated.models.ListSharesResponse + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls: ClsType[_models.ListSharesResponse] = kwargs.pop("cls", None) + + _request = build_service_list_shares_segment_request( + prefix=prefix, + marker=marker, + maxresults=maxresults, + timeout=timeout, + file_request_intent=file_request_intent, + include=include, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _decompress = kwargs.pop("decompress", True) + _stream = kwargs.pop("stream", False) + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + if _stream: + try: + response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + response_headers["Content-Type"] = self._deserialize("str", response.headers.get("Content-Type")) + + if _stream: + deserialized = response.iter_bytes() if _decompress else response.iter_raw() + else: + deserialized = _deserialize_xml(_models.ListSharesResponse, response.text()) + + if cls: + return cls(pipeline_response, deserialized, response_headers) # type: ignore + + return deserialized # type: ignore + + @distributed_trace + def get_user_delegation_key( + self, key_info: _models.KeyInfo, *, timeout: Optional[int] = None, **kwargs: Any + ) -> _models.UserDelegationKey: + """Retrieves a user delegation key for the File service. This can be used to generate a user + delegation SAS. + + :param key_info: Key information. Required. + :type key_info: ~azure.storage.fileshare._generated.models.KeyInfo + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :return: UserDelegationKey. The UserDelegationKey is compatible with MutableMapping + :rtype: ~azure.storage.fileshare._generated.models.UserDelegationKey + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = kwargs.pop("params", {}) or {} + + content_type: str = kwargs.pop("content_type", _headers.pop("Content-Type", "application/xml")) + cls: ClsType[_models.UserDelegationKey] = kwargs.pop("cls", None) + + _content = _get_element(key_info) + + _request = build_service_get_user_delegation_key_request( + timeout=timeout, + content_type=content_type, + version=self._config.version, + content=_content, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _decompress = kwargs.pop("decompress", True) + _stream = kwargs.pop("stream", False) + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + if _stream: + try: + response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + response_headers["Content-Type"] = self._deserialize("str", response.headers.get("Content-Type")) + + if _stream: + deserialized = response.iter_bytes() if _decompress else response.iter_raw() + else: + deserialized = _deserialize_xml(_models.UserDelegationKey, response.text()) + + if cls: + return cls(pipeline_response, deserialized, response_headers) # type: ignore + + return deserialized # type: ignore + + +class ShareOperations: + """ + .. warning:: + **DO NOT** instantiate this class directly. + + Instead, you should access the following operations through + :class:`~azure.storage.fileshare.FileClient`'s + :attr:`share` attribute. + """ + + def __init__(self, *args, **kwargs) -> None: + input_args = list(args) + self._client: PipelineClient = input_args.pop(0) if input_args else kwargs.pop("client") + self._config: FileClientConfiguration = input_args.pop(0) if input_args else kwargs.pop("config") + self._serialize: Serializer = input_args.pop(0) if input_args else kwargs.pop("serializer") + self._deserialize: Deserializer = input_args.pop(0) if input_args else kwargs.pop("deserializer") + + @distributed_trace + def create( # pylint: disable=inconsistent-return-statements,too-many-locals + self, + *, + timeout: Optional[int] = None, + metadata: Optional[dict[str, str]] = None, + quota: Optional[int] = None, + access_tier: Optional[Union[str, _models.ShareAccessTier]] = None, + enabled_protocols: Optional[str] = None, + root_squash: Optional[Union[str, _models.ShareRootSquash]] = None, + enable_snapshot_virtual_directory_access: Optional[bool] = None, + paid_bursting_enabled: Optional[bool] = None, + paid_bursting_max_iops: Optional[int] = None, + paid_bursting_max_bandwidth_mibps: Optional[int] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + share_provisioned_iops: Optional[int] = None, + share_provisioned_bandwidth_mibps: Optional[int] = None, + enable_smb_directory_lease: Optional[bool] = None, + **kwargs: Any + ) -> None: + """Creates a new share under the specified account. If the share with the same name already + exists, the operation fails. + + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword metadata: Optional. User-defined metadata for the resource. Default value is None. + :paramtype metadata: dict[str, str] + :keyword quota: Specifies the maximum size of the share, in gigabytes. Default value is None. + :paramtype quota: int + :keyword access_tier: Specifies the access tier of the share. Known values are: + "TransactionOptimized", "Hot", "Cool", and "Premium". Default value is None. + :paramtype access_tier: str or ~azure.storage.fileshare.models.ShareAccessTier + :keyword enabled_protocols: Protocols to enable on the share. Default value is None. + :paramtype enabled_protocols: str + :keyword root_squash: Root squash to set on the share. Only valid for NFS shares. Known values + are: "NoRootSquash", "RootSquash", and "AllSquash". Default value is None. + :paramtype root_squash: str or ~azure.storage.fileshare.models.ShareRootSquash + :keyword enable_snapshot_virtual_directory_access: Optional. Used to enable snapshot virtual + directory access. Default value is None. + :paramtype enable_snapshot_virtual_directory_access: bool + :keyword paid_bursting_enabled: Optional. Boolean. Default if not specified is false. This + property enables paid bursting. Default value is None. + :paramtype paid_bursting_enabled: bool + :keyword paid_bursting_max_iops: Optional. Integer. Default if not specified is the maximum + IOPS the file share can support. Current maximum for a file share is 102,400 IOPS. Default + value is None. + :paramtype paid_bursting_max_iops: int + :keyword paid_bursting_max_bandwidth_mibps: Optional. Integer. Default if not specified is the + maximum throughput the file share can support. Current maximum for a file share is 10,340 + MiB/sec. Default value is None. + :paramtype paid_bursting_max_bandwidth_mibps: int + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :keyword share_provisioned_iops: Optional. Specifies the provisioned IOPS of the share. Default + value is None. + :paramtype share_provisioned_iops: int + :keyword share_provisioned_bandwidth_mibps: Optional. Specifies the provisioned bandwidth of + the share, in MiBps. Default value is None. + :paramtype share_provisioned_bandwidth_mibps: int + :keyword enable_smb_directory_lease: Optional. Used to enable SMB directory lease. Default + value is None. + :paramtype enable_smb_directory_lease: bool + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls: ClsType[None] = kwargs.pop("cls", None) + + _request = build_share_create_request( + timeout=timeout, + metadata=metadata, + quota=quota, + access_tier=access_tier, + enabled_protocols=enabled_protocols, + root_squash=root_squash, + enable_snapshot_virtual_directory_access=enable_snapshot_virtual_directory_access, + paid_bursting_enabled=paid_bursting_enabled, + paid_bursting_max_iops=paid_bursting_max_iops, + paid_bursting_max_bandwidth_mibps=paid_bursting_max_bandwidth_mibps, + file_request_intent=file_request_intent, + share_provisioned_iops=share_provisioned_iops, + share_provisioned_bandwidth_mibps=share_provisioned_bandwidth_mibps, + enable_smb_directory_lease=enable_smb_directory_lease, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [201]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) + response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) + response_headers["x-ms-share-quota"] = self._deserialize("int", response.headers.get("x-ms-share-quota")) + response_headers["x-ms-share-provisioned-iops"] = self._deserialize( + "int", response.headers.get("x-ms-share-provisioned-iops") + ) + response_headers["x-ms-share-provisioned-bandwidth-mibps"] = self._deserialize( + "int", response.headers.get("x-ms-share-provisioned-bandwidth-mibps") + ) + response_headers["x-ms-share-included-burst-iops"] = self._deserialize( + "int", response.headers.get("x-ms-share-included-burst-iops") + ) + response_headers["x-ms-share-max-burst-credits-for-iops"] = self._deserialize( + "int", response.headers.get("x-ms-share-max-burst-credits-for-iops") + ) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + + if cls: + return cls(pipeline_response, None, response_headers) # type: ignore + + @distributed_trace + def get_properties( # pylint: disable=inconsistent-return-statements + self, + *, + sharesnapshot: Optional[str] = None, + timeout: Optional[int] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + lease_id: Optional[str] = None, + **kwargs: Any + ) -> None: + """Returns all user-defined metadata and system properties for the specified share or share + snapshot. + + :keyword sharesnapshot: The snapshot parameter is an opaque DateTime value that specifies a + share snapshot. Default value is None. + :paramtype sharesnapshot: str + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :keyword lease_id: If specified, the lease ID must match the lease ID of the file. Default + value is None. + :paramtype lease_id: str + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls: ClsType[None] = kwargs.pop("cls", None) + + _request = build_share_get_properties_request( + sharesnapshot=sharesnapshot, + timeout=timeout, + file_request_intent=file_request_intent, + lease_id=lease_id, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["x-ms-meta"] = self._deserialize("{str}", response.headers.get("x-ms-meta")) + response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) + response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) + response_headers["x-ms-share-quota"] = self._deserialize("int", response.headers.get("x-ms-share-quota")) + response_headers["x-ms-share-provisioned-iops"] = self._deserialize( + "int", response.headers.get("x-ms-share-provisioned-iops") + ) + response_headers["x-ms-share-provisioned-ingress-mbps"] = self._deserialize( + "int", response.headers.get("x-ms-share-provisioned-ingress-mbps") + ) + response_headers["x-ms-share-provisioned-egress-mbps"] = self._deserialize( + "int", response.headers.get("x-ms-share-provisioned-egress-mbps") + ) + response_headers["x-ms-share-next-allowed-quota-downgrade-time"] = self._deserialize( + "rfc-1123", response.headers.get("x-ms-share-next-allowed-quota-downgrade-time") + ) + response_headers["x-ms-share-provisioned-bandwidth-mibps"] = self._deserialize( + "int", response.headers.get("x-ms-share-provisioned-bandwidth-mibps") + ) + response_headers["x-ms-lease-duration"] = self._deserialize("str", response.headers.get("x-ms-lease-duration")) + response_headers["x-ms-lease-state"] = self._deserialize("str", response.headers.get("x-ms-lease-state")) + response_headers["x-ms-lease-status"] = self._deserialize("str", response.headers.get("x-ms-lease-status")) + response_headers["x-ms-access-tier"] = self._deserialize("str", response.headers.get("x-ms-access-tier")) + response_headers["x-ms-access-tier-change-time"] = self._deserialize( + "rfc-1123", response.headers.get("x-ms-access-tier-change-time") + ) + response_headers["x-ms-access-tier-transition-state"] = self._deserialize( + "str", response.headers.get("x-ms-access-tier-transition-state") + ) + response_headers["x-ms-enabled-protocols"] = self._deserialize( + "str", response.headers.get("x-ms-enabled-protocols") + ) + response_headers["x-ms-root-squash"] = self._deserialize("str", response.headers.get("x-ms-root-squash")) + response_headers["x-ms-enable-snapshot-virtual-directory-access"] = self._deserialize( + "bool", response.headers.get("x-ms-enable-snapshot-virtual-directory-access") + ) + response_headers["x-ms-share-paid-bursting-enabled"] = self._deserialize( + "bool", response.headers.get("x-ms-share-paid-bursting-enabled") + ) + response_headers["x-ms-share-paid-bursting-max-iops"] = self._deserialize( + "int", response.headers.get("x-ms-share-paid-bursting-max-iops") + ) + response_headers["x-ms-share-paid-bursting-max-bandwidth-mibps"] = self._deserialize( + "int", response.headers.get("x-ms-share-paid-bursting-max-bandwidth-mibps") + ) + response_headers["x-ms-share-included-burst-iops"] = self._deserialize( + "int", response.headers.get("x-ms-share-included-burst-iops") + ) + response_headers["x-ms-share-max-burst-credits-for-iops"] = self._deserialize( + "int", response.headers.get("x-ms-share-max-burst-credits-for-iops") + ) + response_headers["x-ms-share-next-allowed-provisioned-iops-downgrade-time"] = self._deserialize( + "rfc-1123", response.headers.get("x-ms-share-next-allowed-provisioned-iops-downgrade-time") + ) + response_headers["x-ms-share-next-allowed-provisioned-bandwidth-downgrade-time"] = self._deserialize( + "rfc-1123", response.headers.get("x-ms-share-next-allowed-provisioned-bandwidth-downgrade-time") + ) + response_headers["x-ms-enable-smb-directory-lease"] = self._deserialize( + "bool", response.headers.get("x-ms-enable-smb-directory-lease") + ) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + + if cls: + return cls(pipeline_response, None, response_headers) # type: ignore + + @distributed_trace + def delete( # pylint: disable=inconsistent-return-statements + self, + *, + sharesnapshot: Optional[str] = None, + timeout: Optional[int] = None, + delete_snapshots: Optional[Union[str, _models.DeleteSnapshotsOptionType]] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + lease_id: Optional[str] = None, + **kwargs: Any + ) -> None: + """Operation marks the specified share or share snapshot for deletion. The share or share snapshot + and any files contained within it are later deleted during garbage collection. + + :keyword sharesnapshot: The snapshot parameter is an opaque DateTime value that specifies a + share snapshot. Default value is None. + :paramtype sharesnapshot: str + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword delete_snapshots: Specifies the option include to delete the base share and all of its + snapshots. Known values are: "include" and "include-leased". Default value is None. + :paramtype delete_snapshots: str or ~azure.storage.fileshare.models.DeleteSnapshotsOptionType + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :keyword lease_id: If specified, the lease ID must match the lease ID of the file. Default + value is None. + :paramtype lease_id: str + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls: ClsType[None] = kwargs.pop("cls", None) + + _request = build_share_delete_request( + sharesnapshot=sharesnapshot, + timeout=timeout, + delete_snapshots=delete_snapshots, + file_request_intent=file_request_intent, + lease_id=lease_id, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [202]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["x-ms-file-share-usage-bytes"] = self._deserialize( + "int", response.headers.get("x-ms-file-share-usage-bytes") + ) + response_headers["x-ms-file-share-snapshot-usage-bytes"] = self._deserialize( + "int", response.headers.get("x-ms-file-share-snapshot-usage-bytes") + ) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + + if cls: + return cls(pipeline_response, None, response_headers) # type: ignore + + @distributed_trace + def acquire_lease( # pylint: disable=inconsistent-return-statements + self, + *, + timeout: Optional[int] = None, + lease_duration: Optional[int] = None, + proposed_lease_id: Optional[str] = None, + sharesnapshot: Optional[str] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any + ) -> None: + """The Lease Share operation establishes and manages a lock on a share for delete operations. The + lock duration can be 15 to 60 seconds, or can be infinite. + + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword lease_duration: Specifies the duration of the lease, in seconds, or negative one (-1) + for a lease that never expires. A non-infinite lease can be between 15 and 60 seconds. A lease + duration cannot be changed using renew or change. Default value is None. + :paramtype lease_duration: int + :keyword proposed_lease_id: Proposed lease ID, in a GUID string format. The File service + returns 400 (Invalid request) if the proposed lease ID is not in the correct format. See Guid + Constructor (String) for a list of valid GUID string formats. Default value is None. + :paramtype proposed_lease_id: str + :keyword sharesnapshot: The snapshot parameter is an opaque DateTime value that specifies a + share snapshot. Default value is None. + :paramtype sharesnapshot: str + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + action: Literal["acquire"] = kwargs.pop("action", _headers.pop("x-ms-lease-action", "acquire")) + cls: ClsType[None] = kwargs.pop("cls", None) + + _request = build_share_acquire_lease_request( + timeout=timeout, + lease_duration=lease_duration, + proposed_lease_id=proposed_lease_id, + sharesnapshot=sharesnapshot, + file_request_intent=file_request_intent, + action=action, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [201]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) + response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) + response_headers["x-ms-lease-id"] = self._deserialize("str", response.headers.get("x-ms-lease-id")) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + + if cls: + return cls(pipeline_response, None, response_headers) # type: ignore + + @distributed_trace + def release_lease( # pylint: disable=inconsistent-return-statements + self, + *, + lease_id: str, + timeout: Optional[int] = None, + sharesnapshot: Optional[str] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any + ) -> None: + """The Lease Share operation establishes and manages a lock on a share for delete operations. The + lock duration can be 15 to 60 seconds, or can be infinite. + + :keyword lease_id: Specifies the current lease ID on the resource. Required. + :paramtype lease_id: str + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword sharesnapshot: The snapshot parameter is an opaque DateTime value that specifies a + share snapshot. Default value is None. + :paramtype sharesnapshot: str + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + action: Literal["release"] = kwargs.pop("action", _headers.pop("x-ms-lease-action", "release")) + cls: ClsType[None] = kwargs.pop("cls", None) + + _request = build_share_release_lease_request( + lease_id=lease_id, + timeout=timeout, + sharesnapshot=sharesnapshot, + file_request_intent=file_request_intent, + action=action, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) + response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + + if cls: + return cls(pipeline_response, None, response_headers) # type: ignore + + @distributed_trace + def change_lease( # pylint: disable=inconsistent-return-statements + self, + *, + lease_id: str, + proposed_lease_id: Optional[str] = None, + timeout: Optional[int] = None, + sharesnapshot: Optional[str] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any + ) -> None: + """The Lease Share operation establishes and manages a lock on a share for delete operations. The + lock duration can be 15 to 60 seconds, or can be infinite. + + :keyword lease_id: Specifies the current lease ID on the resource. Required. + :paramtype lease_id: str + :keyword proposed_lease_id: Proposed lease ID, in a GUID string format. The File service + returns 400 (Invalid request) if the proposed lease ID is not in the correct format. See Guid + Constructor (String) for a list of valid GUID string formats. Default value is None. + :paramtype proposed_lease_id: str + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword sharesnapshot: The snapshot parameter is an opaque DateTime value that specifies a + share snapshot. Default value is None. + :paramtype sharesnapshot: str + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + action: Literal["change"] = kwargs.pop("action", _headers.pop("x-ms-lease-action", "change")) + cls: ClsType[None] = kwargs.pop("cls", None) + + _request = build_share_change_lease_request( + lease_id=lease_id, + proposed_lease_id=proposed_lease_id, + timeout=timeout, + sharesnapshot=sharesnapshot, + file_request_intent=file_request_intent, + action=action, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) + response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) + response_headers["x-ms-lease-id"] = self._deserialize("str", response.headers.get("x-ms-lease-id")) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + + if cls: + return cls(pipeline_response, None, response_headers) # type: ignore + + @distributed_trace + def renew_lease( # pylint: disable=inconsistent-return-statements + self, + *, + lease_id: str, + timeout: Optional[int] = None, + sharesnapshot: Optional[str] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any + ) -> None: + """The Lease Share operation establishes and manages a lock on a share for delete operations. The + lock duration can be 15 to 60 seconds, or can be infinite. + + :keyword lease_id: Specifies the current lease ID on the resource. Required. + :paramtype lease_id: str + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword sharesnapshot: The snapshot parameter is an opaque DateTime value that specifies a + share snapshot. Default value is None. + :paramtype sharesnapshot: str + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + action: Literal["renew"] = kwargs.pop("action", _headers.pop("x-ms-lease-action", "renew")) + cls: ClsType[None] = kwargs.pop("cls", None) + + _request = build_share_renew_lease_request( + lease_id=lease_id, + timeout=timeout, + sharesnapshot=sharesnapshot, + file_request_intent=file_request_intent, + action=action, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) + response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) + response_headers["x-ms-lease-id"] = self._deserialize("str", response.headers.get("x-ms-lease-id")) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + + if cls: + return cls(pipeline_response, None, response_headers) # type: ignore + + @distributed_trace + def break_lease( # pylint: disable=inconsistent-return-statements + self, + *, + timeout: Optional[int] = None, + break_period: Optional[int] = None, + lease_id: Optional[str] = None, + sharesnapshot: Optional[str] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any + ) -> None: + """The Lease Share operation establishes and manages a lock on a share for delete operations. The + lock duration can be 15 to 60 seconds, or can be infinite. + + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword break_period: For a break operation, proposed duration the lease should continue + before it is broken, in seconds, between 0 and 60. This break period is only used if it is + shorter than the time remaining on the lease. If longer, the time remaining on the lease is + used. A new lease will not be available before the break period has expired, but the lease may + be held for longer than the break period. If this header does not appear with a break + operation, a fixed-duration lease breaks after the remaining lease period elapses, and an + infinite lease breaks immediately. Default value is None. + :paramtype break_period: int + :keyword lease_id: If specified, the lease ID must match the lease ID of the file. Default + value is None. + :paramtype lease_id: str + :keyword sharesnapshot: The snapshot parameter is an opaque DateTime value that specifies a + share snapshot. Default value is None. + :paramtype sharesnapshot: str + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + action: Literal["break"] = kwargs.pop("action", _headers.pop("x-ms-lease-action", "break")) + cls: ClsType[None] = kwargs.pop("cls", None) + + _request = build_share_break_lease_request( + timeout=timeout, + break_period=break_period, + lease_id=lease_id, + sharesnapshot=sharesnapshot, + file_request_intent=file_request_intent, + action=action, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [202]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) + response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) + response_headers["x-ms-lease-time"] = self._deserialize("int", response.headers.get("x-ms-lease-time")) + response_headers["x-ms-lease-id"] = self._deserialize("str", response.headers.get("x-ms-lease-id")) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + + if cls: + return cls(pipeline_response, None, response_headers) # type: ignore + + @distributed_trace + def create_snapshot( # pylint: disable=inconsistent-return-statements + self, + *, + timeout: Optional[int] = None, + metadata: Optional[dict[str, str]] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any + ) -> None: + """Creates a read-only snapshot of a share. + + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword metadata: Optional. User-defined metadata for the resource. Default value is None. + :paramtype metadata: dict[str, str] + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls: ClsType[None] = kwargs.pop("cls", None) + + _request = build_share_create_snapshot_request( + timeout=timeout, + metadata=metadata, + file_request_intent=file_request_intent, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [201]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) + response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) + response_headers["x-ms-snapshot"] = self._deserialize("str", response.headers.get("x-ms-snapshot")) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + + if cls: + return cls(pipeline_response, None, response_headers) # type: ignore + + @overload + def create_permission( + self, + permission: _models.SharePermission, + *, + content_type: str = "application/json", + timeout: Optional[int] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any + ) -> None: + """Create a permission (a security descriptor). This is used to support file level ACLs for SMB + shares. + + :param permission: A permission (a security descriptor) at the share level. Required. + :type permission: ~azure.storage.fileshare._generated.models.SharePermission + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def create_permission( + self, + permission: JSON, + *, + content_type: str = "application/json", + timeout: Optional[int] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any + ) -> None: + """Create a permission (a security descriptor). This is used to support file level ACLs for SMB + shares. + + :param permission: A permission (a security descriptor) at the share level. Required. + :type permission: JSON + :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. + Default value is "application/json". + :paramtype content_type: str + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @overload + def create_permission( + self, + permission: IO[bytes], + *, + content_type: str = "application/json", + timeout: Optional[int] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any + ) -> None: + """Create a permission (a security descriptor). This is used to support file level ACLs for SMB + shares. + + :param permission: A permission (a security descriptor) at the share level. Required. + :type permission: IO[bytes] + :keyword content_type: Body Parameter content-type. Content type parameter for binary body. + Default value is "application/json". + :paramtype content_type: str + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + + @distributed_trace + def create_permission( # pylint: disable=inconsistent-return-statements + self, + permission: Union[_models.SharePermission, JSON, IO[bytes]], + *, + timeout: Optional[int] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any + ) -> None: + """Create a permission (a security descriptor). This is used to support file level ACLs for SMB + shares. + + :param permission: A permission (a security descriptor) at the share level. Is one of the + following types: SharePermission, JSON, IO[bytes] Required. + :type permission: ~azure.storage.fileshare._generated.models.SharePermission or JSON or + IO[bytes] + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = kwargs.pop("params", {}) or {} + + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) + cls: ClsType[None] = kwargs.pop("cls", None) + + content_type = content_type or "application/json" + _content = None + if isinstance(permission, (IOBase, bytes)): + _content = permission + else: + _content = json.dumps(permission, cls=SdkJSONEncoder, exclude_readonly=True) # type: ignore + + _request = build_share_create_permission_request( + timeout=timeout, + file_request_intent=file_request_intent, + content_type=content_type, + version=self._config.version, + content=_content, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [201]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["x-ms-file-permission-key"] = self._deserialize( + "str", response.headers.get("x-ms-file-permission-key") + ) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + + if cls: + return cls(pipeline_response, None, response_headers) # type: ignore + + @distributed_trace + def get_permission( + self, + *, + file_permission_key: str, + timeout: Optional[int] = None, + file_permission_format: Optional[Union[str, _models.FilePermissionFormat]] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any + ) -> _models.SharePermission: + """Returns the permission (security descriptor) for a given permission key. This is used to + support file level ACLs for SMB shares. + + :keyword file_permission_key: Key of the permission to be set for the directory/file. Note: + Only one of the x-ms-file-permission or x-ms-file-permission-key should be specified. Required. + :paramtype file_permission_key: str + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword file_permission_format: Optional. Specifies the format in which the permission is + returned. Acceptable values are SDDL or binary. Known values are: "Sddl" and "Binary". Default + value is None. + :paramtype file_permission_format: str or ~azure.storage.fileshare.models.FilePermissionFormat + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :return: SharePermission. The SharePermission is compatible with MutableMapping + :rtype: ~azure.storage.fileshare._generated.models.SharePermission + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls: ClsType[_models.SharePermission] = kwargs.pop("cls", None) + + _request = build_share_get_permission_request( + file_permission_key=file_permission_key, + timeout=timeout, + file_permission_format=file_permission_format, + file_request_intent=file_request_intent, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _decompress = kwargs.pop("decompress", True) + _stream = kwargs.pop("stream", False) + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + if _stream: + try: + response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + response_headers["Content-Type"] = self._deserialize("str", response.headers.get("Content-Type")) + + if _stream: + deserialized = response.iter_bytes() if _decompress else response.iter_raw() + else: + deserialized = _deserialize(_models.SharePermission, response.json()) + + if cls: + return cls(pipeline_response, deserialized, response_headers) # type: ignore + + return deserialized # type: ignore + + @distributed_trace + def set_properties( # pylint: disable=inconsistent-return-statements,too-many-locals + self, + *, + timeout: Optional[int] = None, + quota: Optional[int] = None, + access_tier: Optional[Union[str, _models.ShareAccessTier]] = None, + lease_id: Optional[str] = None, + root_squash: Optional[Union[str, _models.ShareRootSquash]] = None, + enable_snapshot_virtual_directory_access: Optional[bool] = None, + paid_bursting_enabled: Optional[bool] = None, + paid_bursting_max_iops: Optional[int] = None, + paid_bursting_max_bandwidth_mibps: Optional[int] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + share_provisioned_iops: Optional[int] = None, + share_provisioned_bandwidth_mibps: Optional[int] = None, + enable_smb_directory_lease: Optional[bool] = None, + **kwargs: Any + ) -> None: + """Sets properties for the specified share. + + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword quota: Specifies the maximum size of the share, in gigabytes. Default value is None. + :paramtype quota: int + :keyword access_tier: Specifies the access tier of the share. Known values are: + "TransactionOptimized", "Hot", "Cool", and "Premium". Default value is None. + :paramtype access_tier: str or ~azure.storage.fileshare.models.ShareAccessTier + :keyword lease_id: If specified, the lease ID must match the lease ID of the file. Default + value is None. + :paramtype lease_id: str + :keyword root_squash: Root squash to set on the share. Only valid for NFS shares. Known values + are: "NoRootSquash", "RootSquash", and "AllSquash". Default value is None. + :paramtype root_squash: str or ~azure.storage.fileshare.models.ShareRootSquash + :keyword enable_snapshot_virtual_directory_access: Optional. Used to enable snapshot virtual + directory access. Default value is None. + :paramtype enable_snapshot_virtual_directory_access: bool + :keyword paid_bursting_enabled: Optional. Boolean. Default if not specified is false. This + property enables paid bursting. Default value is None. + :paramtype paid_bursting_enabled: bool + :keyword paid_bursting_max_iops: Optional. Integer. Default if not specified is the maximum + IOPS the file share can support. Current maximum for a file share is 102,400 IOPS. Default + value is None. + :paramtype paid_bursting_max_iops: int + :keyword paid_bursting_max_bandwidth_mibps: Optional. Integer. Default if not specified is the + maximum throughput the file share can support. Current maximum for a file share is 10,340 + MiB/sec. Default value is None. + :paramtype paid_bursting_max_bandwidth_mibps: int + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :keyword share_provisioned_iops: Optional. Specifies the provisioned IOPS of the share. Default + value is None. + :paramtype share_provisioned_iops: int + :keyword share_provisioned_bandwidth_mibps: Optional. Specifies the provisioned bandwidth of + the share, in MiBps. Default value is None. + :paramtype share_provisioned_bandwidth_mibps: int + :keyword enable_smb_directory_lease: Optional. Used to enable SMB directory lease. Default + value is None. + :paramtype enable_smb_directory_lease: bool + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls: ClsType[None] = kwargs.pop("cls", None) + + _request = build_share_set_properties_request( + timeout=timeout, + quota=quota, + access_tier=access_tier, + lease_id=lease_id, + root_squash=root_squash, + enable_snapshot_virtual_directory_access=enable_snapshot_virtual_directory_access, + paid_bursting_enabled=paid_bursting_enabled, + paid_bursting_max_iops=paid_bursting_max_iops, + paid_bursting_max_bandwidth_mibps=paid_bursting_max_bandwidth_mibps, + file_request_intent=file_request_intent, + share_provisioned_iops=share_provisioned_iops, + share_provisioned_bandwidth_mibps=share_provisioned_bandwidth_mibps, + enable_smb_directory_lease=enable_smb_directory_lease, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) + response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) + response_headers["x-ms-share-quota"] = self._deserialize("int", response.headers.get("x-ms-share-quota")) + response_headers["x-ms-share-provisioned-iops"] = self._deserialize( + "int", response.headers.get("x-ms-share-provisioned-iops") + ) + response_headers["x-ms-share-provisioned-bandwidth-mibps"] = self._deserialize( + "int", response.headers.get("x-ms-share-provisioned-bandwidth-mibps") + ) + response_headers["x-ms-share-included-burst-iops"] = self._deserialize( + "int", response.headers.get("x-ms-share-included-burst-iops") + ) + response_headers["x-ms-share-max-burst-credits-for-iops"] = self._deserialize( + "int", response.headers.get("x-ms-share-max-burst-credits-for-iops") + ) + response_headers["x-ms-share-next-allowed-quota-downgrade-time"] = self._deserialize( + "rfc-1123", response.headers.get("x-ms-share-next-allowed-quota-downgrade-time") + ) + response_headers["x-ms-share-next-allowed-provisioned-iops-downgrade-time"] = self._deserialize( + "rfc-1123", response.headers.get("x-ms-share-next-allowed-provisioned-iops-downgrade-time") + ) + response_headers["x-ms-share-next-allowed-provisioned-bandwidth-downgrade-time"] = self._deserialize( + "rfc-1123", response.headers.get("x-ms-share-next-allowed-provisioned-bandwidth-downgrade-time") + ) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + + if cls: + return cls(pipeline_response, None, response_headers) # type: ignore + + @distributed_trace + def set_metadata( # pylint: disable=inconsistent-return-statements + self, + *, + timeout: Optional[int] = None, + metadata: Optional[dict[str, str]] = None, + lease_id: Optional[str] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any + ) -> None: + """Sets one or more user-defined name-value pairs for the specified share. + + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword metadata: Optional. User-defined metadata for the resource. Default value is None. + :paramtype metadata: dict[str, str] + :keyword lease_id: If specified, the lease ID must match the lease ID of the file. Default + value is None. + :paramtype lease_id: str + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls: ClsType[None] = kwargs.pop("cls", None) + + _request = build_share_set_metadata_request( + timeout=timeout, + metadata=metadata, + lease_id=lease_id, + file_request_intent=file_request_intent, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) + response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + + if cls: + return cls(pipeline_response, None, response_headers) # type: ignore + + @distributed_trace + def get_access_policy( + self, + *, + timeout: Optional[int] = None, + lease_id: Optional[str] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any + ) -> _models.SignedIdentifiers: + """Returns information about stored access policies specified on the share that may be used with + Shared Access Signatures. + + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword lease_id: If specified, the lease ID must match the lease ID of the file. Default + value is None. + :paramtype lease_id: str + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :return: SignedIdentifiers. The SignedIdentifiers is compatible with MutableMapping + :rtype: ~azure.storage.fileshare._generated.models.SignedIdentifiers + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls: ClsType[_models.SignedIdentifiers] = kwargs.pop("cls", None) + + _request = build_share_get_access_policy_request( + timeout=timeout, + lease_id=lease_id, + file_request_intent=file_request_intent, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _decompress = kwargs.pop("decompress", True) + _stream = kwargs.pop("stream", False) + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + if _stream: + try: + response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) + response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + response_headers["Content-Type"] = self._deserialize("str", response.headers.get("Content-Type")) + + if _stream: + deserialized = response.iter_bytes() if _decompress else response.iter_raw() + else: + deserialized = _deserialize_xml(_models.SignedIdentifiers, response.text()) + + if cls: + return cls(pipeline_response, deserialized, response_headers) # type: ignore + + return deserialized # type: ignore + + @distributed_trace + def set_access_policy( # pylint: disable=inconsistent-return-statements + self, + share_acl: Optional[_models.SignedIdentifiers] = None, + *, + timeout: Optional[int] = None, + lease_id: Optional[str] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any + ) -> None: + """Sets stored access policies for the share that may be used with Shared Access Signatures. + + :param share_acl: The ACL for the share. Default value is None. + :type share_acl: ~azure.storage.fileshare._generated.models.SignedIdentifiers + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword lease_id: If specified, the lease ID must match the lease ID of the file. Default + value is None. + :paramtype lease_id: str + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) + _params = kwargs.pop("params", {}) or {} + + content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", "application/xml")) + content_type = content_type if share_acl else None + cls: ClsType[None] = kwargs.pop("cls", None) + + if share_acl is not None: + _content = _get_element(share_acl) + else: + _content = None + + _request = build_share_set_access_policy_request( + timeout=timeout, + lease_id=lease_id, + file_request_intent=file_request_intent, + content_type=content_type, + version=self._config.version, + content=_content, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) + response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + + if cls: + return cls(pipeline_response, None, response_headers) # type: ignore + + @distributed_trace + def get_statistics( + self, + *, + timeout: Optional[int] = None, + lease_id: Optional[str] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any + ) -> _models.ShareStats: + """Retrieves statistics related to the share. + + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword lease_id: If specified, the lease ID must match the lease ID of the file. Default + value is None. + :paramtype lease_id: str + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :return: ShareStats. The ShareStats is compatible with MutableMapping + :rtype: ~azure.storage.fileshare._generated.models.ShareStats + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls: ClsType[_models.ShareStats] = kwargs.pop("cls", None) + + _request = build_share_get_statistics_request( + timeout=timeout, + lease_id=lease_id, + file_request_intent=file_request_intent, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _decompress = kwargs.pop("decompress", True) + _stream = kwargs.pop("stream", False) + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [200]: + if _stream: + try: + response.read() # Load the body in memory and close the socket + except (StreamConsumedError, StreamClosedError): + pass + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) + response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + response_headers["Content-Type"] = self._deserialize("str", response.headers.get("Content-Type")) + + if _stream: + deserialized = response.iter_bytes() if _decompress else response.iter_raw() + else: + deserialized = _deserialize_xml(_models.ShareStats, response.text()) + + if cls: + return cls(pipeline_response, deserialized, response_headers) # type: ignore + + return deserialized # type: ignore + + @distributed_trace + def restore( # pylint: disable=inconsistent-return-statements + self, + *, + timeout: Optional[int] = None, + deleted_share_name: Optional[str] = None, + deleted_share_version: Optional[str] = None, + file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, + **kwargs: Any + ) -> None: + """Restores a previously deleted share. + + :keyword timeout: The timeout parameter is expressed in seconds. Default value is None. + :paramtype timeout: int + :keyword deleted_share_name: Specifies the name of the previously-deleted share. Default value + is None. + :paramtype deleted_share_name: str + :keyword deleted_share_version: Specifies the version of the previously-deleted share. Default + value is None. + :paramtype deleted_share_version: str + :keyword file_request_intent: Valid values are 'backup'. "backup" Default value is None. + :paramtype file_request_intent: str or ~azure.storage.fileshare.models.ShareTokenIntent + :return: None + :rtype: None + :raises ~azure.core.exceptions.HttpResponseError: + """ + error_map: MutableMapping = { + 401: ClientAuthenticationError, + 404: ResourceNotFoundError, + 409: ResourceExistsError, + 304: ResourceNotModifiedError, + } + error_map.update(kwargs.pop("error_map", {}) or {}) + + _headers = kwargs.pop("headers", {}) or {} + _params = kwargs.pop("params", {}) or {} + + cls: ClsType[None] = kwargs.pop("cls", None) + + _request = build_share_restore_request( + timeout=timeout, + deleted_share_name=deleted_share_name, + deleted_share_version=deleted_share_version, + file_request_intent=file_request_intent, + version=self._config.version, + headers=_headers, + params=_params, + ) + path_format_arguments = { + "url": self._serialize.url("self._config.url", self._config.url, "str", skip_quote=True), + } + _request.url = self._client.format_url(_request.url, **path_format_arguments) + + _stream = False + pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access + _request, stream=_stream, **kwargs + ) + + response = pipeline_response.http_response + + if response.status_code not in [201]: + map_error(status_code=response.status_code, response=response, error_map=error_map) + error = _failsafe_deserialize_xml( + _models.Error, + response, + ) + raise HttpResponseError(response=response, model=error) + + response_headers = {} + response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) + response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) + response_headers["x-ms-share-quota"] = self._deserialize("int", response.headers.get("x-ms-share-quota")) + response_headers["x-ms-share-provisioned-iops"] = self._deserialize( + "int", response.headers.get("x-ms-share-provisioned-iops") + ) + response_headers["x-ms-share-provisioned-bandwidth-mibps"] = self._deserialize( + "int", response.headers.get("x-ms-share-provisioned-bandwidth-mibps") + ) + response_headers["x-ms-share-included-burst-iops"] = self._deserialize( + "int", response.headers.get("x-ms-share-included-burst-iops") + ) + response_headers["x-ms-share-max-burst-credits-for-iops"] = self._deserialize( + "int", response.headers.get("x-ms-share-max-burst-credits-for-iops") + ) + response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) + response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) + response_headers["x-ms-client-request-id"] = self._deserialize( + "str", response.headers.get("x-ms-client-request-id") + ) + response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) + + if cls: + return cls(pipeline_response, None, response_headers) # type: ignore diff --git a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/operations/_patch.py b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/operations/_patch.py index f7dd32510333..ea765788358a 100644 --- a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/operations/_patch.py +++ b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/operations/_patch.py @@ -1,14 +1,14 @@ -# ------------------------------------ -# Copyright (c) Microsoft Corporation. -# Licensed under the MIT License. -# ------------------------------------ +# coding=utf-8 +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# -------------------------------------------------------------------------- """Customize generated code here. Follow our quickstart for examples: https://aka.ms/azsdk/python/dpcodegen/python/customize """ -from typing import List -__all__: List[str] = [] # Add all objects you want publicly available to users at this package level +__all__: list[str] = [] # Add all objects you want publicly available to users at this package level def patch_sdk(): diff --git a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/operations/_service_operations.py b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/operations/_service_operations.py deleted file mode 100644 index 11db434df4f1..000000000000 --- a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/operations/_service_operations.py +++ /dev/null @@ -1,543 +0,0 @@ -# pylint: disable=line-too-long,useless-suppression -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -from collections.abc import MutableMapping -from typing import Any, Callable, Literal, Optional, TypeVar, Union - -from azure.core import PipelineClient -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.pipeline import PipelineResponse -from azure.core.rest import HttpRequest, HttpResponse -from azure.core.tracing.decorator import distributed_trace -from azure.core.utils import case_insensitive_dict - -from .. import models as _models -from .._configuration import AzureFileStorageConfiguration -from .._utils.serialization import Deserializer, Serializer - -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, dict[str, Any]], Any]] - -_SERIALIZER = Serializer() -_SERIALIZER.client_side_validation = False - - -def build_set_properties_request( - url: str, - *, - content: Any, - version: str, - timeout: Optional[int] = None, - file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - restype: Literal["service"] = kwargs.pop("restype", _params.pop("restype", "service")) - comp: Literal["properties"] = kwargs.pop("comp", _params.pop("comp", "properties")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - accept = _headers.pop("Accept", "application/xml") - - # Construct URL - _url = kwargs.pop("template_url", "{url}") - path_format_arguments = { - "url": _SERIALIZER.url("url", url, "str", skip_quote=True), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["restype"] = _SERIALIZER.query("restype", restype, "str") - _params["comp"] = _SERIALIZER.query("comp", comp, "str") - if timeout is not None: - _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int", minimum=0) - - # Construct headers - _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") - if file_request_intent is not None: - _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, content=content, **kwargs) - - -def build_get_properties_request( - url: str, - *, - version: str, - timeout: Optional[int] = None, - file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - restype: Literal["service"] = kwargs.pop("restype", _params.pop("restype", "service")) - comp: Literal["properties"] = kwargs.pop("comp", _params.pop("comp", "properties")) - accept = _headers.pop("Accept", "application/xml") - - # Construct URL - _url = kwargs.pop("template_url", "{url}") - path_format_arguments = { - "url": _SERIALIZER.url("url", url, "str", skip_quote=True), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["restype"] = _SERIALIZER.query("restype", restype, "str") - _params["comp"] = _SERIALIZER.query("comp", comp, "str") - if timeout is not None: - _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int", minimum=0) - - # Construct headers - _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") - if file_request_intent is not None: - _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_list_shares_segment_request( - url: str, - *, - version: str, - prefix: Optional[str] = None, - marker: Optional[str] = None, - maxresults: Optional[int] = None, - include: Optional[list[Union[str, _models.ListSharesIncludeType]]] = None, - timeout: Optional[int] = None, - file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - comp: Literal["list"] = kwargs.pop("comp", _params.pop("comp", "list")) - accept = _headers.pop("Accept", "application/xml") - - # Construct URL - _url = kwargs.pop("template_url", "{url}") - path_format_arguments = { - "url": _SERIALIZER.url("url", url, "str", skip_quote=True), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["comp"] = _SERIALIZER.query("comp", comp, "str") - if prefix is not None: - _params["prefix"] = _SERIALIZER.query("prefix", prefix, "str") - if marker is not None: - _params["marker"] = _SERIALIZER.query("marker", marker, "str") - if maxresults is not None: - _params["maxresults"] = _SERIALIZER.query("maxresults", maxresults, "int", minimum=1) - if include is not None: - _params["include"] = _SERIALIZER.query("include", include, "[str]", div=",") - if timeout is not None: - _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int", minimum=0) - - # Construct headers - _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") - if file_request_intent is not None: - _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_get_user_delegation_key_request( - url: str, - *, - content: Any, - version: str, - timeout: Optional[int] = None, - request_id_parameter: Optional[str] = None, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - restype: Literal["service"] = kwargs.pop("restype", _params.pop("restype", "service")) - comp: Literal["userdelegationkey"] = kwargs.pop("comp", _params.pop("comp", "userdelegationkey")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - accept = _headers.pop("Accept", "application/xml") - - # Construct URL - _url = kwargs.pop("template_url", "{url}") - path_format_arguments = { - "url": _SERIALIZER.url("url", url, "str", skip_quote=True), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["restype"] = _SERIALIZER.query("restype", restype, "str") - _params["comp"] = _SERIALIZER.query("comp", comp, "str") - if timeout is not None: - _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int", minimum=0) - - # Construct headers - _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") - if request_id_parameter is not None: - _headers["x-ms-client-request-id"] = _SERIALIZER.header("request_id_parameter", request_id_parameter, "str") - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, content=content, **kwargs) - - -class ServiceOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.storage.fileshare.AzureFileStorage`'s - :attr:`service` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs) -> None: - input_args = list(args) - self._client: PipelineClient = input_args.pop(0) if input_args else kwargs.pop("client") - self._config: AzureFileStorageConfiguration = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize: Serializer = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize: Deserializer = input_args.pop(0) if input_args else kwargs.pop("deserializer") - - @distributed_trace - def set_properties( # pylint: disable=inconsistent-return-statements - self, storage_service_properties: _models.StorageServiceProperties, timeout: Optional[int] = None, **kwargs: Any - ) -> None: - """Sets properties for a storage account's File service endpoint, including properties for Storage - Analytics metrics and CORS (Cross-Origin Resource Sharing) rules. - - :param storage_service_properties: The StorageService properties. Required. - :type storage_service_properties: ~azure.storage.fileshare.models.StorageServiceProperties - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - restype: Literal["service"] = kwargs.pop("restype", _params.pop("restype", "service")) - comp: Literal["properties"] = kwargs.pop("comp", _params.pop("comp", "properties")) - content_type: str = kwargs.pop("content_type", _headers.pop("Content-Type", "application/xml")) - cls: ClsType[None] = kwargs.pop("cls", None) - - _content = self._serialize.body(storage_service_properties, "StorageServiceProperties", is_xml=True) - - _request = build_set_properties_request( - url=self._config.url, - version=self._config.version, - timeout=timeout, - file_request_intent=self._config.file_request_intent, - restype=restype, - comp=comp, - content_type=content_type, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [202]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - - if cls: - return cls(pipeline_response, None, response_headers) # type: ignore - - @distributed_trace - def get_properties(self, timeout: Optional[int] = None, **kwargs: Any) -> _models.StorageServiceProperties: - """Gets the properties of a storage account's File service, including properties for Storage - Analytics metrics and CORS (Cross-Origin Resource Sharing) rules. - - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :return: StorageServiceProperties or the result of cls(response) - :rtype: ~azure.storage.fileshare.models.StorageServiceProperties - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - restype: Literal["service"] = kwargs.pop("restype", _params.pop("restype", "service")) - comp: Literal["properties"] = kwargs.pop("comp", _params.pop("comp", "properties")) - cls: ClsType[_models.StorageServiceProperties] = kwargs.pop("cls", None) - - _request = build_get_properties_request( - url=self._config.url, - version=self._config.version, - timeout=timeout, - file_request_intent=self._config.file_request_intent, - restype=restype, - comp=comp, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - - deserialized = self._deserialize("StorageServiceProperties", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def list_shares_segment( - self, - prefix: Optional[str] = None, - marker: Optional[str] = None, - maxresults: Optional[int] = None, - include: Optional[list[Union[str, _models.ListSharesIncludeType]]] = None, - timeout: Optional[int] = None, - **kwargs: Any - ) -> _models.ListSharesResponse: - """The List Shares Segment operation returns a list of the shares and share snapshots under the - specified account. - - :param prefix: Filters the results to return only entries whose name begins with the specified - prefix. Default value is None. - :type prefix: str - :param marker: A string value that identifies the portion of the list to be returned with the - next list operation. The operation returns a marker value within the response body if the list - returned was not complete. The marker value may then be used in a subsequent call to request - the next set of list items. The marker value is opaque to the client. Default value is None. - :type marker: str - :param maxresults: Specifies the maximum number of entries to return. If the request does not - specify maxresults, or specifies a value greater than 5,000, the server will return up to 5,000 - items. Default value is None. - :type maxresults: int - :param include: Include this parameter to specify one or more datasets to include in the - response. Default value is None. - :type include: list[str or ~azure.storage.fileshare.models.ListSharesIncludeType] - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :return: ListSharesResponse or the result of cls(response) - :rtype: ~azure.storage.fileshare.models.ListSharesResponse - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - comp: Literal["list"] = kwargs.pop("comp", _params.pop("comp", "list")) - cls: ClsType[_models.ListSharesResponse] = kwargs.pop("cls", None) - - _request = build_list_shares_segment_request( - url=self._config.url, - version=self._config.version, - prefix=prefix, - marker=marker, - maxresults=maxresults, - include=include, - timeout=timeout, - file_request_intent=self._config.file_request_intent, - comp=comp, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - - deserialized = self._deserialize("ListSharesResponse", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def get_user_delegation_key( - self, - key_info: _models.KeyInfo, - timeout: Optional[int] = None, - request_id_parameter: Optional[str] = None, - **kwargs: Any - ) -> _models.UserDelegationKey: - """Retrieves a user delegation key for the File service. This is only a valid operation when using - bearer token authentication. - - :param key_info: Key information. Required. - :type key_info: ~azure.storage.fileshare.models.KeyInfo - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param request_id_parameter: Provides a client-generated, opaque value with a 1 KB character - limit that is recorded in the analytics logs when storage analytics logging is enabled. Default - value is None. - :type request_id_parameter: str - :return: UserDelegationKey or the result of cls(response) - :rtype: ~azure.storage.fileshare.models.UserDelegationKey - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - restype: Literal["service"] = kwargs.pop("restype", _params.pop("restype", "service")) - comp: Literal["userdelegationkey"] = kwargs.pop("comp", _params.pop("comp", "userdelegationkey")) - content_type: str = kwargs.pop("content_type", _headers.pop("Content-Type", "application/xml")) - cls: ClsType[_models.UserDelegationKey] = kwargs.pop("cls", None) - - _content = self._serialize.body(key_info, "KeyInfo", is_xml=True) - - _request = build_get_user_delegation_key_request( - url=self._config.url, - version=self._config.version, - timeout=timeout, - request_id_parameter=request_id_parameter, - restype=restype, - comp=comp, - content_type=content_type, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["x-ms-client-request-id"] = self._deserialize( - "str", response.headers.get("x-ms-client-request-id") - ) - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - - deserialized = self._deserialize("UserDelegationKey", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore diff --git a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/operations/_share_operations.py b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/operations/_share_operations.py deleted file mode 100644 index 464f7e4f6614..000000000000 --- a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_generated/operations/_share_operations.py +++ /dev/null @@ -1,2651 +0,0 @@ -# pylint: disable=line-too-long,useless-suppression,too-many-lines -# coding=utf-8 -# -------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for license information. -# Code generated by Microsoft (R) AutoRest Code Generator. -# Changes may cause incorrect behavior and will be lost if the code is regenerated. -# -------------------------------------------------------------------------- -from collections.abc import MutableMapping -from io import IOBase -from typing import Any, Callable, IO, Literal, Optional, TypeVar, Union, overload - -from azure.core import PipelineClient -from azure.core.exceptions import ( - ClientAuthenticationError, - HttpResponseError, - ResourceExistsError, - ResourceNotFoundError, - ResourceNotModifiedError, - map_error, -) -from azure.core.pipeline import PipelineResponse -from azure.core.rest import HttpRequest, HttpResponse -from azure.core.tracing.decorator import distributed_trace -from azure.core.utils import case_insensitive_dict - -from .. import models as _models -from .._configuration import AzureFileStorageConfiguration -from .._utils.serialization import Deserializer, Serializer - -T = TypeVar("T") -ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, dict[str, Any]], Any]] - -_SERIALIZER = Serializer() -_SERIALIZER.client_side_validation = False - - -def build_create_request( - url: str, - *, - version: str, - timeout: Optional[int] = None, - metadata: Optional[dict[str, str]] = None, - quota: Optional[int] = None, - access_tier: Optional[Union[str, _models.ShareAccessTier]] = None, - enabled_protocols: Optional[str] = None, - root_squash: Optional[Union[str, _models.ShareRootSquash]] = None, - enable_snapshot_virtual_directory_access: Optional[bool] = None, - paid_bursting_enabled: Optional[bool] = None, - paid_bursting_max_bandwidth_mibps: Optional[int] = None, - paid_bursting_max_iops: Optional[int] = None, - share_provisioned_iops: Optional[int] = None, - share_provisioned_bandwidth_mibps: Optional[int] = None, - enable_smb_directory_lease: Optional[bool] = None, - file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - restype: Literal["share"] = kwargs.pop("restype", _params.pop("restype", "share")) - accept = _headers.pop("Accept", "application/xml") - - # Construct URL - _url = kwargs.pop("template_url", "{url}") - path_format_arguments = { - "url": _SERIALIZER.url("url", url, "str", skip_quote=True), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["restype"] = _SERIALIZER.query("restype", restype, "str") - if timeout is not None: - _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int", minimum=0) - - # Construct headers - if metadata is not None: - _headers["x-ms-meta"] = _SERIALIZER.header("metadata", metadata, "{str}") - if quota is not None: - _headers["x-ms-share-quota"] = _SERIALIZER.header("quota", quota, "int", minimum=1) - if access_tier is not None: - _headers["x-ms-access-tier"] = _SERIALIZER.header("access_tier", access_tier, "str") - _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") - if enabled_protocols is not None: - _headers["x-ms-enabled-protocols"] = _SERIALIZER.header("enabled_protocols", enabled_protocols, "str") - if root_squash is not None: - _headers["x-ms-root-squash"] = _SERIALIZER.header("root_squash", root_squash, "str") - if enable_snapshot_virtual_directory_access is not None: - _headers["x-ms-enable-snapshot-virtual-directory-access"] = _SERIALIZER.header( - "enable_snapshot_virtual_directory_access", enable_snapshot_virtual_directory_access, "bool" - ) - if paid_bursting_enabled is not None: - _headers["x-ms-share-paid-bursting-enabled"] = _SERIALIZER.header( - "paid_bursting_enabled", paid_bursting_enabled, "bool" - ) - if paid_bursting_max_bandwidth_mibps is not None: - _headers["x-ms-share-paid-bursting-max-bandwidth-mibps"] = _SERIALIZER.header( - "paid_bursting_max_bandwidth_mibps", paid_bursting_max_bandwidth_mibps, "int" - ) - if paid_bursting_max_iops is not None: - _headers["x-ms-share-paid-bursting-max-iops"] = _SERIALIZER.header( - "paid_bursting_max_iops", paid_bursting_max_iops, "int" - ) - if file_request_intent is not None: - _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") - if share_provisioned_iops is not None: - _headers["x-ms-share-provisioned-iops"] = _SERIALIZER.header( - "share_provisioned_iops", share_provisioned_iops, "int" - ) - if share_provisioned_bandwidth_mibps is not None: - _headers["x-ms-share-provisioned-bandwidth-mibps"] = _SERIALIZER.header( - "share_provisioned_bandwidth_mibps", share_provisioned_bandwidth_mibps, "int" - ) - if enable_smb_directory_lease is not None: - _headers["x-ms-enable-smb-directory-lease"] = _SERIALIZER.header( - "enable_smb_directory_lease", enable_smb_directory_lease, "bool" - ) - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_get_properties_request( - url: str, - *, - version: str, - sharesnapshot: Optional[str] = None, - timeout: Optional[int] = None, - lease_id: Optional[str] = None, - file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - restype: Literal["share"] = kwargs.pop("restype", _params.pop("restype", "share")) - accept = _headers.pop("Accept", "application/xml") - - # Construct URL - _url = kwargs.pop("template_url", "{url}") - path_format_arguments = { - "url": _SERIALIZER.url("url", url, "str", skip_quote=True), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["restype"] = _SERIALIZER.query("restype", restype, "str") - if sharesnapshot is not None: - _params["sharesnapshot"] = _SERIALIZER.query("sharesnapshot", sharesnapshot, "str") - if timeout is not None: - _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int", minimum=0) - - # Construct headers - _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") - if lease_id is not None: - _headers["x-ms-lease-id"] = _SERIALIZER.header("lease_id", lease_id, "str") - if file_request_intent is not None: - _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_delete_request( - url: str, - *, - version: str, - sharesnapshot: Optional[str] = None, - timeout: Optional[int] = None, - delete_snapshots: Optional[Union[str, _models.DeleteSnapshotsOptionType]] = None, - lease_id: Optional[str] = None, - file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - restype: Literal["share"] = kwargs.pop("restype", _params.pop("restype", "share")) - accept = _headers.pop("Accept", "application/xml") - - # Construct URL - _url = kwargs.pop("template_url", "{url}") - path_format_arguments = { - "url": _SERIALIZER.url("url", url, "str", skip_quote=True), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["restype"] = _SERIALIZER.query("restype", restype, "str") - if sharesnapshot is not None: - _params["sharesnapshot"] = _SERIALIZER.query("sharesnapshot", sharesnapshot, "str") - if timeout is not None: - _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int", minimum=0) - - # Construct headers - _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") - if delete_snapshots is not None: - _headers["x-ms-delete-snapshots"] = _SERIALIZER.header("delete_snapshots", delete_snapshots, "str") - if lease_id is not None: - _headers["x-ms-lease-id"] = _SERIALIZER.header("lease_id", lease_id, "str") - if file_request_intent is not None: - _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="DELETE", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_acquire_lease_request( - url: str, - *, - version: str, - timeout: Optional[int] = None, - duration: Optional[int] = None, - proposed_lease_id: Optional[str] = None, - sharesnapshot: Optional[str] = None, - request_id_parameter: Optional[str] = None, - file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - comp: Literal["lease"] = kwargs.pop("comp", _params.pop("comp", "lease")) - action: Literal["acquire"] = kwargs.pop("action", _headers.pop("x-ms-lease-action", "acquire")) - restype: Literal["share"] = kwargs.pop("restype", _params.pop("restype", "share")) - accept = _headers.pop("Accept", "application/xml") - - # Construct URL - _url = kwargs.pop("template_url", "{url}") - path_format_arguments = { - "url": _SERIALIZER.url("url", url, "str", skip_quote=True), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["comp"] = _SERIALIZER.query("comp", comp, "str") - _params["restype"] = _SERIALIZER.query("restype", restype, "str") - if timeout is not None: - _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int", minimum=0) - if sharesnapshot is not None: - _params["sharesnapshot"] = _SERIALIZER.query("sharesnapshot", sharesnapshot, "str") - - # Construct headers - _headers["x-ms-lease-action"] = _SERIALIZER.header("action", action, "str") - if duration is not None: - _headers["x-ms-lease-duration"] = _SERIALIZER.header("duration", duration, "int") - if proposed_lease_id is not None: - _headers["x-ms-proposed-lease-id"] = _SERIALIZER.header("proposed_lease_id", proposed_lease_id, "str") - _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") - if request_id_parameter is not None: - _headers["x-ms-client-request-id"] = _SERIALIZER.header("request_id_parameter", request_id_parameter, "str") - if file_request_intent is not None: - _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_release_lease_request( - url: str, - *, - lease_id: str, - version: str, - timeout: Optional[int] = None, - sharesnapshot: Optional[str] = None, - request_id_parameter: Optional[str] = None, - file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - comp: Literal["lease"] = kwargs.pop("comp", _params.pop("comp", "lease")) - action: Literal["release"] = kwargs.pop("action", _headers.pop("x-ms-lease-action", "release")) - restype: Literal["share"] = kwargs.pop("restype", _params.pop("restype", "share")) - accept = _headers.pop("Accept", "application/xml") - - # Construct URL - _url = kwargs.pop("template_url", "{url}") - path_format_arguments = { - "url": _SERIALIZER.url("url", url, "str", skip_quote=True), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["comp"] = _SERIALIZER.query("comp", comp, "str") - _params["restype"] = _SERIALIZER.query("restype", restype, "str") - if timeout is not None: - _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int", minimum=0) - if sharesnapshot is not None: - _params["sharesnapshot"] = _SERIALIZER.query("sharesnapshot", sharesnapshot, "str") - - # Construct headers - _headers["x-ms-lease-action"] = _SERIALIZER.header("action", action, "str") - _headers["x-ms-lease-id"] = _SERIALIZER.header("lease_id", lease_id, "str") - _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") - if request_id_parameter is not None: - _headers["x-ms-client-request-id"] = _SERIALIZER.header("request_id_parameter", request_id_parameter, "str") - if file_request_intent is not None: - _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_change_lease_request( - url: str, - *, - lease_id: str, - version: str, - timeout: Optional[int] = None, - proposed_lease_id: Optional[str] = None, - sharesnapshot: Optional[str] = None, - request_id_parameter: Optional[str] = None, - file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - comp: Literal["lease"] = kwargs.pop("comp", _params.pop("comp", "lease")) - action: Literal["change"] = kwargs.pop("action", _headers.pop("x-ms-lease-action", "change")) - restype: Literal["share"] = kwargs.pop("restype", _params.pop("restype", "share")) - accept = _headers.pop("Accept", "application/xml") - - # Construct URL - _url = kwargs.pop("template_url", "{url}") - path_format_arguments = { - "url": _SERIALIZER.url("url", url, "str", skip_quote=True), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["comp"] = _SERIALIZER.query("comp", comp, "str") - _params["restype"] = _SERIALIZER.query("restype", restype, "str") - if timeout is not None: - _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int", minimum=0) - if sharesnapshot is not None: - _params["sharesnapshot"] = _SERIALIZER.query("sharesnapshot", sharesnapshot, "str") - - # Construct headers - _headers["x-ms-lease-action"] = _SERIALIZER.header("action", action, "str") - _headers["x-ms-lease-id"] = _SERIALIZER.header("lease_id", lease_id, "str") - if proposed_lease_id is not None: - _headers["x-ms-proposed-lease-id"] = _SERIALIZER.header("proposed_lease_id", proposed_lease_id, "str") - _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") - if request_id_parameter is not None: - _headers["x-ms-client-request-id"] = _SERIALIZER.header("request_id_parameter", request_id_parameter, "str") - if file_request_intent is not None: - _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_renew_lease_request( - url: str, - *, - lease_id: str, - version: str, - timeout: Optional[int] = None, - sharesnapshot: Optional[str] = None, - request_id_parameter: Optional[str] = None, - file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - comp: Literal["lease"] = kwargs.pop("comp", _params.pop("comp", "lease")) - action: Literal["renew"] = kwargs.pop("action", _headers.pop("x-ms-lease-action", "renew")) - restype: Literal["share"] = kwargs.pop("restype", _params.pop("restype", "share")) - accept = _headers.pop("Accept", "application/xml") - - # Construct URL - _url = kwargs.pop("template_url", "{url}") - path_format_arguments = { - "url": _SERIALIZER.url("url", url, "str", skip_quote=True), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["comp"] = _SERIALIZER.query("comp", comp, "str") - _params["restype"] = _SERIALIZER.query("restype", restype, "str") - if timeout is not None: - _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int", minimum=0) - if sharesnapshot is not None: - _params["sharesnapshot"] = _SERIALIZER.query("sharesnapshot", sharesnapshot, "str") - - # Construct headers - _headers["x-ms-lease-action"] = _SERIALIZER.header("action", action, "str") - _headers["x-ms-lease-id"] = _SERIALIZER.header("lease_id", lease_id, "str") - _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") - if request_id_parameter is not None: - _headers["x-ms-client-request-id"] = _SERIALIZER.header("request_id_parameter", request_id_parameter, "str") - if file_request_intent is not None: - _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_break_lease_request( - url: str, - *, - version: str, - timeout: Optional[int] = None, - break_period: Optional[int] = None, - lease_id: Optional[str] = None, - request_id_parameter: Optional[str] = None, - sharesnapshot: Optional[str] = None, - file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - comp: Literal["lease"] = kwargs.pop("comp", _params.pop("comp", "lease")) - action: Literal["break"] = kwargs.pop("action", _headers.pop("x-ms-lease-action", "break")) - restype: Literal["share"] = kwargs.pop("restype", _params.pop("restype", "share")) - accept = _headers.pop("Accept", "application/xml") - - # Construct URL - _url = kwargs.pop("template_url", "{url}") - path_format_arguments = { - "url": _SERIALIZER.url("url", url, "str", skip_quote=True), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["comp"] = _SERIALIZER.query("comp", comp, "str") - _params["restype"] = _SERIALIZER.query("restype", restype, "str") - if timeout is not None: - _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int", minimum=0) - if sharesnapshot is not None: - _params["sharesnapshot"] = _SERIALIZER.query("sharesnapshot", sharesnapshot, "str") - - # Construct headers - _headers["x-ms-lease-action"] = _SERIALIZER.header("action", action, "str") - if break_period is not None: - _headers["x-ms-lease-break-period"] = _SERIALIZER.header("break_period", break_period, "int") - if lease_id is not None: - _headers["x-ms-lease-id"] = _SERIALIZER.header("lease_id", lease_id, "str") - _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") - if request_id_parameter is not None: - _headers["x-ms-client-request-id"] = _SERIALIZER.header("request_id_parameter", request_id_parameter, "str") - if file_request_intent is not None: - _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_create_snapshot_request( - url: str, - *, - version: str, - timeout: Optional[int] = None, - metadata: Optional[dict[str, str]] = None, - file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - restype: Literal["share"] = kwargs.pop("restype", _params.pop("restype", "share")) - comp: Literal["snapshot"] = kwargs.pop("comp", _params.pop("comp", "snapshot")) - accept = _headers.pop("Accept", "application/xml") - - # Construct URL - _url = kwargs.pop("template_url", "{url}") - path_format_arguments = { - "url": _SERIALIZER.url("url", url, "str", skip_quote=True), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["restype"] = _SERIALIZER.query("restype", restype, "str") - _params["comp"] = _SERIALIZER.query("comp", comp, "str") - if timeout is not None: - _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int", minimum=0) - - # Construct headers - if metadata is not None: - _headers["x-ms-meta"] = _SERIALIZER.header("metadata", metadata, "{str}") - _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") - if file_request_intent is not None: - _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_create_permission_request( - url: str, - *, - version: str, - timeout: Optional[int] = None, - file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - restype: Literal["share"] = kwargs.pop("restype", _params.pop("restype", "share")) - comp: Literal["filepermission"] = kwargs.pop("comp", _params.pop("comp", "filepermission")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - accept = _headers.pop("Accept", "application/xml") - - # Construct URL - _url = kwargs.pop("template_url", "{url}") - path_format_arguments = { - "url": _SERIALIZER.url("url", url, "str", skip_quote=True), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["restype"] = _SERIALIZER.query("restype", restype, "str") - _params["comp"] = _SERIALIZER.query("comp", comp, "str") - if timeout is not None: - _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int", minimum=0) - - # Construct headers - _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") - if file_request_intent is not None: - _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_get_permission_request( - url: str, - *, - file_permission_key: str, - version: str, - file_permission_format: Optional[Union[str, _models.FilePermissionFormat]] = None, - timeout: Optional[int] = None, - file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - restype: Literal["share"] = kwargs.pop("restype", _params.pop("restype", "share")) - comp: Literal["filepermission"] = kwargs.pop("comp", _params.pop("comp", "filepermission")) - accept = _headers.pop("Accept", "application/json") - - # Construct URL - _url = kwargs.pop("template_url", "{url}") - path_format_arguments = { - "url": _SERIALIZER.url("url", url, "str", skip_quote=True), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["restype"] = _SERIALIZER.query("restype", restype, "str") - _params["comp"] = _SERIALIZER.query("comp", comp, "str") - if timeout is not None: - _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int", minimum=0) - - # Construct headers - _headers["x-ms-file-permission-key"] = _SERIALIZER.header("file_permission_key", file_permission_key, "str") - if file_permission_format is not None: - _headers["x-ms-file-permission-format"] = _SERIALIZER.header( - "file_permission_format", file_permission_format, "str" - ) - _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") - if file_request_intent is not None: - _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_set_properties_request( - url: str, - *, - version: str, - timeout: Optional[int] = None, - quota: Optional[int] = None, - access_tier: Optional[Union[str, _models.ShareAccessTier]] = None, - lease_id: Optional[str] = None, - root_squash: Optional[Union[str, _models.ShareRootSquash]] = None, - enable_snapshot_virtual_directory_access: Optional[bool] = None, - paid_bursting_enabled: Optional[bool] = None, - paid_bursting_max_bandwidth_mibps: Optional[int] = None, - paid_bursting_max_iops: Optional[int] = None, - share_provisioned_iops: Optional[int] = None, - share_provisioned_bandwidth_mibps: Optional[int] = None, - enable_smb_directory_lease: Optional[bool] = None, - file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - restype: Literal["share"] = kwargs.pop("restype", _params.pop("restype", "share")) - comp: Literal["properties"] = kwargs.pop("comp", _params.pop("comp", "properties")) - accept = _headers.pop("Accept", "application/xml") - - # Construct URL - _url = kwargs.pop("template_url", "{url}") - path_format_arguments = { - "url": _SERIALIZER.url("url", url, "str", skip_quote=True), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["restype"] = _SERIALIZER.query("restype", restype, "str") - _params["comp"] = _SERIALIZER.query("comp", comp, "str") - if timeout is not None: - _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int", minimum=0) - - # Construct headers - _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") - if quota is not None: - _headers["x-ms-share-quota"] = _SERIALIZER.header("quota", quota, "int", minimum=1) - if access_tier is not None: - _headers["x-ms-access-tier"] = _SERIALIZER.header("access_tier", access_tier, "str") - if lease_id is not None: - _headers["x-ms-lease-id"] = _SERIALIZER.header("lease_id", lease_id, "str") - if root_squash is not None: - _headers["x-ms-root-squash"] = _SERIALIZER.header("root_squash", root_squash, "str") - if enable_snapshot_virtual_directory_access is not None: - _headers["x-ms-enable-snapshot-virtual-directory-access"] = _SERIALIZER.header( - "enable_snapshot_virtual_directory_access", enable_snapshot_virtual_directory_access, "bool" - ) - if paid_bursting_enabled is not None: - _headers["x-ms-share-paid-bursting-enabled"] = _SERIALIZER.header( - "paid_bursting_enabled", paid_bursting_enabled, "bool" - ) - if paid_bursting_max_bandwidth_mibps is not None: - _headers["x-ms-share-paid-bursting-max-bandwidth-mibps"] = _SERIALIZER.header( - "paid_bursting_max_bandwidth_mibps", paid_bursting_max_bandwidth_mibps, "int" - ) - if paid_bursting_max_iops is not None: - _headers["x-ms-share-paid-bursting-max-iops"] = _SERIALIZER.header( - "paid_bursting_max_iops", paid_bursting_max_iops, "int" - ) - if file_request_intent is not None: - _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") - if share_provisioned_iops is not None: - _headers["x-ms-share-provisioned-iops"] = _SERIALIZER.header( - "share_provisioned_iops", share_provisioned_iops, "int" - ) - if share_provisioned_bandwidth_mibps is not None: - _headers["x-ms-share-provisioned-bandwidth-mibps"] = _SERIALIZER.header( - "share_provisioned_bandwidth_mibps", share_provisioned_bandwidth_mibps, "int" - ) - if enable_smb_directory_lease is not None: - _headers["x-ms-enable-smb-directory-lease"] = _SERIALIZER.header( - "enable_smb_directory_lease", enable_smb_directory_lease, "bool" - ) - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_set_metadata_request( - url: str, - *, - version: str, - timeout: Optional[int] = None, - metadata: Optional[dict[str, str]] = None, - lease_id: Optional[str] = None, - file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - restype: Literal["share"] = kwargs.pop("restype", _params.pop("restype", "share")) - comp: Literal["metadata"] = kwargs.pop("comp", _params.pop("comp", "metadata")) - accept = _headers.pop("Accept", "application/xml") - - # Construct URL - _url = kwargs.pop("template_url", "{url}") - path_format_arguments = { - "url": _SERIALIZER.url("url", url, "str", skip_quote=True), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["restype"] = _SERIALIZER.query("restype", restype, "str") - _params["comp"] = _SERIALIZER.query("comp", comp, "str") - if timeout is not None: - _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int", minimum=0) - - # Construct headers - if metadata is not None: - _headers["x-ms-meta"] = _SERIALIZER.header("metadata", metadata, "{str}") - _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") - if lease_id is not None: - _headers["x-ms-lease-id"] = _SERIALIZER.header("lease_id", lease_id, "str") - if file_request_intent is not None: - _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_get_access_policy_request( - url: str, - *, - version: str, - timeout: Optional[int] = None, - lease_id: Optional[str] = None, - file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - restype: Literal["share"] = kwargs.pop("restype", _params.pop("restype", "share")) - comp: Literal["acl"] = kwargs.pop("comp", _params.pop("comp", "acl")) - accept = _headers.pop("Accept", "application/xml") - - # Construct URL - _url = kwargs.pop("template_url", "{url}") - path_format_arguments = { - "url": _SERIALIZER.url("url", url, "str", skip_quote=True), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["restype"] = _SERIALIZER.query("restype", restype, "str") - _params["comp"] = _SERIALIZER.query("comp", comp, "str") - if timeout is not None: - _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int", minimum=0) - - # Construct headers - _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") - if lease_id is not None: - _headers["x-ms-lease-id"] = _SERIALIZER.header("lease_id", lease_id, "str") - if file_request_intent is not None: - _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_set_access_policy_request( - url: str, - *, - version: str, - timeout: Optional[int] = None, - lease_id: Optional[str] = None, - content: Any = None, - file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - restype: Literal["share"] = kwargs.pop("restype", _params.pop("restype", "share")) - comp: Literal["acl"] = kwargs.pop("comp", _params.pop("comp", "acl")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - accept = _headers.pop("Accept", "application/xml") - - # Construct URL - _url = kwargs.pop("template_url", "{url}") - path_format_arguments = { - "url": _SERIALIZER.url("url", url, "str", skip_quote=True), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["restype"] = _SERIALIZER.query("restype", restype, "str") - _params["comp"] = _SERIALIZER.query("comp", comp, "str") - if timeout is not None: - _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int", minimum=0) - - # Construct headers - _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") - if lease_id is not None: - _headers["x-ms-lease-id"] = _SERIALIZER.header("lease_id", lease_id, "str") - if file_request_intent is not None: - _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") - if content_type is not None: - _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, content=content, **kwargs) - - -def build_get_statistics_request( - url: str, - *, - version: str, - timeout: Optional[int] = None, - lease_id: Optional[str] = None, - file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - restype: Literal["share"] = kwargs.pop("restype", _params.pop("restype", "share")) - comp: Literal["stats"] = kwargs.pop("comp", _params.pop("comp", "stats")) - accept = _headers.pop("Accept", "application/xml") - - # Construct URL - _url = kwargs.pop("template_url", "{url}") - path_format_arguments = { - "url": _SERIALIZER.url("url", url, "str", skip_quote=True), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["restype"] = _SERIALIZER.query("restype", restype, "str") - _params["comp"] = _SERIALIZER.query("comp", comp, "str") - if timeout is not None: - _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int", minimum=0) - - # Construct headers - _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") - if lease_id is not None: - _headers["x-ms-lease-id"] = _SERIALIZER.header("lease_id", lease_id, "str") - if file_request_intent is not None: - _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs) - - -def build_restore_request( - url: str, - *, - version: str, - timeout: Optional[int] = None, - request_id_parameter: Optional[str] = None, - deleted_share_name: Optional[str] = None, - deleted_share_version: Optional[str] = None, - file_request_intent: Optional[Union[str, _models.ShareTokenIntent]] = None, - **kwargs: Any -) -> HttpRequest: - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - restype: Literal["share"] = kwargs.pop("restype", _params.pop("restype", "share")) - comp: Literal["undelete"] = kwargs.pop("comp", _params.pop("comp", "undelete")) - accept = _headers.pop("Accept", "application/xml") - - # Construct URL - _url = kwargs.pop("template_url", "{url}") - path_format_arguments = { - "url": _SERIALIZER.url("url", url, "str", skip_quote=True), - } - - _url: str = _url.format(**path_format_arguments) # type: ignore - - # Construct parameters - _params["restype"] = _SERIALIZER.query("restype", restype, "str") - _params["comp"] = _SERIALIZER.query("comp", comp, "str") - if timeout is not None: - _params["timeout"] = _SERIALIZER.query("timeout", timeout, "int", minimum=0) - - # Construct headers - _headers["x-ms-version"] = _SERIALIZER.header("version", version, "str") - if request_id_parameter is not None: - _headers["x-ms-client-request-id"] = _SERIALIZER.header("request_id_parameter", request_id_parameter, "str") - if deleted_share_name is not None: - _headers["x-ms-deleted-share-name"] = _SERIALIZER.header("deleted_share_name", deleted_share_name, "str") - if deleted_share_version is not None: - _headers["x-ms-deleted-share-version"] = _SERIALIZER.header( - "deleted_share_version", deleted_share_version, "str" - ) - if file_request_intent is not None: - _headers["x-ms-file-request-intent"] = _SERIALIZER.header("file_request_intent", file_request_intent, "str") - _headers["Accept"] = _SERIALIZER.header("accept", accept, "str") - - return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs) - - -class ShareOperations: - """ - .. warning:: - **DO NOT** instantiate this class directly. - - Instead, you should access the following operations through - :class:`~azure.storage.fileshare.AzureFileStorage`'s - :attr:`share` attribute. - """ - - models = _models - - def __init__(self, *args, **kwargs) -> None: - input_args = list(args) - self._client: PipelineClient = input_args.pop(0) if input_args else kwargs.pop("client") - self._config: AzureFileStorageConfiguration = input_args.pop(0) if input_args else kwargs.pop("config") - self._serialize: Serializer = input_args.pop(0) if input_args else kwargs.pop("serializer") - self._deserialize: Deserializer = input_args.pop(0) if input_args else kwargs.pop("deserializer") - - @distributed_trace - def create( # pylint: disable=inconsistent-return-statements,too-many-locals - self, - timeout: Optional[int] = None, - metadata: Optional[dict[str, str]] = None, - quota: Optional[int] = None, - access_tier: Optional[Union[str, _models.ShareAccessTier]] = None, - enabled_protocols: Optional[str] = None, - root_squash: Optional[Union[str, _models.ShareRootSquash]] = None, - enable_snapshot_virtual_directory_access: Optional[bool] = None, - paid_bursting_enabled: Optional[bool] = None, - paid_bursting_max_bandwidth_mibps: Optional[int] = None, - paid_bursting_max_iops: Optional[int] = None, - share_provisioned_iops: Optional[int] = None, - share_provisioned_bandwidth_mibps: Optional[int] = None, - enable_smb_directory_lease: Optional[bool] = None, - **kwargs: Any - ) -> None: - """Creates a new share under the specified account. If the share with the same name already - exists, the operation fails. - - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param metadata: A name-value pair to associate with a file storage object. Default value is - None. - :type metadata: dict[str, str] - :param quota: Specifies the maximum size of the share, in gigabytes. Default value is None. - :type quota: int - :param access_tier: Specifies the access tier of the share. Known values are: - "TransactionOptimized", "Hot", "Cool", and "Premium". Default value is None. - :type access_tier: str or ~azure.storage.fileshare.models.ShareAccessTier - :param enabled_protocols: Protocols to enable on the share. Default value is None. - :type enabled_protocols: str - :param root_squash: Root squash to set on the share. Only valid for NFS shares. Known values - are: "NoRootSquash", "RootSquash", and "AllSquash". Default value is None. - :type root_squash: str or ~azure.storage.fileshare.models.ShareRootSquash - :param enable_snapshot_virtual_directory_access: Default value is None. - :type enable_snapshot_virtual_directory_access: bool - :param paid_bursting_enabled: Optional. Boolean. Default if not specified is false. This - property enables paid bursting. Default value is None. - :type paid_bursting_enabled: bool - :param paid_bursting_max_bandwidth_mibps: Optional. Integer. Default if not specified is the - maximum throughput the file share can support. Current maximum for a file share is 10,340 - MiB/sec. Default value is None. - :type paid_bursting_max_bandwidth_mibps: int - :param paid_bursting_max_iops: Optional. Integer. Default if not specified is the maximum IOPS - the file share can support. Current maximum for a file share is 102,400 IOPS. Default value is - None. - :type paid_bursting_max_iops: int - :param share_provisioned_iops: Optional. Supported in version 2025-01-05 and later. Only - allowed for provisioned v2 file shares. Specifies the provisioned number of input/output - operations per second (IOPS) of the share. If this is not specified, the provisioned IOPS is - set to value calculated based on recommendation formula. Default value is None. - :type share_provisioned_iops: int - :param share_provisioned_bandwidth_mibps: Optional. Supported in version 2025-01-05 and later. - Only allowed for provisioned v2 file shares. Specifies the provisioned bandwidth of the share, - in mebibytes per second (MiBps). If this is not specified, the provisioned bandwidth is set to - value calculated based on recommendation formula. Default value is None. - :type share_provisioned_bandwidth_mibps: int - :param enable_smb_directory_lease: SMB only, default is true. Specifies whether granting of - new directory leases for directories present in a share are to be enabled or disabled. An input - of true specifies that granting of new directory leases is to be allowed. An input of false - specifies that granting of new directory leases is to be blocked. Default value is None. - :type enable_smb_directory_lease: bool - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - restype: Literal["share"] = kwargs.pop("restype", _params.pop("restype", "share")) - cls: ClsType[None] = kwargs.pop("cls", None) - - _request = build_create_request( - url=self._config.url, - version=self._config.version, - timeout=timeout, - metadata=metadata, - quota=quota, - access_tier=access_tier, - enabled_protocols=enabled_protocols, - root_squash=root_squash, - enable_snapshot_virtual_directory_access=enable_snapshot_virtual_directory_access, - paid_bursting_enabled=paid_bursting_enabled, - paid_bursting_max_bandwidth_mibps=paid_bursting_max_bandwidth_mibps, - paid_bursting_max_iops=paid_bursting_max_iops, - share_provisioned_iops=share_provisioned_iops, - share_provisioned_bandwidth_mibps=share_provisioned_bandwidth_mibps, - enable_smb_directory_lease=enable_smb_directory_lease, - file_request_intent=self._config.file_request_intent, - restype=restype, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [201]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) - response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - response_headers["x-ms-share-quota"] = self._deserialize("int", response.headers.get("x-ms-share-quota")) - response_headers["x-ms-share-provisioned-iops"] = self._deserialize( - "int", response.headers.get("x-ms-share-provisioned-iops") - ) - response_headers["x-ms-share-provisioned-bandwidth-mibps"] = self._deserialize( - "int", response.headers.get("x-ms-share-provisioned-bandwidth-mibps") - ) - response_headers["x-ms-share-included-burst-iops"] = self._deserialize( - "int", response.headers.get("x-ms-share-included-burst-iops") - ) - response_headers["x-ms-share-max-burst-credits-for-iops"] = self._deserialize( - "int", response.headers.get("x-ms-share-max-burst-credits-for-iops") - ) - - if cls: - return cls(pipeline_response, None, response_headers) # type: ignore - - @distributed_trace - def get_properties( # pylint: disable=inconsistent-return-statements - self, - sharesnapshot: Optional[str] = None, - timeout: Optional[int] = None, - lease_access_conditions: Optional[_models.LeaseAccessConditions] = None, - **kwargs: Any - ) -> None: - """Returns all user-defined metadata and system properties for the specified share or share - snapshot. The data returned does not include the share's list of files. - - :param sharesnapshot: The snapshot parameter is an opaque DateTime value that, when present, - specifies the share snapshot to query. Default value is None. - :type sharesnapshot: str - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param lease_access_conditions: Parameter group. Default value is None. - :type lease_access_conditions: ~azure.storage.fileshare.models.LeaseAccessConditions - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - restype: Literal["share"] = kwargs.pop("restype", _params.pop("restype", "share")) - cls: ClsType[None] = kwargs.pop("cls", None) - - _lease_id = None - if lease_access_conditions is not None: - _lease_id = lease_access_conditions.lease_id - - _request = build_get_properties_request( - url=self._config.url, - version=self._config.version, - sharesnapshot=sharesnapshot, - timeout=timeout, - lease_id=_lease_id, - file_request_intent=self._config.file_request_intent, - restype=restype, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["x-ms-meta"] = self._deserialize("{str}", response.headers.get("x-ms-meta")) - response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) - response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - response_headers["x-ms-share-quota"] = self._deserialize("int", response.headers.get("x-ms-share-quota")) - response_headers["x-ms-share-provisioned-iops"] = self._deserialize( - "int", response.headers.get("x-ms-share-provisioned-iops") - ) - response_headers["x-ms-share-provisioned-ingress-mbps"] = self._deserialize( - "int", response.headers.get("x-ms-share-provisioned-ingress-mbps") - ) - response_headers["x-ms-share-provisioned-egress-mbps"] = self._deserialize( - "int", response.headers.get("x-ms-share-provisioned-egress-mbps") - ) - response_headers["x-ms-share-next-allowed-quota-downgrade-time"] = self._deserialize( - "rfc-1123", response.headers.get("x-ms-share-next-allowed-quota-downgrade-time") - ) - response_headers["x-ms-share-provisioned-bandwidth-mibps"] = self._deserialize( - "int", response.headers.get("x-ms-share-provisioned-bandwidth-mibps") - ) - response_headers["x-ms-lease-duration"] = self._deserialize("str", response.headers.get("x-ms-lease-duration")) - response_headers["x-ms-lease-state"] = self._deserialize("str", response.headers.get("x-ms-lease-state")) - response_headers["x-ms-lease-status"] = self._deserialize("str", response.headers.get("x-ms-lease-status")) - response_headers["x-ms-access-tier"] = self._deserialize("str", response.headers.get("x-ms-access-tier")) - response_headers["x-ms-access-tier-change-time"] = self._deserialize( - "rfc-1123", response.headers.get("x-ms-access-tier-change-time") - ) - response_headers["x-ms-access-tier-transition-state"] = self._deserialize( - "str", response.headers.get("x-ms-access-tier-transition-state") - ) - response_headers["x-ms-enabled-protocols"] = self._deserialize( - "str", response.headers.get("x-ms-enabled-protocols") - ) - response_headers["x-ms-root-squash"] = self._deserialize("str", response.headers.get("x-ms-root-squash")) - response_headers["x-ms-enable-snapshot-virtual-directory-access"] = self._deserialize( - "bool", response.headers.get("x-ms-enable-snapshot-virtual-directory-access") - ) - response_headers["x-ms-share-paid-bursting-enabled"] = self._deserialize( - "bool", response.headers.get("x-ms-share-paid-bursting-enabled") - ) - response_headers["x-ms-share-paid-bursting-max-iops"] = self._deserialize( - "int", response.headers.get("x-ms-share-paid-bursting-max-iops") - ) - response_headers["x-ms-share-paid-bursting-max-bandwidth-mibps"] = self._deserialize( - "int", response.headers.get("x-ms-share-paid-bursting-max-bandwidth-mibps") - ) - response_headers["x-ms-share-included-burst-iops"] = self._deserialize( - "int", response.headers.get("x-ms-share-included-burst-iops") - ) - response_headers["x-ms-share-max-burst-credits-for-iops"] = self._deserialize( - "int", response.headers.get("x-ms-share-max-burst-credits-for-iops") - ) - response_headers["x-ms-share-next-allowed-provisioned-iops-downgrade-time"] = self._deserialize( - "rfc-1123", response.headers.get("x-ms-share-next-allowed-provisioned-iops-downgrade-time") - ) - response_headers["x-ms-share-next-allowed-provisioned-bandwidth-downgrade-time"] = self._deserialize( - "rfc-1123", response.headers.get("x-ms-share-next-allowed-provisioned-bandwidth-downgrade-time") - ) - response_headers["x-ms-enable-smb-directory-lease"] = self._deserialize( - "bool", response.headers.get("x-ms-enable-smb-directory-lease") - ) - - if cls: - return cls(pipeline_response, None, response_headers) # type: ignore - - @distributed_trace - def delete( # pylint: disable=inconsistent-return-statements - self, - sharesnapshot: Optional[str] = None, - timeout: Optional[int] = None, - delete_snapshots: Optional[Union[str, _models.DeleteSnapshotsOptionType]] = None, - lease_access_conditions: Optional[_models.LeaseAccessConditions] = None, - **kwargs: Any - ) -> None: - """Operation marks the specified share or share snapshot for deletion. The share or share snapshot - and any files contained within it are later deleted during garbage collection. - - :param sharesnapshot: The snapshot parameter is an opaque DateTime value that, when present, - specifies the share snapshot to query. Default value is None. - :type sharesnapshot: str - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param delete_snapshots: Specifies the option include to delete the base share and all of its - snapshots. Known values are: "include" and "include-leased". Default value is None. - :type delete_snapshots: str or ~azure.storage.fileshare.models.DeleteSnapshotsOptionType - :param lease_access_conditions: Parameter group. Default value is None. - :type lease_access_conditions: ~azure.storage.fileshare.models.LeaseAccessConditions - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - restype: Literal["share"] = kwargs.pop("restype", _params.pop("restype", "share")) - cls: ClsType[None] = kwargs.pop("cls", None) - - _lease_id = None - if lease_access_conditions is not None: - _lease_id = lease_access_conditions.lease_id - - _request = build_delete_request( - url=self._config.url, - version=self._config.version, - sharesnapshot=sharesnapshot, - timeout=timeout, - delete_snapshots=delete_snapshots, - lease_id=_lease_id, - file_request_intent=self._config.file_request_intent, - restype=restype, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [202]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - response_headers["x-ms-file-share-usage-bytes"] = self._deserialize( - "int", response.headers.get("x-ms-file-share-usage-bytes") - ) - response_headers["x-ms-file-share-snapshot-usage-bytes"] = self._deserialize( - "int", response.headers.get("x-ms-file-share-snapshot-usage-bytes") - ) - - if cls: - return cls(pipeline_response, None, response_headers) # type: ignore - - @distributed_trace - def acquire_lease( # pylint: disable=inconsistent-return-statements - self, - timeout: Optional[int] = None, - duration: Optional[int] = None, - proposed_lease_id: Optional[str] = None, - sharesnapshot: Optional[str] = None, - request_id_parameter: Optional[str] = None, - **kwargs: Any - ) -> None: - """The Lease Share operation establishes and manages a lock on a share, or the specified snapshot - for set and delete share operations. - - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param duration: Specifies the duration of the lease, in seconds, or negative one (-1) for a - lease that never expires. A non-infinite lease can be between 15 and 60 seconds. A lease - duration cannot be changed using renew or change. Default value is None. - :type duration: int - :param proposed_lease_id: Proposed lease ID, in a GUID string format. The File service returns - 400 (Invalid request) if the proposed lease ID is not in the correct format. See Guid - Constructor (String) for a list of valid GUID string formats. Default value is None. - :type proposed_lease_id: str - :param sharesnapshot: The snapshot parameter is an opaque DateTime value that, when present, - specifies the share snapshot to query. Default value is None. - :type sharesnapshot: str - :param request_id_parameter: Provides a client-generated, opaque value with a 1 KB character - limit that is recorded in the analytics logs when storage analytics logging is enabled. Default - value is None. - :type request_id_parameter: str - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - comp: Literal["lease"] = kwargs.pop("comp", _params.pop("comp", "lease")) - action: Literal["acquire"] = kwargs.pop("action", _headers.pop("x-ms-lease-action", "acquire")) - restype: Literal["share"] = kwargs.pop("restype", _params.pop("restype", "share")) - cls: ClsType[None] = kwargs.pop("cls", None) - - _request = build_acquire_lease_request( - url=self._config.url, - version=self._config.version, - timeout=timeout, - duration=duration, - proposed_lease_id=proposed_lease_id, - sharesnapshot=sharesnapshot, - request_id_parameter=request_id_parameter, - file_request_intent=self._config.file_request_intent, - comp=comp, - action=action, - restype=restype, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [201]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) - response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) - response_headers["x-ms-lease-id"] = self._deserialize("str", response.headers.get("x-ms-lease-id")) - response_headers["x-ms-client-request-id"] = self._deserialize( - "str", response.headers.get("x-ms-client-request-id") - ) - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - - if cls: - return cls(pipeline_response, None, response_headers) # type: ignore - - @distributed_trace - def release_lease( # pylint: disable=inconsistent-return-statements - self, - lease_id: str, - timeout: Optional[int] = None, - sharesnapshot: Optional[str] = None, - request_id_parameter: Optional[str] = None, - **kwargs: Any - ) -> None: - """The Lease Share operation establishes and manages a lock on a share, or the specified snapshot - for set and delete share operations. - - :param lease_id: Specifies the current lease ID on the resource. Required. - :type lease_id: str - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param sharesnapshot: The snapshot parameter is an opaque DateTime value that, when present, - specifies the share snapshot to query. Default value is None. - :type sharesnapshot: str - :param request_id_parameter: Provides a client-generated, opaque value with a 1 KB character - limit that is recorded in the analytics logs when storage analytics logging is enabled. Default - value is None. - :type request_id_parameter: str - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - comp: Literal["lease"] = kwargs.pop("comp", _params.pop("comp", "lease")) - action: Literal["release"] = kwargs.pop("action", _headers.pop("x-ms-lease-action", "release")) - restype: Literal["share"] = kwargs.pop("restype", _params.pop("restype", "share")) - cls: ClsType[None] = kwargs.pop("cls", None) - - _request = build_release_lease_request( - url=self._config.url, - lease_id=lease_id, - version=self._config.version, - timeout=timeout, - sharesnapshot=sharesnapshot, - request_id_parameter=request_id_parameter, - file_request_intent=self._config.file_request_intent, - comp=comp, - action=action, - restype=restype, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) - response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) - response_headers["x-ms-client-request-id"] = self._deserialize( - "str", response.headers.get("x-ms-client-request-id") - ) - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - - if cls: - return cls(pipeline_response, None, response_headers) # type: ignore - - @distributed_trace - def change_lease( # pylint: disable=inconsistent-return-statements - self, - lease_id: str, - timeout: Optional[int] = None, - proposed_lease_id: Optional[str] = None, - sharesnapshot: Optional[str] = None, - request_id_parameter: Optional[str] = None, - **kwargs: Any - ) -> None: - """The Lease Share operation establishes and manages a lock on a share, or the specified snapshot - for set and delete share operations. - - :param lease_id: Specifies the current lease ID on the resource. Required. - :type lease_id: str - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param proposed_lease_id: Proposed lease ID, in a GUID string format. The File service returns - 400 (Invalid request) if the proposed lease ID is not in the correct format. See Guid - Constructor (String) for a list of valid GUID string formats. Default value is None. - :type proposed_lease_id: str - :param sharesnapshot: The snapshot parameter is an opaque DateTime value that, when present, - specifies the share snapshot to query. Default value is None. - :type sharesnapshot: str - :param request_id_parameter: Provides a client-generated, opaque value with a 1 KB character - limit that is recorded in the analytics logs when storage analytics logging is enabled. Default - value is None. - :type request_id_parameter: str - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - comp: Literal["lease"] = kwargs.pop("comp", _params.pop("comp", "lease")) - action: Literal["change"] = kwargs.pop("action", _headers.pop("x-ms-lease-action", "change")) - restype: Literal["share"] = kwargs.pop("restype", _params.pop("restype", "share")) - cls: ClsType[None] = kwargs.pop("cls", None) - - _request = build_change_lease_request( - url=self._config.url, - lease_id=lease_id, - version=self._config.version, - timeout=timeout, - proposed_lease_id=proposed_lease_id, - sharesnapshot=sharesnapshot, - request_id_parameter=request_id_parameter, - file_request_intent=self._config.file_request_intent, - comp=comp, - action=action, - restype=restype, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) - response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) - response_headers["x-ms-lease-id"] = self._deserialize("str", response.headers.get("x-ms-lease-id")) - response_headers["x-ms-client-request-id"] = self._deserialize( - "str", response.headers.get("x-ms-client-request-id") - ) - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - - if cls: - return cls(pipeline_response, None, response_headers) # type: ignore - - @distributed_trace - def renew_lease( # pylint: disable=inconsistent-return-statements - self, - lease_id: str, - timeout: Optional[int] = None, - sharesnapshot: Optional[str] = None, - request_id_parameter: Optional[str] = None, - **kwargs: Any - ) -> None: - """The Lease Share operation establishes and manages a lock on a share, or the specified snapshot - for set and delete share operations. - - :param lease_id: Specifies the current lease ID on the resource. Required. - :type lease_id: str - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param sharesnapshot: The snapshot parameter is an opaque DateTime value that, when present, - specifies the share snapshot to query. Default value is None. - :type sharesnapshot: str - :param request_id_parameter: Provides a client-generated, opaque value with a 1 KB character - limit that is recorded in the analytics logs when storage analytics logging is enabled. Default - value is None. - :type request_id_parameter: str - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - comp: Literal["lease"] = kwargs.pop("comp", _params.pop("comp", "lease")) - action: Literal["renew"] = kwargs.pop("action", _headers.pop("x-ms-lease-action", "renew")) - restype: Literal["share"] = kwargs.pop("restype", _params.pop("restype", "share")) - cls: ClsType[None] = kwargs.pop("cls", None) - - _request = build_renew_lease_request( - url=self._config.url, - lease_id=lease_id, - version=self._config.version, - timeout=timeout, - sharesnapshot=sharesnapshot, - request_id_parameter=request_id_parameter, - file_request_intent=self._config.file_request_intent, - comp=comp, - action=action, - restype=restype, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) - response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) - response_headers["x-ms-lease-id"] = self._deserialize("str", response.headers.get("x-ms-lease-id")) - response_headers["x-ms-client-request-id"] = self._deserialize( - "str", response.headers.get("x-ms-client-request-id") - ) - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - - if cls: - return cls(pipeline_response, None, response_headers) # type: ignore - - @distributed_trace - def break_lease( # pylint: disable=inconsistent-return-statements - self, - timeout: Optional[int] = None, - break_period: Optional[int] = None, - request_id_parameter: Optional[str] = None, - sharesnapshot: Optional[str] = None, - lease_access_conditions: Optional[_models.LeaseAccessConditions] = None, - **kwargs: Any - ) -> None: - """The Lease Share operation establishes and manages a lock on a share, or the specified snapshot - for set and delete share operations. - - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param break_period: For a break operation, proposed duration the lease should continue before - it is broken, in seconds, between 0 and 60. This break period is only used if it is shorter - than the time remaining on the lease. If longer, the time remaining on the lease is used. A new - lease will not be available before the break period has expired, but the lease may be held for - longer than the break period. If this header does not appear with a break operation, a - fixed-duration lease breaks after the remaining lease period elapses, and an infinite lease - breaks immediately. Default value is None. - :type break_period: int - :param request_id_parameter: Provides a client-generated, opaque value with a 1 KB character - limit that is recorded in the analytics logs when storage analytics logging is enabled. Default - value is None. - :type request_id_parameter: str - :param sharesnapshot: The snapshot parameter is an opaque DateTime value that, when present, - specifies the share snapshot to query. Default value is None. - :type sharesnapshot: str - :param lease_access_conditions: Parameter group. Default value is None. - :type lease_access_conditions: ~azure.storage.fileshare.models.LeaseAccessConditions - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - comp: Literal["lease"] = kwargs.pop("comp", _params.pop("comp", "lease")) - action: Literal["break"] = kwargs.pop("action", _headers.pop("x-ms-lease-action", "break")) - restype: Literal["share"] = kwargs.pop("restype", _params.pop("restype", "share")) - cls: ClsType[None] = kwargs.pop("cls", None) - - _lease_id = None - if lease_access_conditions is not None: - _lease_id = lease_access_conditions.lease_id - - _request = build_break_lease_request( - url=self._config.url, - version=self._config.version, - timeout=timeout, - break_period=break_period, - lease_id=_lease_id, - request_id_parameter=request_id_parameter, - sharesnapshot=sharesnapshot, - file_request_intent=self._config.file_request_intent, - comp=comp, - action=action, - restype=restype, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [202]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) - response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) - response_headers["x-ms-lease-time"] = self._deserialize("int", response.headers.get("x-ms-lease-time")) - response_headers["x-ms-lease-id"] = self._deserialize("str", response.headers.get("x-ms-lease-id")) - response_headers["x-ms-client-request-id"] = self._deserialize( - "str", response.headers.get("x-ms-client-request-id") - ) - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - - if cls: - return cls(pipeline_response, None, response_headers) # type: ignore - - @distributed_trace - def create_snapshot( # pylint: disable=inconsistent-return-statements - self, timeout: Optional[int] = None, metadata: Optional[dict[str, str]] = None, **kwargs: Any - ) -> None: - """Creates a read-only snapshot of a share. - - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param metadata: A name-value pair to associate with a file storage object. Default value is - None. - :type metadata: dict[str, str] - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - restype: Literal["share"] = kwargs.pop("restype", _params.pop("restype", "share")) - comp: Literal["snapshot"] = kwargs.pop("comp", _params.pop("comp", "snapshot")) - cls: ClsType[None] = kwargs.pop("cls", None) - - _request = build_create_snapshot_request( - url=self._config.url, - version=self._config.version, - timeout=timeout, - metadata=metadata, - file_request_intent=self._config.file_request_intent, - restype=restype, - comp=comp, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [201]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["x-ms-snapshot"] = self._deserialize("str", response.headers.get("x-ms-snapshot")) - response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) - response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - - if cls: - return cls(pipeline_response, None, response_headers) # type: ignore - - @overload - def create_permission( - self, - share_permission: _models.SharePermission, - timeout: Optional[int] = None, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> None: - """Create a permission (a security descriptor). - - :param share_permission: A permission (a security descriptor) at the share level. Required. - :type share_permission: ~azure.storage.fileshare.models.SharePermission - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :keyword content_type: Body Parameter content-type. Content type parameter for JSON body. - Default value is "application/json". - :paramtype content_type: str - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @overload - def create_permission( - self, - share_permission: IO[bytes], - timeout: Optional[int] = None, - *, - content_type: str = "application/json", - **kwargs: Any - ) -> None: - """Create a permission (a security descriptor). - - :param share_permission: A permission (a security descriptor) at the share level. Required. - :type share_permission: IO[bytes] - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :keyword content_type: Body Parameter content-type. Content type parameter for binary body. - Default value is "application/json". - :paramtype content_type: str - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - - @distributed_trace - def create_permission( # pylint: disable=inconsistent-return-statements - self, share_permission: Union[_models.SharePermission, IO[bytes]], timeout: Optional[int] = None, **kwargs: Any - ) -> None: - """Create a permission (a security descriptor). - - :param share_permission: A permission (a security descriptor) at the share level. Is either a - SharePermission type or a IO[bytes] type. Required. - :type share_permission: ~azure.storage.fileshare.models.SharePermission or IO[bytes] - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - restype: Literal["share"] = kwargs.pop("restype", _params.pop("restype", "share")) - comp: Literal["filepermission"] = kwargs.pop("comp", _params.pop("comp", "filepermission")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None)) - cls: ClsType[None] = kwargs.pop("cls", None) - - content_type = content_type or "application/json" - _json = None - _content = None - if isinstance(share_permission, (IOBase, bytes)): - _content = share_permission - else: - _json = self._serialize.body(share_permission, "SharePermission") - - _request = build_create_permission_request( - url=self._config.url, - version=self._config.version, - timeout=timeout, - file_request_intent=self._config.file_request_intent, - restype=restype, - comp=comp, - content_type=content_type, - json=_json, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [201]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - response_headers["x-ms-file-permission-key"] = self._deserialize( - "str", response.headers.get("x-ms-file-permission-key") - ) - - if cls: - return cls(pipeline_response, None, response_headers) # type: ignore - - @distributed_trace - def get_permission( - self, - file_permission_key: str, - file_permission_format: Optional[Union[str, _models.FilePermissionFormat]] = None, - timeout: Optional[int] = None, - **kwargs: Any - ) -> _models.SharePermission: - """Returns the permission (security descriptor) for a given key. - - :param file_permission_key: Key of the permission to be set for the directory/file. Required. - :type file_permission_key: str - :param file_permission_format: Optional. Available for version 2023-06-01 and later. Specifies - the format in which the permission is returned. Acceptable values are SDDL or binary. If - x-ms-file-permission-format is unspecified or explicitly set to SDDL, the permission is - returned in SDDL format. If x-ms-file-permission-format is explicitly set to binary, the - permission is returned as a base64 string representing the binary encoding of the permission. - Known values are: "Sddl" and "Binary". Default value is None. - :type file_permission_format: str or ~azure.storage.fileshare.models.FilePermissionFormat - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :return: SharePermission or the result of cls(response) - :rtype: ~azure.storage.fileshare.models.SharePermission - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - restype: Literal["share"] = kwargs.pop("restype", _params.pop("restype", "share")) - comp: Literal["filepermission"] = kwargs.pop("comp", _params.pop("comp", "filepermission")) - cls: ClsType[_models.SharePermission] = kwargs.pop("cls", None) - - _request = build_get_permission_request( - url=self._config.url, - file_permission_key=file_permission_key, - version=self._config.version, - file_permission_format=file_permission_format, - timeout=timeout, - file_request_intent=self._config.file_request_intent, - restype=restype, - comp=comp, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - - deserialized = self._deserialize("SharePermission", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def set_properties( # pylint: disable=inconsistent-return-statements,too-many-locals - self, - timeout: Optional[int] = None, - quota: Optional[int] = None, - access_tier: Optional[Union[str, _models.ShareAccessTier]] = None, - root_squash: Optional[Union[str, _models.ShareRootSquash]] = None, - enable_snapshot_virtual_directory_access: Optional[bool] = None, - paid_bursting_enabled: Optional[bool] = None, - paid_bursting_max_bandwidth_mibps: Optional[int] = None, - paid_bursting_max_iops: Optional[int] = None, - share_provisioned_iops: Optional[int] = None, - share_provisioned_bandwidth_mibps: Optional[int] = None, - enable_smb_directory_lease: Optional[bool] = None, - lease_access_conditions: Optional[_models.LeaseAccessConditions] = None, - **kwargs: Any - ) -> None: - """Sets properties for the specified share. - - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param quota: Specifies the maximum size of the share, in gigabytes. Default value is None. - :type quota: int - :param access_tier: Specifies the access tier of the share. Known values are: - "TransactionOptimized", "Hot", "Cool", and "Premium". Default value is None. - :type access_tier: str or ~azure.storage.fileshare.models.ShareAccessTier - :param root_squash: Root squash to set on the share. Only valid for NFS shares. Known values - are: "NoRootSquash", "RootSquash", and "AllSquash". Default value is None. - :type root_squash: str or ~azure.storage.fileshare.models.ShareRootSquash - :param enable_snapshot_virtual_directory_access: Default value is None. - :type enable_snapshot_virtual_directory_access: bool - :param paid_bursting_enabled: Optional. Boolean. Default if not specified is false. This - property enables paid bursting. Default value is None. - :type paid_bursting_enabled: bool - :param paid_bursting_max_bandwidth_mibps: Optional. Integer. Default if not specified is the - maximum throughput the file share can support. Current maximum for a file share is 10,340 - MiB/sec. Default value is None. - :type paid_bursting_max_bandwidth_mibps: int - :param paid_bursting_max_iops: Optional. Integer. Default if not specified is the maximum IOPS - the file share can support. Current maximum for a file share is 102,400 IOPS. Default value is - None. - :type paid_bursting_max_iops: int - :param share_provisioned_iops: Optional. Supported in version 2025-01-05 and later. Only - allowed for provisioned v2 file shares. Specifies the provisioned number of input/output - operations per second (IOPS) of the share. If this is not specified, the provisioned IOPS is - set to value calculated based on recommendation formula. Default value is None. - :type share_provisioned_iops: int - :param share_provisioned_bandwidth_mibps: Optional. Supported in version 2025-01-05 and later. - Only allowed for provisioned v2 file shares. Specifies the provisioned bandwidth of the share, - in mebibytes per second (MiBps). If this is not specified, the provisioned bandwidth is set to - value calculated based on recommendation formula. Default value is None. - :type share_provisioned_bandwidth_mibps: int - :param enable_smb_directory_lease: SMB only, default is true. Specifies whether granting of - new directory leases for directories present in a share are to be enabled or disabled. An input - of true specifies that granting of new directory leases is to be allowed. An input of false - specifies that granting of new directory leases is to be blocked. Default value is None. - :type enable_smb_directory_lease: bool - :param lease_access_conditions: Parameter group. Default value is None. - :type lease_access_conditions: ~azure.storage.fileshare.models.LeaseAccessConditions - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - restype: Literal["share"] = kwargs.pop("restype", _params.pop("restype", "share")) - comp: Literal["properties"] = kwargs.pop("comp", _params.pop("comp", "properties")) - cls: ClsType[None] = kwargs.pop("cls", None) - - _lease_id = None - if lease_access_conditions is not None: - _lease_id = lease_access_conditions.lease_id - - _request = build_set_properties_request( - url=self._config.url, - version=self._config.version, - timeout=timeout, - quota=quota, - access_tier=access_tier, - lease_id=_lease_id, - root_squash=root_squash, - enable_snapshot_virtual_directory_access=enable_snapshot_virtual_directory_access, - paid_bursting_enabled=paid_bursting_enabled, - paid_bursting_max_bandwidth_mibps=paid_bursting_max_bandwidth_mibps, - paid_bursting_max_iops=paid_bursting_max_iops, - share_provisioned_iops=share_provisioned_iops, - share_provisioned_bandwidth_mibps=share_provisioned_bandwidth_mibps, - enable_smb_directory_lease=enable_smb_directory_lease, - file_request_intent=self._config.file_request_intent, - restype=restype, - comp=comp, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) - response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - response_headers["x-ms-share-quota"] = self._deserialize("int", response.headers.get("x-ms-share-quota")) - response_headers["x-ms-share-provisioned-iops"] = self._deserialize( - "int", response.headers.get("x-ms-share-provisioned-iops") - ) - response_headers["x-ms-share-provisioned-bandwidth-mibps"] = self._deserialize( - "int", response.headers.get("x-ms-share-provisioned-bandwidth-mibps") - ) - response_headers["x-ms-share-included-burst-iops"] = self._deserialize( - "int", response.headers.get("x-ms-share-included-burst-iops") - ) - response_headers["x-ms-share-max-burst-credits-for-iops"] = self._deserialize( - "int", response.headers.get("x-ms-share-max-burst-credits-for-iops") - ) - response_headers["x-ms-share-next-allowed-quota-downgrade-time"] = self._deserialize( - "rfc-1123", response.headers.get("x-ms-share-next-allowed-quota-downgrade-time") - ) - response_headers["x-ms-share-next-allowed-provisioned-iops-downgrade-time"] = self._deserialize( - "rfc-1123", response.headers.get("x-ms-share-next-allowed-provisioned-iops-downgrade-time") - ) - response_headers["x-ms-share-next-allowed-provisioned-bandwidth-downgrade-time"] = self._deserialize( - "rfc-1123", response.headers.get("x-ms-share-next-allowed-provisioned-bandwidth-downgrade-time") - ) - - if cls: - return cls(pipeline_response, None, response_headers) # type: ignore - - @distributed_trace - def set_metadata( # pylint: disable=inconsistent-return-statements - self, - timeout: Optional[int] = None, - metadata: Optional[dict[str, str]] = None, - lease_access_conditions: Optional[_models.LeaseAccessConditions] = None, - **kwargs: Any - ) -> None: - """Sets one or more user-defined name-value pairs for the specified share. - - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param metadata: A name-value pair to associate with a file storage object. Default value is - None. - :type metadata: dict[str, str] - :param lease_access_conditions: Parameter group. Default value is None. - :type lease_access_conditions: ~azure.storage.fileshare.models.LeaseAccessConditions - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - restype: Literal["share"] = kwargs.pop("restype", _params.pop("restype", "share")) - comp: Literal["metadata"] = kwargs.pop("comp", _params.pop("comp", "metadata")) - cls: ClsType[None] = kwargs.pop("cls", None) - - _lease_id = None - if lease_access_conditions is not None: - _lease_id = lease_access_conditions.lease_id - - _request = build_set_metadata_request( - url=self._config.url, - version=self._config.version, - timeout=timeout, - metadata=metadata, - lease_id=_lease_id, - file_request_intent=self._config.file_request_intent, - restype=restype, - comp=comp, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) - response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - - if cls: - return cls(pipeline_response, None, response_headers) # type: ignore - - @distributed_trace - def get_access_policy( - self, - timeout: Optional[int] = None, - lease_access_conditions: Optional[_models.LeaseAccessConditions] = None, - **kwargs: Any - ) -> list[_models.SignedIdentifier]: - """Returns information about stored access policies specified on the share. - - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param lease_access_conditions: Parameter group. Default value is None. - :type lease_access_conditions: ~azure.storage.fileshare.models.LeaseAccessConditions - :return: list of SignedIdentifier or the result of cls(response) - :rtype: list[~azure.storage.fileshare.models.SignedIdentifier] - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - restype: Literal["share"] = kwargs.pop("restype", _params.pop("restype", "share")) - comp: Literal["acl"] = kwargs.pop("comp", _params.pop("comp", "acl")) - cls: ClsType[list[_models.SignedIdentifier]] = kwargs.pop("cls", None) - - _lease_id = None - if lease_access_conditions is not None: - _lease_id = lease_access_conditions.lease_id - - _request = build_get_access_policy_request( - url=self._config.url, - version=self._config.version, - timeout=timeout, - lease_id=_lease_id, - file_request_intent=self._config.file_request_intent, - restype=restype, - comp=comp, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) - response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - - deserialized = self._deserialize("[SignedIdentifier]", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def set_access_policy( # pylint: disable=inconsistent-return-statements - self, - timeout: Optional[int] = None, - lease_access_conditions: Optional[_models.LeaseAccessConditions] = None, - share_acl: Optional[list[_models.SignedIdentifier]] = None, - **kwargs: Any - ) -> None: - """Sets a stored access policy for use with shared access signatures. - - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param lease_access_conditions: Parameter group. Default value is None. - :type lease_access_conditions: ~azure.storage.fileshare.models.LeaseAccessConditions - :param share_acl: The ACL for the share. Default value is None. - :type share_acl: list[~azure.storage.fileshare.models.SignedIdentifier] - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {}) - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - restype: Literal["share"] = kwargs.pop("restype", _params.pop("restype", "share")) - comp: Literal["acl"] = kwargs.pop("comp", _params.pop("comp", "acl")) - content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", "application/xml")) - content_type = content_type if share_acl else None - cls: ClsType[None] = kwargs.pop("cls", None) - - _lease_id = None - if lease_access_conditions is not None: - _lease_id = lease_access_conditions.lease_id - serialization_ctxt = {"xml": {"name": "SignedIdentifiers", "wrapped": True}} - if share_acl is not None: - _content = self._serialize.body( - share_acl, "[SignedIdentifier]", is_xml=True, serialization_ctxt=serialization_ctxt - ) - else: - _content = None - - _request = build_set_access_policy_request( - url=self._config.url, - version=self._config.version, - timeout=timeout, - lease_id=_lease_id, - file_request_intent=self._config.file_request_intent, - restype=restype, - comp=comp, - content_type=content_type, - content=_content, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) - response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - - if cls: - return cls(pipeline_response, None, response_headers) # type: ignore - - @distributed_trace - def get_statistics( - self, - timeout: Optional[int] = None, - lease_access_conditions: Optional[_models.LeaseAccessConditions] = None, - **kwargs: Any - ) -> _models.ShareStats: - """Retrieves statistics related to the share. - - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param lease_access_conditions: Parameter group. Default value is None. - :type lease_access_conditions: ~azure.storage.fileshare.models.LeaseAccessConditions - :return: ShareStats or the result of cls(response) - :rtype: ~azure.storage.fileshare.models.ShareStats - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - restype: Literal["share"] = kwargs.pop("restype", _params.pop("restype", "share")) - comp: Literal["stats"] = kwargs.pop("comp", _params.pop("comp", "stats")) - cls: ClsType[_models.ShareStats] = kwargs.pop("cls", None) - - _lease_id = None - if lease_access_conditions is not None: - _lease_id = lease_access_conditions.lease_id - - _request = build_get_statistics_request( - url=self._config.url, - version=self._config.version, - timeout=timeout, - lease_id=_lease_id, - file_request_intent=self._config.file_request_intent, - restype=restype, - comp=comp, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [200]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) - response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - - deserialized = self._deserialize("ShareStats", pipeline_response.http_response) - - if cls: - return cls(pipeline_response, deserialized, response_headers) # type: ignore - - return deserialized # type: ignore - - @distributed_trace - def restore( # pylint: disable=inconsistent-return-statements - self, - timeout: Optional[int] = None, - request_id_parameter: Optional[str] = None, - deleted_share_name: Optional[str] = None, - deleted_share_version: Optional[str] = None, - **kwargs: Any - ) -> None: - """Restores a previously deleted Share. - - :param timeout: The timeout parameter is expressed in seconds. For more information, see - :code:`Setting - Timeouts for File Service Operations.`. Default value is None. - :type timeout: int - :param request_id_parameter: Provides a client-generated, opaque value with a 1 KB character - limit that is recorded in the analytics logs when storage analytics logging is enabled. Default - value is None. - :type request_id_parameter: str - :param deleted_share_name: Specifies the name of the previously-deleted share. Default value is - None. - :type deleted_share_name: str - :param deleted_share_version: Specifies the version of the previously-deleted share. Default - value is None. - :type deleted_share_version: str - :return: None or the result of cls(response) - :rtype: None - :raises ~azure.core.exceptions.HttpResponseError: - """ - error_map: MutableMapping = { - 401: ClientAuthenticationError, - 404: ResourceNotFoundError, - 409: ResourceExistsError, - 304: ResourceNotModifiedError, - } - error_map.update(kwargs.pop("error_map", {}) or {}) - - _headers = kwargs.pop("headers", {}) or {} - _params = case_insensitive_dict(kwargs.pop("params", {}) or {}) - - restype: Literal["share"] = kwargs.pop("restype", _params.pop("restype", "share")) - comp: Literal["undelete"] = kwargs.pop("comp", _params.pop("comp", "undelete")) - cls: ClsType[None] = kwargs.pop("cls", None) - - _request = build_restore_request( - url=self._config.url, - version=self._config.version, - timeout=timeout, - request_id_parameter=request_id_parameter, - deleted_share_name=deleted_share_name, - deleted_share_version=deleted_share_version, - file_request_intent=self._config.file_request_intent, - restype=restype, - comp=comp, - headers=_headers, - params=_params, - ) - _request.url = self._client.format_url(_request.url) - - _stream = False - pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access - _request, stream=_stream, **kwargs - ) - - response = pipeline_response.http_response - - if response.status_code not in [201]: - map_error(status_code=response.status_code, response=response, error_map=error_map) - error = self._deserialize.failsafe_deserialize( - _models.StorageError, - pipeline_response, - ) - raise HttpResponseError(response=response, model=error) - - response_headers = {} - response_headers["ETag"] = self._deserialize("str", response.headers.get("ETag")) - response_headers["Last-Modified"] = self._deserialize("rfc-1123", response.headers.get("Last-Modified")) - response_headers["x-ms-request-id"] = self._deserialize("str", response.headers.get("x-ms-request-id")) - response_headers["x-ms-client-request-id"] = self._deserialize( - "str", response.headers.get("x-ms-client-request-id") - ) - response_headers["x-ms-version"] = self._deserialize("str", response.headers.get("x-ms-version")) - response_headers["Date"] = self._deserialize("rfc-1123", response.headers.get("Date")) - response_headers["x-ms-share-quota"] = self._deserialize("int", response.headers.get("x-ms-share-quota")) - response_headers["x-ms-share-provisioned-iops"] = self._deserialize( - "int", response.headers.get("x-ms-share-provisioned-iops") - ) - response_headers["x-ms-share-provisioned-bandwidth-mibps"] = self._deserialize( - "int", response.headers.get("x-ms-share-provisioned-bandwidth-mibps") - ) - response_headers["x-ms-share-included-burst-iops"] = self._deserialize( - "int", response.headers.get("x-ms-share-included-burst-iops") - ) - response_headers["x-ms-share-max-burst-credits-for-iops"] = self._deserialize( - "int", response.headers.get("x-ms-share-max-burst-credits-for-iops") - ) - - if cls: - return cls(pipeline_response, None, response_headers) # type: ignore diff --git a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_lease.py b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_lease.py index 6a4450f1f78f..2d2a7e8cfd21 100644 --- a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_lease.py +++ b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_lease.py @@ -1,3 +1,4 @@ +# pylint: disable=line-too-long,useless-suppression # ------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for @@ -43,18 +44,20 @@ class ShareLeaseClient: # pylint: disable=client-accepts-api-version-keyword This will be `None` if no lease has yet been acquired or modified.""" def __init__( # pylint: disable=missing-client-constructor-parameter-credential, missing-client-constructor-parameter-kwargs - self, client: Union["ShareFileClient", "ShareClient"], - lease_id: Optional[str] = None + self, client: Union["ShareFileClient", "ShareClient"], lease_id: Optional[str] = None ) -> None: self.id = lease_id or str(uuid.uuid4()) self.last_modified = None self.etag = None - if hasattr(client, 'file_name'): + self._file_request_intent = getattr(client, "file_request_intent", None) + if hasattr(client, "file_name"): self._client = client._client.file # type: ignore self._snapshot = None - elif hasattr(client, 'share_name'): + self._allow_trailing_dot = getattr(client, "allow_trailing_dot", None) + elif hasattr(client, "share_name"): self._client = client._client.share self._snapshot = client.snapshot + self._allow_trailing_dot = None else: raise TypeError("Lease must use ShareFileClient or ShareClient.") @@ -90,20 +93,24 @@ def acquire(self, **kwargs: Any) -> None: :rtype: None """ try: - lease_duration = kwargs.pop('lease_duration', -1) + lease_duration = kwargs.pop("lease_duration", -1) if self._snapshot: - kwargs['sharesnapshot'] = self._snapshot + kwargs["sharesnapshot"] = self._snapshot + if self._allow_trailing_dot is not None: + kwargs["allow_trailing_dot"] = self._allow_trailing_dot response = self._client.acquire_lease( - timeout=kwargs.pop('timeout', None), - duration=lease_duration, + timeout=kwargs.pop("timeout", None), + lease_duration=lease_duration, proposed_lease_id=self.id, + file_request_intent=self._file_request_intent, cls=return_response_headers, - **kwargs) + **kwargs + ) except HttpResponseError as error: process_storage_error(error) - self.id = response.get('lease_id') - self.last_modified = response.get('last_modified') - self.etag = response.get('etag') + self.id = response.get("lease_id") + self.last_modified = response.get("last_modified") + self.etag = response.get("etag") @distributed_trace def renew(self, **kwargs: Any) -> None: @@ -130,15 +137,17 @@ def renew(self, **kwargs: Any) -> None: try: response = self._client.renew_lease( lease_id=self.id, - timeout=kwargs.pop('timeout', None), + timeout=kwargs.pop("timeout", None), sharesnapshot=self._snapshot, + file_request_intent=self._file_request_intent, cls=return_response_headers, - **kwargs) + **kwargs + ) except HttpResponseError as error: process_storage_error(error) - self.etag = response.get('etag') - self.id = response.get('lease_id') - self.last_modified = response.get('last_modified') + self.etag = response.get("etag") + self.id = response.get("lease_id") + self.last_modified = response.get("last_modified") @distributed_trace def release(self, **kwargs: Any) -> None: @@ -156,21 +165,25 @@ def release(self, **kwargs: Any) -> None: """ try: if self._snapshot: - kwargs['sharesnapshot'] = self._snapshot + kwargs["sharesnapshot"] = self._snapshot + if self._allow_trailing_dot is not None: + kwargs["allow_trailing_dot"] = self._allow_trailing_dot response = self._client.release_lease( lease_id=self.id, - timeout=kwargs.pop('timeout', None), + timeout=kwargs.pop("timeout", None), + file_request_intent=self._file_request_intent, cls=return_response_headers, - **kwargs) + **kwargs + ) except HttpResponseError as error: process_storage_error(error) - self.etag = response.get('etag') - self.id = response.get('lease_id') - self.last_modified = response.get('last_modified') + self.etag = response.get("etag") + self.id = response.get("lease_id") + self.last_modified = response.get("last_modified") @distributed_trace def change(self, proposed_lease_id: str, **kwargs: Any) -> None: - """ Changes the lease ID of an active lease. A change must include the current lease ID in x-ms-lease-id and + """Changes the lease ID of an active lease. A change must include the current lease ID in x-ms-lease-id and a new lease ID in x-ms-proposed-lease-id. :param str proposed_lease_id: @@ -186,18 +199,22 @@ def change(self, proposed_lease_id: str, **kwargs: Any) -> None: """ try: if self._snapshot: - kwargs['sharesnapshot'] = self._snapshot + kwargs["sharesnapshot"] = self._snapshot + if self._allow_trailing_dot is not None: + kwargs["allow_trailing_dot"] = self._allow_trailing_dot response = self._client.change_lease( lease_id=self.id, proposed_lease_id=proposed_lease_id, - timeout=kwargs.pop('timeout', None), + timeout=kwargs.pop("timeout", None), + file_request_intent=self._file_request_intent, cls=return_response_headers, - **kwargs) + **kwargs + ) except HttpResponseError as error: process_storage_error(error) - self.etag = response.get('etag') - self.id = response.get('lease_id') - self.last_modified = response.get('last_modified') + self.etag = response.get("etag") + self.id = response.get("lease_id") + self.last_modified = response.get("last_modified") @distributed_trace def break_lease(self, **kwargs: Any) -> int: @@ -232,18 +249,23 @@ def break_lease(self, **kwargs: Any) -> int: :rtype: int """ try: - lease_break_period = kwargs.pop('lease_break_period', None) + lease_break_period = kwargs.pop("lease_break_period", None) if self._snapshot: - kwargs['sharesnapshot'] = self._snapshot + kwargs["sharesnapshot"] = self._snapshot if isinstance(self._client, ShareOperations): - kwargs['break_period'] = lease_break_period + kwargs["break_period"] = lease_break_period if isinstance(self._client, FileOperations) and lease_break_period: raise TypeError("Setting a lease break period is only applicable to Share leases.") + if self._allow_trailing_dot is not None: + kwargs["allow_trailing_dot"] = self._allow_trailing_dot + response = self._client.break_lease( - timeout=kwargs.pop('timeout', None), + timeout=kwargs.pop("timeout", None), + file_request_intent=self._file_request_intent, cls=return_response_headers, - **kwargs) + **kwargs + ) except HttpResponseError as error: process_storage_error(error) - return cast(int, response.get('lease_time')) + return cast(int, response.get("lease_time")) diff --git a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_models.py b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_models.py index c3e709e0867a..43b6826350e7 100644 --- a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_models.py +++ b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_models.py @@ -1,3 +1,4 @@ +# pylint: disable=line-too-long,useless-suppression,too-many-lines # ------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for @@ -6,10 +7,8 @@ # pylint: disable=too-few-public-methods, too-many-instance-attributes, super-init-not-called, too-many-lines from enum import Enum -from typing import ( - Any, Callable, Dict, List, Literal, Optional, Union, - TYPE_CHECKING -) +import xml.etree.ElementTree as ET +from typing import Any, Callable, Dict, List, Literal, Optional, Union, TYPE_CHECKING from urllib.parse import unquote from typing_extensions import Self @@ -18,6 +17,7 @@ from azure.core.paging import PageIterator from ._generated._utils.serialization import Deserializer +from ._generated.models._patch import _ModelBackCompatMixin, as_dict as _backcompat_as_dict from ._generated.models import AccessPolicy as GenAccessPolicy from ._generated.models import CorsRule as GeneratedCorsRule from ._generated.models import DirectoryItem @@ -40,11 +40,11 @@ def _wrap_item(item): if isinstance(item, DirectoryItem): - return {'name': item.name, 'is_directory': True} - return {'name': item.name, 'size': item.properties.content_length, 'is_directory': False} + return {"name": item.name, "is_directory": True} + return {"name": item.name, "size": item.properties.content_length, "is_directory": False} -class RetentionPolicy(GeneratedRetentionPolicy): +class RetentionPolicy(GeneratedRetentionPolicy, _ModelBackCompatMixin): """The retention policy which determines how long the associated data should persist. @@ -64,22 +64,46 @@ class RetentionPolicy(GeneratedRetentionPolicy): All data older than this value will be deleted.""" def __init__(self, enabled: bool = False, days: Optional[int] = None) -> None: - self.enabled = enabled - self.days = days - if self.enabled and (self.days is None): + if enabled and (days is None): raise ValueError("If policy is enabled, 'days' must be specified.") + super().__init__(enabled=enabled, days=days) + + def as_dict( + self, + keep_readonly: bool = True, + key_transformer: Optional[Callable[[str, Dict[str, Any], Any], Any]] = None, + **kwargs: Any, + ) -> Dict[str, Any]: + """Return a dict representation of the model. + + :param bool keep_readonly: Whether to include readonly fields. + :param key_transformer: A callable to transform each key serialized + from the model. + :type key_transformer: Optional[Callable[[str, Dict[str, Any], Any], Any]] + :return: A dictionary representation of this model. + :rtype: Dict[str, Any] + """ + return _backcompat_as_dict( + self, + keep_readonly=keep_readonly, + key_transformer=key_transformer, + **kwargs, + ) # type: ignore[return-value] @classmethod def _from_generated(cls, generated): if not generated: return cls() + # Handle XML Element by converting to generated model first + if isinstance(generated, ET.Element): + generated = GeneratedRetentionPolicy(generated) # type: ignore[assignment,call-overload] return cls( enabled=generated.enabled, days=generated.days, ) -class Metrics(GeneratedMetrics): +class Metrics(GeneratedMetrics, _ModelBackCompatMixin): """A summary of request statistics grouped by API in hour or minute aggregates for files. @@ -95,7 +119,7 @@ class Metrics(GeneratedMetrics): Determines how long the associated data should persist. """ - version: str = '1.0' + version: str = "1.0" """The version of Storage Analytics to configure.""" enabled: bool = False """Indicates whether metrics are enabled for the File service.""" @@ -105,24 +129,53 @@ class Metrics(GeneratedMetrics): """Determines how long the associated data should persist.""" def __init__(self, **kwargs: Any) -> None: - self.version = kwargs.get('version', '1.0') - self.enabled = kwargs.get('enabled', False) - self.include_apis = kwargs.get('include_apis') # type: ignore [assignment] - self.retention_policy = kwargs.get('retention_policy') or RetentionPolicy() + super().__init__( + version=kwargs.get("version", "1.0"), + enabled=kwargs.get("enabled", False), + include_apis=kwargs.get("include_apis"), + retention_policy=kwargs.get("retention_policy") or RetentionPolicy(), + ) + + def as_dict( + self, + keep_readonly: bool = True, + key_transformer: Optional[Callable[[str, Dict[str, Any], Any], Any]] = None, + **kwargs: Any, + ) -> Dict[str, Any]: + """Return a dict representation of the model. + + :param bool keep_readonly: Whether to include readonly fields. + :param key_transformer: A callable to transform each key serialized + from the model. + :type key_transformer: Optional[Callable[[str, Dict[str, Any], Any], Any]] + :return: A dictionary representation of this model. + :rtype: Dict[str, Any] + """ + return _backcompat_as_dict( + self, + keep_readonly=keep_readonly, + key_transformer=key_transformer, + **kwargs, + ) # type: ignore[return-value] @classmethod def _from_generated(cls, generated): if not generated: return cls() + # Handle XML Element by converting to generated model first + if isinstance(generated, ET.Element): + generated = GeneratedMetrics(generated) # type: ignore[assignment,call-overload] return cls( version=generated.version, enabled=generated.enabled, include_apis=generated.include_apis, - retention_policy=RetentionPolicy._from_generated(generated.retention_policy) # pylint: disable=protected-access + retention_policy=RetentionPolicy._from_generated( # pylint: disable=protected-access + generated.retention_policy + ), ) -class CorsRule(GeneratedCorsRule): +class CorsRule(GeneratedCorsRule, _ModelBackCompatMixin): """CORS is an HTTP feature that enables a web application running under one domain to access resources in another domain. Web browsers implement a security restriction known as same-origin policy that prevents a web page @@ -168,11 +221,35 @@ class CorsRule(GeneratedCorsRule): """The number of seconds that the client/browser should cache a pre-flight response.""" def __init__(self, allowed_origins: List[str], allowed_methods: List[str], **kwargs: Any) -> None: - self.allowed_origins = ','.join(allowed_origins) - self.allowed_methods = ','.join(allowed_methods) - self.allowed_headers = ','.join(kwargs.get('allowed_headers', [])) - self.exposed_headers = ','.join(kwargs.get('exposed_headers', [])) - self.max_age_in_seconds = kwargs.get('max_age_in_seconds', 0) + super().__init__( + allowed_origins=",".join(allowed_origins), + allowed_methods=",".join(allowed_methods), + allowed_headers=",".join(kwargs.get("allowed_headers", [])), + exposed_headers=",".join(kwargs.get("exposed_headers", [])), + max_age_in_seconds=kwargs.get("max_age_in_seconds", 0), + ) + + def as_dict( + self, + keep_readonly: bool = True, + key_transformer: Optional[Callable[[str, Dict[str, Any], Any], Any]] = None, + **kwargs: Any, + ) -> Dict[str, Any]: + """Return a dict representation of the model. + + :param bool keep_readonly: Whether to include readonly fields. + :param key_transformer: A callable to transform each key serialized + from the model. + :type key_transformer: Optional[Callable[[str, Dict[str, Any], Any], Any]] + :return: A dictionary representation of this model. + :rtype: Dict[str, Any] + """ + return _backcompat_as_dict( + self, + keep_readonly=keep_readonly, + key_transformer=key_transformer, + **kwargs, + ) # type: ignore[return-value] @staticmethod def _to_generated(rules: Optional[List["CorsRule"]]) -> Optional[List[GeneratedCorsRule]]: @@ -194,6 +271,9 @@ def _to_generated(rules: Optional[List["CorsRule"]]) -> Optional[List[GeneratedC @classmethod def _from_generated(cls, generated): + # Handle XML Element by converting to generated model first + if isinstance(generated, ET.Element): + generated = GeneratedCorsRule(generated) # type: ignore[assignment,call-overload] return cls( [generated.allowed_origins], [generated.allowed_methods], @@ -203,7 +283,7 @@ def _from_generated(cls, generated): ) -class SmbMultichannel(GeneratedSmbMultichannel): +class SmbMultichannel(GeneratedSmbMultichannel, _ModelBackCompatMixin): """Settings for Multichannel. :keyword bool enabled: If SMB Multichannel is enabled. @@ -212,11 +292,33 @@ class SmbMultichannel(GeneratedSmbMultichannel): enabled: bool """If SMB Multichannel is enabled.""" - def __init__(self, *, enabled: bool, **kwargs: Any) -> None: - self.enabled = enabled + def __init__(self, *, enabled: bool, **kwargs: Any) -> None: # pylint: disable=unused-argument + super().__init__(enabled=enabled) + + def as_dict( + self, + keep_readonly: bool = True, + key_transformer: Optional[Callable[[str, Dict[str, Any], Any], Any]] = None, + **kwargs: Any, + ) -> Dict[str, Any]: + """Return a dict representation of the model. + + :param bool keep_readonly: Whether to include readonly fields. + :param key_transformer: A callable to transform each key serialized + from the model. + :type key_transformer: Optional[Callable[[str, Dict[str, Any], Any], Any]] + :return: A dictionary representation of this model. + :rtype: Dict[str, Any] + """ + return _backcompat_as_dict( + self, + keep_readonly=keep_readonly, + key_transformer=key_transformer, + **kwargs, + ) # type: ignore[return-value] -class SmbEncryptionInTransit(GeneratedSmbEncryptionInTransit): +class SmbEncryptionInTransit(GeneratedSmbEncryptionInTransit, _ModelBackCompatMixin): """Settings for encryption in transit. :keyword bool required: If encryption in transit is required. @@ -225,11 +327,33 @@ class SmbEncryptionInTransit(GeneratedSmbEncryptionInTransit): required: bool """If encryption in transit is enabled.""" - def __init__(self, *, required: bool, **kwargs: Any) -> None: - self.required = required + def __init__(self, *, required: bool, **kwargs: Any) -> None: # pylint: disable=unused-argument + super().__init__(required=required) + + def as_dict( + self, + keep_readonly: bool = True, + key_transformer: Optional[Callable[[str, Dict[str, Any], Any], Any]] = None, + **kwargs: Any, + ) -> Dict[str, Any]: + """Return a dict representation of the model. + + :param bool keep_readonly: Whether to include readonly fields. + :param key_transformer: A callable to transform each key serialized + from the model. + :type key_transformer: Optional[Callable[[str, Dict[str, Any], Any], Any]] + :return: A dictionary representation of this model. + :rtype: Dict[str, Any] + """ + return _backcompat_as_dict( + self, + keep_readonly=keep_readonly, + key_transformer=key_transformer, + **kwargs, + ) # type: ignore[return-value] -class ShareSmbSettings(GeneratedShareSmbSettings): +class ShareSmbSettings(GeneratedShareSmbSettings, _ModelBackCompatMixin): """Settings for the SMB protocol. :keyword SmbMultichannel multichannel: Sets the multichannel settings. @@ -241,20 +365,41 @@ class ShareSmbSettings(GeneratedShareSmbSettings): encryption_in_transit: Optional[SmbEncryptionInTransit] """Sets the encryption in transit settings.""" - def __init__( + def __init__( # pylint: disable=unused-argument self, *, multichannel: Optional[SmbMultichannel] = None, encryption_in_transit: Optional[SmbEncryptionInTransit] = None, - **kwargs: Any + **kwargs: Any, ) -> None: - self.multichannel = multichannel - self.encryption_in_transit = encryption_in_transit + super().__init__(multichannel=multichannel, encryption_in_transit=encryption_in_transit) if self.multichannel is None and self.encryption_in_transit is None: raise ValueError("The value 'multichannel' or 'encryption_in_transit' must be specified.") + def as_dict( + self, + keep_readonly: bool = True, + key_transformer: Optional[Callable[[str, Dict[str, Any], Any], Any]] = None, + **kwargs: Any, + ) -> Dict[str, Any]: + """Return a dict representation of the model. + + :param bool keep_readonly: Whether to include readonly fields. + :param key_transformer: A callable to transform each key serialized + from the model. + :type key_transformer: Optional[Callable[[str, Dict[str, Any], Any], Any]] + :return: A dictionary representation of this model. + :rtype: Dict[str, Any] + """ + return _backcompat_as_dict( + self, + keep_readonly=keep_readonly, + key_transformer=key_transformer, + **kwargs, + ) # type: ignore[return-value] + -class NfsEncryptionInTransit(GeneratedNfsEncryptionInTransit): +class NfsEncryptionInTransit(GeneratedNfsEncryptionInTransit, _ModelBackCompatMixin): """Settings for encryption in transit. :keyword bool required: If encryption in transit is required. @@ -263,11 +408,33 @@ class NfsEncryptionInTransit(GeneratedNfsEncryptionInTransit): required: bool """If encryption in transit is enabled.""" - def __init__(self, *, required: bool, **kwargs: Any) -> None: - self.required = required + def __init__(self, *, required: bool, **kwargs: Any) -> None: # pylint: disable=unused-argument + super().__init__(required=required) + + def as_dict( + self, + keep_readonly: bool = True, + key_transformer: Optional[Callable[[str, Dict[str, Any], Any], Any]] = None, + **kwargs: Any, + ) -> Dict[str, Any]: + """Return a dict representation of the model. + + :param bool keep_readonly: Whether to include readonly fields. + :param key_transformer: A callable to transform each key serialized + from the model. + :type key_transformer: Optional[Callable[[str, Dict[str, Any], Any], Any]] + :return: A dictionary representation of this model. + :rtype: Dict[str, Any] + """ + return _backcompat_as_dict( + self, + keep_readonly=keep_readonly, + key_transformer=key_transformer, + **kwargs, + ) # type: ignore[return-value] -class ShareNfsSettings(GeneratedShareNfsSettings): +class ShareNfsSettings(GeneratedShareNfsSettings, _ModelBackCompatMixin): """Settings for the NFS protocol. :keyword NfsEncryptionInTransit encryption_in_transit: Sets the encryption in transit settings. @@ -276,11 +443,35 @@ class ShareNfsSettings(GeneratedShareNfsSettings): encryption_in_transit: NfsEncryptionInTransit """Sets the encryption in transit settings.""" - def __init__(self, *, encryption_in_transit: NfsEncryptionInTransit, **kwargs: Any) -> None: - self.encryption_in_transit = encryption_in_transit + def __init__( # pylint: disable=unused-argument + self, *, encryption_in_transit: NfsEncryptionInTransit, **kwargs: Any + ) -> None: + super().__init__(encryption_in_transit=encryption_in_transit) + + def as_dict( + self, + keep_readonly: bool = True, + key_transformer: Optional[Callable[[str, Dict[str, Any], Any], Any]] = None, + **kwargs: Any, + ) -> Dict[str, Any]: + """Return a dict representation of the model. + + :param bool keep_readonly: Whether to include readonly fields. + :param key_transformer: A callable to transform each key serialized + from the model. + :type key_transformer: Optional[Callable[[str, Dict[str, Any], Any], Any]] + :return: A dictionary representation of this model. + :rtype: Dict[str, Any] + """ + return _backcompat_as_dict( + self, + keep_readonly=keep_readonly, + key_transformer=key_transformer, + **kwargs, + ) # type: ignore[return-value] -class ShareProtocolSettings(GeneratedShareProtocolSettings): +class ShareProtocolSettings(GeneratedShareProtocolSettings, _ModelBackCompatMixin): """Protocol Settings class used by the set and get service properties methods in the share service. Contains protocol properties of the share service such as the SMB and NFS setting of the share service. @@ -294,21 +485,41 @@ class ShareProtocolSettings(GeneratedShareProtocolSettings): nfs: Optional[ShareNfsSettings] """Sets the NFS settings.""" - def __init__( - self, - *, - smb: Optional[ShareSmbSettings] = None, - nfs: Optional[ShareNfsSettings] = None, - **kwargs: Any + def __init__( # pylint: disable=unused-argument + self, *, smb: Optional[ShareSmbSettings] = None, nfs: Optional[ShareNfsSettings] = None, **kwargs: Any ) -> None: - self.smb = smb - self.nfs = nfs + super().__init__(smb=smb, nfs=nfs) if self.smb is None and self.nfs is None: raise ValueError("The value 'smb' or 'nfs' must be specified.") + def as_dict( + self, + keep_readonly: bool = True, + key_transformer: Optional[Callable[[str, Dict[str, Any], Any], Any]] = None, + **kwargs: Any, + ) -> Dict[str, Any]: + """Return a dict representation of the model. + + :param bool keep_readonly: Whether to include readonly fields. + :param key_transformer: A callable to transform each key serialized + from the model. + :type key_transformer: Optional[Callable[[str, Dict[str, Any], Any], Any]] + :return: A dictionary representation of this model. + :rtype: Dict[str, Any] + """ + return _backcompat_as_dict( + self, + keep_readonly=keep_readonly, + key_transformer=key_transformer, + **kwargs, + ) # type: ignore[return-value] + @classmethod def _from_generated(cls, generated): - return cls(smb=generated.smb, nfs=generated.nfs) + # Handle XML Element by converting to generated model first + if isinstance(generated, ET.Element): + generated = GeneratedShareProtocolSettings(generated) # type: ignore[assignment,call-overload] + return cls(smb=generated.smb, nfs=generated.nfs) # type: ignore[arg-type] class ShareSasPermissions: @@ -346,22 +557,20 @@ class ShareSasPermissions: """The create permission for share SAS.""" def __init__( - self, read: bool = False, - write: bool = False, - delete: bool = False, - list: bool = False, - create: bool = False + self, read: bool = False, write: bool = False, delete: bool = False, list: bool = False, create: bool = False ) -> None: self.read = read self.create = create self.write = write self.delete = delete self.list = list - self._str = (('r' if self.read else '') + - ('c' if self.create else '') + - ('w' if self.write else '') + - ('d' if self.delete else '') + - ('l' if self.list else '')) + self._str = ( + ("r" if self.read else "") + + ("c" if self.create else "") + + ("w" if self.write else "") + + ("d" if self.delete else "") + + ("l" if self.list else "") + ) def __str__(self) -> str: return self._str @@ -379,18 +588,18 @@ def from_string(cls, permission: str) -> Self: :return: A ShareSasPermissions object :rtype: ~azure.storage.fileshare.ShareSasPermissions """ - p_read = 'r' in permission - p_create = 'c' in permission - p_write = 'w' in permission - p_delete = 'd' in permission - p_list = 'l' in permission + p_read = "r" in permission + p_create = "c" in permission + p_write = "w" in permission + p_delete = "d" in permission + p_list = "l" in permission parsed = cls(p_read, p_write, p_delete, p_list, p_create) return parsed -class AccessPolicy(GenAccessPolicy): +class AccessPolicy(GenAccessPolicy, _ModelBackCompatMixin): """Access Policy class used by the set and get acl methods in each service. A stored access policy can specify the start time, expiry time, and @@ -443,13 +652,37 @@ class AccessPolicy(GenAccessPolicy): """The time at which the shared access signature becomes valid.""" def __init__( - self, permission: Optional[Union[ShareSasPermissions, str]] = None, + self, + permission: Optional[Union[ShareSasPermissions, str]] = None, expiry: Optional[Union["datetime", str]] = None, - start: Optional[Union["datetime", str]] = None + start: Optional[Union["datetime", str]] = None, ) -> None: - self.start = start - self.expiry = expiry - self.permission = permission + super().__init__() + self.start = start # type: ignore [assignment] + self.expiry = expiry # type: ignore [assignment] + self.permission = permission # type: ignore [assignment] + + def as_dict( + self, + keep_readonly: bool = True, + key_transformer: Optional[Callable[[str, Dict[str, Any], Any], Any]] = None, + **kwargs: Any, + ) -> Dict[str, Any]: + """Return a dict representation of the model. + + :param bool keep_readonly: Whether to include readonly fields. + :param key_transformer: A callable to transform each key serialized + from the model. + :type key_transformer: Optional[Callable[[str, Dict[str, Any], Any], Any]] + :return: A dictionary representation of this model. + :rtype: Dict[str, Any] + """ + return _backcompat_as_dict( + self, + keep_readonly=keep_readonly, + key_transformer=key_transformer, + **kwargs, + ) # type: ignore[return-value] class LeaseProperties(DictMixin): @@ -463,9 +696,9 @@ class LeaseProperties(DictMixin): """When a file or share is leased, specifies whether the lease is of infinite or fixed duration.""" def __init__(self, **kwargs: Any) -> None: - self.status = get_enum_value(kwargs.get('x-ms-lease-status')) - self.state = get_enum_value(kwargs.get('x-ms-lease-state')) - self.duration = get_enum_value(kwargs.get('x-ms-lease-duration')) + self.status = get_enum_value(kwargs.get("x-ms-lease-status")) + self.state = get_enum_value(kwargs.get("x-ms-lease-state")) + self.duration = get_enum_value(kwargs.get("x-ms-lease-duration")) @classmethod def _from_generated(cls, generated): @@ -516,20 +749,21 @@ class ContentSettings(DictMixin): """The content md5 specified for the file.""" def __init__( - self, content_type: Optional[str] = None, + self, + content_type: Optional[str] = None, content_encoding: Optional[str] = None, content_language: Optional[str] = None, content_disposition: Optional[str] = None, cache_control: Optional[str] = None, content_md5: Optional[bytearray] = None, - **kwargs: Any + **kwargs: Any, ) -> None: - self.content_type = content_type or kwargs.get('Content-Type') - self.content_encoding = content_encoding or kwargs.get('Content-Encoding') - self.content_language = content_language or kwargs.get('Content-Language') - self.content_md5 = content_md5 or kwargs.get('Content-MD5') - self.content_disposition = content_disposition or kwargs.get('Content-Disposition') - self.cache_control = cache_control or kwargs.get('Cache-Control') + self.content_type = content_type or kwargs.get("Content-Type") + self.content_encoding = content_encoding or kwargs.get("Content-Encoding") + self.content_language = content_language or kwargs.get("Content-Language") + self.content_md5 = content_md5 or kwargs.get("Content-MD5") + self.content_disposition = content_disposition or kwargs.get("Content-Disposition") + self.cache_control = cache_control or kwargs.get("Cache-Control") @classmethod def _from_generated(cls, generated): @@ -604,39 +838,40 @@ class ShareProperties(DictMixin): def __init__(self, **kwargs: Any) -> None: self.name = None # type: ignore [assignment] - self.last_modified = kwargs.get('Last-Modified') # type: ignore [assignment] - self.etag = kwargs.get('ETag') # type: ignore [assignment] - self.quota = kwargs.get('x-ms-share-quota') # type: ignore [assignment] - self.access_tier = kwargs.get('x-ms-access-tier') # type: ignore [assignment] - self.next_allowed_quota_downgrade_time = kwargs.get('x-ms-share-next-allowed-quota-downgrade-time') - self.metadata = kwargs.get('metadata') # type: ignore [assignment] + self.last_modified = kwargs.get("Last-Modified") # type: ignore [assignment] + self.etag = kwargs.get("ETag") # type: ignore [assignment] + self.quota = kwargs.get("x-ms-share-quota") # type: ignore [assignment] + self.access_tier = kwargs.get("x-ms-access-tier") # type: ignore [assignment] + self.next_allowed_quota_downgrade_time = kwargs.get("x-ms-share-next-allowed-quota-downgrade-time") + self.metadata = kwargs.get("metadata") # type: ignore [assignment] self.snapshot = None self.deleted = None self.deleted_time = None self.version = None self.remaining_retention_days = None - self.provisioned_egress_mbps = kwargs.get('x-ms-share-provisioned-egress-mbps') - self.provisioned_ingress_mbps = kwargs.get('x-ms-share-provisioned-ingress-mbps') - self.provisioned_iops = kwargs.get('x-ms-share-provisioned-iops') - self.provisioned_bandwidth = kwargs.get('x-ms-share-provisioned-bandwidth-mibps') + self.provisioned_egress_mbps = kwargs.get("x-ms-share-provisioned-egress-mbps") + self.provisioned_ingress_mbps = kwargs.get("x-ms-share-provisioned-ingress-mbps") + self.provisioned_iops = kwargs.get("x-ms-share-provisioned-iops") + self.provisioned_bandwidth = kwargs.get("x-ms-share-provisioned-bandwidth-mibps") self.lease = LeaseProperties(**kwargs) enabled_protocols = kwargs.get("x-ms-enabled-protocols", None) if enabled_protocols is not None: - self.protocols = [protocol.strip() for protocol in enabled_protocols.split(',')] + self.protocols = [protocol.strip() for protocol in enabled_protocols.split(",")] else: self.protocols = None - self.root_squash = kwargs.get('x-ms-root-squash', None) - self.enable_snapshot_virtual_directory_access = \ - kwargs.get('x-ms-enable-snapshot-virtual-directory-access') - self.paid_bursting_enabled = kwargs.get('x-ms-share-paid-bursting-enabled') - self.paid_bursting_bandwidth_mibps = kwargs.get('x-ms-share-paid-bursting-max-bandwidth-mibps') - self.paid_bursting_iops = kwargs.get('x-ms-share-paid-bursting-max-iops') - self.included_burst_iops = kwargs.get('x-ms-share-included-burst-iops') - self.max_burst_credits_for_iops = kwargs.get('x-ms-share-max-burst-credits-for-iops') - self.next_provisioned_iops_downgrade = ( # pylint: disable=name-too-long - kwargs.get('x-ms-share-next-allowed-provisioned-iops-downgrade-time')) - self.next_provisioned_bandwidth_downgrade = ( # pylint: disable=name-too-long - kwargs.get('x-ms-share-next-allowed-provisioned-bandwidth-downgrade-time')) + self.root_squash = kwargs.get("x-ms-root-squash", None) + self.enable_snapshot_virtual_directory_access = kwargs.get("x-ms-enable-snapshot-virtual-directory-access") + self.paid_bursting_enabled = kwargs.get("x-ms-share-paid-bursting-enabled") + self.paid_bursting_bandwidth_mibps = kwargs.get("x-ms-share-paid-bursting-max-bandwidth-mibps") + self.paid_bursting_iops = kwargs.get("x-ms-share-paid-bursting-max-iops") + self.included_burst_iops = kwargs.get("x-ms-share-included-burst-iops") + self.max_burst_credits_for_iops = kwargs.get("x-ms-share-max-burst-credits-for-iops") + self.next_provisioned_iops_downgrade = kwargs.get( # pylint: disable=name-too-long + "x-ms-share-next-allowed-provisioned-iops-downgrade-time" + ) + self.next_provisioned_bandwidth_downgrade = kwargs.get( # pylint: disable=name-too-long + "x-ms-share-next-allowed-provisioned-bandwidth-downgrade-time" + ) @classmethod def _from_generated(cls, generated): @@ -658,8 +893,11 @@ def _from_generated(cls, generated): props.provisioned_iops = generated.properties.provisioned_iops props.provisioned_bandwidth = generated.properties.provisioned_bandwidth_mi_bps props.lease = LeaseProperties._from_generated(generated) # pylint: disable=protected-access - props.protocols = [protocol.strip() for protocol in generated.properties.enabled_protocols.split(',')]\ - if generated.properties.enabled_protocols else None + props.protocols = ( + [protocol.strip() for protocol in generated.properties.enabled_protocols.split(",")] + if generated.properties.enabled_protocols + else None + ) props.root_squash = generated.properties.root_squash props.enable_snapshot_virtual_directory_access = generated.properties.enable_snapshot_virtual_directory_access props.paid_bursting_enabled = generated.properties.paid_bursting_enabled @@ -668,9 +906,11 @@ def _from_generated(cls, generated): props.included_burst_iops = generated.properties.included_burst_iops props.max_burst_credits_for_iops = generated.properties.max_burst_credits_for_iops props.next_provisioned_iops_downgrade = ( # pylint: disable=name-too-long - generated.properties.next_allowed_provisioned_iops_downgrade_time) + generated.properties.next_allowed_provisioned_iops_downgrade_time + ) props.next_provisioned_bandwidth_downgrade = ( # pylint: disable=name-too-long - generated.properties.next_allowed_provisioned_bandwidth_downgrade_time) + generated.properties.next_allowed_provisioned_bandwidth_downgrade_time + ) return props @@ -699,15 +939,14 @@ class SharePropertiesPaged(PageIterator): """The current page of listed results.""" def __init__( - self, command: Callable, + self, + command: Callable, prefix: Optional[str] = None, results_per_page: Optional[int] = None, - continuation_token: Optional[str] = None + continuation_token: Optional[str] = None, ) -> None: super(SharePropertiesPaged, self).__init__( - get_next=self._get_next_cb, - extract_data=self._extract_data_cb, - continuation_token=continuation_token or "" + get_next=self._get_next_cb, extract_data=self._extract_data_cb, continuation_token=continuation_token or "" ) self._command = command self.service_endpoint = None @@ -724,7 +963,8 @@ def _get_next_cb(self, continuation_token): maxresults=self.results_per_page, prefix=self.prefix, cls=return_context_and_deserialized, - use_location=self.location_mode) + use_location=self.location_mode, + ) except HttpResponseError as error: process_storage_error(error) @@ -734,7 +974,9 @@ def _extract_data_cb(self, get_next_return): self.prefix = self._response.prefix self.marker = self._response.marker self.results_per_page = self._response.max_results - self.current_page = [ShareProperties._from_generated(i) for i in self._response.share_items] # pylint: disable=protected-access + self.current_page = [ + ShareProperties._from_generated(i) for i in self._response.share_items # pylint: disable=protected-access + ] return self._response.next_marker or None, self.current_page @@ -775,20 +1017,20 @@ class Handle(DictMixin): """Time when the session that previously opened the handle was last been reconnected. (UTC)""" last_reconnect_time: Optional["datetime"] """Time handle that was last connected to. (UTC)""" - access_rights: List[Literal['Read', 'Write', 'Delete']] + access_rights: List[Literal["Read", "Write", "Delete"]] """Access rights of the handle.""" def __init__(self, **kwargs: Any) -> None: - self.client_name = kwargs.get('client_name') # type: ignore [assignment] - self.id = kwargs.get('handle_id') # type: ignore [assignment] - self.path = kwargs.get('path') # type: ignore [assignment] - self.file_id = kwargs.get('file_id') # type: ignore [assignment] - self.parent_id = kwargs.get('parent_id') # type: ignore [assignment] - self.session_id = kwargs.get('session_id') # type: ignore [assignment] - self.client_ip = kwargs.get('client_ip') # type: ignore [assignment] - self.open_time = kwargs.get('open_time') # type: ignore [assignment] - self.last_reconnect_time = kwargs.get('last_reconnect_time') - self.access_rights = kwargs.get('access_right_list') # type: ignore [assignment] + self.client_name = kwargs.get("client_name") # type: ignore [assignment] + self.id = kwargs.get("handle_id") # type: ignore [assignment] + self.path = kwargs.get("path") # type: ignore [assignment] + self.file_id = kwargs.get("file_id") # type: ignore [assignment] + self.parent_id = kwargs.get("parent_id") # type: ignore [assignment] + self.session_id = kwargs.get("session_id") # type: ignore [assignment] + self.client_ip = kwargs.get("client_ip") # type: ignore [assignment] + self.open_time = kwargs.get("open_time") # type: ignore [assignment] + self.last_reconnect_time = kwargs.get("last_reconnect_time") + self.access_rights = kwargs.get("access_right_list") # type: ignore [assignment] @classmethod def _from_generated(cls, generated): @@ -825,14 +1067,10 @@ class HandlesPaged(PageIterator): """The current page of listed results.""" def __init__( - self, command: Callable, - results_per_page: Optional[int] = None, - continuation_token: Optional[str] = None + self, command: Callable, results_per_page: Optional[int] = None, continuation_token: Optional[str] = None ) -> None: super(HandlesPaged, self).__init__( - get_next=self._get_next_cb, - extract_data=self._extract_data_cb, - continuation_token=continuation_token or "" + get_next=self._get_next_cb, extract_data=self._extract_data_cb, continuation_token=continuation_token or "" ) self._command = command self.marker = None @@ -846,13 +1084,16 @@ def _get_next_cb(self, continuation_token): marker=continuation_token or None, maxresults=self.results_per_page, cls=return_context_and_deserialized, - use_location=self.location_mode) + use_location=self.location_mode, + ) except HttpResponseError as error: process_storage_error(error) def _extract_data_cb(self, get_next_return): self.location_mode, self._response = get_next_return - self.current_page = [Handle._from_generated(h) for h in self._response.handle_list] # pylint: disable=protected-access + self.current_page = [ + Handle._from_generated(h) for h in self._response.handle_list # pylint: disable=protected-access + ] return self._response.next_marker or None, self.current_page @@ -884,7 +1125,8 @@ class NTFSAttributes: """Enable/disable 'NoScrubData' attribute for DIRECTORY.""" def __init__( - self, read_only: bool = False, + self, + read_only: bool = False, hidden: bool = False, system: bool = False, none: bool = False, @@ -893,7 +1135,7 @@ def __init__( temporary: bool = False, offline: bool = False, not_content_indexed: bool = False, - no_scrub_data: bool = False + no_scrub_data: bool = False, ) -> None: self.read_only = read_only self.hidden = hidden @@ -905,20 +1147,22 @@ def __init__( self.offline = offline self.not_content_indexed = not_content_indexed self.no_scrub_data = no_scrub_data - self._str = (('ReadOnly|' if self.read_only else '') + - ('Hidden|' if self.hidden else '') + - ('System|' if self.system else '') + - ('None|' if self.none else '') + - ('Directory|' if self.directory else '') + - ('Archive|' if self.archive else '') + - ('Temporary|' if self.temporary else '') + - ('Offline|' if self.offline else '') + - ('NotContentIndexed|' if self.not_content_indexed else '') + - ('NoScrubData|' if self.no_scrub_data else '')) + self._str = ( + ("ReadOnly|" if self.read_only else "") + + ("Hidden|" if self.hidden else "") + + ("System|" if self.system else "") + + ("None|" if self.none else "") + + ("Directory|" if self.directory else "") + + ("Archive|" if self.archive else "") + + ("Temporary|" if self.temporary else "") + + ("Offline|" if self.offline else "") + + ("NotContentIndexed|" if self.not_content_indexed else "") + + ("NoScrubData|" if self.no_scrub_data else "") + ) def __str__(self): concatenated_params = self._str - return concatenated_params.strip('|') + return concatenated_params.strip("|") @classmethod def from_string(cls, string: str) -> Self: @@ -942,8 +1186,9 @@ def from_string(cls, string: str) -> Self: not_content_indexed = "NotContentIndexed" in string no_scrub_data = "NoScrubData" in string - parsed = cls(read_only, hidden, system, none, directory, archive, temporary, offline, not_content_indexed, - no_scrub_data) + parsed = cls( + read_only, hidden, system, none, directory, archive, temporary, offline, not_content_indexed, no_scrub_data + ) parsed._str = string return parsed @@ -985,31 +1230,40 @@ class DirectoryProperties(DictMixin): """NFS only. The owning group of the directory.""" file_mode: Optional[str] = None """NFS only. The file mode of the directory.""" - nfs_file_type: Optional[Literal['Directory']] = None + nfs_file_type: Optional[Literal["Directory"]] = None """NFS only. The type of the directory.""" def __init__(self, **kwargs: Any) -> None: self.name = None # type: ignore [assignment] - self.last_modified = kwargs.get('Last-Modified') # type: ignore [assignment] - self.etag = kwargs.get('ETag') # type: ignore [assignment] - self.server_encrypted = kwargs.get('x-ms-server-encrypted') # type: ignore [assignment] - self.metadata = kwargs.get('metadata') # type: ignore [assignment] - self.change_time = Deserializer.deserialize_iso(kwargs.get('x-ms-file-change-time')) if ( - kwargs.get('x-ms-file-change-time') is not None) else None - self.creation_time = Deserializer.deserialize_iso(kwargs.get('x-ms-file-creation-time')) if ( - kwargs.get('x-ms-file-creation-time') is not None) else None - self.last_write_time = Deserializer.deserialize_iso(kwargs.get('x-ms-file-last-write-time')) if ( - kwargs.get('x-ms-file-last-write-time') is not None) else None + self.last_modified = kwargs.get("Last-Modified") # type: ignore [assignment] + self.etag = kwargs.get("ETag") # type: ignore [assignment] + self.server_encrypted = kwargs.get("x-ms-server-encrypted") # type: ignore [assignment] + self.metadata = kwargs.get("metadata") # type: ignore [assignment] + self.change_time = ( + Deserializer.deserialize_iso(kwargs.get("x-ms-file-change-time")) + if (kwargs.get("x-ms-file-change-time") is not None) + else None + ) + self.creation_time = ( + Deserializer.deserialize_iso(kwargs.get("x-ms-file-creation-time")) + if (kwargs.get("x-ms-file-creation-time") is not None) + else None + ) + self.last_write_time = ( + Deserializer.deserialize_iso(kwargs.get("x-ms-file-last-write-time")) + if (kwargs.get("x-ms-file-last-write-time") is not None) + else None + ) self.last_access_time = None - self.file_attributes = kwargs.get('x-ms-file-attributes') # type: ignore [assignment] - self.permission_key = kwargs.get('x-ms-file-permission-key') # type: ignore [assignment] - self.file_id = kwargs.get('x-ms-file-id') # type: ignore [assignment] - self.parent_id = kwargs.get('x-ms-file-parent-id') # type: ignore [assignment] + self.file_attributes = kwargs.get("x-ms-file-attributes") # type: ignore [assignment] + self.permission_key = kwargs.get("x-ms-file-permission-key") # type: ignore [assignment] + self.file_id = kwargs.get("x-ms-file-id") # type: ignore [assignment] + self.parent_id = kwargs.get("x-ms-file-parent-id") # type: ignore [assignment] self.is_directory = True - self.owner = kwargs.get('x-ms-owner') - self.group = kwargs.get('x-ms-group') - self.file_mode = kwargs.get('x-ms-mode') - self.nfs_file_type = kwargs.get('x-ms-file-file-type') + self.owner = kwargs.get("x-ms-owner") + self.group = kwargs.get("x-ms-group") + self.file_mode = kwargs.get("x-ms-mode") + self.nfs_file_type = kwargs.get("x-ms-file-file-type") @classmethod def _from_generated(cls, generated): @@ -1057,15 +1311,14 @@ class DirectoryPropertiesPaged(PageIterator): """The current page of listed results.""" def __init__( - self, command: Callable, + self, + command: Callable, prefix: Optional[str] = None, results_per_page: Optional[int] = None, - continuation_token: Optional[str] = None + continuation_token: Optional[str] = None, ) -> None: super(DirectoryPropertiesPaged, self).__init__( - get_next=self._get_next_cb, - extract_data=self._extract_data_cb, - continuation_token=continuation_token or "" + get_next=self._get_next_cb, extract_data=self._extract_data_cb, continuation_token=continuation_token or "" ) self._command = command self.service_endpoint = None @@ -1082,17 +1335,20 @@ def _get_next_cb(self, continuation_token): prefix=self.prefix, maxresults=self.results_per_page, cls=return_context_and_deserialized, - use_location=self.location_mode) + use_location=self.location_mode, + ) except HttpResponseError as error: process_storage_error(error) def _extract_data_cb(self, get_next_return): + # pylint: disable=protected-access self.location_mode, self._response = get_next_return self.service_endpoint = self._response.service_endpoint self.marker = self._response.marker self.results_per_page = self._response.max_results - self.current_page = [DirectoryProperties._from_generated(i) for i in self._response.segment.directory_items] # pylint: disable = protected-access - self.current_page.extend([FileProperties._from_generated(i) for i in self._response.segment.file_items]) # pylint: disable = protected-access + self.current_page = [DirectoryProperties._from_generated(i) for i in self._response.segment.directory_items] + self.current_page.extend([FileProperties._from_generated(i) for i in self._response.segment.file_items]) + # pylint: enable=protected-access return self._response.next_marker or None, self.current_page @@ -1143,14 +1399,14 @@ class CopyProperties(DictMixin): failed copy attempt.""" def __init__(self, **kwargs: Any) -> None: - self.id = kwargs.get('x-ms-copy-id') # type: ignore [assignment] - self.source = kwargs.get('x-ms-copy-source') - self.status = get_enum_value(kwargs.get('x-ms-copy-status')) - self.progress = kwargs.get('x-ms-copy-progress') - self.completion_time = kwargs.get('x-ms-copy-completion_time') - self.status_description = kwargs.get('x-ms-copy-status-description') - self.incremental_copy = kwargs.get('x-ms-incremental-copy') - self.destination_snapshot = kwargs.get('x-ms-copy-destination-snapshot') + self.id = kwargs.get("x-ms-copy-id") # type: ignore [assignment] + self.source = kwargs.get("x-ms-copy-source") + self.status = get_enum_value(kwargs.get("x-ms-copy-status")) + self.progress = kwargs.get("x-ms-copy-progress") + self.completion_time = kwargs.get("x-ms-copy-completion_time") + self.status_description = kwargs.get("x-ms-copy-status-description") + self.incremental_copy = kwargs.get("x-ms-incremental-copy") + self.destination_snapshot = kwargs.get("x-ms-copy-destination-snapshot") @classmethod def _from_generated(cls, generated): @@ -1226,42 +1482,51 @@ class FileProperties(DictMixin): """NFS only. The file mode of the file.""" link_count: Optional[int] = None """NFS only. The number of hard links of the file.""" - nfs_file_type: Optional[Literal['Regular']] = None + nfs_file_type: Optional[Literal["Regular"]] = None """NFS only. The type of the file.""" def __init__(self, **kwargs: Any) -> None: - self.name = kwargs.get('name') # type: ignore [assignment] + self.name = kwargs.get("name") # type: ignore [assignment] self.path = None self.share = None self.snapshot = None - self.content_length = kwargs.get('Content-Length') # type: ignore [assignment] - self.metadata = kwargs.get('metadata') # type: ignore [assignment] - self.file_type = kwargs.get('x-ms-type') # type: ignore [assignment] - self.last_modified = kwargs.get('Last-Modified') # type: ignore [assignment] - self.etag = kwargs.get('ETag') # type: ignore [assignment] - self.size = kwargs.get('Content-Length') # type: ignore [assignment] - self.content_range = kwargs.get('Content-Range') - self.server_encrypted = kwargs.get('x-ms-server-encrypted') # type: ignore [assignment] + self.content_length = kwargs.get("Content-Length") # type: ignore [assignment] + self.metadata = kwargs.get("metadata") # type: ignore [assignment] + self.file_type = kwargs.get("x-ms-type") # type: ignore [assignment] + self.last_modified = kwargs.get("Last-Modified") # type: ignore [assignment] + self.etag = kwargs.get("ETag") # type: ignore [assignment] + self.size = kwargs.get("Content-Length") # type: ignore [assignment] + self.content_range = kwargs.get("Content-Range") + self.server_encrypted = kwargs.get("x-ms-server-encrypted") # type: ignore [assignment] self.copy = CopyProperties(**kwargs) self.content_settings = ContentSettings(**kwargs) self.lease = LeaseProperties(**kwargs) - self.change_time = Deserializer.deserialize_iso(kwargs.get('x-ms-file-change-time')) if ( - kwargs.get('x-ms-file-change-time') is not None) else None - self.creation_time = Deserializer.deserialize_iso(kwargs.get('x-ms-file-creation-time')) if ( - kwargs.get('x-ms-file-creation-time') is not None) else None - self.last_write_time = Deserializer.deserialize_iso(kwargs.get('x-ms-file-last-write-time')) if ( - kwargs.get('x-ms-file-last-write-time') is not None) else None + self.change_time = ( + Deserializer.deserialize_iso(kwargs.get("x-ms-file-change-time")) + if (kwargs.get("x-ms-file-change-time") is not None) + else None + ) + self.creation_time = ( + Deserializer.deserialize_iso(kwargs.get("x-ms-file-creation-time")) + if (kwargs.get("x-ms-file-creation-time") is not None) + else None + ) + self.last_write_time = ( + Deserializer.deserialize_iso(kwargs.get("x-ms-file-last-write-time")) + if (kwargs.get("x-ms-file-last-write-time") is not None) + else None + ) self.last_access_time = None - self.file_attributes = kwargs.get('x-ms-file-attributes') # type: ignore [assignment] - self.permission_key = kwargs.get('x-ms-file-permission-key') # type: ignore [assignment] - self.file_id = kwargs.get('x-ms-file-id') # type: ignore [assignment] - self.parent_id = kwargs.get('x-ms-file-parent-id') + self.file_attributes = kwargs.get("x-ms-file-attributes") # type: ignore [assignment] + self.permission_key = kwargs.get("x-ms-file-permission-key") # type: ignore [assignment] + self.file_id = kwargs.get("x-ms-file-id") # type: ignore [assignment] + self.parent_id = kwargs.get("x-ms-file-parent-id") self.is_directory = False - self.owner = kwargs.get('x-ms-owner') - self.group = kwargs.get('x-ms-group') - self.file_mode = kwargs.get('x-ms-mode') - self.link_count = kwargs.get('x-ms-link-count') - self.nfs_file_type = kwargs.get('x-ms-file-file-type') + self.owner = kwargs.get("x-ms-owner") + self.group = kwargs.get("x-ms-group") + self.file_mode = kwargs.get("x-ms-mode") + self.link_count = kwargs.get("x-ms-link-count") + self.nfs_file_type = kwargs.get("x-ms-file-file-type") @classmethod def _from_generated(cls, generated): @@ -1282,6 +1547,7 @@ def _from_generated(cls, generated): class ShareProtocols(str, Enum, metaclass=CaseInsensitiveEnumMeta): """Enabled protocols on the share""" + SMB = "SMB" NFS = "NFS" @@ -1311,20 +1577,17 @@ class FileSasPermissions: delete: bool = False """Delete the file.""" - def __init__( - self, read: bool = False, - create: bool = False, - write: bool = False, - delete: bool = False - ) -> None: + def __init__(self, read: bool = False, create: bool = False, write: bool = False, delete: bool = False) -> None: self.read = read self.create = create self.write = write self.delete = delete - self._str = (('r' if self.read else '') + - ('c' if self.create else '') + - ('w' if self.write else '') + - ('d' if self.delete else '')) + self._str = ( + ("r" if self.read else "") + + ("c" if self.create else "") + + ("w" if self.write else "") + + ("d" if self.delete else "") + ) def __str__(self): return self._str @@ -1342,10 +1605,10 @@ def from_string(cls, permission: str) -> Self: :return: A FileSasPermissions object :rtype: ~azure.storage.fileshare.FileSasPermissions """ - p_read = 'r' in permission - p_create = 'c' in permission - p_write = 'w' in permission - p_delete = 'd' in permission + p_read = "r" in permission + p_create = "c" in permission + p_write = "w" in permission + p_delete = "d" in permission parsed = cls(p_read, p_create, p_write, p_delete) @@ -1353,9 +1616,12 @@ def from_string(cls, permission: str) -> Self: def service_properties_deserialize(generated: GeneratedStorageServiceProperties) -> Dict[str, Any]: + # Handle XML Element by converting to generated model first + if isinstance(generated, ET.Element): + generated = GeneratedStorageServiceProperties(generated) # type: ignore[assignment,call-overload] return { - 'hour_metrics': Metrics._from_generated(generated.hour_metrics), # pylint: disable=protected-access - 'minute_metrics': Metrics._from_generated(generated.minute_metrics), # pylint: disable=protected-access - 'cors': [CorsRule._from_generated(cors) for cors in generated.cors], # type: ignore [union-attr] # pylint: disable=protected-access - 'protocol': ShareProtocolSettings._from_generated(generated.protocol), # pylint: disable=protected-access + "hour_metrics": Metrics._from_generated(generated.hour_metrics), # pylint: disable=protected-access + "minute_metrics": Metrics._from_generated(generated.minute_metrics), # pylint: disable=protected-access + "cors": [CorsRule._from_generated(cors) for cors in generated.cors], # type: ignore [union-attr] # pylint: disable=protected-access + "protocol": ShareProtocolSettings._from_generated(generated.protocol), # pylint: disable=protected-access } diff --git a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_parser.py b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_parser.py index 6b3142cadd82..a1635d1439b4 100644 --- a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_parser.py +++ b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_parser.py @@ -9,15 +9,16 @@ from ._generated._utils.serialization import Serializer -_ERROR_TOO_MANY_FILE_PERMISSIONS = 'file_permission and file_permission_key should not be set at the same time' -_FILE_PERMISSION_TOO_LONG = 'Size of file_permission is too large. file_permission should be <=8KB, else' \ - 'please use file_permission_key' +_ERROR_TOO_MANY_FILE_PERMISSIONS = "file_permission and file_permission_key should not be set at the same time" +_FILE_PERMISSION_TOO_LONG = ( + "Size of file_permission is too large. file_permission should be <=8KB, else please use file_permission_key" +) def _get_file_permission(file_permission, file_permission_key, default_permission): # if file_permission and file_permission_key are both empty, then use the default_permission # value as file permission, file_permission size should be <= 8KB, else file permission_key should be used - if file_permission and len(str(file_permission).encode('utf-8')) > 8 * 1024: + if file_permission and len(str(file_permission).encode("utf-8")) > 8 * 1024: raise ValueError(_FILE_PERMISSION_TOO_LONG) if not file_permission: @@ -50,11 +51,27 @@ def _datetime_to_str(datetime_obj): def _parse_snapshot( - snapshot: Optional[Union[str, Dict[str, Any]]] = None, - path_snapshot: Optional[str] = None + snapshot: Optional[Union[str, Dict[str, Any]]] = None, path_snapshot: Optional[str] = None ) -> Optional[str]: - if hasattr(snapshot, 'snapshot'): + if hasattr(snapshot, "snapshot"): return snapshot.snapshot # type: ignore if isinstance(snapshot, Dict): - return cast(str, snapshot['snapshot']) + return cast(str, snapshot["snapshot"]) return snapshot or path_snapshot + + +def _strip_snapshot_from_url(url: str) -> str: + """Strip sharesnapshot and snapshot query params from a URL. + + The generated client should receive a base URL without snapshot params, + since snapshots are passed per-operation. + + :param str url: The full URL possibly containing snapshot query params. + :return: The URL with sharesnapshot and snapshot query params removed. + :rtype: str + """ + if "?" not in url: + return url + base, qs = url.split("?", 1) + filtered = "&".join(part for part in qs.split("&") if not part.startswith(("sharesnapshot=", "snapshot="))) + return f"{base}?{filtered}" if filtered else base diff --git a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_serialize.py b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_serialize.py index 6f62fabe6b52..b53ccf9fecc9 100644 --- a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_serialize.py +++ b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_serialize.py @@ -9,13 +9,6 @@ from azure.core import MatchConditions from ._parser import _datetime_to_str, _get_file_permission -from ._generated.models import ( - SourceModifiedAccessConditions, - LeaseAccessConditions, - SourceLeaseAccessConditions, - DestinationLeaseAccessConditions, - CopyFileSmbInfo -) if TYPE_CHECKING: from ._lease import ShareLeaseClient @@ -23,43 +16,41 @@ _SUPPORTED_API_VERSIONS = [ - '2019-02-02', - '2019-07-07', - '2019-10-10', - '2019-12-12', - '2020-02-10', - '2020-04-08', - '2020-06-12', - '2020-08-04', - '2020-10-02', - '2020-12-06', - '2021-02-12', - '2021-04-10', - '2021-06-08', - '2021-08-06', - '2021-12-02', - '2022-11-02', - '2023-01-03', - '2023-05-03', - '2023-08-03', - '2023-11-03', - '2024-05-04', - '2024-08-04', - '2024-11-04', - '2025-01-05', - '2025-05-05', - '2025-07-05', - '2025-11-05', - '2026-02-06', - '2026-04-06', - '2026-06-06', + "2019-02-02", + "2019-07-07", + "2019-10-10", + "2019-12-12", + "2020-02-10", + "2020-04-08", + "2020-06-12", + "2020-08-04", + "2020-10-02", + "2020-12-06", + "2021-02-12", + "2021-04-10", + "2021-06-08", + "2021-08-06", + "2021-12-02", + "2022-11-02", + "2023-01-03", + "2023-05-03", + "2023-08-03", + "2023-11-03", + "2024-05-04", + "2024-08-04", + "2024-11-04", + "2025-01-05", + "2025-05-05", + "2025-07-05", + "2025-11-05", + "2026-02-06", + "2026-04-06", + "2026-06-06", ] def _get_match_headers( - kwargs: Dict[str, Any], - match_param: str, - etag_param: str + kwargs: Dict[str, Any], match_param: str, etag_param: str ) -> Tuple[Optional[str], Optional[str]]: if_match = None if_none_match = None @@ -69,13 +60,13 @@ def _get_match_headers( if not if_match: raise ValueError(f"'{match_param}' specified without '{etag_param}'.") elif match_condition == MatchConditions.IfPresent: - if_match = '*' + if_match = "*" elif match_condition == MatchConditions.IfModified: if_none_match = kwargs.pop(etag_param, None) if not if_none_match: raise ValueError(f"'{match_param}' specified without '{etag_param}'.") elif match_condition == MatchConditions.IfMissing: - if_none_match = '*' + if_none_match = "*" elif match_condition is None: if etag_param in kwargs: raise ValueError(f"'{etag_param}' specified without '{match_param}'.") @@ -84,61 +75,74 @@ def _get_match_headers( return if_match, if_none_match -def get_source_conditions(kwargs: Dict[str, Any]) -> SourceModifiedAccessConditions: - if_match, if_none_match = _get_match_headers(kwargs, 'source_match_condition', 'source_etag') - return SourceModifiedAccessConditions( - source_if_modified_since=kwargs.pop('source_if_modified_since', None), - source_if_unmodified_since=kwargs.pop('source_if_unmodified_since', None), - source_if_match=if_match or kwargs.pop('source_if_match', None), - source_if_none_match=if_none_match or kwargs.pop('source_if_none_match', None) - ) +def get_source_conditions(kwargs: Dict[str, Any]) -> Dict[str, Any]: + if_match, if_none_match = _get_match_headers(kwargs, "source_match_condition", "source_etag") + return { + "source_if_modified_since": kwargs.pop("source_if_modified_since", None), + "source_if_unmodified_since": kwargs.pop("source_if_unmodified_since", None), + "source_if_match": if_match or kwargs.pop("source_if_match", None), + "source_if_none_match": if_none_match or kwargs.pop("source_if_none_match", None), + } -def get_access_conditions( - lease: Optional[Union["ShareLeaseClient", "ShareLeaseClientAsync", str]] -) -> Optional[LeaseAccessConditions]: +def get_access_conditions(lease: Optional[Union["ShareLeaseClient", "ShareLeaseClientAsync", str]]) -> Optional[str]: + """Extract lease_id from a lease client or string. Returns the lease_id string or None. + + :param lease: A lease client or string lease ID. + :type lease: ~azure.storage.fileshare.ShareLeaseClient or str or None + :returns: The lease ID or None. + :rtype: str or None + """ if lease is None: return None if hasattr(lease, "id"): - lease_id = lease.id - else: - lease_id = lease - return LeaseAccessConditions(lease_id=lease_id) + return lease.id + return lease def get_source_access_conditions( - lease: Optional[Union["ShareLeaseClient", "ShareLeaseClientAsync", str]] -) -> Optional[SourceLeaseAccessConditions]: + lease: Optional[Union["ShareLeaseClient", "ShareLeaseClientAsync", str]], +) -> Optional[str]: + """Extract source_lease_id from a lease client or string. Returns the lease_id string or None. + + :param lease: A lease client or string lease ID. + :type lease: ~azure.storage.fileshare.ShareLeaseClient or str or None + :returns: The lease ID or None. + :rtype: str or None + """ if lease is None: return None if hasattr(lease, "id"): - lease_id = lease.id - else: - lease_id = lease - return SourceLeaseAccessConditions(source_lease_id=lease_id) + return lease.id + return lease def get_dest_access_conditions( - lease: Optional[Union["ShareLeaseClient", "ShareLeaseClientAsync", str]] -) -> Optional[DestinationLeaseAccessConditions]: + lease: Optional[Union["ShareLeaseClient", "ShareLeaseClientAsync", str]], +) -> Optional[str]: + """Extract destination_lease_id from a lease client or string. Returns the lease_id string or None. + + :param lease: A lease client or string lease ID. + :type lease: ~azure.storage.fileshare.ShareLeaseClient or str or None + :returns: The lease ID or None. + :rtype: str or None + """ if lease is None: return None if hasattr(lease, "id"): - lease_id = lease.id - else: - lease_id = lease - return DestinationLeaseAccessConditions(destination_lease_id=lease_id) + return lease.id + return lease def get_smb_properties(kwargs: Dict[str, Any]) -> Dict[str, Any]: - ignore_read_only = kwargs.pop('ignore_read_only', None) - set_archive_attribute = kwargs.pop('set_archive_attribute', None) - file_permission = kwargs.pop('file_permission', None) - file_permission_key = kwargs.pop('permission_key', None) - file_attributes = kwargs.pop('file_attributes', None) - file_creation_time = kwargs.pop('file_creation_time', None) - file_last_write_time = kwargs.pop('file_last_write_time', None) - file_change_time = kwargs.pop('file_change_time', None) + ignore_read_only = kwargs.pop("ignore_read_only", None) + set_archive_attribute = kwargs.pop("set_archive_attribute", None) + file_permission = kwargs.pop("file_permission", None) + file_permission_key = kwargs.pop("permission_key", None) + file_attributes = kwargs.pop("file_attributes", None) + file_creation_time = kwargs.pop("file_creation_time", None) + file_last_write_time = kwargs.pop("file_last_write_time", None) + file_change_time = kwargs.pop("file_change_time", None) file_permission_copy_mode = None file_permission = _get_file_permission(file_permission, file_permission_key, None) @@ -156,45 +160,41 @@ def get_smb_properties(kwargs: Dict[str, Any]) -> Dict[str, Any]: else: file_permission_copy_mode = "override" return { - 'file_permission': file_permission, - 'file_permission_key': file_permission_key, - 'copy_file_smb_info': CopyFileSmbInfo( - file_permission_copy_mode=file_permission_copy_mode, - ignore_read_only=ignore_read_only, - file_attributes=file_attributes, - file_creation_time=_datetime_to_str(file_creation_time), - file_last_write_time=_datetime_to_str(file_last_write_time), - file_change_time=_datetime_to_str(file_change_time), - set_archive_attribute=set_archive_attribute - ) - + "file_permission": file_permission, + "file_permission_key": file_permission_key, + "file_permission_copy_mode": file_permission_copy_mode, + "ignore_read_only": ignore_read_only, + "file_attributes": file_attributes, + "file_creation_time": _datetime_to_str(file_creation_time), + "file_last_write_time": _datetime_to_str(file_last_write_time), + "file_change_time": _datetime_to_str(file_change_time), + "set_archive_attribute": set_archive_attribute, } def get_rename_smb_properties(kwargs: Dict[str, Any]) -> Dict[str, Any]: - file_permission = kwargs.pop('file_permission', None) - file_permission_key = kwargs.pop('permission_key', None) - file_attributes = kwargs.pop('file_attributes', None) - file_creation_time = kwargs.pop('file_creation_time', None) - file_last_write_time = kwargs.pop('file_last_write_time', None) - file_change_time = kwargs.pop('file_change_time', None) + file_permission = kwargs.pop("file_permission", None) + file_permission_key = kwargs.pop("permission_key", None) + file_attributes = kwargs.pop("file_attributes", None) + file_creation_time = kwargs.pop("file_creation_time", None) + file_last_write_time = kwargs.pop("file_last_write_time", None) + file_change_time = kwargs.pop("file_change_time", None) file_permission = _get_file_permission(file_permission, file_permission_key, None) return { - 'file_permission': file_permission, - 'file_permission_key': file_permission_key, - 'copy_file_smb_info': CopyFileSmbInfo( - file_attributes=file_attributes, - file_creation_time=_datetime_to_str(file_creation_time), - file_last_write_time=_datetime_to_str(file_last_write_time), - file_change_time=_datetime_to_str(file_change_time) - )} + "file_permission": file_permission, + "file_permission_key": file_permission_key, + "file_attributes": file_attributes, + "file_creation_time": _datetime_to_str(file_creation_time), + "file_last_write_time": _datetime_to_str(file_last_write_time), + "file_change_time": _datetime_to_str(file_change_time), + } def get_api_version(kwargs: Dict[str, Any]) -> str: - api_version = kwargs.get('api_version', None) + api_version = kwargs.get("api_version", None) if api_version and api_version not in _SUPPORTED_API_VERSIONS: - versions = '\n'.join(_SUPPORTED_API_VERSIONS) + versions = "\n".join(_SUPPORTED_API_VERSIONS) raise ValueError(f"Unsupported API version '{api_version}'. Please select from:\n{versions}") return api_version or _SUPPORTED_API_VERSIONS[-1] diff --git a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_share_client.py b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_share_client.py index f5815256d02a..882471d3ebd3 100644 --- a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_share_client.py +++ b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_share_client.py @@ -1,3 +1,4 @@ +# pylint: disable=too-many-lines # ------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for @@ -5,10 +6,7 @@ # -------------------------------------------------------------------------- # pylint: disable=docstring-keyword-should-match-keyword-only -from typing import ( - Any, cast, Dict, Literal, Optional, Union, - TYPE_CHECKING -) +from typing import Any, cast, Dict, Literal, Optional, Union, TYPE_CHECKING from typing_extensions import Self from azure.core.exceptions import HttpResponseError @@ -18,30 +16,16 @@ from ._deserialize import deserialize_permission, deserialize_share_properties from ._directory_client import ShareDirectoryClient from ._file_client import ShareFileClient -from ._generated import AzureFileStorage -from ._generated.models import ( - DeleteSnapshotsOptionType, - ShareStats, - SignedIdentifier -) +from ._generated import FileClient as AzureFileStorage +from ._generated.models import DeleteSnapshotsOptionType, ShareStats, SignedIdentifier, SignedIdentifiers from ._lease import ShareLeaseClient from ._models import ShareProtocols -from ._parser import _parse_snapshot +from ._parser import _parse_snapshot, _strip_snapshot_from_url from ._serialize import get_access_conditions, get_api_version -from ._share_client_helpers import ( - _create_permission_for_share_options, - _format_url, - _from_share_url, - _parse_url -) +from ._share_client_helpers import _create_permission_for_share_options, _format_url, _from_share_url, _parse_url from ._shared.base_client import parse_connection_str, parse_query, StorageAccountHostsMixin, TransportWrapper from ._shared.request_handlers import add_metadata_headers, serialize_iso -from ._shared.response_handlers import ( - process_storage_error, - return_headers_and_deserialized, - return_response_headers -) - +from ._shared.response_handlers import process_storage_error, return_headers_and_deserialized, return_response_headers if TYPE_CHECKING: from azure.core.credentials import AzureNamedKeyCredential, AzureSasCredential, TokenCredential @@ -101,39 +85,40 @@ class ShareClient(StorageAccountHostsMixin): # pylint: disable=too-many-public- The hostname of the secondary endpoint. :keyword int max_range_size: The maximum range size used for a file upload. Defaults to 4*1024*1024. """ + def __init__( - self, account_url: str, + self, + account_url: str, share_name: str, snapshot: Optional[Union[str, Dict[str, Any]]] = None, - credential: Optional[Union[str, Dict[str, str], "AzureNamedKeyCredential", "AzureSasCredential", "TokenCredential"]] = None, # pylint: disable=line-too-long + credential: Optional[ + Union[str, Dict[str, str], "AzureNamedKeyCredential", "AzureSasCredential", "TokenCredential"] + ] = None, # pylint: disable=line-too-long *, - token_intent: Optional[Literal['backup']] = None, + token_intent: Optional[Literal["backup"]] = None, **kwargs: Any ) -> None: - if hasattr(credential, 'get_token') and not token_intent: + if hasattr(credential, "get_token") and not token_intent: raise ValueError("'token_intent' keyword is required when 'credential' is an TokenCredential.") parsed_url = _parse_url(account_url, share_name) path_snapshot, sas_token = parse_query(parsed_url.query) if not sas_token and not credential: raise ValueError( - 'You need to provide either an account shared key or SAS token when creating a storage service.') + "You need to provide either an account shared key or SAS token when creating a storage service." + ) self.snapshot = _parse_snapshot(snapshot, path_snapshot) self.share_name = share_name self._query_str, credential = self._format_query_string( - sas_token=sas_token, credential=credential, share_snapshot=self.snapshot) - super(ShareClient, self).__init__( - parsed_url=parsed_url, service='file-share', credential=credential, **kwargs) - self.allow_trailing_dot = kwargs.pop('allow_trailing_dot', None) - self.allow_source_trailing_dot = kwargs.pop('allow_source_trailing_dot', None) + sas_token=sas_token, credential=credential, share_snapshot=self.snapshot + ) + super(ShareClient, self).__init__(parsed_url=parsed_url, service="file-share", credential=credential, **kwargs) + self.allow_trailing_dot = kwargs.pop("allow_trailing_dot", None) + self.allow_source_trailing_dot = kwargs.pop("allow_source_trailing_dot", None) self.file_request_intent = token_intent self._client = AzureFileStorage( + url=_strip_snapshot_from_url(self.url), version=get_api_version(kwargs), - url=self.url, - base_url=self.url, pipeline=self._pipeline, - allow_trailing_dot=self.allow_trailing_dot, - allow_source_trailing_dot=self.allow_source_trailing_dot, - file_request_intent=self.file_request_intent ) def __enter__(self) -> Self: @@ -154,9 +139,12 @@ def close(self) -> None: @classmethod def from_share_url( - cls, share_url: str, + cls, + share_url: str, snapshot: Optional[Union[str, Dict[str, Any]]] = None, - credential: Optional[Union[str, Dict[str, str], "AzureNamedKeyCredential", "AzureSasCredential", "TokenCredential"]] = None, # pylint: disable=line-too-long + credential: Optional[ + Union[str, Dict[str, str], "AzureNamedKeyCredential", "AzureSasCredential", "TokenCredential"] + ] = None, # pylint: disable=line-too-long **kwargs: Any ) -> Self: """ @@ -197,10 +185,13 @@ def _format_url(self, hostname: str) -> str: @classmethod def from_connection_string( - cls, conn_str: str, + cls, + conn_str: str, share_name: str, snapshot: Optional[Union[str, Dict[str, Any]]] = None, - credential: Optional[Union[str, Dict[str, str], "AzureNamedKeyCredential", "AzureSasCredential", "TokenCredential"]] = None, # pylint: disable=line-too-long + credential: Optional[ + Union[str, Dict[str, str], "AzureNamedKeyCredential", "AzureSasCredential", "TokenCredential"] + ] = None, # pylint: disable=line-too-long **kwargs: Any ) -> Self: """Create ShareClient from a Connection String. @@ -238,11 +229,10 @@ def from_connection_string( :dedent: 8 :caption: Gets the share client from connection string. """ - account_url, secondary, credential = parse_connection_str(conn_str, credential, 'file') - if 'secondary_hostname' not in kwargs: - kwargs['secondary_hostname'] = secondary - return cls( - account_url, share_name=share_name, snapshot=snapshot, credential=credential, **kwargs) + account_url, secondary, credential = parse_connection_str(conn_str, credential, "file") + if "secondary_hostname" not in kwargs: + kwargs["secondary_hostname"] = secondary + return cls(account_url, share_name=share_name, snapshot=snapshot, credential=credential, **kwargs) def get_directory_client(self, directory_path: Optional[str] = None) -> ShareDirectoryClient: """Get a client to interact with the specified directory. @@ -255,15 +245,24 @@ def get_directory_client(self, directory_path: Optional[str] = None) -> ShareDir """ _pipeline = Pipeline( transport=TransportWrapper(self._pipeline._transport), # pylint: disable=protected-access - policies=self._pipeline._impl_policies # pylint: disable=protected-access + policies=self._pipeline._impl_policies, # pylint: disable=protected-access ) return ShareDirectoryClient( - self.url, share_name=self.share_name, directory_path=directory_path or "", snapshot=self.snapshot, - credential=self.credential, token_intent=self.file_request_intent, api_version=self.api_version, - _hosts=self._hosts, _configuration=self._config, _pipeline=_pipeline, - _location_mode=self._location_mode, allow_trailing_dot=self.allow_trailing_dot, - allow_source_trailing_dot=self.allow_source_trailing_dot) + self.url, + share_name=self.share_name, + directory_path=directory_path or "", + snapshot=self.snapshot, + credential=self.credential, + token_intent=self.file_request_intent, + api_version=self.api_version, + _hosts=self._hosts, + _configuration=self._config, + _pipeline=_pipeline, + _location_mode=self._location_mode, + allow_trailing_dot=self.allow_trailing_dot, + allow_source_trailing_dot=self.allow_source_trailing_dot, + ) def get_file_client(self, file_path: str) -> ShareFileClient: """Get a client to interact with the specified file. @@ -276,15 +275,24 @@ def get_file_client(self, file_path: str) -> ShareFileClient: """ _pipeline = Pipeline( transport=TransportWrapper(self._pipeline._transport), # pylint: disable=protected-access - policies=self._pipeline._impl_policies # pylint: disable=protected-access + policies=self._pipeline._impl_policies, # pylint: disable=protected-access ) return ShareFileClient( - self.url, share_name=self.share_name, file_path=file_path, snapshot=self.snapshot, - credential=self.credential, token_intent=self.file_request_intent, api_version=self.api_version, - _hosts=self._hosts, _configuration=self._config, - _pipeline=_pipeline, _location_mode=self._location_mode, allow_trailing_dot=self.allow_trailing_dot, - allow_source_trailing_dot=self.allow_source_trailing_dot) + self.url, + share_name=self.share_name, + file_path=file_path, + snapshot=self.snapshot, + credential=self.credential, + token_intent=self.file_request_intent, + api_version=self.api_version, + _hosts=self._hosts, + _configuration=self._config, + _pipeline=_pipeline, + _location_mode=self._location_mode, + allow_trailing_dot=self.allow_trailing_dot, + allow_source_trailing_dot=self.allow_source_trailing_dot, + ) @distributed_trace def acquire_lease(self, **kwargs: Any) -> ShareLeaseClient: @@ -322,8 +330,8 @@ def acquire_lease(self, **kwargs: Any) -> ShareLeaseClient: :dedent: 8 :caption: Acquiring a lease on a share. """ - kwargs['lease_duration'] = kwargs.pop('lease_duration', -1) - lease_id = kwargs.pop('lease_id', None) + kwargs["lease_duration"] = kwargs.pop("lease_duration", -1) + lease_id = kwargs.pop("lease_id", None) lease = ShareLeaseClient(self, lease_id=lease_id) lease.acquire(**kwargs) return lease @@ -375,38 +383,43 @@ def create_share(self, **kwargs: Any) -> Dict[str, Any]: :dedent: 8 :caption: Creates a file share. """ - metadata = kwargs.pop('metadata', None) - quota = kwargs.pop('quota', None) - access_tier = kwargs.pop('access_tier', None) - timeout = kwargs.pop('timeout', None) - root_squash = kwargs.pop('root_squash', None) - protocols = kwargs.pop('protocols', None) - paid_bursting_bandwidth_mibps = kwargs.pop('paid_bursting_bandwidth_mibps', None) - paid_bursting_iops = kwargs.pop('paid_bursting_iops', None) - share_provisioned_iops = kwargs.pop('provisioned_iops', None) - share_provisioned_bandwidth_mibps = kwargs.pop('provisioned_bandwidth_mibps', None) - if protocols and protocols not in ['NFS', 'SMB', ShareProtocols.SMB, ShareProtocols.NFS]: + metadata = kwargs.pop("metadata", None) + quota = kwargs.pop("quota", None) + access_tier = kwargs.pop("access_tier", None) + timeout = kwargs.pop("timeout", None) + root_squash = kwargs.pop("root_squash", None) + protocols = kwargs.pop("protocols", None) + paid_bursting_bandwidth_mibps = kwargs.pop("paid_bursting_bandwidth_mibps", None) + paid_bursting_iops = kwargs.pop("paid_bursting_iops", None) + share_provisioned_iops = kwargs.pop("provisioned_iops", None) + share_provisioned_bandwidth_mibps = kwargs.pop("provisioned_bandwidth_mibps", None) + if protocols and protocols not in ["NFS", "SMB", ShareProtocols.SMB, ShareProtocols.NFS]: raise ValueError("The enabled protocol must be set to either SMB or NFS.") - if root_squash and protocols not in ['NFS', ShareProtocols.NFS]: + if root_squash and protocols not in ["NFS", ShareProtocols.NFS]: raise ValueError("The 'root_squash' keyword can only be used on NFS enabled shares.") - headers = kwargs.pop('headers', {}) + headers = kwargs.pop("headers", {}) headers.update(add_metadata_headers(metadata)) try: - return cast(Dict[str, Any], self._client.share.create( - timeout=timeout, - metadata=metadata, - quota=quota, - access_tier=access_tier, - root_squash=root_squash, - enabled_protocols=protocols, - paid_bursting_max_bandwidth_mibps=paid_bursting_bandwidth_mibps, - paid_bursting_max_iops=paid_bursting_iops, - share_provisioned_iops=share_provisioned_iops, - share_provisioned_bandwidth_mibps=share_provisioned_bandwidth_mibps, - cls=return_response_headers, - headers=headers, - **kwargs)) + return cast( + Dict[str, Any], + self._client.share.create( + timeout=timeout, + metadata=metadata, + quota=quota, + access_tier=access_tier, + root_squash=root_squash, + enabled_protocols=protocols, + paid_bursting_max_bandwidth_mibps=paid_bursting_bandwidth_mibps, + paid_bursting_max_iops=paid_bursting_iops, + share_provisioned_iops=share_provisioned_iops, + share_provisioned_bandwidth_mibps=share_provisioned_bandwidth_mibps, + cls=return_response_headers, + headers=headers, + file_request_intent=self.file_request_intent, + **kwargs + ), + ) except HttpResponseError as error: process_storage_error(error) @@ -443,23 +456,27 @@ def create_snapshot(self, **kwargs: Any) -> Dict[str, Any]: :dedent: 12 :caption: Creates a snapshot of the file share. """ - metadata = kwargs.pop('metadata', None) - timeout = kwargs.pop('timeout', None) - headers = kwargs.pop('headers', {}) + metadata = kwargs.pop("metadata", None) + timeout = kwargs.pop("timeout", None) + headers = kwargs.pop("headers", {}) headers.update(add_metadata_headers(metadata)) try: - return cast(Dict[str, Any], self._client.share.create_snapshot( - timeout=timeout, - cls=return_response_headers, - headers=headers, - **kwargs)) + return cast( + Dict[str, Any], + self._client.share.create_snapshot( + timeout=timeout, + cls=return_response_headers, + headers=headers, + file_request_intent=self.file_request_intent, + **kwargs + ), + ) except HttpResponseError as error: process_storage_error(error) @distributed_trace def delete_share( - self, delete_snapshots: Optional[Union[bool, Literal['include', 'include-leased']]] = False, - **kwargs: Any + self, delete_snapshots: Optional[Union[bool, Literal["include", "include-leased"]]] = False, **kwargs: Any ) -> None: """Marks the specified share for deletion. The share is later deleted during garbage collection. @@ -494,23 +511,25 @@ def delete_share( :dedent: 12 :caption: Deletes the share and any snapshots. """ - access_conditions = get_access_conditions(kwargs.pop('lease', None)) - timeout = kwargs.pop('timeout', None) + access_conditions = get_access_conditions(kwargs.pop("lease", None)) + timeout = kwargs.pop("timeout", None) delete_include = None if isinstance(delete_snapshots, bool) and delete_snapshots: delete_include = DeleteSnapshotsOptionType.INCLUDE else: - if delete_snapshots == 'include': + if delete_snapshots == "include": delete_include = DeleteSnapshotsOptionType.INCLUDE - elif delete_snapshots == 'include-leased': + elif delete_snapshots == "include-leased": delete_include = DeleteSnapshotsOptionType.INCLUDE_LEASED try: self._client.share.delete( timeout=timeout, sharesnapshot=self.snapshot, - lease_access_conditions=access_conditions, + lease_id=access_conditions, delete_snapshots=delete_include, - **kwargs) + file_request_intent=self.file_request_intent, + **kwargs + ) except HttpResponseError as error: process_storage_error(error) @@ -546,15 +565,20 @@ def get_share_properties(self, **kwargs: Any) -> "ShareProperties": :dedent: 12 :caption: Gets the share properties. """ - access_conditions = get_access_conditions(kwargs.pop('lease', None)) - timeout = kwargs.pop('timeout', None) + access_conditions = get_access_conditions(kwargs.pop("lease", None)) + timeout = kwargs.pop("timeout", None) try: - props = cast("ShareProperties", self._client.share.get_properties( - timeout=timeout, - sharesnapshot=self.snapshot, - cls=deserialize_share_properties, - lease_access_conditions=access_conditions, - **kwargs)) + props = cast( + "ShareProperties", + self._client.share.get_properties( + timeout=timeout, + sharesnapshot=self.snapshot, + cls=deserialize_share_properties, + lease_id=access_conditions, + file_request_intent=self.file_request_intent, + **kwargs + ), + ) except HttpResponseError as error: process_storage_error(error) props.name = self.share_name @@ -594,16 +618,21 @@ def set_share_quota(self, quota: int, **kwargs: Any) -> Dict[str, Any]: :dedent: 12 :caption: Sets the share quota. """ - access_conditions = get_access_conditions(kwargs.pop('lease', None)) - timeout = kwargs.pop('timeout', None) + access_conditions = get_access_conditions(kwargs.pop("lease", None)) + timeout = kwargs.pop("timeout", None) try: - return cast(Dict[str, Any], self._client.share.set_properties( - timeout=timeout, - quota=quota, - access_tier=None, - lease_access_conditions=access_conditions, - cls=return_response_headers, - **kwargs)) + return cast( + Dict[str, Any], + self._client.share.set_properties( + timeout=timeout, + quota=quota, + access_tier=None, + lease_id=access_conditions, + cls=return_response_headers, + file_request_intent=self.file_request_intent, + **kwargs + ), + ) except HttpResponseError as error: process_storage_error(error) @@ -650,30 +679,35 @@ def set_share_properties(self, **kwargs: Any) -> Dict[str, Any]: :dedent: 12 :caption: Sets the share properties. """ - access_conditions = get_access_conditions(kwargs.pop('lease', None)) - timeout = kwargs.pop('timeout', None) - access_tier = kwargs.pop('access_tier', None) - quota = kwargs.pop('quota', None) - root_squash = kwargs.pop('root_squash', None) - paid_bursting_bandwidth_mibps = kwargs.pop('paid_bursting_bandwidth_mibps', None) - paid_bursting_iops = kwargs.pop('paid_bursting_iops', None) - share_provisioned_iops = kwargs.pop('provisioned_iops', None) - share_provisioned_bandwidth_mibps = kwargs.pop('provisioned_bandwidth_mibps', None) + access_conditions = get_access_conditions(kwargs.pop("lease", None)) + timeout = kwargs.pop("timeout", None) + access_tier = kwargs.pop("access_tier", None) + quota = kwargs.pop("quota", None) + root_squash = kwargs.pop("root_squash", None) + paid_bursting_bandwidth_mibps = kwargs.pop("paid_bursting_bandwidth_mibps", None) + paid_bursting_iops = kwargs.pop("paid_bursting_iops", None) + share_provisioned_iops = kwargs.pop("provisioned_iops", None) + share_provisioned_bandwidth_mibps = kwargs.pop("provisioned_bandwidth_mibps", None) if all(parameter is None for parameter in [access_tier, quota, root_squash]): raise ValueError("set_share_properties should be called with at least one parameter.") try: - return cast(Dict[str, Any], self._client.share.set_properties( - timeout=timeout, - quota=quota, - access_tier=access_tier, - root_squash=root_squash, - lease_access_conditions=access_conditions, - paid_bursting_max_bandwidth_mibps=paid_bursting_bandwidth_mibps, - paid_bursting_max_iops=paid_bursting_iops, - share_provisioned_iops=share_provisioned_iops, - share_provisioned_bandwidth_mibps=share_provisioned_bandwidth_mibps, - cls=return_response_headers, - **kwargs)) + return cast( + Dict[str, Any], + self._client.share.set_properties( + timeout=timeout, + quota=quota, + access_tier=access_tier, + root_squash=root_squash, + lease_id=access_conditions, + paid_bursting_max_bandwidth_mibps=paid_bursting_bandwidth_mibps, + paid_bursting_max_iops=paid_bursting_iops, + share_provisioned_iops=share_provisioned_iops, + share_provisioned_bandwidth_mibps=share_provisioned_bandwidth_mibps, + cls=return_response_headers, + file_request_intent=self.file_request_intent, + **kwargs + ), + ) except HttpResponseError as error: process_storage_error(error) @@ -714,17 +748,22 @@ def set_share_metadata(self, metadata: Dict[str, str], **kwargs: Any) -> Dict[st :dedent: 12 :caption: Sets the share metadata. """ - access_conditions = get_access_conditions(kwargs.pop('lease', None)) - timeout = kwargs.pop('timeout', None) - headers = kwargs.pop('headers', {}) + access_conditions = get_access_conditions(kwargs.pop("lease", None)) + timeout = kwargs.pop("timeout", None) + headers = kwargs.pop("headers", {}) headers.update(add_metadata_headers(metadata)) try: - return cast(Dict[str, Any], self._client.share.set_metadata( - timeout=timeout, - cls=return_response_headers, - headers=headers, - lease_access_conditions=access_conditions, - **kwargs)) + return cast( + Dict[str, Any], + self._client.share.set_metadata( + timeout=timeout, + cls=return_response_headers, + headers=headers, + lease_id=access_conditions, + file_request_intent=self.file_request_intent, + **kwargs + ), + ) except HttpResponseError as error: process_storage_error(error) @@ -750,19 +789,24 @@ def get_share_access_policy(self, **kwargs: Any) -> Dict[str, Any]: :returns: Access policy information in a dict. :rtype: dict[str, Any] """ - access_conditions = get_access_conditions(kwargs.pop('lease', None)) - timeout = kwargs.pop('timeout', None) + access_conditions = get_access_conditions(kwargs.pop("lease", None)) + timeout = kwargs.pop("timeout", None) try: response, identifiers = self._client.share.get_access_policy( timeout=timeout, cls=return_headers_and_deserialized, - lease_access_conditions=access_conditions, - **kwargs) + lease_id=access_conditions, + file_request_intent=self.file_request_intent, + **kwargs + ) except HttpResponseError as error: process_storage_error(error) return { - 'public_access': response.get('share_public_access'), - 'signed_identifiers': identifiers or [] + "public_access": response.get("share_public_access"), + "signed_identifiers": ( + identifiers.items_property if hasattr(identifiers, "items_property") else identifiers + ) + or [], } @distributed_trace @@ -793,12 +837,13 @@ def set_share_access_policy(self, signed_identifiers: Dict[str, "AccessPolicy"], :returns: Share-updated property dict (Etag and last modified). :rtype: dict[str, Any] """ - access_conditions = get_access_conditions(kwargs.pop('lease', None)) - timeout = kwargs.pop('timeout', None) + access_conditions = get_access_conditions(kwargs.pop("lease", None)) + timeout = kwargs.pop("timeout", None) if len(signed_identifiers) > 5: raise ValueError( - 'Too many access policies provided. The server does not support setting ' - 'more than 5 access policies on a single resource.') + "Too many access policies provided. The server does not support setting " + "more than 5 access policies on a single resource." + ) identifiers = [] for key, value in signed_identifiers.items(): if value: @@ -806,12 +851,17 @@ def set_share_access_policy(self, signed_identifiers: Dict[str, "AccessPolicy"], value.expiry = serialize_iso(value.expiry) identifiers.append(SignedIdentifier(id=key, access_policy=value)) try: - return cast(Dict[str, Any], self._client.share.set_access_policy( - share_acl=identifiers or None, - timeout=timeout, - cls=return_response_headers, - lease_access_conditions=access_conditions, - **kwargs)) + return cast( + Dict[str, Any], + self._client.share.set_access_policy( + share_acl=SignedIdentifiers(items_property=identifiers) if identifiers else None, + timeout=timeout, + cls=return_response_headers, + lease_id=access_conditions, + file_request_intent=self.file_request_intent, + **kwargs + ), + ) except HttpResponseError as error: process_storage_error(error) @@ -839,20 +889,23 @@ def get_share_stats(self, **kwargs: Any) -> int: :return: The approximate size of the data (in bytes) stored on the share. :rtype: int """ - access_conditions = get_access_conditions(kwargs.pop('lease', None)) - timeout = kwargs.pop('timeout', None) + access_conditions = get_access_conditions(kwargs.pop("lease", None)) + timeout = kwargs.pop("timeout", None) try: - stats = cast(ShareStats, self._client.share.get_statistics( - timeout=timeout, - lease_access_conditions=access_conditions, - **kwargs)) + stats = cast( + ShareStats, + self._client.share.get_statistics( + timeout=timeout, lease_id=access_conditions, file_request_intent=self.file_request_intent, **kwargs + ), + ) return stats.share_usage_bytes except HttpResponseError as error: process_storage_error(error) @distributed_trace def list_directories_and_files( - self, directory_name: Optional[str] = None, + self, + directory_name: Optional[str] = None, name_starts_with: Optional[str] = None, marker: Optional[str] = None, **kwargs: Any @@ -901,11 +954,12 @@ def list_directories_and_files( :dedent: 12 :caption: List directories and files in the share. """ - timeout = kwargs.pop('timeout', None) + timeout = kwargs.pop("timeout", None) directory = self.get_directory_client(directory_name) - kwargs.setdefault('merge_span', True) + kwargs.setdefault("merge_span", True) return directory.list_directories_and_files( - name_starts_with=name_starts_with, marker=marker, timeout=timeout, **kwargs) + name_starts_with=name_starts_with, marker=marker, timeout=timeout, **kwargs + ) @distributed_trace def create_permission_for_share(self, file_permission: str, **kwargs: Any) -> Optional[str]: @@ -929,10 +983,13 @@ def create_permission_for_share(self, file_permission: str, **kwargs: Any) -> Op :returns: A file permission key :rtype: str or None """ - timeout = kwargs.pop('timeout', None) + timeout = kwargs.pop("timeout", None) options = _create_permission_for_share_options(file_permission, timeout=timeout, **kwargs) try: - return cast(Optional[str], self._client.share.create_permission(**options)) + return cast( + Optional[str], + self._client.share.create_permission(file_request_intent=self.file_request_intent, **options), + ) except HttpResponseError as error: process_storage_error(error) @@ -956,13 +1013,18 @@ def get_permission_for_share(self, permission_key: str, **kwargs: Any) -> str: :returns: A file permission (a portable SDDL) :rtype: str """ - timeout = kwargs.pop('timeout', None) + timeout = kwargs.pop("timeout", None) try: - return cast(str, self._client.share.get_permission( - file_permission_key=permission_key, - cls=deserialize_permission, - timeout=timeout, - **kwargs)) + return cast( + str, + self._client.share.get_permission( + file_permission_key=permission_key, + cls=deserialize_permission, + timeout=timeout, + file_request_intent=self.file_request_intent, + **kwargs + ), + ) except HttpResponseError as error: process_storage_error(error) @@ -1002,7 +1064,7 @@ def create_directory(self, directory_name: str, **kwargs: Any) -> ShareDirectory :rtype: ~azure.storage.fileshare.ShareDirectoryClient """ directory = self.get_directory_client(directory_name) - kwargs.setdefault('merge_span', True) + kwargs.setdefault("merge_span", True) directory.create_directory(**kwargs) return directory diff --git a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_share_client_helpers.py b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_share_client_helpers.py index 7d3f041db0cf..11e16d5832b5 100644 --- a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_share_client_helpers.py +++ b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_share_client_helpers.py @@ -4,10 +4,7 @@ # license information. # -------------------------------------------------------------------------- -from typing import ( - Any, Dict, Optional, Tuple, Union, - TYPE_CHECKING -) +from typing import Any, Dict, Optional, Tuple, Union, TYPE_CHECKING from urllib.parse import quote, unquote, urlparse from ._deserialize import deserialize_permission_key @@ -21,11 +18,11 @@ def _parse_url(account_url: str, share_name: str) -> "ParseResult": try: - if not account_url.lower().startswith('http'): + if not account_url.lower().startswith("http"): account_url = "https://" + account_url except AttributeError as exc: raise ValueError("Account URL must be a string.") from exc - parsed_url = urlparse(account_url.rstrip('/')) + parsed_url = urlparse(account_url.rstrip("/")) if not share_name: raise ValueError("Please specify a share name.") if not parsed_url.netloc: @@ -35,21 +32,21 @@ def _parse_url(account_url: str, share_name: str) -> "ParseResult": def _format_url(scheme: str, hostname: str, share_name: Union[str, bytes], query_str: str) -> str: if isinstance(share_name, str): - share_name = share_name.encode('UTF-8') + share_name = share_name.encode("UTF-8") return f"{scheme}://{hostname}/{quote(share_name)}{query_str}" def _from_share_url(share_url: str, snapshot: Optional[Union[str, Dict[str, Any]]]) -> Tuple[str, str, Optional[str]]: try: - if not share_url.lower().startswith('http'): + if not share_url.lower().startswith("http"): share_url = "https://" + share_url except AttributeError as exc: raise ValueError("Share URL must be a string.") from exc - parsed_url = urlparse(share_url.rstrip('/')) + parsed_url = urlparse(share_url.rstrip("/")) if not (parsed_url.path and parsed_url.netloc): raise ValueError(f"Invalid URL: {share_url}") - share_path = parsed_url.path.lstrip('/').split('/') + share_path = parsed_url.path.lstrip("/").split("/") account_path = "" if len(share_path) > 1: account_path = "/" + "/".join(share_path[:-1]) @@ -67,9 +64,9 @@ def _from_share_url(share_url: str, snapshot: Optional[Union[str, Dict[str, Any] def _create_permission_for_share_options(file_permission: str, **kwargs: Any) -> Dict[str, Any]: options = { - 'share_permission': SharePermission(permission=file_permission), - 'cls': deserialize_permission_key, - 'timeout': kwargs.pop('timeout', None), + "permission": SharePermission(permission=file_permission), + "cls": deserialize_permission_key, + "timeout": kwargs.pop("timeout", None), } options.update(kwargs) return options diff --git a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_share_service_client.py b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_share_service_client.py index 8c35e2ee3d3b..f44ec757cdc7 100644 --- a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_share_service_client.py +++ b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_share_service_client.py @@ -7,17 +7,14 @@ import sys import functools -from typing import ( - Union, Optional, Any, Dict, List, - TYPE_CHECKING -) +from typing import Union, Optional, Any, Dict, List, TYPE_CHECKING from typing_extensions import Self from azure.core.exceptions import HttpResponseError from azure.core.paging import ItemPaged from azure.core.pipeline import Pipeline from azure.core.tracing.decorator import distributed_trace -from ._generated import AzureFileStorage +from ._generated import FileClient as AzureFileStorage from ._generated.models import KeyInfo, StorageServiceProperties from ._models import ( CorsRule, @@ -25,6 +22,7 @@ SharePropertiesPaged, service_properties_deserialize, ) +from ._parser import _strip_snapshot_from_url from ._serialize import get_api_version from ._share_client import ShareClient from ._share_service_client_helpers import _parse_url @@ -103,35 +101,35 @@ class ShareServiceClient(StorageAccountHostsMixin): :dedent: 8 :caption: Create the share service client with url and credential. """ + def __init__( - self, account_url: str, - credential: Optional[Union[str, Dict[str, str], "AzureNamedKeyCredential", "AzureSasCredential", "TokenCredential"]] = None, # pylint: disable=line-too-long + self, + account_url: str, + credential: Optional[ + Union[str, Dict[str, str], "AzureNamedKeyCredential", "AzureSasCredential", "TokenCredential"] + ] = None, # pylint: disable=line-too-long *, - token_intent: Optional[Literal['backup']] = None, - **kwargs: Any + token_intent: Optional[Literal["backup"]] = None, + **kwargs: Any, ) -> None: - if hasattr(credential, 'get_token') and not token_intent: + if hasattr(credential, "get_token") and not token_intent: raise ValueError("'token_intent' keyword is required when 'credential' is an TokenCredential.") parsed_url = _parse_url(account_url=account_url) _, sas_token = parse_query(parsed_url.query) if not sas_token and not credential: raise ValueError( - 'You need to provide either an account shared key or SAS token when creating a storage service.') + "You need to provide either an account shared key or SAS token when creating a storage service." + ) self._query_str, credential = self._format_query_string(sas_token, credential) - super(ShareServiceClient, self).__init__( - parsed_url, service='file-share', credential=credential, **kwargs) - self.allow_trailing_dot = kwargs.pop('allow_trailing_dot', None) - self.allow_source_trailing_dot = kwargs.pop('allow_source_trailing_dot', None) + super(ShareServiceClient, self).__init__(parsed_url, service="file-share", credential=credential, **kwargs) + self.allow_trailing_dot = kwargs.pop("allow_trailing_dot", None) + self.allow_source_trailing_dot = kwargs.pop("allow_source_trailing_dot", None) self.file_request_intent = token_intent self._client = AzureFileStorage( + url=_strip_snapshot_from_url(self.url), version=get_api_version(kwargs), - url=self.url, - base_url=self.url, pipeline=self._pipeline, - allow_trailing_dot=self.allow_trailing_dot, - allow_source_trailing_dot=self.allow_source_trailing_dot, - file_request_intent=self.file_request_intent ) def __enter__(self) -> Self: @@ -162,9 +160,12 @@ def _format_url(self, hostname: str) -> str: @classmethod def from_connection_string( - cls, conn_str: str, - credential: Optional[Union[str, Dict[str, str], "AzureNamedKeyCredential", "AzureSasCredential", "TokenCredential"]] = None, # pylint: disable=line-too-long - **kwargs: Any + cls, + conn_str: str, + credential: Optional[ + Union[str, Dict[str, str], "AzureNamedKeyCredential", "AzureSasCredential", "TokenCredential"] + ] = None, # pylint: disable=line-too-long + **kwargs: Any, ) -> Self: """Create ShareServiceClient from a Connection String. @@ -196,9 +197,9 @@ def from_connection_string( :dedent: 8 :caption: Create the share service client with connection string. """ - account_url, secondary, credential = parse_connection_str(conn_str, credential, 'file') - if 'secondary_hostname' not in kwargs: - kwargs['secondary_hostname'] = secondary + account_url, secondary, credential = parse_connection_str(conn_str, credential, "file") + if "secondary_hostname" not in kwargs: + kwargs["secondary_hostname"] = secondary return cls(account_url, credential=credential, **kwargs) @distributed_trace @@ -209,7 +210,7 @@ def get_user_delegation_key( start: Optional["datetime"] = None, delegated_user_tid: Optional[str] = None, timeout: Optional[int] = None, - **kwargs: Any + **kwargs: Any, ) -> "UserDelegationKey": """ Obtain a user delegation key for the purpose of signing SAS tokens. @@ -233,15 +234,11 @@ def get_user_delegation_key( :rtype: ~azure.storage.fileshare.UserDelegationKey """ key_info = KeyInfo( - start=_to_utc_datetime(start), - expiry=_to_utc_datetime(expiry), - delegated_user_tid=delegated_user_tid + start=_to_utc_datetime(start), expiry=_to_utc_datetime(expiry), delegated_user_tid=delegated_user_tid ) try: user_delegation_key = self._client.service.get_user_delegation_key( # type: ignore - key_info=key_info, - timeout=timeout, - **kwargs + key_info=key_info, timeout=timeout, **kwargs ) except HttpResponseError as error: process_storage_error(error) @@ -271,20 +268,23 @@ def get_service_properties(self, **kwargs: Any) -> Dict[str, Any]: :dedent: 8 :caption: Get file share service properties. """ - timeout = kwargs.pop('timeout', None) + timeout = kwargs.pop("timeout", None) try: - service_props = self._client.service.get_properties(timeout=timeout, **kwargs) + service_props = self._client.service.get_properties( + timeout=timeout, file_request_intent=self.file_request_intent, **kwargs + ) return service_properties_deserialize(service_props) except HttpResponseError as error: process_storage_error(error) @distributed_trace def set_service_properties( - self, hour_metrics: Optional["Metrics"] = None, + self, + hour_metrics: Optional["Metrics"] = None, minute_metrics: Optional["Metrics"] = None, cors: Optional[List[CorsRule]] = None, protocol: Optional["ShareProtocolSettings"] = None, - **kwargs: Any + **kwargs: Any, ) -> None: """Sets the properties of a storage account's File Share service, including Azure Storage Analytics. If an element (e.g. hour_metrics) is left as None, the @@ -323,24 +323,30 @@ def set_service_properties( :dedent: 8 :caption: Sets file share service properties. """ - timeout = kwargs.pop('timeout', None) + timeout = kwargs.pop("timeout", None) props = StorageServiceProperties( hour_metrics=hour_metrics, minute_metrics=minute_metrics, cors=CorsRule._to_generated(cors), # pylint: disable=protected-access - protocol=protocol + protocol=protocol, ) try: - self._client.service.set_properties(storage_service_properties=props, timeout=timeout, **kwargs) + self._client.service.set_properties( + storage_service_properties=props, + timeout=timeout, + file_request_intent=self.file_request_intent, + **kwargs, + ) except HttpResponseError as error: process_storage_error(error) @distributed_trace def list_shares( - self, name_starts_with: Optional[str] = None, + self, + name_starts_with: Optional[str] = None, include_metadata: Optional[bool] = False, include_snapshots: Optional[bool] = False, - **kwargs: Any + **kwargs: Any, ) -> ItemPaged[ShareProperties]: """Returns auto-paging iterable of dict-like ShareProperties under the specified account. The generator will lazily follow the continuation tokens returned by @@ -374,25 +380,30 @@ def list_shares( :dedent: 12 :caption: List shares in the file share service. """ - timeout = kwargs.pop('timeout', None) + timeout = kwargs.pop("timeout", None) include = [] - include_deleted = kwargs.pop('include_deleted', None) + include_deleted = kwargs.pop("include_deleted", None) if include_deleted: include.append("deleted") if include_metadata: - include.append('metadata') + include.append("metadata") if include_snapshots: - include.append('snapshots') + include.append("snapshots") - results_per_page = kwargs.pop('results_per_page', None) + results_per_page = kwargs.pop("results_per_page", None) command = functools.partial( self._client.service.list_shares_segment, include=include, timeout=timeout, - **kwargs) + file_request_intent=self.file_request_intent, + **kwargs, + ) return ItemPaged( - command, prefix=name_starts_with, results_per_page=results_per_page, - page_iterator_class=SharePropertiesPaged) + command, + prefix=name_starts_with, + results_per_page=results_per_page, + page_iterator_class=SharePropertiesPaged, + ) @distributed_trace def create_share(self, share_name: str, **kwargs: Any) -> ShareClient: @@ -426,28 +437,26 @@ def create_share(self, share_name: str, **kwargs: Any) -> ShareClient: :dedent: 8 :caption: Create a share in the file share service. """ - metadata = kwargs.pop('metadata', None) - quota = kwargs.pop('quota', None) - timeout = kwargs.pop('timeout', None) - provisioned_iops = kwargs.pop('provisioned_iops', None) - provisioned_bandwidth_mibps = kwargs.pop('provisioned_bandwidth_mibps', None) + metadata = kwargs.pop("metadata", None) + quota = kwargs.pop("quota", None) + timeout = kwargs.pop("timeout", None) + provisioned_iops = kwargs.pop("provisioned_iops", None) + provisioned_bandwidth_mibps = kwargs.pop("provisioned_bandwidth_mibps", None) share = self.get_share_client(share_name) - kwargs.setdefault('merge_span', True) + kwargs.setdefault("merge_span", True) share.create_share( metadata=metadata, quota=quota, timeout=timeout, provisioned_iops=provisioned_iops, provisioned_bandwidth_mibps=provisioned_bandwidth_mibps, - **kwargs + **kwargs, ) return share @distributed_trace def delete_share( - self, share_name: Union[ShareProperties, str], - delete_snapshots: Optional[bool] = False, - **kwargs: Any + self, share_name: Union[ShareProperties, str], delete_snapshots: Optional[bool] = False, **kwargs: Any ) -> None: """Marks the specified share for deletion. The share is later deleted during garbage collection. @@ -475,11 +484,10 @@ def delete_share( :dedent: 12 :caption: Delete a share in the file share service. """ - timeout = kwargs.pop('timeout', None) + timeout = kwargs.pop("timeout", None) share = self.get_share_client(share_name) - kwargs.setdefault('merge_span', True) - share.delete_share( - delete_snapshots=delete_snapshots, timeout=timeout, **kwargs) + kwargs.setdefault("merge_span", True) + share.delete_share(delete_snapshots=delete_snapshots, timeout=timeout, **kwargs) @distributed_trace def undelete_share(self, deleted_share_name: str, deleted_share_version: str, **kwargs: Any) -> ShareClient: @@ -508,16 +516,18 @@ def undelete_share(self, deleted_share_name: str, deleted_share_version: str, ** share = self.get_share_client(deleted_share_name) try: - share._client.share.restore(deleted_share_name=deleted_share_name, # pylint: disable=protected-access - deleted_share_version=deleted_share_version, - timeout=kwargs.pop('timeout', None), **kwargs) + share._client.share.restore( # pylint: disable=protected-access + deleted_share_name=deleted_share_name, + deleted_share_version=deleted_share_version, + timeout=kwargs.pop("timeout", None), + **kwargs, + ) return share except HttpResponseError as error: process_storage_error(error) def get_share_client( - self, share: Union[ShareProperties, str], - snapshot: Optional[Union[Dict[str, Any], str]] = None + self, share: Union[ShareProperties, str], snapshot: Optional[Union[Dict[str, Any], str]] = None ) -> ShareClient: """Get a client to interact with the specified share. The share need not already exist. @@ -547,12 +557,20 @@ def get_share_client( share_name = share _pipeline = Pipeline( - transport=TransportWrapper(self._pipeline._transport), # pylint: disable=protected-access - policies=self._pipeline._impl_policies # pylint: disable=protected-access + transport=TransportWrapper(self._pipeline._transport), # pylint: disable=protected-access + policies=self._pipeline._impl_policies, # pylint: disable=protected-access ) return ShareClient( - self.url, share_name=share_name, snapshot=snapshot, credential=self.credential, - api_version=self.api_version, _hosts=self._hosts, - _configuration=self._config, _pipeline=_pipeline, _location_mode=self._location_mode, - allow_trailing_dot=self.allow_trailing_dot, allow_source_trailing_dot=self.allow_source_trailing_dot, - token_intent=self.file_request_intent) + self.url, + share_name=share_name, + snapshot=snapshot, + credential=self.credential, + api_version=self.api_version, + _hosts=self._hosts, + _configuration=self._config, + _pipeline=_pipeline, + _location_mode=self._location_mode, + allow_trailing_dot=self.allow_trailing_dot, + allow_source_trailing_dot=self.allow_source_trailing_dot, + token_intent=self.file_request_intent, + ) diff --git a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_share_service_client_helpers.py b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_share_service_client_helpers.py index 9a6ebe8e7c4a..cfc1d7f4ca2d 100644 --- a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_share_service_client_helpers.py +++ b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_share_service_client_helpers.py @@ -17,7 +17,7 @@ def _parse_url(account_url: str) -> "ParseResult": account_url = "https://" + account_url except AttributeError as exc: raise ValueError("Account URL must be a string.") from exc - parsed_url = urlparse(account_url.rstrip('/')) + parsed_url = urlparse(account_url.rstrip("/")) if not parsed_url.netloc: raise ValueError(f"Invalid URL: {account_url}") return parsed_url diff --git a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_shared/base_client.py b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_shared/base_client.py index 57095ca402aa..08e54267f1c7 100644 --- a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_shared/base_client.py +++ b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_shared/base_client.py @@ -86,7 +86,7 @@ def _construct_endpoints(netloc: str, account_part: str) -> Tuple[str, str, str] :return: The account name, primary hostname, and secondary hostname. :rtype: Tuple[str, str, str] """ - domain_suffix = netloc[len(account_part):] + domain_suffix = netloc[len(account_part) :] secondary_idx = account_part.find(_SECONDARY_SUFFIX) # Case where customer provides secondary URL @@ -184,7 +184,7 @@ def url(self) -> str: :return: The full endpoint URL to this entity, including SAS token if used. :rtype: str """ - return self._format_url(self._hosts[self._location_mode]) # type: ignore + return self._format_url(self._hosts[self._location_mode]) # type: ignore @property def primary_endpoint(self) -> str: @@ -217,7 +217,7 @@ def secondary_endpoint(self) -> str: """ if not self._hosts[LocationMode.SECONDARY]: raise ValueError("No secondary host configured.") - return self._format_url(self._hosts[LocationMode.SECONDARY]) # type: ignore + return self._format_url(self._hosts[LocationMode.SECONDARY]) # type: ignore @property def secondary_hostname(self) -> Optional[str]: @@ -455,7 +455,7 @@ def parse_connection_str( if any(len(tup) != 2 for tup in conn_settings_list): raise ValueError("Connection string is either blank or malformed.") conn_settings = dict((key.upper(), val) for key, val in conn_settings_list) - if conn_settings.get('USEDEVELOPMENTSTORAGE') == 'true': + if conn_settings.get("USEDEVELOPMENTSTORAGE") == "true": return _get_development_storage_endpoint(service), None, DEVSTORE_ACCOUNT_KEY endpoints = _SERVICE_PARAMS[service] primary = None diff --git a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_shared/base_client_async.py b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_shared/base_client_async.py index 2e023b1cc8d9..7169ac25464c 100644 --- a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_shared/base_client_async.py +++ b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_shared/base_client_async.py @@ -213,7 +213,7 @@ def parse_connection_str( if any(len(tup) != 2 for tup in conn_settings_list): raise ValueError("Connection string is either blank or malformed.") conn_settings = dict((key.upper(), val) for key, val in conn_settings_list) - if conn_settings.get('USEDEVELOPMENTSTORAGE') == 'true': + if conn_settings.get("USEDEVELOPMENTSTORAGE") == "true": return _get_development_storage_endpoint(service), None, DEVSTORE_ACCOUNT_KEY endpoints = _SERVICE_PARAMS[service] primary = None diff --git a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_shared/constants.py b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_shared/constants.py index 2bf865acf343..c9c2ba8f74d0 100644 --- a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_shared/constants.py +++ b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_shared/constants.py @@ -6,7 +6,6 @@ from .._serialize import _SUPPORTED_API_VERSIONS - X_MS_VERSION = _SUPPORTED_API_VERSIONS[-1] # Connection defaults diff --git a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_shared/policies.py b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_shared/policies.py index b5d0b7d79766..8e45441c1543 100644 --- a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_shared/policies.py +++ b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_shared/policies.py @@ -467,17 +467,25 @@ def _validate_content_response( # Raises exception if missing content_length = int(response.http_response.headers[CONTENT_LENGTH_HEADER]) - # Patch response to return response iterator wrapped in structured message decoder - original_stream_download = response.http_response.stream_download - - def wrapped_stream_download(*args, **kwargs): - iterator = original_stream_download(*args, **kwargs) - decoder = decoder_cls(iterator, content_length, block_size=DATA_BLOCK_SIZE) - decoder.request = iterator.request # type: ignore - decoder.response = iterator.response # type: ignore - return decoder - - response.http_response.stream_download = wrapped_stream_download + def _make_wrapper(original): + def wrapped(*args, **kwargs): + iterator = original(*args, **kwargs) + decoder = decoder_cls(iterator, content_length, block_size=DATA_BLOCK_SIZE) + if hasattr(iterator, "request"): + decoder.request = iterator.request # type: ignore + if hasattr(iterator, "response"): + decoder.response = iterator.response # type: ignore + return decoder + return wrapped + + # Patch response to return response iterator wrapped in structured message decoder. + # TypeSpec-generated code calls iter_bytes()/iter_raw() instead of stream_download(). + if hasattr(response.http_response, "iter_bytes"): + response.http_response.iter_bytes = _make_wrapper(response.http_response.iter_bytes) + if hasattr(response.http_response, "iter_raw"): + response.http_response.iter_raw = _make_wrapper(response.http_response.iter_raw) + if hasattr(response.http_response, "stream_download"): + response.http_response.stream_download = _make_wrapper(response.http_response.stream_download) class StorageContentValidation(SansIOHTTPPolicy): diff --git a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_shared/request_handlers.py b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_shared/request_handlers.py index b23f65859690..d8c71d33a961 100644 --- a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_shared/request_handlers.py +++ b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_shared/request_handlers.py @@ -12,7 +12,6 @@ import isodate - _LOGGER = logging.getLogger(__name__) _REQUEST_DELIMITER_PREFIX = "batch_" @@ -118,11 +117,11 @@ def validate_and_format_range_headers( if align_to_page: if start_range is not None and start_range % 512 != 0: raise ValueError( - f"Invalid page blob start_range: {start_range}. " "The size must be aligned to a 512-byte boundary." + f"Invalid page blob start_range: {start_range}. The size must be aligned to a 512-byte boundary." ) if end_range is not None and end_range % 512 != 511: raise ValueError( - f"Invalid page blob end_range: {end_range}. " "The size must be aligned to a 512-byte boundary." + f"Invalid page blob end_range: {end_range}. The size must be aligned to a 512-byte boundary." ) # Format based on whether end_range is present diff --git a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_shared/response_handlers.py b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_shared/response_handlers.py index 1ed0d1073331..24855e202642 100644 --- a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_shared/response_handlers.py +++ b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_shared/response_handlers.py @@ -1,3 +1,4 @@ +# pylint: disable=line-too-long,useless-suppression # ------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for @@ -21,7 +22,6 @@ from .models import get_enum_value, StorageErrorCode, UserDelegationKey from .parser import _to_utc_datetime - SV_DOCS_URL = "https://learn.microsoft.com/rest/api/storageservices/versioning-for-the-azure-storage-services" _LOGGER = logging.getLogger(__name__) @@ -176,8 +176,11 @@ def process_storage_error(storage_error) -> NoReturn: # type: ignore [misc] # p error_message += f"\n{name}:{info}" if additional_data.get("headername") == "x-ms-version" and error_code == StorageErrorCode.INVALID_HEADER_VALUE: - error_message = ("The provided service version is not enabled on this storage account." + - f"Please see {SV_DOCS_URL} for additional information.\n" + error_message) + error_message = ( + "The provided service version is not enabled on this storage account." + + f"Please see {SV_DOCS_URL} for additional information.\n" + + error_message + ) # No need to create an instance if it has already been serialized by the generated layer if serialized: @@ -206,8 +209,16 @@ def parse_to_internal_user_delegation_key(service_user_delegation_key): internal_user_delegation_key.signed_oid = service_user_delegation_key.signed_oid internal_user_delegation_key.signed_tid = service_user_delegation_key.signed_tid internal_user_delegation_key.signed_delegated_user_tid = service_user_delegation_key.signed_delegated_user_tid - internal_user_delegation_key.signed_start = _to_utc_datetime(service_user_delegation_key.signed_start) - internal_user_delegation_key.signed_expiry = _to_utc_datetime(service_user_delegation_key.signed_expiry) + internal_user_delegation_key.signed_start = ( + service_user_delegation_key.signed_start + if isinstance(service_user_delegation_key.signed_start, str) + else _to_utc_datetime(service_user_delegation_key.signed_start) + ) + internal_user_delegation_key.signed_expiry = ( + service_user_delegation_key.signed_expiry + if isinstance(service_user_delegation_key.signed_expiry, str) + else _to_utc_datetime(service_user_delegation_key.signed_expiry) + ) internal_user_delegation_key.signed_service = service_user_delegation_key.signed_service internal_user_delegation_key.signed_version = service_user_delegation_key.signed_version internal_user_delegation_key.value = service_user_delegation_key.value diff --git a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_shared/uploads.py b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_shared/uploads.py index 7a5fb3f3dc91..b2dc44770eec 100644 --- a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_shared/uploads.py +++ b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_shared/uploads.py @@ -16,7 +16,6 @@ from .request_handlers import get_length from .response_handlers import return_response_headers - _LARGE_BLOB_UPLOAD_MAX_READ_BUFFER_SIZE = 4 * 1024 * 1024 _ERROR_VALUE_SHOULD_BE_SEEKABLE_STREAM = "{0} should be a seekable file-like/io.IOBase type stream object." @@ -56,6 +55,10 @@ def upload_data_chunks( if parallel and "modified_access_conditions" in kwargs: # Access conditions do not work with parallelism kwargs["modified_access_conditions"] = None + if parallel: + # Access conditions do not work with parallelism + kwargs.pop("etag", None) + kwargs.pop("match_condition", None) uploader = uploader_class( service=service, @@ -96,6 +99,10 @@ def upload_substream_blocks( if parallel and "modified_access_conditions" in kwargs: # Access conditions do not work with parallelism kwargs["modified_access_conditions"] = None + if parallel: + # Access conditions do not work with parallelism + kwargs.pop("etag", None) + kwargs.pop("match_condition", None) uploader = uploader_class( service=service, total_size=total_size, @@ -262,9 +269,9 @@ def _upload_chunk(self, chunk_offset, chunk_data): index = f"{chunk_offset:032d}" block_id = encode_base64(url_quote(encode_base64(index))) self.service.stage_block( - block_id, - len(chunk_data), - chunk_data, + block_id=block_id, + content_length=len(chunk_data), + body=chunk_data, data_stream_total=self.total_size, upload_stream_current=self.progress_total, **self.request_options, @@ -275,9 +282,9 @@ def _upload_substream_block(self, index, block_stream): try: block_id = f"BlockId{(index//self.chunk_size):05}" self.service.stage_block( - block_id, - len(block_stream), - block_stream, + block_id=block_id, + content_length=len(block_stream), + body=block_stream, data_stream_total=self.total_size, upload_stream_current=self.progress_total, **self.request_options, @@ -311,8 +318,8 @@ def _upload_chunk(self, chunk_offset, chunk_data): **self.request_options, ) - if not self.parallel and self.request_options.get("modified_access_conditions"): - self.request_options["modified_access_conditions"].if_match = self.response_headers["etag"] + if not self.parallel and self.request_options.get("etag"): + self.request_options["etag"] = self.response_headers["etag"] def _upload_substream_block(self, index, block_stream): pass @@ -336,9 +343,7 @@ def _upload_chunk(self, chunk_offset, chunk_data): ) self.current_length = int(self.response_headers["blob_append_offset"]) else: - self.request_options["append_position_access_conditions"].append_position = ( - self.current_length + chunk_offset - ) + self.request_options["append_position"] = self.current_length + chunk_offset self.response_headers = self.service.append_block( body=chunk_data, content_length=len(chunk_data), diff --git a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_shared/uploads_async.py b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_shared/uploads_async.py index 6ed5ba1d0f91..c1fa2a428dcc 100644 --- a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_shared/uploads_async.py +++ b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_shared/uploads_async.py @@ -73,6 +73,10 @@ async def upload_data_chunks( if parallel and "modified_access_conditions" in kwargs: # Access conditions do not work with parallelism kwargs["modified_access_conditions"] = None + if parallel: + # Access conditions do not work with parallelism + kwargs.pop("etag", None) + kwargs.pop("match_condition", None) uploader = uploader_class( service=service, @@ -119,6 +123,10 @@ async def upload_substream_blocks( if parallel and "modified_access_conditions" in kwargs: # Access conditions do not work with parallelism kwargs["modified_access_conditions"] = None + if parallel: + # Access conditions do not work with parallelism + kwargs.pop("etag", None) + kwargs.pop("match_condition", None) uploader = uploader_class( service=service, total_size=total_size, @@ -287,8 +295,8 @@ async def _upload_chunk(self, chunk_offset, chunk_data): index = f"{chunk_offset:032d}" block_id = encode_base64(url_quote(encode_base64(index))) await self.service.stage_block( - block_id, - len(chunk_data), + block_id=block_id, + content_length=len(chunk_data), body=chunk_data, data_stream_total=self.total_size, upload_stream_current=self.progress_total, @@ -300,9 +308,9 @@ async def _upload_substream_block(self, index, block_stream): try: block_id = f"BlockId{(index//self.chunk_size):05}" await self.service.stage_block( - block_id, - len(block_stream), - block_stream, + block_id=block_id, + content_length=len(block_stream), + body=block_stream, data_stream_total=self.total_size, upload_stream_current=self.progress_total, **self.request_options, @@ -339,8 +347,8 @@ async def _upload_chunk(self, chunk_offset, chunk_data): **self.request_options, ) - if not self.parallel and self.request_options.get("modified_access_conditions"): - self.request_options["modified_access_conditions"].if_match = self.response_headers["etag"] + if not self.parallel and self.request_options.get("etag"): + self.request_options["etag"] = self.response_headers["etag"] async def _upload_substream_block(self, index, block_stream): pass @@ -364,9 +372,7 @@ async def _upload_chunk(self, chunk_offset, chunk_data): ) self.current_length = int(self.response_headers["blob_append_offset"]) else: - self.request_options["append_position_access_conditions"].append_position = ( - self.current_length + chunk_offset - ) + self.request_options["append_position"] = self.current_length + chunk_offset self.response_headers = await self.service.append_block( body=chunk_data, content_length=len(chunk_data), diff --git a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_shared_access_signature.py b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_shared_access_signature.py index 6880a52022a8..0a7f24fa711b 100644 --- a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_shared_access_signature.py +++ b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_shared_access_signature.py @@ -5,10 +5,7 @@ # -------------------------------------------------------------------------- # pylint: disable=docstring-keyword-should-match-keyword-only -from typing import ( - Any, Callable, List, Optional, Union, - TYPE_CHECKING -) +from typing import Any, Callable, List, Optional, Union, TYPE_CHECKING from urllib.parse import parse_qs from ._shared import sign_string @@ -18,12 +15,7 @@ if TYPE_CHECKING: from datetime import datetime - from azure.storage.fileshare import ( - AccountSasPermissions, - FileSasPermissions, - ShareSasPermissions, - ResourceTypes - ) + from azure.storage.fileshare import AccountSasPermissions, FileSasPermissions, ShareSasPermissions, ResourceTypes class FileSharedAccessSignature(SharedAccessSignature): @@ -54,7 +46,8 @@ def __init__( self.user_delegation_key = user_delegation_key def generate_file( - self, share_name: str, + self, + share_name: str, directory_name: Optional[str] = None, file_name: Optional[str] = None, permission: Optional[Union["FileSasPermissions", str]] = None, @@ -69,7 +62,7 @@ def generate_file( content_language: Optional[str] = None, content_type: Optional[str] = None, user_delegation_oid: Optional[str] = None, - sts_hook: Optional[Callable[[str], None]] = None + sts_hook: Optional[Callable[[str], None]] = None, ) -> str: """ Generates a shared access signature for the file. @@ -145,20 +138,21 @@ def generate_file( """ resource_path = share_name if directory_name is not None: - resource_path += '/' + str(directory_name) + resource_path += "/" + str(directory_name) if file_name is not None: - resource_path += '/' + str(file_name) + resource_path += "/" + str(file_name) sas = _FileSharedAccessHelper() sas.add_base(permission, expiry, start, ip, protocol, self.x_ms_version) sas.add_id(policy_id) sas.add_user_delegation_oid(user_delegation_oid) - sas.add_resource('f') - sas.add_override_response_headers(cache_control, content_disposition, - content_encoding, content_language, - content_type) - sas.add_resource_signature(self.account_name, self.account_key, resource_path, - user_delegation_key=self.user_delegation_key) + sas.add_resource("f") + sas.add_override_response_headers( + cache_control, content_disposition, content_encoding, content_language, content_type + ) + sas.add_resource_signature( + self.account_name, self.account_key, resource_path, user_delegation_key=self.user_delegation_key + ) if sts_hook is not None: sts_hook(sas.string_to_sign) @@ -166,7 +160,8 @@ def generate_file( return sas.get_token() def generate_share( - self, share_name: str, + self, + share_name: str, permission: Optional[Union["ShareSasPermissions", str]] = None, expiry: Optional[Union["datetime", str]] = None, start: Optional[Union["datetime", str]] = None, @@ -181,7 +176,7 @@ def generate_share( user_delegation_oid: Optional[str] = None, sts_hook: Optional[Callable[[str], None]] = None, ) -> str: - ''' + """ Generates a shared access signature for the share. Use the returned signature with the sas_token parameter of FileService. @@ -247,17 +242,18 @@ def generate_share( :type sts_hook: Optional[Callable[[str], None]] :returns: The generated SAS token for the account. :rtype: str - ''' + """ sas = _FileSharedAccessHelper() sas.add_base(permission, expiry, start, ip, protocol, self.x_ms_version) sas.add_id(policy_id) sas.add_user_delegation_oid(user_delegation_oid) - sas.add_resource('s') - sas.add_override_response_headers(cache_control, content_disposition, - content_encoding, content_language, - content_type) - sas.add_resource_signature(self.account_name, self.account_key, share_name, - user_delegation_key=self.user_delegation_key) + sas.add_resource("s") + sas.add_override_response_headers( + cache_control, content_disposition, content_encoding, content_language, content_type + ) + sas.add_resource_signature( + self.account_name, self.account_key, share_name, user_delegation_key=self.user_delegation_key + ) if sts_hook is not None: sts_hook(sas.string_to_sign) @@ -269,21 +265,22 @@ class _FileSharedAccessHelper(_SharedAccessHelper): def add_resource_signature(self, account_name, account_key, path, user_delegation_key=None): def get_value_to_append(query): - return_value = self.query_dict.get(query) or '' - return return_value + '\n' + return_value = self.query_dict.get(query) or "" + return return_value + "\n" - if path[0] != '/': - path = '/' + path + if path[0] != "/": + path = "/" + path - canonicalized_resource = '/file/' + account_name + path + '\n' + canonicalized_resource = "/file/" + account_name + path + "\n" # Form the string to sign from shared_access_policy and canonicalized # resource. The order of values is important. - string_to_sign = \ - (get_value_to_append(QueryStringConstants.SIGNED_PERMISSION) + - get_value_to_append(QueryStringConstants.SIGNED_START) + - get_value_to_append(QueryStringConstants.SIGNED_EXPIRY) + - canonicalized_resource) + string_to_sign = ( + get_value_to_append(QueryStringConstants.SIGNED_PERMISSION) + + get_value_to_append(QueryStringConstants.SIGNED_START) + + get_value_to_append(QueryStringConstants.SIGNED_EXPIRY) + + canonicalized_resource + ) if user_delegation_key is not None: self._add_query(QueryStringConstants.SIGNED_OID, user_delegation_key.signed_oid) @@ -293,39 +290,41 @@ def get_value_to_append(query): self._add_query(QueryStringConstants.SIGNED_KEY_SERVICE, user_delegation_key.signed_service) self._add_query(QueryStringConstants.SIGNED_KEY_VERSION, user_delegation_key.signed_version) self._add_query( - QueryStringConstants.SIGNED_KEY_DELEGATED_USER_TID, - user_delegation_key.signed_delegated_user_tid + QueryStringConstants.SIGNED_KEY_DELEGATED_USER_TID, user_delegation_key.signed_delegated_user_tid ) - string_to_sign += \ - (get_value_to_append(QueryStringConstants.SIGNED_OID) + - get_value_to_append(QueryStringConstants.SIGNED_TID) + - get_value_to_append(QueryStringConstants.SIGNED_KEY_START) + - get_value_to_append(QueryStringConstants.SIGNED_KEY_EXPIRY) + - get_value_to_append(QueryStringConstants.SIGNED_KEY_SERVICE) + - get_value_to_append(QueryStringConstants.SIGNED_KEY_VERSION) + - get_value_to_append(QueryStringConstants.SIGNED_KEY_DELEGATED_USER_TID) + - get_value_to_append(QueryStringConstants.SIGNED_DELEGATED_USER_OID)) + string_to_sign += ( + get_value_to_append(QueryStringConstants.SIGNED_OID) + + get_value_to_append(QueryStringConstants.SIGNED_TID) + + get_value_to_append(QueryStringConstants.SIGNED_KEY_START) + + get_value_to_append(QueryStringConstants.SIGNED_KEY_EXPIRY) + + get_value_to_append(QueryStringConstants.SIGNED_KEY_SERVICE) + + get_value_to_append(QueryStringConstants.SIGNED_KEY_VERSION) + + get_value_to_append(QueryStringConstants.SIGNED_KEY_DELEGATED_USER_TID) + + get_value_to_append(QueryStringConstants.SIGNED_DELEGATED_USER_OID) + ) else: string_to_sign += get_value_to_append(QueryStringConstants.SIGNED_IDENTIFIER) - string_to_sign += \ - (get_value_to_append(QueryStringConstants.SIGNED_IP) + - get_value_to_append(QueryStringConstants.SIGNED_PROTOCOL) + - get_value_to_append(QueryStringConstants.SIGNED_VERSION) + - get_value_to_append(QueryStringConstants.SIGNED_CACHE_CONTROL) + - get_value_to_append(QueryStringConstants.SIGNED_CONTENT_DISPOSITION) + - get_value_to_append(QueryStringConstants.SIGNED_CONTENT_ENCODING) + - get_value_to_append(QueryStringConstants.SIGNED_CONTENT_LANGUAGE) + - get_value_to_append(QueryStringConstants.SIGNED_CONTENT_TYPE)) + string_to_sign += ( + get_value_to_append(QueryStringConstants.SIGNED_IP) + + get_value_to_append(QueryStringConstants.SIGNED_PROTOCOL) + + get_value_to_append(QueryStringConstants.SIGNED_VERSION) + + get_value_to_append(QueryStringConstants.SIGNED_CACHE_CONTROL) + + get_value_to_append(QueryStringConstants.SIGNED_CONTENT_DISPOSITION) + + get_value_to_append(QueryStringConstants.SIGNED_CONTENT_ENCODING) + + get_value_to_append(QueryStringConstants.SIGNED_CONTENT_LANGUAGE) + + get_value_to_append(QueryStringConstants.SIGNED_CONTENT_TYPE) + ) # remove the trailing newline - if string_to_sign[-1] == '\n': + if string_to_sign[-1] == "\n": string_to_sign = string_to_sign[:-1] - self._add_query(QueryStringConstants.SIGNED_SIGNATURE, - sign_string(account_key if user_delegation_key is None else user_delegation_key.value, - string_to_sign)) + self._add_query( + QueryStringConstants.SIGNED_SIGNATURE, + sign_string(account_key if user_delegation_key is None else user_delegation_key.value, string_to_sign), + ) self.string_to_sign = string_to_sign @@ -624,7 +623,7 @@ def generate_file_sas( raise ValueError("Either user_delegation_key or account_key must be provided.") sas = FileSharedAccessSignature(account_name, account_key=account_key, user_delegation_key=user_delegation_key) if len(file_path) > 1: - dir_path = '/'.join(file_path[:-1]) + dir_path = "/".join(file_path[:-1]) else: dir_path = None return sas.generate_file( diff --git a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_version.py b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_version.py index b9d6b67ccaeb..6f9bb76017d3 100644 --- a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_version.py +++ b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/_version.py @@ -1,7 +1,9 @@ -# ------------------------------------------------------------------------- +# coding=utf-8 +# -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for -# license information. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) Python Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. # -------------------------------------------------------------------------- VERSION = "12.27.0b1" diff --git a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/aio/__init__.py b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/aio/__init__.py index 73393b819df4..3cdd03d25573 100644 --- a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/aio/__init__.py +++ b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/aio/__init__.py @@ -10,11 +10,10 @@ from ._share_service_client_async import ShareServiceClient from ._lease_async import ShareLeaseClient - __all__ = [ - 'ShareFileClient', - 'ShareDirectoryClient', - 'ShareClient', - 'ShareServiceClient', - 'ShareLeaseClient', + "ShareFileClient", + "ShareDirectoryClient", + "ShareClient", + "ShareServiceClient", + "ShareLeaseClient", ] diff --git a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/aio/_directory_client_async.py b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/aio/_directory_client_async.py index b4fb7ff46333..ef985df17585 100644 --- a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/aio/_directory_client_async.py +++ b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/aio/_directory_client_async.py @@ -1,3 +1,4 @@ +# pylint: disable=too-many-lines # ------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for @@ -10,10 +11,7 @@ import time import warnings from datetime import datetime -from typing import ( - Any, AnyStr, AsyncIterable, cast, Dict, IO, Iterable, Optional, Union, - TYPE_CHECKING -) +from typing import Any, AnyStr, AsyncIterable, cast, Dict, IO, Iterable, Optional, Union, TYPE_CHECKING from typing_extensions import Self from azure.core.async_paging import AsyncItemPaged @@ -22,13 +20,9 @@ from azure.core.tracing.decorator import distributed_trace from azure.core.tracing.decorator_async import distributed_trace_async from .._deserialize import deserialize_directory_properties -from .._directory_client_helpers import ( - _format_url, - _from_directory_url, - _parse_url -) -from .._generated.aio import AzureFileStorage -from .._parser import _datetime_to_str, _get_file_permission, _parse_snapshot +from .._directory_client_helpers import _format_url, _from_directory_url, _parse_url +from .._generated.aio import FileClient as AzureFileStorage +from .._parser import _datetime_to_str, _get_file_permission, _parse_snapshot, _strip_snapshot_from_url from .._serialize import get_api_version, get_dest_access_conditions, get_rename_smb_properties from .._shared.base_client import parse_query, StorageAccountHostsMixin from .._shared.base_client_async import parse_connection_str, AsyncStorageAccountHostsMixin, AsyncTransportWrapper @@ -104,47 +98,49 @@ class ShareDirectoryClient(AsyncStorageAccountHostsMixin, StorageAccountHostsMix authentication. Only has an effect when credential is of type AsyncTokenCredential. The value could be https://storage.azure.com/ (default) or https://.file.core.windows.net. """ + def __init__( - self, account_url: str, + self, + account_url: str, share_name: str, directory_path: str, snapshot: Optional[Union[str, Dict[str, Any]]] = None, - credential: Optional[Union[str, Dict[str, str], "AzureNamedKeyCredential", "AzureSasCredential", "AsyncTokenCredential"]] = None, # pylint: disable=line-too-long + credential: Optional[ + Union[str, Dict[str, str], "AzureNamedKeyCredential", "AzureSasCredential", "AsyncTokenCredential"] + ] = None, # pylint: disable=line-too-long *, - token_intent: Optional[Literal['backup']] = None, - **kwargs: Any + token_intent: Optional[Literal["backup"]] = None, + **kwargs: Any, ) -> None: - kwargs['retry_policy'] = kwargs.get('retry_policy') or ExponentialRetry(**kwargs) - loop = kwargs.pop('loop', None) + kwargs["retry_policy"] = kwargs.get("retry_policy") or ExponentialRetry(**kwargs) + loop = kwargs.pop("loop", None) if loop and sys.version_info >= (3, 8): - warnings.warn("The 'loop' parameter was deprecated from asyncio's high-level" - "APIs in Python 3.8 and is no longer supported.", DeprecationWarning) - if hasattr(credential, 'get_token') and not token_intent: + warnings.warn( + "The 'loop' parameter was deprecated from asyncio's high-level" + "APIs in Python 3.8 and is no longer supported.", + DeprecationWarning, + ) + if hasattr(credential, "get_token") and not token_intent: raise ValueError("'token_intent' keyword is required when 'credential' is an AsyncTokenCredential.") parsed_url = _parse_url(account_url, share_name) path_snapshot, sas_token = parse_query(parsed_url.query) if not sas_token and not credential: raise ValueError( - 'You need to provide either an account shared key or SAS token when creating a storage service.') + "You need to provide either an account shared key or SAS token when creating a storage service." + ) self.snapshot = _parse_snapshot(snapshot, path_snapshot) self.share_name = share_name self.directory_path = directory_path - self._query_str, credential = self._format_query_string( - sas_token, credential, share_snapshot=self.snapshot) - super(ShareDirectoryClient, self).__init__( - parsed_url, service='file-share', credential=credential, **kwargs) - self.allow_trailing_dot = kwargs.pop('allow_trailing_dot', None) - self.allow_source_trailing_dot = kwargs.pop('allow_source_trailing_dot', None) + self._query_str, credential = self._format_query_string(sas_token, credential, share_snapshot=self.snapshot) + super(ShareDirectoryClient, self).__init__(parsed_url, service="file-share", credential=credential, **kwargs) + self.allow_trailing_dot = kwargs.pop("allow_trailing_dot", None) + self.allow_source_trailing_dot = kwargs.pop("allow_source_trailing_dot", None) self.file_request_intent = token_intent self._client = AzureFileStorage( + url=_strip_snapshot_from_url(self.url), version=get_api_version(kwargs), - url=self.url, - base_url=self.url, pipeline=self._pipeline, - allow_trailing_dot=self.allow_trailing_dot, - allow_source_trailing_dot=self.allow_source_trailing_dot, - file_request_intent=self.file_request_intent ) async def __aenter__(self) -> Self: @@ -165,10 +161,13 @@ async def close(self) -> None: @classmethod def from_directory_url( - cls, directory_url: str, + cls, + directory_url: str, snapshot: Optional[Union[str, Dict[str, Any]]] = None, - credential: Optional[Union[str, Dict[str, str], "AzureNamedKeyCredential", "AzureSasCredential", "AsyncTokenCredential"]] = None, # pylint: disable=line-too-long - **kwargs: Any + credential: Optional[ + Union[str, Dict[str, str], "AzureNamedKeyCredential", "AzureSasCredential", "AsyncTokenCredential"] + ] = None, # pylint: disable=line-too-long + **kwargs: Any, ) -> Self: """Create a ShareDirectoryClient from a directory url. @@ -199,8 +198,13 @@ def from_directory_url( """ account_url, share_name, directory_path, snapshot = _from_directory_url(directory_url, snapshot) return cls( - account_url=account_url, share_name=share_name, directory_path=directory_path, - snapshot=snapshot, credential=credential, **kwargs) + account_url=account_url, + share_name=share_name, + directory_path=directory_path, + snapshot=snapshot, + credential=credential, + **kwargs, + ) def _format_url(self, hostname: str) -> str: """Format the endpoint URL according to the current location mode hostname. @@ -214,11 +218,14 @@ def _format_url(self, hostname: str) -> str: @classmethod def from_connection_string( - cls, conn_str: str, + cls, + conn_str: str, share_name: str, directory_path: str, - credential: Optional[Union[str, Dict[str, str], "AzureNamedKeyCredential", "AzureSasCredential", "AsyncTokenCredential"]] = None, # pylint: disable=line-too-long - **kwargs: Any + credential: Optional[ + Union[str, Dict[str, str], "AzureNamedKeyCredential", "AzureSasCredential", "AsyncTokenCredential"] + ] = None, # pylint: disable=line-too-long + **kwargs: Any, ) -> Self: """Create ShareDirectoryClient from a Connection String. @@ -245,11 +252,10 @@ def from_connection_string( :returns: A directory client. :rtype: ~azure.storage.fileshare.aio.ShareDirectoryClient """ - account_url, secondary, credential = parse_connection_str(conn_str, credential, 'file') - if 'secondary_hostname' not in kwargs: - kwargs['secondary_hostname'] = secondary - return cls( - account_url, share_name=share_name, directory_path=directory_path, credential=credential, **kwargs) + account_url, secondary, credential = parse_connection_str(conn_str, credential, "file") + if "secondary_hostname" not in kwargs: + kwargs["secondary_hostname"] = secondary + return cls(account_url, share_name=share_name, directory_path=directory_path, credential=credential, **kwargs) def get_file_client(self, file_name: str, **kwargs: Any) -> ShareFileClient: """Get a client to interact with a specific file. @@ -262,18 +268,28 @@ def get_file_client(self, file_name: str, **kwargs: Any) -> ShareFileClient: :rtype: ~azure.storage.fileshare.ShareFileClient """ if self.directory_path: - file_name = self.directory_path.rstrip('/') + "/" + file_name + file_name = self.directory_path.rstrip("/") + "/" + file_name _pipeline = AsyncPipeline( transport=AsyncTransportWrapper(self._pipeline._transport), # pylint: disable=protected-access - policies=self._pipeline._impl_policies # type: ignore [arg-type] # pylint: disable=protected-access + policies=self._pipeline._impl_policies, # type: ignore [arg-type] # pylint: disable=protected-access ) return ShareFileClient( - self.url, file_path=file_name, share_name=self.share_name, snapshot=self.snapshot, - credential=self.credential, api_version=self.api_version, _hosts=self._hosts, _configuration=self._config, - _pipeline=_pipeline, _location_mode=self._location_mode, allow_trailing_dot=self.allow_trailing_dot, - allow_source_trailing_dot=self.allow_source_trailing_dot, token_intent=self.file_request_intent, - **kwargs) + self.url, + file_path=file_name, + share_name=self.share_name, + snapshot=self.snapshot, + credential=self.credential, + api_version=self.api_version, + _hosts=self._hosts, + _configuration=self._config, + _pipeline=_pipeline, + _location_mode=self._location_mode, + allow_trailing_dot=self.allow_trailing_dot, + allow_source_trailing_dot=self.allow_source_trailing_dot, + token_intent=self.file_request_intent, + **kwargs, + ) def get_subdirectory_client(self, directory_name: str, **kwargs) -> "ShareDirectoryClient": """Get a client to interact with a specific subdirectory. @@ -296,18 +312,28 @@ def get_subdirectory_client(self, directory_name: str, **kwargs) -> "ShareDirect """ directory_path = directory_name if self.directory_path: - directory_path = self.directory_path.rstrip('/') + "/" + directory_name + directory_path = self.directory_path.rstrip("/") + "/" + directory_name _pipeline = AsyncPipeline( transport=AsyncTransportWrapper(self._pipeline._transport), # pylint: disable=protected-access - policies=self._pipeline._impl_policies # type: ignore [arg-type] # pylint: disable=protected-access + policies=self._pipeline._impl_policies, # type: ignore [arg-type] # pylint: disable=protected-access ) return ShareDirectoryClient( - self.url, share_name=self.share_name, directory_path=directory_path, snapshot=self.snapshot, - credential=self.credential, api_version=self.api_version, _hosts=self._hosts, _configuration=self._config, - _pipeline=_pipeline, _location_mode=self._location_mode, allow_trailing_dot=self.allow_trailing_dot, - allow_source_trailing_dot=self.allow_source_trailing_dot, token_intent=self.file_request_intent, - **kwargs) + self.url, + share_name=self.share_name, + directory_path=directory_path, + snapshot=self.snapshot, + credential=self.credential, + api_version=self.api_version, + _hosts=self._hosts, + _configuration=self._config, + _pipeline=_pipeline, + _location_mode=self._location_mode, + allow_trailing_dot=self.allow_trailing_dot, + allow_source_trailing_dot=self.allow_source_trailing_dot, + token_intent=self.file_request_intent, + **kwargs, + ) @distributed_trace_async async def create_directory(self, **kwargs: Any) -> Dict[str, Any]: @@ -380,31 +406,37 @@ async def create_directory(self, **kwargs: Any) -> Dict[str, Any]: :dedent: 16 :caption: Creates a directory. """ - metadata = kwargs.pop('metadata', None) - timeout = kwargs.pop('timeout', None) - headers = kwargs.pop('headers', {}) + metadata = kwargs.pop("metadata", None) + timeout = kwargs.pop("timeout", None) + headers = kwargs.pop("headers", {}) headers.update(add_metadata_headers(metadata)) - file_attributes = kwargs.pop('file_attributes', None) - file_creation_time = kwargs.pop('file_creation_time', None) - file_last_write_time = kwargs.pop('file_last_write_time', None) - file_change_time = kwargs.pop('file_change_time', None) - file_permission = kwargs.pop('file_permission', None) - file_permission_key = kwargs.pop('file_permission_key', None) + file_attributes = kwargs.pop("file_attributes", None) + file_creation_time = kwargs.pop("file_creation_time", None) + file_last_write_time = kwargs.pop("file_last_write_time", None) + file_change_time = kwargs.pop("file_change_time", None) + file_permission = kwargs.pop("file_permission", None) + file_permission_key = kwargs.pop("file_permission_key", None) file_permission = _get_file_permission(file_permission, file_permission_key, None) try: - return cast(Dict[str, Any], await self._client.directory.create( - file_attributes=str(file_attributes) if file_attributes is not None else file_attributes, - file_creation_time=_datetime_to_str(file_creation_time), - file_last_write_time=_datetime_to_str(file_last_write_time), - file_change_time=_datetime_to_str(file_change_time), - file_permission=file_permission, - file_permission_key=file_permission_key, - timeout=timeout, - cls=return_response_headers, - headers=headers, - **kwargs)) + return cast( + Dict[str, Any], + await self._client.directory.create( + file_attributes=str(file_attributes) if file_attributes is not None else file_attributes, + file_creation_time=_datetime_to_str(file_creation_time), + file_last_write_time=_datetime_to_str(file_last_write_time), + file_change_time=_datetime_to_str(file_change_time), + file_permission=file_permission, + file_permission_key=file_permission_key, + timeout=timeout, + cls=return_response_headers, + headers=headers, + allow_trailing_dot=self.allow_trailing_dot, + file_request_intent=self.file_request_intent, + **kwargs, + ), + ) except HttpResponseError as error: process_storage_error(error) @@ -430,9 +462,14 @@ async def delete_directory(self, **kwargs: Any) -> None: :dedent: 16 :caption: Deletes a directory. """ - timeout = kwargs.pop('timeout', None) + timeout = kwargs.pop("timeout", None) try: - await self._client.directory.delete(timeout=timeout, **kwargs) + await self._client.directory.delete( + timeout=timeout, + allow_trailing_dot=self.allow_trailing_dot, + file_request_intent=self.file_request_intent, + **kwargs, + ) except HttpResponseError as error: process_storage_error(error) @@ -500,40 +537,51 @@ async def rename_directory(self, new_name: str, **kwargs: Any) -> "ShareDirector if not new_name: raise ValueError("Please specify a new directory name.") - new_name = new_name.strip('/') - new_path_and_query = new_name.split('?') + new_name = new_name.strip("/") + new_path_and_query = new_name.split("?") new_dir_path = new_path_and_query[0] if len(new_path_and_query) == 2: - new_dir_sas = new_path_and_query[1] or self._query_str.strip('?') + new_dir_sas = new_path_and_query[1] or self._query_str.strip("?") else: - new_dir_sas = self._query_str.strip('?') + new_dir_sas = self._query_str.strip("?") new_directory_client = ShareDirectoryClient( - f'{self.scheme}://{self.primary_hostname}', self.share_name, new_dir_path, - credential=new_dir_sas or self.credential, api_version=self.api_version, - _hosts=self._hosts, _configuration=self._config, _pipeline=self._pipeline, - _location_mode=self._location_mode, allow_trailing_dot=self.allow_trailing_dot, - allow_source_trailing_dot=self.allow_source_trailing_dot, token_intent=self.file_request_intent + f"{self.scheme}://{self.primary_hostname}", + self.share_name, + new_dir_path, + credential=new_dir_sas or self.credential, + api_version=self.api_version, + _hosts=self._hosts, + _configuration=self._config, + _pipeline=self._pipeline, + _location_mode=self._location_mode, + allow_trailing_dot=self.allow_trailing_dot, + allow_source_trailing_dot=self.allow_source_trailing_dot, + token_intent=self.file_request_intent, ) kwargs.update(get_rename_smb_properties(kwargs)) - timeout = kwargs.pop('timeout', None) - overwrite = kwargs.pop('overwrite', None) - metadata = kwargs.pop('metadata', None) - headers = kwargs.pop('headers', {}) + timeout = kwargs.pop("timeout", None) + overwrite = kwargs.pop("overwrite", None) + metadata = kwargs.pop("metadata", None) + headers = kwargs.pop("headers", {}) headers.update(add_metadata_headers(metadata)) - destination_access_conditions = get_dest_access_conditions(kwargs.pop('destination_lease', None)) + destination_access_conditions = get_dest_access_conditions(kwargs.pop("destination_lease", None)) try: await new_directory_client._client.directory.rename( # pylint: disable=protected-access - self.url, + rename_source=self.url, timeout=timeout, replace_if_exists=overwrite, - destination_lease_access_conditions=destination_access_conditions, + destination_lease_id=destination_access_conditions, headers=headers, - **kwargs) + allow_trailing_dot=self.allow_trailing_dot, + allow_source_trailing_dot=self.allow_source_trailing_dot, + file_request_intent=self.file_request_intent, + **kwargs, + ) return new_directory_client except HttpResponseError as error: @@ -541,9 +589,7 @@ async def rename_directory(self, new_name: str, **kwargs: Any) -> "ShareDirector @distributed_trace def list_directories_and_files( - self, - name_starts_with: Optional[str] = None, - **kwargs: Any + self, name_starts_with: Optional[str] = None, **kwargs: Any ) -> AsyncItemPaged[Union["DirectoryProperties", "FileProperties"]]: """Lists all the directories and files under the directory. @@ -583,16 +629,22 @@ def list_directories_and_files( :dedent: 16 :caption: List directories and files. """ - timeout = kwargs.pop('timeout', None) - results_per_page = kwargs.pop('results_per_page', None) + timeout = kwargs.pop("timeout", None) + results_per_page = kwargs.pop("results_per_page", None) command = functools.partial( self._client.directory.list_files_and_directories_segment, sharesnapshot=self.snapshot, timeout=timeout, - **kwargs) + allow_trailing_dot=self.allow_trailing_dot, + file_request_intent=self.file_request_intent, + **kwargs, + ) return AsyncItemPaged( - command, prefix=name_starts_with, results_per_page=results_per_page, - page_iterator_class=DirectoryPropertiesPaged) + command, + prefix=name_starts_with, + results_per_page=results_per_page, + page_iterator_class=DirectoryPropertiesPaged, + ) @distributed_trace def list_handles(self, recursive: bool = False, **kwargs: Any) -> AsyncItemPaged["Handle"]: @@ -610,17 +662,18 @@ def list_handles(self, recursive: bool = False, **kwargs: Any) -> AsyncItemPaged :returns: An auto-paging iterable of Handle :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.storage.fileshare.Handle] """ - timeout = kwargs.pop('timeout', None) - results_per_page = kwargs.pop('results_per_page', None) + timeout = kwargs.pop("timeout", None) + results_per_page = kwargs.pop("results_per_page", None) command = functools.partial( self._client.directory.list_handles, sharesnapshot=self.snapshot, timeout=timeout, recursive=recursive, - **kwargs) - return AsyncItemPaged( - command, results_per_page=results_per_page, - page_iterator_class=HandlesPaged) + allow_trailing_dot=self.allow_trailing_dot, + file_request_intent=self.file_request_intent, + **kwargs, + ) + return AsyncItemPaged(command, results_per_page=results_per_page, page_iterator_class=HandlesPaged) @distributed_trace_async async def exists(self, **kwargs: Any) -> bool: @@ -637,7 +690,12 @@ async def exists(self, **kwargs: Any) -> bool: :rtype: bool """ try: - await self._client.directory.get_properties(**kwargs) + await self._client.directory.get_properties( + allow_trailing_dot=self.allow_trailing_dot, + file_request_intent=self.file_request_intent, + sharesnapshot=self.snapshot, + **kwargs, + ) return True except HttpResponseError as error: try: @@ -666,20 +724,22 @@ async def close_handle(self, handle: Union[str, "Handle"], **kwargs: Any) -> Dic handle_id = handle.id else: handle_id = handle - if handle_id == '*': + if handle_id == "*": raise ValueError("Handle ID '*' is not supported. Use 'close_all_handles' instead.") try: response = await self._client.directory.force_close_handles( - handle_id, + handle_id=handle_id, marker=None, recursive=None, sharesnapshot=self.snapshot, cls=return_response_headers, - **kwargs + allow_trailing_dot=self.allow_trailing_dot, + file_request_intent=self.file_request_intent, + **kwargs, ) return { - 'closed_handles_count': response.get('number_of_handles_closed', 0), - 'failed_handles_count': response.get('number_of_handles_failed', 0) + "closed_handles_count": response.get("number_of_handles_closed", 0), + "failed_handles_count": response.get("number_of_handles_failed", 0), } except HttpResponseError as error: process_storage_error(error) @@ -703,7 +763,7 @@ async def close_all_handles(self, recursive: bool = False, **kwargs: Any) -> Dic and the number of handles failed to close in a dict. :rtype: dict[str, int] """ - timeout = kwargs.pop('timeout', None) + timeout = kwargs.pop("timeout", None) start_time = time.time() try_close = True @@ -713,26 +773,25 @@ async def close_all_handles(self, recursive: bool = False, **kwargs: Any) -> Dic while try_close: try: response = await self._client.directory.force_close_handles( - handle_id='*', + handle_id="*", timeout=timeout, marker=continuation_token, recursive=recursive, sharesnapshot=self.snapshot, cls=return_response_headers, - **kwargs + allow_trailing_dot=self.allow_trailing_dot, + file_request_intent=self.file_request_intent, + **kwargs, ) except HttpResponseError as error: process_storage_error(error) - continuation_token = response.get('marker') + continuation_token = response.get("marker") try_close = bool(continuation_token) - total_closed += response.get('number_of_handles_closed', 0) - total_failed += response.get('number_of_handles_failed', 0) + total_closed += response.get("number_of_handles_closed", 0) + total_failed += response.get("number_of_handles_failed", 0) if timeout: timeout = max(0, timeout - (time.time() - start_time)) - return { - 'closed_handles_count': total_closed, - 'failed_handles_count': total_failed - } + return {"closed_handles_count": total_closed, "failed_handles_count": total_failed} @distributed_trace_async async def get_directory_properties(self, **kwargs: Any) -> "DirectoryProperties": @@ -749,12 +808,19 @@ async def get_directory_properties(self, **kwargs: Any) -> "DirectoryProperties" :returns: DirectoryProperties :rtype: ~azure.storage.fileshare.DirectoryProperties """ - timeout = kwargs.pop('timeout', None) + timeout = kwargs.pop("timeout", None) try: - response = cast("DirectoryProperties", await self._client.directory.get_properties( - timeout=timeout, - cls=deserialize_directory_properties, - **kwargs)) + response = cast( + "DirectoryProperties", + await self._client.directory.get_properties( + timeout=timeout, + cls=deserialize_directory_properties, + allow_trailing_dot=self.allow_trailing_dot, + file_request_intent=self.file_request_intent, + sharesnapshot=self.snapshot, + **kwargs, + ), + ) except HttpResponseError as error: process_storage_error(error) return response @@ -779,26 +845,33 @@ async def set_directory_metadata(self, metadata: Dict[str, Any], **kwargs: Any) :returns: Directory-updated property dict (Etag and last modified). :rtype: dict[str, Any] """ - timeout = kwargs.pop('timeout', None) - headers = kwargs.pop('headers', {}) + timeout = kwargs.pop("timeout", None) + headers = kwargs.pop("headers", {}) headers.update(add_metadata_headers(metadata)) try: - return cast(Dict[str, Any], await self._client.directory.set_metadata( - timeout=timeout, - cls=return_response_headers, - headers=headers, - **kwargs)) + return cast( + Dict[str, Any], + await self._client.directory.set_metadata( + timeout=timeout, + cls=return_response_headers, + headers=headers, + allow_trailing_dot=self.allow_trailing_dot, + file_request_intent=self.file_request_intent, + **kwargs, + ), + ) except HttpResponseError as error: process_storage_error(error) @distributed_trace_async async def set_http_headers( - self, file_attributes: Optional[Union[str, "NTFSAttributes"]] = None, + self, + file_attributes: Optional[Union[str, "NTFSAttributes"]] = None, file_creation_time: Optional[Union[str, datetime]] = None, file_last_write_time: Optional[Union[str, datetime]] = None, file_permission: Optional[str] = None, permission_key: Optional[str] = None, - **kwargs: Any + **kwargs: Any, ) -> Dict[str, Any]: """Sets HTTP headers on the directory. @@ -848,20 +921,26 @@ async def set_http_headers( :returns: File-updated property dict (Etag and last modified). :rtype: dict[str, Any] """ - timeout = kwargs.pop('timeout', None) + timeout = kwargs.pop("timeout", None) file_permission = _get_file_permission(file_permission, permission_key, None) - file_change_time = kwargs.pop('file_change_time', None) + file_change_time = kwargs.pop("file_change_time", None) try: - return cast(Dict[str, Any], await self._client.directory.set_properties( - file_attributes=str(file_attributes) if file_attributes is not None else file_attributes, - file_creation_time=_datetime_to_str(file_creation_time), - file_last_write_time=_datetime_to_str(file_last_write_time), - file_change_time=_datetime_to_str(file_change_time), - file_permission=file_permission, - file_permission_key=permission_key, - timeout=timeout, - cls=return_response_headers, - **kwargs)) + return cast( + Dict[str, Any], + await self._client.directory.set_properties( + file_attributes=str(file_attributes) if file_attributes is not None else file_attributes, + file_creation_time=_datetime_to_str(file_creation_time), + file_last_write_time=_datetime_to_str(file_last_write_time), + file_change_time=_datetime_to_str(file_change_time), + file_permission=file_permission, + file_permission_key=permission_key, + timeout=timeout, + cls=return_response_headers, + allow_trailing_dot=self.allow_trailing_dot, + file_request_intent=self.file_request_intent, + **kwargs, + ), + ) except HttpResponseError as error: process_storage_error(error) @@ -893,8 +972,8 @@ async def create_subdirectory(self, directory_name: str, **kwargs: Any) -> "Shar :dedent: 16 :caption: Create a subdirectory. """ - metadata = kwargs.pop('metadata', None) - timeout = kwargs.pop('timeout', None) + metadata = kwargs.pop("metadata", None) + timeout = kwargs.pop("timeout", None) subdir = self.get_subdirectory_client(directory_name) await subdir.create_directory(metadata=metadata, timeout=timeout, **kwargs) return subdir @@ -922,16 +1001,17 @@ async def delete_subdirectory(self, directory_name: str, **kwargs: Any) -> None: :dedent: 16 :caption: Delete a subdirectory. """ - timeout = kwargs.pop('timeout', None) + timeout = kwargs.pop("timeout", None) subdir = self.get_subdirectory_client(directory_name) await subdir.delete_directory(timeout=timeout, **kwargs) @distributed_trace_async async def upload_file( - self, file_name: str, + self, + file_name: str, data: Union[bytes, str, Iterable[AnyStr], AsyncIterable[AnyStr], IO[AnyStr]], length: Optional[int] = None, - **kwargs: Any + **kwargs: Any, ) -> ShareFileClient: """Creates a new file in the directory and returns a ShareFileClient to interact with the file. @@ -984,10 +1064,7 @@ async def upload_file( :caption: Upload a file to a directory. """ file_client = self.get_file_client(file_name) - await file_client.upload_file( - data, - length=length, - **kwargs) + await file_client.upload_file(data, length=length, **kwargs) return file_client @distributed_trace_async diff --git a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/aio/_download_async.py b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/aio/_download_async.py index b3a2a1750f04..11624b860816 100644 --- a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/aio/_download_async.py +++ b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/aio/_download_async.py @@ -11,11 +11,7 @@ import warnings from io import BytesIO from itertools import islice -from typing import ( - Any, AsyncIterator, Awaitable, Callable, - cast, Generator, IO, Optional, Tuple, - TYPE_CHECKING -) +from typing import Any, AsyncIterator, Awaitable, Callable, cast, Generator, IO, Optional, Tuple, TYPE_CHECKING from azure.core.exceptions import HttpResponseError, ResourceModifiedError from .._download import _ChunkDownloader @@ -45,8 +41,8 @@ async def process_content(data: Any) -> bytes: class _AsyncChunkDownloader(_ChunkDownloader): def __init__(self, **kwargs: Any) -> None: super(_AsyncChunkDownloader, self).__init__(**kwargs) - self.stream_lock_async = asyncio.Lock() if kwargs.get('parallel') else None - self.progress_lock_async = asyncio.Lock() if kwargs.get('parallel') else None + self.stream_lock_async = asyncio.Lock() if kwargs.get("parallel") else None + self.progress_lock_async = asyncio.Lock() if kwargs.get("parallel") else None async def process_chunk(self, chunk_start: int) -> None: chunk_start, chunk_end = self._calculate_range(chunk_start) @@ -69,7 +65,8 @@ async def _update_progress(self, length: int) -> None: if self.progress_hook: await cast(Callable[[int, Optional[int]], Awaitable[Any]], self.progress_hook)( - self.progress_total, self.total_size) + self.progress_total, self.total_size + ) async def _write_to_stream(self, chunk_data: bytes, chunk_start: int) -> None: if self.stream_lock_async: @@ -81,19 +78,20 @@ async def _write_to_stream(self, chunk_data: bytes, chunk_start: int) -> None: async def _download_chunk(self, chunk_start: int, chunk_end: int) -> bytes: range_header, range_validation = validate_and_format_range_headers( - chunk_start, - chunk_end, - check_content_md5=is_md5_validation(self.validate_content) + chunk_start, chunk_end, check_content_md5=is_md5_validation(self.validate_content) ) try: - _, response = await cast(Awaitable[Any], self.client.download( - range=range_header, - range_get_content_md5=range_validation, - validate_content=self.validate_content, - data_stream_total=self.total_size, - download_stream_current=self.progress_total, - **self.request_options - )) + _, response = await cast( + Awaitable[Any], + self.client.download( + range=range_header, + range_get_content_md5=range_validation, + validate_content=self.validate_content, + data_stream_total=self.total_size, + download_stream_current=self.progress_total, + **self.request_options, + ), + ) if response.properties.etag != self.etag: raise ResourceModifiedError(message="The file has been modified while downloading.") except HttpResponseError as error: @@ -154,7 +152,7 @@ async def __anext__(self) -> bytes: def _get_chunk_data(self) -> bytes: chunk_data = self._current_content[: self._chunk_size] - self._current_content = self._current_content[self._chunk_size:] + self._current_content = self._current_content[self._chunk_size :] return chunk_data @@ -175,7 +173,8 @@ class StorageStreamDownloader: # pylint: disable=too-many-instance-attributes otherwise the total size of the file.""" def __init__( - self, client: "FileOperations" = None, # type: ignore [assignment] + self, + client: "FileOperations" = None, # type: ignore [assignment] config: "StorageConfiguration" = None, # type: ignore [assignment] start_range: Optional[int] = None, end_range: Optional[int] = None, @@ -185,7 +184,7 @@ def __init__( path: str = None, # type: ignore [assignment] share: str = None, # type: ignore [assignment] encoding: Optional[str] = None, - **kwargs: Any + **kwargs: Any, ) -> None: self.name = name self.path = path @@ -199,7 +198,7 @@ def __init__( self._max_concurrency = max_concurrency if max_concurrency is not None else DEFAULT_MAX_CONCURRENCY self._encoding = encoding self._validate_content = validate_content - self._progress_hook = kwargs.pop('progress_hook', None) + self._progress_hook = kwargs.pop("progress_hook", None) self._request_options = kwargs self._location_mode = None self._download_complete = False @@ -240,7 +239,7 @@ async def _setup(self) -> None: self.properties.size = self.size # Overwrite the content range to the user requested range - self.properties.content_range = f'bytes {self._start_range}-{self._end_range}/{self._file_size}' + self.properties.content_range = f"bytes {self._start_range}-{self._end_range}/{self._file_size}" # Overwrite the content MD5 as it is the MD5 for the last range instead # of the stored MD5 @@ -258,17 +257,21 @@ async def _initial_request(self): self._initial_range[1], start_range_required=False, end_range_required=False, - check_content_md5=is_md5_validation(self._validate_content)) + check_content_md5=is_md5_validation(self._validate_content), + ) try: - location_mode, response = cast(Tuple[Optional[str], Any], await self._client.download( - range=range_header, - range_get_content_md5=range_validation, - validate_content=self._validate_content, - data_stream_total=None, - download_stream_current=0, - **self._request_options - )) + location_mode, response = cast( + Tuple[Optional[str], Any], + await self._client.download( + range=range_header, + range_get_content_md5=range_validation, + validate_content=self._validate_content, + data_stream_total=None, + download_stream_current=0, + **self._request_options, + ), + ) # Check the location we read from to ensure we use the same one # for subsequent requests. @@ -294,12 +297,15 @@ async def _initial_request(self): # request a range, do a regular get request in order to get # any properties. try: - _, response = cast(Tuple[Optional[Any], Any], await self._client.download( - validate_content=self._validate_content, - data_stream_total=0, - download_stream_current=0, - **self._request_options - )) + _, response = cast( + Tuple[Optional[Any], Any], + await self._client.download( + validate_content=self._validate_content, + data_stream_total=0, + download_stream_current=0, + **self._request_options, + ), + ) except HttpResponseError as e: process_storage_error(e) @@ -342,12 +348,13 @@ def chunks(self) -> AsyncIterator[bytes]: validate_content=self._validate_content, use_location=self._location_mode, etag=self._etag, - **self._request_options) + **self._request_options, + ) return _AsyncChunkIterator( size=self.size, content=self._current_content, downloader=iter_downloader, - chunk_size=self._config.max_chunk_get_size + chunk_size=self._config.max_chunk_get_size, ) async def readall(self) -> bytes: @@ -376,10 +383,7 @@ async def content_as_bytes(self, max_concurrency=None): :return: The contents of the file as bytes. :rtype: bytes """ - warnings.warn( - "content_as_bytes is deprecated, use readall instead", - DeprecationWarning - ) + warnings.warn("content_as_bytes is deprecated, use readall instead", DeprecationWarning) self._max_concurrency = max_concurrency if max_concurrency is not None else DEFAULT_MAX_CONCURRENCY return await self.readall() @@ -397,10 +401,7 @@ async def content_as_text(self, max_concurrency=None, encoding="UTF-8"): :return: The contents of the file as a str. :rtype: str """ - warnings.warn( - "content_as_text is deprecated, use readall instead", - DeprecationWarning - ) + warnings.warn("content_as_text is deprecated, use readall instead", DeprecationWarning) self._max_concurrency = max_concurrency if max_concurrency is not None else DEFAULT_MAX_CONCURRENCY self._encoding = encoding return await self.readall() @@ -453,17 +454,16 @@ async def readinto(self, stream: IO[bytes]) -> int: use_location=self._location_mode, progress_hook=self._progress_hook, etag=self._etag, - **self._request_options) + **self._request_options, + ) dl_tasks = downloader.get_chunk_offsets() running_futures = { - asyncio.ensure_future(downloader.process_chunk(d)) - for d in islice(dl_tasks, 0, self._max_concurrency) + asyncio.ensure_future(downloader.process_chunk(d)) for d in islice(dl_tasks, 0, self._max_concurrency) } while running_futures: # Wait for some download to finish before adding a new one - done, running_futures = await asyncio.wait( - running_futures, return_when=asyncio.FIRST_COMPLETED) + done, running_futures = await asyncio.wait(running_futures, return_when=asyncio.FIRST_COMPLETED) try: for task in done: task.result() @@ -500,10 +500,7 @@ async def download_to_stream(self, stream, max_concurrency=None): :returns: The properties of the downloaded file. :rtype: Any """ - warnings.warn( - "download_to_stream is deprecated, use readinto instead", - DeprecationWarning - ) + warnings.warn("download_to_stream is deprecated, use readinto instead", DeprecationWarning) self._max_concurrency = max_concurrency if max_concurrency is not None else DEFAULT_MAX_CONCURRENCY await self.readinto(stream) return self.properties diff --git a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/aio/_file_client_async.py b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/aio/_file_client_async.py index 636228460008..188ab3ec5846 100644 --- a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/aio/_file_client_async.py +++ b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/aio/_file_client_async.py @@ -1,3 +1,4 @@ +# pylint: disable=too-many-lines # ------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for @@ -12,9 +13,21 @@ from datetime import datetime from io import BytesIO from typing import ( - Any, AnyStr, AsyncGenerator, AsyncIterable, Callable, cast, - Dict, IO, Iterable, List, Literal, Optional, Tuple, Union, - TYPE_CHECKING + Any, + AnyStr, + AsyncGenerator, + AsyncIterable, + Callable, + cast, + Dict, + IO, + Iterable, + List, + Literal, + Optional, + Tuple, + Union, + TYPE_CHECKING, ) from typing_extensions import Self @@ -28,18 +41,17 @@ _from_file_url, _get_ranges_options, _parse_url, - _upload_range_from_url_options + _upload_range_from_url_options, ) -from .._generated.aio import AzureFileStorage -from .._generated.models import FileHTTPHeaders -from .._parser import _datetime_to_str, _get_file_permission, _parse_snapshot +from .._generated.aio import FileClient as AzureFileStorage +from .._parser import _datetime_to_str, _get_file_permission, _parse_snapshot, _strip_snapshot_from_url from .._serialize import ( get_access_conditions, get_api_version, get_dest_access_conditions, get_rename_smb_properties, get_smb_properties, - get_source_access_conditions + get_source_access_conditions, ) from .._shared.base_client import StorageAccountHostsMixin, parse_query from .._shared.base_client_async import AsyncStorageAccountHostsMixin, parse_connection_str @@ -76,20 +88,22 @@ async def _upload_file_helper( file_permission: Optional[str] = None, file_permission_key: Optional[str] = None, progress_hook: Optional[Callable[[int, Optional[int]], None]] = None, - **kwargs: Any + **kwargs: Any, ) -> Dict[str, Any]: try: if size is None or size < 0: raise ValueError("A content size must be specified for a File.") response = await client.create_file( - size, content_settings=content_settings, metadata=metadata, + size, + content_settings=content_settings, + metadata=metadata, file_attributes=file_attributes, file_creation_time=file_creation_time, file_last_write_time=file_last_write_time, file_permission=file_permission, permission_key=file_permission_key, timeout=timeout, - **kwargs + **kwargs, ) if size == 0: return response @@ -104,9 +118,9 @@ async def _upload_file_helper( validate_content=validate_content, progress_hook=progress_hook, timeout=timeout, - **kwargs + **kwargs, ) - return cast(Dict[str, Any], sorted(responses, key=lambda r: r.get('last_modified'))[-1]) + return cast(Dict[str, Any], sorted(responses, key=lambda r: r.get("last_modified"))[-1]) except HttpResponseError as error: process_storage_error(error) @@ -163,49 +177,51 @@ class ShareFileClient(AsyncStorageAccountHostsMixin, StorageAccountHostsMixin): authentication. Only has an effect when credential is of type AsyncTokenCredential. The value could be https://storage.azure.com/ (default) or https://.blob.core.windows.net. """ + def __init__( - self, account_url: str, + self, + account_url: str, share_name: str, file_path: str, snapshot: Optional[Union[str, Dict[str, Any]]] = None, - credential: Optional[Union[str, Dict[str, str], "AzureNamedKeyCredential", "AzureSasCredential", "AsyncTokenCredential"]] = None, # pylint: disable=line-too-long + credential: Optional[ + Union[str, Dict[str, str], "AzureNamedKeyCredential", "AzureSasCredential", "AsyncTokenCredential"] + ] = None, # pylint: disable=line-too-long *, - token_intent: Optional[Literal['backup']] = None, - **kwargs: Any + token_intent: Optional[Literal["backup"]] = None, + **kwargs: Any, ) -> None: kwargs["retry_policy"] = kwargs.get("retry_policy") or ExponentialRetry(**kwargs) - loop = kwargs.pop('loop', None) + loop = kwargs.pop("loop", None) if loop and sys.version_info >= (3, 8): - warnings.warn("The 'loop' parameter was deprecated from asyncio's high-level" - "APIs in Python 3.8 and is no longer supported.", DeprecationWarning) - if hasattr(credential, 'get_token') and not token_intent: + warnings.warn( + "The 'loop' parameter was deprecated from asyncio's high-level" + "APIs in Python 3.8 and is no longer supported.", + DeprecationWarning, + ) + if hasattr(credential, "get_token") and not token_intent: raise ValueError("'token_intent' keyword is required when 'credential' is an AsyncTokenCredential.") parsed_url = _parse_url(account_url, share_name, file_path) path_snapshot, sas_token = parse_query(parsed_url.query) if not sas_token and not credential: raise ValueError( - 'You need to provide either an account shared key or SAS token when creating a storage service.') + "You need to provide either an account shared key or SAS token when creating a storage service." + ) self.snapshot = _parse_snapshot(snapshot, path_snapshot) self.share_name = share_name - self.file_path = file_path.split('/') + self.file_path = file_path.split("/") self.file_name = self.file_path[-1] self.directory_path = "/".join(self.file_path[:-1]) - self._query_str, credential = self._format_query_string( - sas_token, credential, share_snapshot=self.snapshot) - super(ShareFileClient, self).__init__( - parsed_url, service='file-share', credential=credential, **kwargs) - self.allow_trailing_dot = kwargs.pop('allow_trailing_dot', None) - self.allow_source_trailing_dot = kwargs.pop('allow_source_trailing_dot', None) + self._query_str, credential = self._format_query_string(sas_token, credential, share_snapshot=self.snapshot) + super(ShareFileClient, self).__init__(parsed_url, service="file-share", credential=credential, **kwargs) + self.allow_trailing_dot = kwargs.pop("allow_trailing_dot", None) + self.allow_source_trailing_dot = kwargs.pop("allow_source_trailing_dot", None) self.file_request_intent = token_intent self._client = AzureFileStorage( + url=_strip_snapshot_from_url(self.url), version=get_api_version(kwargs), - url=self.url, - base_url=self.url, pipeline=self._pipeline, - allow_trailing_dot=self.allow_trailing_dot, - allow_source_trailing_dot=self.allow_source_trailing_dot, - file_request_intent=self.file_request_intent ) async def __aenter__(self) -> Self: @@ -226,10 +242,13 @@ async def close(self) -> None: @classmethod def from_file_url( - cls, file_url: str, + cls, + file_url: str, snapshot: Optional[Union[str, Dict[str, Any]]] = None, - credential: Optional[Union[str, Dict[str, str], "AzureNamedKeyCredential", "AzureSasCredential", "AsyncTokenCredential"]] = None, # pylint: disable=line-too-long - **kwargs: Any + credential: Optional[ + Union[str, Dict[str, str], "AzureNamedKeyCredential", "AzureSasCredential", "AsyncTokenCredential"] + ] = None, # pylint: disable=line-too-long + **kwargs: Any, ) -> Self: """A client to interact with a specific file, although that file may not yet exist. @@ -265,12 +284,15 @@ def _format_url(self, hostname: str): @classmethod def from_connection_string( - cls, conn_str: str, + cls, + conn_str: str, share_name: str, file_path: str, snapshot: Optional[Union[str, Dict[str, Any]]] = None, - credential: Optional[Union[str, Dict[str, str], "AzureNamedKeyCredential", "AzureSasCredential", "AsyncTokenCredential"]] = None, # pylint: disable=line-too-long - **kwargs: Any + credential: Optional[ + Union[str, Dict[str, str], "AzureNamedKeyCredential", "AzureSasCredential", "AsyncTokenCredential"] + ] = None, # pylint: disable=line-too-long + **kwargs: Any, ) -> Self: """Create ShareFileClient from a Connection String. @@ -312,11 +334,12 @@ def from_connection_string( :dedent: 12 :caption: Creates the file client with connection string. """ - account_url, secondary, credential = parse_connection_str(conn_str, credential, 'file') - if 'secondary_hostname' not in kwargs: - kwargs['secondary_hostname'] = secondary + account_url, secondary, credential = parse_connection_str(conn_str, credential, "file") + if "secondary_hostname" not in kwargs: + kwargs["secondary_hostname"] = secondary return cls( - account_url, share_name=share_name, file_path=file_path, snapshot=snapshot, credential=credential, **kwargs) + account_url, share_name=share_name, file_path=file_path, snapshot=snapshot, credential=credential, **kwargs + ) @distributed_trace_async async def acquire_lease(self, lease_id: Optional[str] = None, **kwargs: Any) -> ShareLeaseClient: @@ -338,7 +361,7 @@ async def acquire_lease(self, lease_id: Optional[str] = None, **kwargs: Any) -> :returns: A ShareLeaseClient object. :rtype: ~azure.storage.fileshare.aio.ShareLeaseClient """ - kwargs['lease_duration'] = -1 + kwargs["lease_duration"] = -1 lease = ShareLeaseClient(self, lease_id=lease_id) await lease.acquire(**kwargs) return lease @@ -358,7 +381,12 @@ async def exists(self, **kwargs: Any) -> bool: :rtype: bool """ try: - await self._client.file.get_properties(**kwargs) + await self._client.file.get_properties( + allow_trailing_dot=self.allow_trailing_dot, + file_request_intent=self.file_request_intent, + sharesnapshot=self.snapshot, + **kwargs, + ) return True except HttpResponseError as error: try: @@ -368,13 +396,14 @@ async def exists(self, **kwargs: Any) -> bool: @distributed_trace_async async def create_file( - self, size: int, + self, + size: int, file_attributes: Optional[Union[str, "NTFSAttributes"]] = None, file_creation_time: Optional[Union[str, datetime]] = None, file_last_write_time: Optional[Union[str, datetime]] = None, file_permission: Optional[str] = None, permission_key: Optional[str] = None, - **kwargs: Any + **kwargs: Any, ) -> Dict[str, Any]: """Creates a new file. @@ -468,62 +497,65 @@ async def create_file( :dedent: 16 :caption: Create a file. """ - access_conditions = get_access_conditions(kwargs.pop('lease', None)) - content_settings = kwargs.pop('content_settings', None) - metadata = kwargs.pop('metadata', None) - timeout = kwargs.pop('timeout', None) - validate_content = parse_validation_option( - kwargs.pop('validate_content', None), - force_structured_message=True - ) + access_conditions = get_access_conditions(kwargs.pop("lease", None)) + content_settings = kwargs.pop("content_settings", None) + metadata = kwargs.pop("metadata", None) + timeout = kwargs.pop("timeout", None) + validate_content = parse_validation_option(kwargs.pop("validate_content", None), force_structured_message=True) headers = kwargs.pop("headers", {}) headers.update(add_metadata_headers(metadata)) - data = kwargs.pop('data', None) - file_http_headers = None + data = kwargs.pop("data", None) + file_http_headers = {} if content_settings: - file_http_headers = FileHTTPHeaders( - file_cache_control=content_settings.cache_control, - file_content_type=content_settings.content_type, - file_content_md5=bytearray(content_settings.content_md5) if content_settings.content_md5 else None, - file_content_encoding=content_settings.content_encoding, - file_content_language=content_settings.content_language, - file_content_disposition=content_settings.content_disposition, - ) + file_http_headers = { + "file_cache_control": content_settings.cache_control, + "file_content_type": content_settings.content_type, + "file_content_md5": bytearray(content_settings.content_md5) if content_settings.content_md5 else None, + "file_content_encoding": content_settings.content_encoding, + "file_content_language": content_settings.content_language, + "file_content_disposition": content_settings.content_disposition, + } file_permission = _get_file_permission(file_permission, permission_key, None) - file_change_time = kwargs.pop('file_change_time', None) + file_change_time = kwargs.pop("file_change_time", None) try: - return cast(Dict[str, Any], await self._client.file.create( - file_content_length=size, - metadata=metadata, - file_attributes=str(file_attributes) if file_attributes is not None else file_attributes, - file_creation_time=_datetime_to_str(file_creation_time), - file_last_write_time=_datetime_to_str(file_last_write_time), - file_change_time=_datetime_to_str(file_change_time), - file_permission=file_permission, - file_permission_key=permission_key, - file_http_headers=file_http_headers, - optionalbody=data, - validate_content=validate_content, - content_length=len(data) if data is not None else None, - lease_access_conditions=access_conditions, - headers=headers, - timeout=timeout, - cls=return_response_headers, - **kwargs - )) + return cast( + Dict[str, Any], + await self._client.file.create( + file_content_length=size, + metadata=metadata, + file_attributes=str(file_attributes) if file_attributes is not None else file_attributes, + file_creation_time=_datetime_to_str(file_creation_time), + file_last_write_time=_datetime_to_str(file_last_write_time), + file_change_time=_datetime_to_str(file_change_time), + file_permission=file_permission, + file_permission_key=permission_key, + **file_http_headers, + optional_body=data, + validate_content=validate_content, + content_length=len(data) if data is not None else None, + lease_id=access_conditions, + headers=headers, + timeout=timeout, + cls=return_response_headers, + allow_trailing_dot=self.allow_trailing_dot, + file_request_intent=self.file_request_intent, + **kwargs, + ), + ) except HttpResponseError as error: process_storage_error(error) @distributed_trace_async async def upload_file( - self, data: Union[bytes, str, Iterable[AnyStr], AsyncIterable[AnyStr], IO[bytes]], + self, + data: Union[bytes, str, Iterable[AnyStr], AsyncIterable[AnyStr], IO[bytes]], length: Optional[int] = None, file_attributes: Optional[Union[str, "NTFSAttributes"]] = None, file_creation_time: Optional[Union[str, datetime]] = None, file_last_write_time: Optional[Union[str, datetime]] = None, file_permission: Optional[str] = None, permission_key: Optional[str] = None, - **kwargs + **kwargs, ) -> Dict[str, Any]: """Uploads a new file. @@ -608,18 +640,15 @@ async def upload_file( :dedent: 16 :caption: Upload a file. """ - metadata = kwargs.pop('metadata', None) - content_settings = kwargs.pop('content_settings', None) - max_concurrency = kwargs.pop('max_concurrency', None) + metadata = kwargs.pop("metadata", None) + content_settings = kwargs.pop("content_settings", None) + max_concurrency = kwargs.pop("max_concurrency", None) if max_concurrency is None: max_concurrency = DEFAULT_MAX_CONCURRENCY - validate_content = parse_validation_option( - kwargs.pop('validate_content', None), - force_structured_message=True - ) - progress_hook = kwargs.pop('progress_hook', None) - timeout = kwargs.pop('timeout', None) - encoding = kwargs.pop('encoding', 'UTF-8') + validate_content = parse_validation_option(kwargs.pop("validate_content", None), force_structured_message=True) + progress_hook = kwargs.pop("progress_hook", None) + timeout = kwargs.pop("timeout", None) + encoding = kwargs.pop("encoding", "UTF-8") if isinstance(data, str): data = data.encode(encoding) @@ -635,7 +664,7 @@ async def upload_file( stream = data elif hasattr(data, "__iter__"): stream = IterStreamer(data, encoding=encoding) - elif hasattr(data, '__aiter__'): + elif hasattr(data, "__aiter__"): stream = AsyncIterStreamer(cast(AsyncGenerator, data), encoding=encoding) else: raise TypeError(f"Unsupported data type: {type(data)}") @@ -655,7 +684,8 @@ async def upload_file( file_permission=file_permission, file_permission_key=permission_key, progress_hook=progress_hook, - **kwargs) + **kwargs, + ) @distributed_trace_async async def start_copy_from_url(self, source_url: str, **kwargs: Any) -> Dict[str, Any]: @@ -797,32 +827,38 @@ async def start_copy_from_url(self, source_url: str, **kwargs: Any) -> Dict[str, :dedent: 16 :caption: Copy a file from a URL """ - metadata = kwargs.pop('metadata', None) - access_conditions = get_access_conditions(kwargs.pop('lease', None)) - timeout = kwargs.pop('timeout', None) - owner = kwargs.pop('owner', None) - group = kwargs.pop('group', None) - file_mode = kwargs.pop('file_mode', None) - file_mode_copy_mode = kwargs.pop('file_mode_copy_mode', None) - file_owner_copy_mode = kwargs.pop('owner_copy_mode', None) + metadata = kwargs.pop("metadata", None) + access_conditions = get_access_conditions(kwargs.pop("lease", None)) + timeout = kwargs.pop("timeout", None) + owner = kwargs.pop("owner", None) + group = kwargs.pop("group", None) + file_mode = kwargs.pop("file_mode", None) + file_mode_copy_mode = kwargs.pop("file_mode_copy_mode", None) + file_owner_copy_mode = kwargs.pop("owner_copy_mode", None) headers = kwargs.pop("headers", {}) headers.update(add_metadata_headers(metadata)) kwargs.update(get_smb_properties(kwargs)) try: - return cast(Dict[str, Any], await self._client.file.start_copy( - source_url, - metadata=metadata, - lease_access_conditions=access_conditions, - owner=owner, - group=group, - file_mode=file_mode, - file_mode_copy_mode=file_mode_copy_mode, - file_owner_copy_mode=file_owner_copy_mode, - headers=headers, - cls=return_response_headers, - timeout=timeout, - **kwargs - )) + return cast( + Dict[str, Any], + await self._client.file.start_copy( + copy_source=source_url, + metadata=metadata, + lease_id=access_conditions, + owner=owner, + group=group, + file_mode=file_mode, + file_mode_copy_mode=file_mode_copy_mode, + file_owner_copy_mode=file_owner_copy_mode, + headers=headers, + cls=return_response_headers, + timeout=timeout, + allow_trailing_dot=self.allow_trailing_dot, + allow_source_trailing_dot=self.allow_source_trailing_dot, + file_request_intent=self.file_request_intent, + **kwargs, + ), + ) except HttpResponseError as error: process_storage_error(error) @@ -852,24 +888,27 @@ async def abort_copy(self, copy_id: Union[str, FileProperties], **kwargs: Any) - #other-client--per-operation-configuration>`__. :rtype: None """ - access_conditions = get_access_conditions(kwargs.pop('lease', None)) - timeout = kwargs.pop('timeout', None) + access_conditions = get_access_conditions(kwargs.pop("lease", None)) + timeout = kwargs.pop("timeout", None) if isinstance(copy_id, FileProperties): copy_id = copy_id.copy.id elif isinstance(copy_id, Dict): - copy_id = copy_id['copy_id'] + copy_id = copy_id["copy_id"] try: - await self._client.file.abort_copy(copy_id=copy_id, - lease_access_conditions=access_conditions, - timeout=timeout, **kwargs) + await self._client.file.abort_copy( + copyid=copy_id, + lease_id=access_conditions, + timeout=timeout, + allow_trailing_dot=self.allow_trailing_dot, + file_request_intent=self.file_request_intent, + **kwargs, + ) except HttpResponseError as error: process_storage_error(error) @distributed_trace_async async def download_file( - self, offset: Optional[int] = None, - length: Optional[int] = None, - **kwargs: Any + self, offset: Optional[int] = None, length: Optional[int] = None, **kwargs: Any ) -> StorageStreamDownloader: """Downloads a file to the StorageStreamDownloader. The readall() method must be used to read all the content or readinto() must be used to download the file into @@ -931,8 +970,14 @@ async def download_file( raise ValueError("Offset value must not be None if length is set.") range_end = offset + length - 1 # Service actually uses an end-range inclusive index - access_conditions = get_access_conditions(kwargs.pop('lease', None)) - validate_content = parse_validation_option(kwargs.pop('validate_content', None)) + access_conditions = get_access_conditions(kwargs.pop("lease", None)) + + # download doesn't accept sharesnapshot as a kwarg, inject via params + if self.snapshot: + params = kwargs.pop("params", {}) or {} + params["sharesnapshot"] = self.snapshot + kwargs["params"] = params + validate_content = parse_validation_option(kwargs.pop("validate_content", None)) downloader = StorageStreamDownloader( client=self._client.file, @@ -941,11 +986,13 @@ async def download_file( end_range=range_end, validate_content=validate_content, name=self.file_name, - path='/'.join(self.file_path), + path="/".join(self.file_path), share=self.share_name, - lease_access_conditions=access_conditions, + lease_id=access_conditions, cls=deserialize_file_stream, - **kwargs + allow_trailing_dot=self.allow_trailing_dot, + file_request_intent=self.file_request_intent, + **kwargs, ) await downloader._setup() # pylint: disable=protected-access return downloader @@ -979,10 +1026,16 @@ async def delete_file(self, **kwargs: Any) -> None: :dedent: 16 :caption: Delete a file. """ - access_conditions = get_access_conditions(kwargs.pop('lease', None)) - timeout = kwargs.pop('timeout', None) + access_conditions = get_access_conditions(kwargs.pop("lease", None)) + timeout = kwargs.pop("timeout", None) try: - await self._client.file.delete(lease_access_conditions=access_conditions, timeout=timeout, **kwargs) + await self._client.file.delete( + lease_id=access_conditions, + timeout=timeout, + allow_trailing_dot=self.allow_trailing_dot, + file_request_intent=self.file_request_intent, + **kwargs, + ) except HttpResponseError as error: process_storage_error(error) @@ -1061,50 +1114,56 @@ async def rename_file(self, new_name: str, **kwargs: Any) -> "ShareFileClient": if not new_name: raise ValueError("Please specify a new file name.") - new_name = new_name.strip('/') - new_path_and_query = new_name.split('?') + new_name = new_name.strip("/") + new_path_and_query = new_name.split("?") new_file_path = new_path_and_query[0] if len(new_path_and_query) == 2: - new_file_sas = new_path_and_query[1] or self._query_str.strip('?') + new_file_sas = new_path_and_query[1] or self._query_str.strip("?") else: - new_file_sas = self._query_str.strip('?') + new_file_sas = self._query_str.strip("?") new_file_client = ShareFileClient( - f'{self.scheme}://{self.primary_hostname}', self.share_name, new_file_path, - credential=new_file_sas or self.credential, api_version=self.api_version, - _hosts=self._hosts, _configuration=self._config, _pipeline=self._pipeline, - _location_mode=self._location_mode, allow_trailing_dot=self.allow_trailing_dot, - allow_source_trailing_dot=self.allow_source_trailing_dot, token_intent=self.file_request_intent + f"{self.scheme}://{self.primary_hostname}", + self.share_name, + new_file_path, + credential=new_file_sas or self.credential, + api_version=self.api_version, + _hosts=self._hosts, + _configuration=self._config, + _pipeline=self._pipeline, + _location_mode=self._location_mode, + allow_trailing_dot=self.allow_trailing_dot, + allow_source_trailing_dot=self.allow_source_trailing_dot, + token_intent=self.file_request_intent, ) kwargs.update(get_rename_smb_properties(kwargs)) - file_http_headers = None - content_type = kwargs.pop('content_type', None) - if content_type: - file_http_headers = FileHTTPHeaders( - file_content_type=content_type - ) + file_content_type = kwargs.pop("content_type", None) - timeout = kwargs.pop('timeout', None) - overwrite = kwargs.pop('overwrite', None) - metadata = kwargs.pop('metadata', None) - headers = kwargs.pop('headers', {}) + timeout = kwargs.pop("timeout", None) + overwrite = kwargs.pop("overwrite", None) + metadata = kwargs.pop("metadata", None) + headers = kwargs.pop("headers", {}) headers.update(add_metadata_headers(metadata)) - source_access_conditions = get_source_access_conditions(kwargs.pop('source_lease', None)) - dest_access_conditions = get_dest_access_conditions(kwargs.pop('destination_lease', None)) + source_access_conditions = get_source_access_conditions(kwargs.pop("source_lease", None)) + dest_access_conditions = get_dest_access_conditions(kwargs.pop("destination_lease", None)) try: await new_file_client._client.file.rename( # pylint: disable=protected-access - self.url, + rename_source=self.url, timeout=timeout, replace_if_exists=overwrite, - file_http_headers=file_http_headers, - source_lease_access_conditions=source_access_conditions, - destination_lease_access_conditions=dest_access_conditions, + file_content_type=file_content_type, + source_lease_id=source_access_conditions, + destination_lease_id=dest_access_conditions, headers=headers, - **kwargs) + allow_trailing_dot=self.allow_trailing_dot, + allow_source_trailing_dot=self.allow_source_trailing_dot, + file_request_intent=self.file_request_intent, + **kwargs, + ) return new_file_client except HttpResponseError as error: @@ -1131,16 +1190,21 @@ async def get_file_properties(self, **kwargs: Any) -> FileProperties: :returns: FileProperties :rtype: ~azure.storage.fileshare.FileProperties """ - access_conditions = get_access_conditions(kwargs.pop('lease', None)) - timeout = kwargs.pop('timeout', None) + access_conditions = get_access_conditions(kwargs.pop("lease", None)) + timeout = kwargs.pop("timeout", None) try: - file_props = cast(FileProperties, await self._client.file.get_properties( - sharesnapshot=self.snapshot, - lease_access_conditions=access_conditions, - timeout=timeout, - cls=deserialize_file_properties, - **kwargs - )) + file_props = cast( + FileProperties, + await self._client.file.get_properties( + sharesnapshot=self.snapshot, + lease_id=access_conditions, + timeout=timeout, + cls=deserialize_file_properties, + allow_trailing_dot=self.allow_trailing_dot, + file_request_intent=self.file_request_intent, + **kwargs, + ), + ) except HttpResponseError as error: process_storage_error(error) file_props.name = self.file_name @@ -1151,13 +1215,14 @@ async def get_file_properties(self, **kwargs: Any) -> FileProperties: @distributed_trace_async async def set_http_headers( - self, content_settings: "ContentSettings", + self, + content_settings: "ContentSettings", file_attributes: Optional[Union[str, "NTFSAttributes"]] = None, file_creation_time: Optional[Union[str, datetime]] = None, file_last_write_time: Optional[Union[str, datetime]] = None, file_permission: Optional[str] = None, permission_key: Optional[str] = None, - **kwargs: Any + **kwargs: Any, ) -> Dict[str, Any]: """Sets HTTP headers on the file. @@ -1217,34 +1282,39 @@ async def set_http_headers( :returns: File-updated property dict (Etag and last modified). :rtype: dict[str, Any] """ - access_conditions = get_access_conditions(kwargs.pop('lease', None)) - timeout = kwargs.pop('timeout', None) + access_conditions = get_access_conditions(kwargs.pop("lease", None)) + timeout = kwargs.pop("timeout", None) file_content_length = kwargs.pop("size", None) - file_http_headers = FileHTTPHeaders( - file_cache_control=content_settings.cache_control, - file_content_type=content_settings.content_type, - file_content_md5=bytearray(content_settings.content_md5) if content_settings.content_md5 else None, - file_content_encoding=content_settings.content_encoding, - file_content_language=content_settings.content_language, - file_content_disposition=content_settings.content_disposition, - ) + file_http_headers = { + "file_cache_control": content_settings.cache_control, + "file_content_type": content_settings.content_type, + "file_content_md5": bytearray(content_settings.content_md5) if content_settings.content_md5 else None, + "file_content_encoding": content_settings.content_encoding, + "file_content_language": content_settings.content_language, + "file_content_disposition": content_settings.content_disposition, + } file_permission = _get_file_permission(file_permission, permission_key, None) - file_change_time = kwargs.pop('file_change_time', None) + file_change_time = kwargs.pop("file_change_time", None) try: - return cast(Dict[str, Any], await self._client.file.set_http_headers( - file_content_length=file_content_length, - file_http_headers=file_http_headers, - file_attributes=str(file_attributes) if file_attributes is not None else file_attributes, - file_creation_time=_datetime_to_str(file_creation_time), - file_last_write_time=_datetime_to_str(file_last_write_time), - file_change_time=_datetime_to_str(file_change_time), - file_permission=file_permission, - file_permission_key=permission_key, - lease_access_conditions=access_conditions, - timeout=timeout, - cls=return_response_headers, - **kwargs - )) + return cast( + Dict[str, Any], + await self._client.file.set_http_headers( + file_content_length=file_content_length, + **file_http_headers, + file_attributes=str(file_attributes) if file_attributes is not None else file_attributes, + file_creation_time=_datetime_to_str(file_creation_time), + file_last_write_time=_datetime_to_str(file_last_write_time), + file_change_time=_datetime_to_str(file_change_time), + file_permission=file_permission, + file_permission_key=permission_key, + lease_id=access_conditions, + timeout=timeout, + cls=return_response_headers, + allow_trailing_dot=self.allow_trailing_dot, + file_request_intent=self.file_request_intent, + **kwargs, + ), + ) except HttpResponseError as error: process_storage_error(error) @@ -1276,25 +1346,29 @@ async def set_file_metadata(self, metadata: Optional[Dict[str, Any]] = None, **k :returns: File-updated property dict (Etag and last modified). :rtype: dict[str, Any] """ - access_conditions = get_access_conditions(kwargs.pop('lease', None)) - timeout = kwargs.pop('timeout', None) + access_conditions = get_access_conditions(kwargs.pop("lease", None)) + timeout = kwargs.pop("timeout", None) headers = kwargs.pop("headers", {}) headers.update(add_metadata_headers(metadata)) try: - return cast(Dict[str, Any], await self._client.file.set_metadata( - metadata=metadata, lease_access_conditions=access_conditions, - timeout=timeout, cls=return_response_headers, headers=headers, **kwargs - )) + return cast( + Dict[str, Any], + await self._client.file.set_metadata( + metadata=metadata, + lease_id=access_conditions, + timeout=timeout, + cls=return_response_headers, + headers=headers, + allow_trailing_dot=self.allow_trailing_dot, + file_request_intent=self.file_request_intent, + **kwargs, + ), + ) except HttpResponseError as error: process_storage_error(error) @distributed_trace_async - async def upload_range( - self, data: bytes, - offset: int, - length: int, - **kwargs: Any - ) -> Dict[str, Any]: + async def upload_range(self, data: bytes, offset: int, length: int, **kwargs: Any) -> Dict[str, Any]: """Upload a range of bytes to a file. :param bytes data: @@ -1338,40 +1412,39 @@ async def upload_range( :returns: File-updated property dict (Etag and last modified). :rtype: Dict[str, Any] """ - validate_content = parse_validation_option( - kwargs.pop('validate_content', None), - force_structured_message=True - ) - timeout = kwargs.pop('timeout', None) - encoding = kwargs.pop('encoding', 'UTF-8') - file_last_write_mode = kwargs.pop('file_last_write_mode', None) + validate_content = parse_validation_option(kwargs.pop("validate_content", None), force_structured_message=True) + timeout = kwargs.pop("timeout", None) + encoding = kwargs.pop("encoding", "UTF-8") + file_last_write_mode = kwargs.pop("file_last_write_mode", None) if isinstance(data, str): data = data.encode(encoding) end_range = offset + length - 1 # Reformat to an inclusive range index - content_range = f'bytes={offset}-{end_range}' - access_conditions = get_access_conditions(kwargs.pop('lease', None)) + content_range = f"bytes={offset}-{end_range}" + access_conditions = get_access_conditions(kwargs.pop("lease", None)) try: - return cast(Dict[str, Any], await self._client.file.upload_range( - range=content_range, - content_length=length, - optionalbody=data, - timeout=timeout, - validate_content=validate_content, - file_last_written_mode=file_last_write_mode, - lease_access_conditions=access_conditions, - cls=return_response_headers, - **kwargs - )) + return cast( + Dict[str, Any], + await self._client.file.upload_range( + range=content_range, + file_range_write="update", + content_length=length, + optional_body=data, + timeout=timeout, + validate_content=validate_content, + file_last_written_mode=file_last_write_mode, + lease_id=access_conditions, + cls=return_response_headers, + allow_trailing_dot=self.allow_trailing_dot, + file_request_intent=self.file_request_intent, + **kwargs, + ), + ) except HttpResponseError as error: process_storage_error(error) @distributed_trace_async async def upload_range_from_url( - self, source_url: str, - offset: int, - length: int, - source_offset: int, - **kwargs: Any + self, source_url: str, offset: int, length: int, source_offset: int, **kwargs: Any ) -> Dict[str, Any]: """ Writes the bytes from one Azure File endpoint into the specified range of another Azure File endpoint. @@ -1441,12 +1514,11 @@ async def upload_range_from_url( :rtype: dict[str, Any] """ options = _upload_range_from_url_options( - source_url=source_url, - offset=offset, - length=length, - source_offset=source_offset, - **kwargs + source_url=source_url, offset=offset, length=length, source_offset=source_offset, **kwargs ) + options["allow_trailing_dot"] = self.allow_trailing_dot + options["allow_source_trailing_dot"] = self.allow_source_trailing_dot + options["file_request_intent"] = self.file_request_intent try: return cast(Dict[str, Any], await self._client.file.upload_range_from_url(**options)) except HttpResponseError as error: @@ -1454,9 +1526,7 @@ async def upload_range_from_url( @distributed_trace_async async def get_ranges( - self, offset: Optional[int] = None, - length: Optional[int] = None, - **kwargs: Any + self, offset: Optional[int] = None, length: Optional[int] = None, **kwargs: Any ) -> List[Dict[str, int]]: """Returns the list of valid page ranges for a file or snapshot of a file. @@ -1482,25 +1552,24 @@ async def get_ranges( A list of valid ranges. :rtype: List[dict[str, int]] """ - options = _get_ranges_options( - snapshot=self.snapshot, - offset=offset, - length=length, - **kwargs) + options = _get_ranges_options(snapshot=self.snapshot, offset=offset, length=length, **kwargs) + options["allow_trailing_dot"] = self.allow_trailing_dot + options["file_request_intent"] = self.file_request_intent try: ranges = await self._client.file.get_range_list(**options) except HttpResponseError as error: process_storage_error(error) - return [{'start': file_range.start, 'end': file_range.end} for file_range in ranges.ranges] + return [{"start": file_range.start, "end": file_range.end} for file_range in (ranges.ranges or [])] @distributed_trace_async async def get_ranges_diff( - self, previous_sharesnapshot: Union[str, Dict[str, Any]], + self, + previous_sharesnapshot: Union[str, Dict[str, Any]], offset: Optional[int] = None, length: Optional[int] = None, *, include_renames: Optional[bool] = None, - **kwargs: Any + **kwargs: Any, ) -> Tuple[List[Dict[str, int]], List[Dict[str, int]]]: """Returns the list of valid page ranges for a file or snapshot of a file. @@ -1541,7 +1610,10 @@ async def get_ranges_diff( length=length, previous_sharesnapshot=previous_sharesnapshot, support_rename=include_renames, - **kwargs) + **kwargs, + ) + options["allow_trailing_dot"] = self.allow_trailing_dot + options["file_request_intent"] = self.file_request_intent try: ranges = await self._client.file.get_range_list(**options) except HttpResponseError as error: @@ -1575,8 +1647,8 @@ async def clear_range(self, offset: int, length: int, **kwargs: Any) -> Dict[str :returns: File-updated property dict (Etag and last modified). :rtype: Dict[str, Any] """ - access_conditions = get_access_conditions(kwargs.pop('lease', None)) - timeout = kwargs.pop('timeout', None) + access_conditions = get_access_conditions(kwargs.pop("lease", None)) + timeout = kwargs.pop("timeout", None) if offset is None or offset % 512 != 0: raise ValueError("offset must be an integer that aligns with 512 bytes file size") @@ -1585,16 +1657,21 @@ async def clear_range(self, offset: int, length: int, **kwargs: Any) -> Dict[str end_range = length + offset - 1 # Reformat to an inclusive range index content_range = f"bytes={offset}-{end_range}" try: - return cast(Dict[str, Any], await self._client.file.upload_range( - timeout=timeout, - cls=return_response_headers, - content_length=0, - optionalbody=None, - file_range_write="clear", - range=content_range, - lease_access_conditions=access_conditions, - **kwargs - )) + return cast( + Dict[str, Any], + await self._client.file.upload_range( + timeout=timeout, + cls=return_response_headers, + content_length=0, + optional_body=None, + file_range_write="clear", + range=content_range, + lease_id=access_conditions, + allow_trailing_dot=self.allow_trailing_dot, + file_request_intent=self.file_request_intent, + **kwargs, + ), + ) except HttpResponseError as error: process_storage_error(error) @@ -1620,20 +1697,25 @@ async def resize_file(self, size: int, **kwargs: Any) -> Dict[str, Any]: :returns: File-updated property dict (Etag and last modified). :rtype: Dict[str, Any] """ - access_conditions = get_access_conditions(kwargs.pop('lease', None)) - timeout = kwargs.pop('timeout', None) + access_conditions = get_access_conditions(kwargs.pop("lease", None)) + timeout = kwargs.pop("timeout", None) try: - return cast(Dict[str, Any], await self._client.file.set_http_headers( - file_content_length=size, - file_attributes=None, - file_creation_time=None, - file_last_write_time=None, - file_permission="preserve", - lease_access_conditions=access_conditions, - cls=return_response_headers, - timeout=timeout, - **kwargs - )) + return cast( + Dict[str, Any], + await self._client.file.set_http_headers( + file_content_length=size, + file_attributes=None, + file_creation_time=None, + file_last_write_time=None, + file_permission="preserve", + lease_id=access_conditions, + cls=return_response_headers, + timeout=timeout, + allow_trailing_dot=self.allow_trailing_dot, + file_request_intent=self.file_request_intent, + **kwargs, + ), + ) except HttpResponseError as error: process_storage_error(error) @@ -1650,16 +1732,17 @@ def list_handles(self, **kwargs: Any) -> AsyncItemPaged[Handle]: :returns: An auto-paging iterable of Handle :rtype: ~azure.core.async_paging.AsyncItemPaged[~azure.storage.fileshare.Handle] """ - timeout = kwargs.pop('timeout', None) + timeout = kwargs.pop("timeout", None) results_per_page = kwargs.pop("results_per_page", None) command = functools.partial( self._client.file.list_handles, sharesnapshot=self.snapshot, timeout=timeout, - **kwargs) - return AsyncItemPaged( - command, results_per_page=results_per_page, - page_iterator_class=HandlesPaged) + allow_trailing_dot=self.allow_trailing_dot, + file_request_intent=self.file_request_intent, + **kwargs, + ) + return AsyncItemPaged(command, results_per_page=results_per_page, page_iterator_class=HandlesPaged) @distributed_trace_async async def close_handle(self, handle: Union[str, Handle], **kwargs: Any) -> Dict[str, int]: @@ -1683,19 +1766,21 @@ async def close_handle(self, handle: Union[str, Handle], **kwargs: Any) -> Dict[ handle_id = handle.id else: handle_id = handle - if handle_id == '*': + if handle_id == "*": raise ValueError("Handle ID '*' is not supported. Use 'close_all_handles' instead.") try: response = await self._client.file.force_close_handles( - handle_id, + handle_id=handle_id, marker=None, sharesnapshot=self.snapshot, cls=return_response_headers, - **kwargs + allow_trailing_dot=self.allow_trailing_dot, + file_request_intent=self.file_request_intent, + **kwargs, ) return { - 'closed_handles_count': response.get('number_of_handles_closed', 0), - 'failed_handles_count': response.get('number_of_handles_failed', 0) + "closed_handles_count": response.get("number_of_handles_closed", 0), + "failed_handles_count": response.get("number_of_handles_failed", 0), } except HttpResponseError as error: process_storage_error(error) @@ -1717,7 +1802,7 @@ async def close_all_handles(self, **kwargs: Any) -> Dict[str, int]: and the number of handles failed to close in a dict. :rtype: dict[str, int] """ - timeout = kwargs.pop('timeout', None) + timeout = kwargs.pop("timeout", None) start_time = time.time() try_close = True @@ -1727,33 +1812,33 @@ async def close_all_handles(self, **kwargs: Any) -> Dict[str, int]: while try_close: try: response = await self._client.file.force_close_handles( - handle_id='*', + handle_id="*", timeout=timeout, marker=continuation_token, sharesnapshot=self.snapshot, cls=return_response_headers, - **kwargs + allow_trailing_dot=self.allow_trailing_dot, + file_request_intent=self.file_request_intent, + **kwargs, ) except HttpResponseError as error: process_storage_error(error) - continuation_token = response.get('marker') + continuation_token = response.get("marker") try_close = bool(continuation_token) - total_closed += response.get('number_of_handles_closed', 0) - total_failed += response.get('number_of_handles_failed', 0) + total_closed += response.get("number_of_handles_closed", 0) + total_failed += response.get("number_of_handles_failed", 0) if timeout: timeout = max(0, timeout - (time.time() - start_time)) - return { - 'closed_handles_count': total_closed, - 'failed_handles_count': total_failed - } + return {"closed_handles_count": total_closed, "failed_handles_count": total_failed} @distributed_trace_async async def create_hardlink( - self, target: str, + self, + target: str, *, lease: Optional[Union[ShareLeaseClient, str]] = None, timeout: Optional[int] = None, - **kwargs: Any + **kwargs: Any, ) -> Dict[str, Any]: """NFS only. Creates a hard link to the file specified by path. @@ -1775,19 +1860,24 @@ async def create_hardlink( :rtype: dict[str, Any] """ try: - return cast(Dict[str, Any], await self._client.file.create_hard_link( - target_file=target, - lease_access_conditions=lease, - timeout=timeout, - cls=return_response_headers, - **kwargs - )) + return cast( + Dict[str, Any], + await self._client.file.create_hard_link( + target_file=target, + lease_id=lease, + timeout=timeout, + cls=return_response_headers, + file_request_intent=self.file_request_intent, + **kwargs, + ), + ) except HttpResponseError as error: process_storage_error(error) @distributed_trace_async async def create_symlink( - self, target: str, + self, + target: str, *, metadata: Optional[Dict[str, str]] = None, file_creation_time: Optional[Union[str, datetime]] = None, @@ -1796,7 +1886,7 @@ async def create_symlink( group: Optional[str] = None, lease: Optional[Union[ShareLeaseClient, str]] = None, timeout: Optional[int] = None, - **kwargs: Any + **kwargs: Any, ) -> Dict[str, Any]: """NFS only. Creates a symbolic link to the specified file. @@ -1824,28 +1914,27 @@ async def create_symlink( :rtype: dict[str, Any] """ try: - return cast(Dict[str, Any], await self._client.file.create_symbolic_link( - link_text=target, - metadata=metadata, - file_creation_time=file_creation_time, - file_last_write_time=file_last_write_time, - owner=owner, - group=group, - lease_access_conditions=lease, - timeout=timeout, - cls=return_response_headers, - **kwargs - )) + return cast( + Dict[str, Any], + await self._client.file.create_symbolic_link( + link_text=target, + metadata=metadata, + file_creation_time=file_creation_time, + file_last_write_time=file_last_write_time, + owner=owner, + group=group, + lease_id=lease, + timeout=timeout, + cls=return_response_headers, + file_request_intent=self.file_request_intent, + **kwargs, + ), + ) except HttpResponseError as error: process_storage_error(error) @distributed_trace_async - async def get_symlink( - self, - *, - timeout: Optional[int] = None, - **kwargs: Any - ) -> Dict[str, Any]: + async def get_symlink(self, *, timeout: Optional[int] = None, **kwargs: Any) -> Dict[str, Any]: """NFS only. Gets the symbolic link for the file client. :keyword int timeout: @@ -1858,10 +1947,14 @@ async def get_symlink( :rtype: dict[str, Any] """ try: - return cast(Dict[str, Any], await self._client.file.get_symbolic_link( - timeout=timeout, - cls=return_response_headers, - **kwargs - )) + return cast( + Dict[str, Any], + await self._client.file.get_symbolic_link( + timeout=timeout, + cls=return_response_headers, + file_request_intent=self.file_request_intent, + **kwargs, + ), + ) except HttpResponseError as error: process_storage_error(error) diff --git a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/aio/_file_client_async.pyi b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/aio/_file_client_async.pyi index 905f5a2bb002..49555a8964f4 100644 --- a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/aio/_file_client_async.pyi +++ b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/aio/_file_client_async.pyi @@ -135,7 +135,7 @@ class ShareFileClient(AsyncStorageAccountHostsMixin, StorageAccountHostsMixin): file_mode: Optional[str] = None, file_property_semantics: Optional[Literal["New", "Restore"]] = None, data: Optional[bytes] = None, - validate_content: Optional[Literal['auto', 'crc64', 'md5']] = None, + validate_content: Optional[Literal["auto", "crc64", "md5"]] = None, timeout: Optional[int] = None, **kwargs: Any ) -> Dict[str, Any]: ... @@ -152,7 +152,7 @@ class ShareFileClient(AsyncStorageAccountHostsMixin, StorageAccountHostsMixin): file_change_time: Optional[Union[str, datetime]] = None, metadata: Optional[Dict[str, str]] = None, content_settings: Optional[ContentSettings] = None, - validate_content: Optional[Union[bool, Literal['auto', 'crc64', 'md5']]] = None, + validate_content: Optional[Union[bool, Literal["auto", "crc64", "md5"]]] = None, max_concurrency: Optional[int] = None, lease: Optional[Union[ShareLeaseClient, str]] = None, progress_hook: Optional[Callable[[int, Optional[int]], Awaitable[None]]] = None, @@ -200,7 +200,7 @@ class ShareFileClient(AsyncStorageAccountHostsMixin, StorageAccountHostsMixin): length: Optional[int] = None, *, max_concurrency: Optional[int] = None, - validate_content: Optional[Union[bool, Literal['auto', 'crc64', 'md5']]] = None, + validate_content: Optional[Union[bool, Literal["auto", "crc64", "md5"]]] = None, lease: Optional[Union[ShareLeaseClient, str]] = None, progress_hook: Optional[Callable[[int, Optional[int]], Awaitable[None]]] = None, decompress: Optional[bool] = None, @@ -271,7 +271,7 @@ class ShareFileClient(AsyncStorageAccountHostsMixin, StorageAccountHostsMixin): offset: int, length: int, *, - validate_content: Optional[Union[bool, Literal['auto', 'crc64', 'md5']]] = None, + validate_content: Optional[Union[bool, Literal["auto", "crc64", "md5"]]] = None, file_last_write_mode: Optional[Literal["preserve", "now"]] = None, lease: Optional[Union[ShareLeaseClient, str]] = None, encoding: str = "UTF-8", diff --git a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/aio/_lease_async.py b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/aio/_lease_async.py index 440ad12326ca..ae3d3a747743 100644 --- a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/aio/_lease_async.py +++ b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/aio/_lease_async.py @@ -1,3 +1,4 @@ +# pylint: disable=line-too-long,useless-suppression # ------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for @@ -53,18 +54,20 @@ class ShareLeaseClient: # pylint: disable=client-accepts-api-version-keyword This will be `None` if no lease has yet been acquired or modified.""" def __init__( # pylint: disable=missing-client-constructor-parameter-credential, missing-client-constructor-parameter-kwargs - self, client: Union["ShareFileClient", "ShareClient"], - lease_id: Optional[str] = None + self, client: Union["ShareFileClient", "ShareClient"], lease_id: Optional[str] = None ) -> None: self.id = lease_id or str(uuid.uuid4()) self.last_modified = None self.etag = None - if hasattr(client, 'file_name'): + self._file_request_intent = getattr(client, "file_request_intent", None) + if hasattr(client, "file_name"): self._client = client._client.file # type: ignore self._snapshot = None - elif hasattr(client, 'share_name'): + self._allow_trailing_dot = getattr(client, "allow_trailing_dot", None) + elif hasattr(client, "share_name"): self._client = client._client.share self._snapshot = client.snapshot + self._allow_trailing_dot = None else: raise TypeError("Lease must use ShareFileClient or ShareClient.") @@ -100,20 +103,24 @@ async def acquire(self, **kwargs: Any) -> None: :rtype: None """ try: - lease_duration = kwargs.pop('lease_duration', -1) + lease_duration = kwargs.pop("lease_duration", -1) if self._snapshot: - kwargs['sharesnapshot'] = self._snapshot + kwargs["sharesnapshot"] = self._snapshot + if self._allow_trailing_dot is not None: + kwargs["allow_trailing_dot"] = self._allow_trailing_dot response = await self._client.acquire_lease( - timeout=kwargs.pop('timeout', None), - duration=lease_duration, + timeout=kwargs.pop("timeout", None), + lease_duration=lease_duration, proposed_lease_id=self.id, + file_request_intent=self._file_request_intent, cls=return_response_headers, - **kwargs) + **kwargs + ) except HttpResponseError as error: process_storage_error(error) - self.id = response.get('lease_id') - self.last_modified = response.get('last_modified') - self.etag = response.get('etag') + self.id = response.get("lease_id") + self.last_modified = response.get("last_modified") + self.etag = response.get("etag") @distributed_trace_async async def renew(self, **kwargs: Any) -> None: @@ -140,15 +147,17 @@ async def renew(self, **kwargs: Any) -> None: try: response = await self._client.renew_lease( lease_id=self.id, - timeout=kwargs.pop('timeout', None), + timeout=kwargs.pop("timeout", None), sharesnapshot=self._snapshot, + file_request_intent=self._file_request_intent, cls=return_response_headers, - **kwargs) + **kwargs + ) except HttpResponseError as error: process_storage_error(error) - self.etag = response.get('etag') - self.id = response.get('lease_id') - self.last_modified = response.get('last_modified') + self.etag = response.get("etag") + self.id = response.get("lease_id") + self.last_modified = response.get("last_modified") @distributed_trace_async async def release(self, **kwargs: Any) -> None: @@ -166,21 +175,25 @@ async def release(self, **kwargs: Any) -> None: """ try: if self._snapshot: - kwargs['sharesnapshot'] = self._snapshot + kwargs["sharesnapshot"] = self._snapshot + if self._allow_trailing_dot is not None: + kwargs["allow_trailing_dot"] = self._allow_trailing_dot response = await self._client.release_lease( lease_id=self.id, - timeout=kwargs.pop('timeout', None), + timeout=kwargs.pop("timeout", None), + file_request_intent=self._file_request_intent, cls=return_response_headers, - **kwargs) + **kwargs + ) except HttpResponseError as error: process_storage_error(error) - self.etag = response.get('etag') - self.id = response.get('lease_id') - self.last_modified = response.get('last_modified') + self.etag = response.get("etag") + self.id = response.get("lease_id") + self.last_modified = response.get("last_modified") @distributed_trace_async async def change(self, proposed_lease_id: str, **kwargs: Any) -> None: - """ Changes the lease ID of an active lease. A change must include the current lease ID in x-ms-lease-id and + """Changes the lease ID of an active lease. A change must include the current lease ID in x-ms-lease-id and a new lease ID in x-ms-proposed-lease-id. :param str proposed_lease_id: @@ -196,18 +209,22 @@ async def change(self, proposed_lease_id: str, **kwargs: Any) -> None: """ try: if self._snapshot: - kwargs['sharesnapshot'] = self._snapshot + kwargs["sharesnapshot"] = self._snapshot + if self._allow_trailing_dot is not None: + kwargs["allow_trailing_dot"] = self._allow_trailing_dot response = await self._client.change_lease( lease_id=self.id, proposed_lease_id=proposed_lease_id, - timeout=kwargs.pop('timeout', None), + timeout=kwargs.pop("timeout", None), + file_request_intent=self._file_request_intent, cls=return_response_headers, - **kwargs) + **kwargs + ) except HttpResponseError as error: process_storage_error(error) - self.etag = response.get('etag') - self.id = response.get('lease_id') - self.last_modified = response.get('last_modified') + self.etag = response.get("etag") + self.id = response.get("lease_id") + self.last_modified = response.get("last_modified") @distributed_trace_async async def break_lease(self, **kwargs: Any) -> int: @@ -242,18 +259,23 @@ async def break_lease(self, **kwargs: Any) -> int: :rtype: int """ try: - lease_break_period = kwargs.pop('lease_break_period', None) + lease_break_period = kwargs.pop("lease_break_period", None) if self._snapshot: - kwargs['sharesnapshot'] = self._snapshot + kwargs["sharesnapshot"] = self._snapshot if isinstance(self._client, ShareOperations): - kwargs['break_period'] = lease_break_period + kwargs["break_period"] = lease_break_period if isinstance(self._client, FileOperations) and lease_break_period: raise TypeError("Setting a lease break period is only applicable to Share leases.") + if self._allow_trailing_dot is not None: + kwargs["allow_trailing_dot"] = self._allow_trailing_dot + response = await self._client.break_lease( - timeout=kwargs.pop('timeout', None), + timeout=kwargs.pop("timeout", None), + file_request_intent=self._file_request_intent, cls=return_response_headers, - **kwargs) + **kwargs + ) except HttpResponseError as error: process_storage_error(error) - return cast(int, response.get('lease_time')) + return cast(int, response.get("lease_time")) diff --git a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/aio/_lease_async.pyi b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/aio/_lease_async.pyi index 451f6a9d21ac..b15a5716d707 100644 --- a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/aio/_lease_async.pyi +++ b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/aio/_lease_async.pyi @@ -15,27 +15,17 @@ from azure.core.tracing.decorator_async import distributed_trace_async from ._file_client_async import ShareFileClient from ._share_client_async import ShareClient - class ShareLeaseClient: id: str etag: Optional[str] last_modified: Optional[datetime] - def __init__( - self, client: Union[ShareFileClient, ShareClient], - lease_id: Optional[str] = None - ) -> None: ... + def __init__(self, client: Union[ShareFileClient, ShareClient], lease_id: Optional[str] = None) -> None: ... async def __aenter__(self) -> Self: ... async def __aexit__( self, typ: Optional[type[BaseException]], exc: Optional[BaseException], tb: Optional[TracebackType] ) -> None: ... @distributed_trace_async - async def acquire( - self, - *, - lease_duration: int = -1, - timeout: Optional[int] = None, - **kwargs: Any - ) -> None: ... + async def acquire(self, *, lease_duration: int = -1, timeout: Optional[int] = None, **kwargs: Any) -> None: ... @distributed_trace_async async def renew(self, *, timeout: Optional[int] = None, **kwargs: Any) -> None: ... @distributed_trace_async @@ -44,9 +34,5 @@ class ShareLeaseClient: async def change(self, proposed_lease_id: str, *, timeout: Optional[int] = None, **kwargs: Any) -> None: ... @distributed_trace_async async def break_lease( - self, - *, - lease_break_period: Optional[int] = None, - timeout: Optional[int] = None, - **kwargs: Any + self, *, lease_break_period: Optional[int] = None, timeout: Optional[int] = None, **kwargs: Any ) -> int: ... diff --git a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/aio/_models.py b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/aio/_models.py index 4e378e3b8715..35cafac5975f 100644 --- a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/aio/_models.py +++ b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/aio/_models.py @@ -5,9 +5,7 @@ # -------------------------------------------------------------------------- # pylint: disable=too-few-public-methods -from typing import ( - Any, Callable, Dict, List, Optional -) +from typing import Any, Callable, Dict, List, Optional from azure.core.async_paging import AsyncPageIterator from azure.core.exceptions import HttpResponseError @@ -19,8 +17,8 @@ def _wrap_item(item): if isinstance(item, DirectoryItem): - return {'name': item.name, 'is_directory': True} - return {'name': item.name, 'size': item.properties.content_length, 'is_directory': False} + return {"name": item.name, "is_directory": True} + return {"name": item.name, "size": item.properties.content_length, "is_directory": False} class SharePropertiesPaged(AsyncPageIterator): @@ -49,15 +47,14 @@ class SharePropertiesPaged(AsyncPageIterator): """The current page of listed results.""" def __init__( - self, command: Callable, + self, + command: Callable, prefix: Optional[str] = None, results_per_page: Optional[int] = None, - continuation_token: Optional[str] = None + continuation_token: Optional[str] = None, ) -> None: super(SharePropertiesPaged, self).__init__( - get_next=self._get_next_cb, - extract_data=self._extract_data_cb, - continuation_token=continuation_token or "" + get_next=self._get_next_cb, extract_data=self._extract_data_cb, continuation_token=continuation_token or "" ) self._command = command self.service_endpoint = None @@ -74,7 +71,8 @@ async def _get_next_cb(self, continuation_token): maxresults=self.results_per_page, prefix=self.prefix, cls=return_context_and_deserialized, - use_location=self.location_mode) + use_location=self.location_mode, + ) except HttpResponseError as error: process_storage_error(error) @@ -84,7 +82,9 @@ async def _extract_data_cb(self, get_next_return): self.prefix = self._response.prefix self.marker = self._response.marker self.results_per_page = self._response.max_results - self.current_page = [ShareProperties._from_generated(i) for i in self._response.share_items] # pylint: disable=protected-access + self.current_page = [ + ShareProperties._from_generated(i) for i in self._response.share_items # pylint: disable=protected-access + ] return self._response.next_marker or None, self.current_page @@ -107,14 +107,10 @@ class HandlesPaged(AsyncPageIterator): """The current page of listed results.""" def __init__( - self, command: Callable, - results_per_page: Optional[int] = None, - continuation_token: Optional[str] = None + self, command: Callable, results_per_page: Optional[int] = None, continuation_token: Optional[str] = None ) -> None: super(HandlesPaged, self).__init__( - get_next=self._get_next_cb, - extract_data=self._extract_data_cb, - continuation_token=continuation_token or "" + get_next=self._get_next_cb, extract_data=self._extract_data_cb, continuation_token=continuation_token or "" ) self._command = command self.marker = None @@ -128,13 +124,16 @@ async def _get_next_cb(self, continuation_token): marker=continuation_token or None, maxresults=self.results_per_page, cls=return_context_and_deserialized, - use_location=self.location_mode) + use_location=self.location_mode, + ) except HttpResponseError as error: process_storage_error(error) async def _extract_data_cb(self, get_next_return): self.location_mode, self._response = get_next_return - self.current_page = [Handle._from_generated(h) for h in self._response.handle_list] # pylint: disable=protected-access + self.current_page = [ + Handle._from_generated(h) for h in self._response.handle_list # pylint: disable=protected-access + ] return self._response.next_marker or None, self.current_page @@ -168,15 +167,14 @@ class DirectoryPropertiesPaged(AsyncPageIterator): """The current page of listed results.""" def __init__( - self, command: Callable, + self, + command: Callable, prefix: Optional[str] = None, results_per_page: Optional[int] = None, - continuation_token: Optional[str] = None + continuation_token: Optional[str] = None, ) -> None: super(DirectoryPropertiesPaged, self).__init__( - get_next=self._get_next_cb, - extract_data=self._extract_data_cb, - continuation_token=continuation_token or "" + get_next=self._get_next_cb, extract_data=self._extract_data_cb, continuation_token=continuation_token or "" ) self._command = command self.service_endpoint = None @@ -193,7 +191,8 @@ async def _get_next_cb(self, continuation_token): prefix=self.prefix, maxresults=self.results_per_page, cls=return_context_and_deserialized, - use_location=self.location_mode) + use_location=self.location_mode, + ) except HttpResponseError as error: process_storage_error(error) @@ -202,6 +201,14 @@ async def _extract_data_cb(self, get_next_return): self.service_endpoint = self._response.service_endpoint self.marker = self._response.marker self.results_per_page = self._response.max_results - self.current_page = [DirectoryProperties._from_generated(i) for i in self._response.segment.directory_items] # pylint: disable = protected-access - self.current_page.extend([FileProperties._from_generated(i) for i in self._response.segment.file_items]) # pylint: disable = protected-access + self.current_page = [ + DirectoryProperties._from_generated(i) # pylint: disable=protected-access + for i in self._response.segment.directory_items + ] + self.current_page.extend( + [ + FileProperties._from_generated(i) # pylint: disable=protected-access + for i in self._response.segment.file_items + ] + ) return self._response.next_marker or None, self.current_page diff --git a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/aio/_share_client_async.py b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/aio/_share_client_async.py index 8f6be194dc5c..a4b2360c6181 100644 --- a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/aio/_share_client_async.py +++ b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/aio/_share_client_async.py @@ -1,3 +1,4 @@ +# pylint: disable=line-too-long,useless-suppression,too-many-lines # ------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for @@ -7,10 +8,7 @@ import sys import warnings -from typing import ( - Any, cast, Dict, Literal, Optional, Union, - TYPE_CHECKING -) +from typing import Any, cast, Dict, Literal, Optional, Union, TYPE_CHECKING from typing_extensions import Self from azure.core.async_paging import AsyncItemPaged @@ -19,29 +17,16 @@ from azure.core.tracing.decorator import distributed_trace from azure.core.tracing.decorator_async import distributed_trace_async from .._deserialize import deserialize_permission, deserialize_share_properties -from .._generated.aio import AzureFileStorage -from .._generated.models import ( - DeleteSnapshotsOptionType, - ShareStats, - SignedIdentifier -) +from .._generated.aio import FileClient as AzureFileStorage +from .._generated.models import DeleteSnapshotsOptionType, ShareStats, SignedIdentifier, SignedIdentifiers from .._models import ShareProtocols -from .._parser import _parse_snapshot -from .._share_client_helpers import ( - _create_permission_for_share_options, - _format_url, - _from_share_url, - _parse_url -) +from .._parser import _parse_snapshot, _strip_snapshot_from_url +from .._share_client_helpers import _create_permission_for_share_options, _format_url, _from_share_url, _parse_url from .._shared.policies_async import ExponentialRetry from .._shared.base_client import parse_query, StorageAccountHostsMixin from .._shared.base_client_async import AsyncStorageAccountHostsMixin, AsyncTransportWrapper, parse_connection_str from .._shared.request_handlers import add_metadata_headers, serialize_iso -from .._shared.response_handlers import ( - process_storage_error, - return_headers_and_deserialized, - return_response_headers -) +from .._shared.response_handlers import process_storage_error, return_headers_and_deserialized, return_response_headers from .._serialize import get_access_conditions, get_api_version from ..aio._lease_async import ShareLeaseClient from ._directory_client_async import ShareDirectoryClient @@ -102,44 +87,48 @@ class ShareClient(AsyncStorageAccountHostsMixin, StorageAccountHostsMixin): # t The hostname of the secondary endpoint. :keyword int max_range_size: The maximum range size used for a file upload. Defaults to 4*1024*1024. """ + def __init__( - self, account_url: str, + self, + account_url: str, share_name: str, snapshot: Optional[Union[str, Dict[str, Any]]] = None, - credential: Optional[Union[str, Dict[str, str], "AzureNamedKeyCredential", "AzureSasCredential", "AsyncTokenCredential"]] = None, # pylint: disable=line-too-long + credential: Optional[ + Union[str, Dict[str, str], "AzureNamedKeyCredential", "AzureSasCredential", "AsyncTokenCredential"] + ] = None, # pylint: disable=line-too-long *, - token_intent: Optional[Literal['backup']] = None, + token_intent: Optional[Literal["backup"]] = None, **kwargs: Any ) -> None: - kwargs['retry_policy'] = kwargs.get('retry_policy') or ExponentialRetry(**kwargs) - loop = kwargs.pop('loop', None) + kwargs["retry_policy"] = kwargs.get("retry_policy") or ExponentialRetry(**kwargs) + loop = kwargs.pop("loop", None) if loop and sys.version_info >= (3, 8): - warnings.warn("The 'loop' parameter was deprecated from asyncio's high-level" - "APIs in Python 3.8 and is no longer supported.", DeprecationWarning) - if hasattr(credential, 'get_token') and not token_intent: + warnings.warn( + "The 'loop' parameter was deprecated from asyncio's high-level" + "APIs in Python 3.8 and is no longer supported.", + DeprecationWarning, + ) + if hasattr(credential, "get_token") and not token_intent: raise ValueError("'token_intent' keyword is required when 'credential' is an AsyncTokenCredential.") parsed_url = _parse_url(account_url, share_name) path_snapshot, sas_token = parse_query(parsed_url.query) if not sas_token and not credential: raise ValueError( - 'You need to provide either an account shared key or SAS token when creating a storage service.') + "You need to provide either an account shared key or SAS token when creating a storage service." + ) self.snapshot = _parse_snapshot(snapshot, path_snapshot) self.share_name = share_name self._query_str, credential = self._format_query_string( - sas_token=sas_token, credential=credential, share_snapshot=self.snapshot) - super(ShareClient, self).__init__( - parsed_url=parsed_url, service='file-share', credential=credential, **kwargs) - self.allow_trailing_dot = kwargs.pop('allow_trailing_dot', None) - self.allow_source_trailing_dot = kwargs.pop('allow_source_trailing_dot', None) + sas_token=sas_token, credential=credential, share_snapshot=self.snapshot + ) + super(ShareClient, self).__init__(parsed_url=parsed_url, service="file-share", credential=credential, **kwargs) + self.allow_trailing_dot = kwargs.pop("allow_trailing_dot", None) + self.allow_source_trailing_dot = kwargs.pop("allow_source_trailing_dot", None) self.file_request_intent = token_intent self._client = AzureFileStorage( + url=_strip_snapshot_from_url(self.url), version=get_api_version(kwargs), - url=self.url, - base_url=self.url, pipeline=self._pipeline, - allow_trailing_dot=self.allow_trailing_dot, - allow_source_trailing_dot=self.allow_source_trailing_dot, - file_request_intent=self.file_request_intent ) async def __aenter__(self) -> Self: @@ -160,9 +149,12 @@ async def close(self) -> None: @classmethod def from_share_url( - cls, share_url: str, + cls, + share_url: str, snapshot: Optional[Union[str, Dict[str, Any]]] = None, - credential: Optional[Union[str, Dict[str, str], "AzureNamedKeyCredential", "AzureSasCredential", "AsyncTokenCredential"]] = None, # pylint: disable=line-too-long + credential: Optional[ + Union[str, Dict[str, str], "AzureNamedKeyCredential", "AzureSasCredential", "AsyncTokenCredential"] + ] = None, # pylint: disable=line-too-long **kwargs: Any ) -> Self: """ @@ -203,10 +195,13 @@ def _format_url(self, hostname: str) -> str: @classmethod def from_connection_string( - cls, conn_str: str, + cls, + conn_str: str, share_name: str, snapshot: Optional[Union[str, Dict[str, Any]]] = None, - credential: Optional[Union[str, Dict[str, str], "AzureNamedKeyCredential", "AzureSasCredential", "AsyncTokenCredential"]] = None, # pylint: disable=line-too-long + credential: Optional[ + Union[str, Dict[str, str], "AzureNamedKeyCredential", "AzureSasCredential", "AsyncTokenCredential"] + ] = None, # pylint: disable=line-too-long **kwargs: Any ) -> Self: """Create ShareClient from a Connection String. @@ -244,11 +239,10 @@ def from_connection_string( :dedent: 8 :caption: Gets the share client from connection string. """ - account_url, secondary, credential = parse_connection_str(conn_str, credential, 'file') - if 'secondary_hostname' not in kwargs: - kwargs['secondary_hostname'] = secondary - return cls( - account_url, share_name=share_name, snapshot=snapshot, credential=credential, **kwargs) + account_url, secondary, credential = parse_connection_str(conn_str, credential, "file") + if "secondary_hostname" not in kwargs: + kwargs["secondary_hostname"] = secondary + return cls(account_url, share_name=share_name, snapshot=snapshot, credential=credential, **kwargs) def get_directory_client(self, directory_path: Optional[str] = None) -> ShareDirectoryClient: """Get a client to interact with the specified directory. @@ -261,14 +255,24 @@ def get_directory_client(self, directory_path: Optional[str] = None) -> ShareDir """ _pipeline = AsyncPipeline( transport=AsyncTransportWrapper(self._pipeline._transport), # pylint: disable=protected-access - policies=self._pipeline._impl_policies # type: ignore [arg-type] # pylint: disable=protected-access + policies=self._pipeline._impl_policies, # type: ignore [arg-type] # pylint: disable=protected-access ) return ShareDirectoryClient( - self.url, share_name=self.share_name, directory_path=directory_path or "", snapshot=self.snapshot, - credential=self.credential, api_version=self.api_version, _hosts=self._hosts, _configuration=self._config, - _pipeline=_pipeline, _location_mode=self._location_mode, allow_trailing_dot=self.allow_trailing_dot, - allow_source_trailing_dot=self.allow_source_trailing_dot, token_intent=self.file_request_intent) + self.url, + share_name=self.share_name, + directory_path=directory_path or "", + snapshot=self.snapshot, + credential=self.credential, + api_version=self.api_version, + _hosts=self._hosts, + _configuration=self._config, + _pipeline=_pipeline, + _location_mode=self._location_mode, + allow_trailing_dot=self.allow_trailing_dot, + allow_source_trailing_dot=self.allow_source_trailing_dot, + token_intent=self.file_request_intent, + ) def get_file_client(self, file_path: str) -> ShareFileClient: """Get a client to interact with the specified file. @@ -281,14 +285,24 @@ def get_file_client(self, file_path: str) -> ShareFileClient: """ _pipeline = AsyncPipeline( transport=AsyncTransportWrapper(self._pipeline._transport), # pylint: disable=protected-access - policies=self._pipeline._impl_policies # type: ignore [arg-type] # pylint: disable=protected-access + policies=self._pipeline._impl_policies, # type: ignore [arg-type] # pylint: disable=protected-access ) return ShareFileClient( - self.url, share_name=self.share_name, file_path=file_path, snapshot=self.snapshot, - credential=self.credential, api_version=self.api_version, _hosts=self._hosts, _configuration=self._config, - _pipeline=_pipeline, _location_mode=self._location_mode, allow_trailing_dot=self.allow_trailing_dot, - allow_source_trailing_dot=self.allow_source_trailing_dot, token_intent=self.file_request_intent) + self.url, + share_name=self.share_name, + file_path=file_path, + snapshot=self.snapshot, + credential=self.credential, + api_version=self.api_version, + _hosts=self._hosts, + _configuration=self._config, + _pipeline=_pipeline, + _location_mode=self._location_mode, + allow_trailing_dot=self.allow_trailing_dot, + allow_source_trailing_dot=self.allow_source_trailing_dot, + token_intent=self.file_request_intent, + ) @distributed_trace_async async def acquire_lease(self, **kwargs: Any) -> ShareLeaseClient: @@ -317,8 +331,8 @@ async def acquire_lease(self, **kwargs: Any) -> ShareLeaseClient: :returns: A ShareLeaseClient object. :rtype: ~azure.storage.fileshare.ShareLeaseClient """ - kwargs['lease_duration'] = kwargs.pop('lease_duration', -1) - lease_id = kwargs.pop('lease_id', None) + kwargs["lease_duration"] = kwargs.pop("lease_duration", -1) + lease_id = kwargs.pop("lease_id", None) lease = ShareLeaseClient(self, lease_id=lease_id) await lease.acquire(**kwargs) return lease @@ -370,38 +384,43 @@ async def create_share(self, **kwargs: Any) -> Dict[str, Any]: :dedent: 12 :caption: Creates a file share. """ - metadata = kwargs.pop('metadata', None) - quota = kwargs.pop('quota', None) - access_tier = kwargs.pop('access_tier', None) - timeout = kwargs.pop('timeout', None) - root_squash = kwargs.pop('root_squash', None) - protocols = kwargs.pop('protocols', None) - paid_bursting_bandwidth_mibps = kwargs.pop('paid_bursting_bandwidth_mibps', None) - paid_bursting_iops = kwargs.pop('paid_bursting_iops', None) - share_provisioned_iops = kwargs.pop('provisioned_iops', None) - share_provisioned_bandwidth_mibps = kwargs.pop('provisioned_bandwidth_mibps', None) - if protocols and protocols not in ['NFS', 'SMB', ShareProtocols.SMB, ShareProtocols.NFS]: + metadata = kwargs.pop("metadata", None) + quota = kwargs.pop("quota", None) + access_tier = kwargs.pop("access_tier", None) + timeout = kwargs.pop("timeout", None) + root_squash = kwargs.pop("root_squash", None) + protocols = kwargs.pop("protocols", None) + paid_bursting_bandwidth_mibps = kwargs.pop("paid_bursting_bandwidth_mibps", None) + paid_bursting_iops = kwargs.pop("paid_bursting_iops", None) + share_provisioned_iops = kwargs.pop("provisioned_iops", None) + share_provisioned_bandwidth_mibps = kwargs.pop("provisioned_bandwidth_mibps", None) + if protocols and protocols not in ["NFS", "SMB", ShareProtocols.SMB, ShareProtocols.NFS]: raise ValueError("The enabled protocol must be set to either SMB or NFS.") - if root_squash and protocols not in ['NFS', ShareProtocols.NFS]: + if root_squash and protocols not in ["NFS", ShareProtocols.NFS]: raise ValueError("The 'root_squash' keyword can only be used on NFS enabled shares.") - headers = kwargs.pop('headers', {}) + headers = kwargs.pop("headers", {}) headers.update(add_metadata_headers(metadata)) try: - return cast(Dict[str, Any], await self._client.share.create( - timeout=timeout, - metadata=metadata, - quota=quota, - access_tier=access_tier, - root_squash=root_squash, - enabled_protocols=protocols, - paid_bursting_max_bandwidth_mibps=paid_bursting_bandwidth_mibps, - paid_bursting_max_iops=paid_bursting_iops, - share_provisioned_iops=share_provisioned_iops, - share_provisioned_bandwidth_mibps=share_provisioned_bandwidth_mibps, - cls=return_response_headers, - headers=headers, - **kwargs)) + return cast( + Dict[str, Any], + await self._client.share.create( + timeout=timeout, + metadata=metadata, + quota=quota, + access_tier=access_tier, + root_squash=root_squash, + enabled_protocols=protocols, + paid_bursting_max_bandwidth_mibps=paid_bursting_bandwidth_mibps, + paid_bursting_max_iops=paid_bursting_iops, + share_provisioned_iops=share_provisioned_iops, + share_provisioned_bandwidth_mibps=share_provisioned_bandwidth_mibps, + cls=return_response_headers, + headers=headers, + file_request_intent=self.file_request_intent, + **kwargs + ), + ) except HttpResponseError as error: process_storage_error(error) @@ -438,23 +457,27 @@ async def create_snapshot(self, **kwargs: Any) -> Dict[str, Any]: :dedent: 16 :caption: Creates a snapshot of the file share. """ - metadata = kwargs.pop('metadata', None) - timeout = kwargs.pop('timeout', None) - headers = kwargs.pop('headers', {}) + metadata = kwargs.pop("metadata", None) + timeout = kwargs.pop("timeout", None) + headers = kwargs.pop("headers", {}) headers.update(add_metadata_headers(metadata)) try: - return cast(Dict[str, Any], await self._client.share.create_snapshot( - timeout=timeout, - cls=return_response_headers, - headers=headers, - **kwargs)) + return cast( + Dict[str, Any], + await self._client.share.create_snapshot( + timeout=timeout, + cls=return_response_headers, + headers=headers, + file_request_intent=self.file_request_intent, + **kwargs + ), + ) except HttpResponseError as error: process_storage_error(error) @distributed_trace_async async def delete_share( - self, delete_snapshots: Optional[Union[bool, Literal['include', 'include-leased']]] = False, - **kwargs: Any + self, delete_snapshots: Optional[Union[bool, Literal["include", "include-leased"]]] = False, **kwargs: Any ) -> None: """Marks the specified share for deletion. The share is later deleted during garbage collection. @@ -488,23 +511,25 @@ async def delete_share( :dedent: 16 :caption: Deletes the share and any snapshots. """ - access_conditions = get_access_conditions(kwargs.pop('lease', None)) - timeout = kwargs.pop('timeout', None) + access_conditions = get_access_conditions(kwargs.pop("lease", None)) + timeout = kwargs.pop("timeout", None) delete_include = None if isinstance(delete_snapshots, bool) and delete_snapshots: delete_include = DeleteSnapshotsOptionType.INCLUDE else: - if delete_snapshots == 'include': + if delete_snapshots == "include": delete_include = DeleteSnapshotsOptionType.INCLUDE - elif delete_snapshots == 'include-leased': + elif delete_snapshots == "include-leased": delete_include = DeleteSnapshotsOptionType.INCLUDE_LEASED try: await self._client.share.delete( timeout=timeout, sharesnapshot=self.snapshot, delete_snapshots=delete_include, - lease_access_conditions=access_conditions, - **kwargs) + lease_id=access_conditions, + file_request_intent=self.file_request_intent, + **kwargs + ) except HttpResponseError as error: process_storage_error(error) @@ -540,15 +565,20 @@ async def get_share_properties(self, **kwargs: Any) -> "ShareProperties": :dedent: 16 :caption: Gets the share properties. """ - access_conditions = get_access_conditions(kwargs.pop('lease', None)) - timeout = kwargs.pop('timeout', None) + access_conditions = get_access_conditions(kwargs.pop("lease", None)) + timeout = kwargs.pop("timeout", None) try: - props = cast("ShareProperties", await self._client.share.get_properties( - timeout=timeout, - sharesnapshot=self.snapshot, - cls=deserialize_share_properties, - lease_access_conditions=access_conditions, - **kwargs)) + props = cast( + "ShareProperties", + await self._client.share.get_properties( + timeout=timeout, + sharesnapshot=self.snapshot, + cls=deserialize_share_properties, + lease_id=access_conditions, + file_request_intent=self.file_request_intent, + **kwargs + ), + ) except HttpResponseError as error: process_storage_error(error) props.name = self.share_name @@ -588,16 +618,21 @@ async def set_share_quota(self, quota: int, **kwargs: Any) -> Dict[str, Any]: :dedent: 16 :caption: Sets the share quota. """ - access_conditions = get_access_conditions(kwargs.pop('lease', None)) - timeout = kwargs.pop('timeout', None) + access_conditions = get_access_conditions(kwargs.pop("lease", None)) + timeout = kwargs.pop("timeout", None) try: - return cast(Dict[str, Any], await self._client.share.set_properties( - timeout=timeout, - quota=quota, - access_tier=None, - cls=return_response_headers, - lease_access_conditions=access_conditions, - **kwargs)) + return cast( + Dict[str, Any], + await self._client.share.set_properties( + timeout=timeout, + quota=quota, + access_tier=None, + cls=return_response_headers, + lease_id=access_conditions, + file_request_intent=self.file_request_intent, + **kwargs + ), + ) except HttpResponseError as error: process_storage_error(error) @@ -644,30 +679,35 @@ async def set_share_properties(self, **kwargs: Any) -> Dict[str, Any]: :dedent: 16 :caption: Sets the share properties. """ - access_conditions = get_access_conditions(kwargs.pop('lease', None)) - timeout = kwargs.pop('timeout', None) - access_tier = kwargs.pop('access_tier', None) - quota = kwargs.pop('quota', None) - root_squash = kwargs.pop('root_squash', None) - paid_bursting_bandwidth_mibps = kwargs.pop('paid_bursting_bandwidth_mibps', None) - paid_bursting_iops = kwargs.pop('paid_bursting_iops', None) - share_provisioned_iops = kwargs.pop('provisioned_iops', None) - share_provisioned_bandwidth_mibps = kwargs.pop('provisioned_bandwidth_mibps', None) + access_conditions = get_access_conditions(kwargs.pop("lease", None)) + timeout = kwargs.pop("timeout", None) + access_tier = kwargs.pop("access_tier", None) + quota = kwargs.pop("quota", None) + root_squash = kwargs.pop("root_squash", None) + paid_bursting_bandwidth_mibps = kwargs.pop("paid_bursting_bandwidth_mibps", None) + paid_bursting_iops = kwargs.pop("paid_bursting_iops", None) + share_provisioned_iops = kwargs.pop("provisioned_iops", None) + share_provisioned_bandwidth_mibps = kwargs.pop("provisioned_bandwidth_mibps", None) if all(parameter is None for parameter in [access_tier, quota, root_squash]): raise ValueError("set_share_properties should be called with at least one parameter.") try: - return cast(Dict[str, Any], await self._client.share.set_properties( - timeout=timeout, - quota=quota, - access_tier=access_tier, - root_squash=root_squash, - lease_access_conditions=access_conditions, - paid_bursting_max_bandwidth_mibps=paid_bursting_bandwidth_mibps, - paid_bursting_max_iops=paid_bursting_iops, - share_provisioned_iops=share_provisioned_iops, - share_provisioned_bandwidth_mibps=share_provisioned_bandwidth_mibps, - cls=return_response_headers, - **kwargs)) + return cast( + Dict[str, Any], + await self._client.share.set_properties( + timeout=timeout, + quota=quota, + access_tier=access_tier, + root_squash=root_squash, + lease_id=access_conditions, + paid_bursting_max_bandwidth_mibps=paid_bursting_bandwidth_mibps, + paid_bursting_max_iops=paid_bursting_iops, + share_provisioned_iops=share_provisioned_iops, + share_provisioned_bandwidth_mibps=share_provisioned_bandwidth_mibps, + cls=return_response_headers, + file_request_intent=self.file_request_intent, + **kwargs + ), + ) except HttpResponseError as error: process_storage_error(error) @@ -708,17 +748,22 @@ async def set_share_metadata(self, metadata: Dict[str, str], **kwargs: Any) -> D :dedent: 16 :caption: Sets the share metadata. """ - access_conditions = get_access_conditions(kwargs.pop('lease', None)) - timeout = kwargs.pop('timeout', None) - headers = kwargs.pop('headers', {}) + access_conditions = get_access_conditions(kwargs.pop("lease", None)) + timeout = kwargs.pop("timeout", None) + headers = kwargs.pop("headers", {}) headers.update(add_metadata_headers(metadata)) try: - return cast(Dict[str, Any], await self._client.share.set_metadata( - timeout=timeout, - cls=return_response_headers, - headers=headers, - lease_access_conditions=access_conditions, - **kwargs)) + return cast( + Dict[str, Any], + await self._client.share.set_metadata( + timeout=timeout, + cls=return_response_headers, + headers=headers, + lease_id=access_conditions, + file_request_intent=self.file_request_intent, + **kwargs + ), + ) except HttpResponseError as error: process_storage_error(error) @@ -744,25 +789,29 @@ async def get_share_access_policy(self, **kwargs: Any) -> Dict[str, Any]: :returns: Access policy information in a dict. :rtype: dict[str, Any] """ - access_conditions = get_access_conditions(kwargs.pop('lease', None)) - timeout = kwargs.pop('timeout', None) + access_conditions = get_access_conditions(kwargs.pop("lease", None)) + timeout = kwargs.pop("timeout", None) try: response, identifiers = await self._client.share.get_access_policy( timeout=timeout, cls=return_headers_and_deserialized, - lease_access_conditions=access_conditions, - **kwargs) + lease_id=access_conditions, + file_request_intent=self.file_request_intent, + **kwargs + ) except HttpResponseError as error: process_storage_error(error) return { - 'public_access': response.get('share_public_access'), - 'signed_identifiers': identifiers or [] + "public_access": response.get("share_public_access"), + "signed_identifiers": ( + identifiers.items_property if hasattr(identifiers, "items_property") else identifiers + ) + or [], } @distributed_trace_async async def set_share_access_policy( - self, signed_identifiers: Dict[str, "AccessPolicy"], - **kwargs: Any + self, signed_identifiers: Dict[str, "AccessPolicy"], **kwargs: Any ) -> Dict[str, Any]: """Sets the permissions for the share, or stored access policies that may be used with Shared Access Signatures. The permissions @@ -790,12 +839,13 @@ async def set_share_access_policy( :returns: Share-updated property dict (Etag and last modified). :rtype: dict[str, Any] """ - access_conditions = get_access_conditions(kwargs.pop('lease', None)) - timeout = kwargs.pop('timeout', None) + access_conditions = get_access_conditions(kwargs.pop("lease", None)) + timeout = kwargs.pop("timeout", None) if len(signed_identifiers) > 5: raise ValueError( - 'Too many access policies provided. The server does not support setting ' - 'more than 5 access policies on a single resource.') + "Too many access policies provided. The server does not support setting " + "more than 5 access policies on a single resource." + ) identifiers = [] for key, value in signed_identifiers.items(): if value: @@ -803,12 +853,17 @@ async def set_share_access_policy( value.expiry = serialize_iso(value.expiry) identifiers.append(SignedIdentifier(id=key, access_policy=value)) try: - return cast(Dict[str, Any], await self._client.share.set_access_policy( - share_acl=identifiers or None, - timeout=timeout, - cls=return_response_headers, - lease_access_conditions=access_conditions, - **kwargs)) + return cast( + Dict[str, Any], + await self._client.share.set_access_policy( + share_acl=SignedIdentifiers(items_property=identifiers) if identifiers else None, + timeout=timeout, + cls=return_response_headers, + lease_id=access_conditions, + file_request_intent=self.file_request_intent, + **kwargs + ), + ) except HttpResponseError as error: process_storage_error(error) @@ -836,20 +891,23 @@ async def get_share_stats(self, **kwargs: Any) -> int: :return: The approximate size of the data (in bytes) stored on the share. :rtype: int """ - access_conditions = get_access_conditions(kwargs.pop('lease', None)) - timeout = kwargs.pop('timeout', None) + access_conditions = get_access_conditions(kwargs.pop("lease", None)) + timeout = kwargs.pop("timeout", None) try: - stats = cast(ShareStats, await self._client.share.get_statistics( - timeout=timeout, - lease_access_conditions=access_conditions, - **kwargs)) + stats = cast( + ShareStats, + await self._client.share.get_statistics( + timeout=timeout, lease_id=access_conditions, file_request_intent=self.file_request_intent, **kwargs + ), + ) return stats.share_usage_bytes except HttpResponseError as error: process_storage_error(error) @distributed_trace def list_directories_and_files( - self, directory_name: Optional[str] = None, + self, + directory_name: Optional[str] = None, name_starts_with: Optional[str] = None, marker: Optional[str] = None, **kwargs: Any @@ -898,10 +956,11 @@ def list_directories_and_files( :dedent: 16 :caption: List directories and files in the share. """ - timeout = kwargs.pop('timeout', None) + timeout = kwargs.pop("timeout", None) directory = self.get_directory_client(directory_name) return directory.list_directories_and_files( - name_starts_with=name_starts_with, marker=marker, timeout=timeout, **kwargs) + name_starts_with=name_starts_with, marker=marker, timeout=timeout, **kwargs + ) @distributed_trace_async async def create_permission_for_share(self, file_permission: str, **kwargs: Any) -> Optional[str]: @@ -925,10 +984,13 @@ async def create_permission_for_share(self, file_permission: str, **kwargs: Any) :returns: A file permission key :rtype: str or None """ - timeout = kwargs.pop('timeout', None) + timeout = kwargs.pop("timeout", None) options = _create_permission_for_share_options(file_permission, timeout=timeout, **kwargs) try: - return cast(Optional[str], await self._client.share.create_permission(**options)) + return cast( + Optional[str], + await self._client.share.create_permission(file_request_intent=self.file_request_intent, **options), + ) except HttpResponseError as error: process_storage_error(error) @@ -952,13 +1014,18 @@ async def get_permission_for_share(self, permission_key: str, **kwargs: Any) -> :returns: A file permission (a portable SDDL) :rtype: str """ - timeout = kwargs.pop('timeout', None) + timeout = kwargs.pop("timeout", None) try: - return cast(str, await self._client.share.get_permission( - file_permission_key=permission_key, - cls=deserialize_permission, - timeout=timeout, - **kwargs)) + return cast( + str, + await self._client.share.get_permission( + file_permission_key=permission_key, + cls=deserialize_permission, + timeout=timeout, + file_request_intent=self.file_request_intent, + **kwargs + ), + ) except HttpResponseError as error: process_storage_error(error) @@ -998,7 +1065,7 @@ async def create_directory(self, directory_name: str, **kwargs: Any) -> ShareDir :rtype: ~azure.storage.fileshare.aio.ShareDirectoryClient """ directory = self.get_directory_client(directory_name) - kwargs.setdefault('merge_span', True) + kwargs.setdefault("merge_span", True) await directory.create_directory(**kwargs) return directory diff --git a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/aio/_share_service_client_async.py b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/aio/_share_service_client_async.py index 048b8973994c..22e093a60954 100644 --- a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/aio/_share_service_client_async.py +++ b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/aio/_share_service_client_async.py @@ -8,10 +8,7 @@ import functools import sys import warnings -from typing import ( - Union, Optional, Any, Dict, List, - TYPE_CHECKING -) +from typing import Union, Optional, Any, Dict, List, TYPE_CHECKING from typing_extensions import Self from azure.core.async_paging import AsyncItemPaged @@ -19,9 +16,10 @@ from azure.core.tracing.decorator import distributed_trace from azure.core.tracing.decorator_async import distributed_trace_async from azure.core.pipeline import AsyncPipeline -from .._generated.aio import AzureFileStorage +from .._generated.aio import FileClient as AzureFileStorage from .._generated.models import KeyInfo, StorageServiceProperties from .._models import CorsRule, service_properties_deserialize, ShareProperties +from .._parser import _strip_snapshot_from_url from .._serialize import get_api_version from .._share_service_client_helpers import _parse_url from .._shared.base_client import StorageAccountHostsMixin, parse_query @@ -100,41 +98,44 @@ class ShareServiceClient(AsyncStorageAccountHostsMixin, StorageAccountHostsMixin :dedent: 8 :caption: Create the share service client with url and credential. """ + def __init__( - self, account_url: str, - credential: Optional[Union[str, Dict[str, str], "AzureNamedKeyCredential", "AzureSasCredential", "AsyncTokenCredential"]] = None, # pylint: disable=line-too-long + self, + account_url: str, + credential: Optional[ + Union[str, Dict[str, str], "AzureNamedKeyCredential", "AzureSasCredential", "AsyncTokenCredential"] + ] = None, # pylint: disable=line-too-long *, - token_intent: Optional[Literal['backup']] = None, - **kwargs: Any + token_intent: Optional[Literal["backup"]] = None, + **kwargs: Any, ) -> None: - kwargs['retry_policy'] = kwargs.get('retry_policy') or ExponentialRetry(**kwargs) - loop = kwargs.pop('loop', None) + kwargs["retry_policy"] = kwargs.get("retry_policy") or ExponentialRetry(**kwargs) + loop = kwargs.pop("loop", None) if loop and sys.version_info >= (3, 8): - warnings.warn("The 'loop' parameter was deprecated from asyncio's high-level" - "APIs in Python 3.8 and is no longer supported.", DeprecationWarning) + warnings.warn( + "The 'loop' parameter was deprecated from asyncio's high-level" + "APIs in Python 3.8 and is no longer supported.", + DeprecationWarning, + ) - if hasattr(credential, 'get_token') and not token_intent: + if hasattr(credential, "get_token") and not token_intent: raise ValueError("'token_intent' keyword is required when 'credential' is an AsyncTokenCredential.") parsed_url = _parse_url(account_url=account_url) _, sas_token = parse_query(parsed_url.query) if not sas_token and not credential: raise ValueError( - 'You need to provide either an account shared key or SAS token when creating a storage service.') + "You need to provide either an account shared key or SAS token when creating a storage service." + ) self._query_str, credential = self._format_query_string(sas_token, credential) - super(ShareServiceClient, self).__init__( - parsed_url, service='file-share', credential=credential, **kwargs) - self.allow_trailing_dot = kwargs.pop('allow_trailing_dot', None) - self.allow_source_trailing_dot = kwargs.pop('allow_source_trailing_dot', None) + super(ShareServiceClient, self).__init__(parsed_url, service="file-share", credential=credential, **kwargs) + self.allow_trailing_dot = kwargs.pop("allow_trailing_dot", None) + self.allow_source_trailing_dot = kwargs.pop("allow_source_trailing_dot", None) self.file_request_intent = token_intent self._client = AzureFileStorage( + url=_strip_snapshot_from_url(self.url), version=get_api_version(kwargs), - url=self.url, - base_url=self.url, pipeline=self._pipeline, - allow_trailing_dot=self.allow_trailing_dot, - allow_source_trailing_dot=self.allow_source_trailing_dot, - file_request_intent=self.file_request_intent ) async def __aenter__(self) -> Self: @@ -165,9 +166,12 @@ def _format_url(self, hostname: str) -> str: @classmethod def from_connection_string( - cls, conn_str: str, - credential: Optional[Union[str, Dict[str, str], "AzureNamedKeyCredential", "AzureSasCredential", "AsyncTokenCredential"]] = None, # pylint: disable=line-too-long - **kwargs: Any + cls, + conn_str: str, + credential: Optional[ + Union[str, Dict[str, str], "AzureNamedKeyCredential", "AzureSasCredential", "AsyncTokenCredential"] + ] = None, # pylint: disable=line-too-long + **kwargs: Any, ) -> Self: """Create ShareServiceClient from a Connection String. @@ -199,9 +203,9 @@ def from_connection_string( :dedent: 8 :caption: Create the share service client with connection string. """ - account_url, secondary, credential = parse_connection_str(conn_str, credential, 'file') - if 'secondary_hostname' not in kwargs: - kwargs['secondary_hostname'] = secondary + account_url, secondary, credential = parse_connection_str(conn_str, credential, "file") + if "secondary_hostname" not in kwargs: + kwargs["secondary_hostname"] = secondary return cls(account_url, credential=credential, **kwargs) @distributed_trace_async @@ -212,7 +216,7 @@ async def get_user_delegation_key( start: Optional["datetime"] = None, delegated_user_tid: Optional[str] = None, timeout: Optional[int] = None, - **kwargs: Any + **kwargs: Any, ) -> "UserDelegationKey": """ Obtain a user delegation key for the purpose of signing SAS tokens. @@ -236,15 +240,11 @@ async def get_user_delegation_key( :rtype: ~azure.storage.queue.UserDelegationKey """ key_info = KeyInfo( - start=_to_utc_datetime(start), - expiry=_to_utc_datetime(expiry), - delegated_user_tid=delegated_user_tid + start=_to_utc_datetime(start), expiry=_to_utc_datetime(expiry), delegated_user_tid=delegated_user_tid ) try: user_delegation_key = await self._client.service.get_user_delegation_key( # type: ignore - key_info=key_info, - timeout=timeout, - **kwargs + key_info=key_info, timeout=timeout, **kwargs ) except HttpResponseError as error: process_storage_error(error) @@ -274,20 +274,23 @@ async def get_service_properties(self, **kwargs: Any) -> Dict[str, Any]: :dedent: 12 :caption: Get file share service properties. """ - timeout = kwargs.pop('timeout', None) + timeout = kwargs.pop("timeout", None) try: - service_props = await self._client.service.get_properties(timeout=timeout, **kwargs) + service_props = await self._client.service.get_properties( + timeout=timeout, file_request_intent=self.file_request_intent, **kwargs + ) return service_properties_deserialize(service_props) except HttpResponseError as error: process_storage_error(error) @distributed_trace_async async def set_service_properties( - self, hour_metrics: Optional["Metrics"] = None, + self, + hour_metrics: Optional["Metrics"] = None, minute_metrics: Optional["Metrics"] = None, cors: Optional[List[CorsRule]] = None, protocol: Optional["ShareProtocolSettings"] = None, - **kwargs: Any + **kwargs: Any, ) -> None: """Sets the properties of a storage account's File Share service, including Azure Storage Analytics. If an element (e.g. hour_metrics) is left as None, the @@ -326,24 +329,27 @@ async def set_service_properties( :dedent: 8 :caption: Sets file share service properties. """ - timeout = kwargs.pop('timeout', None) + timeout = kwargs.pop("timeout", None) props = StorageServiceProperties( hour_metrics=hour_metrics, minute_metrics=minute_metrics, cors=CorsRule._to_generated(cors), # pylint: disable=protected-access - protocol=protocol + protocol=protocol, ) try: - await self._client.service.set_properties(props, timeout=timeout, **kwargs) + await self._client.service.set_properties( + props, timeout=timeout, file_request_intent=self.file_request_intent, **kwargs + ) except HttpResponseError as error: process_storage_error(error) @distributed_trace def list_shares( - self, name_starts_with: Optional[str] = None, + self, + name_starts_with: Optional[str] = None, include_metadata: Optional[bool] = False, include_snapshots: Optional[bool] = False, - **kwargs: Any + **kwargs: Any, ) -> AsyncItemPaged[ShareProperties]: """Returns auto-paging iterable of dict-like ShareProperties under the specified account. The generator will lazily follow the continuation tokens returned by @@ -377,25 +383,30 @@ def list_shares( :dedent: 16 :caption: List shares in the file share service. """ - timeout = kwargs.pop('timeout', None) + timeout = kwargs.pop("timeout", None) include = [] - include_deleted = kwargs.pop('include_deleted', None) + include_deleted = kwargs.pop("include_deleted", None) if include_deleted: include.append("deleted") if include_metadata: - include.append('metadata') + include.append("metadata") if include_snapshots: - include.append('snapshots') + include.append("snapshots") - results_per_page = kwargs.pop('results_per_page', None) + results_per_page = kwargs.pop("results_per_page", None) command = functools.partial( self._client.service.list_shares_segment, include=include, timeout=timeout, - **kwargs) + file_request_intent=self.file_request_intent, + **kwargs, + ) return AsyncItemPaged( - command, prefix=name_starts_with, results_per_page=results_per_page, - page_iterator_class=SharePropertiesPaged) + command, + prefix=name_starts_with, + results_per_page=results_per_page, + page_iterator_class=SharePropertiesPaged, + ) @distributed_trace_async async def create_share(self, share_name: str, **kwargs: Any) -> ShareClient: @@ -429,28 +440,26 @@ async def create_share(self, share_name: str, **kwargs: Any) -> ShareClient: :dedent: 12 :caption: Create a share in the file share service. """ - metadata = kwargs.pop('metadata', None) - quota = kwargs.pop('quota', None) - timeout = kwargs.pop('timeout', None) - provisioned_iops = kwargs.pop('provisioned_iops', None) - provisioned_bandwidth_mibps = kwargs.pop('provisioned_bandwidth_mibps', None) + metadata = kwargs.pop("metadata", None) + quota = kwargs.pop("quota", None) + timeout = kwargs.pop("timeout", None) + provisioned_iops = kwargs.pop("provisioned_iops", None) + provisioned_bandwidth_mibps = kwargs.pop("provisioned_bandwidth_mibps", None) share = self.get_share_client(share_name) - kwargs.setdefault('merge_span', True) + kwargs.setdefault("merge_span", True) await share.create_share( metadata=metadata, quota=quota, timeout=timeout, provisioned_iops=provisioned_iops, provisioned_bandwidth_mibps=provisioned_bandwidth_mibps, - **kwargs + **kwargs, ) return share @distributed_trace_async async def delete_share( - self, share_name: Union[ShareProperties, str], - delete_snapshots: Optional[bool] = False, - **kwargs: Any + self, share_name: Union[ShareProperties, str], delete_snapshots: Optional[bool] = False, **kwargs: Any ) -> None: """Marks the specified share for deletion. The share is later deleted during garbage collection. @@ -478,11 +487,10 @@ async def delete_share( :dedent: 16 :caption: Delete a share in the file share service. """ - timeout = kwargs.pop('timeout', None) + timeout = kwargs.pop("timeout", None) share = self.get_share_client(share_name) - kwargs.setdefault('merge_span', True) - await share.delete_share( - delete_snapshots=delete_snapshots, timeout=timeout, **kwargs) + kwargs.setdefault("merge_span", True) + await share.delete_share(delete_snapshots=delete_snapshots, timeout=timeout, **kwargs) @distributed_trace_async async def undelete_share(self, deleted_share_name: str, deleted_share_version: str, **kwargs: Any) -> ShareClient: @@ -510,16 +518,18 @@ async def undelete_share(self, deleted_share_name: str, deleted_share_version: s """ share = self.get_share_client(deleted_share_name) try: - await share._client.share.restore(deleted_share_name=deleted_share_name, # pylint: disable=protected-access - deleted_share_version=deleted_share_version, - timeout=kwargs.pop('timeout', None), **kwargs) + await share._client.share.restore( # pylint: disable=protected-access + deleted_share_name=deleted_share_name, + deleted_share_version=deleted_share_version, + timeout=kwargs.pop("timeout", None), + **kwargs, + ) return share except HttpResponseError as error: process_storage_error(error) def get_share_client( - self, share: Union[ShareProperties, str], - snapshot: Optional[Union[Dict[str, Any], str]] = None + self, share: Union[ShareProperties, str], snapshot: Optional[Union[Dict[str, Any], str]] = None ) -> ShareClient: """Get a client to interact with the specified share. The share need not already exist. @@ -550,10 +560,19 @@ def get_share_client( _pipeline = AsyncPipeline( transport=AsyncTransportWrapper(self._pipeline._transport), # pylint: disable = protected-access - policies=self._pipeline._impl_policies # type: ignore [arg-type] # pylint: disable = protected-access + policies=self._pipeline._impl_policies, # type: ignore [arg-type] # pylint: disable = protected-access ) return ShareClient( - self.url, share_name=share_name, snapshot=snapshot, credential=self.credential, - api_version=self.api_version, _hosts=self._hosts, _configuration=self._config, - _pipeline=_pipeline, _location_mode=self._location_mode, allow_trailing_dot=self.allow_trailing_dot, - allow_source_trailing_dot=self.allow_source_trailing_dot, token_intent=self.file_request_intent) + self.url, + share_name=share_name, + snapshot=snapshot, + credential=self.credential, + api_version=self.api_version, + _hosts=self._hosts, + _configuration=self._config, + _pipeline=_pipeline, + _location_mode=self._location_mode, + allow_trailing_dot=self.allow_trailing_dot, + allow_source_trailing_dot=self.allow_source_trailing_dot, + token_intent=self.file_request_intent, + ) diff --git a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/py.typed b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/py.typed index e69de29bb2d1..e5aff4f83af8 100644 --- a/sdk/storage/azure-storage-file-share/azure/storage/fileshare/py.typed +++ b/sdk/storage/azure-storage-file-share/azure/storage/fileshare/py.typed @@ -0,0 +1 @@ +# Marker file for PEP 561. \ No newline at end of file diff --git a/sdk/storage/azure-storage-file-share/pyproject.toml b/sdk/storage/azure-storage-file-share/pyproject.toml index 08a774b6e206..16a28d216941 100644 --- a/sdk/storage/azure-storage-file-share/pyproject.toml +++ b/sdk/storage/azure-storage-file-share/pyproject.toml @@ -1,3 +1,70 @@ +# -------------------------------------------------------------------------- +# Copyright (c) Microsoft Corporation. All rights reserved. +# Licensed under the MIT License. See License.txt in the project root for license information. +# Code generated by Microsoft (R) Python Code Generator. +# Changes may cause incorrect behavior and will be lost if the code is regenerated. +# -------------------------------------------------------------------------- + +[build-system] +requires = ["setuptools>=77.0.3", "wheel"] +build-backend = "setuptools.build_meta" + +[project] +name = "azure-storage-file-share" +authors = [ + { name = "Microsoft Corporation", email = "ascl@microsoft.com" }, +] +description = "Microsoft Corporation Azure Storage File Share Client Library for Python" +license = "MIT" +classifiers = [ + "Development Status :: 4 - Beta", + "Programming Language :: Python", + "Programming Language :: Python :: 3 :: Only", + "Programming Language :: Python :: 3", + "Programming Language :: Python :: 3.10", + "Programming Language :: Python :: 3.11", + "Programming Language :: Python :: 3.12", + "Programming Language :: Python :: 3.13", +] +requires-python = ">=3.10" +keywords = ["azure", "azure sdk"] + +dependencies = [ + "isodate>=0.6.1", + "azure-core>=1.38.3", + "typing-extensions>=4.6.0", + "cryptography>=2.1.4", +] +dynamic = [ +"version", "readme" +] + +[project.optional-dependencies] +aio = [ + "azure-core[aio]>=1.38.3", +] + +[project.urls] +repository = "https://github.com/Azure/azure-sdk-for-python" + +[tool.setuptools.dynamic] +version = {attr = "azure.storage.fileshare._version.VERSION"} +readme = {file = ["README.md", "CHANGELOG.md"], content-type = "text/markdown"} + +[tool.setuptools.packages.find] +exclude = [ + "tests*", + "generated_tests*", + "samples*", + "generated_samples*", + "doc*", + "azure", + "azure.storage", +] + +[tool.setuptools.package-data] +pytyped = ["py.typed"] + [tool.azure-sdk-build] mypy = true pyright = false diff --git a/sdk/storage/azure-storage-file-share/setup.py b/sdk/storage/azure-storage-file-share/setup.py deleted file mode 100644 index 2e62c6db6a86..000000000000 --- a/sdk/storage/azure-storage-file-share/setup.py +++ /dev/null @@ -1,79 +0,0 @@ -#!/usr/bin/env python - -#------------------------------------------------------------------------- -# Copyright (c) Microsoft Corporation. All rights reserved. -# Licensed under the MIT License. See License.txt in the project root for -# license information. -#-------------------------------------------------------------------------- - -import re -import os.path -from io import open -from setuptools import find_packages, setup - -# Change the PACKAGE_NAME only to change folder and different name -PACKAGE_NAME = "azure-storage-file-share" -NAMESPACE_NAME = "azure.storage.fileshare" -PACKAGE_PPRINT_NAME = "Azure File Share Storage" - -# a.b.c => a/b/c -package_folder_path = NAMESPACE_NAME.replace('.', '/') - -# Version extraction inspired from 'requests' -with open(os.path.join(package_folder_path, '_version.py'), 'r') as fd: - version = re.search(r'^VERSION\s*=\s*[\'"]([^\'"]*)[\'"]', - fd.read(), re.MULTILINE).group(1) - -if not version: - raise RuntimeError('Cannot find version information') - -with open('README.md', encoding='utf-8') as f: - readme = f.read() -with open('CHANGELOG.md', encoding='utf-8') as f: - changelog = f.read() - -setup( - name=PACKAGE_NAME, - version=version, - include_package_data=True, - description=f'Microsoft Azure {PACKAGE_PPRINT_NAME} Client Library for Python', - long_description=readme + '\n\n' + changelog, - long_description_content_type='text/markdown', - license='MIT License', - author='Microsoft Corporation', - author_email='ascl@microsoft.com', - url='https://github.com/Azure/azure-sdk-for-python/tree/main/sdk/storage/azure-storage-file-share', - keywords="azure, azure sdk", - classifiers=[ - 'Development Status :: 4 - Beta', - 'Programming Language :: Python', - 'Programming Language :: Python :: 3 :: Only', - 'Programming Language :: Python :: 3', - 'Programming Language :: Python :: 3.9', - 'Programming Language :: Python :: 3.10', - 'Programming Language :: Python :: 3.11', - 'Programming Language :: Python :: 3.12', - 'Programming Language :: Python :: 3.13', - 'Programming Language :: Python :: 3.14', - 'License :: OSI Approved :: MIT License', - ], - zip_safe=False, - packages=find_packages(exclude=[ - # Exclude packages that will be covered by PEP420 or nspkg - 'azure', - 'azure.storage', - 'tests', - ]), - python_requires=">=3.9", - install_requires=[ - "azure-core>=1.37.0", - "cryptography>=2.1.4", - "typing-extensions>=4.6.0", - "isodate>=0.6.1" - ], - extras_require={ - "aio": [ - "azure-core[aio]>=1.37.0", - ], - }, -) diff --git a/sdk/storage/azure-storage-file-share/tests/conftest.py b/sdk/storage/azure-storage-file-share/tests/conftest.py index cb5378cb35f9..2be8b15e6cf4 100644 --- a/sdk/storage/azure-storage-file-share/tests/conftest.py +++ b/sdk/storage/azure-storage-file-share/tests/conftest.py @@ -15,10 +15,13 @@ add_header_regex_sanitizer, add_oauth_response_sanitizer, add_uri_string_sanitizer, + set_custom_default_matcher, + add_remove_header_sanitizer, add_uri_regex_sanitizer, - test_proxy + test_proxy, ) + @pytest.fixture(scope="session", autouse=True) def add_sanitizers(test_proxy): subscription_id = os.environ.get("AZURE_SUBSCRIPTION_ID", "00000000-0000-0000-0000-000000000000") @@ -34,6 +37,11 @@ def add_sanitizers(test_proxy): add_body_regex_sanitizer(regex=r".*?", value="0.0.0.0:0") add_uri_string_sanitizer(target=".preprod.", value=".") + + # TypeSpec-generated code may order query parameters differently than AutoRest + set_custom_default_matcher(ignore_query_ordering=True) + + add_remove_header_sanitizer(headers="Accept") add_uri_regex_sanitizer( regex=r"(?<=[?&]sktid=)[^&#]+", value="00000000-0000-0000-0000-000000000000", diff --git a/sdk/storage/azure-storage-file-share/tests/test_file.py b/sdk/storage/azure-storage-file-share/tests/test_file.py index 0ab9522021e2..03a5a449fae5 100644 --- a/sdk/storage/azure-storage-file-share/tests/test_file.py +++ b/sdk/storage/azure-storage-file-share/tests/test_file.py @@ -3883,6 +3883,7 @@ def test_file_permission_format(self, **kwargs): new_file.delete_file() file_client.delete_file() + @pytest.mark.skip("Legacy transports will not be supported moving forward") @FileSharePreparer() def test_legacy_transport(self, **kwargs): storage_account_name = kwargs.pop("storage_account_name") @@ -3913,6 +3914,7 @@ def test_legacy_transport(self, **kwargs): file_data = file_client.download_file().readall() assert file_data == b"Hello World!" # data is fixed by mock transport + @pytest.mark.skip("Legacy transports will not be supported moving forward") @FileSharePreparer() def test_legacy_transport_with_content_validation(self, **kwargs): storage_account_name = kwargs.pop("storage_account_name") diff --git a/sdk/storage/azure-storage-file-share/tests/test_file_async.py b/sdk/storage/azure-storage-file-share/tests/test_file_async.py index 1d776aa8306c..a739b1c53b87 100644 --- a/sdk/storage/azure-storage-file-share/tests/test_file_async.py +++ b/sdk/storage/azure-storage-file-share/tests/test_file_async.py @@ -4037,6 +4037,7 @@ async def test_file_permission_format(self, **kwargs): await new_file.delete_file() await file_client.delete_file() + @pytest.mark.skip("Legacy transports will not be supported moving forward") @FileSharePreparer() async def test_legacy_transport(self, **kwargs): storage_account_name = kwargs.pop("storage_account_name") @@ -4068,6 +4069,7 @@ async def test_legacy_transport(self, **kwargs): file_data = await (await file_client.download_file()).readall() assert file_data == b"Hello Async World!" # data is fixed by mock transport + @pytest.mark.skip("Legacy transports will not be supported moving forward") @FileSharePreparer() async def test_legacy_transport_with_content_validation(self, **kwargs): storage_account_name = kwargs.pop("storage_account_name") diff --git a/sdk/storage/azure-storage-file-share/tsp-location.yaml b/sdk/storage/azure-storage-file-share/tsp-location.yaml new file mode 100644 index 000000000000..2a735d219eae --- /dev/null +++ b/sdk/storage/azure-storage-file-share/tsp-location.yaml @@ -0,0 +1,4 @@ +directory: specification/storage/data-plane/FileStorage +commit: cfd58963682948f5242b945bc6152c4e54c88c0c +repo: Azure/azure-rest-api-specs +additionalDirectories: