azure-storage-blob 12.25.1__py3-none-any.whl → 12.26.0__py3-none-any.whl

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)
 

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

@@ -26,17 +26,18 @@ logger = logging.getLogger(__name__)
 VERSION = 1
 
 if PY3:
-    MAGIC = b'Obj' + bytes([VERSION])
+    MAGIC = b"Obj" + bytes([VERSION])
     MAGIC_SIZE = len(MAGIC)
 else:
-    MAGIC = 'Obj' + chr(VERSION)
+    MAGIC = "Obj" + chr(VERSION)
     MAGIC_SIZE = len(MAGIC)
 
 # Size of the synchronization marker, in number of bytes:
 SYNC_SIZE = 16
 
 # Schema of the container header:
-META_SCHEMA = schema.parse("""
+META_SCHEMA = schema.parse(
+    """
 {
   "type": "record", "name": "org.apache.avro.file.Header",
   "fields": [{
@@ -50,13 +51,15 @@ META_SCHEMA = schema.parse("""
     "type": {"type": "fixed", "name": "sync", "size": %(sync_size)d}
   }]
 }
-""" % {
-    'magic_size': MAGIC_SIZE,
-    'sync_size': SYNC_SIZE,
-})
+"""
+    % {
+        "magic_size": MAGIC_SIZE,
+        "sync_size": SYNC_SIZE,
+    }
+)
 
 # Codecs supported by container files:
-VALID_CODECS = frozenset(['null', 'deflate'])
+VALID_CODECS = frozenset(["null", "deflate"])
 
 # Metadata key associated to the schema:
 SCHEMA_KEY = "avro.schema"
@@ -69,6 +72,7 @@ SCHEMA_KEY = "avro.schema"
 class DataFileException(schema.AvroException):
     """Problem reading or writing file object containers."""
 
+
 # ------------------------------------------------------------------------------
 
 
@@ -84,7 +88,7 @@ class DataFileReader(object):  # pylint: disable=too-many-instance-attributes
         """
         self._reader = reader
         self._raw_decoder = avro_io.BinaryDecoder(reader)
-        self._header_reader = kwargs.pop('header_reader', None)
+        self._header_reader = kwargs.pop("header_reader", None)
         self._header_decoder = None if self._header_reader is None else avro_io.BinaryDecoder(self._header_reader)
         self._datum_decoder = None  # Maybe reset at every block.
         self._datum_reader = datum_reader
@@ -97,11 +101,11 @@ class DataFileReader(object):  # pylint: disable=too-many-instance-attributes
         self._read_header()
 
         # ensure codec is valid
-        avro_codec_raw = self.get_meta('avro.codec')
+        avro_codec_raw = self.get_meta("avro.codec")
         if avro_codec_raw is None:
             self.codec = "null"
         else:
-            self.codec = avro_codec_raw.decode('utf-8')
+            self.codec = avro_codec_raw.decode("utf-8")
         if self.codec not in VALID_CODECS:
             raise DataFileException(f"Unknown codec: {self.codec}.")
 
@@ -110,7 +114,7 @@ class DataFileReader(object):  # pylint: disable=too-many-instance-attributes
 
         # object_position is to support reading from current position in the future read,
         # no need to downloading from the beginning of avro.
-        if hasattr(self._reader, 'object_position'):
+        if hasattr(self._reader, "object_position"):
             self.reader.track_object_position()
 
         self._cur_object_index = 0
@@ -120,8 +124,7 @@ class DataFileReader(object):  # pylint: disable=too-many-instance-attributes
         if self._header_reader is not None:
             self._datum_decoder = self._raw_decoder
 
-        self.datum_reader.writer_schema = (
-            schema.parse(self.get_meta(SCHEMA_KEY).decode('utf-8')))
+        self.datum_reader.writer_schema = schema.parse(self.get_meta(SCHEMA_KEY).decode("utf-8"))
 
     def __enter__(self):
         return self
@@ -168,7 +171,7 @@ class DataFileReader(object):  # pylint: disable=too-many-instance-attributes
         """Reports the value of a given metadata key.
 
         :param str key: Metadata key to report the value of.
-        :returns: Value associated to the metadata key, as bytes.
+        :return: Value associated to the metadata key, as bytes.
         :rtype: bytes
         """
         return self._meta.get(key)
@@ -184,15 +187,15 @@ class DataFileReader(object):  # pylint: disable=too-many-instance-attributes
         header = self.datum_reader.read_data(META_SCHEMA, header_decoder)
 
         # check magic number
-        if header.get('magic') != MAGIC:
+        if header.get("magic") != MAGIC:
             fail_msg = f"Not an Avro data file: {header.get('magic')} doesn't match {MAGIC!r}."
             raise schema.AvroException(fail_msg)
 
         # set metadata
-        self._meta = header['meta']
+        self._meta = header["meta"]
 
         # set sync marker
-        self._sync_marker = header['sync']
+        self._sync_marker = header["sync"]
 
     def _read_block_header(self):
         self._block_count = self.raw_decoder.read_long()
@@ -200,7 +203,7 @@ class DataFileReader(object):  # pylint: disable=too-many-instance-attributes
             # Skip a long; we don't need to use the length.
             self.raw_decoder.skip_long()
             self._datum_decoder = self._raw_decoder
-        elif self.codec == 'deflate':
+        elif self.codec == "deflate":
             # Compressed data is stored as (length, data), which
             # corresponds to how the "bytes" type is encoded.
             data = self.raw_decoder.read_bytes()
@@ -229,7 +232,7 @@ class DataFileReader(object):  # pylint: disable=too-many-instance-attributes
 
             # object_position is to support reading from current position in the future read,
             # no need to downloading from the beginning of avro file with this attr.
-            if hasattr(self._reader, 'object_position'):
+            if hasattr(self._reader, "object_position"):
                 self.reader.track_object_position()
             self._cur_object_index = 0
 
@@ -242,7 +245,7 @@ class DataFileReader(object):  # pylint: disable=too-many-instance-attributes
         # object_position is to support reading from current position in the future read,
         # This will track the index of the next item to be read.
         # This will also track the offset before the next sync marker.
-        if hasattr(self._reader, 'object_position'):
+        if hasattr(self._reader, "object_position"):
             if self.block_count == 0:
                 # the next event to be read is at index 0 in the new chunk of blocks,
                 self.reader.track_object_position()

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

@@ -24,7 +24,7 @@ logger = logging.getLogger(__name__)
 # Constants
 
 # Codecs supported by container files:
-VALID_CODECS = frozenset(['null'])
+VALID_CODECS = frozenset(["null"])
 
 
 class AsyncDataFileReader(object):  # pylint: disable=too-many-instance-attributes
@@ -39,9 +39,10 @@ class AsyncDataFileReader(object):  # pylint: disable=too-many-instance-attribut
         """
         self._reader = reader
         self._raw_decoder = avro_io_async.AsyncBinaryDecoder(reader)
-        self._header_reader = kwargs.pop('header_reader', None)
-        self._header_decoder = None if self._header_reader is None else \
-            avro_io_async.AsyncBinaryDecoder(self._header_reader)
+        self._header_reader = kwargs.pop("header_reader", None)
+        self._header_decoder = (
+            None if self._header_reader is None else avro_io_async.AsyncBinaryDecoder(self._header_reader)
+        )
         self._datum_decoder = None  # Maybe reset at every block.
         self._datum_reader = datum_reader
         self.codec = "null"
@@ -59,11 +60,11 @@ class AsyncDataFileReader(object):  # pylint: disable=too-many-instance-attribut
         await self._read_header()
 
         # ensure codec is valid
-        avro_codec_raw = self.get_meta('avro.codec')
+        avro_codec_raw = self.get_meta("avro.codec")
         if avro_codec_raw is None:
             self.codec = "null"
         else:
-            self.codec = avro_codec_raw.decode('utf-8')
+            self.codec = avro_codec_raw.decode("utf-8")
         if self.codec not in VALID_CODECS:
             raise DataFileException(f"Unknown codec: {self.codec}.")
 
@@ -72,7 +73,7 @@ class AsyncDataFileReader(object):  # pylint: disable=too-many-instance-attribut
 
         # object_position is to support reading from current position in the future read,
         # no need to downloading from the beginning of avro.
-        if hasattr(self._reader, 'object_position'):
+        if hasattr(self._reader, "object_position"):
             self.reader.track_object_position()
 
         # header_reader indicates reader only has partial content. The reader doesn't have block header,
@@ -80,8 +81,7 @@ class AsyncDataFileReader(object):  # pylint: disable=too-many-instance-attribut
         # Also ChangeFeed only has codec==null, so use _raw_decoder is good.
         if self._header_reader is not None:
             self._datum_decoder = self._raw_decoder
-        self.datum_reader.writer_schema = (
-            schema.parse(self.get_meta(SCHEMA_KEY).decode('utf-8')))
+        self.datum_reader.writer_schema = schema.parse(self.get_meta(SCHEMA_KEY).decode("utf-8"))
         return self
 
     async def __aenter__(self):
@@ -129,7 +129,7 @@ class AsyncDataFileReader(object):  # pylint: disable=too-many-instance-attribut
         """Reports the value of a given metadata key.
 
         :param str key: Metadata key to report the value of.
-        :returns: Value associated to the metadata key, as bytes.
+        :return: Value associated to the metadata key, as bytes.
         :rtype: bytes
         """
         return self._meta.get(key)
@@ -145,15 +145,15 @@ class AsyncDataFileReader(object):  # pylint: disable=too-many-instance-attribut
         header = await self.datum_reader.read_data(META_SCHEMA, header_decoder)
 
         # check magic number
-        if header.get('magic') != MAGIC:
+        if header.get("magic") != MAGIC:
             fail_msg = f"Not an Avro data file: {header.get('magic')} doesn't match {MAGIC!r}."
             raise schema.AvroException(fail_msg)
 
         # set metadata
-        self._meta = header['meta']
+        self._meta = header["meta"]
 
         # set sync marker
-        self._sync_marker = header['sync']
+        self._sync_marker = header["sync"]
 
     async def _read_block_header(self):
         self._block_count = await self.raw_decoder.read_long()
@@ -182,7 +182,7 @@ class AsyncDataFileReader(object):  # pylint: disable=too-many-instance-attribut
 
             # object_position is to support reading from current position in the future read,
             # no need to downloading from the beginning of avro file with this attr.
-            if hasattr(self._reader, 'object_position'):
+            if hasattr(self._reader, "object_position"):
                 await self.reader.track_object_position()
             self._cur_object_index = 0
 
@@ -195,7 +195,7 @@ class AsyncDataFileReader(object):  # pylint: disable=too-many-instance-attribut
         # object_position is to support reading from current position in the future read,
         # This will track the index of the next item to be read.
         # This will also track the offset before the next sync marker.
-        if hasattr(self._reader, 'object_position'):
+        if hasattr(self._reader, "object_position"):
             if self.block_count == 0:
                 # the next event to be read is at index 0 in the new chunk of blocks,
                 await self.reader.track_object_position()