dfindexeddb 20241105__py3-none-any.whl → 20260205__py3-none-any.whl

dfindexeddb/leveldb/plugins/chrome_notifications.py

@@ -17,30 +17,37 @@ from __future__ import annotations
 
 import dataclasses
 import logging
-
-from typing import Optional
+from typing import TYPE_CHECKING, Optional
 
 try:
   # pytype: disable=import-error
   from dfdatetime import webkit_time
-  from dfindexeddb.leveldb.plugins import notification_database_data_pb2 as \
-      notification_pb2
+
+  from dfindexeddb.leveldb.plugins import notification_database_data_pb2 as notification_pb2
+
   # pytype: enable=import-error
   _has_import_dependencies = True
 except ImportError as err:
   _has_import_dependencies = False
-  logging.warning((
-      'Could not import dependencies for '
-      'leveldb.plugins.chrome_notifications: %s'), err)
+  logging.warning(
+      (
+          "Could not import dependencies for "
+          "leveldb.plugins.chrome_notifications: %s"
+      ),
+      err,
+  )
 
 from dfindexeddb.indexeddb.chromium import blink
-from dfindexeddb.leveldb.plugins import interface
-from dfindexeddb.leveldb.plugins import manager
+from dfindexeddb.leveldb.plugins import interface, manager
+
+if TYPE_CHECKING:
+  from dfindexeddb.leveldb import ldb, log
 
 
 @dataclasses.dataclass
 class ChromeNotificationRecord(interface.LeveldbPlugin):
   """Chrome notification record."""
+
   src_file: Optional[str] = None
   offset: Optional[int] = None
   key: Optional[str] = None
@@ -71,8 +78,7 @@ class ChromeNotificationRecord(interface.LeveldbPlugin):
 
   @classmethod
   def FromKeyValueRecord(
-      cls,
-      ldb_record
+      cls, ldb_record: ldb.KeyValueRecord | log.ParsedInternalKey
   ) -> ChromeNotificationRecord:
     record = cls()
     record.offset = ldb_record.offset
@@ -84,15 +90,17 @@ class ChromeNotificationRecord(interface.LeveldbPlugin):
       return record
 
     # pylint: disable-next=no-member,line-too-long
-    notification_proto = notification_pb2.NotificationDatabaseDataProto()  # pytype: disable=module-attr
+    notification_proto = notification_pb2.NotificationDatabaseDataProto()  # type: ignore[attr-defined]
     notification_proto.ParseFromString(ldb_record.value)
 
     record.origin = notification_proto.origin
     record.service_worker_registration_id = (
-        notification_proto.service_worker_registration_id)
+        notification_proto.service_worker_registration_id
+    )
     record.notification_title = notification_proto.notification_data.title
     record.notification_direction = (
-        notification_proto.notification_data.direction)
+        notification_proto.notification_data.direction
+    )
     record.notification_lang = notification_proto.notification_data.lang
     record.notification_body = notification_proto.notification_data.body
     record.notification_tag = notification_proto.notification_data.tag
@@ -100,7 +108,8 @@ class ChromeNotificationRecord(interface.LeveldbPlugin):
     record.notification_silent = notification_proto.notification_data.silent
     record.notification_data = notification_proto.notification_data.data
     record.notification_require_interaction = (
-        notification_proto.notification_data.require_interaction)
+        notification_proto.notification_data.require_interaction
+    )
     record.notification_time = webkit_time.WebKitTime(
         timestamp=notification_proto.notification_data.timestamp
     ).CopyToDateTimeString()
@@ -109,10 +118,12 @@ class ChromeNotificationRecord(interface.LeveldbPlugin):
     record.notification_image = notification_proto.notification_data.image
     record.notification_id = notification_proto.notification_id
     record.replaced_existing_notification = (
-        notification_proto.replaced_existing_notification)
+        notification_proto.replaced_existing_notification
+    )
     record.num_clicks = notification_proto.num_clicks
     record.num_action_button_clicks = (
-        notification_proto.num_action_button_clicks)
+        notification_proto.num_action_button_clicks
+    )
     record.creation_time = webkit_time.WebKitTime(
         timestamp=notification_proto.creation_time_millis
     ).CopyToDateTimeString()
@@ -123,7 +134,8 @@ class ChromeNotificationRecord(interface.LeveldbPlugin):
       return record
 
     notification_data = blink.V8ScriptValueDecoder(
-        raw_data=notification_proto.notification_data.data).Deserialize()
+        raw_data=notification_proto.notification_data.data
+    ).Deserialize()
     record.notification_data = notification_data
 
     return record

