funktionsklempner 1.0.0__py3-none-any.whl

funktionsklempner/generate/__init__.py

@@ -0,0 +1,26 @@
+# The Funktionsklempner wrapper code generation module.
+#
+# Author: Malte J. Ziebarth (malte.ziebarth@tum.de)
+#
+# Copyright (C) 2026 Technische Universität München
+#
+# Licensed under the EUPL, Version 1.2 or – as soon they will be approved by
+# the European Commission - subsequent versions of the EUPL (the "Licence");
+# You may not use this work except in compliance with the Licence.
+# You may obtain a copy of the Licence at:
+#
+# https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the Licence is distributed on an "AS IS" basis,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the Licence for the specific language governing permissions and
+# limitations under the Licence.
+#
+# SPDX-FileCopyrightText: 2026 Technical University of Munich
+# SPDX-License-Identifier: EUPL-1.2
+# SPDX-FileContributor: Malte J. Ziebarth <malte.ziebarth@tum.de>
+
+from .python import generate_python_source as generate_python_source
+from .cpp import (generate_cpp_source as generate_cpp_source,
+    generate_cpp_header as generate_cpp_header)

funktionsklempner/generate/boilerplate.py

@@ -0,0 +1,92 @@
+# Write C++ and Python boilerplate code.
+#
+# Author: Malte J. Ziebarth (malte.ziebarth@tum.de)
+#
+# Copyright (C) 2025 Technische Universität München
+#
+# Licensed under the EUPL, Version 1.2 or – as soon they will be approved by
+# the European Commission - subsequent versions of the EUPL (the "Licence");
+# You may not use this work except in compliance with the Licence.
+# You may obtain a copy of the Licence at:
+#
+# https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the Licence is distributed on an "AS IS" basis,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the Licence for the specific language governing permissions and
+# limitations under the Licence.
+#
+# SPDX-FileCopyrightText: 2025 Technical University of Munich
+# SPDX-License-Identifier: EUPL-1.2
+# SPDX-FileContributor: Malte J. Ziebarth <malte.ziebarth@tum.de>
+
+from typing import Iterable, Literal
+from ..wrap.library import WrappedLibrary
+from itertools import islice
+
+
+def generate_boilerplate(
+        lib: WrappedLibrary,
+        ncols: int,
+        language: Literal["C++","Python"]
+    ) -> Iterable[str]:
+    """
+    Generate the license boilerplate code.
+    """
+    if language == "C++":
+        yield f"/*\n"
+        indent = " *"
+    else:
+        indent = "#"
+    n_indent = len(indent)
+    yield indent
+    yield " Autogenerated shared library wrapper for "
+    module = ".".join(lib.module())
+    if len(module) > ncols - 41 - len(indent):
+        # Exceeding maximum column width 'ncols'.
+        yield f"\n{indent} {module}\n{indent}\n{indent} Authors: "
+    else:
+        yield f"{lib.module}\n{indent}\n{indent} Authors: "
+    authors = lib.authors()
+    if len(authors) == 0:
+        raise RuntimeError("No authors declared.")
+    yield f"{authors[0][0]} ({authors[0][1]})\n"
+    for author, email in islice(authors, 1, None):
+        yield f"{indent}          {author} ({email})\n"
+    yield from (
+        f"{indent}\n{indent} SPDX-FileCopyrightText: {cr}\n"
+        for cr in lib.copyright()
+    )
+
+    # Assemble the license boilerplate into the column width:
+    license_boilerplate = lib.license_boilerplate()
+    if license_boilerplate is not None:
+        yield f"{indent}\n"
+        words = license_boilerplate.split()
+        line: list[str] = [indent]
+        line_length = n_indent
+        for word in words:
+            nw = len(word)
+            if line_length + nw + 1 > ncols:
+                # Start a new line. However, if there's only one long word,
+                # write it out here:
+                if len(line) == 1:
+                    yield f"{indent} {word}\n"
+                else:
+                    yield " ".join(line)
+                    yield "\n"
+                    line.clear()
+                    line.append(indent)
+                    line.append(word)
+                    line_length = n_indent + 1 + nw
+            else:
+                line_length += nw + 1
+                line.append(word)
+
+        if len(line) > 1:
+            yield " ".join(line)
+            yield "\n"
+
+    if language == "C++":
+        yield "*/\n"

