OpenSMI-Core 0.4__tar.gz → 0.5__tar.gz

{opensmi_core-0.4 → opensmi_core-0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: OpenSMI-Core
-Version: 0.4
+Version: 0.5
 Summary: Smart Machine Interface core functionality for server and client applications.
 Author-email: Carsten Harms <Carsten.Harms@dfki.de>, Simon Jungbluth <Simon.Jungbluth@smartfactory.de>
 License-Expression: MIT

{opensmi_core-0.4 → opensmi_core-0.5}/src/OpenSMI_Core.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: OpenSMI-Core
-Version: 0.4
+Version: 0.5
 Summary: Smart Machine Interface core functionality for server and client applications.
 Author-email: Carsten Harms <Carsten.Harms@dfki.de>, Simon Jungbluth <Simon.Jungbluth@smartfactory.de>
 License-Expression: MIT

opensmi_core-0.5/src/OpenSMI_Core.egg-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "0.5",
+  "distance": 0,
+  "node": "gddccea703057c24b9ad0c2411b5d680aed029421",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-10-15"
+}

{opensmi_core-0.4 → opensmi_core-0.5}/src/opensmi/core/lifecycle_mixin.py

@@ -5,23 +5,30 @@
 """Mixin for async lifecycle management for mixin-composed classes.
 
 Concepts
+========
 
-Resource mixin: a plain class (does not inherit `LifecycleMixin`) with one or
-multiple ``@lifecycle``-decorated async-generator method(s). Code before yield is init;
-code after yield is shutdown.
+Resource
+    A single `lifecycle`-decorated async-generator method. Code before ``yield`` initializes it;
+    code after ``yield`` shuts it down. A resource is the unit of ordering:
+    ``after``, ``before`` and ``requires`` refer to resources, not classes.
 
-Composed class: the concrete class that inherits its resource mixins and
-`LifecycleMixin`. This is the only class that should inherit `LifecycleMixin`.
+Resource mixin
+    A plain class (does not inherit `LifecycleMixin`) that provides one or more resources.
 
-Ordering: resources init in dependency order and shut down in the exact
-reverse order. Order is resolved once, in `LifecycleMixin.__init_subclass__`, from
-``after`` / ``before`` arguments of ``@lifecycle``-decorated methods.
+Composed class
+    The concrete class that inherits its resource mixins and `LifecycleMixin`.
+    This is the only class that should inherit `LifecycleMixin`.
+
+Ordering
+    Resources are initialized in dependency order and shut down in the exact reverse order. Order is
+    resolved once, in `LifecycleMixin.__init_subclass__`, from ``after`` / ``before``
+    arguments of `lifecycle`-decorated methods. ``requires`` is checked at the same point
+    but imposes no ordering.
 """
 
 import graphlib
 import inspect
 import time
-from asyncio import CancelledError
 from collections.abc import AsyncGenerator, Callable
 from typing import Final, Self, TypeVar, overload
 
