Change linter to Ruff (#106)

Author: Schamper

dissect/cstruct/__init__.py

@@ -46,46 +46,46 @@
 )
 
 __all__ = [
-    "cstruct",
-    "ctypes",
-    "ctypes_type",
     "LEB128",
     "Array",
     "BaseType",
+    "BitBuffer",
     "Char",
     "CharArray",
     "Enum",
+    "Error",
     "Expression",
     "Field",
     "Flag",
     "Int",
     "MetaType",
+    "NullPointerDereference",
     "Packed",
+    "ParserError",
     "Pointer",
+    "ResolveError",
     "Structure",
     "Union",
     "Void",
     "Wchar",
     "WcharArray",
-    "BitBuffer",
+    "cstruct",
+    "ctypes",
+    "ctypes_type",
     "dumpstruct",
     "hexdump",
-    "pack",
     "p8",
     "p16",
     "p32",
     "p64",
+    "pack",
     "swap",
     "swap16",
     "swap32",
     "swap64",
-    "unpack",
     "u8",
     "u16",
     "u32",
     "u64",
-    "Error",
-    "ParserError",
-    "ResolveError",
-    "NullPointerDereference",
+    "unpack",
 ]

dissect/cstruct/compiler.py

@@ -6,8 +6,7 @@
 import logging
 from enum import Enum
 from textwrap import dedent, indent
-from types import MethodType
-from typing import TYPE_CHECKING, Iterator
+from typing import TYPE_CHECKING
 
 from dissect.cstruct.bitbuffer import BitBuffer
 from dissect.cstruct.types import (
@@ -30,6 +29,9 @@
 from dissect.cstruct.types.packed import _struct
 
 if TYPE_CHECKING:
+    from collections.abc import Iterator
+    from types import MethodType
+
     from dissect.cstruct.cstruct import cstruct
     from dissect.cstruct.types.structure import Field
 
@@ -127,8 +129,7 @@ def generate_source(self) -> str:
 
         code = indent(dedent(preamble).lstrip() + read_code + dedent(outro), "    ")
 
-        template = f"def _read(cls, stream, context=None):\n{code}"
-        return template
+        return f"def _read(cls, stream, context=None):\n{code}"
 
     def _generate_fields(self) -> Iterator[str]:
         current_offset = 0
@@ -210,10 +211,9 @@ def align_to_field(field: Field) -> Iterator[str]:
             else:
                 current_block.append(field)
 
-            if current_offset is not None and size is not None:
-                if not field.bits or (field.bits and bits_rollover):
-                    current_offset += size
-                    bits_rollover = False
+            if current_offset is not None and size is not None and (not field.bits or bits_rollover):
+                current_offset += size
+                bits_rollover = False
 
         yield from flush()
 

dissect/cstruct/cstruct.py

@@ -4,7 +4,8 @@
 import struct
 import sys
 import types
-from typing import Any, BinaryIO, Iterator
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, BinaryIO
 
 from dissect.cstruct.exceptions import ResolveError
 from dissect.cstruct.expression import Expression
@@ -27,6 +28,9 @@
     Wchar,
 )
 
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+
 
 class cstruct:
     """Main class of cstruct. All types are registered in here.
@@ -134,7 +138,6 @@ def __init__(self, endian: str = "<", pointer: str | None = None):
             "unsigned __int32": "uint32",
             "unsigned __int64": "uint64",
             "unsigned __int128": "uint128",
-            "unsigned __int128": "uint128",
 
             "wchar_t": "wchar",
 
@@ -233,7 +236,7 @@ def add_custom_type(
         """
         self.add_type(name, self._make_type(name, (type_,), size, alignment=alignment, attrs=kwargs))
 
-    def load(self, definition: str, deftype: int = None, **kwargs) -> cstruct:
+    def load(self, definition: str, deftype: int | None = None, **kwargs) -> cstruct:
         """Parse structures from the given definitions using the given definition type.
 
         Definitions can be parsed using different parsers. Currently, there's
@@ -259,7 +262,7 @@ def load(self, definition: str, deftype: int = None, **kwargs) -> cstruct:
 
         return self
 
-    def loadfile(self, path: str, deftype: int = None, **kwargs) -> None:
+    def loadfile(self, path: str, deftype: int | None = None, **kwargs) -> None:
         """Load structure definitions from a file.
 
         The given path will be read and parsed using the .load() function.
