ctyped 0.8.1__py3-none-any.whl

ctyped/__init__.py

@@ -0,0 +1 @@
+VERSION = '0.8.1'

ctyped/exceptions.py

@@ -0,0 +1,20 @@
+
+
+class CtypedException(Exception):
+    """"""
+
+
+class FunctionRedeclared(CtypedException):
+    """"""
+
+
+class UnsupportedTypeError(CtypedException):
+    """"""
+
+
+class TypehintError(CtypedException):
+    """"""
+
+
+class SniffingError(CtypedException):
+    """"""

ctyped/library.py

@@ -0,0 +1,472 @@
+import ctypes
+import inspect
+import logging
+from contextlib import contextmanager
+from ctypes.util import find_library
+from functools import partial, partialmethod, reduce
+from pathlib import Path
+from typing import Any, Callable, Union, List, Dict, Type, ContextManager
+
+from .exceptions import UnsupportedTypeError, TypehintError, CtypedException
+from .sniffer import NmSymbolSniffer, SniffResult
+from .types import CChars, CastedTypeBase, CStruct
+from .utils import cast_type, extract_func_info, FuncInfo
+
+LOGGER = logging.getLogger(__name__)
+
+
+class Scopes:
+
+    def __init__(self, params: dict):
+        self._scopes: list[dict] = []
+        self._keys = ['prefix', 'str_type', 'int_bits', 'int_sign']
+        self.push(params)
+
+    def __call__(
+            this,
+            prefix: str | None = None,
+            str_type: type[CastedTypeBase] = CChars,
+            int_bits: int | None = None,
+            int_sign: bool | None = None,
+            **kwargs) -> ContextManager['Scopes']:
+        """
+
+        :param prefix: Function name prefix to apply to functions under the manager.
+
+        :param str_type: Type to represent strings.
+
+            * ``CChars`` - strings as chars (ANSI) **default**
+            * ``CCharsW`` - strings as wide chars (UTF)
+
+        :param int_bits: int length to be used in function.
+
+            Possible values: 8, 16, 32, 64
+
+        :param int_sign: Flag. Whether to use signed (True) or unsigned (False) ints.
+
+        :param kwargs:
+
+        """
+        return this.context(locals())
+
+    def push(self, params: dict):
+
+        scope = {key: params.get(key) for key in self._keys}
+        self._scopes.append(scope)
+
+    def pop(self):
+        self._scopes.pop()
+
+    def flatten(self):
+
+        scopes = self._scopes
+        keys_bool = {'int_sign'}
+        keys_concat = {'prefix'}
+        result = {}
+
+        def choose(current, prev):
+            return current or prev
+
+        def pick_bool(current, prev):
+            return current if current is not None else prev
+
+        def concat(current, prev):
+            return (prev or '') + (current or '')
+
+        for key in self._keys:
+
+            if key in keys_concat:
+                reducer = concat
+
+            elif key in keys_bool:
+                reducer = pick_bool
+
+            else:
+                reducer = choose
+
+            result[key] = reduce(reducer, (scope[key] for scope in scopes[::-1]))
+
+        return result
+
+    @contextmanager
+    def context(self, params: dict):
+        self.push(params)
+        yield self
+        self.pop()
+
+
+class Library:
+    """Main entry point to describe C library interface.
+
+    Basic usage:
+
+    .. code-block:: python
+
+        lib = Library('mylib')
+
+        with lib.scope(prefix='mylib_'):
+
+            @lib.function()
+            def my_func():
+                ...
+
+        lib.bind_types()
+
+    """
+
+    def __init__(
+            self, name: Union[str, Path], *, autoload: bool = True,
+            prefix: str | None = None,
+            str_type: type[CastedTypeBase] = CChars,
+            int_bits: int | None = None,
+            int_sign: bool | None = None
+    ):
+        """
+
+        :param name: Shared library name or filepath.
+
+        :param autoload: Load library just on Library object initialization.
+
+        :param prefix: Function name prefix to apply to functions in the library.
+
+            Useful when C functions have common prefixes.
+
+        :param str_type: Type to represent strings.
+
+            * ``CChars`` - strings as chars (ANSI) **default**
+            * ``CCharsW`` - strings as wide chars (UTF)
+
+            .. note:: This setting is global to library. Can be changed on function definition level.
+
+        :param int_bits: int length to use by default.
+
+            Possible values: 8, 16, 32, 64
+
+            .. note:: This setting is global to library. Can be changed on function definition level.
+
+        :param int_sign: Flag. Whether to use signed (True) or unsigned (False) ints.
+
+            .. note:: This setting is global to library. Can be changed on function definition level.
+
+        """
+        self.scope = Scopes(locals())
+        self.s = self.scope
+
+        self.name = str(name)
+        self.lib = None
+        self.funcs: dict[str, Union[Callable, partialmethod[Any]]] = {}
+
+        autoload and self.load()
+
+    def load(self):
+        """Loads shared library."""
+        name = self.name
+
+        if not Path(name).exists():
+            name = name.replace('lib', '', 1)
+            name = find_library(name)
+
+        lib = ctypes.CDLL(name, use_errno=True)
+
+        if lib._name is None:
+            lib = None
+
+        if lib is None:
+            raise CtypedException(f'Unable to find library: {name or self.name}')
+
+        self.lib = lib
+
+    def structure(
+            self, *,
+            pack: int | None = None,
+            str_type: CastedTypeBase | None = None,
+            int_bits: int | None = None,
+            int_sign: bool | None = None,
+    ):
+        """Class decorator for C structures definition.
+
+        .. code-block:: python
+
+            @lib.structure
+            class MyStruct:
+
+                first: int
+                second: str
+                third: 'MyStruct'
+
+        :param pack: Allows custom maximum alignment for the fields (as #pragma pack(n)).
+
+        :param str_type: Type to represent strings.
+
+        :param int_bits: int length to be used in function.
+
+        :param int_sign: Flag. Whether to use signed (True) or unsigned (False) ints.
+
+        """
+        params = locals()
+
+        def wrapper(cls_):
+
+            annotations = {
+                attrname: attrhint for attrname, attrhint in cls_.__annotations__.items()
+                if not attrname.startswith('_')}
+
+            with self.scope(**params):
+
+                cls_name = cls_.__name__
+
+                info = FuncInfo(
+                    name_py=cls_name, name_c=None,
+                    annotations=annotations, options=self.scope.flatten())
+
+                # todo maybe support big/little byte order
+                struct = type(cls_name, (CStruct, cls_), {})
+
+                ct_fields = {}
+                fields = []
+
+                for attrname, attrhint in annotations.items():
+
+                    if attrhint == cls_name:
+                        casted = ctypes.POINTER(struct)
+                        ct_fields[attrname] = struct
+
+                    else:
+                        casted = cast_type(info, attrname, attrhint)
+
+                        if issubclass(casted, CastedTypeBase):
+                            ct_fields[attrname] = casted
+
+                    fields.append((attrname, casted))
+
+                LOGGER.debug('Structure %s fields: %s', cls_name, fields)
+
+                if pack:
+                    struct._pack_ = pack
+
+                struct._ct_fields = ct_fields
+                struct._fields_ = fields
+
+            return struct
+
+        return wrapper
+
+    def cls(
+            self, *,
+            prefix: str | None = None,
+            str_type: CastedTypeBase | None = None,
+            int_bits: int | None = None,
+            int_sign: bool | None = None,
+    ):
+        """Class decorator. Allows common parameters application for class methods.
+
+        .. code-block:: python
+
+            @lib.cls(prefix='common_', str_type=CCharsW)
+            class Wide:
+
+                @staticmethod
+                @lib.function()
+                def get_utf(some: str) -> str:
+                    ...
+
+        :param prefix: Function name prefix to apply to functions under the manager.
+
+        :param str_type: Type to represent strings.
+
+        :param int_bits: int length to be used in function.
+
+        :param int_sign: Flag. Whether to use signed (True) or unsigned (False) ints.
+
+        """
+        self.scope.push(locals())
+
+        def wrapper(cls_):
+            # Class body construction is done, unwind scope.
+            self.scope.pop()
+            return cls_
+
+        return wrapper
+
+    def function(
+            self, name_c: Union[str, Callable] | None = None, *, wrap: bool = False,
+            str_type: CastedTypeBase | None = None,
+            int_bits: int | None = None,
+            int_sign: bool | None = None,
+
+    ) -> Callable:
+        """Decorator to mark functions which exported from the library.
+
+        :param name_c: C function name with or without prefix (see ``.scope(prefix=)``).
+            If not set, Python function name is used.
+
+        :param wrap: Do not replace decorated function with ctypes function,
+            but with wrapper, allowing pre- or post-process ctypes function call.
+
+            Useful to organize functions to classes (to automatically pass ``self``)
+            to ctypes function to C function.
+
+            .. code-block:: python
+
+                class Thing(CObject):
+
+                    @lib.function(wrap=True)
+                    def one(self, some: int) -> int:
+                        # Implicitly pass Thing instance alongside
+                        # with explicitly passed `some` arg.
+                        ...
+
+                    @lib.function(wrap=True)
+                    def two(self, some:int, cfunc: Callable) -> int:
+                        # `cfunc` is a wrapper, calling an actual ctypes function.
+                        # If no arguments provided the wrapper will try detect them
+                        # automatically.
+                        result = cfunc()
+                        return result + 1
+
+        :param str_type: Type to represent strings.
+
+            .. note:: Overrides the same named param from library level (see ``__init__`` description).
+
+        :param int_bits: int length to be used in function.
+
+            .. note:: Overrides the same named param from library level (see ``__init__`` description).
+
+        :param int_sign: Flag. Whether to use signed (True) or unsigned (False) ints.
+
+            .. note:: Overrides the same named param from library level (see ``__init__`` description).
+
+        """
+        def cfunc_wrapped(*args, f: Callable, **kwargs):
+
+            if not args:
+                argvals = inspect.getargvalues(inspect.currentframe().f_back)
+                loc = argvals.locals
+                args = tuple(loc[argname] for argname in argvals.args if argname != 'cfunc')
+
+            return f(*args)
+
+        def function_(func_py: Callable, *, name_c: str | None, scope: dict):
+
+            info = extract_func_info(func_py, name_c=name_c, scope=scope, registry=self.funcs)
+            name = info.name_c
+
+            func_c = getattr(self.lib, name)
+
+            # Prepare for late binding in .bind_types().
+            func_c.ctyped = info
+
+            if wrap:
+                func_args = inspect.getfullargspec(func_py).args
+
+                if 'cfunc' in func_args:
+                    # Use existing function, pass `cfunc`.
+
+                    LOGGER.debug('Func [ %s -> %s ] uses wrapped manual call.', name, info.name_py)
+
+                    func_swapped = partialmethod(func_py, cfunc=partial(cfunc_wrapped, f=func_c))
+
+                else:
+                    # Automatically bind first param (self, cls)
+
+                    LOGGER.debug('Func [ %s -> %s ] uses wrapped auto call.', name, info.name_py)
+
+                    func_swapped = partialmethod(func_c)
+
+                func_swapped.cfunc = func_c
+                func_out = func_swapped
+
+            else:
+
+                LOGGER.debug('Func [ %s -> %s ] uses direct call.', name, info.name_py)
+
+                func_out = func_c
+
+            self.funcs[name] = func_out
+
+            return func_out
+
+        if callable(name_c):
+            # Decorator without params.
+            scope = self.scope.flatten()
+            py_func, name_c = name_c, None
+            return function_(py_func, name_c=name_c, scope=scope)
+
+        # Decorator with parameters.
+        with self.scope(**locals()) as scope:
+            scope = scope.flatten()
+
+        return partial(function_, name_c=name_c, scope=scope)
+
+    def method(self, name_c: str | None = None, **kwargs):
+        """Decorator. The same as ``.function()`` with ``wrap=True``."""
+        return self.function(name_c=name_c, wrap=True, **kwargs)
+
+    def sniff(self) -> SniffResult:
+        """Sniffs the library for symbols.
+
+        Sniffing result can be used as 'ctyped' code generator.
+
+        """
+        sniffer = NmSymbolSniffer(self.lib._name)
+        result = sniffer.sniff()
+        return result
+
+    def bind_types(self):
+        """Deduces ctypes argument and result types from Python type hints,
+        binding those types to ctypes functions.
+
+        """
+        LOGGER.debug('Binding signature types to ctypes functions ...')
+
+        for name_c, func_out in self.funcs.items():
+
+            func_c = getattr(func_out, 'cfunc', func_out)
+            func_info: FuncInfo = func_c.ctyped
+
+            name_py = func_info.name_py
+            annotations = func_info.annotations
+            errcheck = None
+
+            try:
+                return_is_annotated = 'return' in annotations
+                restype = cast_type(func_info, 'return', annotations.pop('return', None))
+
+                if restype and issubclass(restype, CastedTypeBase):
+                    errcheck = restype._ct_res
+
+                argtypes = [cast_type(func_info, argname, argtype) for argname, argtype in annotations.items()]
+
+            except TypehintError:
+                # Reset annotations to allow subsequent .bind_types() calls w/o exceptions.
+                func_info.annotations.clear()
+                raise
+
+            try:
+                if argtypes:
+                    func_c.argtypes = argtypes
+
+                if restype or return_is_annotated:
+                    func_c.restype = restype
+
+                if errcheck:
+                    func_c.errcheck = errcheck
+
+            except TypeError as e:
+
+                raise UnsupportedTypeError(
+                    f'Unsupported types declared for {name_py} ({name_c}). '
+                    f'Args: {argtypes}. Result: {restype}. Errcheck: {errcheck}.'
+                ) from e
+
+    #####################################################################################
+    # Shortcuts
+
+    f = function
+    """Shortcut for ``.function()``."""
+    
+    m = method
+    """Shortcut for ``.method()``."""
+    
+    s = None  # type: ignore
+    """Shortcut for ``.scope()``."""

