azure-storage-blob 12.26.0b1__py3-none-any.whl → 12.27.0__py3-none-any.whl

azure/storage/blob/_shared/authentication.py

@@ -28,6 +28,7 @@ from . import sign_string
 logger = logging.getLogger(__name__)
 
 
+# fmt: off
 table_lv0 = [
     0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
     0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
@@ -51,6 +52,8 @@ table_lv4 = [
     0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
     0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
 ]
+# fmt: on
+
 
 def compare(lhs: str, rhs: str) -> int:  # pylint:disable=too-many-return-statements
     tables = [table_lv0, table_lv4]
@@ -95,6 +98,7 @@ def _wrap_exception(ex, desired_type):
         msg = ex.args[0]
     return desired_type(msg)
 
+
 # This method attempts to emulate the sorting done by the service
 def _storage_header_sort(input_headers: List[Tuple[str, str]]) -> List[Tuple[str, str]]:
 
@@ -135,38 +139,42 @@ class SharedKeyCredentialPolicy(SansIOHTTPPolicy):
     @staticmethod
     def _get_headers(request, headers_to_sign):
         headers = dict((name.lower(), value) for name, value in request.http_request.headers.items() if value)
-        if 'content-length' in headers and headers['content-length'] == '0':
-            del headers['content-length']
-        return '\n'.join(headers.get(x, '') for x in headers_to_sign) + '\n'
+        if "content-length" in headers and headers["content-length"] == "0":
+            del headers["content-length"]
+        return "\n".join(headers.get(x, "") for x in headers_to_sign) + "\n"
 
     @staticmethod
     def _get_verb(request):
-        return request.http_request.method + '\n'
+        return request.http_request.method + "\n"
 
     def _get_canonicalized_resource(self, request):
         uri_path = urlparse(request.http_request.url).path
         try:
-            if isinstance(request.context.transport, AioHttpTransport) or \
-                    isinstance(getattr(request.context.transport, "_transport", None), AioHttpTransport) or \
-                    isinstance(getattr(getattr(request.context.transport, "_transport", None), "_transport", None),
-                               AioHttpTransport):
+            if (
+                isinstance(request.context.transport, AioHttpTransport)
+                or isinstance(getattr(request.context.transport, "_transport", None), AioHttpTransport)
+                or isinstance(
+                    getattr(getattr(request.context.transport, "_transport", None), "_transport", None),
+                    AioHttpTransport,
+                )
+            ):
                 uri_path = URL(uri_path)
-                return '/' + self.account_name + str(uri_path)
+                return "/" + self.account_name + str(uri_path)
         except TypeError:
             pass
-        return '/' + self.account_name + uri_path
+        return "/" + self.account_name + uri_path
 
     @staticmethod
     def _get_canonicalized_headers(request):
-        string_to_sign = ''
+        string_to_sign = ""
         x_ms_headers = []
         for name, value in request.http_request.headers.items():
-            if name.startswith('x-ms-'):
+            if name.startswith("x-ms-"):
                 x_ms_headers.append((name.lower(), value))
         x_ms_headers = _storage_header_sort(x_ms_headers)
         for name, value in x_ms_headers:
             if value is not None:
-                string_to_sign += ''.join([name, ':', value, '\n'])
+                string_to_sign += "".join([name, ":", value, "\n"])
         return string_to_sign
 
     @staticmethod
@@ -174,37 +182,46 @@ class SharedKeyCredentialPolicy(SansIOHTTPPolicy):
         sorted_queries = list(request.http_request.query.items())
         sorted_queries.sort()
 
-        string_to_sign = ''
+        string_to_sign = ""
         for name, value in sorted_queries:
             if value is not None:
-                string_to_sign += '\n' + name.lower() + ':' + unquote(value)
+                string_to_sign += "\n" + name.lower() + ":" + unquote(value)
 
         return string_to_sign
 
     def _add_authorization_header(self, request, string_to_sign):
         try:
             signature = sign_string(self.account_key, string_to_sign)
-            auth_string = 'SharedKey ' + self.account_name + ':' + signature
-            request.http_request.headers['Authorization'] = auth_string
+            auth_string = "SharedKey " + self.account_name + ":" + signature
+            request.http_request.headers["Authorization"] = auth_string
         except Exception as ex:
             # Wrap any error that occurred as signing error
             # Doing so will clarify/locate the source of problem
             raise _wrap_exception(ex, AzureSigningError) from ex
 
     def on_request(self, request):
-        string_to_sign = \
-            self._get_verb(request) + \
-            self._get_headers(
+        string_to_sign = (
+            self._get_verb(request)
+            + self._get_headers(
                 request,
                 [
-                    'content-encoding', 'content-language', 'content-length',
-                    'content-md5', 'content-type', 'date', 'if-modified-since',
-                    'if-match', 'if-none-match', 'if-unmodified-since', 'byte_range'
-                ]
-            ) + \
-            self._get_canonicalized_headers(request) + \
-            self._get_canonicalized_resource(request) + \
-            self._get_canonicalized_resource_query(request)
+                    "content-encoding",
+                    "content-language",
+                    "content-length",
+                    "content-md5",
+                    "content-type",
+                    "date",
+                    "if-modified-since",
+                    "if-match",
+                    "if-none-match",
+                    "if-unmodified-since",
+                    "byte_range",
+                ],
+            )
+            + self._get_canonicalized_headers(request)
+            + self._get_canonicalized_resource(request)
+            + self._get_canonicalized_resource_query(request)
+        )
 
         self._add_authorization_header(request, string_to_sign)
         # logger.debug("String_to_sign=%s", string_to_sign)
