shvcli 0.4.0__tar.gz → 0.5.0__tar.gz

{shvcli-0.4.0/shvcli.egg-info → shvcli-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: shvcli
-Version: 0.4.0
+Version: 0.5.0
 Summary: Silicon Heaven CLI access application
 Author: Elektroline a.s.
 License: MIT License
@@ -38,7 +38,7 @@ Classifier: Topic :: Terminals
 Requires-Python: >=3.11
 Description-Content-Type: text/x-rst
 License-File: LICENSE
-Requires-Dist: pyshv>=0.6.0
+Requires-Dist: pyshv>=0.7.0
 Requires-Dist: prompt_toolkit
 Requires-Dist: pygments
 Requires-Dist: pyxdg

{shvcli-0.4.0 → shvcli-0.5.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "shvcli"
-version = "0.4.0"
+version = "0.5.0"
 description = "Silicon Heaven CLI access application"
 readme = "README.rst"
 license = {file = "LICENSE"}
@@ -20,7 +20,7 @@ classifiers = [
 ]
 requires-python = ">=3.11"
 dependencies = [
-  "pyshv >= 0.6.0",
+  "pyshv >= 0.7.0",
   "prompt_toolkit",
   "pygments",
   "pyxdg",
@@ -52,7 +52,7 @@ exclude_lines = [
 target-version = "py311"
 [tool.ruff.lint]
 select = [
-  "F", "E", "W", "I", "N", "D", "UP", "YTT", "ANN", "ASYNC", "TRIO", "S", "BLE",
+  "F", "E", "W", "I", "N", "D", "UP", "YTT", "ANN", "ASYNC", "ASYNC1", "S", "BLE",
   "B", "A", "COM", "PL", "RUF"
 ]
 ignore = [

{shvcli-0.4.0 → shvcli-0.5.0}/shvcli/__version__.py

@@ -15,10 +15,11 @@ def _get_version() -> str:
         if str(dist.locate_file(f"{__package__}/__version__.py")) == __file__:
             return dist.version
     pyproject = pathlib.Path(__file__).parent.parent / "pyproject.toml"
-    with pyproject.open("rb") as f:
-        res = tomllib.load(f)["project"]["version"]
-        if isinstance(res, str):
-            return res
+    if pyproject.exists():
+        with pyproject.open("rb") as f:
+            res = tomllib.load(f)["project"]["version"]
+            if isinstance(res, str):
+                return res
     return "unknown"
 
 

{shvcli-0.4.0 → shvcli-0.5.0}/shvcli/builtin.py

@@ -10,7 +10,9 @@ from .client import SHVClient
 from .config import CliConfig
 from .parse import CliItems
 
-_T_METHOD = typing.Callable[[SHVClient, CliConfig, CliItems], typing.Awaitable[None]]
+_T_METHOD = typing.Callable[
+    [SHVClient, CliConfig, CliItems], typing.Awaitable[None] | None
+]
 _T_XMETHOD = typing.Callable[
     [SHVClient, CliConfig, CliItems, int | None], typing.Awaitable[None]
 ]
@@ -115,7 +117,10 @@ async def call_builtin(
         return
 
     if isinstance(m, Method):
-        return await m.func(shvclient, config, items)
+        res = m.func(shvclient, config, items)
+        if isinstance(res, collections.abc.Awaitable):
+            await res
+        return
 
     typing.assert_type(m, XMethod)
     strnum = items.method[len(m.name) + 1 :]

{shvcli-0.4.0 → shvcli-0.5.0}/shvcli/builtin_impl.py

@@ -5,7 +5,6 @@ import inspect
 import itertools
 
 from prompt_toolkit.completion import Completion
-from shv import RpcSubscription
 
 from .builtin import METHODS, Argument, XMethod, builtin, xbuiltin
 from .client import Node, SHVClient
@@ -22,11 +21,13 @@ def argument_signal_comp(
 ) -> collections.abc.Iterable[Completion]:
     """Completion for subscribe argument."""
     if ":" in items.param_raw:
-        path, method = items.interpret_param_method(config)
-        assert method is not None
+        path, method, signal = items.interpret_param_ri(config).split(":")
         node = shvclient.tree.get_path(path)
         if node is not None:
-            yield from comp_from(method, node.signals)
+            if items.param_raw.count(":") == 1:
+                yield from comp_from(method, node.methods)
+            elif method in node.methods:
+                yield from comp_from(signal, node.methods[method])
     else:
         yield from comp_path(shvclient, config, items)
 
@@ -53,7 +54,7 @@ argument_set = Argument("[OPTION [VALUE]]", argument_set_comp)
 
 
 @builtin("help", {"h"}, hidden=True)
-async def _help(_: SHVClient, __: CliConfig, ___: CliItems) -> None:
+def _help(_: SHVClient, __: CliConfig, ___: CliItems) -> None:
     """Print help for all builtin methods."""
     print_row("Available internal methods (all prefixed with '!'):")
     for name, m in METHODS.items():
@@ -70,15 +71,13 @@ async def _help(_: SHVClient, __: CliConfig, ___: CliItems) -> None:
 @builtin(aliases={"sub"}, argument=argument_signal)
 async def subscribe(shvclient: SHVClient, config: CliConfig, items: CliItems) -> None:
     """Add new subscribe."""
-    path, method = items.interpret_param_method(config)
-    await shvclient.subscribe(RpcSubscription(path, method or ""))
+    await shvclient.subscribe(items.interpret_param_ri(config))
 
 
 @builtin(aliases={"usub"}, argument=argument_signal)
 async def unsubscribe(shvclient: SHVClient, config: CliConfig, items: CliItems) -> None:
     """Unsubscribe existing subscription."""
-    path, method = items.interpret_param_method(config)
-    await shvclient.unsubscribe(RpcSubscription(path, method or ""))
+    await shvclient.unsubscribe(items.interpret_param_ri(config))
 
 
 @builtin(aliases={"subs", "test"})
@@ -88,7 +87,7 @@ async def subscriptions(shvclient: SHVClient, _: CliConfig, __: CliItems) -> Non
 
 
 @builtin(aliases={"t"}, argument=argument_path)
-async def tree(shvclient: SHVClient, config: CliConfig, items: CliItems) -> None:
+def tree(shvclient: SHVClient, config: CliConfig, items: CliItems) -> None:
     """Print tree of nodes discovered in this session."""
 
     def print_node(node: Node, cols: list[bool]) -> None:
@@ -126,7 +125,7 @@ async def scan(
 
 
 @builtin("set", aliases={"s"}, argument=argument_set)
-async def _set(_: SHVClient, config: CliConfig, items: CliItems) -> None:
+def _set(_: SHVClient, config: CliConfig, items: CliItems) -> None:
     """Set configuration options in runtime."""
     opt, val = items.interpret_param_set()
     if not opt:

{shvcli-0.4.0 → shvcli-0.5.0}/shvcli/cli.py

@@ -52,7 +52,7 @@ async def _app(config: CliConfig, shvclient: SHVClient) -> None:
                         [prompt_path, ("", "> ")], vi_mode=config.vimode
                     )
             except EOFError:
-                shvclient.client.disconnect()
+                await shvclient.disconnect()
                 return
             await handle_line(shvclient, config, result)
         except KeyboardInterrupt:

{shvcli-0.4.0 → shvcli-0.5.0}/shvcli/client.py

@@ -26,8 +26,7 @@ class Node(collections.abc.Mapping[str, "Node"]):
     def __init__(self) -> None:
         """Initialize the node."""
         self.nodes: dict[str, Node] = {}
-        self.methods: set[str] = {"ls", "dir"}
-        self.signals: set[str] = set()
+        self.methods: dict[str, set[str]] = {"ls": {"lsmod"}, "dir": set()}
         self.nodes_probed = False
         self.methods_probed = False
 
@@ -83,8 +82,7 @@ class Node(collections.abc.Mapping[str, "Node"]):
         """Dump the data to basic types."""
         return {
             "nodes": {n: v.dump() for n, v in self.nodes.items()},
-            "methods": list(self.methods),
-            "signals": list(self.signals),
+            "methods": {n: list(v) for n, v in self.methods.items()},
             "nodes_probed": self.nodes_probed,
             "methods_probed": self.methods_probed,
         }
@@ -96,10 +94,8 @@ class Node(collections.abc.Mapping[str, "Node"]):
         res = cls()
         if isinstance(data["nodes"], collections.abc.Mapping):
             res.nodes = {n: cls.load(v) for n, v in data["nodes"].items()}
-        if isinstance(data["methods"], collections.abc.Sequence):
-            res.methods = set(data["methods"])
-        if isinstance(data["signals"], collections.abc.Sequence):
-            res.signals = set(data["signals"])
+        if isinstance(data["methods"], collections.abc.Mapping):
+            res.methods = {str(n): set(v) for n, v in data["methods"].items()}
         res.nodes_probed = bool(data["nodes_probed"])
         res.methods_probed = bool(data["methods_probed"])
         return res
@@ -124,10 +120,10 @@ class SHVClient(SimpleClient):
     async def _message(self, msg: RpcMessage) -> None:
         await super()._message(msg)
         if msg.is_signal:
-            method = msg.method
-            assert method is not None
-            self.tree.valid_path(msg.path or "").signals.add(method)
-            print(f"{msg.path}:{method}: {Cpon.pack(msg.param)}")
+            self.tree.valid_path(msg.path or "").methods.setdefault(
+                msg.source, set()
+            ).add(msg.signal_name)
+            print(f"{msg.path}:{msg.source}:{msg.signal_name}: {Cpon.pack(msg.param)}")
 
     async def ls(self, path: str) -> list[str]:
         """List same as in ValueClient but with result being preserved in tree."""
@@ -154,9 +150,10 @@ class SHVClient(SimpleClient):
             raise exc
         node = self.tree.valid_path(path)
         node.methods = {
-            d.name for d in res if RpcMethodFlags.NOT_CALLABLE not in d.flags
+            d.name: set(d.signals)
+            for d in res
+            if RpcMethodFlags.NOT_CALLABLE not in d.flags
         }
-        node.signals = {d.name for d in res if RpcMethodFlags.NOT_CALLABLE in d.flags}
         node.methods_probed = True
         return res
 
@@ -177,9 +174,9 @@ class SHVClient(SimpleClient):
         except RpcMethodNotFoundError as exc:
             raise exc
         except RpcError as exc:
-            self.tree.valid_path(path).methods.add(method)
+            self.tree.valid_path(path).methods.setdefault(method, set())
             raise exc
-        self.tree.valid_path(path).methods.add(method)
+        self.tree.valid_path(path).methods.setdefault(method, set())
         return res
 
     async def probe(self, path: str) -> Node | None:

{shvcli-0.4.0 → shvcli-0.5.0}/shvcli/complet.py

@@ -61,7 +61,8 @@ class CliCompleter(Completer):
             CliFlags.COMPLETE_CALL not in items.flags
             or items.method in {"ls", "dir"}
             or (
-                items.method[0] == "!"
+                items.method
+                and items.method[0] == "!"
                 and (bmethod := builtin.get_builtin(items.method[1:])) is not None
                 and bmethod.argument
                 and bmethod.argument.autoprobe

{shvcli-0.4.0 → shvcli-0.5.0}/shvcli/config.py

@@ -101,9 +101,9 @@ class CliConfig:
                 self.__rurl = self.__url
             elif isinstance(self.__url, str):
                 self.__rurl = RpcUrl.parse(
-                    subprocess.run(
+                    subprocess.run(  # noqa S602
                         f"printf '%s' \"{self.__url}\"",
-                        shell=True,  # noqa S602
+                        shell=True,
                         stdout=subprocess.PIPE,
                         check=True,
                     ).stdout.decode()

{shvcli-0.4.0 → shvcli-0.5.0}/shvcli/parse.py

@@ -39,16 +39,6 @@ class CliItems:
             return None
         return Cpon.unpack(self.param_raw)
 
-    @property
-    def param_method(self) -> tuple[str, str | None]:
-        """Interpret parameter as path and method."""
-        if ":" in self.param_raw:
-            path, method = self.param_raw.split(":", maxsplit=1)
-            return path, method
-        if "/" in self.param_raw:
-            return self.param_raw, None
-        return "", self.param_raw
-
     def interpret_param_path(self, config: CliConfig) -> str:
         """Interpret parameter as path specification.
 
@@ -56,16 +46,18 @@ class CliItems:
         """
         return config.shvpath([self.path, self.param_raw])
 
-    def interpret_param_method(self, config: CliConfig) -> tuple[str, str | None]:
-        """Interpret parameter as method specification.
+    def interpret_param_ri(self, config: CliConfig, expand: bool = True) -> str:
+        """Interpret parameter as RI.
 
-        Compared to :meth:`param_method` this provides a full combination of
-        path and method not just parsed :prop:`param_raw`.
+        The path in RI is combined with pat in the configuration.
 
-        :return: pair of SHV path and method name that is from parameter.
+        :return: SHV RPC RI.
         """
-        param_path, method = self.param_method
-        return config.shvpath([self.path, param_path]), method
+        parts = self.param_raw.split(":")
+        path = parts[0] if parts[0] else "**"
+        method = parts[1] if len(parts) == 2 else "*"
+        signal = parts[2] if len(parts) == 3 else "*"
+        return f"{self.path}{"/" if path else ""}{path}:{method}:{signal}"
 
     def interpret_param_set(self) -> tuple[str | None, str | None]:
         """Interpret parameter as 'set' method specification.

{shvcli-0.4.0 → shvcli-0.5.0/shvcli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: shvcli
-Version: 0.4.0
+Version: 0.5.0
 Summary: Silicon Heaven CLI access application
 Author: Elektroline a.s.
 License: MIT License
@@ -38,7 +38,7 @@ Classifier: Topic :: Terminals
 Requires-Python: >=3.11
 Description-Content-Type: text/x-rst
 License-File: LICENSE
-Requires-Dist: pyshv>=0.6.0
+Requires-Dist: pyshv>=0.7.0
 Requires-Dist: prompt_toolkit
 Requires-Dist: pygments
 Requires-Dist: pyxdg

{shvcli-0.4.0 → shvcli-0.5.0}/shvcli.egg-info/requires.txt

@@ -1,4 +1,4 @@
-pyshv>=0.6.0
+pyshv>=0.7.0
 prompt_toolkit
 pygments
 pyxdg