pycan-send 0.0.1__py3-none-any.whl

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/__init__.py

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

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.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,8 @@
+pycan_send/__about__.py,sha256=VOvIJ7Epjsynw8ZNY3FIAAUEMvBsvyFiQXKKwEmQT8I,183
+pycan_send/__init__.py,sha256=s8AKqKGu2E_AP5LFUerd8Pjj8xpncezzUxr4hqdOars,116
+pycan_send/main.py,sha256=hVoIv8J9qaBKws-SGW3DEEy6li0P45oZ6Q0oj3AN-v8,6787
+pycan_send-0.0.1.dist-info/METADATA,sha256=BNQb3p7w7f2sMI_JY-LrLpHy2UNGTgrcm-agd7Iw4UM,2212
+pycan_send-0.0.1.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+pycan_send-0.0.1.dist-info/entry_points.txt,sha256=EEkxm_H9eenzFqLDt3LHL7Sz00mW24X2d7Fxu33dX9Y,52
+pycan_send-0.0.1.dist-info/licenses/LICENSE.txt,sha256=NjpbyaWzT2JQHqe2mUJftu67l6NfN13kddmgOTVZcQ8,748
+pycan_send-0.0.1.dist-info/RECORD,,

pycan_send-0.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

pycan_send-0.0.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+pycan-send = pycan_send.main:main

pycan_send-0.0.1.dist-info/licenses/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/>.
+