pyxcp 0.21.10__cp38-cp38-win_amd64.whl → 0.22.23__cp38-cp38-win_amd64.whl

pyxcp/transport/usb_transport.py

@@ -1,55 +1,57 @@
 #!/usr/bin/env python
-# -*- coding: utf-8 -*-
 import struct
 import threading
 from array import array
 from collections import deque
-from time import perf_counter
-from time import sleep
-from time import time
+from typing import Optional
 
-import usb.backend.libusb1 as libusb1
 import usb.backend.libusb0 as libusb0
+import usb.backend.libusb1 as libusb1
 import usb.backend.openusb as openusb
 import usb.core
 import usb.util
+from usb.core import USBError, USBTimeoutError
 
 from pyxcp.transport.base import BaseTransport
-from pyxcp.utils import SHORT_SLEEP
+from pyxcp.utils import short_sleep
+
 
 RECV_SIZE = 16384
+FIVE_MS = 5_000_000  # Five milliseconds in nanoseconds.
 
 
 class Usb(BaseTransport):
     """"""
 
-    PARAMETER_MAP = {
-        #                            Type    Req'd   Default
-        "serial_number": (str, True, ""),
-        "configuration_number": (int, True, 1),
-        "interface_number": (int, True, 2),
-        "command_endpoint_number": (int, True, 0),
-        "reply_endpoint_number": (int, True, 1),
-        "vendor_id": (int, False, 0),
-        "product_id": (int, False, 0),
-        "library": (str, False, "")  # absolute path to USB shared library
-    }
     HEADER = struct.Struct("<2H")
     HEADER_SIZE = HEADER.size
 
-    def __init__(self, config=None, policy=None):
-        super(Usb, self).__init__(config, policy)
-        self.loadConfig(config)
-        self.serial_number = self.config.get("serial_number").strip()
-        self.vendor_id = self.config.get("vendor_id")
-        self.product_id = self.config.get("product_id")
-        self.configuration_number = self.config.get("configuration_number")
-        self.interface_number = self.config.get("interface_number")
-        self.command_endpoint_number = self.config.get("command_endpoint_number")
-        self.reply_endpoint_number = self.config.get("reply_endpoint_number")
+    def __init__(self, config=None, policy=None, transport_layer_interface: Optional[usb.core.Device] = None):
+        super().__init__(config, policy, transport_layer_interface)
+        self.load_config(config)
+        self.serial_number: str = self.config.serial_number
+        self.vendor_id: int = self.config.vendor_id
+        self.product_id: int = self.config.product_id
+        self.configuration_number: int = self.config.configuration_number
+        self.interface_number: int = self.config.interface_number
+        self.library: str = self.config.library
+        self.header_format: str = self.config.header_format
         self.library = self.config.get("library")
         self.device = None
 