@@ -212,7 +229,7 @@ class SharedKeyCredentialPolicy(SansIOHTTPPolicy):
 
 class StorageHttpChallenge(object):
     def __init__(self, challenge):
-        """ Parses an HTTP WWW-Authentication Bearer challenge from the Storage service. """
+        """Parses an HTTP WWW-Authentication Bearer challenge from the Storage service."""
         if not challenge:
             raise ValueError("Challenge cannot be empty")
 
@@ -221,7 +238,7 @@ class StorageHttpChallenge(object):
 
         # name=value pairs either comma or space separated with values possibly being
         # enclosed in quotes
-        for item in re.split('[, ]', trimmed_challenge):
+        for item in re.split("[, ]", trimmed_challenge):
             comps = item.split("=")
             if len(comps) == 2:
                 key = comps[0].strip(' "')
@@ -230,11 +247,11 @@ class StorageHttpChallenge(object):
                     self._parameters[key] = value
 
         # Extract and verify required parameters
-        self.authorization_uri = self._parameters.get('authorization_uri')
+        self.authorization_uri = self._parameters.get("authorization_uri")
         if not self.authorization_uri:
             raise ValueError("Authorization Uri not found")
 
-        self.resource_id = self._parameters.get('resource_id')
+        self.resource_id = self._parameters.get("resource_id")
         if not self.resource_id:
             raise ValueError("Resource id not found")
 

azure/storage/blob/_shared/avro/avro_io.py

@@ -42,8 +42,8 @@ logger = logging.getLogger(__name__)
 # ------------------------------------------------------------------------------
 # Constants
 
-STRUCT_FLOAT = struct.Struct('<f')  # little-endian float
-STRUCT_DOUBLE = struct.Struct('<d')  # little-endian double
+STRUCT_FLOAT = struct.Struct("<f")  # little-endian float
+STRUCT_DOUBLE = struct.Struct("<d")  # little-endian double
 
 # ------------------------------------------------------------------------------
 # Exceptions
@@ -56,6 +56,7 @@ class SchemaResolutionException(schema.AvroException):
             fail_msg += f"\nWriter's Schema: {pretty_writers}"
         schema.AvroException.__init__(self, fail_msg)
 
+
 # ------------------------------------------------------------------------------
 # Decoder
 
@@ -78,14 +79,14 @@ class BinaryDecoder(object):
         """Read n bytes.
 
         :param int n: Number of bytes to read.
-        :returns: The next n bytes from the input.
+        :return: The next n bytes from the input.
         :rtype: bytes
         """
-        assert (n >= 0), n
+        assert n >= 0, n
         input_bytes = self.reader.read(n)
         if n > 0 and not input_bytes:
             raise StopIteration
-        assert (len(input_bytes) == n), input_bytes
+        assert len(input_bytes) == n, input_bytes
         return input_bytes
 
     @staticmethod