ctyped/sniffer.py

@@ -0,0 +1,128 @@
+import subprocess
+from typing import NamedTuple
+from datetime import datetime
+from pathlib import Path
+from textwrap import dedent
+from typing import List, Union
+
+from .exceptions import SniffingError
+
+
+class SniffedSymbol(NamedTuple):
+    name: str
+    address: str
+    line: str
+"""Represents a symbol sniffed from a library."""
+
+
+class SniffResult:
+    """Represents a library sniffing results."""
+
+    def __init__(self, *, libpath: str):
+        self.symbols: list[SniffedSymbol] = []
+        self.libpath = libpath
+
+    def add_symbol(self, symbol: SniffedSymbol):
+        """Added a symbol to the result."""
+        self.symbols.append(symbol)
+
+    def to_ctyped(self):
+        """Generates ctyped code from sniff result."""
+
+        dumped = [
+            '###',
+            f'# Code below was automatically generated {datetime.utcnow()} UTC',
+            f'# Total functions: {len(self.symbols)}',
+            '###',
+            f"lib = Library('{self.libpath}')",
+            ''
+        ]
+
+        dumped.extend(dedent(
+                f'''
+                @lib.f
+                def {symbol.name}():
+                    """{symbol.line}"""
+                '''
+            ) for symbol in self.symbols)
+
+        dumped.append('\nlib.bind_types()')
+
+        return '\n'.join(dumped)
+
+
+class NmSymbolSniffer:
+    """Uses 'nm' command from 'binutils' package to sniff a library for exported symbols."""
+
+    def __init__(self, libpath: Union[str, Path]):
+        """
+
+        :param libpath: Library path to sniff for symbols.
+
+        """
+        self.libpath = str(libpath)
+
+    def _run(self) -> list[str]:
+
+        try:
+            result = subprocess.run(
+                ['nm', '-DCl', self.libpath],
+                capture_output=True,
+            )
+
+        except FileNotFoundError:  # pragma: nocover
+
+            raise SniffingError(
+                "Command 'nm' execution failed. "
+                "Make sure 'nm' command from 'binutils' package is available.") from None
+
+        if result.returncode:  # pragma: nocover
+            raise SniffingError(f"Command 'nm' execution failed: {result.stderr.decode()}")
+
+        return result.stdout.decode().splitlines()
+
+    def _get_symbols(self, lines: list[str]) -> list[SniffedSymbol]:
+
+        symbols = []
+
+        for line in lines:
+
+            if line.startswith(' '):
+                continue
+
+            chunks = line.split(' ')
+            chunks_len = len(chunks)
+
+            if chunks_len < 2 or chunks[1] != 'T':
+                continue
+
+            if len(chunks) != 3:  # pragma: nocover
+                raise SniffingError(
+                    f"Command 'nm' execution failed: 3 chunks line expected, but given {chunks}")
+
+            address, symtype, name = chunks
+
+            if symtype != 'T' or name.startswith('_'):
+                continue
+
+            name, _, srcline = name.partition('\t')
+
+            symbols.append(
+                SniffedSymbol(
+                    name=name,
+                    address=address,
+                    line=srcline,
+                )
+            )
+
+        return symbols
+
+    def sniff(self) -> SniffResult:
+        """Runs symbols sniffing for library."""
+
+        result = SniffResult(libpath=self.libpath)
+
+        for symbol in self._get_symbols(self._run()):
+            result.add_symbol(symbol)
+
+        return result

