cbridge 0.1.0b0__tar.gz

cbridge-0.1.0b0/PKG-INFO

@@ -0,0 +1,24 @@
+Metadata-Version: 2.4
+Name: cbridge
+Version: 0.1.0b0
+Summary: Creating ctype structure like dataclass
+Author: ZhengYu, Xu
+Author-email: ZhengYu, Xu <zen-xu@outlook.com>
+License-Expression: MIT
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: typing-extensions ; python_full_version < '3.12'
+Requires-Python: >=3.9
+Project-URL: homepage, https://github.com/zen-xu/cbridge
+Project-URL: issues, https://github.com/zen-xu/cbridge/issues
+Project-URL: repository, https://github.com/zen-xu/cbridge.git
+Description-Content-Type: text/markdown
+
+# cbridge

cbridge-0.1.0b0/README.md

@@ -0,0 +1 @@
+# cbridge

cbridge-0.1.0b0/pyproject.toml

@@ -0,0 +1,66 @@
+[project]
+name = "cbridge"
+version = "0.1.0b0"
+authors = [{ name = "ZhengYu, Xu", email = "zen-xu@outlook.com" }]
+description = "Creating ctype structure like dataclass"
+requires-python = ">=3.9"
+readme = "README.md"
+license = "MIT"
+classifiers = [
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+]
+dependencies = ["typing-extensions; python_version< '3.12'"]
+
+[project.urls]
+homepage = "https://github.com/zen-xu/cbridge"
+repository = "https://github.com/zen-xu/cbridge.git"
+issues = "https://github.com/zen-xu/cbridge/issues"
+
+[build-system]
+requires = ["uv_build>=0.8,<0.9"]
+build-backend = "uv_build"
+
+[tool.ruff]
+extend-exclude = ["docs/*"]
+fix = true
+line-length = 88
+target-version = "py39"
+
+[tool.ruff.lint]
+extend-select = [
+    "B",   # flake8-bugbear
+    "C4",  # flake8-comprehensions
+    "ERA", # flake8-eradicate/eradicate
+    "I",   # isort
+    "N",   # pep8-naming
+    "PIE", # flake8-pie
+    "PGH", # pygrep
+    "RUF", # ruff checks
+    "SIM", # flake8-simplify
+    "TC",  # flake8-type-checking
+    "TID", # flake8-tidy-imports
+    "UP",  # pyupgrade
+]
+
+[tool.ruff.lint.isort]
+force-single-line = true
+known-first-party = ["cbridge"]
+lines-after-imports = 2
+lines-between-types = 1
+
+[tool.ruff.format]
+docstring-code-format = true
+
+[tool.mypy]
+files = "src"
+explicit_package_bases = true
+namespace_packages = true
+show_error_codes = true

cbridge-0.1.0b0/src/cbridge/__init__.py

@@ -0,0 +1,10 @@
+from __future__ import annotations
+
+from .cbridge import CStruct
+
+
+__version__ = "0.1.0b0"
+__authors__ = [
+    "ZhengYu, Xu <zen-xu@outlook.com>",
+]
+__all__ = ["CStruct"]

cbridge-0.1.0b0/src/cbridge/cbridge.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+import ctypes
+import dataclasses as ds
+import sys
+import typing
+
+from typing import TYPE_CHECKING
+from typing import Any
+from typing import TypeVar
+
+
+if sys.version_info >= (3, 12):
+    from typing import dataclass_transform
+else:
+    from typing_extensions import dataclass_transform
+
+if TYPE_CHECKING:
+    from .types import CData
+
+    field = ds.field
+
+
+_T = TypeVar("_T")
+
+
+_BaseStructMeta: type = type(ctypes.Structure)
+
+
+@dataclass_transform()
+class CStructMeta(_BaseStructMeta):
+    def __new__(meta_self, name: str, bases: tuple[type, ...], attrs: dict[str, Any]):
+        annotations = attrs.get("__annotations__", {})
+
+        fields: list[tuple[str, type[CData]]] = []
+
+        def get_base_fields(cls):
+            fields = []
+            for base in reversed(cls.__mro__):
+                if hasattr(base, "_fields_"):
+                    fields += list(base._fields_)
+            return fields
+
+        for base in bases:
+            fields += get_base_fields(base)
+
+        for f_name, field in annotations.items():
+            if getattr(field, "__origin__", None) is typing.ClassVar:
+                continue
+
+            if isinstance(field, tuple):
+                # field is array
+                ctype, length = field
+                if hasattr(length, "__args__"):
+                    length = length.__args__[0]
+                fields.append((f_name, ctype * length))
+            else:
+                fields.append((f_name, field))
+
+        if fields:
+            attrs["_fields_"] = tuple(fields)
+        cls = super().__new__(meta_self, name, bases, attrs)
+        return ds.dataclass()(cls)
+
+
+if TYPE_CHECKING:
+
+    @dataclass_transform(field_specifiers=(field,))
+    class CStruct(ctypes.Structure): ...
+else:
+
+    class CStruct(ctypes.Structure, metaclass=CStructMeta): ...