@@ -149,7 +150,7 @@ class BinaryDecoder(object):
         Bytes are encoded as a long followed by that many bytes of data.
         """
         nbytes = self.read_long()
-        assert (nbytes >= 0), nbytes
+        assert nbytes >= 0, nbytes
         return self.read(nbytes)
 
     def read_utf8(self):
@@ -160,9 +161,9 @@ class BinaryDecoder(object):
         input_bytes = self.read_bytes()
         if PY3:
             try:
-                return input_bytes.decode('utf-8')
+                return input_bytes.decode("utf-8")
             except UnicodeDecodeError as exn:
-                logger.error('Invalid UTF-8 input bytes: %r', input_bytes)  # pylint: disable=do-not-log-raised-errors
+                logger.error("Invalid UTF-8 input bytes: %r", input_bytes)  # pylint: disable=do-not-log-raised-errors
                 raise exn
         else:
             # PY2
@@ -216,41 +217,40 @@ class DatumReader(object):
     def set_writer_schema(self, writer_schema):
         self._writer_schema = writer_schema
 
-    writer_schema = property(lambda self: self._writer_schema,
-                             set_writer_schema)
+    writer_schema = property(lambda self: self._writer_schema, set_writer_schema)
 
     def read(self, decoder):
         return self.read_data(self.writer_schema, decoder)
 
     def read_data(self, writer_schema, decoder):
         # function dispatch for reading data based on type of writer's schema
-        if writer_schema.type == 'null':
+        if writer_schema.type == "null":
             result = decoder.read_null()
-        elif writer_schema.type == 'boolean':
+        elif writer_schema.type == "boolean":
             result = decoder.read_boolean()
-        elif writer_schema.type == 'string':
+        elif writer_schema.type == "string":
             result = decoder.read_utf8()
-        elif writer_schema.type == 'int':
+        elif writer_schema.type == "int":
             result = decoder.read_int()
-        elif writer_schema.type == 'long':
+        elif writer_schema.type == "long":
             result = decoder.read_long()
-        elif writer_schema.type == 'float':
+        elif writer_schema.type == "float":
             result = decoder.read_float()
-        elif writer_schema.type == 'double':
+        elif writer_schema.type == "double":
             result = decoder.read_double()
-        elif writer_schema.type == 'bytes':
+        elif writer_schema.type == "bytes":
             result = decoder.read_bytes()
-        elif writer_schema.type == 'fixed':
+        elif writer_schema.type == "fixed":
             result = self.read_fixed(writer_schema, decoder)
-        elif writer_schema.type == 'enum':
+        elif writer_schema.type == "enum":
             result = self.read_enum(writer_schema, decoder)
-        elif writer_schema.type == 'array':
+        elif writer_schema.type == "array":
             result = self.read_array(writer_schema, decoder)
-        elif writer_schema.type == 'map':
+        elif writer_schema.type == "map":
             result = self.read_map(writer_schema, decoder)
-        elif writer_schema.type in ['union', 'error_union']:
+        elif writer_schema.type in ["union", "error_union"]:
             result = self.read_union(writer_schema, decoder)
-        elif writer_schema.type in ['record', 'error', 'request']:
+        elif writer_schema.type in ["record", "error", "request"]:
             result = self.read_record(writer_schema, decoder)
         else:
             fail_msg = f"Cannot read unknown schema type: {writer_schema.type}"
@@ -258,35 +258,35 @@ class DatumReader(object):
         return result
 
     def skip_data(self, writer_schema, decoder):
-        if writer_schema.type == 'null':
+        if writer_schema.type == "null":
             result = decoder.skip_null()
-        elif writer_schema.type == 'boolean':
+        elif writer_schema.type == "boolean":
             result = decoder.skip_boolean()
-        elif writer_schema.type == 'string':
+        elif writer_schema.type == "string":
             result = decoder.skip_utf8()
-        elif writer_schema.type == 'int':
+        elif writer_schema.type == "int":
             result = decoder.skip_int()
-        elif writer_schema.type == 'long':
+        elif writer_schema.type == "long":
             result = decoder.skip_long()
-        elif writer_schema.type == 'float':
+        elif writer_schema.type == "float":
             result = decoder.skip_float()
-        elif writer_schema.type == 'double':
+        elif writer_schema.type == "double":
             result = decoder.skip_double()
-        elif writer_schema.type == 'bytes':
+        elif writer_schema.type == "bytes":
             result = decoder.skip_bytes()
-        elif writer_schema.type == 'fixed':
+        elif writer_schema.type == "fixed":
             result = self.skip_fixed(writer_schema, decoder)
-        elif writer_schema.type == 'enum':
+        elif writer_schema.type == "enum":
             result = self.skip_enum(decoder)
-        elif writer_schema.type == 'array':
+        elif writer_schema.type == "array":
             self.skip_array(writer_schema, decoder)
             result = None
-        elif writer_schema.type == 'map':
+        elif writer_schema.type == "map":
             self.skip_map(writer_schema, decoder)
             result = None
-        elif writer_schema.type in ['union', 'error_union']:
+        elif writer_schema.type in ["union", "error_union"]:
             result = self.skip_union(writer_schema, decoder)
-        elif writer_schema.type in ['record', 'error', 'request']:
+        elif writer_schema.type in ["record", "error", "request"]:
             self.skip_record(writer_schema, decoder)
             result = None
         else:
@@ -389,8 +389,9 @@ class DatumReader(object):
         # schema resolution
         index_of_schema = int(decoder.read_long())
         if index_of_schema >= len(writer_schema.schemas):
-            fail_msg = (f"Can't access branch index {index_of_schema} "
-                        f"for union with {len(writer_schema.schemas)} branches")
+            fail_msg = (
+                f"Can't access branch index {index_of_schema} " f"for union with {len(writer_schema.schemas)} branches"
+            )
             raise SchemaResolutionException(fail_msg, writer_schema)
         selected_writer_schema = writer_schema.schemas[index_of_schema]
 
@@ -400,8 +401,9 @@ class DatumReader(object):
     def skip_union(self, writer_schema, decoder):
         index_of_schema = int(decoder.read_long())
         if index_of_schema >= len(writer_schema.schemas):
-            fail_msg = (f"Can't access branch index {index_of_schema} "
-                        f"for union with {len(writer_schema.schemas)} branches")
+            fail_msg = (
+                f"Can't access branch index {index_of_schema} " f"for union with {len(writer_schema.schemas)} branches"
+            )
             raise SchemaResolutionException(fail_msg, writer_schema)
         return self.skip_data(writer_schema.schemas[index_of_schema], decoder)
 

azure/storage/blob/_shared/avro/avro_io_async.py

@@ -61,14 +61,14 @@ class AsyncBinaryDecoder(object):
         """Read n bytes.
 
         :param int n: Number of bytes to read.
