pyxcp 0.23.3__cp312-cp312-win_arm64.whl → 0.25.6__cp312-cp312-win_arm64.whl

pyxcp/utils/cli.py

@@ -0,0 +1,78 @@
+#!/usr/bin/env python
+"""
+Reusable command-line parser utilities.
+"""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from collections.abc import Sequence
+
+
+class StrippingParser:
+    """Base class for parsers that can strip recognized arguments from sys.argv.
+
+    This is useful when multiple argument parsers are used in a single process (chained),
+    and downstream parsers should not see arguments already handled by an
+    upstream parser.
+    """
+
+    def __init__(self, parser: argparse.ArgumentParser) -> None:
+        """Initialize with an existing ArgumentParser instance."""
+        self._parser = parser
+
+    @property
+    def parser(self) -> argparse.ArgumentParser:
+        """Return the underlying ArgumentParser instance."""
+        return self._parser
+
+    def parse_known(self, argv: Sequence[str] | None = None) -> tuple[argparse.Namespace, list[str]]:
+        """Parse known args from ``argv`` and return (namespace, remaining).
+
+        Does not mutate ``sys.argv``.
+        """
+        if argv is None:
+            argv = sys.argv[1:]
+        namespace, remaining = self._parser.parse_known_args(argv)
+
+        # Emulate standard -h/--help behavior if "help" is in the namespace
+        if getattr(namespace, "help", False):
+            # Print help and exit similarly to ArgumentParser
+            # We need a temporary full parser to render standard help including program name
+            full = argparse.ArgumentParser(description=self._parser.description)
+            for action in self._parser._actions:
+                if action.option_strings and action.dest == "help":
+                    continue
+                full._add_action(action)
+            full.print_help()
+            sys.exit(0)
+
+        return namespace, list(remaining)
+
+    def strip_from_argv(self, argv: list[str] | None = None) -> None:
+        """Remove this parser's recognized options from ``sys.argv`` in-place.
+
+        If ``argv`` is provided, it is treated as a mutable list whose content
+        will be replaced with the stripped version (first element preserved as
+        program name). If omitted, ``sys.argv`` is modified.
+        """
+        arg_list = argv if argv is not None else sys.argv
+        if not arg_list:
+            return
+        _, remaining = self.parse_known(arg_list[1:])
+        # Rebuild argv with program name + remaining
+        prog = arg_list[0]
+        arg_list[:] = [prog] + remaining
+
+    def parse_and_strip(self, argv: list[str] | None = None) -> argparse.Namespace:
+        """Parse options and strip them from argv; returns the parsed namespace."""
+        arg_list = argv if argv is not None else sys.argv
+        if not arg_list:
+            # Fallback for empty list
+            return self.parse_known([])[0]
+        namespace, remaining = self.parse_known(arg_list[1:])
+        # mutate
+        prog = arg_list[0]
+        arg_list[:] = [prog] + remaining
+        return namespace

pyxcp-0.25.6.dist-info/METADATA

@@ -0,0 +1,341 @@
+Metadata-Version: 2.4
+Name: pyxcp
+Version: 0.25.6
+Summary: Universal Calibration Protocol for Python
+License: LGPLv3
+License-File: LICENSE
+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: pydantic (>=2.5,<3)
+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.svg
+    :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.25.6.dist-info/RECORD

