pyxcp 0.23.4__tar.gz → 0.23.7__tar.gz

pyxcp-0.23.7/PKG-INFO

@@ -0,0 +1,339 @@
+Metadata-Version: 2.3
+Name: pyxcp
+Version: 0.23.7
+Summary: Universal Calibration Protocol for Python
+License: LGPLv3
+Keywords: automotive,ecu,xcp,asam,autosar
+Author: Christoph Schueler
+Author-email: cpu.gems@googlemail.com
+Requires-Python: >=3.10,<4.0
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: GNU Lesser General Public License v3 or later (LGPLv3+)
+Classifier: License :: Other/Proprietary License
+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
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Software Development
+Requires-Dist: bandit (>=1.7.8,<2.0.0)
+Requires-Dist: chardet (>=5.2.0,<6.0.0)
+Requires-Dist: construct (>=2.10.68,<3.0.0)
+Requires-Dist: line-profiler-pycharm (>=1.1.0,<2.0.0)
+Requires-Dist: mako (>=1.2.4,<2.0.0)
+Requires-Dist: pyserial (>=3.5,<4.0)
+Requires-Dist: python-can (>=4.2.2,<5.0.0)
+Requires-Dist: pytz (>=2025.2,<2026.0)
+Requires-Dist: pyusb (>=1.2.1,<2.0.0)
+Requires-Dist: rich (>=14.0.0,<15.0.0)
+Requires-Dist: toml (>=0.10.2,<0.11.0)
+Requires-Dist: tomlkit (>=0.13.3,<0.14.0)
+Requires-Dist: traitlets (<=5.11.2)
+Requires-Dist: uptime (>=3.0.1,<4.0.0)
+Project-URL: Homepage, https://github.com/christoph2/pyxcp
+Description-Content-Type: text/x-rst
+
+Readme
+======
+
+.. image:: pyxcp_social.jpg
+    :align: center
+
+Reliable Python tooling for the ASAM MCD-1 XCP protocol (measurement,
+calibration, flashing) with multiple transports (CAN, Ethernet, USB,
+Serial) and handy CLI utilities.
+
+|PyPI| |Python Versions| |License: LGPL v3+| |Code style: black|
+
+``pyXCP`` is a production-ready Python library for communicating with
+XCP-enabled devices, most commonly automotive ECUs. Use it to take
+measurements, adjust parameters (calibration), stream DAQ/STIM, and
+program devices during development.
+
+Highlights:
+
+- Transports: Ethernet (TCP/IP), CAN, USB, Serial (SxI)
+- Cross-platform: Windows, Linux, macOS
+- Rich CLI tools for common XCP tasks
+- Extensible architecture and layered design
+
+--------------
+
+Installation
+------------
+
+The easiest way is from PyPI:
+
+.. code:: shell
+
+   pip install pyxcp
+
+To install from the main branch:
+
+.. code:: shell
+
+   pip install git+https://github.com/christoph2/pyxcp.git
+
+Requirements
+~~~~~~~~~~~~
+
+- Python >= 3.10
+- Building from source requires a working C/C++ toolchain (native
+  extensions are used for performance). Wheels are provided for common
+  platforms and Python versions; if a wheel is not available, pip will
+  build from source.
+- An XCP slave device (or simulator)
+
+Quick start
+-----------
+
+The tutorial walks you through typical tasks end-to-end: see `tutorial <tutorial.rst>`_.
+
+Minimal example using the built-in argument parser and context manager:
+
+.. code:: python
+
+   from pyxcp.cmdline import ArgumentParser
+
+   ap = ArgumentParser(description="pyXCP hello world")
+
+   with ap.run() as x:
+       x.connect()
+       identifier = x.identifier(0x01)
+       print(f"ID: {identifier!r}")
+       print(x.slaveProperties)
+       x.disconnect()
+
+Configuration
+~~~~~~~~~~~~~
+
+``pyXCP`` supports a
+`traitlets <https://github.com/ipython/traitlets>`__\-based configuration system.
+
+- Recommended Python config example and generator: `tutorial <tutorial.rst>`__ and `configuration <configuration.rst>`__
+- Legacy TOML examples remain available for compatibility.
+
+Command‑line tools
+~~~~~~~~~~~~~~~~~~
+
+Installed entry points (see pyproject.toml):
+
+- xcp-info — print capabilities and properties
+- xcp-id-scanner — scan for slave identifiers
+- xcp-fetch-a2l — retrieve A2L from target (if supported)
+- xcp-profile — generate/convert config files
+- xcp-examples — launch assorted demos/examples
+- xmraw-converter — convert recorder .xmraw data
+- pyxcp-probe-can-drivers — list available CAN interfaces
+
+Run any tool with -h for options.
+
+Features
+--------
+
+- Multiple transport layers: Ethernet (TCP), CAN, USB, SxI (serial/UART)
+- Data Acquisition (DAQ) and Stimulation (STIM)
+- Calibration (read/write parameters)
+- Flashing/programming workflows
+- A2L (ASAM MCD‑2 MC) support
+- Recorder utilities and converters (see `recorder <recorder.rst>`__)
+- Extensible architecture for custom transports
+
+Documentation
+-------------
+
+- Getting started tutorial: `tutorial <tutorial.rst>`__
+- Configuration: `configuration <configuration.rst>`__
+- CAN driver setup and troubleshooting: `howto_can_driver <howto_can_driver.rst>`__
+- Recorder: `recorder <recorder.rst>`__
+- Troubleshooting: `troubleshooting <troubleshooting.rst>`__
+- Troubleshooting matrix (common errors, root causes, fixes):
+  `troubleshooting_matrix <troubleshooting_matrix.rst>`__
+
+To build the Sphinx documentation locally:
+
+1. Install doc requirements:
+	``pip install -r docs/requirements.txt``
+2. Build:
+	``sphinx-build -b html docs docs/_build/html``
+3. Open
+	``docs/_build/html/index.html``
+
+Compatibility
+-------------
+
+- Operating systems: Windows, Linux, macOS
+- Python: 3.10 - 3.14, CPython wheels where available
+- CAN backends: python-can compatible drivers (see `howto_can_driver <howto_can_driver.rst>`__)
+
+Contributing
+------------
+
+Contributions are welcome! Please: - Read `CODE_OF_CONDUCT <../CODE_OF_CONDUCT.md>`__ - Open an
+issue or discussion before large changes - Use
+`pre-commit <https://github.com/pre-commit/pre-commit>`__ to run linters
+and tests locally
+
+License
+-------
+
+GNU Lesser General Public License v3 or later (LGPLv3+). See LICENSE for
+details.
+
+References
+----------
+
+- ASAM MCD‑1 XCP standard:
+  https://www.asam.net/standards/detail/mcd-1-xcp/
+
+About ASAM MCD‑1 XCP
+--------------------
+
+XCP (Universal Measurement and Calibration Protocol) is an ASAM standard
+defining a vendor‑neutral protocol to access internal data of electronic
+control units (ECUs) for measurement, calibration (parameter tuning),
+and programming. XCP decouples the protocol from the physical transport,
+so the same command set can be carried over different buses such as CAN,
+FlexRay, Ethernet, USB, or Serial.
+
+- Roles: An XCP Master (this library) communicates with an XCP Slave
+  (your device/ECU or simulator).
+- Layered concept: XCP defines an application layer and transport
+  layers. ``pyXCP`` implements the application layer and multiple transport
+  bindings.
+- Use cases:
+
+  - Measurement: Read variables from the ECU in real‑time, including
+    high‑rate DAQ streaming.
+  - Calibration: Read/write parameters (calibration data) in RAM/flash.
+  - Programming: Download new program/data to flash (where the slave
+    supports it).
+
+For the authoritative description, see the ASAM page:
+https://www.asam.net/standards/detail/mcd-1-xcp/
+
+XCP in a nutshell
+-----------------
+
+- Connect/Session: The master establishes a connection, negotiates
+  capabilities/features, and optionally unlocks protected functions via
+  seed & key.
+- Addressing: Memory is accessed via absolute or segment‑relative
+  addresses. Addressing modes are described in the associated A2L file
+  (ASAM MCD‑2 MC), which maps symbolic names to addresses, data types,
+  and conversion rules.
+- Events: The slave exposes events (e.g., “1 ms task”, “Combustion
+  cycle”), which trigger DAQ sampling. The master assigns signals (ODTs)
+  to these events for time‑aligned acquisition.
+- DAQ/STIM: DAQ = Data Acquisition (slave → master), STIM = Stimulation
+  (master → slave). Both use event‑driven lists for deterministic
+  timing.
+- Timestamps: DAQ may carry timestamps from the slave for precise time
+  correlation.
+- Security: Access to sensitive commands (e.g., programming,
+  calibration) can be protected by a seed & key algorithm negotiated at
+  runtime.
+- Checksums: XCP defines checksum services useful for verifying memory
+  regions (e.g., after flashing).
+
+Relation to A2L (ASAM MCD‑2 MC)
+-------------------------------
+
+While XCP defines the protocol, the A2L file describes the measurement
+and calibration objects (characteristics, measurements), data types,
+conversion rules, and memory layout. In practice, you use ``pyXCP`` together
+with an A2L to: - Resolve symbolic names to addresses and data types. -
+Configure DAQ lists from human‑readable signal names. - Interpret raw
+values using the appropriate conversion methods.
+
+``pyXCP`` provides utilities to fetch A2L data when supported by the slave
+and to work with A2L‑described objects. See also
+`pya2ldb <https://github.com/christoph2/pya2l>`__!
+
+Transports and addressing
+-------------------------
+
+XCP is transport‑agnostic. ``pyXCP`` supports multiple transports and
+addressing schemes: - CAN (XCP on CAN): Robust and ubiquitous in
+vehicles; limited payload and bandwidth; suited for many calibration
+tasks and moderate DAQ rates. - Ethernet (XCP on TCP/UDP): High
+bandwidth with low latency; well suited for rich DAQ and programming
+workflows. - USB: High throughput for lab setups; requires device
+support. - Serial/SxI: Simple point‑to‑point links for embedded targets
+and simulators.
+
+The exact capabilities (e.g., max CTO/DTO, checksum types, timestamping)
+are negotiated at connect time and depend on the slave and transport.
+
+Supported features (overview)
+-----------------------------
+
+The scope of features depends on the connected slave. At the library
+level, ``pyXCP`` provides: - Session management: CONNECT/DISCONNECT,
+GET_STATUS/SLAVE_PROPERTIES, communication mode setup, error handling. -
+Memory access: Upload/short upload, Download/Download Next,
+verifications, optional paged memory where supported. - DAQ/STIM:
+Configuration of DAQ lists/ODTs, event assignment, data streaming,
+timestamp handling when available. - Programming helpers: Building
+blocks for program/erase/write flows (exact sequence per slave’s flash
+algorithm and A2L description). - Security/Seed & Key: Pluggable
+seed‑to‑key resolution including 32↔64‑bit bridge on Windows. -
+Utilities: Identifier scanning, A2L helpers, recorder and converters.
+
+Refer to `tutorial <tutorial.rst>`__ and `configuration <configuration.rst>`__ for feature usage,
+and xcp-info for a capability dump of your target.
+
+Compliance and versions
+-----------------------
+
+``pyXCP`` aims to be compatible with commonly used parts of ASAM MCD‑1 XCP.
+Specific optional features are enabled when a slave advertises them
+during CONNECT. Because implementations vary across vendors and ECU
+projects, always consult your A2L and use xcp-info to confirm negotiated
+options (e.g., checksum type, timestamp unit, max DTO size, address
+granularity).
+
+If you rely on a particular XCP feature/profile not mentioned here,
+please open an issue with details about your slave and A2L so we can
+clarify support and—if feasible—add coverage.
+
+Safety, performance, and limitations
+------------------------------------
+
+- Safety‑critical systems: XCP is a development and testing protocol. Do
+  not enable measurement/calibration on safety‑critical systems in the
+  field unless your system‑level safety case covers it.
+- Performance: Achievable DAQ rates depend on transport bandwidth, ECU
+  event rates, DTO sizes, and host processing. Ethernet typically yields
+  the highest throughput.
+- Latency/jitter: Event scheduling in the slave and OS scheduling on the
+  host can affect determinism. Use timestamps to correlate data
+  precisely.
+- Access control: Seed & key protects sensitive functions; your
+  organization’s policy should govern algorithm distribution and access.
+
+Further resources
+-----------------
+
+- ASAM MCD‑1 XCP standard (overview and membership):
+  https://www.asam.net/standards/detail/mcd-1-xcp/
+- ASAM MCD‑2 MC (A2L) for object descriptions:
+  https://www.asam.net/standards/detail/mcd-2-mc/
+- Introduction to DAQ/STIM concepts (ASAM publications and vendor docs)
+- Related: CCP (legacy predecessor to XCP), ASAM MDF for measurement
+  data storage
+
+.. |CI| image:: https://github.com/christoph2/pyxcp/workflows/Python%20application/badge.svg
+   :target: https://github.com/christoph2/pyxcp/actions
+.. |PyPI| image:: https://img.shields.io/pypi/v/pyxcp.svg
+   :target: https://pypi.org/project/pyxcp/
+.. |Python Versions| image:: https://img.shields.io/pypi/pyversions/pyxcp.svg
+   :target: https://pypi.org/project/pyxcp/
+.. |License: LGPL v3+| image:: https://img.shields.io/badge/License-LGPL%20v3%2B-blue.svg
+   :target: https://www.gnu.org/licenses/lgpl-3.0
+.. |Code style: black| image:: https://img.shields.io/badge/code%20style-black-000000.svg
+   :target: https://github.com/psf/black
+

