tinycwrap 0.0.2__tar.gz → 0.0.4__tar.gz

{tinycwrap-0.0.2 → tinycwrap-0.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tinycwrap
-Version: 0.0.2
+Version: 0.0.4
 Summary: Lightweight C-to-Python wrapper generator using CFFI and NumPy
 Author: TinyCWrap Contributors
 Requires-Python: >=3.9

{tinycwrap-0.0.2 → tinycwrap-0.0.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tinycwrap"
-version = "0.0.2"
+version = "0.0.4"
 description = "Lightweight C-to-Python wrapper generator using CFFI and NumPy"
 readme = "README.md"
 requires-python = ">=3.9"

{tinycwrap-0.0.2 → tinycwrap-0.0.4}/tests/test_geom.py

@@ -27,12 +27,18 @@ def test_circle_points_length_contract(cg):
     assert pts.shape == (101,)
 
 
+
 def test_return_struct_array_member(cg):
     seg = cg.G2DSegment()
     seg.type = 1
     seg.data = [0.0, 0.0, 1.0, 1.0, 2.0, 2.0, 3.0, 3.0]
     assert seg.type == 1
     np.testing.assert_allclose(seg.data, [0.0, 0.0, 1.0, 1.0, 2.0, 2.0, 3.0, 3.0])
+    seg= cg.G2DSegment(type=2, data=[9.0]*8)
+    assert seg.type == 2
+    np.testing.assert_allclose(seg.data, [9.0]*8)
+
+
 
 def test_geom2d_return_strct(cg):
     seg = cg.geom2d_line_segment_from_start_length(0.1, 0.2, 0.5, 0.4, 0.3)
@@ -52,3 +58,12 @@ def test_docstring_contains_contract(cg):
     doc = cg.geom2d_rectangle_to_path.__doc__
     assert "Contract: len(out_segments)=4" in doc
     assert "Auto-wrapped C function `geom2d_rectangle_to_path`." in doc
+
+
+def test_polygon_length(cg):
+    pts = cg.G2DPoints(len_points=3)
+    pts.points[0]["x"] = 0.0; pts.points[0]["y"] = 0.0
+    pts.points[1]["x"] = 1.0; pts.points[1]["y"] = 0.0
+    pts.points[2]["x"] = 1.0; pts.points[2]["y"] = 1.0
+    length = cg.geom2d_polygon_length(pts.points)
+    assert length == 2.0

tinycwrap-0.0.4/tests/test_path.py

@@ -0,0 +1,54 @@
+from pathlib import Path
+
+import numpy as np
+import pytest
+
+from tinycwrap import CModule
+
+
+@pytest.fixture(scope="module")
+def cp():
+    return CModule(Path("tests/t1/base.c"), Path("tests/t1/path.c"))
+
+
+def test_path_get_steps_contract(cp):
+    seg = cp.G2DSegment()
+    # line from (0,0) to (1,0)
+    seg.type = 0
+    seg.data = [0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0]
+    segments = np.array([seg._data], dtype=cp.G2DSegment.dtype)
+    steps = cp.geom2d_path_get_steps(segments, ds_min=0.25)
+    expected_len = cp.geom2d_path_get_len_steps(segments, len_segments=len(segments), ds_min=0.25)
+    assert len(steps) == expected_len
+    assert np.isclose(steps[-1], cp.geom2d_path_get_length(segments, len_segments=1))
+
+
+def test_path_struct_pointer_array(cp):
+    path = cp.G2DPath(len_segments=3)
+    assert path.len_segments == 3
+    assert isinstance(path.segments, np.ndarray)
+    assert path.segments.shape == (3,)
+    assert path.segments.dtype == cp.G2DSegment.dtype
+
+
+def test_return_class_path(cp):
+    path=cp.G2DPath(len_segments=1)
+    cp.geom2d_path_from_circle(1.0, path)
+    assert path.len_segments == 1
+    assert path.segments.shape == (1,)
+    seg = path.segments[0]
+    assert seg['type'] == 1  # circle segment
+    np.testing.assert_allclose(seg['data'][:3], [0.0, 0.0, 1.0])  # cx,cy,radius
+
+def test_build_pointer_from_data(cp):
+    segments=cp.geom2d_rectangle_to_path(2.0, 3.0)
+    assert segments.shape == (4,)
+    path=cp.G2DPath(segments=segments, len_segments=len(segments))
+    assert path.len_segments == 4
+    assert path.segments.shape == (4,)
+
+def test_repr_pointer_array(cp):
+    path = cp.G2DPath(len_segments=2)
+    repr_str = repr(path)
+    assert "segments=<segments* 0x" in repr_str
+    assert "len_segments=2" in repr_str

{tinycwrap-0.0.2 → tinycwrap-0.0.4}/tinycwrap/__init__.py

@@ -6,6 +6,6 @@ from .cmodule import CModule
 try:
     __version__ = version("tinycwrap")
 except PackageNotFoundError:
-    __version__ = "0.0.2"
+    __version__ = "0.0.4"
 
 __all__ = ["CModule", "__version__"]

{tinycwrap-0.0.2 → tinycwrap-0.0.4}/tinycwrap/cmodule.py

@@ -462,8 +462,19 @@ class CModule:
         for sname, sspec in self._struct_specs.items():
             try:
                 dtype_fields = []
+                pointer_meta = []
                 for f in sspec.fields:
-                    base_dtype = numpy_dtype_for_base_type(f.base_type)
+                    try:
+                        base_dtype = numpy_dtype_for_base_type(f.base_type)
+                    except TypeError:
+                        base_dtype = None
+                    if f.is_pointer:
+                        dtype_fields.append((f.name, np.uintp))
+                        pointer_meta.append(f)
+                        if base_dtype is None:
+                            continue
+                    if base_dtype is None:
+                        continue
                     if f.array_len:
                         dtype_fields.append((f.name, (base_dtype, (f.array_len,))))
                     else:
@@ -472,19 +483,75 @@ class CModule:
             except TypeError:
                 continue
 
-            def make_struct_class(spec, dtype):
-                slots = ("_data",)
+            def make_struct_class(spec, dtype, _struct_dtypes=self._struct_dtypes):
+                slots = ("_data", "_children")
 
                 def __init__(self, **kwargs):
                     data = np.zeros((), dtype=dtype)
+                    children = {}
+                    # handle pointer+len convention
+                    for f in spec.fields:
+                        if f.is_pointer and f.name in dtype.names:
+                            len_field = f"len_{f.name}"
+                            target_dtype = _struct_dtypes.get(f.base_type)
+                            provided = kwargs.get(f.name)
+                            if provided is not None and target_dtype is not None:
+                                arr = np.ascontiguousarray(provided, dtype=target_dtype)
+                                children[f.name] = arr
+                                data[f.name] = arr.ctypes.data
+                                if len_field in dtype.names and len_field not in kwargs:
+                                    data[len_field] = len(arr)
+                            elif len_field in kwargs and target_dtype is not None:
+                                llen = int(kwargs[len_field])
+                                arr = np.zeros(llen, dtype=target_dtype)
+                                children[f.name] = arr
+                                data[f.name] = arr.ctypes.data
+                                data[len_field] = llen
+                            elif provided is not None:
+                                arr = np.ascontiguousarray(provided)
+                                children[f.name] = arr
+                                data[f.name] = arr.ctypes.data
+                                if len_field in dtype.names and len_field not in kwargs:
+                                    data[len_field] = len(arr)
+                            elif target_dtype is not None and len_field in dtype.names:
+                                llen = int(kwargs.get(len_field, 1))
+                                arr = np.zeros(llen, dtype=target_dtype)
+                                children[f.name] = arr
+                                data[f.name] = arr.ctypes.data
+                                data[len_field] = llen
                     for k in dtype.names:
                         if k in kwargs:
-                            data[k] = kwargs[k]
+                            val = kwargs[k]
+                            field_info = dtype.fields[k][0]
+                            if field_info.shape != ():
+                                arr = np.asarray(val, dtype=field_info.base)
+                                if arr.shape != field_info.shape:
+                                    raise ValueError(f"Field {k} expects shape {field_info.shape}, got {arr.shape}")
+                                np.copyto(data[k], arr)
+                            else:
+                                if k in children:
+                                    data[k] = children[k].ctypes.data
+                                elif isinstance(val, np.ndarray):
+                                    if val.dtype.kind == "V" and val.shape != ():
+                                        arr = np.ascontiguousarray(val)
+                                        data[k] = arr.ctypes.data
+                                        if f"len_{k}" in dtype.names and f"len_{k}" not in kwargs:
+                                            data[f"len_{k}"] = len(arr)
+                                    else:
+                                        data[k] = val
+                                else:
+                                    data[k] = val
                     object.__setattr__(self, "_data", data)
+                    object.__setattr__(self, "_children", children)
 
                 def __repr__(self):
                     parts_list = []
+                    pointer_lengths = getattr(self, "_pointer_lengths", {})
                     for name in dtype.names:
+                        if name in pointer_lengths:
+                            ptr_val = int(self._data[name])
+                            parts_list.append(f"{name}=<{name}* 0x{ptr_val:x}>")
+                            continue
                         val = self._data[name]
                         if val.shape == ():
                             parts_list.append(f"{name}={val.item()!r}")
@@ -502,13 +569,16 @@ class CModule:
                     "zeros": staticmethod(
                         lambda n, _dtype=dtype: np.zeros(n, dtype=_dtype)
                     ),
+                    "_pointer_lengths": {f.name: f"len_{f.name}" for f in spec.fields if f.is_pointer},
                 }
 
                 for fname in dtype.names:
                     field_info = dtype.fields[fname][0]
                     is_scalar = field_info.shape == ()
 
-                    def getter(self, fname=fname, is_scalar=is_scalar):
+                    def getter(self, fname=fname, is_scalar=is_scalar, field_info=field_info):
+                        if fname in getattr(self, "_children", {}):
+                            return self._children[fname]
                         val = self._data[fname]
                         return val.item() if is_scalar else val
 
@@ -519,6 +589,11 @@ class CModule:
                         field_info=field_info,
                         is_scalar=is_scalar,
                     ):
