[DataLake][SetExpiry]Set Expiry of DataLake File

sdk/storage/azure-storage-blob/azure/storage/blob/_blob_client.py

@@ -35,25 +35,21 @@
     AppendPositionAccessConditions,
     SequenceNumberAccessConditions,
     StorageErrorException,
-    UserDelegationKey,
     CpkInfo)
 from ._serialize import get_modify_conditions, get_source_conditions, get_cpk_scope_info, get_api_version
 from ._deserialize import get_page_ranges_result, deserialize_blob_properties, deserialize_blob_stream
 from ._upload_helpers import (
     upload_block_blob,
     upload_append_blob,
     upload_page_blob)
-from ._models import BlobType, BlobBlock
+from ._models import BlobType, BlobBlock, BlobProperties
 from ._download import StorageStreamDownloader
 from ._lease import BlobLeaseClient, get_access_conditions
 
 if TYPE_CHECKING:
     from datetime import datetime
     from ._generated.models import BlockList
     from ._models import (  # pylint: disable=unused-import
-        ContainerProperties,
-        BlobProperties,
-        BlobSasPermissions,
         ContentSettings,
         PremiumPageBlobTier,
         StandardBlobTier,
@@ -94,7 +90,7 @@ class BlobClient(StorageAccountHostsMixin):  # pylint: disable=too-many-public-m
         The hostname of the secondary endpoint.
     :keyword int max_block_size: The maximum chunk size for uploading a block blob in chunks.
         Defaults to 4*1024*1024, or 4MB.
-    :keyword int max_single_put_size: If the blob size is less than max_single_put_size, then the blob will be
+    :keyword int max_single_put_size: If the blob size is less than or equal max_single_put_size, then the blob will be
         uploaded with only one http PUT request. If the blob size is larger than max_single_put_size,
         the blob will be uploaded in chunks. Defaults to 64*1024*1024, or 64MB.
     :keyword int min_large_block_upload_threshold: The minimum chunk size required to use the memory efficient
@@ -788,13 +784,14 @@ def get_blob_properties(self, **kwargs):
                 snapshot=self.snapshot,
                 lease_access_conditions=access_conditions,
                 modified_access_conditions=mod_conditions,
-                cls=deserialize_blob_properties,
+                cls=kwargs.pop('cls', None) or deserialize_blob_properties,
                 cpk_info=cpk_info,
                 **kwargs)
         except StorageErrorException as error:
             process_storage_error(error)
         blob_props.name = self.blob_name
-        blob_props.container = self.container_name
+        if isinstance(blob_props, BlobProperties):
+            blob_props.container = self.container_name
         return blob_props # type: ignore
 
     def _set_http_headers_options(self, content_settings=None, **kwargs):

sdk/storage/azure-storage-blob/azure/storage/blob/_blob_service_client.py

@@ -77,7 +77,7 @@ class BlobServiceClient(StorageAccountHostsMixin):
         The hostname of the secondary endpoint.
     :keyword int max_block_size: The maximum chunk size for uploading a block blob in chunks.
         Defaults to 4*1024*1024, or 4MB.
-    :keyword int max_single_put_size: If the blob size is less than max_single_put_size, then the blob will be
+    :keyword int max_single_put_size: If the blob size is less than or equal max_single_put_size, then the blob will be
         uploaded with only one http PUT request. If the blob size is larger than max_single_put_size,
         the blob will be uploaded in chunks. Defaults to 64*1024*1024, or 64MB.
     :keyword int min_large_block_upload_threshold: The minimum chunk size required to use the memory efficient