+        ## IN-EP (RES/ERR, DAQ, and EV/SERV) Parameters.
+        self.in_ep_number: int = self.config.in_ep_number
+        self.in_ep_transfer_type = self.config.in_ep_transfer_type
+        self.in_ep_max_packet_size: int = self.config.in_ep_max_packet_size
+        self.in_ep_polling_interval: int = self.config.in_ep_polling_interval
+        self.in_ep_message_packing = self.config.in_ep_message_packing
+        self.in_ep_alignment = self.config.in_ep_alignment
+        self.in_ep_recommended_host_bufsize: int = self.config.in_ep_recommended_host_bufsize
+
+        ## OUT-EP (CMD and STIM) Parameters.
+        self.out_ep_number: int = self.config.out_ep_number
+
+        self.device: Optional[usb.core.Device] = None
         self.status = 0
 
         self._packet_listener = threading.Thread(
@@ -86,10 +88,10 @@ class Usb(BaseTransport):
                 if device.serial_number.strip().strip("\0").lower() == self.serial_number.lower():
                     self.device = device
                     break
-            except BaseException:
+            except (USBError, USBTimeoutError):
                 continue
         else:
-            raise Exception("Device with serial {} not found".format(self.serial_number))
+            raise Exception(f"XCPonUSB - device with serial {self.serial_number!r} not found")
 
         current_configuration = self.device.get_active_configuration()
         if current_configuration.bConfigurationValue != self.configuration_number:
@@ -98,14 +100,14 @@ class Usb(BaseTransport):
 
         interface = cfg[(self.interface_number, 0)]
 
-        self.command_endpoint = interface[self.command_endpoint_number]
-        self.reply_endpoint = interface[self.reply_endpoint_number]
+        self.out_ep = interface[self.out_ep_number]
+        self.in_ep = interface[self.in_ep_number]
 
-        self.startListener()
+        self.start_listener()
         self.status = 1  # connected
 
-    def startListener(self):
-        super().startListener()
+    def start_listener(self):
+        super().start_listener()
         if self._packet_listener.is_alive():
             self._packet_listener.join()
         self._packet_listener = threading.Thread(target=self._packet_listen)
@@ -113,83 +115,68 @@ class Usb(BaseTransport):
 
     def close(self):
         """Close the transport-layer connection and event-loop."""
-        self.finishListener()
+        self.finish_listener()
         if self.listener.is_alive():
             self.listener.join()
         if self._packet_listener.is_alive():
             self._packet_listener.join()
-        self.closeConnection()
+        self.close_connection()
 
     def _packet_listen(self):
-
-        close_event_set = self.closeEvent.isSet
-
+        close_event_set = self.closeEvent.is_set
         _packets = self._packets
-        read = self.reply_endpoint.read
-
+        read = self.in_ep.read
         buffer = array("B", bytes(RECV_SIZE))
         buffer_view = memoryview(buffer)
-
         while True:
             try:
                 if close_event_set():
                     return
-
                 try:
-                    recv_timestamp = time()
+                    recv_timestamp = self.timestamp.value
                     read_count = read(buffer, 100)  # 100ms timeout
                     if read_count != RECV_SIZE:
                         _packets.append((buffer_view[:read_count].tobytes(), recv_timestamp))
                     else:
                         _packets.append((buffer.tobytes(), recv_timestamp))
-                except BaseException:
+                except (USBError, USBTimeoutError):
                     # print(format_exc())
-                    sleep(SHORT_SLEEP)
+                    short_sleep()
                     continue
-
-            except BaseException:
+            except BaseException:  # noqa: B036
+                # Note: catch-all only permitted if the intention is re-raising.
                 self.status = 0  # disconnected
                 break
 
     def listen(self):
         HEADER_UNPACK_FROM = self.HEADER.unpack_from
         HEADER_SIZE = self.HEADER_SIZE
-
         popleft = self._packets.popleft
-
-        processResponse = self.processResponse
-        close_event_set = self.closeEvent.isSet
-
+        process_response = self.process_response
+        close_event_set = self.closeEvent.is_set
         _packets = self._packets
-        length, counter = None, None
-
-        data = bytearray(b"")
-
-        last_sleep = perf_counter()
+        length: Optional[int] = None
+        counter: int = 0
+        data: bytearray = bytearray(b"")
+        last_sleep: int = self.timestamp.value
 
         while True:
             if close_event_set():
                 return
-
-            count = len(_packets)
-
+            count: int = len(_packets)
             if not count:
-                sleep(SHORT_SLEEP)
-                last_sleep = perf_counter()
+                short_sleep()
+                last_sleep = self.timestamp.value
                 continue
-
             for _ in range(count):
                 bts, timestamp = popleft()
-
                 data += bts
-                current_size = len(data)
-                current_position = 0
-
+                current_size: int = len(data)
+                current_position: int = 0
                 while True:
-                    if perf_counter() - last_sleep >= 0.005:
-                        sleep(SHORT_SLEEP)
-                        last_sleep = perf_counter()
-
+                    if self.timestamp.value - last_sleep >= FIVE_MS:
+                        short_sleep()
+                        last_sleep = self.timestamp.value
                     if length is None:
                         if current_size >= HEADER_SIZE:
                             length, counter = HEADER_UNPACK_FROM(data, current_position)
@@ -201,31 +188,26 @@ class Usb(BaseTransport):
                     else:
                         if current_size >= length:
                             response = data[current_position : current_position + length]
-                            processResponse(response, length, counter, timestamp)
-
+                            process_response(response, length, counter, timestamp)
                             current_size -= length
                             current_position += length
-
                             length = None
-
                         else:
-
                             data = data[current_position:]
                             break
 
     def send(self, frame):
-
-        self.pre_send_timestamp = time()
+        self.pre_send_timestamp = self.timestamp.value
         try:
-            self.command_endpoint.write(frame)
-        except BaseException:
+            self.out_ep.write(frame)
+        except (USBError, USBTimeoutError):
             # sometimes usb.core.USBError: [Errno 5] Input/Output Error is raised
             # even though the command is send and a reply is received from the device.
             # Ignore this here since a Timeout error will be raised anyway if
             # the device does not respond
             pass
-        self.post_send_timestamp = time()
+        self.post_send_timestamp = self.timestamp.value
 
-    def closeConnection(self):
+    def close_connection(self):
         if self.device is not None:
             usb.util.dispose_resources(self.device)

pyxcp/types.py

@@ -1,28 +1,30 @@
 #!/usr/bin/env python
-# -*- coding: utf-8 -*-
 import enum
 from collections import namedtuple
 
 import construct
-from construct import BitsInteger
-from construct import BitStruct
-from construct import Enum
-from construct import Flag
-from construct import GreedyBytes
-from construct import GreedyRange
-from construct import If
-from construct import IfThenElse
-from construct import Int16ub
-from construct import Int16ul
-from construct import Int32ub
-from construct import Int32ul
-from construct import Int64ub
-from construct import Int64ul
-from construct import Int8ul
-from construct import Padding
-from construct import Struct
-from construct import Switch
-from construct import this
+from construct import (
+    BitsInteger,
+    BitStruct,
+    Bytes,
+    Enum,
+    Flag,
+    GreedyBytes,
+    GreedyRange,
+    If,
+    IfThenElse,
+    Int8ul,
+    Int16ub,
+    Int16ul,
+    Int32ub,
+    Int32ul,
+    Int64ub,
+    Int64ul,
+    Padding,
+    Struct,
+    Switch,
+    this,
+)
 
 
 if construct.version < (2, 8):
@@ -735,6 +737,11 @@ GetEventChannelInfoResponse = Struct(
     "eventChannelPriority" / Int8ul,
 )
 
+GetSlaveIdResponse = Struct(
+    "magic" / Bytes(3),
+    "identifier" / Int32u,
+)
+
 GetDaqIdResponse = Struct(
     "canIdFixed"
     / Enum(
@@ -909,6 +916,7 @@ DbgGetTriDescTblResponse = Struct("mode" / Int8ul, Padding(2), "length" / Int32u
 
 DbgLlbtResponse = Struct(Padding(1), "length" / Int16u, "data" / Int8ul[this.length])
 
+# Convert to seconds.
 DAQ_TIMESTAMP_UNIT_TO_EXP = {
     "DAQ_TIMESTAMP_UNIT_1PS": -12,
     "DAQ_TIMESTAMP_UNIT_10PS": -11,
@@ -925,6 +933,39 @@ DAQ_TIMESTAMP_UNIT_TO_EXP = {
     "DAQ_TIMESTAMP_UNIT_1S": 0,
 }
 
+# Convert to nano-seconds.
+DAQ_TIMESTAMP_UNIT_TO_NS = {
+    "DAQ_TIMESTAMP_UNIT_1PS": 0.001,
+    "DAQ_TIMESTAMP_UNIT_10PS": 0.01,
+    "DAQ_TIMESTAMP_UNIT_100PS": 0.1,
+    "DAQ_TIMESTAMP_UNIT_1NS": 1,
+    "DAQ_TIMESTAMP_UNIT_10NS": 10,
+    "DAQ_TIMESTAMP_UNIT_100NS": 100,
+    "DAQ_TIMESTAMP_UNIT_1US": 1000,
+    "DAQ_TIMESTAMP_UNIT_10US": 10 * 1000,
+    "DAQ_TIMESTAMP_UNIT_100US": 100 * 1000,
+    "DAQ_TIMESTAMP_UNIT_1MS": 1000 * 1000,
+    "DAQ_TIMESTAMP_UNIT_10MS": 10 * 1000 * 1000,
+    "DAQ_TIMESTAMP_UNIT_100MS": 100 * 1000 * 1000,
+    "DAQ_TIMESTAMP_UNIT_1S": 1000 * 1000 * 1000,
+}
+
+EVENT_CHANNEL_TIME_UNIT_TO_EXP = {
+    "EVENT_CHANNEL_TIME_UNIT_1PS": -12,
+    "EVENT_CHANNEL_TIME_UNIT_10PS": -11,
+    "EVENT_CHANNEL_TIME_UNIT_100PS": -10,
+    "EVENT_CHANNEL_TIME_UNIT_1NS": -9,
+    "EVENT_CHANNEL_TIME_UNIT_10NS": -8,
+    "EVENT_CHANNEL_TIME_UNIT_100NS": -7,
+    "EVENT_CHANNEL_TIME_UNIT_1US": -6,
+    "EVENT_CHANNEL_TIME_UNIT_10US": -5,
+    "EVENT_CHANNEL_TIME_UNIT_100US": -4,
+    "EVENT_CHANNEL_TIME_UNIT_1MS": -3,
+    "EVENT_CHANNEL_TIME_UNIT_10MS": -2,
+    "EVENT_CHANNEL_TIME_UNIT_100MS": -1,
+    "EVENT_CHANNEL_TIME_UNIT_1S": 0,
+}
+
 
 class XcpGetSeedMode(enum.IntEnum):
     FIRST_PART = 0
@@ -942,3 +983,11 @@ class FrameCategory(enum.IntEnum):
     SERV = 5
     DAQ = 6
     STIM = 7
+
+
+class TryCommandResult(enum.IntEnum):
+    """ """
+
+    OK = 0
+    XCP_ERROR = 1
+    OTHER_ERROR = 2

pyxcp/utils.py

@@ -1,12 +1,15 @@
 #!/usr/bin/env python
-# -*- coding: utf-8 -*-
+import datetime
+import functools
+import operator
 import sys
 from binascii import hexlify
-from time import get_clock_info
-from time import perf_counter
-from time import time
+from time import perf_counter, sleep
 
 import chardet
+import pytz
+
+from pyxcp.cpp_ext.cpp_ext import TimestampInfo
 
 
 def hexDump(arr):
@@ -14,7 +17,7 @@ def hexDump(arr):
         size = len(arr)
         try:
             arr = arr.hex()
-        except BaseException:
+        except BaseException:  # noqa: B036
             arr = hexlify(arr).decode("ascii")
         return "[{}]".format(" ".join([arr[i * 2 : (i + 1) * 2] for i in range(size)]))
     elif isinstance(arr, (list, tuple)):
@@ -22,28 +25,34 @@ def hexDump(arr):
         size = len(arr)
         try:
             arr = arr.hex()
-        except BaseException:
+        except BaseException:  # noqa: B036
             arr = hexlify(arr).decode("ascii")
         return "[{}]".format(" ".join([arr[i * 2 : (i + 1) * 2] for i in range(size)]))
     else:
-        return "[{}]".format(" ".join(["{:02x}".format(x) for x in arr]))
+        return "[{}]".format(" ".join([f"{x:02x}" for x in arr]))
+
+
+def seconds_to_nanoseconds(value: float) -> int:
+    return int(value * 1_000_000_000)
 
 
 def slicer(iterable, sliceLength, converter=None):
     if converter is None:
         converter = type(iterable)
     length = len(iterable)
-    return [converter((iterable[item : item + sliceLength])) for item in range(0, length, sliceLength)]
+    return [converter(iterable[item : item + sliceLength]) for item in range(0, length, sliceLength)]
+
+
+def functools_reduce_iconcat(a):
+    return functools.reduce(operator.iconcat, a, [])
 
 
 def flatten(*args):
-    result = []
-    for arg in list(args):
-        if hasattr(arg, "__iter__"):
-            result.extend(flatten(*arg))
-        else:
-            result.append(arg)
-    return result
+    """Flatten a list of lists into a single list.
+
+    s. https://stackoverflow.com/questions/952914/how-do-i-make-a-flat-list-out-of-a-list-of-lists
+    """
+    return functools.reduce(operator.iconcat, args, [])
 
 
 def getPythonVersion():
@@ -60,7 +69,10 @@ def decode_bytes(byte_str: bytes) -> str:
 
 
 PYTHON_VERSION = getPythonVersion()
-SHORT_SLEEP = 0.0005
+
+
+def short_sleep():
+    sleep(0.0005)
 
 
 def delay(amount: float):
@@ -69,3 +81,22 @@ def delay(amount: float):
     start = perf_counter()
     while perf_counter() < start + amount:
         pass
+
+
+class CurrentDatetime(TimestampInfo):
+
+    def __init__(self, timestamp_ns: int):
+        TimestampInfo.__init__(self, timestamp_ns)
+        timezone = pytz.timezone(self.timezone)
+        dt = datetime.datetime.fromtimestamp(timestamp_ns / 1_000_000_000.0)
+        self.utc_offset = int(timezone.utcoffset(dt).total_seconds() / 60)
+        self.dst_offset = int(timezone.dst(dt).total_seconds() / 60)
+
+    def __str__(self):
+        return f"""CurrentDatetime(
+    datetime="{datetime.datetime.fromtimestamp(self.timestamp_ns / 1_000_000_000.0)!s}",
+    timezone="{self.timezone}",
+    timestamp_ns={self.timestamp_ns},
+    utc_offset={self.utc_offset},
+    dst_offset={self.dst_offset}
+)"""

pyxcp/vector/map.py

@@ -1,6 +1,4 @@
 #!/usr/bin/env python
-# -*- coding: utf-8 -*-
-from enum import IntEnum
 
 MAP_NAMES = {
     1: "BorlandC 16 Bit",
@@ -81,4 +79,4 @@ MAP name
 
 
 def mapfile_name(name, counter, fmt):
-    return "{:2d}{:d}{:s}.map".format(fmt, counter, name)
+    return f"{fmt:2d}{counter:d}{name:s}.map"

{pyxcp-0.21.10.dist-info → pyxcp-0.22.23.dist-info}/METADATA

@@ -1,41 +1,43 @@
 Metadata-Version: 2.1
 Name: pyxcp
-Version: 0.21.10
+Version: 0.22.23
 Summary: Universal Calibration Protocol for Python
+Home-page: https://github.com/christoph2/pyxcp
+License: LGPLv3
 Keywords: automotive,ecu,xcp,asam,autosar
 Author: Christoph Schueler
-Author-email: cpu12.gems@googlemail.com
-Requires-Python: >=3.7
+Author-email: cpu.gems@googlemail.com
+Requires-Python: >=3.8.1,<4.0.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.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.7
+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: Mako<2.0.0,>=1.1.6
-Requires-Dist: chardet>=5.2.0
-Requires-Dist: construct<3.0.0,>=2.10.67
-Requires-Dist: pyserial<4.0,>=3.5
-Requires-Dist: python-can>=4.0.0
-Requires-Dist: pyusb<2.0.0,>=1.2.1
-Requires-Dist: setuptools-cpp<1.0.0,>=0.1.0
-Requires-Dist: toml<1.0.0,>=0.10.2
-Requires-Dist: traitlets>=5.9.0
-Requires-Dist: uptime>=3.0.1
-Provides-Extra: doc
-Requires-Dist: sphinx; extra == "doc"
-Requires-Dist: sphinxcontrib-napoleon; extra == "doc"
-Project-URL: homepage, https://github.com/christoph2/pyxcp
+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 (>=2024.1,<2025.0)
+Requires-Dist: pyusb (>=1.2.1,<2.0.0)
+Requires-Dist: rich (>=13.6.0,<14.0.0)
+Requires-Dist: toml (>=0.10.2,<0.11.0)
+Requires-Dist: tomlkit (>=0.12.5,<0.13.0)
+Requires-Dist: traitlets (<=5.11.2)
+Requires-Dist: uptime (>=3.0.1,<4.0.0)
 Description-Content-Type: text/markdown
 
-
-pyXCP
-=====
+# 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)
@@ -59,17 +61,20 @@ XCP also replaces the older CCP (CAN Calibration Protocol).
 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
 ```