@@ -269,7 +272,7 @@ def loadfile(self, path: str, deftype: int = None, **kwargs) -> None:
             deftype: The definition type to parse the definitions with.
             **kwargs: Keyword arguments for parsers.
         """
-        with open(path) as fh:
+        with Path(path).open() as fh:
             self.load(fh.read(), deftype, **kwargs)
 
     def read(self, name: str, stream: BinaryIO) -> Any:
@@ -354,10 +357,10 @@ def _make_array(self, type_: MetaType, num_entries: int | Expression | None) ->
 
         return self._make_type(name, bases, size, alignment=type_.alignment, attrs=attrs)
 
-    def _make_int_type(self, name: str, size: int, signed: bool, *, alignment: int = None) -> type[Int]:
+    def _make_int_type(self, name: str, size: int, signed: bool, *, alignment: int | None = None) -> type[Int]:
         return self._make_type(name, (Int,), size, alignment=alignment, attrs={"signed": signed})
 
-    def _make_packed_type(self, name: str, packchar: str, base: type, *, alignment: int = None) -> type[Packed]:
+    def _make_packed_type(self, name: str, packchar: str, base: type, *, alignment: int | None = None) -> type[Packed]:
         return self._make_type(
             name,
             (base, Packed),
@@ -414,8 +417,7 @@ def ctypes(structure: Structure) -> _ctypes.Structure:
         t = ctypes_type(field.type)
         fields.append((field.name, t))
 
-    tt = type(structure.name, (_ctypes.Structure,), {"_fields_": fields})
-    return tt
+    return type(structure.name, (_ctypes.Structure,), {"_fields_": fields})
 
 
 def ctypes_type(type_: MetaType) -> Any:

dissect/cstruct/expression.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import string
-from typing import TYPE_CHECKING, Callable
+from typing import TYPE_CHECKING, Callable, ClassVar
 
 from dissect.cstruct.exceptions import ExpressionParserError, ExpressionTokenizerError
 
@@ -21,8 +21,7 @@ def __init__(self, expression: str):
     def equal(self, token: str, expected: str | set[str]) -> bool:
         if isinstance(expected, set):
             return token in expected
-        else:
-            return token == expected
+        return token == expected
 
     def alnum(self, token: str) -> bool:
         return token.isalnum()
@@ -88,7 +87,7 @@ def tokenize(self) -> list[str]:
                 continue
 
             # If token is a single digit, keep looping over expression and build the number
-            elif self.match(self.digit, consume=False, append=False):
+            if self.match(self.digit, consume=False, append=False):
                 token += self.get_token()
                 self.consume()
 
@@ -154,7 +153,7 @@ def tokenize(self) -> list[str]:
 class Expression:
     """Expression parser for calculations in definitions."""
 
-    binary_operators = {
+    binary_operators: ClassVar[dict[str, Callable[[int, int], int]]] = {
         "|": lambda a, b: a | b,
         "^": lambda a, b: a ^ b,
         "&": lambda a, b: a & b,
@@ -167,12 +166,12 @@ class Expression:
         "%": lambda a, b: a % b,
     }
 
-    unary_operators = {
+    unary_operators: ClassVar[dict[str, Callable[[int], int]]] = {
         "u": lambda a: -a,
         "~": lambda a: ~a,
     }
 
-    precedence_levels = {
+    precedence_levels: ClassVar[dict[str, int]] = {
         "|": 0,
         "^": 1,
         "&": 2,

dissect/cstruct/parser.py

@@ -2,7 +2,7 @@
 
 import ast
 import re
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
 from dissect.cstruct import compiler
 from dissect.cstruct.exceptions import (
@@ -33,7 +33,7 @@ def parse(self, data: str) -> None:
         Args:
             data: Data to parse definitions from, usually a string.
         """
-        raise NotImplementedError()
+        raise NotImplementedError
 
 
 class TokenParser(Parser):
@@ -119,10 +119,8 @@ def _enum(self, tokens: TokenConsumer) -> None:
                 val = val.strip()
                 if not key:
                     continue
-                if not val:
-                    val = nextval
-                else:
-                    val = Expression(self.cstruct, val).evaluate(values)
+
+                val = nextval if not val else Expression(self.cstruct, val).evaluate(values)
 
                 if enumtype == "flag":
                     high_bit = val.bit_length() - 1