+                        if fname in getattr(self, "_children", {}):
+                            arr = np.ascontiguousarray(value, dtype=self._children[fname].dtype)
+                            self._children[fname] = arr
+                            self._data[fname] = arr.ctypes.data
+                            return
                         if is_scalar:
                             self._data[fname] = value
                         else:
@@ -594,20 +669,26 @@ class CModule:
         struct_names = set(self._struct_specs.keys())
         params: list[str] = []
         len_params: list[str] = []
+        optional_seen = False
         for a in fspec.args:
             if a.is_array_out and a.name.lower().startswith("out"):
                 params.append(f"{a.name}=None")
+                optional_seen = True
             elif a.is_length_param:
                 len_params.append(f"{a.name}=None")
+                optional_seen = True
             elif (
                 a.is_pointer
                 and a.base_type in struct_names
                 and not a.is_const
-                and a.name.lower().startswith("out")
             ):
                 params.append(f"{a.name}=None")
+                optional_seen = True
             else:
-                params.append(a.name)
+                if optional_seen:
+                    params.append(f"{a.name}=None")
+                else:
+                    params.append(a.name)
 
         params.extend(len_params)
         signature = ", ".join(params)
@@ -725,11 +806,10 @@ class CModule:
             if a.is_array_in:
                 const_prefix = "const " if a.is_const else ""
                 if a.base_type in struct_names:
