pycan-send 0.0.1__tar.gz

pycan_send-0.0.1/.gitignore

@@ -0,0 +1 @@
+__pycache__/

pycan_send-0.0.1/LICENSE.txt

@@ -0,0 +1,9 @@
+pycan-send, Send can-frames encoded according to a KCD database
+Copyright (c) 2025-present Alexander Becker <nabla.becker@mailbox.org>
+
+This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along with this program. If not, see <https://www.gnu.org/licenses/>.
+

pycan_send-0.0.1/PKG-INFO

@@ -0,0 +1,72 @@
+Metadata-Version: 2.4
+Name: pycan-send
+Version: 0.0.1
+Summary: Command line tool that quickly lets you send a can frame using the message and signal names encoded in a KCD
+Project-URL: Documentation, https://sr.ht/~laplace/pycan-send#readme
+Project-URL: Issues, https://sr.ht/~laplace/pycan-send/issues
+Project-URL: Source, https://sr.ht/~laplace/pycan-send
+Author-email: Alexander Becker <nabla.becker@mailbox.org>
+License-Expression: GPL-3.0-or-later
+License-File: LICENSE.txt
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.8
+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 :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Python: >=3.8
+Requires-Dist: cantools
+Requires-Dist: click
+Description-Content-Type: text/markdown
+
+# pycan-send
+
+[![PyPI - Version](https://img.shields.io/pypi/v/pycan-send.svg)](https://pypi.org/project/pycan-send)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/pycan-send.svg)](https://pypi.org/project/pycan-send)
+
+-----
+
+## Table of Contents
+
+- [Installation](#installation)
+- [License](#license)
+
+## Installation
+
+```console
+pip install pycan-send
+```
+
+## Usage
+
+```console
+pycan-send path/to/file.kcd can0 -m MessageName -s SignalName Value
+```
+
+`Value` can be numeric or, for signals that define labeled choices in the
+KCD, the label name itself (e.g. `-s Mode Active`).
+
+## Fish tab completion
+
+One-shot (current shell only):
+
+```fish
+_PYCAN_SEND_COMPLETE=fish_source pycan-send | source
+```
+
+Persistent:
+
+```fish
+_PYCAN_SEND_COMPLETE=fish_source pycan-send > ~/.config/fish/completions/pycan-send.fish
+```
+
+Once enabled, tab completion works for KCD files, message names (`-m <TAB>`
+after the KCD path), signal names, and choice labels — all pulled live from
+the KCD file given on the command line.
+
+## License
+
+`pycan-send` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.

pycan_send-0.0.1/README.md

@@ -0,0 +1,48 @@
+# pycan-send
+
+[![PyPI - Version](https://img.shields.io/pypi/v/pycan-send.svg)](https://pypi.org/project/pycan-send)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/pycan-send.svg)](https://pypi.org/project/pycan-send)
+
+-----
+
+## Table of Contents
+
+- [Installation](#installation)
+- [License](#license)
+
+## Installation
+
+```console
+pip install pycan-send
+```
+
+## Usage
+
+```console
+pycan-send path/to/file.kcd can0 -m MessageName -s SignalName Value
+```
+
+`Value` can be numeric or, for signals that define labeled choices in the
+KCD, the label name itself (e.g. `-s Mode Active`).
+
+## Fish tab completion
+
+One-shot (current shell only):
+
+```fish
+_PYCAN_SEND_COMPLETE=fish_source pycan-send | source
+```
+
+Persistent:
+
+```fish
+_PYCAN_SEND_COMPLETE=fish_source pycan-send > ~/.config/fish/completions/pycan-send.fish
+```
+
+Once enabled, tab completion works for KCD files, message names (`-m <TAB>`
+after the KCD path), signal names, and choice labels — all pulled live from
+the KCD file given on the command line.
+
+## License
+
+`pycan-send` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.

pycan_send-0.0.1/pyproject.toml

@@ -0,0 +1,67 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "pycan-send"
+dynamic = ["version"]
+description = 'Command line tool that quickly lets you send a can frame using the message and signal names encoded in a KCD'
+readme = "README.md"
+requires-python = ">=3.8"
+license = "GPL-3.0-or-later"
+keywords = []
+authors = [
+  { name = "Alexander Becker", email = "nabla.becker@mailbox.org" },
+]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Programming Language :: Python",
+  "Programming Language :: Python :: 3.8",
+  "Programming Language :: Python :: 3.9",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: Implementation :: CPython",
+  "Programming Language :: Python :: Implementation :: PyPy",
+]
+dependencies = [
+  'click',
+  'cantools',
+]
+
+[project.urls]
+Documentation = "https://sr.ht/~laplace/pycan-send#readme"
+Issues = "https://sr.ht/~laplace/pycan-send/issues"
+Source = "https://sr.ht/~laplace/pycan-send"
+
+[project.scripts]
+pycan-send = "pycan_send.main:main"
+
+[tool.hatch.version]
+path = "src/pycan_send/__about__.py"
+
+[tool.hatch.envs.types]
+extra-dependencies = [
+  "mypy>=1.0.0",
+]
+[tool.hatch.envs.types.scripts]
+check = "mypy --install-types --non-interactive {args:src/pycan_send tests}"
+
+[tool.coverage.run]
+source_pkgs = ["pycan_send", "tests"]
+branch = true
+parallel = true
+omit = [
+  "src/pycan_send/__about__.py",
+]
+
+[tool.coverage.paths]
+pycan_send = ["src/pycan_send", "*/pycan-send/src/pycan_send"]
+tests = ["tests", "*/pycan-send/tests"]
+
+[tool.coverage.report]
+exclude_lines = [
+  "no cov",
+  "if __name__ == .__main__.:",
+  "if TYPE_CHECKING:",
+]

pycan_send-0.0.1/src/pycan_send/__about__.py

@@ -0,0 +1,5 @@
+# SPDX-FileCopyrightText: 2025-present Alexander Becker <nabla.becker@mailbox.org>
+#
+# SPDX-License-Identifier: GPL-3.0-or-later
+__version__ = "0.0.1"
+__author__ = "Alexander Becker"

pycan_send-0.0.1/src/pycan_send/__init__.py

@@ -0,0 +1,3 @@
+# SPDX-FileCopyrightText: 2025-present Alexander Becker <nabla.becker@mailbox.org>
+#
+# SPDX-License-Identifier: MIT

pycan_send-0.0.1/src/pycan_send/main.py

@@ -0,0 +1,202 @@
+from pathlib import Path
+
+import click
+import cantools
+import can
+from click.shell_completion import CompletionItem
+
+
+def _kcd_from_ctx(ctx):
+    """During shell completion, positional args aren't parsed into
+    ctx.params yet — they sit in ctx.args. Check both."""
+    kcd = ctx.params.get("kcd_file")
+    if kcd:
+        return kcd
+    for a in ctx.args:
+        if a.endswith(".kcd"):
+            return a
+    return None
+
+
+def _load_db(ctx):
+    kcd = _kcd_from_ctx(ctx)
+    if not kcd:
+        return None
+    kcd = Path(kcd).expanduser()
+    try:
+        return cantools.database.load_file(str(kcd))
+    except Exception:
+        return None
+
+
+def _complete_message(ctx, param, incomplete):
+    db = _load_db(ctx)
+    if db is None:
+        return []
+    return [
+        CompletionItem(m.name)
+        for m in db.messages
+        if m.name.startswith(incomplete)
+    ]
+
+
+def _complete_signal(ctx, param, incomplete):
+    db = _load_db(ctx)
+    if db is None:
+        return []
+    message = ctx.params.get("message")
+    existing = ctx.params.get("signal") or ()
+
+    # Click invokes shell_complete once per tuple element. Determine which
+    # element we're completing by the count of already-parsed pairs vs the
+    # raw tokens on the command line.
+    # Heuristic: if the last existing tuple is incomplete, we're on value.
+    # Simpler: inspect the current incomplete position via len of trailing
+    # partial. Click passes only the current token as `incomplete`, so use
+    # ctx.params to decide: if #signals * 2 tokens already consumed, we're
+    # on a name; otherwise on a value.
+    # `existing` is a tuple of fully-parsed (name, value) pairs; Click only
+    # adds a pair once both tokens are provided. So when shell_complete
+    # fires, we're always completing the NAME of the next pair... unless
+    # the user is mid-pair. We can't distinguish from ctx alone, so offer
+    # both: signal names (always useful) plus — if the previous token on
+    # argv was a known signal name — its choice labels.
+    if not message:
+        return []
+    try:
+        db_msg = db.get_message_by_name(message)
+    except KeyError:
+        return []
+
+    items = [
+        CompletionItem(s.name)
+        for s in db_msg.signals
+        if s.name.startswith(incomplete)
+    ]
+
+    # Also add choice labels for any signal in the message whose choices
+    # start with `incomplete` — this makes value completion work after
+    # typing `-s SigName <TAB>`.
+    for s in db_msg.signals:
+        if not s.choices:
+            continue
+        for raw_label in s.choices.values():
+            label = str(raw_label)
+            if label.startswith(incomplete):
+                items.append(CompletionItem(label))
+    return items
+
+
+def _complete_kcd(ctx, param, incomplete):
+    raw = incomplete or ""
+    expanded = Path(raw).expanduser() if raw else Path(".")
+    if raw.endswith("/") and expanded.is_dir():
+        directory, prefix = expanded, ""
+    else:
+        directory, prefix = expanded.parent, expanded.name
+    if not directory.exists():
+        return []
+
+    # Keep the user-visible form (~/foo, ./foo, foo) rather than
+    # replacing the token with an absolute path.
+    if raw.startswith("~"):
+        home = Path.home()
+
+        def display(p: Path) -> str:
+            try:
+                return "~/" + str(p.relative_to(home))
+            except ValueError:
+                return str(p)
+    else:
+        def display(p: Path) -> str:
+            return str(p)
+
+    items = []
+    for entry in directory.iterdir():
+        if not entry.name.startswith(prefix):
+            continue
+        shown = display(entry)
+        if entry.is_dir():
+            items.append(CompletionItem(shown + "/", type="plain"))
+        elif entry.suffix == ".kcd":
+            items.append(CompletionItem(shown))
+    return items
+
+
+def _coerce_signal_value(sig, raw):
+    """Accept a numeric string or a choice label and return what cantools
+    encode() should receive."""
+    try:
+        f = float(raw)
+        if f.is_integer():
+            return int(f)
+        return f
+    except ValueError:
+        pass
+    if sig.choices:
+        labels = {str(v): k for k, v in sig.choices.items()}
+        if raw in labels:
+            # cantools encode accepts the label string directly when a
+            # signal has choices, so pass it through.
+            return raw
+    raise click.ClickException(
+        f"Value '{raw}' for signal '{sig.name}' is not numeric and is not "
+        f"one of the defined labels: "
+        f"{', '.join(str(v) for v in sig.choices.values()) if sig.choices else '(none)'}"
+    )
+
+
+@click.command()
+@click.argument("KCD-File", type=click.Path(exists=True, dir_okay=False),
+                required=True, nargs=1, shell_complete=_complete_kcd)
+@click.argument("can-interface", type=str, required=True)
+@click.option("-p", "--prefix", required=False, default="0x0", type=str,
+              help="A prefixe that is 'ORed' with the message id. This is "
+              "useful if there are multiple identical devices on the bus")
+@click.option("-m", "--message", required=False, type=str, multiple=False,
+              shell_complete=_complete_message)
+@click.option("-s", "--signal", required=False, type=(str, str), multiple=True,
+              shell_complete=_complete_signal)
+def main(kcd_file, can_interface, prefix, message, signal):
+    signals = signal
+    prefix = int(prefix, 16)
+    try:
+        can_db = cantools.database.load_file(kcd_file)
+    except ValueError as e:
+        click.echo(e)
+        return
+
+    try:
+        db_msg = can_db.get_message_by_name(message)
+    except KeyError:
+        click.echo(f"The message '{message}' could not be found")
+        click.echo("Available messages are:")
+        for msg in can_db.messages:
+            click.echo(f"    {msg.name}")
+        return
+
+    resolved = {}
+    for signame, raw in signals:
+        try:
+            sig = db_msg.get_signal_by_name(signame)
+        except KeyError:
+            click.echo(f"The message '{message}' does not contain '{signame}'")
+            click.echo(f"Available signals in '{message}' are:")
+            for s in db_msg.signals:
+                click.echo(f"    {s.name}")
+            return
+        resolved[signame] = _coerce_signal_value(sig, raw)
+
+    try:
+        other_signals = {s.name: 0 for s in db_msg.signals if s.name not in resolved}
+        encode_input = resolved | other_signals
+        data = db_msg.encode(encode_input)
+    except OverflowError as err:
+        click.echo(str(err))
+        exit(-1)
+
+    bus = can.interface.Bus(channel=can_interface, interface="socketcan")
+    msg = can.Message(arbitration_id=db_msg.frame_id | prefix, data=data,
+                      is_extended_id=True)
+    bus.send(msg)
+    bus.shutdown()

pycan_send-0.0.1/tests/__init__.py

@@ -0,0 +1,3 @@
+# SPDX-FileCopyrightText: 2025-present Alexander Becker <nabla.becker@mailbox.org>
+#
+# SPDX-License-Identifier: MIT