-        :returns: The next n bytes from the input.
+        :return: The next n bytes from the input.
         :rtype: bytes
         """
-        assert (n >= 0), n
+        assert n >= 0, n
         input_bytes = await self.reader.read(n)
         if n > 0 and not input_bytes:
             raise StopAsyncIteration
-        assert (len(input_bytes) == n), input_bytes
+        assert len(input_bytes) == n, input_bytes
         return input_bytes
 
     @staticmethod
@@ -132,7 +132,7 @@ class AsyncBinaryDecoder(object):
         Bytes are encoded as a long followed by that many bytes of data.
         """
         nbytes = await self.read_long()
-        assert (nbytes >= 0), nbytes
+        assert nbytes >= 0, nbytes
         return await self.read(nbytes)
 
     async def read_utf8(self):
@@ -143,13 +143,13 @@ class AsyncBinaryDecoder(object):
         input_bytes = await self.read_bytes()
         if PY3:
             try:
-                return input_bytes.decode('utf-8')
+                return input_bytes.decode("utf-8")
             except UnicodeDecodeError as exn:
-                logger.error('Invalid UTF-8 input bytes: %r', input_bytes)  # pylint: disable=do-not-log-raised-errors
+                logger.error("Invalid UTF-8 input bytes: %r", input_bytes)  # pylint: disable=do-not-log-raised-errors
                 raise exn
         else:
             # PY2
-            return unicode(input_bytes, "utf-8") # pylint: disable=undefined-variable
+            return unicode(input_bytes, "utf-8")  # pylint: disable=undefined-variable
 
     def skip_null(self):
         pass
@@ -200,41 +200,40 @@ class AsyncDatumReader(object):
     def set_writer_schema(self, writer_schema):
         self._writer_schema = writer_schema
 
-    writer_schema = property(lambda self: self._writer_schema,
-                             set_writer_schema)
+    writer_schema = property(lambda self: self._writer_schema, set_writer_schema)
 
     async def read(self, decoder):
         return await self.read_data(self.writer_schema, decoder)
 
     async def read_data(self, writer_schema, decoder):
         # function dispatch for reading data based on type of writer's schema
-        if writer_schema.type == 'null':
+        if writer_schema.type == "null":
             result = decoder.read_null()
-        elif writer_schema.type == 'boolean':
+        elif writer_schema.type == "boolean":
             result = await decoder.read_boolean()
-        elif writer_schema.type == 'string':
+        elif writer_schema.type == "string":
             result = await decoder.read_utf8()
-        elif writer_schema.type == 'int':
+        elif writer_schema.type == "int":
             result = await decoder.read_int()
-        elif writer_schema.type == 'long':
+        elif writer_schema.type == "long":
             result = await decoder.read_long()
-        elif writer_schema.type == 'float':
+        elif writer_schema.type == "float":
             result = await decoder.read_float()