funktionsklempner/generate/cpp.py

@@ -0,0 +1,86 @@
+# Generate C++ wrapper codes.
+#
+# Author: Malte J. Ziebarth (malte.ziebarth@tum.de)
+#
+# Copyright (C) 2025-2026 Technische Universität München
+#
+# Licensed under the EUPL, Version 1.2 or – as soon they will be approved by
+# the European Commission - subsequent versions of the EUPL (the "Licence");
+# You may not use this work except in compliance with the Licence.
+# You may obtain a copy of the Licence at:
+#
+# https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the Licence is distributed on an "AS IS" basis,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the Licence for the specific language governing permissions and
+# limitations under the Licence.
+#
+# SPDX-FileCopyrightText: 2025 Technical University of Munich
+# SPDX-License-Identifier: EUPL-1.2
+# SPDX-FileContributor: Malte J. Ziebarth <malte.ziebarth@tum.de>
+
+from typing import Iterable
+from ..wrap.library import WrappedLibrary
+from .boilerplate import generate_boilerplate
+from ..repo import include_statement
+
+
+def generate_cpp_source(
+        lib: WrappedLibrary
+    ) -> Iterable[str]:
+    """
+    Writes the C++ source.
+    """
+    # Boilerplate:
+    yield from generate_boilerplate(lib, 80, 'C++')
+
+    yield (
+        "/* For error handling: */\n"
+        "#include <funktionsklempner/strings.hpp>\n\n"
+        "#include <funktionsklempner/call.hpp>\n\n"
+       f"{include_statement(lib.wrapper_include(), delimiter='""')}\n\n"
+    )
+
+    for f in lib.functions:
+        yield from f.compose_cpp_body()
+
+
+def generate_cpp_header(
+        lib: WrappedLibrary
+    ) -> Iterable[str]:
+    """
+    Writes the C++ header.
+    """
+    # Boilerplate:
+    yield from generate_boilerplate(lib, 80, 'C++')
+    yield "\n"
+
+    includeguard = (
+        f"{"_".join(lib.module()).upper()}_HPP"
+    )
+    yield (
+       f"#ifndef {includeguard}\n#define {includeguard}\n\n"
+        "/* For uint64_t and the like: */\n"
+        "#include <cstdint>\n\n"
+        "\n"
+        "\n"
+       f"{include_statement(lib.header_include(), '""')}\n"
+        "\n"
+        'extern "C" {\n'
+        "\n"
+        "\n"
+    )
+
+    for f in lib.functions:
+        yield from f.compose_cpp_head(True)
+        yield "\n"
+
+    yield (
+        "\n"
+        "\n"
+        "}\n"
+        "\n"
+        "#endif\n"
+    )

funktionsklempner/generate/python.py

