tinycwrap 0.0.3__tar.gz → 0.0.5__tar.gz

{tinycwrap-0.0.3 → tinycwrap-0.0.5}/PKG-INFO

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

{tinycwrap-0.0.3 → tinycwrap-0.0.5}/pyproject.toml

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

{tinycwrap-0.0.3 → tinycwrap-0.0.5}/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)

tinycwrap-0.0.3/tests/test_examples.py → tinycwrap-0.0.5/tests/test_kernels.py

@@ -14,9 +14,9 @@ def cm():
 
 
 def test_dot(cm):
-    x = np.arange(10, dtype=np.float64)
-    y = np.ones_like(x)
-    assert cm.dot(x, y, len_x=len(x)) == np.sum(x * y)
+    x = np.array([1.0, 2.0, 3.0], dtype=np.float64)
+    y = np.array([4.0, 5.0, 6.0], dtype=np.float64)
+    assert cm.dot(x, y, len_x=len(x)) == np.dot(x, y)
 
 
 def test_scale_auto_output(cm):

{tinycwrap-0.0.3 → tinycwrap-0.0.5}/tests/test_path.py

@@ -39,3 +39,20 @@ def test_return_class_path(cp):
     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
+
+def test_post_contract(cp):
+    segments, len_segments = cp.geom2d_segments_from_rectellipse(1,2,3,4)
+    assert segments.shape == (4,)

{tinycwrap-0.0.3 → tinycwrap-0.0.5}/tinycwrap/__init__.py

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

{tinycwrap-0.0.3 → tinycwrap-0.0.5}/tinycwrap/cmodule.py

@@ -381,24 +381,22 @@ class CModule:
             fspec.doc = doc
             contracts = []
             for line in doc.splitlines():
-                if "Contract:" in line or "Post-Contract:" in line:
-                    after = (
-                        line.split("Contract:", 1)[1]
-                        if "Contract:" in line
-                        else line.split("Post-Contract:", 1)[1]
-                    )
-                    is_post = "Post-Contract" in line
-                    for part in after.split(";"):
-                        part = part.strip()
-                        if not part:
-                            continue
-                        mlen = re.match(r"len\((\w+)\)\s*=\s*(.+)", part)
-                        if not mlen:
-                            mlen = re.match(r"(\w+)\s*=\s*(.+)", part)
-                        if mlen:
-                            target = mlen.group(1)
-                            expr = mlen.group(2).strip()
-                            contracts.append((target, expr, is_post))
+                m_contract = re.search(r"(post-)?contract:\s*(.*)", line, flags=re.IGNORECASE)
+                if not m_contract:
+                    continue
+                is_post = m_contract.group(1) is not None
+                after = m_contract.group(2)
+                for part in after.split(";"):
+                    part = part.strip()
+                    if not part:
+                        continue
+                    mlen = re.match(r"len\((\w+)\)\s*=\s*(.+)", part)
+                    if not mlen:
+                        mlen = re.match(r"(\w+)\s*=\s*(.+)", part)
+                    if mlen:
+                        target = mlen.group(1)
+                        expr = mlen.group(2).strip()
+                        contracts.append((target, expr, is_post))
             fspec.contracts = contracts or None
 
     def _mark_length_params_from_contracts(self):
@@ -496,7 +494,15 @@ class CModule:
                             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)
+                                try:
+                                    arr = np.ascontiguousarray(provided, dtype=target_dtype)
+                                except ValueError:
+                                    if hasattr(provided, "_data"):
+                                        arr = np.ascontiguousarray(provided._data, dtype=target_dtype)
+                                    elif isinstance(provided, (list, tuple)) and provided and hasattr(provided[0], "_data"):
+                                        arr = np.ascontiguousarray([p._data for p in provided], dtype=target_dtype)
+                                    else:
+                                        raise
                                 children[f.name] = arr
                                 data[f.name] = arr.ctypes.data
                                 if len_field in dtype.names and len_field not in kwargs:
@@ -507,15 +513,51 @@ class CModule:
                                 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}")
@@ -533,6 +575,7 @@ 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:
@@ -632,20 +675,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)
@@ -763,11 +812,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}))",
@@ -872,11 +920,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}))",
@@ -884,33 +931,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.3 → tinycwrap-0.0.5}/tinycwrap.egg-info/PKG-INFO

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

{tinycwrap-0.0.3 → tinycwrap-0.0.5}/tinycwrap.egg-info/SOURCES.txt

@@ -1,7 +1,7 @@
 README.md
 pyproject.toml
-tests/test_examples.py
 tests/test_geom.py
+tests/test_kernels.py
 tests/test_path.py
 tinycwrap/__init__.py
 tinycwrap/cmodule.py