@@ -243,7 +241,7 @@ def _lookup(self, tokens: TokenConsumer) -> None:
         # Dirty trick because the regex expects a ; but we don't want it to be part of the value
         m = pattern.match(ltok.value + ";")
         d = ast.literal_eval(m.group(2))
-        self.cstruct.lookups[m.group(1)] = dict([(self.cstruct.consts[k], v) for k, v in d.items()])
+        self.cstruct.lookups[m.group(1)] = {self.cstruct.consts[k]: v for k, v in d.items()}
 
     def _parse_field(self, tokens: TokenConsumer) -> Field:
         type_ = None
@@ -279,10 +277,7 @@ def _parse_field_type(self, type_: MetaType, name: str) -> tuple[MetaType, str,
 
         if count_expression is not None:
             # Poor mans multi-dimensional array by abusing the eager regex match of count
-            if "][" in count_expression:
-                counts = count_expression.split("][")
-            else:
-                counts = [count_expression]
+            counts = count_expression.split("][") if "][" in count_expression else [count_expression]
 
             for count in reversed(counts):
                 if count == "":
@@ -315,8 +310,7 @@ def _names(self, tokens: TokenConsumer) -> list[str]:
             if ntoken == self.TOK.NAME:
                 names.append(ntoken.value.strip())
             elif ntoken == self.TOK.DEFS:
-                for name in ntoken.value.strip().split(","):
-                    names.append(name.strip())
+                names.extend([name.strip() for name in ntoken.value.strip().split(",")])
 
         return names
 
@@ -333,8 +327,8 @@ def _replacer(match: re.Match) -> str:
             # it means we have captured a non-quoted (real) comment string.
             if comment := match.group(2):
                 return "\n" * comment.count("\n")  # so we will return empty to remove the comment
-            else:  # otherwise, we will return the 1st group
-                return match.group(1)  # captured quoted-string
+            # otherwise, we will return the 1st group
+            return match.group(1)  # captured quoted-string
 
         return regex.sub(_replacer, string)
 
@@ -429,10 +423,8 @@ def _enums(self, data: str) -> None:
                     val = val.strip()
                     if not key:
                         continue
-                    if not val:
-                        val = nextval
-                    else:
-                        val = Expression(self.cstruct, val).evaluate()
+
+                    val = nextval if not val else Expression(self.cstruct, val).evaluate()
 
                     if enumtype == "flag":
                         high_bit = val.bit_length() - 1
@@ -535,7 +527,7 @@ def _lookups(self, data: str, consts: dict[str, int]) -> None:
 
         for t in r:
             d = ast.literal_eval(t.group(2))
-            self.cstruct.lookups[t.group(1)] = dict([(self.cstruct.consts[k], v) for k, v in d.items()])
+            self.cstruct.lookups[t.group(1)] = {self.cstruct.consts[k]: v for k, v in d.items()}
 
     def parse(self, data: str) -> None:
         self._constants(data)
@@ -545,23 +537,23 @@ def parse(self, data: str) -> None:
 
 
 class Token:
-    __slots__ = ("token", "value", "match")
+    __slots__ = ("match", "token", "value")
 
     def __init__(self, token: str, value: str, match: re.Match):
         self.token = token
         self.value = value
         self.match = match
 
-    def __eq__(self, other):
+    def __eq__(self, other: object) -> bool:
         if isinstance(other, Token):
             other = other.token
 
         return self.token == other
 
-    def __ne__(self, other):
+    def __ne__(self, other: object) -> bool:
         return not self == other
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return f"<Token.{self.token} value={self.value!r}>"
 
 
@@ -571,7 +563,7 @@ def __init__(self):
         self.lookup: dict[str, str] = {}
         self.patterns: dict[str, re.Pattern] = {}
 
-    def __getattr__(self, attr: str):
+    def __getattr__(self, attr: str) -> str | Any:
         try:
             return self.lookup[attr]
         except AttributeError:

dissect/cstruct/types/__init__.py

@@ -11,6 +11,7 @@
 from dissect.cstruct.types.wchar import Wchar, WcharArray
 
 __all__ = [
+    "LEB128",
     "Array",
     "ArrayMetaType",
     "BaseType",
@@ -20,7 +21,6 @@
     "Field",
     "Flag",
     "Int",
-    "LEB128",
     "MetaType",
     "Packed",
     "Pointer",