motor-drive-layer 0.5.10__tar.gz

motor_drive_layer-0.5.10/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Motor-Drive-Layer
+
+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.

motor_drive_layer-0.5.10/PKG-INFO

@@ -0,0 +1,90 @@
+Metadata-Version: 2.4
+Name: motor-drive-layer
+Version: 0.5.10
+Summary: Python SDK for the Motor-Drive-Layer C++ ABI
+Author: Motor-Drive-Layer contributors
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/TheYoungW/Motor-Drive-Layer
+Project-URL: Repository, https://github.com/TheYoungW/Motor-Drive-Layer
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+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: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: test
+Requires-Dist: pytest>=7; extra == "test"
+Dynamic: license-file
+
+# motor-drive-layer
+
+Python bindings for the Motor-Drive-Layer native C++ Damiao motor driver.
+
+The package loads the bundled C ABI library through Python `ctypes` and exposes
+SocketCAN, SocketCAN-FD, Damiao serial bridge, and optional DM_Device transports.
+Published wheels cover Linux x86_64/ARM64, macOS Intel/Apple Silicon, and Windows x64. The serial
+transport is cross-platform; SocketCAN transports remain Linux-only.
+
+DM-USB2FDCAN Dual works with its original `dual_app` firmware through
+`Controller.from_dm_device(device="usb2canfd-dual", channel=0, bitrate=1_000_000,
+data_bitrate=5_000_000)`. CH0 and CH1 are independently selectable, old positional arguments remain
+compatible, and the loader probes both vendor v1.0 and v1.1 ABIs. Install the separate vendor
+runtime with `motor-drive-layer-install-dm-device --download` or set `MOTOR_DM_DEVICE_LIB`.
+On final Controller close, v1.1 fully tears down its device session. The Linux v1.0 runtime instead
+closes the selected channels and motor-layer resources but retains its legacy context/device until
+process exit, allowing a later `Controller.from_dm_device(...)` call to reconnect reliably in the
+same Python process. A process-scope cleanup closes and destroys those retained vendor objects at
+normal process exit.
+
+Use `Motor.request_fresh_state(timeout_ms=50)` when the caller must wait for a newly requested
+feedback frame. For multiple motors, `Controller.request_feedback_all(timeout_ms=50)` sends every
+request with the configured TX pacing and waits against one shared deadline; a timeout reports the
+missing motor IDs. The lower-level `request_feedback()`, `get_state()`, and
+`poll_feedback_once()` methods remain non-blocking asynchronous/cache operations.
+
+For synchronized multi-channel control, `ControllerGroup([ch0, ch1])` creates one persistent
+native worker per Controller. `send_pos_vel([...])` and `send_mit([...])` dispatch typed
+`PosVelCommand` or `MitCommand` values across their owning controllers, overlap independent TX
+pacing waits, and return after every controller finishes. Errors retain the controller/channel,
+motor ID, and native reason.
+For fixed high-rate layouts, `prepare_pos_vel(motors)` and `prepare_mit(motors)` reuse one validated
+ctypes command array across calls. `Controller.transport_capabilities()` reports the active
+transport's CAN-FD, channel, parallel-send, reconnect, session-reuse, and timestamp capabilities.
+`Controller.transport_health()` reports live connection state, TX/RX counters, errors, and last
+activity ages without adding robot-product policy to the transport layer.
+
+The `motor-drive-layer-stress` command provides a feedback-only DM_Device load/reconnect test and
+reports latency plus Linux file-descriptor/thread counts. It never enables or commands motors.
+
+The wheel includes `py.typed` and `.pyi` declarations for editor completion and static type
+checking. The main public APIs are:
+
+- `Controller(...)`, `from_socketcanfd(...)`, `from_dm_serial(...)`, and `from_dm_device(...)`.
+- `Controller.add_damiao_motor(...)`, `enable_all()`, `disable_all()`,
+  `request_feedback_all()`, `set_tx_gap_us()`, `transport_capabilities()`, `shutdown()`, and
+  `close_bus()`.
+- `ControllerGroup(...)`, `send_pos_vel(...)`, and `send_mit(...)` for persistent native
+  multi-controller dispatch, plus reusable prepared batches for fixed layouts.
+- `Motor.enable()`, `disable()`, `ensure_mode()`, all four control-mode send methods,
+  fresh/cached feedback methods, typed register access, parameter aliases, and
+  `store_parameters()`.
+- `MitCommand`, `PosVelCommand`, `MotorState`, `FeedbackStats`, `Mode`, register
+  metadata/constants, and SDK exception classes.
+
+`Motor` is a logical child of its creating `Controller`. After the parent closes, motor operations
+raise `CallError`; `motor.close()` can still release the handle. Both classes support context
+managers. Leaving a Motor context only frees its handle, while leaving a Controller context attempts
+to disable all motors before closing the bus.
+
+See the [project README](https://github.com/TheYoungW/Motor-Drive-Layer)
+for build instructions, architecture, configuration, safety guidance, and examples.
+
+This package is distributed under the MIT License. The optional DM_Device vendor
+runtime is distributed separately and may have its own license terms.

motor_drive_layer-0.5.10/README.md

@@ -0,0 +1,65 @@
+# motor-drive-layer
+
+Python bindings for the Motor-Drive-Layer native C++ Damiao motor driver.
+
+The package loads the bundled C ABI library through Python `ctypes` and exposes
+SocketCAN, SocketCAN-FD, Damiao serial bridge, and optional DM_Device transports.
+Published wheels cover Linux x86_64/ARM64, macOS Intel/Apple Silicon, and Windows x64. The serial
+transport is cross-platform; SocketCAN transports remain Linux-only.
+
+DM-USB2FDCAN Dual works with its original `dual_app` firmware through
+`Controller.from_dm_device(device="usb2canfd-dual", channel=0, bitrate=1_000_000,
+data_bitrate=5_000_000)`. CH0 and CH1 are independently selectable, old positional arguments remain
+compatible, and the loader probes both vendor v1.0 and v1.1 ABIs. Install the separate vendor
+runtime with `motor-drive-layer-install-dm-device --download` or set `MOTOR_DM_DEVICE_LIB`.
+On final Controller close, v1.1 fully tears down its device session. The Linux v1.0 runtime instead
+closes the selected channels and motor-layer resources but retains its legacy context/device until
+process exit, allowing a later `Controller.from_dm_device(...)` call to reconnect reliably in the
+same Python process. A process-scope cleanup closes and destroys those retained vendor objects at
+normal process exit.
+
+Use `Motor.request_fresh_state(timeout_ms=50)` when the caller must wait for a newly requested
+feedback frame. For multiple motors, `Controller.request_feedback_all(timeout_ms=50)` sends every
+request with the configured TX pacing and waits against one shared deadline; a timeout reports the
+missing motor IDs. The lower-level `request_feedback()`, `get_state()`, and
+`poll_feedback_once()` methods remain non-blocking asynchronous/cache operations.
+
+For synchronized multi-channel control, `ControllerGroup([ch0, ch1])` creates one persistent
+native worker per Controller. `send_pos_vel([...])` and `send_mit([...])` dispatch typed
+`PosVelCommand` or `MitCommand` values across their owning controllers, overlap independent TX
+pacing waits, and return after every controller finishes. Errors retain the controller/channel,
+motor ID, and native reason.
+For fixed high-rate layouts, `prepare_pos_vel(motors)` and `prepare_mit(motors)` reuse one validated
+ctypes command array across calls. `Controller.transport_capabilities()` reports the active
+transport's CAN-FD, channel, parallel-send, reconnect, session-reuse, and timestamp capabilities.
+`Controller.transport_health()` reports live connection state, TX/RX counters, errors, and last
+activity ages without adding robot-product policy to the transport layer.
+
+The `motor-drive-layer-stress` command provides a feedback-only DM_Device load/reconnect test and
+reports latency plus Linux file-descriptor/thread counts. It never enables or commands motors.
+
+The wheel includes `py.typed` and `.pyi` declarations for editor completion and static type
+checking. The main public APIs are:
+
+- `Controller(...)`, `from_socketcanfd(...)`, `from_dm_serial(...)`, and `from_dm_device(...)`.
+- `Controller.add_damiao_motor(...)`, `enable_all()`, `disable_all()`,
+  `request_feedback_all()`, `set_tx_gap_us()`, `transport_capabilities()`, `shutdown()`, and
+  `close_bus()`.
+- `ControllerGroup(...)`, `send_pos_vel(...)`, and `send_mit(...)` for persistent native
+  multi-controller dispatch, plus reusable prepared batches for fixed layouts.
+- `Motor.enable()`, `disable()`, `ensure_mode()`, all four control-mode send methods,
+  fresh/cached feedback methods, typed register access, parameter aliases, and
+  `store_parameters()`.
+- `MitCommand`, `PosVelCommand`, `MotorState`, `FeedbackStats`, `Mode`, register
+  metadata/constants, and SDK exception classes.
+
+`Motor` is a logical child of its creating `Controller`. After the parent closes, motor operations
+raise `CallError`; `motor.close()` can still release the handle. Both classes support context
+managers. Leaving a Motor context only frees its handle, while leaving a Controller context attempts
+to disable all motors before closing the bus.
+
+See the [project README](https://github.com/TheYoungW/Motor-Drive-Layer)
+for build instructions, architecture, configuration, safety guidance, and examples.
+
+This package is distributed under the MIT License. The optional DM_Device vendor
+runtime is distributed separately and may have its own license terms.

motor_drive_layer-0.5.10/pyproject.toml

@@ -0,0 +1,50 @@
+[build-system]
+requires = ["setuptools>=77.0.3", "wheel>=0.43"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "motor-drive-layer"
+dynamic = ["version"]
+description = "Python SDK for the Motor-Drive-Layer C++ ABI"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Motor-Drive-Layer contributors" }]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3 :: Only",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
+  "Operating System :: MacOS",
+  "Operating System :: Microsoft :: Windows",
+  "Operating System :: POSIX :: Linux",
+]
+
+[tool.setuptools.dynamic]
+version = { attr = "motor_drive_layer._version.VERSION" }
+
+[project.urls]
+Homepage = "https://github.com/TheYoungW/Motor-Drive-Layer"
+Repository = "https://github.com/TheYoungW/Motor-Drive-Layer"
+
+[project.scripts]
+motor-drive-layer = "motor_drive_layer.cli:main"
+motor-drive-layer-cli = "motor_drive_layer.cli:main"
+motor-drive-layer-install-dm-device = "motor_drive_layer.dm_device_runtime:main"
+motor-drive-layer-stress = "motor_drive_layer.stress:main"
+
+[project.optional-dependencies]
+test = ["pytest>=7"]
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+motor_drive_layer = ["lib/*", "lib/dm_device/*", "*.pyi", "py.typed"]

motor_drive_layer-0.5.10/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

motor_drive_layer-0.5.10/setup.py

@@ -0,0 +1,141 @@
+import os
+import platform
+import shutil
+import sys
+from pathlib import Path
+
+from setuptools import Distribution, setup
+from setuptools.command.bdist_wheel import bdist_wheel as _bdist_wheel
+from setuptools.command.build_py import build_py as _build_py
+
+
+def _platform_lib_name() -> str:
+    if sys.platform.startswith("win"):
+        return "motor_abi.dll"
+    if sys.platform == "darwin":
+        return "libmotor_abi.dylib"
+    return "libmotor_abi.so"
+
+
+def _dm_device_platform_relpath() -> Path | None:
+    machine = platform.machine().lower()
+    if sys.platform.startswith("linux"):
+        if machine in {"x86_64", "amd64"}:
+            return Path("linux/x86_64/libdm_device.so")
+        if machine in {"aarch64", "arm64"}:
+            return Path("linux/arm64/libdm_device.so")
+    if sys.platform == "darwin":
+        if machine in {"arm64", "aarch64"}:
+            return Path("macos/arm64/libdm_device.dylib")
+        if machine in {"x86_64", "amd64"}:
+            return Path("macos/x86_64/libdm_device.dylib")
+    if sys.platform.startswith("win") and machine in {"x86_64", "amd64"}:
+        return Path("windows/msvc/dm_device.dll")
+    return None
+
+
+def _candidate_dm_device_paths() -> list[Path]:
+    here = Path(__file__).resolve()
+    repo_root = here.parents[2]
+    rel = _dm_device_platform_relpath()
+    candidates: list[Path] = []
+
+    env = os.getenv("MOTOR_DM_DEVICE_LIB")
+    if env:
+        candidates.append(Path(env).expanduser())
+
+    if rel is None:
+        return candidates
+
+    candidates.append(repo_root / "third_party" / "dm_device" / "v1.1.0" / rel)
+    candidates.append(repo_root / "dm-device-sdk" / "C&C++" / "lib" / "v1.1.0" / rel)
+    candidates.append(repo_root.parent / "dm-device-sdk" / "C&C++" / "lib" / "v1.1.0" / rel)
+    if sys.platform.startswith("linux"):
+        legacy_rel = Path("linux/libdm_device.so") if platform.machine().lower() in {"x86_64", "amd64"} else Path("aarch64/libdm_device.so")
+        candidates.append(repo_root / "third_party" / "dm_device" / "v1.0.0" / legacy_rel)
+        candidates.append(repo_root / "dm-device-sdk" / "C&C++" / "lib" / "v1.0.0" / legacy_rel)
+        candidates.append(repo_root.parent / "dm-device-sdk" / "C&C++" / "lib" / "v1.0.0" / legacy_rel)
+    candidates.append(here.parent / "src" / "motor_drive_layer" / "lib" / "dm_device" / rel.name)
+    return candidates
+
+
+def _bundle_dm_device_runtime() -> bool:
+    raw = os.getenv("MOTOR_DM_DEVICE_BUNDLE", "0").strip().lower()
+    return raw not in {"0", "false", "off", "no"}
+
+
+def _find_dm_device_path() -> Path | None:
+    if not _bundle_dm_device_runtime():
+        return None
+    for path in _candidate_dm_device_paths():
+        if path.exists():
+            return path
+    return None
+
+
+def _candidate_abi_paths() -> list[Path]:
+    here = Path(__file__).resolve()
+    repo_root = here.parents[2]
+    lib_name = _platform_lib_name()
+    candidates: list[Path] = []
+
+    env = os.getenv("MOTOR_DRIVE_LAYER_LIB")
+    if env:
+        candidates.append(Path(env).expanduser())
+
+    candidates.append(repo_root / "cpp_damiao" / "build" / lib_name)
+    candidates.append(repo_root / "cpp_damiao" / "build" / "Release" / lib_name)
+    candidates.append(here.parent / "src" / "motor_drive_layer" / "lib" / lib_name)
+    return candidates
+
+
+def _resolve_abi_path() -> Path:
+    for p in _candidate_abi_paths():
+        if p.exists():
+            return p
+    tried = "\n".join(f"- {p}" for p in _candidate_abi_paths())
+    raise RuntimeError(
+        "Cannot locate motor_abi shared library for wheel build.\n"
+        f"Tried:\n{tried}\n"
+        "Build ABI first (`cmake -S cpp_damiao -B cpp_damiao/build && cmake --build cpp_damiao/build`) "
+        "or set MOTOR_DRIVE_LAYER_LIB."
+    )
+
+
+class BuildPyWithAbi(_build_py):
+    def run(self):
+        super().run()
+        abi_src = _resolve_abi_path()
+        dst_dir = Path(self.build_lib) / "motor_drive_layer" / "lib"
+        if dst_dir.exists():
+            shutil.rmtree(dst_dir)
+        dst_dir.mkdir(parents=True, exist_ok=True)
+        shutil.copy2(abi_src, dst_dir / abi_src.name)
+
+        dm_src = _find_dm_device_path()
+        if dm_src is not None:
+            dm_dst_dir = dst_dir / "dm_device"
+            dm_dst_dir.mkdir(parents=True, exist_ok=True)
+            shutil.copy2(dm_src, dm_dst_dir / dm_src.name)
+
+class BdistWheelWithAbi(_bdist_wheel):
+    def finalize_options(self):
+        super().finalize_options()
+        self.root_is_pure = False
+
+    def get_tag(self):
+        _, _, platform_tag = super().get_tag()
+        return "py3", "none", platform_tag
+
+
+class BinaryDistribution(Distribution):
+    """Install the ctypes shared library into platlib, not purelib."""
+
+    def has_ext_modules(self) -> bool:
+        return True
+
+
+setup(
+    cmdclass={"build_py": BuildPyWithAbi, "bdist_wheel": BdistWheelWithAbi},
+    distclass=BinaryDistribution,
+)

motor_drive_layer-0.5.10/src/motor_drive_layer/__init__.py

@@ -0,0 +1,109 @@
+from importlib import import_module
+
+from .abi import abi_capabilities, abi_version
+from .core import (
+    Controller,
+    ControllerGroup,
+    Motor,
+    PreparedMitBatch,
+    PreparedPosVelBatch,
+)
+from .dm_device_runtime import ensure_dm_device_runtime
+from .errors import AbiLoadError, CallError, MotorBridgeError
+from .models import (
+    FeedbackStats,
+    MitCommand,
+    Mode,
+    MotorState,
+    PosVelCommand,
+    TransportCapabilities,
+    TransportHealth,
+)
+from ._version import VERSION
+
+
+_REGISTER_EXPORTS = {
+    "RegisterSpec",
+    "DAMIAO_RW_REGISTERS",
+    "DAMIAO_HIGH_IMPACT_RIDS",
+    "DAMIAO_PROTECTION_RIDS",
+    "get_damiao_register_spec",
+    "RID_CTRL_MODE",
+    "RID_MST_ID",
+    "RID_ESC_ID",
+    "RID_TIMEOUT",
+    "RID_PMAX",
+    "RID_VMAX",
+    "RID_TMAX",
+    "RID_KP_ASR",
+    "RID_KI_ASR",
+    "RID_KP_APR",
+    "RID_KI_APR",
+    "MODE_MIT",
+    "MODE_POS_VEL",
+    "MODE_VEL",
+    "MODE_FORCE_POS",
+}
+
+
+def __getattr__(name: str):
+    if name in _REGISTER_EXPORTS:
+        module = import_module(".damiao_registers", __name__)
+        value = getattr(module, name)
+        globals()[name] = value
+        return value
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+def __dir__() -> list[str]:
+    return sorted(set(globals()) | _REGISTER_EXPORTS)
+
+
+def get_version() -> str:
+    return VERSION
+
+
+__version__ = get_version()
+
+__all__ = [
+    "__version__",
+    "get_version",
+    "abi_version",
+    "abi_capabilities",
+    "ensure_dm_device_runtime",
+    "Controller",
+    "ControllerGroup",
+    "PreparedMitBatch",
+    "PreparedPosVelBatch",
+    "Motor",
+    "Mode",
+    "MotorState",
+    "FeedbackStats",
+    "MitCommand",
+    "PosVelCommand",
+    "TransportCapabilities",
+    "TransportHealth",
+    "RegisterSpec",
+    "DAMIAO_RW_REGISTERS",
+    "DAMIAO_HIGH_IMPACT_RIDS",
+    "DAMIAO_PROTECTION_RIDS",
+    "get_damiao_register_spec",
+    "RID_CTRL_MODE",
+    "RID_MST_ID",
+    "RID_ESC_ID",
+    "RID_TIMEOUT",
+    "RID_PMAX",
+    "RID_VMAX",
+    "RID_TMAX",
+    "RID_KP_ASR",
+    "RID_KI_ASR",
+    "RID_KP_APR",
+    "RID_KI_APR",
+    "MODE_MIT",
+    "MODE_POS_VEL",
+    "MODE_VEL",
+    "MODE_FORCE_POS",
+    "MotorBridgeError",
+    "AbiLoadError",
+    "CallError",
+]

motor_drive_layer-0.5.10/src/motor_drive_layer/__init__.pyi

@@ -0,0 +1,48 @@
+from .abi import abi_capabilities as abi_capabilities, abi_version as abi_version
+from .core import (
+    Controller as Controller,
+    ControllerGroup as ControllerGroup,
+    Motor as Motor,
+    PreparedMitBatch as PreparedMitBatch,
+    PreparedPosVelBatch as PreparedPosVelBatch,
+)
+from .damiao_registers import (
+    DAMIAO_HIGH_IMPACT_RIDS as DAMIAO_HIGH_IMPACT_RIDS,
+    DAMIAO_PROTECTION_RIDS as DAMIAO_PROTECTION_RIDS,
+    DAMIAO_RW_REGISTERS as DAMIAO_RW_REGISTERS,
+    MODE_FORCE_POS as MODE_FORCE_POS,
+    MODE_MIT as MODE_MIT,
+    MODE_POS_VEL as MODE_POS_VEL,
+    MODE_VEL as MODE_VEL,
+    RID_CTRL_MODE as RID_CTRL_MODE,
+    RID_ESC_ID as RID_ESC_ID,
+    RID_KI_APR as RID_KI_APR,
+    RID_KI_ASR as RID_KI_ASR,
+    RID_KP_APR as RID_KP_APR,
+    RID_KP_ASR as RID_KP_ASR,
+    RID_MST_ID as RID_MST_ID,
+    RID_PMAX as RID_PMAX,
+    RID_TMAX as RID_TMAX,
+    RID_TIMEOUT as RID_TIMEOUT,
+    RID_VMAX as RID_VMAX,
+    RegisterSpec as RegisterSpec,
+    get_damiao_register_spec as get_damiao_register_spec,
+)
+from .dm_device_runtime import ensure_dm_device_runtime as ensure_dm_device_runtime
+from .errors import (
+    AbiLoadError as AbiLoadError,
+    CallError as CallError,
+    MotorBridgeError as MotorBridgeError,
+)
+from .models import (
+    FeedbackStats as FeedbackStats,
+    MitCommand as MitCommand,
+    Mode as Mode,
+    MotorState as MotorState,
+    PosVelCommand as PosVelCommand,
+    TransportCapabilities as TransportCapabilities,
+    TransportHealth as TransportHealth,
+)
+
+__version__: str
+def get_version() -> str: ...

motor_drive_layer-0.5.10/src/motor_drive_layer/__main__.py

@@ -0,0 +1,5 @@
+from .cli import main
+
+
+if __name__ == "__main__":
+    main()

motor_drive_layer-0.5.10/src/motor_drive_layer/_version.py

@@ -0,0 +1 @@
+VERSION = "0.5.10"