ctyped/toolbox.py

@@ -0,0 +1,3 @@
+from .library import Library
+from .types import CObject, CRef
+from .utils import get_last_error, c_callback

ctyped/types.py

@@ -0,0 +1,200 @@
+import ctypes
+from typing import Any, Union
+
+
+class CastedTypeBase:
+
+    @classmethod
+    def _ct_prep(cls, val: Any) -> Union[bytes, int]:
+        # Prepare value. Used for structure fields.
+        return val
+
+    @classmethod
+    def _ct_res(cls, cobj: Any, *args, **kwargs) -> Any:  # pragma: nocover
+        # Function result caster.
+        raise NotImplementedError(f'{cls.__name__}._ct_res() is not implemented')
+
+    @classmethod
+    def from_param(cls, val: Any) -> Any:
+        # Function parameter caster.
+        return val
+
+
+# getattr to cheat type hints
+CShort: int = ctypes.c_short
+CShortU: int = ctypes.c_ushort
+CLong: int = ctypes.c_long
+CLongU: int = ctypes.c_ulong
+CLongLong: int = ctypes.c_longlong
+CLongLongU: int = ctypes.c_ulonglong
+
+CInt: int = ctypes.c_int
+CIntU: int = ctypes.c_uint
+CInt8: int = ctypes.c_int8
+CInt8U: int = ctypes.c_uint8
+CInt16: int = ctypes.c_int16
+CInt16U: int = ctypes.c_uint16
+CInt32: int = ctypes.c_int32
+CInt32U: int = ctypes.c_uint32
+CInt64: int = ctypes.c_int64
+CInt64U: int = ctypes.c_uint64
+
+CPointer: Any = ctypes.c_void_p
+CObject = CPointer  # Mere alias for those who prefer ``class My(CObject): ...`` better.
+
+
+class CStruct(CastedTypeBase, ctypes.Structure):
+    """Helper to represent a structure using native byte order."""
+
+    @classmethod
+    def _ct_prep(cls, val):
+        return ctypes.pointer(val)
+
+    @classmethod
+    def _ct_res(cls, cobj: Any, *args, **kwargs) -> Any:
+
+        if isinstance(cobj, cls):
+            # Structure as a function result.
+            return cobj
+
+        # Substructure handling.
+        return cobj.contents
+
+    def __setattr__(self, key, value):
+        # Allows structure field value casting on assignments.
+
+        casted = self._ct_fields.get(key)
+
+        if casted:
+            value = casted._ct_prep(value)
+
+        super().__setattr__(key, value)
+
+    def __getattribute__(self, key):
+        # Allows customizes structure members types handling.
+
+        get = super().__getattribute__
+
+        value = get(key)
+
+        casted = get('_ct_fields').get(key)
+
+        if casted:
+            return casted._ct_res(value)
+
+        return value
+
+
+class CRef(CastedTypeBase):
+    """Reference helper."""
+
+    @classmethod
+    def carray(cls, typecls: Any, *, size: int = 1) -> 'CRef':
+        """Alternative constructor. Creates a reference to array."""
+
+        typecls = {
+
+            int: ctypes.c_int,
+            str: ctypes.c_char,
+            bool: ctypes.c_bool,
+            float: ctypes.c_float,
+
+        }.get(typecls, typecls)
+
+        val = (typecls * (size or 1))()
+
+        return cls(val)
+
+    @classmethod
+    def cbool(cls, value: bool = False) -> 'CRef':
+        """Alternative constructor. Creates a reference to boolean."""
+        return cls(ctypes.c_bool(value))
+
+    @classmethod
+    def cint(cls, value: int = 0) -> 'CRef':
+        """Alternative constructor. Creates a reference to integer."""
+        return cls(ctypes.c_int(value))
+
+    @classmethod
+    def cfloat(cls, value: float = 0.0) -> 'CRef':
+        """Alternative constructor. Creates a reference to float."""
+        return cls(ctypes.c_float(value))
+
+    @classmethod
+    def from_param(cls, obj: 'CRef'):
+        return ctypes.byref(obj._ct_val)
+
+    def __init__(self, cval: Any):
+        self._ct_val = cval
+
+    def __iter__(self):
+        # Allows iteration for arrays.
+        return iter(self._ct_val)
+
+    def __str__(self):
+        val = self._ct_val.value
+
+        if isinstance(val, bytes):
+            val = val.decode('utf-8')
+
+        return str(val)
+
+    def __int__(self):
+        return int(self._ct_val.value)
+
+    def __float__(self):
+        return float(self._ct_val.value)
+
+    def __bool__(self):
+        return bool(self._ct_val.value)
+
+    def __eq__(self, other):
+        return self._ct_val.value == other
+
+    def __ne__(self, other):
+        return self._ct_val.value != other
+
+    def __lt__(self, other):
+        return self._ct_val.value < other
+
+    def __gt__(self, other):
+        return self._ct_val.value > other
+
+    def __le__(self, other):
+        return self._ct_val.value <= other
+
+    def __ge__(self, other):
+        return self._ct_val.value >= other
+
+
+class CChars(CastedTypeBase, ctypes.c_char_p):
+    """Represents a Python string as a C chars pointer."""
+
+    @classmethod
+    def _ct_prep(cls, val):
+        return val.encode('utf-8')
+
+    @classmethod
+    def _ct_res(cls, cobj: 'CChars', *args, **kwargs) -> str | None:
+        value = cobj.value
+
+        if not value:
+            return ''
+
+        return value.decode('utf-8')
+
+    @classmethod
+    def from_param(cls, val: str):
+        return ctypes.c_char_p(val.encode('utf-8'))
+
+
+class CCharsW(CastedTypeBase, ctypes.c_wchar_p):
+    """Represents a Python string as a C wide chars pointer."""
+
+    @classmethod
+    def _ct_res(cls, cobj: 'CCharsW', *args, **kwargs) -> str | None:
+        return cobj.value or ''
+
+    @classmethod
+    def from_param(cls, val: str):
+        return ctypes.c_wchar_p(val)