dfindexeddb/leveldb/plugins/interface.py

@@ -15,16 +15,14 @@
 """Interface for leveldb plugins."""
 from typing import Any, Union
 
-from dfindexeddb.leveldb import record
-from dfindexeddb.leveldb import ldb
-from dfindexeddb.leveldb import log
+from dfindexeddb.leveldb import ldb, log, record
+
 
 class LeveldbPlugin:
   """The base leveldb plugin class."""
 
   @classmethod
-  def FromLevelDBRecord(cls,
-      ldb_record: record.LevelDBRecord) -> Any:
+  def FromLevelDBRecord(cls, ldb_record: record.LevelDBRecord) -> Any:
     """Parses a leveldb record."""
     parsed_record = cls.FromKeyValueRecord(ldb_record.record)
     ldb_record.record = parsed_record
@@ -32,5 +30,6 @@ class LeveldbPlugin:
 
   @classmethod
   def FromKeyValueRecord(
-      cls, ldb_record: Union[ldb.KeyValueRecord, log.ParsedInternalKey]) -> Any:
+      cls, ldb_record: Union[ldb.KeyValueRecord, log.ParsedInternalKey]
+  ) -> Any:
     """Parses a leveldb key value record."""

dfindexeddb/leveldb/plugins/manager.py

@@ -13,7 +13,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 """Leveldb plugin manager."""
-from typing import Type
+from typing import Iterable, Type
 
 from dfindexeddb.leveldb.plugins import interface
 
@@ -21,10 +21,10 @@ from dfindexeddb.leveldb.plugins import interface
 class LeveldbPluginManager:
   """The leveldb plugin manager."""
 
-  _class_registry = {}
+  _class_registry: dict[str, Type[interface.LeveldbPlugin]] = {}
 
   @classmethod
-  def GetPlugins(cls):
+  def GetPlugins(cls) -> Iterable[tuple[str, type[interface.LeveldbPlugin]]]:
     """Retrieves the registered leveldb plugins.
 
     Yields:
@@ -35,7 +35,7 @@ class LeveldbPluginManager:
     yield from cls._class_registry.items()
 
   @classmethod
-  def GetPlugin(cls, plugin_name: str) -> interface.LeveldbPlugin:
+  def GetPlugin(cls, plugin_name: str) -> type[interface.LeveldbPlugin]:
     """Retrieves a class object of a specific plugin.
 
     Args:
@@ -50,10 +50,10 @@ class LeveldbPluginManager:
     try:
       return cls._class_registry[plugin_name]
     except KeyError as exc:
-      raise KeyError(f'Plugin not found: {plugin_name}') from exc
+      raise KeyError(f"Plugin not found: {plugin_name}") from exc
 
   @classmethod
-  def RegisterPlugin(cls, plugin_class: Type[interface.LeveldbPlugin]):
+  def RegisterPlugin(cls, plugin_class: Type[interface.LeveldbPlugin]) -> None:
     """Registers a leveldb plugin.
 
     Args:
@@ -64,12 +64,13 @@ class LeveldbPluginManager:
     """
     plugin_name = plugin_class.__name__
     if plugin_name in cls._class_registry:
-      raise KeyError(f'Plugin already registered {plugin_name}')
+      raise KeyError(f"Plugin already registered {plugin_name}")
     cls._class_registry[plugin_name] = plugin_class
 
   @classmethod
-  def ClearPlugins(cls):
+  def ClearPlugins(cls) -> None:
     """Clears all plugin registrations."""
     cls._class_registry = {}
 
-PluginManager = LeveldbPluginManager()
+
+PluginManager = LeveldbPluginManager()  # pylint: disable=invalid-name

dfindexeddb/leveldb/record.py

@@ -14,18 +14,16 @@
 # limitations under the License.
 """A module for records from LevelDB files."""
 from __future__ import annotations
-from collections import defaultdict
+
 import dataclasses
 import pathlib
 import re
 import sys
+from collections import defaultdict
 from typing import Generator, Optional, Union
 
 from dfindexeddb import errors
-from dfindexeddb.leveldb import definitions
-from dfindexeddb.leveldb import descriptor
-from dfindexeddb.leveldb import ldb
-from dfindexeddb.leveldb import log
+from dfindexeddb.leveldb import definitions, descriptor, ldb, log
 
 
 @dataclasses.dataclass
