pyxcp 0.23.1__cp314-cp314-win_amd64.whl → 0.23.3__cp314-cp314-win_amd64.whl

pyxcp/__init__.py

@@ -17,4 +17,4 @@ tb_install(show_locals=True, max_frames=3)  # Install custom exception handler.
 
 # if you update this manually, do not forget to update
 # .bumpversion.cfg and pyproject.toml.
-__version__ = "0.23.1"
+__version__ = "0.23.3"

pyxcp/cmdline.py

@@ -8,7 +8,11 @@ import warnings
 from dataclasses import dataclass
 from typing import List
 
-from pyxcp.config import create_application, reset_application  # noqa: F401
+from pyxcp.config import (  # noqa: F401
+    create_application,
+    get_application,
+    reset_application,
+)
 from pyxcp.master import Master
 
 
@@ -23,28 +27,56 @@ class Option:
     help: str = ""
     type: str = ""
     default: str = ""
+    action: str = ""
 
 
 class FakeParser:
+    """Parser that collects arguments for later processing."""
 
-    options: List[Option] = []
+    def __init__(self):
+        self.options = []
 
-    def add_argument(self, short_opt: str, long_opt: str = "", dest: str = "", help: str = "", type: str = "", default: str = ""):
-        warnings.warn("Argument parser extension is currently not supported.", DeprecationWarning, 2)
-        self.options.append(Option(short_opt, long_opt, dest, help, type, default))
+    def add_argument(self, short_opt, long_opt="", dest="", help="", type=None, default=None, action=None):
+        """Collect argument definitions without issuing warnings."""
+        self.options.append(Option(short_opt, long_opt, dest, help, type, default, action))
 
 
 class ArgumentParser:
-    def __init__(self, callout=None, *args, **kws):
+    """Argument parser for pyXCP applications.
+
+    This class provides a way to add custom command-line arguments to pyXCP applications.
+    It also supports a callout function that will be called with the master instance and
+    the parsed arguments.
+    """
+
+    def __init__(self, callout=None, description=None, *args, **kws):
         self._parser = FakeParser()
-        if callout is not None:
-            warnings.warn("callout  argument is currently not supported.", DeprecationWarning, 2)
+        self._callout = callout
+        self._description = description
 
     def run(self, policy=None, transport_layer_interface=None):
-        application = create_application(self.parser.options)
+        """Create and configure a master instance.
+
+        Args:
+            policy: Optional policy to use for the master
+            transport_layer_interface: Optional transport layer interface to use
+
+        Returns:
+            A configured master instance
+        """
+        # Create the application with custom arguments and callout
+        application = get_application(self.parser.options, self._callout)
+
+        # Create the master instance
         master = Master(
             application.transport.layer, config=application, policy=policy, transport_layer_interface=transport_layer_interface
         )
+
+        # If there's a callout function, call it with the master and args
+        if application.callout is not None and hasattr(application, "custom_args"):
+            args = application.custom_args.get_args()
+            application.callout(master, args)
+
         return master
 
     @property

pyxcp/config/__init__.py