{pyxcp-0.23.4 → pyxcp-0.23.7}/build_ext.py

@@ -1,157 +1,160 @@
-#!/usr/bin/env python
-
-import multiprocessing as mp
-import os
-import platform
-import re
-import subprocess  # nosec
-import sys
-import sysconfig
-from pathlib import Path
-from tempfile import TemporaryDirectory
-
-
-TOP_DIR = Path(__file__).parent
-
-print("Platform", platform.system())
-uname = platform.uname()
-if uname.system == "Darwin":
-    os.environ["MACOSX_DEPLOYMENT_TARGET"] = "10.13"
-
-VARS = sysconfig.get_config_vars()
-
-
-def get_python_base() -> str:
-    # Applies in this form only to Windows.
-    if "base" in VARS and VARS["base"]:
-        return VARS["base"]
-    if "installed_base" in VARS and VARS["installed_base"]:
-        return VARS["installed_base"]
-
-
-def alternate_libdir(pth: str):
-    base = Path(pth).parent
-    libdir = Path(base) / "libs"
-    if libdir.exists():
-        # available_libs = os.listdir(libdir)
-        return str(libdir)
-    else:
-        return ""
-
-
-def get_py_config() -> dict:
-    pynd = VARS["py_version_nodot"]  # Should always be present.
-    include = sysconfig.get_path("include")  # Seems to be cross-platform.
-    if uname.system == "Windows":
-        base = get_python_base()
-        library = f"python{pynd}.lib"
-        libdir = Path(base) / "libs"
-        if libdir.exists():
-            available_libs = os.listdir(libdir)
-            if library in available_libs:
-                libdir = str(libdir)
-            else:
-                libdir = ""
-        else:
-            libdir = alternate_libdir(include)
-    else:
-        library = VARS["LIBRARY"]
-        DIR_VARS = ("LIBDIR", "BINLIBDEST", "DESTLIB", "LIBDEST", "MACHDESTLIB", "DESTSHARED", "LIBPL")
-        arch = None
-        if uname.system == "Linux":
-            arch = VARS.get("MULTIARCH", "")
-        found = False
-        for dir_var in DIR_VARS:
-            if found:
-                break
-            dir_name = VARS.get(dir_var)
-            if not dir_name:
-                continue
-            if uname.system == "Darwin":
-                full_path = [Path(dir_name) / library]
-            elif uname.system == "Linux":
-                full_path = [Path(dir_name) / arch / library, Path(dir_name) / library]
-            else:
-                print("PF?", uname.system)
-            for fp in full_path:
-                print(f"Trying '{fp}'")
-                if fp.exists():
-                    print(f"found Python library: '{fp}'")
-                    libdir = str(fp.parent)
-                    found = True
-                    break
-        if not found:
-            print("Could NOT locate Python library.")
-            return dict(exe=sys.executable, include=include, libdir="", library=library)
-    return dict(exe=sys.executable, include=include, libdir=libdir, library=library)
-
-
-def banner(msg: str) -> None:
-    print("=" * 80)
-    print(str.center(msg, 80))
-    print("=" * 80)
-
-
-def get_env_int(name: str, default: int = 0) -> int:
-    return int(os.environ.get(name, default))
-
-
-def get_env_bool(name: str, default: int = 0) -> bool:
-    return get_env_int(name, default)
-
-
-def build_extension(debug: bool = False, use_temp_dir: bool = False) -> None:
-    print("build_ext::build_extension()")
-
-    use_temp_dir = use_temp_dir or get_env_bool("BUILD_TEMP")
-    debug = debug or get_env_bool("BUILD_DEBUG")
-
-    cfg = "Debug" if debug else "Release"
-    print(f" BUILD-TYPE: {cfg!r}")
-
-    py_cfg = get_py_config()
-
-    cmake_args = [
-        f"-DPython3_EXECUTABLE={py_cfg['exe']}",
-        f"-DPython3_INCLUDE_DIR={py_cfg['include']}",
-        f"-DCMAKE_BUILD_TYPE={cfg}",  # not used on MSVC, but no harm
-    ]
-    if py_cfg["libdir"]:
-        cmake_args.append(f"-DPython3_LIBRARY={str(Path(py_cfg['libdir']) / Path(py_cfg['library']))}")
-
-    build_args = ["--config Release", "--verbose"]
-    # cmake -DCMAKE_EXPORT_COMPILE_COMMANDS=1 /path/to/src
-
-    if sys.platform.startswith("darwin"):
-        # Cross-compile support for macOS - respect ARCHFLAGS if set
-        archs = re.findall(r"-arch (\S+)", os.environ.get("ARCHFLAGS", ""))
-        if archs:
-            cmake_args += ["-DCMAKE_OSX_ARCHITECTURES={}".format(";".join(archs))]
-
-    if use_temp_dir:
-        build_temp = Path(TemporaryDirectory(suffix=".build-temp").name) / "extension_it_in"
-    else:
-        build_temp = Path(".")
-    # print("cwd:", os.getcwd(), "build-dir:", build_temp, "top:", str(TOP_DIR))
-    if not build_temp.exists():
-        build_temp.mkdir(parents=True)
-
-    banner("Step #1: Configure")
-    # cmake_args += ["--debug-output"]
-    subprocess.run(["cmake", "-S", str(TOP_DIR), *cmake_args], cwd=build_temp, check=True)  # nosec
-
-    cmake_args += [f"--parallel {mp.cpu_count()}"]
-
-    banner("Step #2: Build")
-    # build_args += ["-DCMAKE_VERBOSE_MAKEFILE:BOOL=ON"]
-    subprocess.run(["cmake", "--build", str(build_temp), *build_args], cwd=TOP_DIR, check=True)  # nosec
-
-    banner("Step #3: Install")
-    # subprocess.run(["cmake", "--install", "."], cwd=build_temp, check=True)  # nosec
-    subprocess.run(["cmake", "--install", build_temp], cwd=TOP_DIR, check=True)  # nosec
-
-
-if __name__ == "__main__":
-    includes = subprocess.getoutput("pybind11-config --cmakedir")  # nosec
-    os.environ["pybind11_DIR"] = includes
-    build_extension(use_temp_dir=False)
+#!/usr/bin/env python
+
+import multiprocessing as mp
+import os
+import platform
+import re
+import subprocess  # nosec
+import sys
+import sysconfig
+from pathlib import Path
+from tempfile import TemporaryDirectory
+
+
+TOP_DIR = Path(__file__).parent
+
+print("Platform", platform.system())
+uname = platform.uname()
+if uname.system == "Darwin":
+    os.environ["MACOSX_DEPLOYMENT_TARGET"] = "10.13"
+
+VARS = sysconfig.get_config_vars()
+
+
+def get_python_base() -> str:
+    # Applies in this form only to Windows.
+    if "base" in VARS and VARS["base"]:
+        return VARS["base"]
+    if "installed_base" in VARS and VARS["installed_base"]:
+        return VARS["installed_base"]
+
+
+def alternate_libdir(pth: str):
+    base = Path(pth).parent
+    libdir = Path(base) / "libs"
+    if libdir.exists():
+        # available_libs = os.listdir(libdir)
+        return str(libdir)
+    else:
+        return ""
+
+
+def get_py_config() -> dict:
+    pynd = VARS["py_version_nodot"]  # Should always be present.
+    include = sysconfig.get_path("include")  # Seems to be cross-platform.
+    if uname.system == "Windows":
+        base = get_python_base()
+        library = f"python{pynd}.lib"
+        libdir = Path(base) / "libs"
+        if libdir.exists():
+            available_libs = os.listdir(libdir)
+            if library in available_libs:
+                libdir = str(libdir)
+            else:
+                libdir = ""
+        else:
+            libdir = alternate_libdir(include)
+    else:
+        library = VARS["LIBRARY"]
+        DIR_VARS = ("LIBDIR", "BINLIBDEST", "DESTLIB", "LIBDEST", "MACHDESTLIB", "DESTSHARED", "LIBPL")
+        arch = None
+        if uname.system == "Linux":
+            arch = VARS.get("MULTIARCH", "")
+        found = False
+        for dir_var in DIR_VARS:
+            if found:
+                break
+            dir_name = VARS.get(dir_var)
+            if not dir_name:
+                continue
+            if uname.system == "Darwin":
+                full_path = [Path(dir_name) / library]
+            elif uname.system == "Linux":
+                full_path = [Path(dir_name) / arch / library, Path(dir_name) / library]
+            else:
+                print("PF?", uname.system)
+            for fp in full_path:
+                print(f"Trying '{fp}'")
+                if fp.exists():
+                    print(f"found Python library: '{fp}'")
+                    libdir = str(fp.parent)
+                    found = True
+                    break
+        if not found:
+            print("Could NOT locate Python library.")
+            return dict(exe=sys.executable, include=include, libdir="", library=library)
+    return dict(exe=sys.executable, include=include, libdir=libdir, library=library)
+
+
+def banner(msg: str) -> None:
+    print("=" * 80)
+    print(str.center(msg, 80))
+    print("=" * 80)
+
+
+def get_env_int(name: str, default: int = 0) -> int:
+    return int(os.environ.get(name, default))
+
+
+def get_env_bool(name: str, default: int = 0) -> bool:
+    return get_env_int(name, default)
+
+
+def build_extension(debug: bool = False, use_temp_dir: bool = False) -> None:
+    print("build_ext::build_extension()")
+
+    use_temp_dir = use_temp_dir or get_env_bool("BUILD_TEMP")
+    debug = debug or get_env_bool("BUILD_DEBUG")
+
+    cfg = "Debug" if debug else "Release"
+    bits, linkage = platform.architecture()
+    print(f"Bits: {bits!r} Linkage: {linkage!r} Build-Type: {cfg!r}")
+
+    if bits == "32bit" and linkage == "ELF":
+        cmake_args = []
+    else:
+        py_cfg = get_py_config()
+        cmake_args = [
+            f"-DPython3_EXECUTABLE={py_cfg['exe']}",
+            f"-DPython3_INCLUDE_DIR={py_cfg['include']}",
+            f"-DCMAKE_BUILD_TYPE={cfg}",  # not used on MSVC, but no harm
+        ]
+        if py_cfg["libdir"]:
+            cmake_args.append(f"-DPython3_LIBRARY={str(Path(py_cfg['libdir']) / Path(py_cfg['library']))}")
+
+    build_args = ["--config Release", "--verbose"]
+    # cmake -DCMAKE_EXPORT_COMPILE_COMMANDS=1 /path/to/src
+
+    if sys.platform.startswith("darwin"):
+        # Cross-compile support for macOS - respect ARCHFLAGS if set
+        archs = re.findall(r"-arch (\S+)", os.environ.get("ARCHFLAGS", ""))
+        if archs:
+            cmake_args += ["-DCMAKE_OSX_ARCHITECTURES={}".format(";".join(archs))]
+
+    if use_temp_dir:
+        build_temp = Path(TemporaryDirectory(suffix=".build-temp").name) / "extension_it_in"
+    else:
+        build_temp = Path(".")
+    # print("cwd:", os.getcwd(), "build-dir:", build_temp, "top:", str(TOP_DIR))
+    if not build_temp.exists():
+        build_temp.mkdir(parents=True)
+
+    banner("Step #1: Configure")
+    # cmake_args += ["--debug-output"]
+    subprocess.run(["cmake", "-S", str(TOP_DIR), *cmake_args], cwd=build_temp, check=True)  # nosec
+
+    cmake_args += [f"--parallel {mp.cpu_count()}"]
+
+    banner("Step #2: Build")
+    # build_args += ["-DCMAKE_VERBOSE_MAKEFILE:BOOL=ON"]
+    subprocess.run(["cmake", "--build", str(build_temp), *build_args], cwd=TOP_DIR, check=True)  # nosec
+
+    banner("Step #3: Install")
+    # subprocess.run(["cmake", "--install", "."], cwd=build_temp, check=True)  # nosec
+    subprocess.run(["cmake", "--install", build_temp], cwd=TOP_DIR, check=True)  # nosec
+
+
+if __name__ == "__main__":
+    includes = subprocess.getoutput("pybind11-config --cmakedir")  # nosec
+    os.environ["pybind11_DIR"] = includes
+    build_extension(use_temp_dir=False)