Black code style

Author: andreax79

cstruct/__init__.py

@@ -22,10 +22,10 @@
 # IN THE SOFTWARE.
 #
 
-__author__ = 'Andrea Bonomi <andrea.bonomi@gmail.com>'
-__license__ = 'MIT'
-__version__ = '4.0'
-__date__ = '15 August 2013'
+__author__ = "Andrea Bonomi <andrea.bonomi@gmail.com>"
+__license__ = "MIT"
+__version__ = "4.0"
+__date__ = "15 August 2013"
 
 from typing import Any, Dict, Optional, Type, Union
 from .base import (
@@ -46,20 +46,20 @@
 from .native_types import get_native_type
 
 __all__ = [
-    'LITTLE_ENDIAN',
-    'BIG_ENDIAN',
-    'NATIVE_ORDER',
-    'CHAR_ZERO',
-    'CStruct',
-    'MemCStruct',
-    'CEnum',
-    'define',
-    'undef',
-    'getdef',
-    'typedef',
-    'get_type',
-    'sizeof',
-    'parse',
+    "LITTLE_ENDIAN",
+    "BIG_ENDIAN",
+    "NATIVE_ORDER",
+    "CHAR_ZERO",
+    "CStruct",
+    "MemCStruct",
+    "CEnum",
+    "define",
+    "undef",
+    "getdef",
+    "typedef",
+    "get_type",
+    "sizeof",
+    "parse",
 ]
 
 
@@ -150,14 +150,14 @@ def get_type(type_: str) -> Any:
         type_ = TYPEDEFS[type_]
     if isinstance(type_, CStructMeta):
         return type_
-    elif type_.startswith('struct ') or type_.startswith('union '):
-        kind, type_ = type_.split(' ', 1)
+    elif type_.startswith("struct ") or type_.startswith("union "):
+        kind, type_ = type_.split(" ", 1)
         try:
             return STRUCTS[type_]
         except KeyError:
             raise KeyError(f"Unknown {kind} `{type_}`")
-    elif type_.startswith('enum '):
-        kind, type_ = type_.split(' ', 1)
+    elif type_.startswith("enum "):
+        kind, type_ = type_.split(" ", 1)
         try:
             return ENUMS[type_]
         except KeyError:
@@ -222,4 +222,4 @@ def parse(
     cls_def = parse_struct_def(__struct__, __cls__=__cls__, process_muliple_definition=True, **kargs)
     if cls_def is None:
         return None
-    return cls_def['__cls__'].parse(cls_def, **kargs)
+    return cls_def["__cls__"].parse(cls_def, **kargs)

cstruct/abstract.py

@@ -37,27 +37,27 @@
 from .native_types import get_native_type
 from .exceptions import CStructException, ParserError
 
-__all__ = ['CStructMeta', 'AbstractCStruct', 'CEnumMeta', 'AbstractCEnum']
+__all__ = ["CStructMeta", "AbstractCStruct", "CEnumMeta", "AbstractCEnum"]
 
 
 class CStructMeta(ABCMeta):
     __size__: int = 0
 
     def __new__(metacls: Type[type], name: str, bases: Tuple[str], namespace: Dict[str, Any]) -> Type[Any]:
-        __struct__ = namespace.get('__struct__', None)
-        namespace['__cls__'] = bases[0] if bases else None
+        __struct__ = namespace.get("__struct__", None)
+        namespace["__cls__"] = bases[0] if bases else None
         # Parse the struct
-        if '__struct__' in namespace:
-            if isinstance(namespace['__struct__'], (str, Tokens)):
+        if "__struct__" in namespace:
+            if isinstance(namespace["__struct__"], (str, Tokens)):
                 namespace.update(parse_struct(**namespace))
             __struct__ = True
-        if '__def__' in namespace:
+        if "__def__" in namespace:
             namespace.update(parse_struct_def(**namespace))
             __struct__ = True
         # Create the new class
         new_class: Type[Any] = super().__new__(metacls, name, bases, namespace)
         # Register the class
-        if __struct__ is not None and not namespace.get('__anonymous__'):
+        if __struct__ is not None and not namespace.get("__anonymous__"):
             STRUCTS[name] = new_class
         return new_class
 
@@ -128,23 +128,23 @@ def parse(
         """
         cls_kargs: Dict[str, Any] = dict(kargs)
         if __byte_order__ is not None:
-            cls_kargs['__byte_order__'] = __byte_order__
+            cls_kargs["__byte_order__"] = __byte_order__
         if __is_union__ is not None:
-            cls_kargs['__is_union__'] = __is_union__
-        cls_kargs['__struct__'] = __struct__
+            cls_kargs["__is_union__"] = __is_union__
+        cls_kargs["__struct__"] = __struct__
         if isinstance(__struct__, (str, Tokens)):
-            del cls_kargs['__struct__']
+            del cls_kargs["__struct__"]
             cls_kargs.update(parse_struct_def(__struct__, __cls__=cls, **cls_kargs))
-            cls_kargs['__struct__'] = None
+            cls_kargs["__struct__"] = None
         elif isinstance(__struct__, dict):
-            del cls_kargs['__struct__']
+            del cls_kargs["__struct__"]
             cls_kargs.update(__struct__)
-            cls_kargs['__struct__'] = None
-        __name__ = cls_kargs.get('__name__') or __name__
+            cls_kargs["__struct__"] = None
+        __name__ = cls_kargs.get("__name__") or __name__
         if __name__ is None:  # Anonymous struct
-            __name__ = cls.__name__ + '_' + hashlib.sha1(str(__struct__).encode('utf-8')).hexdigest()
-            cls_kargs['__anonymous__'] = True
-        cls_kargs['__name__'] = __name__
+            __name__ = cls.__name__ + "_" + hashlib.sha1(str(__struct__).encode("utf-8")).hexdigest()
+            cls_kargs["__anonymous__"] = True
+        cls_kargs["__name__"] = __name__
         return type(__name__, (cls,), cls_kargs)
 
     def set_flexible_array_length(self, flexible_array_length: Optional[int]) -> None:
@@ -173,7 +173,7 @@ def unpack(self, buffer: Optional[Union[bytes, BinaryIO]], flexible_array_length
             flexible_array_length: flexible array length
         """
         self.set_flexible_array_length(flexible_array_length)
-        if hasattr(buffer, 'read'):
+        if hasattr(buffer, "read"):
             buffer = buffer.read(self.size)  # type: ignore
             if not buffer:
                 return False
@@ -237,19 +237,19 @@ def inspect(self, start_addr: Optional[int] = None, end_addr: Optional[int] = No
             end_addr: end address
         """
         buffer = StringIO()
-        if hasattr(self, '__mem__'):
+        if hasattr(self, "__mem__"):
             mem = self.__mem__
         else:
             mem = self.pack()
         for i in range(start_addr or 0, end_addr or self.size, 16):
             row = mem[i : i + 16]
             buffer.write(f"{i:08x} ")
             for j, c in enumerate(row):
-                separator = ' ' if j == 7 else ''
+                separator = " " if j == 7 else ""
                 buffer.write(f" {c:02x}{separator}")
             buffer.write("  |")
             for c in row:
-                buffer.write(chr(c) if c >= 32 and c < 127 else '.')
+                buffer.write(chr(c) if c >= 32 and c < 127 else ".")
             buffer.write("|")
             buffer.write("\n")
         buffer.seek(0, 0)
@@ -368,16 +368,16 @@ def parse(
         """
         cls_kargs: Dict[str, Any] = dict(kargs)
         if __size__ is not None:
-            cls_kargs['__size__'] = __size__
+            cls_kargs["__size__"] = __size__
         if __native_format__ is not None:
-            cls_kargs['__native_format__'] = __native_format__
+            cls_kargs["__native_format__"] = __native_format__
 
         if isinstance(__enum__, (str, Tokens)):
             cls_kargs.update(parse_enum_def(__enum__, __cls__=cls, **cls_kargs))
         elif isinstance(__enum__, dict):
             cls_kargs.update(__enum__)
 
-        __name__ = cls_kargs.get('__name__') or __name__
+        __name__ = cls_kargs.get("__name__") or __name__
         if __name__ is None:
             __name__ = cls.__name__ + "_" + hashlib.sha1(str(__enum__).encode("utf-8")).hexdigest()
             cls_kargs["__anonymous__"] = True

cstruct/base.py

@@ -28,22 +28,22 @@
     from .abstract import AbstractCStruct, AbstractCEnum
 
 __all__ = [
-    'LITTLE_ENDIAN',
-    'BIG_ENDIAN',
-    'NATIVE_ORDER',
-    'CHAR_ZERO',
-    'STRUCTS',
-    'DEFINES',
-    'TYPEDEFS',
-    'CHAR_ZERO',
-    'DEFAULT_ENUM_SIZE',
+    "LITTLE_ENDIAN",
+    "BIG_ENDIAN",
+    "NATIVE_ORDER",
+    "CHAR_ZERO",
+    "STRUCTS",
+    "DEFINES",
+    "TYPEDEFS",
+    "CHAR_ZERO",
+    "DEFAULT_ENUM_SIZE",
 ]
 
-LITTLE_ENDIAN = '<'
+LITTLE_ENDIAN = "<"
 "Little-endian, std. size & alignment"
-BIG_ENDIAN = '>'
+BIG_ENDIAN = ">"
 "Big-endian, std. size & alignment"
-NATIVE_ORDER = '@'
+NATIVE_ORDER = "@"
 "Native order, size & alignment"
 
 STRUCTS: Dict[str, Type["AbstractCStruct"]] = {}
@@ -53,23 +53,23 @@
 DEFINES: Dict[str, Any] = {}
 
 TYPEDEFS: Dict[str, str] = {
-    'short int': 'short',
-    'unsigned short int': 'unsigned short',
-    'ushort': 'unsigned short',
-    'long int': 'long',
-    'unsigned long int': 'unsigned long',
-    'int8_t': 'int8',
-    'uint8_t': 'uint8',
-    'int16_t': 'int16',
-    'uint16_t': 'uint16',
-    'int32_t': 'int32',
-    'uint32_t': 'uint32',
-    'int64_t': 'int64',
-    'uint64_t': 'uint64',
+    "short int": "short",
+    "unsigned short int": "unsigned short",
+    "ushort": "unsigned short",
+    "long int": "long",
+    "unsigned long int": "unsigned long",
+    "int8_t": "int8",
+    "uint8_t": "uint8",
+    "int16_t": "int16",
+    "uint16_t": "uint16",
+    "int32_t": "int32",
+    "uint32_t": "uint32",
+    "int64_t": "int64",
+    "uint64_t": "uint64",
 }
 
-ENUM_SIZE_TO_C_TYPE: Dict[int, str] = {1: 'int8', 2: 'int16', 4: 'int32', 8: 'int64'}
+ENUM_SIZE_TO_C_TYPE: Dict[int, str] = {1: "int8", 2: "int16", 4: "int32", 8: "int64"}
 
-CHAR_ZERO = bytes('\0', 'ascii')
+CHAR_ZERO = bytes("\0", "ascii")
 
 DEFAULT_ENUM_SIZE = 4

cstruct/c_expr.py

@@ -31,7 +31,7 @@
 if TYPE_CHECKING:
     from .abstract import AbstractCStruct
 
-__all__ = ['c_eval']
+__all__ = ["c_eval"]
 
 
 def c_eval(expr: str) -> Union[int, float]: