shvcli 0.4.0__tar.gz → 0.6.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: shvcli
-Version: 0.4.0
+Version: 0.6.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.1
 Requires-Dist: prompt_toolkit
 Requires-Dist: pygments
 Requires-Dist: pyxdg

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

@@ -1,6 +1,6 @@
 [project]
 name = "shvcli"
-version = "0.4.0"
+version = "0.6.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.1",
   "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.6.0}/shvcli/__main__.py

@@ -21,6 +21,12 @@ def parse_args() -> argparse.Namespace:
     )
     parser.add_argument(
         "-s",
+        "--subscribe",
+        action="append",
+        default=[],
+        help="Automatic subscription right after connection.",
+    )
+    parser.add_argument(
         "--scan",
         action="store_true",
         help="Perform scan as a first action right after connect.",
@@ -49,7 +55,7 @@ def main() -> None:
     config.debug = config.debug or args.debug
     config.initial_scan = args.scan
     config.initial_scan_depth = args.scan_depth
-    asyncio.run(run(config))
+    asyncio.run(run(config, args.subscribe))
 
 
 if __name__ == "__main__":

{shvcli-0.4.0 → shvcli-0.6.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.6.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.6.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
@@ -14,7 +13,7 @@ from .config import CliConfig
 from .lsdir import ls_node_format
 from .parse import CliItems
 from .scan import scan_nodes
-from .tools import lookahead, print_block, print_ftext, print_row
+from .tools import lookahead, print_block, print_flist, print_ftext, print_row
 
 
 def argument_signal_comp(
@@ -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)[-1].split(":")
         node = shvclient.tree.get_path(path)
         if node is not None:
-            yield from comp_from(method, node.signals)
+            if items.param_raw.rsplit(maxsplit=1)[-1].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,25 +71,32 @@ 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 ""))
+    for ri in items.interpret_param_ri(config):
+        await shvclient.subscribe(ri)
 
 
 @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 ""))
+    for ri in items.interpret_param_ri(config):
+        await shvclient.unsubscribe(ri)
 
 
 @builtin(aliases={"subs", "test"})
 async def subscriptions(shvclient: SHVClient, _: CliConfig, __: CliItems) -> None:
     """List current subscriptions."""
-    print(await shvclient.call(".app/broker/currentClient", "subscriptions"))
+    subs = await shvclient.call(".broker/currentClient", "subscriptions")
+    if isinstance(subs, dict):
+        print_flist(
+            ("", sub + (f"?{timeout}secs" if timeout is not None else ""))
+            for sub, timeout in subs.items()
+        )
+    else:
+        print(subs)
 
 
 @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 +134,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.6.0}/shvcli/cli.py

@@ -52,17 +52,19 @@ 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:
             continue
 
 
-async def run(config: CliConfig) -> None:
+async def run(config: CliConfig, subscriptions: list[str]) -> None:
     """Loop to run interactive CLI session."""
     shvclient = await SHVClient.connect(config.url)
     assert isinstance(shvclient, SHVClient)
+    for ri in subscriptions:
+        await shvclient.subscribe(ri)
 
     if config.cache:
         cacheurl = RpcUrl(

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

@@ -15,9 +15,9 @@ from shv import (
     SHVType,
     SimpleClient,
 )
-from shv.cpon import Cpon
 
 from . import VERSION
+from .tools import print_cpon
 
 
 class Node(collections.abc.Mapping[str, "Node"]):
@@ -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_cpon(msg.param, f"{msg.path}:{msg.source}:{msg.signal_name}: ", True)
 
     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.6.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.6.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.6.0}/shvcli/lsdir.py

@@ -42,7 +42,7 @@ def dir_method_format(method: RpcMethodDesc) -> tuple[str, str]:
             methstyle = "ansimagenta"
         else:
             methstyle = "ansigreen"
-    elif method.signals or RpcMethodFlags.NOT_CALLABLE in method.flags:
+    elif method.signals:
         methstyle = "ansipurple"
     name = method.name
     return (
@@ -51,6 +51,20 @@ def dir_method_format(method: RpcMethodDesc) -> tuple[str, str]:
     )
 
 
+def dir_signal_format(method: RpcMethodDesc, signal: str) -> tuple[str, str]:
+    """Print format for signals."""
+    sigstyle = "ansipurple"
+    if method.name in {"ls", "dir"}:
+        sigstyle = "ansibrightblack"
+    elif RpcMethodFlags.GETTER in method.flags:
+        sigstyle = "ansimagenta"
+    label = f"{method.name}:{signal}"
+    return (
+        sigstyle,
+        f'"{label}"' if any(c in label for c in string.whitespace) else label,
+    )
+
+
 async def ls_method(shvclient: SHVClient, config: CliConfig, items: CliItems) -> None:
     """SHV ls method that is just smarter than regular call."""
     shvpath = items.interpret_param_path(config)
@@ -94,6 +108,8 @@ async def dir_method(shvclient: SHVClient, config: CliConfig, items: CliItems) -
     if config.autoget and any(_use_autoget(d) for d in dirr):
         w = max(len(d.name) for d in dirr)
         for d in dirr:
+            if RpcMethodFlags.NOT_CALLABLE in d.flags:
+                continue  # Ignore not callable
             n = [("", " " * (w - len(d.name))), dir_method_format(d)]
             if _use_autoget(d):
                 try:
@@ -110,6 +126,8 @@ async def dir_method(shvclient: SHVClient, config: CliConfig, items: CliItems) -
             print_row(n)
     else:
         print_flist(dir_method_format(d) for d in dirr)
+    if any(d.signals for d in dirr):
+        print_flist(dir_signal_format(d, s) for d in dirr for s in d.signals)
 
 
 def _use_autoget(method: RpcMethodDesc) -> bool:

{shvcli-0.4.0 → shvcli-0.6.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,21 @@ 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) -> list[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
+        res = []
+        for item in self.param_raw.split():
+            parts = item.split(":")
+            path = parts[0] if parts[0] else "**"
+            method = parts[1] if len(parts) == 2 else "*"
+            signal = parts[2] if len(parts) == 3 else "*"
+            res.append(f"{self.path}{"/" if self.path else ""}{path}:{method}:{signal}")
+        return res
 
     def interpret_param_set(self) -> tuple[str | None, str | None]:
         """Interpret parameter as 'set' method specification.

{shvcli-0.4.0 → shvcli-0.6.0}/shvcli/tools.py

@@ -1,6 +1,7 @@
 """Various tools used in the code."""
 
 import collections.abc
+import itertools
 import os
 import textwrap
 import typing
@@ -118,16 +119,31 @@ def cpon_ftext(cpon: str) -> collections.abc.Iterator[tuple[str, str]]:
             yield "", "\n"
 
 
-def print_cpon(data: shv.SHVType, short: bool = False) -> None:
+def _wrap_cpon(cpon: str) -> collections.abc.Iterator[str]:
+    """Wrap CPON.
+
+    It is better to wrap CPON on division characters rather than white spaces
+    because those are part of the data.
+    """
+    cols = os.get_terminal_size().columns
+    while len(cpon) > cols:
+        i = max(cpon.rfind(sep, 0, cols) for sep in (",", "]", "}"))
+        if i == -1:
+            i = cols
+        yield cpon[: i + 1]
+        cpon = " " + cpon[i + 1 :]
+    yield cpon
+
+
+def print_cpon(data: shv.SHVType, prefix: str = "", short: bool = False) -> None:
     """Print given data in CPON format."""
-    simple = shv.Cpon.pack(data)
-    if len(simple) > os.get_terminal_size().columns:
-        if short:
-            print_row(cpon_ftext(simple))
-        else:
-            for line in shv.Cpon.pack(
-                data, shv.CponWriter.Options(indent=b" ")
-            ).splitlines():
-                print_row(cpon_ftext(line))
+    if short:
+        cpon = "\n".join(_wrap_cpon(prefix + shv.Cpon.pack(data)))[len(prefix) :]
+        print_ftext(itertools.chain(iter((("", prefix),)), cpon_ftext(cpon)))
     else:
-        print_ftext(cpon_ftext(simple))
+        print_row(
+            itertools.chain(
+                iter((("", prefix),)),
+                cpon_ftext(shv.Cpon.pack(data, shv.CponWriter.Options(indent=b" "))),
+            )
+        )

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: shvcli
-Version: 0.4.0
+Version: 0.6.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.1
 Requires-Dist: prompt_toolkit
 Requires-Dist: pygments
 Requires-Dist: pyxdg

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

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