python-can-cansub 2026.6.2__tar.gz → 2026.7.2__tar.gz

python_can_cansub-2026.7.2/CHANGELOG.md

@@ -0,0 +1,26 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+## 2026.07.02 (API 03.00)
+
+### Added
+- `server_cert`: path to the server certificate (`.crt` file).
+- `client_cert`: tuple of paths to the client certificate and key (`.crt`, `.key`), used for TLS mutual authentication.
+- Warning when devices with unsupported API versions are found.
+
+### Changed
+- Supported device API version changed from `02.00` to `03.00`.
+
+## 2026.06.02 (API 02.00)
+
+### Added
+- `CANSUB_ROOT_CERT`: path to the CANsub root certificate.
+
+### Changed
+- Transmit sequences (on the device) are deleted on bus open.
+
+## 2026.06.01 (API 02.00)
+
+### Fixed
+- `CyclicSendTask` with `duration=None` now working.

{python_can_cansub-2026.6.2 → python_can_cansub-2026.7.2}/PKG-INFO

@@ -1,9 +1,10 @@
 Metadata-Version: 2.4
 Name: python-can-cansub
-Version: 2026.6.2
+Version: 2026.7.2
 Summary: CANsub python-can interface
 Project-URL: Homepage, https://csselectronics.com/
 Project-URL: Source, https://github.com/CSS-Electronics/python-can-cansub
+Project-URL: Changelog, https://github.com/CSS-Electronics/python-can-cansub/blob/master/CHANGELOG.md
 Author: CSS Electronics
 Author-email: contact@csselectronics.com
 License: MIT
@@ -25,6 +26,17 @@ This package registers the CANsub as a standard python-can interface, making it
 
 > **Tip:** This README is optimized for LLMs. When using an AI coding assistant with this package, provide this file as context for accurate results.
 