@@ -47,7 +54,7 @@ _FuncOrFuncs = _Func | tuple[_Func, ...] | list[_Func]
 def lifecycle(_func: _LifecycleFunc) -> _LifecycleFunc: ...
 @overload
 def lifecycle(
-    _func: None = None, *, after: _FuncOrFuncs = (), before: _FuncOrFuncs = ()
+    _func: None = None, *, after: _FuncOrFuncs = (), before: _FuncOrFuncs = (), requires: _FuncOrFuncs = ()
 ) -> Callable[[_LifecycleFunc], _LifecycleFunc]: ...
 def lifecycle(
     _func: _LifecycleFunc | None = None,
@@ -56,7 +63,7 @@ def lifecycle(
     before: _FuncOrFuncs = (),
     requires: _FuncOrFuncs = (),
 ) -> _LifecycleFunc | Callable[[_LifecycleFunc], _LifecycleFunc]:
-    """Mark an async generator method as a lifecycle resource.
+    """Mark an async generator method as a resource.
 
     Code before ``yield`` runs during initialization; code after ``yield``
     runs during shutdown, in reverse lifecycle order.
@@ -92,13 +99,13 @@ def lifecycle(
         setattr(func, _ATTR_LIFECYCLE_REQUIRES, tuple(_normalize(requires)))
         return func
 
-    if _func is not None:  # bare @resource, no args
+    if _func is not None:  # bare @lifecycle, no args
         return _decorator(_func)
-    return _decorator  # @resource(after=(...))
+    return _decorator  # @lifecycle(after=(...))
 
 
 class LifecycleMixin:
-    """Mixin managing the lifecycle of classes with ``@resource`` decorated methods."""
+    """Mixin managing the lifecycle of classes with `lifecycle` decorated methods."""
 
     __order: list[_Func] | None = None
     __generators: dict[_Func, AsyncGenerator[None, None]] | None = None
@@ -124,7 +131,7 @@ class LifecycleMixin:
         On failure, rollback anything already started, in reverse.
 
         :raises BaseException: Reraised exception from failed resource initialization.
-        :raises ExceptionGroup: If exceptions were caught during rollback.
+        :raises BaseExceptionGroup: If exceptions were caught during rollback.
         """
         if self.__state != LifecycleState.NEW:
             return self
@@ -133,10 +140,12 @@ class LifecycleMixin:
         self.__generators = {}
 
         started: list[_Func] = []
+        current: _Func | None = None
         time_start = time.monotonic()
         try:
             assert self.__order is not None
             for func in self.__order:
+                current = func
                 get_logger(self, _LOGGER).debug("starting...", func=func.__qualname__)
                 agen = func(self)
                 await agen.__anext__()  # run resource init (until it yields)
@@ -144,21 +153,19 @@ class LifecycleMixin:
                 started.append(func)
                 get_logger(self, _LOGGER).debug("started successfully", func=func.__qualname__)
         except BaseException as init_exception:
-            if isinstance(init_exception, CancelledError):
-                get_logger(self, _LOGGER).error("Initialization cancelled")
-            else:
-                get_logger(self, _LOGGER).exception("Failed to initialize!")
+            if current is not None:
+                init_exception.add_note(
+                    f"{type(self).__name__}: failed starting {current.__qualname__}; "
+                    f"{len(started)} resource(s) had been started before it."
+                )
             self.__state = LifecycleState.INITIALIZATION_FAILED
             rollback_exceptions: list[Exception] = await self.__shutdown(started)
             if rollback_exceptions:
                 msg = (
-                    f"Resource failed to initialize, and rollback {len(rollback_exceptions)} "
+                    f"Resource failed to initialize, and rollback of {len(rollback_exceptions)} "
                     "resource(s) failed to shut down cleanly."
                 )
-                raise ExceptionGroup(
-                    msg,
-                    [init_exception, *rollback_exceptions],  # pyright: ignore[reportArgumentType]
-                ) from init_exception
+                raise BaseExceptionGroup(msg, [init_exception, *rollback_exceptions]) from init_exception
             raise
 
         self.__state = LifecycleState.INITIALIZED
@@ -256,7 +263,7 @@ def _build_edges(funcs: set[_Func]) -> dict[_Func, set[_Func]]:
 
     for func in funcs:
         # hard requirement: target must be present
-        required_funcs: tuple[type, ...] = getattr(func, _ATTR_LIFECYCLE_REQUIRES, ())
+        required_funcs: tuple[_Func, ...] = getattr(func, _ATTR_LIFECYCLE_REQUIRES, ())
         for dep in required_funcs:
             if dep not in funcs:
                 msg = (
@@ -266,12 +273,12 @@ def _build_edges(funcs: set[_Func]) -> dict[_Func, set[_Func]]:
                 raise TypeError(msg)
 
         # soft hint: only wire the edge if the target actually ended up present
-        after_funcs: tuple[type, ...] = getattr(func, _ATTR_LIFECYCLE_AFTER, ())
+        after_funcs: tuple[_Func, ...] = getattr(func, _ATTR_LIFECYCLE_AFTER, ())
         for after_func in after_funcs:
             if after_func in funcs:
                 edges[func].add(after_func)
 
-        before_funcs: tuple[type, ...] = getattr(func, _ATTR_LIFECYCLE_BEFORE, ())
+        before_funcs: tuple[_Func, ...] = getattr(func, _ATTR_LIFECYCLE_BEFORE, ())
         for before_func in before_funcs:
             if before_func in funcs:
                 edges[before_func].add(func)

{opensmi_core-0.4 → opensmi_core-0.5}/src/opensmi/core/logging.py

@@ -10,7 +10,8 @@ import shutil
 import sys
 from collections.abc import Mapping, MutableMapping
 from enum import Enum
-from typing import Any
+from pathlib import PurePath
+from typing import Any, Final
 
 import structlog
 
@@ -31,8 +32,17 @@ def _elapsed_to_ms(_, __, event_dict: MutableMapping[str, Any]) -> MutableMappin
     return event_dict
 
 
+def _path_to_str(_, __, event_dict: MutableMapping[str, Any]) -> MutableMapping[str, Any]:  # noqa: ANN001
+    """Convert ``path`` entry in structlog processor event dict to simple string."""
+    if "path" in event_dict:
+        path = event_dict["path"]
+        if isinstance(path, PurePath):
+            event_dict["path"] = str(path)
+    return event_dict
+
+
 _logging_initialized = False
-""" Global flag indicated whether logging is initialized. """
+"""Global flag indicated whether logging is initialized."""
 
 
 class LogFormat(Enum):
@@ -46,11 +56,15 @@ class LogFormat(Enum):
     """JSON formatted logging output"""
 
 
-def _setup_console_logging() -> None:
+def _setup_key_value_logging(
+    *,
+    min_level: int | str = logging.NOTSET,
+    enable_rich_tracebacks: bool = True,
+) -> None:
     from importlib.util import find_spec
 
     # see https://www.structlog.org/en/stable/logging-best-practices.html#pretty-printing-vs-structured-output
-    if find_spec("rich") is not None:
+    if find_spec("rich") is not None and enable_rich_tracebacks:
         console_renderer = structlog.dev.ConsoleRenderer(
             sort_keys=False,
             exception_formatter=structlog.dev.RichTracebackFormatter(
@@ -62,10 +76,10 @@ def _setup_console_logging() -> None:
 
     processors = [
         structlog.contextvars.merge_contextvars,
-        structlog.stdlib.filter_by_level,
         structlog.stdlib.add_logger_name,
         structlog.stdlib.add_log_level,
         _elapsed_to_ms,
+        _path_to_str,
         structlog.processors.TimeStamper(fmt="iso", utc=False),
         structlog.processors.UnicodeDecoder(),
         console_renderer,
@@ -73,67 +87,91 @@ def _setup_console_logging() -> None:
 
     structlog.configure(
         processors=processors,
-        wrapper_class=structlog.make_filtering_bound_logger(logging.NOTSET),
+        wrapper_class=structlog.make_filtering_bound_logger(min_level=min_level),
         logger_factory=structlog.stdlib.LoggerFactory(),
         cache_logger_on_first_use=True,
     )
 
 
-def _setup_key_value_logging() -> None:
+def _setup_json_logging(
+    *,
+    min_level: int | str = logging.NOTSET,
+) -> None:
+
+    processors = [
+        structlog.contextvars.merge_contextvars,
+        structlog.stdlib.add_logger_name,
+        structlog.stdlib.add_log_level,
+        _path_to_str,
+        structlog.processors.dict_tracebacks,
+        structlog.processors.TimeStamper(fmt="iso", utc=True),
+    ]
+
     try:
         import orjson
 
         _LOGGER.info("Using orjson serialization")
-        processors = [
-            structlog.contextvars.merge_contextvars,
-            # structlog.stdlib.filter_by_level,
-            # structlog.stdlib.add_logger_name,
-            structlog.stdlib.add_log_level,
-            _elapsed_to_ms,
-            structlog.processors.dict_tracebacks,
-            structlog.processors.JSONRenderer(serializer=orjson.dumps),
-        ]
+
+        processors.append(structlog.processors.JSONRenderer(serializer=orjson.dumps))
         logger_factory = structlog.BytesLoggerFactory()
     except ImportError:
-        _LOGGER.warning("Could not import orjson, fallback to buildin serializer.")
-
-        processors = [
-            structlog.contextvars.merge_contextvars,
-            # structlog.stdlib.filter_by_level,
-            # structlog.stdlib.add_logger_name,
-            structlog.stdlib.add_log_level,
-            _elapsed_to_ms,
-            structlog.processors.dict_tracebacks,
-            structlog.processors.JSONRenderer(),
-        ]
+        _LOGGER.warning("Could not import orjson, fallback to builtin serializer.")
+
+        processors.append(structlog.processors.JSONRenderer())
         logger_factory = structlog.stdlib.LoggerFactory()
 
     structlog.configure(
         processors=processors,
-        wrapper_class=structlog.make_filtering_bound_logger(logging.NOTSET),
+        wrapper_class=structlog.make_filtering_bound_logger(min_level=min_level),
         logger_factory=logger_factory,
         cache_logger_on_first_use=True,
     )
 
 
+DEFAULT_LOG_LEVELS: Final[dict[str, int | str]] = {
+    "opensmi": logging.INFO,
+    "asyncua": logging.ERROR,
+}
+
+
 def setup_logging(
     *,
+    log_min_level: int | str = logging.NOTSET,
     log_levels: Mapping[str, int | str] | None = None,
     log_format: LogFormat = LogFormat.AUTOMATIC,
+    enable_rich_tracebacks: bool = True,
+    force_basic_config: bool = False,
 ) -> None:
-    """Set up structured logging."""
+    """Set up structured logging.
+
+    ``log_format`` can be overridden with the ``LOG_FORMAT`` environment variable.
+
+    :param log_min_level: Minimum logging level for structlog loggers.
+    :param log_levels: Logging levels for *all* loggers. Maps logger name to level. Defaults to `DEFAULT_LOG_LEVELS`.
+    :param log_format: Logging format for *all* loggers.
+    :param enable_rich_tracebacks: Enable Rich tracebacks if `KEY_VALUE` log format is used.
+    :param force_basic_config: ``force`` parameter of ``logging.basicConfig``.
+    """
     global _logging_initialized
     if _logging_initialized:
         return
 
-    logging.basicConfig(force=True, format="")
+    logging.basicConfig(format="", force=force_basic_config)
+
+    if log_levels is None:
+        log_levels = DEFAULT_LOG_LEVELS
+
+    # structlog loggers created via structlog.stdlib.LoggerFactory are also gated by the stdlib level
+    if log_min_level != logging.NOTSET and (log_levels is None or "" not in log_levels):
+        logging.getLogger().setLevel(log_min_level)
+
     if log_levels is not None:
         for name, level in log_levels.items():
             try:
                 logging.getLogger(name).setLevel(level)
-                _LOGGER.debug(f"Set logger level of '{name}' to {level}")
+                _LOGGER.debug("Set logger level of %r to %s", name, level)
             except (TypeError, ValueError):
-                _LOGGER.exception(f"Could not set logger level of '{name}' to {level}")
+                _LOGGER.exception("Could not set logger level of %r to %s", name, level)
     if _LOGGER.level == logging.NOTSET:
         _LOGGER.setLevel(logging.INFO)
 
@@ -142,8 +180,8 @@ def setup_logging(
     if env_log_format is not None:
         try:
             log_format = LogFormat[env_log_format.upper()]
-        except ValueError:
-            _LOGGER.warning(f"Invalid log format '{env_log_format}'")
+        except KeyError:
+            _LOGGER.warning("Invalid log format %r", env_log_format)
 
     if log_format == LogFormat.AUTOMATIC:
         if sys.stderr.isatty():
@@ -154,8 +192,8 @@ def setup_logging(
             log_format = LogFormat.JSON
 
     if log_format == LogFormat.KEY_VALUE:
-        _setup_console_logging()
+        _setup_key_value_logging(min_level=log_min_level, enable_rich_tracebacks=enable_rich_tracebacks)
     else:  # JSON
-        _setup_key_value_logging()
+        _setup_json_logging(min_level=log_min_level)
 
     _logging_initialized = True

{opensmi_core-0.4 → opensmi_core-0.5}/src/opensmi/core/subscription_manager.py

@@ -9,7 +9,7 @@ import contextlib
 import time
 from abc import ABC, abstractmethod
 from asyncio import Task
-from collections.abc import Iterable
+from collections.abc import Iterable, Sequence
 from dataclasses import dataclass, field
 from typing import Any, Generic, Never, TypeVar
 
@@ -19,7 +19,6 @@ from asyncua.client.client import Client
 from asyncua.common.node import Node
 from asyncua.common.subscription import DataChangeNotif, Subscription
 from asyncua.ua import NodeId, UaStatusCodeError
-from asyncua.ua.uaerrors import BadAttributeIdInvalid
 
 from opensmi.core.protocols import UaEvent
 
@@ -48,6 +47,20 @@ class _MonitoredItem(Generic[_HandlerType]):
     handle: int | None
     """Handle as returned by ``asyncua``. Is ``None`` when renew failed."""
     handlers: list[_HandlerType] = field(default_factory=list)
+    """List of handler that are subscribed to the monitored item. Shall not contain duplicates."""
+
+    def add_handlers(self, handlers: Iterable[_HandlerType]) -> None:
+        """Add given handlers if they are not already in the ``handlers`` list."""
+        for handler in handlers:
+            if handler not in self.handlers:
+                self.handlers.append(handler)
+
+
+@dataclass
+class _Wanted:
+    node: Node
+    handlers: list[UaDataChangeSubscriber] = field(default_factory=list)
+    """List of handlers that asked to be subscribed to ``node``."""
 
 
 class SubscriptionManager:
@@ -66,12 +79,15 @@ class SubscriptionManager:
         ua_client: Client,
         publishing_interval_ms: float = 100,
         heartbeat_stale_after: float = 10.0,
+        max_items_per_call: int | None = None,
     ) -> None:
         """Create a new instance.
 
         :param ua_client: OPC UA client to use.
         :param publishing_interval_ms: Publishing interval in milliseconds for OPC UA subscription
         :param heartbeat_stale_after: Time in seconds until any subscription should be received.
+        :param max_items_per_call: Maximum number of OPC UA monitored items per call. If ``None``, will be read from the
+            servers ``MaxMonitoredItemsPerCall``.
         """
         self._publishing_interval_ms = publishing_interval_ms
         self._ua_client = ua_client
@@ -84,6 +100,7 @@ class SubscriptionManager:
         self._heartbeat_task: Task[Never] | None = None
         self._last_heartbeat = time.monotonic()
         self._heartbeat_stale_after = heartbeat_stale_after
+        self._max_items_per_call: int | None = max_items_per_call
 
         self.logger = structlog.getLogger("opensmi.SubscriptionManager")
 
@@ -93,6 +110,20 @@ class SubscriptionManager:
         )
         self.logger.info("Created subscription!", parameters=self._ua_subscription.parameters)
 
+    async def _read_max_items_per_call(self) -> None:
+        fallback_value = 100
+        ua_max_monitored_items_per_call = self._ua_client.get_node(
+            ua.object_ids.ObjectIds.Server_ServerCapabilities_OperationLimits_MaxMonitoredItemsPerCall
+        )
+        try:
+            self._max_items_per_call = await ua_max_monitored_items_per_call.read_value() or fallback_value
+        except UaStatusCodeError as err:
+            self.logger.warning(
+                "Could not read server limit", ua_node=ua_max_monitored_items_per_call.nodeid.to_string(), reason=err
+            )
+            self._max_items_per_call = fallback_value
+        self.logger.debug("Updated max_items_per_call", value=self._max_items_per_call)
+
     async def init(self) -> None:
         """Create the subscription and start heartbeat monitoring.
 
@@ -101,7 +132,10 @@ class SubscriptionManager:
         if self._heartbeat_task is not None:
             return
 
-        await self._create_subscription()
+        async with asyncio.TaskGroup() as tg:
+            if self._max_items_per_call is None:
+                tg.create_task(self._read_max_items_per_call())
+            tg.create_task(self._create_subscription())
 
         # subscribe to a node that always changes reliably, for example the current time of the server
         # this is done to prevent the subscription from timing out
@@ -127,13 +161,21 @@ class SubscriptionManager:
     # TODO(CaHa): What about the subscriptions that could not be renewed?
 
     async def _renew_data_change_subscriptions(self) -> None:
-        for node_id, monitored_item in list(self._data_subscription_map.items()):
-            try:
-                handle = await self._ua_subscription.subscribe_data_change(self._ua_client.get_node(node_id))
-                monitored_item.handle = handle
-            except UaStatusCodeError as err:
-                monitored_item.handle = None
-                self.logger.warning("Could not renew data change subscription", node=node_id.to_string(), reason=err)
+        node_ids = list(self._data_subscription_map)
+        nodes = [self._ua_client.get_node(node_id) for node_id in node_ids]
+        results = await self._create_data_items(nodes)
+        for node_id, result in zip(node_ids, results, strict=True):
+            item = self._data_subscription_map.get(node_id)  # may be gone
+            if item is None:
+                continue
+
+            if isinstance(result, ua.StatusCode):
+                item.handle = None
+                self.logger.warning(
+                    "Could not renew data change subscription", node=node_id.to_string(), reason=result.name
+                )
+            else:
+                item.handle = result
 
     async def _renew_event_subscriptions(self) -> None:
         for node_id, monitored_item in list(self._event_subscription_map.items()):
@@ -192,36 +234,88 @@ class SubscriptionManager:
         """Return the number of monitored nodes."""
         return len(self._data_subscription_map) + len(self._event_subscription_map)
 
+    async def _create_data_items(self, nodes: Sequence[Node]) -> list[int | ua.StatusCode]:
+        """Batches node subscriptions respecting server's max items per call limit.
+
+        :return: List of handles of the subscription or status codes on failure.
+        """
+        results: list[int | ua.StatusCode] = []
+        size = self._max_items_per_call or len(nodes)
+        for i in range(0, len(nodes), size):
+            batch = nodes[i : i + size]
+            self.logger.debug("Subscribing to data changes", count=len(batch))
+            results.extend(await self._ua_subscription.subscribe_data_change(batch))
+        return results
+
+    def _collect_wanted(
+        self,
+        subscriptions: Iterable[tuple[UaDataChangeSubscriber, Node | NodeId | Iterable[Node | NodeId]]],
+    ) -> dict[NodeId, _Wanted]:
+        wanted: dict[NodeId, _Wanted] = {}
+        for handler, nodes in subscriptions:
+            if not isinstance(nodes, Iterable):
+                nodes = [nodes]
+            for node in nodes:
+                if isinstance(node, NodeId):
+                    node = self._ua_client.get_node(node)
+                entry = wanted.setdefault(node.nodeid, _Wanted(node))
+                if handler not in entry.handlers:
+                    entry.handlers.append(handler)
+        return wanted
+
+    def _attach_to_monitored(self, wanted: dict[NodeId, _Wanted]) -> list[Node]:
+        new_nodes: list[Node] = []
+        for node_id, entry in wanted.items():
+            item = self._data_subscription_map.get(node_id)
+            if item is None:
+                new_nodes.append(entry.node)
+            else:
+                item.add_handlers(entry.handlers)
+        return new_nodes
+
+    async def _subscribe_new_nodes(
+        self, new_nodes: list[Node], wanted: dict[NodeId, _Wanted]
+    ) -> dict[Node, ua.StatusCode]:
+        results: list[int | ua.StatusCode] = await self._create_data_items(new_nodes)
+
+        errors: dict[Node, ua.StatusCode] = {}
+        for node, result in zip(new_nodes, results, strict=True):
+            if isinstance(result, ua.StatusCode):
+                errors[node] = result
+                continue
+
+            handlers: list[UaDataChangeSubscriber] = wanted[node.nodeid].handlers
+            if (item := self._data_subscription_map.get(node.nodeid)) is None:
+                self._data_subscription_map[node.nodeid] = _MonitoredItem(handle=result, handlers=handlers)
+            else:
+                item.add_handlers(handlers)
+        return errors
+
     async def subscribe_data_change(
         self, handler: UaDataChangeSubscriber, nodes: Node | NodeId | Iterable[Node | NodeId]
-    ) -> None:
-        """Add given handler to receive data change notifications for given nodes."""
-        if not isinstance(nodes, Iterable):
-            nodes = [nodes]  # create a list out of the given single node or node id
+    ) -> dict[Node, ua.StatusCode]:
+        """Add given ``handler`` to receive data change notifications for given nodes.
 
-        for node in nodes:
-            if isinstance(node, NodeId):
-                node = self._ua_client.get_node(node)
-
-            if node.nodeid not in self._data_subscription_map:
-                try:
-                    handle = await self._ua_subscription.subscribe_data_change(node)
-                    self._data_subscription_map[node.nodeid] = _MonitoredItem(handle=handle, handlers=[handler])
-                    self.logger.debug(
-                        "Added data change handler", handler=handler, node=node.nodeid.to_string(), handle=handle
-                    )
-                except BadAttributeIdInvalid:
-                    self.logger.warning("Node does not support subscription!", node=node.nodeid.to_string())
-                except UaStatusCodeError as err:
-                    self.logger.exception("Unexpected UA error!", err=err)
-            else:
-                # We only need 1 subscription for n handlers.
-                self.logger.debug(
-                    "Added data change handler, reusing existing subscription.",
-                    handler=handler,
-                    node=node.nodeid.to_string(),
-                )
-                self._data_subscription_map[node.nodeid].handlers.append(handler)
+        Note: Any given ``handler`` can only be subscribed once to each node.
+
+        :return: OPC UA error status codes for all failed subscriptions. Mapping of node to status code.
+        """
+        return await self.subscribe_data_change_batch([(handler, nodes)])
+
+    async def subscribe_data_change_batch(
+        self,
+        subscriptions: Iterable[tuple[UaDataChangeSubscriber, Node | NodeId | Iterable[Node | NodeId]]],
+    ) -> dict[Node, ua.StatusCode]:
+        """Subscribe many handlers to many nodes using as few server calls as possible.
+
+        :param subscriptions: Pairs of ``(handler, nodes)``. A node may appear for several handlers.
+        :return: OPC UA error status codes for all failed subscriptions. Mapping of node to status code.
+        """
+        wanted = self._collect_wanted(subscriptions)
+        new_nodes = self._attach_to_monitored(wanted)
+        if not new_nodes:
+            return {}
+        return await self._subscribe_new_nodes(new_nodes, wanted)
 
     async def subscribe_event(self, handler: UaEventSubscriber, source_node: Node | NodeId) -> None:
         """Add given handler to receive event notifications for given node."""

opensmi_core-0.4/src/OpenSMI_Core.egg-info/scm_version.json

@@ -1,8 +0,0 @@
-{
-  "tag": "0.4",
-  "distance": 0,
-  "node": "gf395f24046a13a5a9c4b6536f16e250aada34582",
-  "dirty": false,
-  "branch": "HEAD",
-  "node_date": "2026-10-12"
-}