pyspw-rmap 0.0.1__tar.gz

pyspw_rmap-0.0.1/.clang-format

@@ -0,0 +1,5 @@
+BasedOnStyle: Google
+ColumnLimit: 80
+IndentWidth: 2
+TabWidth: 2
+UseTab: Never

pyspw_rmap-0.0.1/.clang-tidy

@@ -0,0 +1,29 @@
+Checks:
+  - modernize-*
+  - bugprone-*
+  - cppcoreguidelines-*
+  - -bugprone-easily-swappable-parameters
+  - -cppcoreguidelines-avoid-magic-numbers
+  - -modernize-use-std-numbers
+  - -cppcoreguidelines-owning-memory
+  - -cppcoreguidelines-pro-type-vararg
+  - -cppcoreguidelines-pro-bounds-pointer-arithmetic
+  - -cppcoreguidelines-avoid-do-while
+
+WarningsAsErrors: '*'
+
+ExtraArgs:
+  - -nostdlibinc
+  - -isystem/nix/store/hv7qldswrqvg1sjys1lmgjg875hkffng-python3-3.13.9/include
+  - -isystem/nix/store/dg6ikmg5aavlpldk5yr0ka63y9ry1hb0-gtest-1.17.0-dev/include
+  - -isystem/nix/store/a3mw2msblrnfmdr9nmw8ysiqh2nl4fyl-python3-3.13.9-env/include
+  - -isystem/nix/store/qrqws7rbynwdg34kig3mp33rjsar32dd-libcxx-19.1.2+apple-sdk-15.5/include
+  - -isystem/nix/store/lzwcv5378dilf1bw4gkazy3h6hkp66gm-compiler-rt-libc-21.1.2-dev/include
+  - -isystem/nix/store/9zym1ak4fkg1jy6w63kq37x02da6vipb-libiconv-109.100.2-dev/include
+  - -isystem/nix/store/4spjp33v2kkahvwl9r09hlnr8ayw6wm3-libresolv-91-dev/include
+  - -isystem/nix/store/xhv6ncxn7ic2ir7pp6q1vs3q83kd6nc4-libsbuf-14.1.0-dev/include
+  - -isystem/nix/store/qrqws7rbynwdg34kig3mp33rjsar32dd-libcxx-19.1.2+apple-sdk-15.5/include/c++/v1
+  - -isystem/nix/store/b0pmskfnq9b3vfqqn2zr0kfp3lj17zaw-clang-wrapper-21.1.2/resource-root/include
+  - -isystem/nix/store/rrjy7x4jpxp92gs1prpbg79ng0mcl5hj-apple-sdk-14.4/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/usr/include
+  - -isystem/nix/store/rrjy7x4jpxp92gs1prpbg79ng0mcl5hj-apple-sdk-14.4/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/System/Library/Frameworks (framework directory)
+  - -isystem/nix/store/lm725blqlq4bjmfrxps1wdizgh3k4q6z-libSystem-B/include

pyspw_rmap-0.0.1/.clangd

@@ -0,0 +1,25 @@
+CompileFlags:
+  Add:
+    - -Wall
+    - -Werror
+    - -Wextra
+    - -Wpedantic
+    - -std=c++23
+    - -xc++
+    - -nostdlibinc
+    - -isystem/nix/store/hv7qldswrqvg1sjys1lmgjg875hkffng-python3-3.13.9/include
+    - -isystem/nix/store/dg6ikmg5aavlpldk5yr0ka63y9ry1hb0-gtest-1.17.0-dev/include
+    - -isystem/nix/store/a3mw2msblrnfmdr9nmw8ysiqh2nl4fyl-python3-3.13.9-env/include
+    - -isystem/nix/store/qrqws7rbynwdg34kig3mp33rjsar32dd-libcxx-19.1.2+apple-sdk-15.5/include
+    - -isystem/nix/store/lzwcv5378dilf1bw4gkazy3h6hkp66gm-compiler-rt-libc-21.1.2-dev/include
+    - -isystem/nix/store/9zym1ak4fkg1jy6w63kq37x02da6vipb-libiconv-109.100.2-dev/include
+    - -isystem/nix/store/4spjp33v2kkahvwl9r09hlnr8ayw6wm3-libresolv-91-dev/include
+    - -isystem/nix/store/xhv6ncxn7ic2ir7pp6q1vs3q83kd6nc4-libsbuf-14.1.0-dev/include
+    - -isystem/nix/store/qrqws7rbynwdg34kig3mp33rjsar32dd-libcxx-19.1.2+apple-sdk-15.5/include/c++/v1
+    - -isystem/nix/store/b0pmskfnq9b3vfqqn2zr0kfp3lj17zaw-clang-wrapper-21.1.2/resource-root/include
+    - -isystem/nix/store/rrjy7x4jpxp92gs1prpbg79ng0mcl5hj-apple-sdk-14.4/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/usr/include
+    - -isystem/nix/store/rrjy7x4jpxp92gs1prpbg79ng0mcl5hj-apple-sdk-14.4/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/System/Library/Frameworks (framework directory)
+    - -isystem/nix/store/lm725blqlq4bjmfrxps1wdizgh3k4q6z-libSystem-B/include
+
+
+  CompilationDatabase: ./build