-                    cls_expr = f"_struct_classes['{a.base_type}']"
                     dtype_expr = f"_struct_dtypes['{a.base_type}']"
                     pre_lines += [
-                        f"    if isinstance({a.name}, {cls_expr}):",
-                        f"        arr_{a.name} = {a.name}._data",
+                        f"    if hasattr({a.name}, '_data') and getattr({a.name}, '_data', None) is not None and getattr({a.name}, '_data').dtype == {dtype_expr}:",
+                        f"        arr_{a.name} = getattr({a.name}, '_data')",
                         "    else:",
                         f"        arr_{a.name} = np.ascontiguousarray({a.name}, dtype={dtype_expr})",
                         f"    ptr_{a.name} = _self._ffi.cast('{const_prefix}{a.base_type} *', _self._ffi.from_buffer(arr_{a.name}))",
@@ -834,11 +914,10 @@ class CModule:
                         )
             elif a.is_pointer and a.base_type in struct_names:
                 dtype_expr = f"_struct_dtypes['{a.base_type}']"
-                cls_expr = f"_struct_classes['{a.base_type}']"
                 if a.is_const:
                     out_lines += [
-                        f"    if isinstance({a.name}, {cls_expr}):",
-                        f"        arr_{a.name} = {a.name}._data",
+                        f"    if hasattr({a.name}, '_data') and getattr({a.name}, '_data', None) is not None and getattr({a.name}, '_data').dtype == {dtype_expr}:",
+                        f"        arr_{a.name} = getattr({a.name}, '_data')",
                         "    else:",
                         f"        arr_{a.name} = np.ascontiguousarray({a.name}, dtype={dtype_expr})",
                         f"    ptr_{a.name} = _self._ffi.cast('{a.base_type} *', _self._ffi.from_buffer(arr_{a.name}))",
@@ -846,33 +925,18 @@ class CModule:
                 else:
                     out_lines += [
                         f"    if {a.name} is None:",
-                    ]
-                    if a.array_len is not None:
-                        out_lines += [
-                            f"        arr_{a.name} = np.zeros({int(a.array_len)}, dtype={dtype_expr})"
-                        ]
-                    elif a.name in contract_map:
-                        expr_py = _expr_py(contract_map[a.name])
-                        out_lines += [
-                            f"        arr_{a.name} = np.zeros(int({expr_py}), dtype={dtype_expr})"
-                        ]
-                    elif a.array_len is None and a.name not in contract_map:
-                        out_lines += [
-                            f"        arr_{a.name} = np.zeros((), dtype={dtype_expr})"
-                        ]
-                    else:
-                        out_lines += [
-                            f"        raise ValueError('{fspec.name}: provide {a.name} or a Contract for its length')"
-                        ]
-                    out_lines += [
-                        f"    elif isinstance({a.name}, {cls_expr}):",
+                        f"        obj_{a.name} = _struct_classes['{a.base_type}']()",
+                        f"        arr_{a.name} = obj_{a.name}._data",
+                        f"    elif hasattr({a.name}, '_data') and getattr({a.name}, '_data', None) is not None and getattr({a.name}, '_data').dtype == {dtype_expr}:",
+                        f"        obj_{a.name} = {a.name}",
                         f"        arr_{a.name} = {a.name}._data",
                         "    else:",
                         f"        arr_{a.name} = np.ascontiguousarray({a.name}, dtype={dtype_expr})",
+                        f"        obj_{a.name} = None",
                         f"    ptr_{a.name} = _self._ffi.cast('{a.base_type} *', _self._ffi.from_buffer(arr_{a.name}))",
                     ]
                     output_names.append(a.name)
-                    output_vars.append(f"arr_{a.name}")
+                    output_vars.append(f"obj_{a.name} if obj_{a.name} is not None else arr_{a.name}")
                 arg_call_args[idx] = f"ptr_{a.name}"
             elif a.is_scalar and not a.is_length_param and arg_call_args[idx] is None:
                 scalar_lines.append(f"    {a.name} = {a.name}")

{tinycwrap-0.0.2 → tinycwrap-0.0.4}/tinycwrap/parsing.py

@@ -200,10 +200,6 @@ def _parse_structs_with_pycparser(cdef: str) -> dict[str, StructSpec]:
                 for decl in struct.decls:
                     ctype, is_ptr, is_const, arr_len = _ctype_from_decl(decl.type)
                     base = base_type_from_ctype(ctype)
-                    try:
-                        numpy_dtype_for_base_type(base)
-                    except TypeError:
-                        continue
                     fields.append(
                         StructField(
                             name=decl.name,
@@ -311,7 +307,7 @@ def _parse_structs_regex(cdef: str) -> dict[str, StructSpec]:
             if not line:
                 continue
             line = re.sub(r"/\*.*?\*/", "", line).strip()
-            m_field = re.match(r"(.+?)\s+([A-Za-z_]\w*)(\s*\[(\d+)\])?$", line)
+            m_field = re.match(r"(.+?\*?)\s*([A-Za-z_]\w*)(\s*\[(\d+)\])?$", line)
             if not m_field:
                 continue
             raw_ctype = m_field.group(1).strip()
@@ -320,10 +316,6 @@ def _parse_structs_regex(cdef: str) -> dict[str, StructSpec]:
             is_pointer = "*" in raw_ctype
             is_const = "const" in raw_ctype
             base = base_type_from_ctype(raw_ctype)
-            try:
-                numpy_dtype_for_base_type(base)
-            except TypeError:
-                continue
             fields.append(
                 StructField(
                     name=fname,

{tinycwrap-0.0.2 → tinycwrap-0.0.4}/tinycwrap.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tinycwrap
-Version: 0.0.2
+Version: 0.0.4
 Summary: Lightweight C-to-Python wrapper generator using CFFI and NumPy
 Author: TinyCWrap Contributors
 Requires-Python: >=3.9

tinycwrap-0.0.2/tests/test_path.py

@@ -1,23 +0,0 @@
-from pathlib import Path
-
-import numpy as np
-import pytest
-
-from tinycwrap import CModule
-
-
-@pytest.fixture(scope="module")
-def cp():
-    return CModule(Path("tests/t1/base.c"), Path("tests/t1/path.c"))
-
-
-def test_path_get_steps_contract(cp):
-    seg = cp.G2DSegment()
-    # line from (0,0) to (1,0)
-    seg.type = 0
-    seg.data = [0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0]
-    segments = np.array([seg._data], dtype=cp.G2DSegment.dtype)
-    steps = cp.geom2d_path_get_steps(segments, ds_min=0.25)
-    expected_len = cp.geom2d_path_get_len_steps(segments, len_segments=len(segments), ds_min=0.25)
-    assert len(steps) == expected_len
-    assert np.isclose(steps[-1], cp.geom2d_path_get_length(segments, len_segments=1))