+## Compatibility
+
+The python-can-cansub package and the CANsub device communicate over a versioned API. They are compatible when the package supports the API version used by the device firmware.
+
+- Each **python-can-cansub** release supports one API version. The supported API version for each release is listed in the [python-can-cansub changelog](https://github.com/CSS-Electronics/python-can-cansub/blob/master/CHANGELOG.md).
+- Each **CANsub firmware** release uses one API version. The API version for each firmware release is listed in the CANsub changelog (provided with the device).
+
+To check compatibility, look up the API version of the package release and of the device firmware release in their respective changelogs. If they match, the two are compatible.
+
+If the package finds a connected device whose API version it does not support, it emits a warning. Update the package or the device firmware so their API versions align.
+
 ## python-can API
 
 ### Installation
@@ -81,6 +93,12 @@ In the above example two CANsub devices are detected, each with two channels. On
 
 ### Opening a Bus
 
+> **Note:** `data_bitrate` is required even on a classic (non-FD) bus. On a non-FD bus, simply set it to e.g. `1_000_000` (1 Mbit/s).
+
+> **Tip:** Pass `listen_only=True` to `can.Bus` to monitor a bus without transmitting or acknowledging frames.
+
+> **Tip:** Pass `error_frames=True` to `can.Bus` to receive error frames.
+
 #### Single bus - hardcoded
 
 ```python
@@ -110,6 +128,22 @@ with (can.Bus(interface=configs[0]["interface"], channel=configs[0]["channel"],
 >     pass
 > ```
 
+### TLS / Certificates
+
+The data connection to the device is secured by TLS. When connecting via an IP address (where hostname verification will fail), `server_cert=None` can be used to disable certificate validation:
+
+```python
+with can.Bus(interface="cansub", channel="192.168.1.10@1", server_cert=None, bitrate=250_000, data_bitrate=1_000_000) as bus:
+    pass
+```
+
+If TLS mutual authentication is enabled, `client_cert` can be used to provide a tuple of paths to the client certificate (`.crt` file) and its unencrypted private key (`.key` file), i.e. `("cert", "key")`:
+
+```python
+with can.Bus(**configs[0], client_cert=("/path/to/client.crt", "/path/to/client.key"), bitrate=250_000, data_bitrate=1_000_000) as bus:
+    pass
+```
+
 ### Receive and Transmit
 
 ```python
@@ -124,6 +158,20 @@ with can.Bus(**configs[0], bitrate=250_000, data_bitrate=1_000_000) as bus:
     print(msg_rx)
 ```
 
+### Error Frames
+
+Error frame reporting is disabled by default; enable it by passing `error_frames=True` to `can.Bus`. Bus errors are then received as a `can.Message` with `is_error_frame` set. The error type is encoded in `arbitration_id`, which can be converted to a `CanSubErrorFrameType` enum:
+
+```python
+from python_can_cansub import CanSubErrorFrameType
+
+with can.Bus(**configs[0], bitrate=250_000, data_bitrate=1_000_000, error_frames=True) as bus:
+    msg = bus.recv(timeout=1.0)
+    if msg and msg.is_error_frame:
+        error_type = CanSubErrorFrameType(msg.arbitration_id)
+        print(f"Bus error: {error_type.name}")  # e.g. "Bus error: ACK"
+```
+
 ### Filters
 
 Apply hardware filters by passing `can_filters` to `can.Bus`. Each filter specifies a `can_id`, a `can_mask`, and whether to match standard (`extended=False`) or extended (`extended=True`) frames. A frame passes if `(frame_id & can_mask) == (can_id & can_mask)`.
@@ -192,6 +240,28 @@ with can.Bus(**configs[0], bitrate=250_000, data_bitrate=1_000_000) as bus:
             bus.send(msg)
 ```
 
+### CSV Logger
+
+On import, this package overrides the default python-can `.csv` reader and writer with a format compatible with the *webCAN* browser tool provided with the device. This applies automatically wherever `.csv` files are read or written, including `can.Logger`, `can.LogReader`, and the command-line tools.
+
+The writer (`CanSubCSVWriter`) and reader (`CanSubCSVReader`) can also be used directly:
+
+```python
+from python_can_cansub import CanSubCSVWriter, CanSubCSVReader
+
+# Write received messages to a webCAN-compatible CSV file
+with can.Bus(**configs[0], bitrate=250_000, data_bitrate=1_000_000) as bus:
+    with CanSubCSVWriter("log.csv") as writer:
+        msg = bus.recv(timeout=1.0)
+        if msg:
+            writer.on_message_received(msg)
+
+# Read messages back from the CSV file
+with CanSubCSVReader("log.csv") as reader:
+    for msg in reader:
+        print(msg)
+```
+
 ## python-can tools
 
 python-can includes several command line tools. All tools accept `--interface` and `--channel` to select the bus, following the same configuration as the API.

{python_can_cansub-2026.6.2 → python_can_cansub-2026.7.2}/README.md

@@ -6,6 +6,17 @@ This package registers the CANsub as a standard python-can interface, making it
 
 > **Tip:** This README is optimized for LLMs. When using an AI coding assistant with this package, provide this file as context for accurate results.
 
+## Compatibility
+
+The python-can-cansub package and the CANsub device communicate over a versioned API. They are compatible when the package supports the API version used by the device firmware.
+
+- Each **python-can-cansub** release supports one API version. The supported API version for each release is listed in the [python-can-cansub changelog](https://github.com/CSS-Electronics/python-can-cansub/blob/master/CHANGELOG.md).
+- Each **CANsub firmware** release uses one API version. The API version for each firmware release is listed in the CANsub changelog (provided with the device).
+
+To check compatibility, look up the API version of the package release and of the device firmware release in their respective changelogs. If they match, the two are compatible.
+
+If the package finds a connected device whose API version it does not support, it emits a warning. Update the package or the device firmware so their API versions align.
+
 ## python-can API
 
 ### Installation
@@ -62,6 +73,12 @@ In the above example two CANsub devices are detected, each with two channels. On
 
 ### Opening a Bus
 
+> **Note:** `data_bitrate` is required even on a classic (non-FD) bus. On a non-FD bus, simply set it to e.g. `1_000_000` (1 Mbit/s).
+
+> **Tip:** Pass `listen_only=True` to `can.Bus` to monitor a bus without transmitting or acknowledging frames.
+
+> **Tip:** Pass `error_frames=True` to `can.Bus` to receive error frames.
+
 #### Single bus - hardcoded
 
 ```python
@@ -91,6 +108,22 @@ with (can.Bus(interface=configs[0]["interface"], channel=configs[0]["channel"],
 >     pass
 > ```
 
+### TLS / Certificates
+
+The data connection to the device is secured by TLS. When connecting via an IP address (where hostname verification will fail), `server_cert=None` can be used to disable certificate validation:
+
+```python
+with can.Bus(interface="cansub", channel="192.168.1.10@1", server_cert=None, bitrate=250_000, data_bitrate=1_000_000) as bus:
+    pass
+```
+
+If TLS mutual authentication is enabled, `client_cert` can be used to provide a tuple of paths to the client certificate (`.crt` file) and its unencrypted private key (`.key` file), i.e. `("cert", "key")`:
+
+```python
+with can.Bus(**configs[0], client_cert=("/path/to/client.crt", "/path/to/client.key"), bitrate=250_000, data_bitrate=1_000_000) as bus:
+    pass
+```
+
 ### Receive and Transmit
 
 ```python
@@ -105,6 +138,20 @@ with can.Bus(**configs[0], bitrate=250_000, data_bitrate=1_000_000) as bus:
     print(msg_rx)
 ```
 
+### Error Frames
+
+Error frame reporting is disabled by default; enable it by passing `error_frames=True` to `can.Bus`. Bus errors are then received as a `can.Message` with `is_error_frame` set. The error type is encoded in `arbitration_id`, which can be converted to a `CanSubErrorFrameType` enum:
+
+```python
+from python_can_cansub import CanSubErrorFrameType
+
+with can.Bus(**configs[0], bitrate=250_000, data_bitrate=1_000_000, error_frames=True) as bus:
+    msg = bus.recv(timeout=1.0)
+    if msg and msg.is_error_frame:
+        error_type = CanSubErrorFrameType(msg.arbitration_id)
+        print(f"Bus error: {error_type.name}")  # e.g. "Bus error: ACK"
+```
+
 ### Filters
 
 Apply hardware filters by passing `can_filters` to `can.Bus`. Each filter specifies a `can_id`, a `can_mask`, and whether to match standard (`extended=False`) or extended (`extended=True`) frames. A frame passes if `(frame_id & can_mask) == (can_id & can_mask)`.
@@ -173,6 +220,28 @@ with can.Bus(**configs[0], bitrate=250_000, data_bitrate=1_000_000) as bus:
             bus.send(msg)
 ```
 
+### CSV Logger
+
+On import, this package overrides the default python-can `.csv` reader and writer with a format compatible with the *webCAN* browser tool provided with the device. This applies automatically wherever `.csv` files are read or written, including `can.Logger`, `can.LogReader`, and the command-line tools.
+
+The writer (`CanSubCSVWriter`) and reader (`CanSubCSVReader`) can also be used directly:
+
+```python
+from python_can_cansub import CanSubCSVWriter, CanSubCSVReader
+
+# Write received messages to a webCAN-compatible CSV file
+with can.Bus(**configs[0], bitrate=250_000, data_bitrate=1_000_000) as bus:
+    with CanSubCSVWriter("log.csv") as writer:
+        msg = bus.recv(timeout=1.0)
+        if msg:
+            writer.on_message_received(msg)
+
+# Read messages back from the CSV file
+with CanSubCSVReader("log.csv") as reader:
+    for msg in reader:
+        print(msg)
+```
+
 ## python-can tools
 
 python-can includes several command line tools. All tools accept `--interface` and `--channel` to select the bus, following the same configuration as the API.

python_can_cansub-2026.7.2/private_repo/README_REPO.md

@@ -0,0 +1,43 @@
+# Repository Workflow Reminder
+
+This project uses a **private repository for development** and a **public repository for cleaned releases**.
+
+The private repository is hosted on Bitbucket while the public repository is hosted on GitHub (https://github.com/CSS-Electronics/python-can-cansub).
+
+## Branches
+
+- `master`: private development master. Full history. **Never pushed to the public repository.**
+- `public-master`: temporary local branch used only to build and push a public release.
+
+## Publish a Release
+
+1. Fetch the public master into a local `public-master`. No GitHub remote is added, which avoids accidental pushes:
+
+   ```bash
+   git fetch git@github.com:CSS-Electronics/python-can-cansub.git master:public-master
+   git checkout public-master
+   ```
+
+2. Bring the release changes over from the private branch **manually**. In CLion, open the private branch's **"Show Diff with Working Tree"** and pick the individual changes to include. Leave out anything private (e.g. the `private_repo/` folder).
+
+   > Do not use `git merge` / `git cherry-pick` — hand-picking keeps the public history clean and prevents private content leaking.
+
+3. Commit on `public-master`, then verify the diff against the private branch is exactly what should be public (versions in `CHANGELOG.md` and `pyproject.toml` match, no private files).
+
+4. Push straight to the public GitHub master:
+
+   ```bash
+   git push git@github.com:CSS-Electronics/python-can-cansub.git public-master:master
+   ```
+
+5. Delete the local `public-master` when done:
+
+   ```bash
+   git branch -D public-master
+   ```
+
+## Rule of Thumb
+
+- `master` = private full history.
+- `public-master` = throwaway branch, hand-curated per release.
+- Never push private `master` to the public repository.

{python_can_cansub-2026.6.2 → python_can_cansub-2026.7.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "python-can-cansub"
-version = "2026.06.02"
+version = "2026.07.02"
 authors = [
     { name="CSS Electronics" },
     { email="contact@csselectronics.com" },
@@ -37,6 +37,7 @@ csv = "python_can_cansub.cansub:CanSubCSVReader"
 [project.urls]
 "Homepage" = "https://csselectronics.com/"
 "Source" = "https://github.com/CSS-Electronics/python-can-cansub"
+"Changelog" = "https://github.com/CSS-Electronics/python-can-cansub/blob/master/CHANGELOG.md"
 
 [tool.pytest.ini_options]
 pythonpath = [

{python_can_cansub-2026.6.2 → python_can_cansub-2026.7.2}/src/python_can_cansub/cansub.py

@@ -8,10 +8,12 @@ import threading
 from pathlib import Path
 from datetime import datetime, timezone
 from time import time, sleep
-from typing import Optional, Sequence, TypedDict, Union, Callable, Generator, Any
+from typing import Optional, Sequence, Tuple, TypedDict, Union, Callable, Generator, Any
 from can import LimitedDurationCyclicSendTaskABC, BusABC, RestartableCyclicTaskABC
 from can.io.generic import TextIOMessageWriter, TextIOMessageReader
 from wsproto import ConnectionType, WSConnection, ConnectionState, events
+from zeroconf import InterfacesType, ServiceListener, Zeroconf, ServiceBrowser, InterfaceChoice, IPVersion
+
 from python_can_cansub.cansub_protocol import cansub_protocol_decode, cansub_protocol_encode
 
 CANSUB_ROOT_CERT: Path = Path(__file__).with_name("cansub_root_cert.crt")
@@ -26,7 +28,7 @@ CanSubHwFilters = Sequence[CanSubHwFilter]
 
 class CanSub(can.BusABC):
 
-    _supported_api_versions = ["02.00"]
+    _supported_api_versions = ["03.00"]
     _can_protocol = can.CanProtocol.CAN_FD_NON_ISO
     _can_f_clock = 80_000_000
 
@@ -40,12 +42,24 @@ class CanSub(can.BusABC):
                  listen_only: Optional[bool] = False,
                  auto_reset: Optional[bool] = True,
                  error_frames: Optional[bool] = False,
+                 server_cert: Optional[Union[str, Path]] = CANSUB_ROOT_CERT,
+                 client_cert: Optional[Tuple[Union[str, Path], Union[str, Path]]] = None,
                  **kwargs: object
                  ):
         """
         Python-can compatible interface over a websocket connection. Functions bus.send and bus.recv are made
         thread-safe by using queues.
 
+        :param channel:
+            The CAN channel to use. Can be an integer or a string. If a string contains '@',
+            it can specify both the device address and the channel (e.g., 'aabbccdd-usb.local@1').
+
+        :param can_filters:
+            Optional hardware filters to apply.
+
+        :param address:
+            The hostname or IP address of the device. If not provided, it must be part of the `channel` string.
+
         :param timing:
             CAN-bus bit-timing. Takes precedence over bitrate and data_bitrate.
 
@@ -64,6 +78,18 @@ class CanSub(can.BusABC):
         :param error_frames:
             CAN-bus error frame reporting.
 
+        :param server_cert:
+            Path to the server (device) public certificate (.crt file). If None, server verification is turned off.
+            Defaults to the built-in CANsub root certificate.
+
+        :param client_cert:
+            Tuple of paths to the client certificate (.crt file) and the unencrypted private key (.key file)
+            (i.e. ('cert', 'key')). Password protection is not supported.
+            Required when TLS mutual authentication is enabled.
+
+        :param kwargs:
+            Extra arguments passed to the parent `can.BusABC` class.
+
         """
 
         # To be able to use python-can command line tool without custom arguments, support that channel can contain
@@ -85,6 +111,41 @@ class CanSub(can.BusABC):
             host = address
             port = 443
 
+        # Server (device) certificate
+        if not isinstance(server_cert, (type(None), str, Path)):
+            raise can.exceptions.CanInitializationError("Invalid server_cert")
+
+        self.server_cert = Path(server_cert) if server_cert else None
+        del server_cert
+
+        if self.server_cert is not None:
+            if not self.server_cert.is_file():
+                raise can.exceptions.CanInitializationError(f"Server certificate not found: {self.server_cert}")
+            if self.server_cert.suffix.lower() != ".crt":
+                raise can.exceptions.CanInitializationError(f"Server certificate must be a .crt file: {self.server_cert}")
+
+        # Client certificate (mTLS)
+        if client_cert is not None:
+            if not (isinstance(client_cert, (tuple, list)) and len(client_cert) == 2
+                    and all(isinstance(p, (str, Path)) for p in client_cert)):
+                raise can.exceptions.CanInitializationError("Invalid client_cert")
+
+            self.client_cert = (Path(client_cert[0]), Path(client_cert[1]))
+        else:
+            self.client_cert = None
+        del client_cert
+
+        if self.client_cert is not None:
+            client_crt, client_key = self.client_cert
+            if not client_crt.is_file():
+                raise can.exceptions.CanInitializationError(f"Client certificate not found: {client_crt}")
+            if client_crt.suffix.lower() != ".crt":
+                raise can.exceptions.CanInitializationError(f"Client certificate must be a .crt file: {client_crt}")
+            if not client_key.is_file():
+                raise can.exceptions.CanInitializationError(f"Client key not found: {client_key}")
+            if client_key.suffix.lower() != ".key":
+                raise can.exceptions.CanInitializationError(f"Client key must be a .key file: {client_key}")
+
         # Channel
         self.channel = None
         if isinstance(channel, can.typechecking.ChannelInt):
@@ -136,16 +197,14 @@ class CanSub(can.BusABC):
         # Set channel info (required by python-can)
         self.channel_info = f"{address}@{self.channel}"
 
-        # Path to device root certificate
-        self.cansub_cert = str(CANSUB_ROOT_CERT)
-
         # Perform REST interaction with the device in a persistent session
         self.api_url = f"https://{host}:{port}/api"
         self._net_timeout = 3.0
 
         # Create persistent session for REST API calls
         self.session = requests.Session()
-        self.session.verify = self.cansub_cert
+        self.session.verify = str(self.server_cert) if self.server_cert else False
+        self.session.cert = (str(self.client_cert[0]), str(self.client_cert[1])) if self.client_cert else None
 
         # Get api version (and test connection)
         try:
@@ -217,7 +276,15 @@ class CanSub(can.BusABC):
             raise can.exceptions.CanInitializationError(f"Failed to configure channel ({e})")
 
         # Socket TLS configuration
-        ssl_context = ssl.create_default_context(cafile=self.cansub_cert)
+        if self.server_cert:
+            ssl_context = ssl.create_default_context(cafile=self.server_cert)
+        else:
+            ssl_context = ssl.create_default_context()
+            ssl_context.check_hostname = False
+            ssl_context.verify_mode = ssl.CERT_NONE
+
+        if self.client_cert:
+            ssl_context.load_cert_chain(certfile=self.client_cert[0], keyfile=self.client_cert[1])
 
         # Socket
         self.ws_sock = ssl_context.wrap_socket(sock=socket.socket(socket.AF_INET, socket.SOCK_STREAM), server_hostname=host)
@@ -655,8 +722,16 @@ class CanSub(can.BusABC):
 
     @staticmethod
     def _detect_available_configs() -> Sequence[can.typechecking.AutoDetectedConfig]:
-        from zeroconf import InterfaceChoice, ServiceBrowser, Zeroconf
+        return CanSub.mdns_discover(interfaces=InterfaceChoice.All)
 
+    @staticmethod
+    def mdns_discover(interfaces: InterfacesType = InterfaceChoice.All, discovery_time: float = 2.0) -> Sequence[can.typechecking.AutoDetectedConfig]:
+        """Discover available CANsub devices by performing a mDNS lookup.
+
+        @param interfaces: The interfaces to listen on. These must be either interface addresses or one of the zeroconf
+        InterfaceChoice enum values.
+        @return: A sequence of auto-detected CANbus configurations.
+        """
         # Collect DNS-SD service info objects keyed by service name.
         # The device firmware advertises _cansub._tcp with TXT records:
         #   api=<version>   - must match _supported_api_versions
@@ -665,7 +740,7 @@ class CanSub(can.BusABC):
         # e.g. 1b5b9343-usb.local (USB) or 1b5b9343-eth.local (Ethernet).
         discovered = {}
 
-        class _Listener:
+        class _Listener(ServiceListener):
             def add_service(self, zc, type_, name):
                 info = zc.get_service_info(type_, name)
                 if info:
@@ -673,12 +748,11 @@ class CanSub(can.BusABC):
             def remove_service(self, zc, type_, name): pass
             def update_service(self, zc, type_, name): pass
 
-        # Listen on all interfaces so devices on multiple USB/Ethernet links
-        # are all discovered (each CDC-NCM or Ethernet link is a separate interface).
-        zc = Zeroconf(interfaces=InterfaceChoice.All)
+        # Listen on all specified interfaces.
+        zc = Zeroconf(interfaces=interfaces, ip_version=IPVersion.V4Only, use_asyncio=False)
         try:
             ServiceBrowser(zc, "_cansub._tcp.local.", _Listener())
-            sleep(2.0)
+            sleep(discovery_time)
         finally:
             zc.close()
 
@@ -692,7 +766,13 @@ class CanSub(can.BusABC):
             }
 
             # Skip devices running an unsupported API version.
-            if txt.get("api") not in CanSub._supported_api_versions:
+            api_version = txt.get("api")
+            if api_version not in CanSub._supported_api_versions:
+                warnings.warn(
+                    f"Detected CANsub device {info.server.rstrip('.')} has an unsupported API version ({api_version}). "
+                    f"Supported versions: [{', '.join(CanSub._supported_api_versions)}]",
+                    UserWarning
+                )
                 continue
 
             # info.server has a trailing dot (DNS convention); strip it.
@@ -727,7 +807,6 @@ class CyclicSendTask(LimitedDurationCyclicSendTaskABC, RestartableCyclicTaskABC)
 
         self.transmit_api_url = f"{cansub.api_url}/can/{channel}/transmit"
         self._net_timeout = cansub._net_timeout
-        self.cansub_cert = cansub.cansub_cert
         self.session = cansub.session
 
         period_ms = int(len(self.messages) * self.period_ns / 1_000_000)
@@ -756,7 +835,7 @@ class CyclicSendTask(LimitedDurationCyclicSendTaskABC, RestartableCyclicTaskABC)
         }
 
         # Set up new transmit sequence
-        response = self.session.post(url=self.transmit_api_url, timeout=self._net_timeout, verify=self.cansub_cert,
+        response = self.session.post(url=self.transmit_api_url, timeout=self._net_timeout,
                                 json=transmit_sequence)
 
         if response.status_code != 201:
@@ -775,14 +854,13 @@ class CyclicSendTask(LimitedDurationCyclicSendTaskABC, RestartableCyclicTaskABC)
     def start(self) -> None:
         """Restart a stopped periodic task."""
         response = self.session.put(url=f"{self.transmit_api_url}/{self.transmit_id}/count", timeout=self._net_timeout,
-                                verify=self.cansub_cert, json=0)
+                                json=0)
         if response.status_code != 200:
             raise can.exceptions.CanOperationError(f"Failed to (re)start transmit sequence ({response.status_code})")
 
     def stop(self) -> None:
         """Stop periodic task."""
-        response = self.session.delete(url=f"{self.transmit_api_url}/{self.transmit_id}", timeout=self._net_timeout,
-                                   verify=self.cansub_cert)
+        response = self.session.delete(url=f"{self.transmit_api_url}/{self.transmit_id}", timeout=self._net_timeout)
         if response.status_code != 200:
             raise can.exceptions.CanOperationError(f"Failed to stop transmit sequence ({response.status_code})")
         return

python_can_cansub-2026.6.2/CHANGELOG.md

@@ -1,16 +0,0 @@
-# Changelog
-
-All notable changes to this project will be documented in this file.
-
-## 2026.06.02
-
-### Added
-- `CANSUB_ROOT_CERT`: path to the CANsub root certificate.
-
-### Changed
-- Transmit sequences (on the device) are deleted on bus open.
-
-## 2026.06.01
-
-### Fixed
-- `CyclicSendTask` with `duration=None` now working.

python_can_cansub-2026.6.2/private_repo/README_REPO.md

@@ -1,70 +0,0 @@
-# Repository Workflow Reminder
-
-This project uses a **private repository for development** and a **public repository for cleaned releases**.
-
-The private repository is hosted on Bitbucket while the public repository is hosted on GitHub (https://github.com/CSS-Electronics/python-can-cansub).
-
-## Branches
-
-### `master`
-
-Private development master.
-
-- Lives in the private repository.
-- Contains the full commit history.
-- Feature branches are reviewed and fast-forward merged here.
-- This branch is **not pushed to the public repository**.
-
-### `public-master`
-
-Clean public-ready master.
-
-- Lives in the private repository too.
-- Contains squashed/clean commits only.
-- This is the branch that gets pushed to the public repository's `master`.
-
-## Normal Development
-
-Work normally in the IDE using the private repository.
-
-## Prepare Public Version
-
-When a feature is ready for public release, squash it into `public-master`:
-
-```bash
-git checkout public-master
-git merge --squash feature/my-feature
-git commit -m "Add my feature"
-```
-
-Validate that `public-master` content and history is correct.
-
-Push the cleaned branch to the private repo:
-
-```bash
-git push origin public-master
-```
-
-## Push to Public Repository
-
-The public repository remote is not kept configured permanently.
-
-Push only when intentionally publishing:
-
-```bash
-git push git@github.com:CSS-Electronics/python-can-cansub.git public-master:master
-```
-
-This pushes:
-
-```text
-local/private public-master -> public repo master
-```
-
-## Rule of Thumb
-
-- `master` = private full history
-- `public-master` = clean squashed history
-- public repo `master` = copy of `public-master`
-
-Never push private `master` to the public repository.