cbridge-0.1.0b0/src/cbridge/types.py

@@ -0,0 +1,94 @@
+import ctypes
+
+from typing import TYPE_CHECKING
+from typing import Any
+from typing import Generic
+from typing import TypeVar
+from typing import Union
+
+
+if TYPE_CHECKING:
+    from _ctypes import _CData as CData
+
+    Bool = Union[bool, CData]
+    Byte = Union[bytes, CData]
+    Char = Union[bytes, CData]
+    Double = Union[float, CData]
+    Float = Union[float, CData]
+    UByte = Union[bytes, CData]
+    Int = Union[int, CData]
+    Int8 = Union[int, CData]
+    Int16 = Union[int, CData]
+    Int32 = Union[int, CData]
+    Int64 = Union[int, CData]
+    Long = Union[int, CData]
+    LongDouble = Union[float, CData]
+    LongLong = Union[float, CData]
+    Short = Union[int, CData]
+    SizeT = Union[int, CData]
+    SSizeT = Union[int, CData]
+    UInt = Union[int, CData]
+    UInt8 = Union[int, CData]
+    UInt16 = Union[int, CData]
+    UInt32 = Union[int, CData]
+    UInt64 = Union[int, CData]
+    ULong = Union[int, CData]
+    ULongLong = Union[int, CData]
+    UShort = Union[int, CData]
+    WChar = Union[str, CData]
+    VoidPtr = Union[ctypes.c_void_p, Any]
+    CharPtr = Union[ctypes.c_char_p, Any]
+    WCharPtr = Union[ctypes.c_wchar_p, Any]
+else:
+    CData = object
+    Byte = ctypes.c_byte
+    Bool = ctypes.c_bool
+    Char = ctypes.c_char
+    Double = ctypes.c_double
+    Float = ctypes.c_float
+    UByte = ctypes.c_ubyte
+    Int = ctypes.c_int
+    Int8 = ctypes.c_int8
+    Int16 = ctypes.c_int16
+    Int32 = ctypes.c_int32
+    Int64 = ctypes.c_int64
+    Long = ctypes.c_long
+    LongDouble = ctypes.c_longdouble
+    LongLong = ctypes.c_longlong
+    Short = ctypes.c_short
+    SizeT = ctypes.c_size_t
+    SSizeT = ctypes.c_ssize_t
+    UInt = ctypes.c_uint
+    UInt8 = ctypes.c_uint8
+    UInt16 = ctypes.c_uint16
+    UInt32 = ctypes.c_uint32
+    UInt64 = ctypes.c_uint64
+    ULong = ctypes.c_ulong
+    ULongLong = ctypes.c_ulonglong
+    UShort = ctypes.c_ushort
+    WChar = ctypes.c_wchar
+    VoidPtr = ctypes.c_void_p
+    CharPtr = ctypes.c_char_p
+    WCharPtr = ctypes.c_wchar_p
+
+
+CTimeT = ULong
+
+_T = TypeVar("_T")
+_Len = TypeVar("_Len")
+
+
+if TYPE_CHECKING:
+
+    class _Array(Generic[_T, _Len]): ...
+
+    Array = Union[_Array[_T, _Len], list[_T]]
+else:
+
+    class _Array:
+        def __getitem__(
+            self, type_length: tuple[type[CData], int]
+        ) -> tuple[type[CData], int]:
+            return type_length
+
+    Array = _Array()