pyspw_rmap-0.0.1/.envrc

@@ -0,0 +1 @@
+use flake

pyspw_rmap-0.0.1/.github/workflows/publish.yml

@@ -0,0 +1,57 @@
+name: Publish Python Package
+
+on:
+  push:
+    branches:
+      - main
+  release:
+    types:
+      - published
+
+permissions:
+  contents: read
+  id-token: write
+
+jobs:
+  publish-testpypi:
+    if: github.event_name == 'push'
+    runs-on: ubuntu-latest
+    env:
+      CMAKE_ARGS: -DSPWRMAP_BUILD_TESTS=OFF
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.x"
+      - name: Install build tooling
+        run: |
+          python -m pip install --upgrade pip
+          python -m pip install build
+      - name: Build distribution
+        run: python -m build
+      - name: Publish package to TestPyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          password: ${{ secrets.TEST_PYPI_API_TOKEN }}
+          repository-url: https://test.pypi.org/legacy/
+
+  publish-pypi:
+    if: github.event_name == 'release'
+    runs-on: ubuntu-latest
+    env:
+      CMAKE_ARGS: -DSPWRMAP_BUILD_TESTS=OFF
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.x"
+      - name: Install build tooling
+        run: |
+          python -m pip install --upgrade pip
+          python -m pip install build
+      - name: Build distribution
+        run: python -m build
+      - name: Publish package to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          password: ${{ secrets.PYPI_API_TOKEN }}

pyspw_rmap-0.0.1/.gitignore

@@ -0,0 +1,8 @@
+.DS_Store
+
+.direnv
+.cache
+
+build/
+result
+workdir/

pyspw_rmap-0.0.1/CMakeLists.txt