@@ -17,6 +17,7 @@ from traitlets import (
     Dict,
     Enum,
     Float,
+    HasTraits,
     Integer,
     List,
     TraitError,
@@ -24,6 +25,7 @@ from traitlets import (
     Union,
 )
 from traitlets.config import Application, Configurable, Instance, default
+from traitlets.config.loader import Config
 
 from pyxcp.config import legacy
 
@@ -491,10 +493,22 @@ If set, the `app_name` does not have to be previously defined in
 
 
 class CanCustom(Configurable, CanBase):
-    """ """
+    """Generic custom CAN interface.
+
+    Enable basic CanBase options so user-provided python-can backends can
+    consume common parameters like bitrate, fd, data_bitrate, poll_interval,
+    receive_own_messages, and optional timing.
+    """
 
     interface_name = "custom"
 
+    # Allow usage of the basic options from CanBase for custom backends
+    has_fd = True
+    has_data_bitrate = True
+    has_poll_interval = True
+    has_receive_own_messages = True
+    has_timing = True
+
 
 class Virtual(Configurable, CanBase):
     """ """
@@ -829,6 +843,68 @@ if there is no response to a command.""",
         self.usb = Usb(config=self.config, parent=self)
 
 
+class CustomArgs(Configurable):
+    """Class to handle custom command-line arguments."""
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self._custom_args = {}
+
+    def add_argument(self, short_opt, long_opt="", dest="", help="", type=None, default=None, action=None):
+        """Add a custom argument dynamically.
+
+        This mimics the argparse.ArgumentParser.add_argument method.
+        """
+        if not dest and long_opt:
+            dest = long_opt.lstrip("-").replace("-", "_")
+
+        # Store the argument definition
+        self._custom_args[dest] = {
+            "short_opt": short_opt,
+            "long_opt": long_opt,
+            "help": help,
+            "type": type,
+            "default": default,
+            "action": action,
+            "value": default,
+        }
+
+        # Dynamically add a trait for this argument
+        trait_type = Any()
+        if type == bool or action == "store_true" or action == "store_false":
+            trait_type = Bool(default)
+        elif type == int:
+            trait_type = Integer(default)
+        elif type == float:
+            trait_type = Float(default)
+        elif type == str:
+            trait_type = Unicode(default)
+
+        # Add the trait to this instance
+        self.add_trait(dest, trait_type)
+        setattr(self, dest, default)
+
+    def update_from_options(self, options):
+        """Update trait values from parsed options."""
+        for option in options:
+            if option.dest and option.dest in self._custom_args:
+                if option.default is not None:
+                    setattr(self, option.dest, option.default)
+                    self._custom_args[option.dest]["value"] = option.default
+
+    def get_args(self):
+        """Return an object with all custom arguments as attributes."""
+
+        class Args:
+            pass
+
+        args = Args()
+        for name, arg_def in self._custom_args.items():
+            setattr(args, name, arg_def["value"])
+
+        return args
+
+
 class General(Configurable):
     """ """
 
@@ -929,7 +1005,12 @@ class PyXCP(Application):
     description = "pyXCP application"
     config_file = Unicode(default_value="pyxcp_conf.py", help="base name of config file").tag(config=True)
 
-    classes = List([General, Transport])
+    # Add callout function support
+    callout = Callable(default_value=None, allow_none=True, help="Callback function to be called with master and args").tag(
+        config=True
+    )
+
+    classes = List([General, Transport, CustomArgs])
 
     subcommands = dict(
         profile=(
@@ -985,6 +1066,7 @@ class PyXCP(Application):
         self.read_configuration_file(file_name, emit_warning)
         self.general = General(config=self.config, parent=self)
         self.transport = Transport(parent=self)
+        self.custom_args = CustomArgs(config=self.config, parent=self)
 
     def read_configuration_file(self, file_name: str, emit_warning: bool = True):
         self.legacy_config: bool = False
@@ -1086,7 +1168,7 @@ class PyXCP(Application):
 application: typing.Optional[PyXCP] = None
 
 
-def create_application(options: typing.Optional[typing.List[typing.Any]] = None) -> PyXCP:
+def create_application(options: typing.Optional[typing.List[typing.Any]] = None, callout=None) -> PyXCP:
     global application
     if options is None:
         options = []
@@ -1095,15 +1177,24 @@ def create_application(options: typing.Optional[typing.List[typing.Any]] = None)
     application = PyXCP()
     application.initialize(sys.argv)
     application.start()
+
+    # Set callout function if provided
+    if callout is not None:
+        application.callout = callout
+
+    # Process custom arguments if provided
+    if options and hasattr(application, "custom_args"):
+        application.custom_args.update_from_options(options)
+
     return application
 
 
-def get_application(options: typing.Optional[typing.List[typing.Any]] = None) -> PyXCP:
+def get_application(options: typing.Optional[typing.List[typing.Any]] = None, callout=None) -> PyXCP:
     if options is None:
         options = []
     global application
     if application is None:
-        application = create_application(options)
+        application = create_application(options, callout)
     return application
 
 

pyxcp/examples/xcphello.py

@@ -16,14 +16,14 @@ def callout(master, args):
 
 
 ap = ArgumentParser(description="pyXCP hello world.", callout=callout)
-# ap.parser.add_argument(
-#    "-d",
-#    "--daq-info",
-#    dest="daq_info",
-#    help="Display DAQ-info",
-#    default=False,
-#    action="store_true",
-# )
+ap.parser.add_argument(
+    "-d",
+    "--daq-info",
+    dest="daq_info",
+    help="Display DAQ-info",
+    default=False,
+    action="store_true",
+)
 
 with ap.run() as x:
     x.connect()

pyxcp-0.23.3.dist-info/METADATA

@@ -0,0 +1,219 @@
+Metadata-Version: 2.3
+Name: pyxcp
+Version: 0.23.3
+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/markdown
+
+# pyXCP
+
+Reliable Python tooling for the ASAM MCD‑1 XCP protocol (measurement, calibration, flashing) with multiple transports (CAN, Ethernet, USB, Serial) and handy CLI utilities.
+
+[![CI](https://github.com/christoph2/pyxcp/workflows/Python%20application/badge.svg)](https://github.com/christoph2/pyxcp/actions)
+[![PyPI](https://img.shields.io/pypi/v/pyxcp.svg)](https://pypi.org/project/pyxcp/)
+[![Python Versions](https://img.shields.io/pypi/pyversions/pyxcp.svg)](https://pypi.org/project/pyxcp/)
+[![License: LGPL v3+](https://img.shields.io/badge/License-LGPL%20v3%2B-blue.svg)](https://www.gnu.org/licenses/lgpl-3.0)
+[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/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:
+
+```shell
+pip install pyxcp
+```
+
+To install from the main branch:
+
+```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 docs/tutorial.md.
+
+Minimal example using the built‑in argument parser and context manager:
+
+```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: docs/tutorial.md and docs/configuration.md
+- 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 docs/recorder.md)
+- Extensible architecture for custom transports
+
+## Documentation
+- Getting started tutorial: docs/tutorial.md
+- Configuration: docs/configuration.md
+- CAN driver setup and troubleshooting: docs/howto_can_driver.md
+- Recorder: docs/recorder.md
+
+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 docs/howto_can_driver.md)
+
+## Contributing
+Contributions are welcome! Please:
+- Read 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 docs/tutorial.md and docs/configuration.md 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
+

{pyxcp-0.23.1.dist-info → pyxcp-0.23.3.dist-info}/RECORD

@@ -1,4 +1,4 @@
-pyxcp/__init__.py,sha256=HQBiOPfZK2f7NGrXX2R-3kzx2bnjcg1nj3e6BhJPCrw,547
+pyxcp/__init__.py,sha256=fVDaHDWZ31NkogpcyWKgMLiQBK356XczUnYPRUcrLAo,547
 pyxcp/aml/EtasCANMonitoring.a2l,sha256=EJYwe3Z3H24vyWAa6lUgcdKnQY8pwFxjyCN6ZU1ST8w,1509
 pyxcp/aml/EtasCANMonitoring.aml,sha256=xl0DdyeiIaLW0mmmJNAyJS0CQdOLSxt9dxfgrdSlU8Y,2405
 pyxcp/aml/ifdata_CAN.a2l,sha256=NCUnCUEEgRbZYSLGtUGwL2e7zJ8hrp0SbmLHGv8uY58,612
@@ -17,18 +17,18 @@ pyxcp/asam/types.py,sha256=_gKcpBF5mon_SDWZBUW0PGBMcb37yrvhhEuk1wslg-s,2441
 pyxcp/asamkeydll.c,sha256=dVEvU0S1kgIo62S0La-T8xHSw668LM_DYc_fiQ0No6g,2952
 pyxcp/asamkeydll.sh,sha256=DC2NKUMwvi39OQgJ6514Chr4wc1LYbTmQHmMq9jAHHs,59
 pyxcp/checksum.py,sha256=hO2JW_eiO9I0A4eiqovMV9d_y5oidq_w8jKdAE4FeOo,11899
-pyxcp/cmdline.py,sha256=na3ZbWQ-5ezsi1MrkuxMTCAXonUF3X6-LutoneyE3dU,1529
-pyxcp/config/__init__.py,sha256=hM1eQtllcZeZ4zo9YzscO2Z5EOpV3hWyZgY9GZMiavw,42085
+pyxcp/cmdline.py,sha256=4kNHOjbA0HeVfRicnFDeX1J9EBkTlA7KWL5SDfwbbaM,2525
+pyxcp/config/__init__.py,sha256=z9bXNb2Hp-h2ZtASCyGk3JWP3OGoOL5Hmvazl-L_ANE,45258
 pyxcp/config/legacy.py,sha256=4QdDheX8DbBKv5JVT72_C_cjCgKvZmhN3tJ6hsvBEtI,5220
 pyxcp/constants.py,sha256=9yGfujC0ImTYQWfn41wyw8pluJTSrhMGWIVeIZTgsLg,1160
 pyxcp/cpp_ext/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pyxcp/cpp_ext/bin.hpp,sha256=PwJloZek21la-RBSda2Hc0u_6gID0sfTduPeplaAyR4,2561
 pyxcp/cpp_ext/blockmem.hpp,sha256=ysaJwmTWGTfE54Outk3gJYOfAVFd_QaonBMtXLcXwCc,1242
-pyxcp/cpp_ext/cpp_ext.cp310-win_amd64.pyd,sha256=06wlmKXUq518IN8Pqp6z37nfjhBeZmiyEu1EmPZXQeg,285184
-pyxcp/cpp_ext/cpp_ext.cp311-win_amd64.pyd,sha256=0OnABdaqJW_BSavyeIdDfVTv3jFIETJkooMERA5jFPo,286720
-pyxcp/cpp_ext/cpp_ext.cp312-win_amd64.pyd,sha256=PTdXxjZYSuYuCu00VhwQm2axTKC2qNF14Tt_D9LVLfg,291840
-pyxcp/cpp_ext/cpp_ext.cp313-win_amd64.pyd,sha256=w2H0qj9JYsWkP10d1CU2-cz6PbNzH7z6JvYBHaKlhUM,291328
-pyxcp/cpp_ext/cpp_ext.cp314-win_amd64.pyd,sha256=sqCdPwuKUepwOMeZiQR8Jd06UWm7S31naFbX4iwLOZY,292864
+pyxcp/cpp_ext/cpp_ext.cp310-win_amd64.pyd,sha256=DnSJWDFdj1sm90iV3sEQx8nbkUIKDVRXw8ds113cKKw,288768
+pyxcp/cpp_ext/cpp_ext.cp311-win_amd64.pyd,sha256=nZzaLOhg6Q3vj2xlETL-oQ1ujBeLMlxcapRUK4EKB-8,290816
+pyxcp/cpp_ext/cpp_ext.cp312-win_amd64.pyd,sha256=nXFMOQ0eISY57I-D6hQHeUfxgDMsaf2-Cpy0xBw4eII,295424
+pyxcp/cpp_ext/cpp_ext.cp313-win_amd64.pyd,sha256=ydJGO_zJtB3bDdc9uqAHW2OJp5k62bsS8piscFywAbI,295424
+pyxcp/cpp_ext/cpp_ext.cp314-win_amd64.pyd,sha256=IUj44MCjuVhv3pAPoenwhFnSWks_9eYJHaQjPKKvW9c,297984
 pyxcp/cpp_ext/daqlist.hpp,sha256=g2hlxgoQorAGKHedZFZ0c2FQh1APMIA9sVB6M6hD_n8,7277
 pyxcp/cpp_ext/event.hpp,sha256=Z-1yxsEKsr81NnLVEWJ2ANA8FV7YsM7EbNxaw-elheE,1200
 pyxcp/cpp_ext/extension_wrapper.cpp,sha256=xFs3IcrvHPHA82-n11WPzt8HATGqcks02p84SjQ2BKM,4855
@@ -40,11 +40,11 @@ pyxcp/daq_stim/optimize/__init__.py,sha256=FUWK0GkNpNT-sUlhibp7xa2aSYpm6Flh5yA2w
 pyxcp/daq_stim/optimize/binpacking.py,sha256=Iltho5diKlJG-ltbmx053U2vOFRlCISolXK61T14l_I,1257
 pyxcp/daq_stim/scheduler.cpp,sha256=NuNkAz3Dv849f51_T36YPck2dl-YsdDdG-cozc7XN9U,1504
 pyxcp/daq_stim/scheduler.hpp,sha256=U_6tUbebmzX5vVZS0EFSgTaPsyxMg6yRXHG_aPWA0x4,1884
-pyxcp/daq_stim/stim.cp310-win_amd64.pyd,sha256=F0tp7tDp0H06jcSnnWizOKIEakeNwl0IPhFsT9dBYvY,204288
-pyxcp/daq_stim/stim.cp311-win_amd64.pyd,sha256=vKADm1t9UviD7Yg6OTK0ht0zyAxxH_xvHJcfzyhaFTA,205824
-pyxcp/daq_stim/stim.cp312-win_amd64.pyd,sha256=W0iiXJ_s5nju8trqorOuLIwMoF2bQm06kC1G2h6XZds,209920
-pyxcp/daq_stim/stim.cp313-win_amd64.pyd,sha256=9AkQtgVGyB2Q7iW-YWo-8Vf7V97LWw9iBit8JKNnT7E,209920
-pyxcp/daq_stim/stim.cp314-win_amd64.pyd,sha256=eV8bYSYXp9KqqVwWdu_l2bGIdEb_VVM8ft_5k0-iZGg,210944
+pyxcp/daq_stim/stim.cp310-win_amd64.pyd,sha256=jzG2SA5yhxvEOe_Rztm5s3_1giPtEl8WAMxdDu-65pk,208896
+pyxcp/daq_stim/stim.cp311-win_amd64.pyd,sha256=BlIYDELUmxBFneVVrOP9d0DCaGaVidX1mnnp2M-Zu7M,210432
+pyxcp/daq_stim/stim.cp312-win_amd64.pyd,sha256=oYTn7_qL1-RCquj6PwEnHI-jeH_38PiScnp6HZniSgE,214528
+pyxcp/daq_stim/stim.cp313-win_amd64.pyd,sha256=8nzCcn8oqzdoyOxKHqRQxWsv8BQl7hAlxW579FrqEu4,214528
+pyxcp/daq_stim/stim.cp314-win_amd64.pyd,sha256=WT53aHDOj_q825FkAAVF-DTN_FpsChScZSy_9mviClI,215552
 pyxcp/daq_stim/stim.cpp,sha256=F2OG67W4KKwTTiUCxm-9egIv3TLFdOkRunX6xf7YOtc,177
 pyxcp/daq_stim/stim.hpp,sha256=U-uInRrA6OCdMl1l1SWbQ_KEPpnNYrWut924IvbW6R0,18508
 pyxcp/daq_stim/stim_wrapper.cpp,sha256=iT2yxJ3LRG7HoYC1bwhM3tCAxF9X_HHierBNsLRmTJg,1995
@@ -65,7 +65,7 @@ pyxcp/examples/xcp_read_benchmark.py,sha256=zOG0Yrji10vA0vhHa27KK7zgc3JDpzXzXsFn
 pyxcp/examples/xcp_skel.py,sha256=YXLQC8nn8aAwYSVuBGhr1dvmdMBjmO1Ee1w3e5sy16s,1159
 pyxcp/examples/xcp_unlock.py,sha256=5F7oW17MboxKO3REYrGyhYX4Oc0Dg1oD3EQ3fQXB2Is,690
 pyxcp/examples/xcp_user_supplied_driver.py,sha256=9fFiud6sbjkBjxmcdGwIO6yBc83sUykY388gvI5EcXU,1148
-pyxcp/examples/xcphello.py,sha256=ZNfnk0nyz6qiY2i5L0lFFng42RwZdREwevIJW7C5QCA,2638
+pyxcp/examples/xcphello.py,sha256=TAFCRf9Cg5uc-WGaxdHHUS_hKYkWqt77-3j9gGG6GW8,2628
 pyxcp/examples/xcphello_recorder.py,sha256=QHWJsq5h5CI9t5qEmMSorZyzirTpoXz4nzuKTMzbZCA,3409
 pyxcp/master/__init__.py,sha256=QQbkUJM1WQ-5p2MiNFYxLAmHhNsCQLzDp-S4aoOFxoA,318
 pyxcp/master/errorhandler.py,sha256=ulL6WiraZbVZnM2pfR8S9vlWAAP5UXwXqmbjjxH9rgc,15359
@@ -86,11 +86,11 @@ pyxcp/recorder/mio.hpp,sha256=5ASJLKSEykH0deAQD5uak-_yAgd5p2n8t06315GSGrg,63346
 pyxcp/recorder/reader.hpp,sha256=rr9XZ_ciL6eF2_xEqyt9XYNqTIze9ytAsnf8uYukO9U,5201
 pyxcp/recorder/reco.py,sha256=6N6FIwfCEVMpi5dr3eUOQa1lowcg2LCnS_sy_-b-UiQ,8725
 pyxcp/recorder/recorder.rst,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pyxcp/recorder/rekorder.cp310-win_amd64.pyd,sha256=yqeVlyQA8MQ2zPxt9-JXyyEvc94gJ1QkBA7N6KImFeo,385536
-pyxcp/recorder/rekorder.cp311-win_amd64.pyd,sha256=8Ix-n8z4PWJkEeZ4kDYtz1DCSrWSFVPs4FbYF4DTWo0,387584
-pyxcp/recorder/rekorder.cp312-win_amd64.pyd,sha256=Rb_F4sqPANQx8SR_uP-aVmoL6TD6t4CZYA0pYfahR7Q,392192
-pyxcp/recorder/rekorder.cp313-win_amd64.pyd,sha256=l_XH-sb9qFqHD0tVfLbwWfC2w6rZJOqoVS4lRuSGj2I,392192
-pyxcp/recorder/rekorder.cp314-win_amd64.pyd,sha256=HRhzPvyVDBdF-IQe0xbF_UvTGQOO_p2pdw-owqDHWVQ,394240
+pyxcp/recorder/rekorder.cp310-win_amd64.pyd,sha256=53jF5N8lV5iLn8XHgYtrZZoK9i94kSwaB5uZwr93h3A,389632
+pyxcp/recorder/rekorder.cp311-win_amd64.pyd,sha256=MIeTpsRbjzLTbIBGHBinirn9jvrz_r4ao7JPVMqY6Yw,391168
+pyxcp/recorder/rekorder.cp312-win_amd64.pyd,sha256=pWoFwxF3pU80eHFI9k-vxDRJa5CI0p4mHidvEBYHznQ,396800
+pyxcp/recorder/rekorder.cp313-win_amd64.pyd,sha256=M-Rwojpjafj5Gcj5E50EAHfzqx2EmZcKXtvOJ43o-UM,396800
+pyxcp/recorder/rekorder.cp314-win_amd64.pyd,sha256=5TrY17qawo3iSuBP-oZR_JDS0dm84m6f1RAi0VKFmDc,398848
 pyxcp/recorder/rekorder.cpp,sha256=U0LMyk8pZXx9emgS_WPVthvn_9IpgE7JGrh4kg-8CX4,1900
 pyxcp/recorder/rekorder.hpp,sha256=sWvRch9bVt6mmgrFHp5mwWhap7HoFG4geeb7UqEIzio,7638
 pyxcp/recorder/setup.py,sha256=_99XFPQAd5V4LcJaSGJwdnbxgxJ7kl8DEXfHsnKO1Yg,998
@@ -130,8 +130,8 @@ pyxcp/types.py,sha256=mjp3FhsTTbS3D5VuC-dfdbMql0lJwEfbZjf8a2pHi1o,26158
 pyxcp/utils.py,sha256=_ag2QMt0IxVhiCLG5BIO8JzIGt-rdqYrY7DRAPQ4AtA,3530
 pyxcp/vector/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pyxcp/vector/map.py,sha256=7Gnhvr79geMeqqGVIJPxODXGwABdNDinnqzhpooN5TE,2306
-pyxcp-0.23.1.dist-info/entry_points.txt,sha256=LkHsEwubm30s4oiyCy0cKj6k97ALvQ6KjAVdyEcqu7g,358
-pyxcp-0.23.1.dist-info/LICENSE,sha256=fTqV5eBpeAZO0_jit8j4Ref9ikBSlHJ8xwj5TLg7gFk,7817
-pyxcp-0.23.1.dist-info/METADATA,sha256=SSK24XxtgfqPWfnBC70rkXdY_vWCxI3aI6FfQHGU34k,4084
-pyxcp-0.23.1.dist-info/WHEEL,sha256=kwfqy3xKRHEZfXFvb9ph-wqPOS4inj_OLrOJzUuVYBY,98
-pyxcp-0.23.1.dist-info/RECORD,,
+pyxcp-0.23.3.dist-info/entry_points.txt,sha256=LkHsEwubm30s4oiyCy0cKj6k97ALvQ6KjAVdyEcqu7g,358
+pyxcp-0.23.3.dist-info/LICENSE,sha256=fTqV5eBpeAZO0_jit8j4Ref9ikBSlHJ8xwj5TLg7gFk,7817
+pyxcp-0.23.3.dist-info/METADATA,sha256=wQmqlFOaiVIYsJGLg5m2M0aHyit3Ofwl7T1FEjWiWNg,11688
+pyxcp-0.23.3.dist-info/WHEEL,sha256=kwfqy3xKRHEZfXFvb9ph-wqPOS4inj_OLrOJzUuVYBY,98
+pyxcp-0.23.3.dist-info/RECORD,,

pyxcp-0.23.1.dist-info/METADATA

@@ -1,107 +0,0 @@
-Metadata-Version: 2.3
-Name: pyxcp
-Version: 0.23.1
-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.8
-Classifier: Programming Language :: Python :: 3.9
-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/markdown
-
-# pyXCP
-
-[![Codacy Badge](https://api.codacy.com/project/badge/Grade/85f774708b2542d98d02df55c743d24a)](https://app.codacy.com/app/christoph2/pyxcp?utm_source=github.com&utm_medium=referral&utm_content=christoph2/pyxcp&utm_campaign=Badge_Grade_Settings)
-[![Maintainability](https://api.codeclimate.com/v1/badges/4c639f3695f2725e392a/maintainability)](https://codeclimate.com/github/christoph2/pyxcp/maintainability)
-[![Build Status](https://github.com/christoph2/pyxcp/workflows/Python%20application/badge.svg)](https://github.com/christoph2/pyxcp/actions)
-[![Build status](https://ci.appveyor.com/api/projects/status/r00l4i4co095e9ht?svg=true)](https://ci.appveyor.com/project/christoph2/pyxcp)
-[![Coverage Status](https://coveralls.io/repos/github/christoph2/pyxcp/badge.svg?branch=master)](https://coveralls.io/github/christoph2/pyxcp?branch=master)
-[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
-[![GPL License](http://img.shields.io/badge/license-GPL-blue.svg)](http://opensource.org/licenses/GPL-2.0)
-
-pyXCP is a lightweight Python library which talks to ASAM MCD-1 XCP enabled devices.
-These are mainly, but not only, automotive ECUs (Electronic Control Units).
-
-XCP is used to take measurements, to adjust parameters, and to flash during the development process.
-
-XCP also replaces the older CCP (CAN Calibration Protocol).
-
----
-
-## Installation
-
-pyXCP is hosted on Github, get the latest release: [https://github.com/christoph2/pyxcp](https://github.com/christoph2/pyxcp)
-
-You can install pyxcp from source:
-
-```
-pip install -r requirements.txt
-python setup.py install
-```
-
-Alternatively, you can install pyxcp from source with pip:
-
-```
-pip install git+https://github.com/christoph2/pyxcp.git
-```
-
-Alternatively, get pyxcp from [PyPI](https://pypi.org/project/pyxcp/):
-
-```
-pip install pyxcp
-```
-
-### Requirements
-
-- Python >= 3.7
-- A running XCP slave (of course).
-- If you are using a 64bit Windows version and want to use seed-and-key .dlls (to unlock resources), a GCC compiler capable of creating 32bit
-  executables is required:
-
-  These .dlls almost always ship as 32bit versions, but you can't load a 32bit .dll into a 64bit process, so a small bridging program (asamkeydll.exe) is
-  required.
-
-## First steps
-
-T.B.D.
-
-## Features
-
-T.B.D.
-
-## References
-
-- [Offical home of XCP](https://www.asam.net/standards/detail/mcd-1-xcp/)
-
-## License
-
-GNU Lesser General Public License v3 or later (LGPLv3+)
-