ctyped/utils.py

@@ -0,0 +1,172 @@
+import inspect
+from typing import NamedTuple
+from ctypes import get_errno, CFUNCTYPE
+from errno import errorcode
+from os import strerror
+from typing import Callable, Optional
+
+from .exceptions import TypehintError, FunctionRedeclared
+from .types import *
+
+class FuncInfo(NamedTuple):
+    name_py: str
+    name_c: str
+    annotations: dict
+    options: dict
+
+
+class ErrorInfo(NamedTuple):
+    num: int
+    code: int
+    msg: str
+
+
+class _Missing(NamedTuple):
+    pass
+
+
+_MISSING = _Missing()
+
+
+def extract_func_info(func: Callable, *, name_c: str | None, scope: dict, registry: dict) -> FuncInfo:
+
+    name_py = func.__name__
+    name = scope.get('prefix', '') + (name_c or name_py)
+
+    if name in registry:
+        raise FunctionRedeclared(f'Unable to redeclare: {name} ({name_py})')
+
+    annotated_args = {}
+    annotations = func.__annotations__
+
+    # Gather all args and annotations for them.
+    for argname in inspect.getfullargspec(func).args:
+
+        if argname == 'cfunc':
+            continue
+
+        annotation = annotations.get(argname, _MISSING)
+
+        if argname == 'self' and annotation is _MISSING:
+            # Pick class name from qualname.
+            annotation = func.__qualname__.split('.')[-2]
+
+        annotated_args[argname] = annotation
+
+    annotated_args['return'] = annotations.get('return')
+
+    return FuncInfo(name_py=name_py, name_c=name, annotations=annotated_args, options=scope)
+
+
+def thint_str_to_obj(thint: str):
+
+    fback = inspect.currentframe().f_back
+
+    while fback:
+        target = fback.f_globals.get(thint)
+
+        if target:
+            return target
+
+        fback = fback.f_back
+
+
+def cast_type(func_info, argname: str, thint: Any):
+
+    if thint is None:
+        return None
+
+    if isinstance(thint, str):
+        thint_orig = thint
+        thint = thint_str_to_obj(thint)
+
+        if thint is None:
+            raise TypehintError(
+                f'Unable to resolve type hint. '
+                f'Function: {func_info.name_py}. Arg: {argname}. Type: {thint_orig}.')
+
+    if thint is bool:
+        thint = ctypes.c_bool
+
+    elif thint is float:
+        thint = ctypes.c_float
+
+    elif thint is str:
+        thint = func_info.options.get('str_type', CChars)
+
+    elif thint is int:
+        int_bits = func_info.options.get('int_bits')
+        int_sign = func_info.options.get('int_sign', False)
+
+        thint_map = {
+            8: (CInt8, CInt8U),
+            16: (CInt16, CInt16U),
+            32: (CInt32, CInt32U),
+            64: (CInt64, CInt64U),
+
+        }
+
+        if int_bits:
+            assert int_bits in thint_map.keys(), 'Wrong value passed for int_bits.'
+
+        else:
+            int_bits = 64  # todo maybe try to guess
+
+        type_idx = 1 if int_sign is False else 0
+
+        thint = thint_map[int_bits][type_idx] or thint
+
+    return thint
+
+
+def get_last_error() -> ErrorInfo:
+    """Returns last error (``errno``) information named tuple:
+
+    .. code-block:: python
+
+        (err_no, err_code, err_message)
+
+    """
+    num = get_errno()
+    code = errorcode[num]
+    msg = strerror(num)
+
+    return ErrorInfo(num=num, code=code, msg=msg)
+
+
+def c_callback(use_errno: bool = False) -> Callable:
+    """Decorator to turn a Python function into a C callback function.
+
+    .. code-block:: python
+
+        @lib.f
+        def c_func_using_callback(hook: CPointer) -> int:
+            ...
+
+        @c_callback
+        def hook(num: int) -> int:
+            return num + 10
+
+        c_func_using_callback(hook)
+
+    :param use_errno:
+
+    """
+    def cfunction_(func: Callable) -> Callable:
+
+        func_info = extract_func_info(func, name_c=None, scope={}, registry={})
+        annotations = func_info.annotations
+
+        restype = cast_type(func_info, 'return', annotations.pop('return', None))
+        argtypes = [cast_type(func_info, argname, argtype) for argname, argtype in annotations.items()]
+
+        functype = CFUNCTYPE(restype, *argtypes, use_errno=use_errno)
+        cfunc = functype(func)
+
+        return cfunc
+
+    if callable(use_errno):
+        # Decorator without params.
+        return cfunction_(use_errno)
+
+    return cfunction_