@@ -0,0 +1,65 @@
+cmake_minimum_required(VERSION 3.15)
+project(spw_rmap LANGUAGES CXX)
+
+set(CMAKE_POSITION_INDEPENDENT_CODE ON)
+
+option(SPWRMAP_BUILD_APPS "Build command line applications" ON)
+option(SPWRMAP_BUILD_EXAMPLES "Build examples" OFF)
+option(SPWRMAP_BUILD_TESTS "Build tests" ON)
+
+add_library(${PROJECT_NAME} STATIC)
+
+add_subdirectory(src)
+
+if(SPWRMAP_BUILD_APPS)
+  add_subdirectory(app)
+endif()
+
+if(SPWRMAP_BUILD_EXAMPLES)
+  add_subdirectory(examples)
+endif()
+
+if(SPWRMAP_BUILD_TESTS)
+  enable_testing()
+  add_subdirectory(tests)
+endif()
+
+if(SPWRMAP_BUILD_PYTHON_BINDINGS)
+  add_subdirectory(bindings/python)
+endif()
+
+include(CMakePackageConfigHelpers)
+
+install(
+  TARGETS ${PROJECT_NAME}
+  EXPORT spw_rmapTargets
+  INCLUDES
+  DESTINATION include
+  ARCHIVE DESTINATION lib)
+
+install(
+  EXPORT spw_rmapTargets
+  FILE spw_rmapTargets.cmake
+  NAMESPACE spw_rmap::
+  DESTINATION lib/cmake/spw_rmap)
+
+configure_package_config_file(
+  ${CMAKE_CURRENT_SOURCE_DIR}/cmake/spw_rmapConfig.cmake.in
+  ${CMAKE_CURRENT_BINARY_DIR}/spw_rmapConfig.cmake
+  INSTALL_DESTINATION lib/cmake/spw_rmap)
+
+write_basic_package_version_file(
+  ${CMAKE_CURRENT_BINARY_DIR}/spw_rmapConfigVersion.cmake
+  VERSION 0.0.1
+  COMPATIBILITY SameMajorVersion)
+
+file(GLOB HEADER_FILES ${CMAKE_SOURCE_DIR}/include/spw_rmap/*.hh)
+file(GLOB HEADER_FILES_INTERNAL
+     ${CMAKE_SOURCE_DIR}/include/spw_rmap/internal/*.hh)
+
+install(FILES ${HEADER_FILES} DESTINATION include/spw_rmap)
+install(FILES ${HEADER_FILES_INTERNAL} DESTINATION include/spw_rmap/internal)
+
+install(FILES ${CMAKE_CURRENT_BINARY_DIR}/spw_rmapConfig.cmake
+              ${CMAKE_CURRENT_BINARY_DIR}/spw_rmapConfigVersion.cmake
+        DESTINATION lib/cmake/spw_rmap)

pyspw_rmap-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Gen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pyspw_rmap-0.0.1/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.2
+Name: pyspw_rmap
+Version: 0.0.1
+Summary: spw_rmap with python bindings
+License: MIT
+Requires-Python: >=3.9
+

pyspw_rmap-0.0.1/README.md

@@ -0,0 +1,171 @@
+# spw_rmap
+
+`spw_rmap` is a SpaceWire/RMAP helper library that provides packet builders/parsers, a TCP transport, CLI utilities, and Python bindings.
+
+## Building
+
+```bash
+cmake -S . -B build
+cmake --build build
+```
+
+Key CMake options:
+
+- `SPWRMAP_BUILD_APPS` (default `ON`): build the `spwrmap` and `spwrmap_speedtest` CLI tools.
+- `SPWRMAP_BUILD_EXAMPLES` (default `OFF`): enable examples under `examples/`.
+- `SPWRMAP_BUILD_TESTS` (default `ON`): add the `tests` subdirectory and register the GTest suite.
+- `SPWRMAP_BUILD_PYTHON_BINDINGS` (default `OFF`): build the pybind11 module (also enabled when using `pyproject.toml` / `scikit-build-core`).
+
+## Testing
+
+```bash
+cmake --build build --target spwrmap_tests
+cd build
+ctest --output-on-failure
+```
+
+Some TCP tests require the ability to bind a local port; they will be skipped automatically when the environment forbids that operation (e.g., in sandboxed CI).
+
+## Python bindings
+
+To build the wheel:
+
+```bash
+python -m pip install .  # uses pyproject + scikit-build-core
+```
+
+The resulting package exposes `_core.SpwRmapTCPNode` mirroring the C++ API.
+
+## Key Concepts
+
+- `target_node`: abstraction describing a SpaceWire node address (logical address, SpaceWire hop list, reply path). Implemented by `TargetNodeBase` with fixed/dynamic variants so the same transport can talk to different hardware endpoints.
+- `tcp_node`: the SpaceWire-over-TCP bridge (`SpwRmapTCPClient`/`SpwRmapTCPServer`) that owns the sockets, buffers, and RMAP transaction management.
+- `write` / `read`: synchronous helpers that perform the transaction, block until a reply arrives (or timeout/retry), and return `std::expected` success/error codes.
+- `writeAsync` / `readAsync`: asynchronous variants returning `std::future` that resolve when the reply is received; they invoke user-supplied callbacks before fulfilling the future so event-driven integrations can react immediately.
+
+See `examples/spwrmap_example.cc` (C++) and `examples/spwrmap_example.py` (Python) for minimal workflows demonstrating how to connect, construct a target node, and issue read/write RMAP commands.
+
+# Quick Start Guide
+
+## C++
+
+### Initialize spw
+
+```cpp
+#include <chrono>
+#include <memory>
+#include <thread>
+#include <vector>
+
+#include <spw_rmap/spw_rmap_tcp_node.hh>
+#include <spw_rmap/target_node.hh>
+
+int main() {
+  using namespace std::chrono_literals;
+
+  spw_rmap::SpwRmapTCPClient client(
+      {.ip_address = "127.0.0.1", .port = "10030"});
+
+  client.setInitiatorLogicalAddress(0xFE);
+  client.connect(500ms).value();  // abort on failure
+
+  std::thread loop([&client] {
+    auto res = client.runLoop();
+    if (!res) {
+      throw std::system_error(res.error());
+    }
+  });
+
+  // ...
+
+  client.shutdown();
+  if (loop.joinable()) {
+    loop.join();
+  }
+}
+```
+
+You can also call `poll()` manually from your own loop instead of spawning a thread.
+
+### Creating target node
+
+```cpp
+auto target = std::make_shared<spw_rmap::TargetNodeDynamic>(
+    /*logical_address=*/0x34,
+    std::vector<uint8_t>{3, 5, 7},        // SpaceWire hops
+    std::vector<uint8_t>{9, 11, 13, 0x0}  // Reply path
+);
+```
+
+`TargetNodeFixed<N,M>` is available when the address sizes are known at compile time.
+
+### Read and write
+
+```cpp
+std::array<uint8_t, 4> write_payload{0x12, 0x34, 0x56, 0x78};
+client.write(target, /*address=*/0x20000000, write_payload).value();
+
+std::array<uint8_t, 4> read_buffer{};
+client.read(target, 0x20000000, std::span(read_buffer)).value();
+
+auto read_future =
+    client.readAsync(target, 0x20000000, /*length=*/4,
+                     [](spw_rmap::Packet packet) {
+                       std::cout << "Async read returned "
+                                 << packet.data.size() << " bytes\n";
+                     });
+read_future.get().value();
+
+auto write_future =
+    client.writeAsync(target, 0x20000000, std::span(write_payload),
+                      [](const spw_rmap::Packet&) {
+                        std::cout << "Async write acknowledged\n";
+                      });
+write_future.get().value();
+```
+
+`write`/`read` are *synchronous*: they transmit the command, block until a reply is parsed (with retries/timeouts handled internally), and return `std::expected`.  
+`writeAsync`/`readAsync` are *asynchronous*: they enqueue the transaction, immediately return a `std::future`, and invoke the supplied callback as soon as the reply arrives—before the future resolves—allowing low-latency event handling.
+
+## Python
+
+### Initialize spw
+
+```python
+from pyspw_rmap import _core as spw
+
+node = spw.SpwRmapTCPNode("127.0.0.1", "10030")
+node.start()  # connects and launches runLoop internally
+```
+
+Call `node.stop()` to shut down and join the worker thread. Manual polling isn’t exposed in Python; launch `start()` once and let the worker handle replies.
+
+### Creating target node
+
+```python
+target = spw.TargetNode()
+target.logical_address = 0x34
+target.target_spacewire_address = [3, 5, 7]
+target.reply_address = [9, 11, 13, 0]
+```
+
+### Read and write
+
+```python
+# blocking write/read; no async API is exposed in Python
+node.write(target, 0x20000000, [0x12, 0x34, 0x56, 0x78])
+data = node.read(target, 0x20000000, 4)
+print("sync read:", list(data))
+
+node.stop()
+
+## Timeouts and Error Handling
+
+- `write` / `read` accept a `timeout` (default 100 ms) and a `retry_count`. When the timeout expires the pending transaction is cancelled internally, its transaction ID is released, and the call returns `std::errc::timed_out`. This prevents deadlocks when a remote node never replies.
+
+- Asynchronous APIs propagate callback failures: if the function you pass to `writeAsync` / `readAsync` throws, the exception is caught by the library, the transaction is cancelled, and the returned `std::future` resolves to `std::errc::operation_canceled`. This keeps the polling loop alive and makes the failure visible to the caller. Catch exceptions inside your callback if you want to mark the operation successful despite local errors.
+```
+
+Python bindings currently offer only synchronous `read`/`write` methods. To parallelize operations you must call them from your own threads or processes; there is no built-in async wrapper.
+
+The [examples](examples) directory contains CLI programs that parse command-line arguments, manage the lifecycle for you, and show additional patterns (speed tests, multi-target setups, etc.).

pyspw_rmap-0.0.1/app/CMakeLists.txt

@@ -0,0 +1,12 @@
+add_executable(spwrmap_cli spwrmap.cc)
+target_link_libraries(spwrmap_cli PRIVATE spw_rmap)
+target_compile_features(spwrmap_cli PRIVATE cxx_std_23)
+set_target_properties(spwrmap_cli PROPERTIES OUTPUT_NAME spwrmap)
+
+add_executable(spwrmap_speedtest_cli spwrmap_speedtest.cc)
+target_link_libraries(spwrmap_speedtest_cli PRIVATE spw_rmap)
+target_compile_features(spwrmap_speedtest_cli PRIVATE cxx_std_23)
+set_target_properties(spwrmap_speedtest_cli PROPERTIES
+                      OUTPUT_NAME spwrmap_speedtest)
+
+install(TARGETS spwrmap_cli spwrmap_speedtest_cli RUNTIME DESTINATION bin)