-        elif writer_schema.type == 'double':
+        elif writer_schema.type == "double":
             result = await decoder.read_double()
-        elif writer_schema.type == 'bytes':
+        elif writer_schema.type == "bytes":
             result = await decoder.read_bytes()
-        elif writer_schema.type == 'fixed':
+        elif writer_schema.type == "fixed":
             result = await self.read_fixed(writer_schema, decoder)
-        elif writer_schema.type == 'enum':
+        elif writer_schema.type == "enum":
             result = await self.read_enum(writer_schema, decoder)
-        elif writer_schema.type == 'array':
+        elif writer_schema.type == "array":
             result = await self.read_array(writer_schema, decoder)
-        elif writer_schema.type == 'map':
+        elif writer_schema.type == "map":
             result = await self.read_map(writer_schema, decoder)
-        elif writer_schema.type in ['union', 'error_union']:
+        elif writer_schema.type in ["union", "error_union"]:
             result = await self.read_union(writer_schema, decoder)
-        elif writer_schema.type in ['record', 'error', 'request']:
+        elif writer_schema.type in ["record", "error", "request"]:
             result = await self.read_record(writer_schema, decoder)
         else:
             fail_msg = f"Cannot read unknown schema type: {writer_schema.type}"
@@ -242,35 +241,35 @@ class AsyncDatumReader(object):
         return result
 
     async def skip_data(self, writer_schema, decoder):
-        if writer_schema.type == 'null':
+        if writer_schema.type == "null":
             result = decoder.skip_null()
-        elif writer_schema.type == 'boolean':
+        elif writer_schema.type == "boolean":
             result = await decoder.skip_boolean()
-        elif writer_schema.type == 'string':
+        elif writer_schema.type == "string":
             result = await decoder.skip_utf8()
-        elif writer_schema.type == 'int':
+        elif writer_schema.type == "int":
             result = await decoder.skip_int()
-        elif writer_schema.type == 'long':
+        elif writer_schema.type == "long":
             result = await decoder.skip_long()
-        elif writer_schema.type == 'float':
+        elif writer_schema.type == "float":
             result = await decoder.skip_float()
-        elif writer_schema.type == 'double':
+        elif writer_schema.type == "double":
             result = await decoder.skip_double()
-        elif writer_schema.type == 'bytes':
+        elif writer_schema.type == "bytes":
             result = await decoder.skip_bytes()
-        elif writer_schema.type == 'fixed':
+        elif writer_schema.type == "fixed":
             result = await self.skip_fixed(writer_schema, decoder)
-        elif writer_schema.type == 'enum':
+        elif writer_schema.type == "enum":
             result = await self.skip_enum(decoder)
-        elif writer_schema.type == 'array':
+        elif writer_schema.type == "array":
             await self.skip_array(writer_schema, decoder)
             result = None
-        elif writer_schema.type == 'map':
+        elif writer_schema.type == "map":
             await self.skip_map(writer_schema, decoder)
             result = None
-        elif writer_schema.type in ['union', 'error_union']:
+        elif writer_schema.type in ["union", "error_union"]:
             result = await self.skip_union(writer_schema, decoder)
-        elif writer_schema.type in ['record', 'error', 'request']:
+        elif writer_schema.type in ["record", "error", "request"]:
             await self.skip_record(writer_schema, decoder)
             result = None
         else:
@@ -373,8 +372,9 @@ class AsyncDatumReader(object):
         # schema resolution
         index_of_schema = int(await decoder.read_long())
         if index_of_schema >= len(writer_schema.schemas):
-            fail_msg = (f"Can't access branch index {index_of_schema} "
-                    f"for union with {len(writer_schema.schemas)} branches")
+            fail_msg = (
+                f"Can't access branch index {index_of_schema} " f"for union with {len(writer_schema.schemas)} branches"
+            )
             raise SchemaResolutionException(fail_msg, writer_schema)
         selected_writer_schema = writer_schema.schemas[index_of_schema]
 
@@ -384,8 +384,9 @@ class AsyncDatumReader(object):
     async def skip_union(self, writer_schema, decoder):
         index_of_schema = int(await decoder.read_long())
         if index_of_schema >= len(writer_schema.schemas):
-            fail_msg = (f"Can't access branch index {index_of_schema} "
-                    f"for union with {len(writer_schema.schemas)} branches")
+            fail_msg = (
+                f"Can't access branch index {index_of_schema} " f"for union with {len(writer_schema.schemas)} branches"
+            )
             raise SchemaResolutionException(fail_msg, writer_schema)
         return await self.skip_data(writer_schema.schemas[index_of_schema], decoder)