@@ -42,17 +40,15 @@ class LevelDBRecord:
         a file not part of the active file set (determined by a MANIFEST file).
     recovered: True if the record is a recovered record.
   """
+
   path: str
-  record: Union[
-      ldb.KeyValueRecord,
-      log.ParsedInternalKey]
+  record: Union[ldb.KeyValueRecord, log.ParsedInternalKey]
   level: Optional[int] = None
   recovered: Optional[bool] = None
 
   @classmethod
   def FromFile(
-      cls,
-      file_path: pathlib.Path
+      cls, file_path: pathlib.Path
   ) -> Generator[LevelDBRecord, None, None]:
     """Yields leveldb records from the given path.
 
@@ -62,19 +58,22 @@ class LevelDBRecord:
     Args:
       file_path: the file path.
     """
-    if file_path.name.endswith('.log'):
-      for record in log.FileReader(
-          file_path.as_posix()).GetParsedInternalKeys():
-        yield cls(path=file_path.as_posix(), record=record)
-    elif file_path.name.endswith('.ldb'):
-      for record in ldb.FileReader(file_path.as_posix()).GetKeyValueRecords():
-        yield cls(path=file_path.as_posix(), record=record)
-    elif file_path.name.startswith('MANIFEST'):
-      print(f'Ignoring descriptor file {file_path.as_posix()}', file=sys.stderr)
-    elif file_path.name in ('LOCK', 'CURRENT', 'LOG', 'LOG.old'):
-      print(f'Ignoring {file_path.as_posix()}', file=sys.stderr)
+    if file_path.name.endswith(".log"):
+      for internal_record in log.FileReader(
+          file_path.as_posix()
+      ).GetParsedInternalKeys():
+        yield cls(path=file_path.as_posix(), record=internal_record)
+    elif file_path.name.endswith(".ldb"):
+      for kv_record in ldb.FileReader(
+          file_path.as_posix()
+      ).GetKeyValueRecords():
+        yield cls(path=file_path.as_posix(), record=kv_record)
+    elif file_path.name.startswith("MANIFEST"):
+      print(f"Ignoring descriptor file {file_path.as_posix()}", file=sys.stderr)
+    elif file_path.name in ("LOCK", "CURRENT", "LOG", "LOG.old"):
+      print(f"Ignoring {file_path.as_posix()}", file=sys.stderr)
     else:
-      print(f'Unsupported file type {file_path.as_posix()}', file=sys.stderr)
+      print(f"Unsupported file type {file_path.as_posix()}", file=sys.stderr)
 
 
 class FolderReader:
@@ -94,20 +93,20 @@ class FolderReader:
       ValueError: if foldername is None or not a directory.
     """
     if not foldername or not foldername.is_dir():
-      raise ValueError(f'{foldername} is None or not a directory')
+      raise ValueError(f"{foldername} is None or not a directory")
     self.foldername = foldername
 
   def LogFiles(self) -> Generator[pathlib.Path, None, None]:
     """Returns the log filenames."""
-    yield from self.foldername.glob('*.log')
+    yield from self.foldername.glob("*.log")
 
   def LdbFiles(self) -> Generator[pathlib.Path, None, None]:
     """Returns the ldb filenames."""
-    yield from self.foldername.glob('*.ldb')
+    yield from self.foldername.glob("*.ldb")
 
   def Manifest(self) -> Generator[pathlib.Path, None, None]:
     """Returns the Manifest filenames."""
-    yield from self.foldername.glob('MANIFEST-*')
+    yield from self.foldername.glob("MANIFEST-*")
 
   def GetCurrentManifestPath(self) -> pathlib.Path:
     """Returns the path of the current manifest file.
@@ -116,19 +115,20 @@ class FolderReader:
       ParserError: when the CURRENT file does not exist/contain the expected
           content or when the expected MANIFEST file does not exist.
     """
-    current_path = self.foldername / 'CURRENT'
+    current_path = self.foldername / "CURRENT"
     if not current_path.exists():
-      raise errors.ParserError(f'{current_path!s} does not exist.')
+      raise errors.ParserError(f"{current_path!s} does not exist.")
 
     current_manifest = current_path.read_text().strip()
     manifest_regex = re.compile(definitions.MANIFEST_FILENAME_PATTERN)
     if not manifest_regex.fullmatch(current_manifest):
       raise errors.ParserError(
-          f'{current_path!s} does not contain the expected content')
+          f"{current_path!s} does not contain the expected content"
+      )
 
     manifest_path = self.foldername / current_manifest
     if not manifest_path.exists():