@@ -0,0 +1,119 @@
+# Generate Python wrapper code.
+#
+# Author: Malte J. Ziebarth (malte.ziebarth@tum.de)
+#
+# Copyright (C) 2025 Technische Universität München
+#
+# Licensed under the EUPL, Version 1.2 or – as soon they will be approved by
+# the European Commission - subsequent versions of the EUPL (the "Licence");
+# You may not use this work except in compliance with the Licence.
+# You may obtain a copy of the Licence at:
+#
+# https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the Licence is distributed on an "AS IS" basis,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the Licence for the specific language governing permissions and
+# limitations under the Licence.
+#
+# SPDX-FileCopyrightText: 2025 Technical University of Munich
+# SPDX-License-Identifier: EUPL-1.2
+# SPDX-FileContributor: Malte J. Ziebarth <malte.ziebarth@tum.de>
+
+from importlib import resources
+from typing import Iterable
+from itertools import islice
+from ..wrap.library import WrappedLibrary
+from ..language.strings import type_string
+from ..language.arrays import NDArray
+from .boilerplate import generate_boilerplate
+from ..tools.views import join
+
+
+with resources.open_text(
+        'funktionsklempner.templates','wrapper.py', encoding='utf-8'
+    ) as f:
+    WRAPPER_PY: str = f.read()
+
+
+CDLL_NAME = "_cdll"
+
+
+
+def generate_python_source(
+        lib: WrappedLibrary
+    ) -> Iterable[str]:
+    """
+
+    """
+    # Boilerplate:
+    yield from generate_boilerplate(lib, 80, 'Python')
+
+    # Define the package and the shared library name for finding them
+    # among the package resources:
+    yield "\n\nANCHOR = '"
+    module = lib.module()
+    yield from join(islice(module, 0, len(module)-1), ".")
+    yield f"'\nSHARED_LIBRARY = '"
+    yield lib.shared_library_name()
+    yield "'\nPACKAGE = '"
+    yield lib.module()[0]
+    yield "'\n\n"
+
+    # Include the boilerplate glue code:
+    yield WRAPPER_PY
+
+    # Import the quantity array. Use a relative import going up to the
+    # root of this package and then back down to _funktionsklempner.
+    yield (
+        f"\n\nfrom {"." * (len(lib.module()) - 2)}"
+         "._funktionsklempner.quantityarray import QuantityArray\n\n"
+    )
+
+    # Import NumPy if we encountered any arrays:
+    if lib.requires_numpy():
+        yield "\nimport numpy as np\nfrom typing import Iterable\n"
+
+    # Structures:
+    structs = lib.structs()
+    if len(structs) > 0:
+        yield "\n"
+        for s in structs:
+            yield f"class {s.name}(Structure):\n"
+            if len(s.members) == 0:
+                yield "    _fields_ = []\n\n"
+            else:
+                yield "    _fields_ = [\n"
+                yield from (
+                    f"        ('{m[1]}', {type_string(m[0])}),\n"
+                    for m in s.members
+                )
+                yield "    ]\n\n"
+
+    # Functions:
+    yield "# Shared library functions:\n"
+    # Keep track of whether any NumPy array occurs. This allows us to
+    # only conditionally include the NumPy types and keep NumPy an
+    # optional dependency.
+    has_np_array: bool = False
+    for f in lib.functions:
+        yield from f.compose_ctypes_function(CDLL_NAME)
+        if any(isinstance(p.dtype.val, NDArray) for p in f.python_input):
+            has_np_array = True
+        if any(isinstance(p.dtype.val, NDArray) for p in f.python_output):
+            has_np_array = True
+
+
+    yield "# Python interface:\n"
+    if has_np_array:
+        yield (
+            "from typing import TYPE_CHECKING\n"
+            "if TYPE_CHECKING:\n"
+            "    from numpy.typing import NDArray\n"
+            "    import numpy as np\n\n"
+        )
+
+    yield from (
+        body for f in lib.functions for body in f.compose_python_body()
+    )

funktionsklempner/language/__init__.py

@@ -0,0 +1,22 @@
+# Funktionsklempner types module.
+#
+# Author: Malte J. Ziebarth (malte.ziebarth@tum.de)
+#
+# Copyright (C) 2025 Technische Universität München
+#
+# Licensed under the EUPL, Version 1.2 or – as soon they will be approved by
+# the European Commission - subsequent versions of the EUPL (the "Licence");
+# You may not use this work except in compliance with the Licence.
+# You may obtain a copy of the Licence at:
+#
+# https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the Licence is distributed on an "AS IS" basis,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the Licence for the specific language governing permissions and
+# limitations under the Licence.
+#
+# SPDX-FileCopyrightText: 2025 Technical University of Munich
+# SPDX-License-Identifier: EUPL-1.2
+# SPDX-FileContributor: Malte J. Ziebarth <malte.ziebarth@tum.de>