@@ -0,0 +1,153 @@
+pyxcp/__init__.py,sha256=6HPxFiiIwIZMKF542IgvDiJ32LZS2ZoS4q_gYkafSwg,547
+pyxcp/aml/EtasCANMonitoring.a2l,sha256=EJYwe3Z3H24vyWAa6lUgcdKnQY8pwFxjyCN6ZU1ST8w,1509
+pyxcp/aml/EtasCANMonitoring.aml,sha256=xl0DdyeiIaLW0mmmJNAyJS0CQdOLSxt9dxfgrdSlU8Y,2405
+pyxcp/aml/ifdata_CAN.a2l,sha256=NCUnCUEEgRbZYSLGtUGwL2e7zJ8hrp0SbmLHGv8uY58,612
+pyxcp/aml/ifdata_Eth.a2l,sha256=w4Vek0Xc5Rt7zroZztY0FEJTyVnk-E21wq_itxX2hI4,250
+pyxcp/aml/ifdata_Flx.a2l,sha256=oXIIwl3DA9JCyVRGKaLEedauC0q4JoRWQly-qTiYAaw,1891
+pyxcp/aml/ifdata_SxI.a2l,sha256=PPTZvyKKtp12qDiv9oHlW32ocPD7elJaOHklfg56r5E,316
+pyxcp/aml/ifdata_USB.a2l,sha256=bN59aYL19CFr5EMwkoUZYLnH5uSubqGGNsg8dPYNDd0,3656
+pyxcp/aml/XCP_Common.aml,sha256=CW9lgPw2V6qxtgZaT9wUGTP9FtaH6tse0_rzQ_Tcc7E,15445
+pyxcp/aml/XCPonCAN.aml,sha256=WpWvKPZLDHEMaTUljCu6WidVkiLL8kmZ4VIZBoXQyl4,3849
+pyxcp/aml/XCPonEth.aml,sha256=koFPs6hvInPrSSk6OHI1pF3Mq2bslT7TWBoTAjjYPWw,2247
+pyxcp/aml/XCPonFlx.aml,sha256=Q3byhPQ1DvPFoCkX6ta4A9KPAXAiIDBbuKz3bVHbP8s,4760
+pyxcp/aml/XCPonSxI.aml,sha256=sIHrBrvLHJkIcW77P7nVp17hTeKbEMRj3ssUsI7-Umw,3301
+pyxcp/aml/XCPonUSB.aml,sha256=Xcu52ZckyuEX0v5rwYQxz8gJCAs4qyepXmd_bkCJVlA,4953
+pyxcp/asam/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyxcp/asam/types.py,sha256=_gKcpBF5mon_SDWZBUW0PGBMcb37yrvhhEuk1wslg-s,2441
+pyxcp/asamkeydll.c,sha256=dVEvU0S1kgIo62S0La-T8xHSw668LM_DYc_fiQ0No6g,2952
+pyxcp/asamkeydll.exe,sha256=nOrsvVJrVILKslJVPSR1luxhBoMcM58V2xDevWfwHDw,11264
+pyxcp/asamkeydll.sh,sha256=DC2NKUMwvi39OQgJ6514Chr4wc1LYbTmQHmMq9jAHHs,59
+pyxcp/checksum.py,sha256=hO2JW_eiO9I0A4eiqovMV9d_y5oidq_w8jKdAE4FeOo,11899
+pyxcp/cmdline.py,sha256=PltxEwPp6KnXkStI3u3_K9fLNAfCDQauIxMktMzMhxA,2357
+pyxcp/config/__init__.py,sha256=kZ-6hotQYuVa4C6cEGUSqga6CTezKCC2HRa89yVQtXM,48272
+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/aligned_buffer.hpp,sha256=KoUYDjvIJRc2IDOSQXbbSfQ6pdhnBcCi_bxZFC9C6Ko,5448
+pyxcp/cpp_ext/bin.hpp,sha256=WF7ljBEbATQ3wplk7pna4qWtM0MJVHRs5pnILxfkbGU,2673
+pyxcp/cpp_ext/blockmem.hpp,sha256=ysaJwmTWGTfE54Outk3gJYOfAVFd_QaonBMtXLcXwCc,1242
+pyxcp/cpp_ext/cpp_ext.cp310-win_arm64.pyd,sha256=DenFVbetxIENRikCdHjkPwEaI_g-h-MrDNJPkfI01xA,393728
+pyxcp/cpp_ext/cpp_ext.cp311-win_arm64.pyd,sha256=0CzHXuHtxHxYIaO2YbLp8IDa8cLa5URR5Y81J6xuB9c,394240
+pyxcp/cpp_ext/cpp_ext.cp312-win_arm64.pyd,sha256=RNn9rXcjYlYtqWn_UilHF4_qlHVHXwFrYGhUZKew_WU,373248
+pyxcp/cpp_ext/daqlist.hpp,sha256=Dv5v9JvaP3Xhe4uTrYfdBsySElIRO50H9Bu4Xl92yfQ,13996
+pyxcp/cpp_ext/event.hpp,sha256=Z-1yxsEKsr81NnLVEWJ2ANA8FV7YsM7EbNxaw-elheE,1200
+pyxcp/cpp_ext/extension_wrapper.cpp,sha256=TRrhjinnKkaH9wcY9Tx16kMoVEwSwAFoRVZ2Uot1hao,9852
+pyxcp/cpp_ext/framing.hpp,sha256=8k2juQO0FJvMIiEXjZRMh4CtJdjRBBgH2N3CY57hbyY,11660
+pyxcp/cpp_ext/helper.hpp,sha256=ONAsVupIqqmNDp8bgGWS0TfSYeCFkk3kwwZbbqsh0HQ,7813
+pyxcp/cpp_ext/mcobject.hpp,sha256=t_sjka8_TaWF0EG7mIx8feWAF6uf_CyMtuvCmhE4DB4,6522
+pyxcp/cpp_ext/sxi_framing.hpp,sha256=FvaDOFD5zK8AJUn6yBVoTr-pclstmr478_q_W6COANo,11837
+pyxcp/cpp_ext/tsqueue.hpp,sha256=FWMemzXNgV5dQ7gYmTCzC0QYfgl0VI9JCybYelBcCHU,1026
+pyxcp/daq_stim/__init__.py,sha256=mWHeLkq9fuoylNypGz_CCKShYN_3c3Su6IEB76Z4U2M,16509
+pyxcp/daq_stim/optimize/__init__.py,sha256=FUWK0GkNpNT-sUlhibp7xa2aSYpm6Flh5yA2w2IOJqg,2520
+pyxcp/daq_stim/optimize/binpacking.py,sha256=RcRTMNmcb5oIAY2G5RHygb_g0GgNf35-cp3utIeUA9w,1257
+pyxcp/daq_stim/scheduler.cpp,sha256=uUR4RUpukE5qZpJNbT_1ARFslAbWupGv0TQJHO_OM0s,1466
+pyxcp/daq_stim/scheduler.hpp,sha256=U_6tUbebmzX5vVZS0EFSgTaPsyxMg6yRXHG_aPWA0x4,1884
+pyxcp/daq_stim/stim.cp310-win_arm64.pyd,sha256=jKEznebDYNCjeQZ8MwjOkp_n3vzqFdsK49pyfpFu4-0,215552
+pyxcp/daq_stim/stim.cp311-win_arm64.pyd,sha256=_bLXkDdwxuPQiOfRhdPUeOW3igFCYCuy9CnZjpC9Yao,216576
+pyxcp/daq_stim/stim.cp312-win_arm64.pyd,sha256=n9BZ11zTRp_MpWmuzGoTR9JiT2kNTuH1Of219gkav-0,216576
+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
+pyxcp/dllif.py,sha256=qeo7quKQ-_7TjRh_umTD-g0utBcCJd1q4GBRl2m93-M,3444
+pyxcp/errormatrix.py,sha256=ZAl8N-JZRVYWeSls135FWAk-xw4KsPgvUscqeAkZpFQ,45464
+pyxcp/examples/conf_can.toml,sha256=4o-M4xmh7pCzuQLfXnIOLIXqx5aZjMAZ6jtjYJ8hLBQ,370
+pyxcp/examples/conf_can_user.toml,sha256=IJhcc60tKMDgNhviYtHr2OjEl_ID4CsfMKchDeMFdJs,314
+pyxcp/examples/conf_can_vector.json,sha256=spux_wLX4EZdEpUqD2SU9-9uPDc2U1poeMaYo7QQT2M,249
+pyxcp/examples/conf_can_vector.toml,sha256=VXkHgJ9OjSnaz4BpIKsYg53oSNsj9F0LrTSDh8vHJMk,262
+pyxcp/examples/conf_eth.toml,sha256=BQE8UwZlBL4vNPQ_IDXVzrK9klFH9FhDCX68fXdSp_w,199
+pyxcp/examples/conf_nixnet.json,sha256=BvXPrljPGzaRTNPch3K0XfU3KSBP1sVDDNP7yY850OQ,444
+pyxcp/examples/conf_socket_can.toml,sha256=gTacQGm0p6fhPCMWC3ScLq9Xj-xJmNbjNXkjO4o7r8k,269
+pyxcp/examples/run_daq.py,sha256=-AmT1UhY8V4vHmi3jwcw2WrV9b0GhFqULEybWjtkgTo,5676
+pyxcp/examples/xcp_policy.py,sha256=XpXPLAH1y0xiTAcVUSp9TiHtoD8-AsoqffwJuKQPrhc,1921
+pyxcp/examples/xcp_read_benchmark.py,sha256=HJu29FJQB-lqOqx2z4tF_vtB5a2zpHYLgsWSohP7Nj0,956
+pyxcp/examples/xcp_skel.py,sha256=eRjn6m5TuddOUYpHtw8MZhADdaZHAb2AKZJlRIbauac,1157
+pyxcp/examples/xcp_unlock.py,sha256=Ch4EJkLuDBWJgtBNQFKqENhvTQqKDAE0LJZMQUhktmk,732
+pyxcp/examples/xcp_user_supplied_driver.py,sha256=ycYVdjqjQrBr99CKZ-FG3IgAxTCfbUzSFH99JJ36ZQs,1134
+pyxcp/examples/xcphello.py,sha256=6hLOzeqPyNERxQn94_Vup87FbGeRjmjPBe4ZLl6tkmU,2356
+pyxcp/examples/xcphello_recorder.py,sha256=c7ldGXpjyHe7DCit_S8D5AkqVX81pleLEvLDugcdCeU,3409
+pyxcp/master/__init__.py,sha256=RbMGgWZWRMEpembwgV-kkdSfQxuUZeXsybcspAhMzj0,320
+pyxcp/master/errorhandler.py,sha256=Hyn6geDgrH7EJdpgPWuQYbe_fDOQ2zzYFqRnHFny1Fw,26628
+pyxcp/master/master.py,sha256=aTcoKqRKVeX2wwE4Ox0n7POW6VQbscgWbYDi9x9cXWs,101460
+pyxcp/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyxcp/recorder/.idea/.gitignore,sha256=G_3s42Re2O01YDDyLMIATcP0Af8GCsPSTegRw7zYLhY,184
+pyxcp/recorder/.idea/misc.xml,sha256=XfcpM2YHByf1o3XaftWMr5UIaGSVc9LMzRnZmUp1ynM,142
+pyxcp/recorder/.idea/modules.xml,sha256=vq9Gc9pRmTRFr3iP9TcHkz1CYfObW6QVQGGRViKwRhM,277
+pyxcp/recorder/.idea/recorder.iml,sha256=m0L-3jEfCtu6qHTzY3iOsTfFMLvuspSBrkE8PBlhyOo,248
+pyxcp/recorder/.idea/sonarlint/issuestore/3/8/3808afc69ac1edb9d760000a2f137335b1b99728,sha256=YKcXNhekpl1LD7TEGHPjjXbmwyfY0c50DyveDrMVFxo,602
+pyxcp/recorder/.idea/sonarlint/issuestore/9/a/9a2aa4db38d3115ed60da621e012c0efc0172aae,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyxcp/recorder/.idea/sonarlint/issuestore/b/4/b49006702b459496a8e8c94ebe60947108361b91,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyxcp/recorder/.idea/sonarlint/issuestore/index.pb,sha256=pt_itWgvTAnMANXontA5cYFLHGjruv10VB_c2Ij5YFs,184
+pyxcp/recorder/.idea/sonarlint/securityhotspotstore/3/8/3808afc69ac1edb9d760000a2f137335b1b99728,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyxcp/recorder/.idea/sonarlint/securityhotspotstore/9/a/9a2aa4db38d3115ed60da621e012c0efc0172aae,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyxcp/recorder/.idea/sonarlint/securityhotspotstore/b/4/b49006702b459496a8e8c94ebe60947108361b91,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyxcp/recorder/.idea/sonarlint/securityhotspotstore/index.pb,sha256=pt_itWgvTAnMANXontA5cYFLHGjruv10VB_c2Ij5YFs,184
+pyxcp/recorder/.idea/vcs.xml,sha256=BStFtkvzuXVRrIMy3OssQHjOMNmxZlh8j_BEkJyMaHY,428
+pyxcp/recorder/__init__.py,sha256=FwlOc4Ci3DRYBT6VaRy_RcioUPpA8MvtM-9ju71Z_GM,2776
+pyxcp/recorder/build_clang.cmd,sha256=JvFngSnb28XcBGXxC6MGrcOCGYfahOIvHpgRpqbA6HQ,175
+pyxcp/recorder/build_clang.sh,sha256=zmU3nZxaNH1pxGWMyQ-S541TuVqxS00p3iPR9NUP4Ec,181
+pyxcp/recorder/build_gcc.cmd,sha256=zj732DdvqDzGAFg7dvF83DUpf8Qf6rQ0cqEaID15Z80,238
+pyxcp/recorder/build_gcc.sh,sha256=nCSh7G8xtxWtDNrMqNUxcjnm_CFpMeduIF0X-RSJtHA,211
+pyxcp/recorder/build_gcc_arm.sh,sha256=jEo6Mgt_aVDL3nHtffecXOrN6gRsEoaA3S4pPrAzpCE,240
+pyxcp/recorder/converter/__init__.py,sha256=wSWMl0xY-nG7f649SXQZ0_1MD196pWw9sr96tqjV-Uo,14893
+pyxcp/recorder/lz4.c,sha256=rOy3JE2SsOXvJ8a9pgGEfGpbDJnJR03dSVej0CwPmjg,120974
+pyxcp/recorder/lz4.h,sha256=Kz_2V6kvOunNHoPl9-EqxWDVCvYXbU0J-pkSnCeXubs,46483
+pyxcp/recorder/lz4hc.c,sha256=E56iE5CQ6fhQIVi3qNpxiIIP2sTGeC80JtVPyhidV6Q,88870
+pyxcp/recorder/lz4hc.h,sha256=dtxPbesyAongP7CK_pL0M2DL707iMm9jGKrl8hXXRNk,20592
+pyxcp/recorder/mio.hpp,sha256=5ASJLKSEykH0deAQD5uak-_yAgd5p2n8t06315GSGrg,63346
+pyxcp/recorder/reader.hpp,sha256=ssdaAaG_fHKrJMuMo_tfcCaCjFrIC5HQGNXgR343bVY,5131
+pyxcp/recorder/reco.py,sha256=2CPKxIZNSr6BhjfPrWtxdt81zaJlgU-e73RneG9IsJA,8727
+pyxcp/recorder/recorder.rst,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyxcp/recorder/rekorder.cp310-win_arm64.pyd,sha256=xPIWYTtkGv8E8UciTeXYqWO0RBVOCLr-Cb99Tmw72Hc,425984
+pyxcp/recorder/rekorder.cp311-win_arm64.pyd,sha256=-0eUYfUSKYNhU1x5ritZzlnvzfUohW4Vq3Yk4BR42-o,425984
+pyxcp/recorder/rekorder.cp312-win_arm64.pyd,sha256=Isbgj3M7IlTtuyNniMnFWgUP_uroC47Shq5gqTFX9EU,417792
+pyxcp/recorder/rekorder.cpp,sha256=U0LMyk8pZXx9emgS_WPVthvn_9IpgE7JGrh4kg-8CX4,1900
+pyxcp/recorder/rekorder.hpp,sha256=sWvRch9bVt6mmgrFHp5mwWhap7HoFG4geeb7UqEIzio,7638
+pyxcp/recorder/setup.py,sha256=_99XFPQAd5V4LcJaSGJwdnbxgxJ7kl8DEXfHsnKO1Yg,998
+pyxcp/recorder/test_reko.py,sha256=M8lfKBmBUl-28IMVoD6lU5Bnorz7fYFOvcAjfVZxuXA,1014
+pyxcp/recorder/unfolder.hpp,sha256=USNXbsKWFa807I_XCJyG846uW2kVlUhqvSK2jR1uvsE,49691
+pyxcp/recorder/wrap.cpp,sha256=oCsEOnRsvLlaWjyN09X7mcHLzzqCyLskREKb6kmyqNE,8707
+pyxcp/recorder/writer.hpp,sha256=rNjtRTtJes5z-BzKR2K56P_Kvc9MEVQgycu8J0wKf1g,11284
+pyxcp/scripts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyxcp/scripts/pyxcp_probe_can_drivers.py,sha256=P_gscDTAofbSVA_Wd1GATrnyWGTf1-Dz_oPdlRFfjuk,567
+pyxcp/scripts/xcp_examples.py,sha256=q2wNXHVZu4GjcIlZwp2j9Sqm5QH39Olro4BQaLoIqiM,2583
+pyxcp/scripts/xcp_fetch_a2l.py,sha256=mRS42707lEFjH9q9ip2TgIOstc6QBnZ3IMMkf7GtEtk,1239
+pyxcp/scripts/xcp_id_scanner.py,sha256=zsqjEJko8OtzRtHZT6YVVanD7hbaGPv0qsC_jK1Gzig,419
+pyxcp/scripts/xcp_info.py,sha256=sYkh48FyXtmRZg3uM27YjM-6A_oBV82BujuueM-NOhI,6437
+pyxcp/scripts/xcp_profile.py,sha256=NPZWVTVUiyNulaYIeShw3VO0ChhE9OtN-rMWgjHiTn0,613
+pyxcp/scripts/xmraw_converter.py,sha256=LvjiKAWHUKs5QZNiIDT-vdNgPG0Gioas2MzLJOo62-Y,684
+pyxcp/stim/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyxcp/tests/test_asam_types.py,sha256=0M08q8dJIVx-rkUtFKTqUhhW9NkThYL83LW3d_yCols,587
+pyxcp/tests/test_binpacking.py,sha256=kxLwYNzop775BkV68WXBoXVnLIuP0y4EKIW7u9niMKc,7623
+pyxcp/tests/test_can.py,sha256=fLLATWZxZK3vG-jDwjkWSOCqzy1UmtdV304-3qD6kRQ,63996
+pyxcp/tests/test_checksum.py,sha256=ZQ9-7bpKBLNKk1jxQ61AKAVUTWReOBYCZ8ikNo2jmII,1808
+pyxcp/tests/test_daq.py,sha256=1uUK0Y3svHx-cqx1LKfThhBxJcgG9lmV7OCYRUQlxHw,5537
+pyxcp/tests/test_daq_opt.py,sha256=GznXj4lVGfLWa8nJ2w3t_IlUQeq8HOspqEHbQq3zJ4I,13011
+pyxcp/tests/test_frame_padding.py,sha256=b7D0oh_n33iFhi_FKav6LkA0smJB4vg5bTMKu-jIaf0,3205
+pyxcp/tests/test_framing.py,sha256=Ul9ZcG6Jq3DDC1JCsPTP9K1y6GiKFwoip8S5Rqz8qKc,7971
+pyxcp/tests/test_master.py,sha256=8HYqmKqSv1OS6BvsKmDQDrm8udvopPBzYzV75Ry7KjE,75456
+pyxcp/tests/test_transport.py,sha256=AYmYywlS6qFRFfTnji0pWEScZuYaapzzO8LfrB4fNPI,5948
+pyxcp/tests/test_utils.py,sha256=SrURAFc_6jtHng3PSZ5gpqXzVBVuPoMPB0YNvOvaIE0,880
+pyxcp/timing.py,sha256=mKefaRHUKTuWlBuSHXRauNen_KJCO3P1e7TJMUkwE9k,1702
+pyxcp/transport/__init__.py,sha256=gKZy_GXJFpPoJ1V7j14hPF6u5k-LeM1cIXTREeKRQvk,417
+pyxcp/transport/base.py,sha256=Eb5qLeAP-VXQwHcX2M58Rdl0jZ8K_RFYSoE-Pq6kW64,18784
+pyxcp/transport/base_transport.hpp,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyxcp/transport/can.py,sha256=JeASLHW2A66Zaq6X5XG9vdfX-eXdhWbttbaMR0Zow20,24032
+pyxcp/transport/eth.py,sha256=8QRzHIQIzzM9T5fbAIMk7FLSQLkMsCJa3UPW_61rXDw,10530
+pyxcp/transport/hdf5_policy.py,sha256=KIewRq5AI-EPNPzw-MHb5lriF-K4Jt5cuaxYFvreonU,5544
+pyxcp/transport/sxi.py,sha256=P3ppV-MzuvLMGPldm8sB_nXKyTCRJeqraQj8yzRwmqI,7379
+pyxcp/transport/transport_ext.cp310-win_arm64.pyd,sha256=Qbtsyu3vXjS9lyLRm7GPgnEeKpoqfZhZcVu7hvejizg,455168
+pyxcp/transport/transport_ext.cp311-win_arm64.pyd,sha256=NJLfvFMgynxEsTJ-KcbInbATzkuNLRakSk-JSFgXB9U,455680
+pyxcp/transport/transport_ext.cp312-win_arm64.pyd,sha256=XPIDxCCJSCQ18Ue809YeosOEByt3Qt50fG0yZLUC_2A,418304
+pyxcp/transport/transport_ext.hpp,sha256=ABxcvoDPua_IUJ9NhrmxcSoTr3ofLVXlezHtN_bHY5w,6511
+pyxcp/transport/transport_wrapper.cpp,sha256=fJmsiGrH4WZvDri2rJpwTosTHTqlANpWi4kHu7vda8M,12485
+pyxcp/transport/usb_transport.py,sha256=K_tAESxgSVllJinoYanJbFB_j28yOId6m5EgdXvPItQ,8902
+pyxcp/types.py,sha256=Hwan9e9VmFud5nYgI_iS0c3LVlh2IfmpKXbml-obfD0,25963
+pyxcp/utils/__init__.py,sha256=d4QmrEZiK7xtdCThhZapV2Zbyi0YB_ELNDL49mkji5Y,3509
+pyxcp/utils/cli.py,sha256=BnwQvMk8GERns4B-2I0hDuBk9pE-krc_o36NkBsezB8,3027
+pyxcp/vector/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pyxcp/vector/map.py,sha256=7Gnhvr79geMeqqGVIJPxODXGwABdNDinnqzhpooN5TE,2306
+pyxcp-0.25.6.dist-info/entry_points.txt,sha256=LkHsEwubm30s4oiyCy0cKj6k97ALvQ6KjAVdyEcqu7g,358
+pyxcp-0.25.6.dist-info/licenses/LICENSE,sha256=fTqV5eBpeAZO0_jit8j4Ref9ikBSlHJ8xwj5TLg7gFk,7817
+pyxcp-0.25.6.dist-info/METADATA,sha256=Mk0PCY9QH3eMJ3O4GV0mTTWSMgkKlSBJuZ9pqsN0EGU,12775
+pyxcp-0.25.6.dist-info/WHEEL,sha256=2OrXvuvO0Q8KtvYHaCXJr4ZHJ7u3YqiFdY-BJEkKGf0,98
+pyxcp-0.25.6.dist-info/RECORD,,

{pyxcp-0.23.3.dist-info → pyxcp-0.25.6.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 2.1.3
+Generator: poetry-core 2.2.1
 Root-Is-Purelib: false
 Tag: cp312-cp312-win_arm64

pyxcp/examples/conf_sxi.json

@@ -1,9 +0,0 @@
-{
-  "TRANSPORT": "SXI",
-  "PORT": "COM10",
-  "BITRATE": 38400,
-  "BYTESIZE": 8,
-  "PARITY": "N",
-  "STOPBITS": 1,
-  "CREATE_DAQ_TIMESTAMPS": false
-}

pyxcp/examples/conf_sxi.toml

@@ -1,7 +0,0 @@
-TRANSPORT = "SXI"
-PORT = "COM10"
-BITRATE = 38400
-PARITY = "N"
-BYTESIZE = 8
-STOPBITS = 1
-CREATE_DAQ_TIMESTAMPS = false