-      raise errors.ParserError(f'{manifest_path!s} does not exist.')
+      raise errors.ParserError(f"{manifest_path!s} does not exist.")
     return manifest_path
 
   def GetLatestVersion(self) -> descriptor.LevelDBVersion:
@@ -139,14 +139,17 @@ class FolderReader:
     """
     current_manifest_path = self.GetCurrentManifestPath()
     latest_version = descriptor.FileReader(
-        str(current_manifest_path)).GetLatestVersion()
+        str(current_manifest_path)
+    ).GetLatestVersion()
     if not latest_version:
       raise errors.ParserError(
-          f'Could not parse a leveldb version from {current_manifest_path!s}')
+          f"Could not parse a leveldb version from {current_manifest_path!s}"
+      )
     return latest_version
 
   def _GetRecordsByFile(
-      self, filename: pathlib.Path) -> Generator[LevelDBRecord, None, None]:
+      self, filename: pathlib.Path
+  ) -> Generator[LevelDBRecord, None, None]:
     """Yields the LevelDBRecords from a file.
 
     Non-log/ldb files are ignored.
@@ -157,20 +160,19 @@ class FolderReader:
     Yields:
       LevelDBRecords
     """
-    if filename.name.endswith('.log'):
+    if filename.name.endswith(".log"):
       yield from self._GetLogRecords(filename)
-    elif filename.name.endswith('.ldb'):
+    elif filename.name.endswith(".ldb"):
       yield from self._GetLdbRecords(filename)
-    elif filename.name.startswith('MANIFEST'):
-      print(f'Ignoring descriptor file {filename.as_posix()}', file=sys.stderr)
-    elif filename.name in ('LOCK', 'CURRENT', 'LOG', 'LOG.old'):
-      print(f'Ignoring {filename.as_posix()}', file=sys.stderr)
+    elif filename.name.startswith("MANIFEST"):
+      print(f"Ignoring descriptor file {filename.as_posix()}", file=sys.stderr)
+    elif filename.name in ("LOCK", "CURRENT", "LOG", "LOG.old"):
+      print(f"Ignoring {filename.as_posix()}", file=sys.stderr)
     else:
-      print(f'Unsupported file type {filename.as_posix()}', file=sys.stderr)
+      print(f"Unsupported file type {filename.as_posix()}", file=sys.stderr)
 
   def _GetLogRecords(
-      self,
-      filename: pathlib.Path
+      self, filename: pathlib.Path
   ) -> Generator[LevelDBRecord, None, None]:
     """Yields the LevelDBRecords from a log file.
 
@@ -184,8 +186,7 @@ class FolderReader:
       yield LevelDBRecord(path=filename.as_posix(), record=record)
 
   def _GetLdbRecords(
-      self,
-      filename: pathlib.Path
+      self, filename: pathlib.Path
   ) -> Generator[LevelDBRecord, None, None]:
     """Yields the LevelDBRecords from a log file.
 
@@ -216,7 +217,7 @@ class FolderReader:
         log_records = list(self._GetLogRecords(filename=current_log_filename))
         processed_files.add(current_log_filename)
     else:
-      print('No current log file.', file=sys.stderr)
+      print("No current log file.", file=sys.stderr)
 
     # read and cache the records from the "young" or 0-level
     young_records = []
@@ -227,8 +228,9 @@ class FolderReader:
         processed_files.add(current_young_filename)
       else:
         print(
-            f'Could not find {current_young_filename} for level 0.',
-            file=sys.stderr)
+            f"Could not find {current_young_filename} for level 0.",
+            file=sys.stderr,
+        )
 
     # sort the log records by the leveldb sequence number in reverse
     # order and update the recovered attribute based on the highest sequence
@@ -237,7 +239,8 @@ class FolderReader:
     for record in sorted(
         log_records,
         key=lambda record: record.record.sequence_number,
-        reverse=True):
+        reverse=True,
+    ):
       if record.record.key not in active_records:
         record.recovered = False
         active_records[record.record.key] = record
@@ -251,7 +254,8 @@ class FolderReader:
     for record in sorted(
         young_records,
         key=lambda record: record.record.sequence_number,
-        reverse=True):
+        reverse=True,
+    ):
       if record.record.key not in active_records:
         record.recovered = False
         active_records[record.record.key] = record
@@ -262,7 +266,8 @@ class FolderReader:
     yield from sorted(
         log_records + young_records,
         key=lambda record: record.record.sequence_number,
-        reverse=False)
+        reverse=False,
+    )
 
     # read records from the active files in each level (except the 0 level)
     # and update the recovered and level attribute.
@@ -278,8 +283,9 @@ class FolderReader:
               yield record
           else:
             print(
-                f'Could not find {current_filename} for level {level}.',
-                file=sys.stderr)
+                f"Could not find {current_filename} for level {level}.",
+                file=sys.stderr,
+            )
 
     # as a final step, parse any other log/ldb files which we will consider
     # any records as recovered since they are not listed in the the active file
@@ -304,22 +310,27 @@ class FolderReader:
     Yields:
       LevelDBRecords.
     """