funktionsklempner/language/abstract.py

@@ -0,0 +1,177 @@
+# Funktionsklempner abstract types.
+#
+# Author: Malte J. Ziebarth (malte.ziebarth@tum.de)
+#
+# Copyright (C) 2025-2026 Technische Universität München
+#
+# Licensed under the EUPL, Version 1.2 or – as soon they will be approved by
+# the European Commission - subsequent versions of the EUPL (the "Licence");
+# You may not use this work except in compliance with the Licence.
+# You may obtain a copy of the Licence at:
+#
+# https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the Licence is distributed on an "AS IS" basis,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the Licence for the specific language governing permissions and
+# limitations under the Licence.
+#
+# SPDX-FileCopyrightText: 2025-2026 Technical University of Munich
+# SPDX-License-Identifier: EUPL-1.2
+# SPDX-FileContributor: Malte J. Ziebarth <malte.ziebarth@tum.de>
+
+from typing import Any, Iterable, TypeVar, Generic
+
+T0 = TypeVar("T0", covariant=True)
+
+class Pointer(Generic[T0]):
+    val: T0
+
+    def __init__(self, val: T0):
+        self.val = val
+
+    def __repr__(self):
+        return f"POINTER({self.val.__repr__()})"
+
+    def __eq__(self, other: Any) -> bool:
+        if isinstance(other, Pointer):
+            return self.val == other.val # pyright: ignore
+        return False
+
+
+T1 = TypeVar("T1", covariant=True)
+
+class Const(Generic[T1]):
+    val: T1
+
+    def __init__(self, val: T1):
+        self.val = val
+
+    def __repr__(self):
+        return f"CONST({self.val.__repr__()})"
+
+    def __eq__(self, other: Any) -> bool:
+        if isinstance(other, Const):
+            return self.val == other.val # pyright: ignore
+        return False
+
+T2 = TypeVar("T2", covariant=True)
+
+class Struct(Generic[T2]):
+    name: str
+    members: tuple[tuple[T2, str], ...]
+
+    def __init__(self, name: str, members: Iterable[tuple[T2, str]]):
+        self.name = name
+        self.members = tuple(members)
+
+    def __repr__(self) -> str:
+        repr = f"struct {self.name} {{"
+        for i,m in enumerate(self.members):
+            if i > 0:
+                repr += ", "
+            repr += f"{m[0].__repr__()} {m[1]}"
+        return repr + "}"
+
+    def __eq__(self, other: Any):
+        return isinstance(other, Struct) and self.name == other.name
+
+
+T3 = TypeVar("T3", covariant=True)
+
+class Input(Generic[T3]):
+    """
+    Input that is automatically converted into a corresponding fundamental
+    Python type, if possible.
+    """
+    val: T3
+
+    def __init__(self, val: T3):
+        self.val = val
+
+    def __repr__(self):
+        return f"INPUT({self.val.__repr__()})"
+
+    def __eq__(self, other: Any) -> bool:
+        if type(other) == Input:
+            return self.val == other.val # pyright: ignore
+        return False
+
+
+T4 = TypeVar("T4", covariant=True)
+
+class PureInput(Input[T4]):
+    """
+    Input that is not auto-converted into a corresponding fundamental
+    Python type.
+    """
+    def __repr__(self):
+        return f"PURE_INPUT({self.val.__repr__()})"
+
+    def __eq__(self, other: Any) -> bool:
+        if type(other) == PureInput:
+            return self.val == other.val # pyright: ignore
+        return False
+
+
+
+T5 = TypeVar("T5", covariant=True)
+
+class Output(Generic[T5]):
+    """
+    Output that is automatically converted into a corresponding fundamental
+    Python type, if possible.
+    """
+    val: T5
+
+    def __init__(self, val: T5):
+        if isinstance(val, Const):
+            raise RuntimeError(
+                "Output arguments need to be non-const types."
+            )
+        self.val = val
+
+    def __repr__(self):
+        return f"OUTPUT({self.val.__repr__()})"
+
+    def __eq__(self, other: Any) -> bool:
+        if isinstance(other, Output):
+            return self.val == other.val # pyright: ignore
+        return False
+
+T6 = TypeVar("T6", covariant=True)
+
+class PureOutput(Output[T6]):
+    """
+    Output that is not auto-converted into a corresponding fundamental
+    Python type.
+    """
+    def __repr__(self):
+        return f"PURE_OUTPUT({self.val.__repr__()})"
+
+    def __eq__(self, other: Any) -> bool:
+        if isinstance(other, Output):
+            return self.val == other.val # pyright: ignore
+        return False
+
+
+
+T7 = TypeVar("T7", covariant=True)
+
+class Temporary(Generic[T7]):
+    """
+    TemporaryType.
+    """
+    val: T7
+
+    def __init__(self, val: T7):
+        self.val = val
+
+    def __repr__(self):
+        return f"Temporary({self.val.__repr__()})"
+
+    def __eq__(self, other: Any) -> bool:
+        if type(other) == Input:
+            return self.val == other.val # pyright: ignore
+        return False