@@ -400,7 +400,7 @@ def list_containers(
                 :dedent: 12
                 :caption: Listing the containers in the blob service.
         """
-        include = 'metadata' if include_metadata else None
+        include = ['metadata'] if include_metadata else None
         timeout = kwargs.pop('timeout', None)
         results_per_page = kwargs.pop('results_per_page', None)
         command = functools.partial(

sdk/storage/azure-storage-blob/azure/storage/blob/_container_client.py

@@ -97,7 +97,7 @@ class ContainerClient(StorageAccountHostsMixin):
         The hostname of the secondary endpoint.
     :keyword int max_block_size: The maximum chunk size for uploading a block blob in chunks.
         Defaults to 4*1024*1024, or 4MB.
-    :keyword int max_single_put_size: If the blob size is less than max_single_put_size, then the blob will be
+    :keyword int max_single_put_size: If the blob size is less than or equal max_single_put_size, then the blob will be
         uploaded with only one http PUT request. If the blob size is larger than max_single_put_size,
         the blob will be uploaded in chunks. Defaults to 64*1024*1024, or 64MB.
     :keyword int min_large_block_upload_threshold: The minimum chunk size required to use the memory efficient

sdk/storage/azure-storage-blob/azure/storage/blob/_generated/_azure_blob_storage.py

@@ -55,7 +55,7 @@ def __init__(self, url, **kwargs):
         self._client = PipelineClient(base_url=base_url, config=self._config, **kwargs)
 
         client_models = {k: v for k, v in models.__dict__.items() if isinstance(v, type)}
-        self.api_version = '2019-07-07'
+        self.api_version = '2019-12-12'
         self._serialize = Serializer(client_models)
         self._deserialize = Deserializer(client_models)
 

sdk/storage/azure-storage-blob/azure/storage/blob/_generated/_configuration.py

@@ -40,7 +40,7 @@ def __init__(self, url, **kwargs):
         self.generate_client_request_id = True
 
         self.url = url
-        self.version = "2019-07-07"
+        self.version = "2019-12-12"
 
     def _configure(self, **kwargs):
         self.user_agent_policy = kwargs.get('user_agent_policy') or policies.UserAgentPolicy(**kwargs)

sdk/storage/azure-storage-blob/azure/storage/blob/_generated/aio/_azure_blob_storage_async.py

@@ -56,7 +56,7 @@ def __init__(
         self._client = AsyncPipelineClient(base_url=base_url, config=self._config, **kwargs)
 
         client_models = {k: v for k, v in models.__dict__.items() if isinstance(v, type)}
-        self.api_version = '2019-07-07'
+        self.api_version = '2019-12-12'
         self._serialize = Serializer(client_models)
         self._deserialize = Deserializer(client_models)
 

sdk/storage/azure-storage-blob/azure/storage/blob/_generated/aio/_configuration_async.py

@@ -41,7 +41,7 @@ def __init__(self, url, **kwargs):
         self.accept_language = None
 
         self.url = url
-        self.version = "2019-07-07"
+        self.version = "2019-12-12"
 
     def _configure(self, **kwargs):
         self.user_agent_policy = kwargs.get('user_agent_policy') or policies.UserAgentPolicy(**kwargs)

sdk/storage/azure-storage-blob/azure/storage/blob/_generated/aio/operations_async/_append_blob_operations_async.py

@@ -24,7 +24,6 @@ class AppendBlobOperations:
     :param serializer: An object model serializer.
     :param deserializer: An object model deserializer.
     :ivar x_ms_blob_type: Specifies the type of blob to create: block blob, page blob, or append blob. Constant value: "AppendBlob".
-    :ivar comp: . Constant value: "appendblock".
     """
 
     models = models
@@ -37,9 +36,8 @@ def __init__(self, client, config, serializer, deserializer) -> None:
 
         self._config = config
         self.x_ms_blob_type = "AppendBlob"
-        self.comp = "appendblock"
 
-    async def create(self, content_length, timeout=None, metadata=None, request_id=None, blob_http_headers=None, lease_access_conditions=None, cpk_info=None, cpk_scope_info=None, modified_access_conditions=None, *, cls=None, **kwargs):
+    async def create(self, content_length, timeout=None, metadata=None, request_id=None, blob_tags_string=None, blob_http_headers=None, lease_access_conditions=None, cpk_info=None, cpk_scope_info=None, modified_access_conditions=None, *, cls=None, **kwargs):
         """The Create Append Blob operation creates a new append blob.
 
         :param content_length: The length of the request.
@@ -63,6 +61,9 @@ async def create(self, content_length, timeout=None, metadata=None, request_id=N
          KB character limit that is recorded in the analytics logs when storage
          analytics logging is enabled.
         :type request_id: str
+        :param blob_tags_string: Optional.  Used to set blob tags in various
+         blob operations.
+        :type blob_tags_string: str
         :param blob_http_headers: Additional parameters for the operation
         :type blob_http_headers: ~azure.storage.blob.models.BlobHTTPHeaders
         :param lease_access_conditions: Additional parameters for the
@@ -151,6 +152,8 @@ async def create(self, content_length, timeout=None, metadata=None, request_id=N
         header_parameters['x-ms-version'] = self._serialize.header("self._config.version", self._config.version, 'str')
         if request_id is not None:
             header_parameters['x-ms-client-request-id'] = self._serialize.header("request_id", request_id, 'str')
+        if blob_tags_string is not None:
+            header_parameters['x-ms-tags'] = self._serialize.header("blob_tags_string", blob_tags_string, 'str')
         header_parameters['x-ms-blob-type'] = self._serialize.header("self.x_ms_blob_type", self.x_ms_blob_type, 'str')
         if blob_content_type is not None:
             header_parameters['x-ms-blob-content-type'] = self._serialize.header("blob_content_type", blob_content_type, 'str')
@@ -200,6 +203,7 @@ async def create(self, content_length, timeout=None, metadata=None, request_id=N
                 'x-ms-client-request-id': self._deserialize('str', response.headers.get('x-ms-client-request-id')),
                 'x-ms-request-id': self._deserialize('str', response.headers.get('x-ms-request-id')),
                 'x-ms-version': self._deserialize('str', response.headers.get('x-ms-version')),
+                'x-ms-version-id': self._deserialize('str', response.headers.get('x-ms-version-id')),
                 'Date': self._deserialize('rfc-1123', response.headers.get('Date')),
                 'x-ms-request-server-encrypted': self._deserialize('bool', response.headers.get('x-ms-request-server-encrypted')),
                 'x-ms-encryption-key-sha256': self._deserialize('str', response.headers.get('x-ms-encryption-key-sha256')),
@@ -292,6 +296,8 @@ async def append_block(self, body, content_length, timeout=None, transactional_c
         if modified_access_conditions is not None:
             if_none_match = modified_access_conditions.if_none_match
 
+        comp = "appendblock"
+
         # Construct URL
         url = self.append_block.metadata['url']
         path_format_arguments = {
@@ -303,7 +309,7 @@ async def append_block(self, body, content_length, timeout=None, transactional_c
         query_parameters = {}
         if timeout is not None:
             query_parameters['timeout'] = self._serialize.query("timeout", timeout, 'int', minimum=0)
-        query_parameters['comp'] = self._serialize.query("self.comp", self.comp, 'str')
+        query_parameters['comp'] = self._serialize.query("comp", comp, 'str')
 
         # Construct headers
         header_parameters = {}
@@ -475,6 +481,8 @@ async def append_block_from_url(self, source_url, content_length, source_range=N
         if source_modified_access_conditions is not None:
             source_if_none_match = source_modified_access_conditions.source_if_none_match
 
+        comp = "appendblock"
+
         # Construct URL
         url = self.append_block_from_url.metadata['url']
         path_format_arguments = {
@@ -486,7 +494,7 @@ async def append_block_from_url(self, source_url, content_length, source_range=N
         query_parameters = {}
         if timeout is not None:
             query_parameters['timeout'] = self._serialize.query("timeout", timeout, 'int', minimum=0)
-        query_parameters['comp'] = self._serialize.query("self.comp", self.comp, 'str')
+        query_parameters['comp'] = self._serialize.query("comp", comp, 'str')
 
         # Construct headers
         header_parameters = {}
@@ -561,3 +569,111 @@ async def append_block_from_url(self, source_url, content_length, source_range=N
             }
             return cls(response, None, response_headers)
     append_block_from_url.metadata = {'url': '/{containerName}/{blob}'}
+
+    async def seal(self, timeout=None, request_id=None, lease_access_conditions=None, modified_access_conditions=None, append_position_access_conditions=None, *, cls=None, **kwargs):
+        """The Seal operation seals the Append Blob to make it read-only. Seal is
+        supported only on version 2019-12-12 version or later.
+
+        :param timeout: The timeout parameter is expressed in seconds. For
+         more information, see <a
+         href="https://docs.microsoft.com/en-us/rest/api/storageservices/fileservices/setting-timeouts-for-blob-service-operations">Setting
+         Timeouts for Blob Service Operations.</a>
+        :type timeout: int
+        :param request_id: 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.
+        :type request_id: str
+        :param lease_access_conditions: Additional parameters for the
+         operation
+        :type lease_access_conditions:
+         ~azure.storage.blob.models.LeaseAccessConditions
+        :param modified_access_conditions: Additional parameters for the
+         operation
+        :type modified_access_conditions:
+         ~azure.storage.blob.models.ModifiedAccessConditions
+        :param append_position_access_conditions: Additional parameters for
+         the operation
+        :type append_position_access_conditions:
+         ~azure.storage.blob.models.AppendPositionAccessConditions
+        :param callable cls: A custom type or function that will be passed the
+         direct response
+        :return: None or the result of cls(response)
+        :rtype: None
+        :raises:
+         :class:`StorageErrorException<azure.storage.blob.models.StorageErrorException>`
+        """
+        error_map = kwargs.pop('error_map', None)
+        lease_id = None
+        if lease_access_conditions is not None:
+            lease_id = lease_access_conditions.lease_id
+        if_modified_since = None
+        if modified_access_conditions is not None:
+            if_modified_since = modified_access_conditions.if_modified_since
+        if_unmodified_since = None
+        if modified_access_conditions is not None:
+            if_unmodified_since = modified_access_conditions.if_unmodified_since
+        if_match = None
+        if modified_access_conditions is not None:
+            if_match = modified_access_conditions.if_match
+        if_none_match = None
+        if modified_access_conditions is not None:
+            if_none_match = modified_access_conditions.if_none_match
+        append_position = None
+        if append_position_access_conditions is not None:
+            append_position = append_position_access_conditions.append_position
+
+        comp = "seal"
+
+        # Construct URL
+        url = self.seal.metadata['url']
+        path_format_arguments = {
+            'url': self._serialize.url("self._config.url", self._config.url, 'str', skip_quote=True)
+        }
+        url = self._client.format_url(url, **path_format_arguments)
+
+        # Construct parameters
+        query_parameters = {}
+        if timeout is not None:
+            query_parameters['timeout'] = self._serialize.query("timeout", timeout, 'int', minimum=0)
+        query_parameters['comp'] = self._serialize.query("comp", comp, 'str')
+
+        # Construct headers
+        header_parameters = {}
+        header_parameters['x-ms-version'] = self._serialize.header("self._config.version", self._config.version, 'str')
+        if request_id is not None:
+            header_parameters['x-ms-client-request-id'] = self._serialize.header("request_id", request_id, 'str')
+        if lease_id is not None:
+            header_parameters['x-ms-lease-id'] = self._serialize.header("lease_id", lease_id, 'str')
+        if if_modified_since is not None:
+            header_parameters['If-Modified-Since'] = self._serialize.header("if_modified_since", if_modified_since, 'rfc-1123')
+        if if_unmodified_since is not None:
+            header_parameters['If-Unmodified-Since'] = self._serialize.header("if_unmodified_since", if_unmodified_since, 'rfc-1123')
+        if if_match is not None:
+            header_parameters['If-Match'] = self._serialize.header("if_match", if_match, 'str')
+        if if_none_match is not None:
+            header_parameters['If-None-Match'] = self._serialize.header("if_none_match", if_none_match, 'str')
+        if append_position is not None:
+            header_parameters['x-ms-blob-condition-appendpos'] = self._serialize.header("append_position", append_position, 'long')
+
+        # Construct and send request
+        request = self._client.put(url, query_parameters, header_parameters)
+        pipeline_response = await self._client._pipeline.run(request, stream=False, **kwargs)
+        response = pipeline_response.http_response
+
+        if response.status_code not in [200]:
+            map_error(status_code=response.status_code, response=response, error_map=error_map)
+            raise models.StorageErrorException(response, self._deserialize)
+
+        if cls:
+            response_headers = {
+                'ETag': self._deserialize('str', response.headers.get('ETag')),
+                'Last-Modified': self._deserialize('rfc-1123', response.headers.get('Last-Modified')),
+                'x-ms-client-request-id': self._deserialize('str', response.headers.get('x-ms-client-request-id')),
+                'x-ms-request-id': self._deserialize('str', response.headers.get('x-ms-request-id')),
+                'x-ms-version': self._deserialize('str', response.headers.get('x-ms-version')),
+                'Date': self._deserialize('rfc-1123', response.headers.get('Date')),
+                'x-ms-blob-sealed': self._deserialize('bool', response.headers.get('x-ms-blob-sealed')),
+                'x-ms-error-code': self._deserialize('str', response.headers.get('x-ms-error-code')),
+            }
+            return cls(response, None, response_headers)
+    seal.metadata = {'url': '/{containerName}/{blob}'}