-    unsorted_records = defaultdict(list)
+    unsorted_records_by_key = defaultdict(list)
 
     for filename in self.foldername.iterdir():
       for leveldb_record in LevelDBRecord.FromFile(filename):
         if leveldb_record:
-          unsorted_records[leveldb_record.record.key].append(leveldb_record)
-    for _, unsorted_records in unsorted_records.items():
+          unsorted_records_by_key[leveldb_record.record.key].append(
+              leveldb_record
+          )
+    for _, unsorted_records in unsorted_records_by_key.items():
       num_unsorted_records = len(unsorted_records)
       if num_unsorted_records == 1:
         unsorted_records[0].recovered = False
         yield unsorted_records[0]
       else:
-        for i, record in enumerate(sorted(
-            unsorted_records, key=lambda x: (
-                x.record.sequence_number, x.record.offset)),
-            start=1):
+        for i, record in enumerate(
+            sorted(
+                unsorted_records,
+                key=lambda x: (x.record.sequence_number, x.record.offset),
+            ),
+            start=1,
+        ):
           if i == num_unsorted_records:
             record.recovered = False
           else:
@@ -327,9 +338,7 @@ class FolderReader:
           yield record
 
   def GetRecords(
-      self,
-      use_manifest: bool = False,
-      use_sequence_number: bool = False
+      self, use_manifest: bool = False, use_sequence_number: bool = False
   ) -> Generator[LevelDBRecord, None, None]:
     """Yield LevelDBRecords.
 

dfindexeddb/leveldb/utils.py

@@ -14,11 +14,21 @@
 # limitations under the License.
 """Helper/utility classes for LevelDB."""
 from __future__ import annotations
+
 import io
+import struct
 from typing import BinaryIO, Tuple, Type, TypeVar
 
-from dfindexeddb import errors
-from dfindexeddb import utils
+from dfindexeddb import errors, utils
+
+
+_CHUNK_SIZE = 8
+_MARKER = _CHUNK_SIZE + 1
+_EMPTY_BINARY_SENTINEL = 0
+_SIGN_BIT = 1 << 63
+_SENTINEL = 0
+_TWO_BYTE_ENCODING_INDICATOR = 0x80
+_THREE_BYTE_ENCODING_INDICATOR = 0xFF
 
 
 class LevelDBDecoder(utils.StreamDecoder):
@@ -40,8 +50,9 @@ class LevelDBDecoder(utils.StreamDecoder):
     buffer = self.stream.read()
     if len(buffer) % 2:
       raise errors.DecoderError(
-          f'Odd number of bytes encountered at offset {offset}')
-    return offset, buffer.decode('utf-16-be')
+          f"Odd number of bytes encountered at offset {offset}"
+      )
+    return offset, buffer.decode("utf-16-be")
 
   def DecodeLengthPrefixedSlice(self) -> Tuple[int, bytes]:
     """Returns a tuple of the offset of decoding and the byte 'slice'."""
@@ -55,14 +66,90 @@ class LevelDBDecoder(utils.StreamDecoder):
     _, blob = self.ReadBytes(num_bytes)
     return offset, blob
 
-  def DecodeStringWithLength(self, encoding='utf-16-be') -> Tuple[int, str]:
+  def DecodeStringWithLength(
+      self, encoding: str = "utf-16-be"
+  ) -> Tuple[int, str]:
     """Returns a tuple of the offset of decoding and the string value."""
     offset, length = self.DecodeUint64Varint()
-    _, buffer = self.ReadBytes(length*2)
+    _, buffer = self.ReadBytes(length * 2)
     return offset, buffer.decode(encoding=encoding)
 
+  def DecodeSortableBinary(self) -> Tuple[int, bytes]:
+    """Decodes a sortable binary from the binary stream.
+
+    Returns:
+      a tuple of the offset and the decoded bytes.
 