funktionsklempner/language/arrays.py

@@ -0,0 +1,82 @@
+# Funktionsklempner array types.
+#
+# Author: Malte J. Ziebarth (malte.ziebarth@tum.de)
+#
+# Copyright (C) 2025-2026 Technische Universität München
+#
+# Licensed under the EUPL, Version 1.2 or – as soon they will be approved by
+# the European Commission - subsequent versions of the EUPL (the "Licence");
+# You may not use this work except in compliance with the Licence.
+# You may obtain a copy of the Licence at:
+#
+# https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the Licence is distributed on an "AS IS" basis,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the Licence for the specific language governing permissions and
+# limitations under the Licence.
+#
+# SPDX-FileCopyrightText: 2025-2026 Technical University of Munich
+# SPDX-License-Identifier: EUPL-1.2
+# SPDX-FileContributor: Malte J. Ziebarth <malte.ziebarth@tum.de>
+
+from typing import Any
+from .fundamental import FundamentalBaseType, CTypeBaseType
+from .conversion import TYPE_MAP
+from .abstract import Const
+
+
+class NDArray:
+    dtype: FundamentalBaseType | Const[FundamentalBaseType]
+    size_control: "NDArray | QuantityArray | None"
+
+    def __init__(self,
+            dtype: FundamentalBaseType | Const[FundamentalBaseType]
+        ):
+        self.dtype = dtype
+        self.size_control = None
+
+    def __repr__(self):
+        return "NDArray(" + self.dtype.__repr__() + ")"
+
+    def __eq__(self, other: Any) -> bool:
+        if isinstance(other, NDArray):
+            return self.dtype == other.dtype # pyright: ignore
+        return False
+
+    def ctypes_type(self) -> CTypeBaseType:
+        if isinstance(self.dtype, Const):
+            return TYPE_MAP[self.dtype.val]
+        return TYPE_MAP[self.dtype]
+
+
+
+class QuantityArray:
+    dtype: FundamentalBaseType | Const[FundamentalBaseType]
+    boost_unit: str
+    size_control: "NDArray | QuantityArray | None"
+
+    def __init__(self,
+            dtype: FundamentalBaseType | Const[FundamentalBaseType],
+            boost_unit: str
+        ):
+        self.dtype = dtype
+        self.boost_unit = boost_unit
+        self.size_control = None
+
+    def __repr__(self):
+        return f"QuantityArray({self.dtype.__repr__()}, {self.boost_unit})"
+
+    def __eq__(self, other: Any) -> bool:
+        if isinstance(other, QuantityArray):
+            return (
+                self.dtype == other.dtype # pyright: ignore
+                and self.boost_unit == other.boost_unit
+            )
+        return False
+
+    def ctypes_type(self) -> CTypeBaseType:
+        if isinstance(self.dtype, Const):
+            return TYPE_MAP[self.dtype.val]
+        return TYPE_MAP[self.dtype]