ctyped-0.8.1.dist-info/METADATA

@@ -0,0 +1,66 @@
+Metadata-Version: 2.5
+Name: ctyped
+Version: 0.8.1
+Summary: Build ctypes interfaces for shared libraries with type hinting
+Project-URL: Homepage, https://github.com/idlesign/ctyped
+Author-email: Igor Starikov <idlesign@yandex.ru>
+License-Expression: BSD-3-Clause
+License-File: LICENSE
+Keywords: cffi,ctypes,shared library
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# ctyped
+
+<https://github.com/idlesign/ctyped>
+
+[![release](https://img.shields.io/pypi/v/ctyped.svg)](https://pypi.python.org/pypi/ctyped)
+[![lic](https://img.shields.io/pypi/l/ctyped.svg)](https://pypi.python.org/pypi/ctyped)
+[![coverage](https://img.shields.io/coveralls/idlesign/ctyped/master.svg)](https://coveralls.io/r/idlesign/ctyped)
+
+## Description
+
+*Build ctypes interfaces for shared libraries with type hinting*
+
+**Requires Python 3.10+**
+
+* Less boilerplate;
+* Logical structuring;
+* Basic code generator (.so function -> ctyped function);
+* Useful helpers.
+
+```python
+from ctyped.toolbox import Library
+
+# Define library.
+lib = Library('mylib.so')
+
+@lib.structure
+class Box:
+
+    one: int
+    two: str
+
+# Type less with function names prefixes.
+with lib.scope(prefix='mylib_'):
+
+    # Describe function available in the library.
+    @lib.function
+    def some_func(title: str, year: int, box: Box) -> str:
+        ...
+```
+
+## Documentation
+
+<https://ctyped.readthedocs.io/>

ctyped-0.8.1.dist-info/RECORD

@@ -0,0 +1,11 @@
+ctyped/__init__.py,sha256=WH2l3vFfy8w0Du6NRYJJK1jNK0WjKXJ202C4JjWcUWo,18
+ctyped/exceptions.py,sha256=_GJHxHRPevkL7DldeUvBvOTXXNVhSpMuIfp7z-UYvco,263
+ctyped/library.py,sha256=ptDGhOS7Pg6CKMEJn1Co43EWgAW6gwvvp2-FHHEM8kg,14418
+ctyped/sniffer.py,sha256=pteQKKsEX4BL7S4tdPqTwZ2cQHztLEkjN4pQtfKfMcg,3361
+ctyped/toolbox.py,sha256=6Yg1tM3HTudlP9ziH-Aogdj29AJdiHZ2O1iKgAjuTlY,108
+ctyped/types.py,sha256=NKJ5l_53k-EWuejOGMp6xiEKzPV3LB7_xoFUJaK3m8Q,5011
+ctyped/utils.py,sha256=mXAm7YW4axakHxsaMMejRM6Qvn3zfm3nPhefAzlMnjE,4135
+ctyped-0.8.1.dist-info/METADATA,sha256=4vUo0QRi8pz1iBh576G0ygKcNoJXpJFog6TXUNA7ixY,1919
+ctyped-0.8.1.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+ctyped-0.8.1.dist-info/licenses/LICENSE,sha256=vfvP40vyus-Y2rmKhWDSIGSBpLgTBuLj8YN-SU7Boyw,1499
+ctyped-0.8.1.dist-info/RECORD,,

ctyped-0.8.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.33.0
+Root-Is-Purelib: true
+Tag: py3-none-any

ctyped-0.8.1.dist-info/licenses/LICENSE

@@ -0,0 +1,28 @@
+Copyright (c) 2019-2026, Igor `idle sign` Starikov
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the ctyped nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+