-T = TypeVar('T')
+    Raises:
+      errors.ParserError: if an invalid tag is encountered.
+    """
+    output = bytearray()
+
+    offset, first = self.PeekBytes(1)
+    if first[0] == _EMPTY_BINARY_SENTINEL:
+      self.ReadBytes(1)
+      return offset, b""
+
+    while True:
+      _, marker_or_sentinel = self.DecodeUint8()
+      if marker_or_sentinel == _MARKER:
+        _, chunk = self.ReadBytes(_CHUNK_SIZE)
+        output.extend(chunk)
+        continue
+      if 1 <= marker_or_sentinel <= _CHUNK_SIZE:
+        payload_len = marker_or_sentinel
+        padding_len = _CHUNK_SIZE - payload_len
+        if padding_len > 0:
+          return offset, bytes(output[:-padding_len])
+        return offset, bytes(output)
+      raise errors.ParserError(
+          f"Invalid marker or sentinel {marker_or_sentinel} in sortable binary"
+      )
+
+  def DecodeSortableDouble(self) -> Tuple[int, float]:
+    """Decodes a sortable double-precision float from the binary stream.
+
+    Returns:
+      a tuple of the offset and the decoded double.
+    """
+    offset, host_bits = self.DecodeInt(8, byte_order="big", signed=False)
+    if host_bits & _SIGN_BIT:
+      host_bits ^= _SIGN_BIT
+    else:
+      host_bits ^= 0xFFFFFFFFFFFFFFFF
+    blob = host_bits.to_bytes(8, byteorder="big")
+    return offset, struct.unpack(">d", blob)[0]
+
+  def DecodeSortableString(self) -> Tuple[int, str]:
+    """Decodes a sortable string from the binary stream.
+
+    Returns:
+      a tuple of the offset and the decoded string.
+
+    Raises:
+      errors.ParserError: if an invalid byte is encountered.
+    """
+    output = []
+    offset = self.stream.tell()
+    while True:
+      _, first = self.DecodeUint8()
+      if first == _SENTINEL:
+        break
+      if (first & 0x80) == 0:
+        output.append(chr((first & 0x7F) - 1))
+      elif (first & 0xC0) == _TWO_BYTE_ENCODING_INDICATOR:
+        _, second = self.DecodeUint8()
+        output.append(chr(((first & 0x3F) << 8) | second))
+      elif first == _THREE_BYTE_ENCODING_INDICATOR:
+        _, high = self.DecodeUint8()
+        _, low = self.DecodeUint8()
+        output.append(chr((high << 8) | low))
+      else:
+        raise errors.ParserError(f"Invalid byte {first} in sortable string")
+    return offset, "".join(output)
+
+
+T = TypeVar("T")
 
 
 class FromDecoderMixin:
@@ -70,7 +157,8 @@ class FromDecoderMixin:
 
   @classmethod
   def FromDecoder(
-      cls: Type[T], decoder: LevelDBDecoder, base_offset: int = 0) -> T:
+      cls: Type[T], decoder: LevelDBDecoder, base_offset: int = 0
+  ) -> T:
     """Decodes a class type from the current position of a LevelDBDecoder.
 
     Args:
@@ -86,8 +174,7 @@ class FromDecoderMixin:
     raise NotImplementedError
 
   @classmethod
-  def FromStream(
-      cls: Type[T], stream: BinaryIO, base_offset: int = 0) -> T:
+  def FromStream(cls: Type[T], stream: BinaryIO, base_offset: int = 0) -> T:
     """Decodes a class type from the current position of a binary stream.
 
     Args:
@@ -98,11 +185,14 @@ class FromDecoderMixin:
       The class instance.
     """
     decoder = LevelDBDecoder(stream)
-    return cls.FromDecoder(decoder=decoder, base_offset=base_offset)
+    return cls.FromDecoder(  # type: ignore[attr-defined,no-any-return]
+        decoder=decoder, base_offset=base_offset
+    )
 
   @classmethod
   def FromBytes(
-      cls: Type[T], raw_data: bytes, base_offset: int = 0) -> T:
+      cls: Type[T], raw_data: bytes | bytearray, base_offset: int = 0
+  ) -> T:
     """Parses a class type from raw bytes.
 
     Args:
@@ -113,4 +203,6 @@ class FromDecoderMixin:
       The class instance.
     """
     stream = io.BytesIO(raw_data)
-    return cls.FromStream(stream=stream, base_offset=base_offset)
+    return cls.FromStream(  # type: ignore[attr-defined,no-any-return]
+        stream=stream, base_offset=base_offset
+    )