remotivelabs-cli 0.5.0a1__py3-none-any.whl

remotivelabs/cli/broker/lib/client.py

@@ -0,0 +1,224 @@
+from __future__ import annotations
+
+import binascii
+import json
+import queue
+from threading import Thread
+from typing import Any, Callable, Iterable, Iterator, List, Optional, Union
+
+import grpc
+
+import remotivelabs.broker._generated.common_pb2 as common
+import remotivelabs.broker._generated.network_api_pb2 as network_api
+import remotivelabs.broker._generated.network_api_pb2_grpc as network_api_grpc
+import remotivelabs.broker._generated.system_api_pb2_grpc as system_api_grpc
+import remotivelabs.broker._generated.traffic_api_pb2_grpc as traffic_api_grpc
+from remotivelabs.cli.broker.lib.helper import act_on_signal, create_channel
+from remotivelabs.cli.broker.lib.signalcreator import SignalCreator
+
+
+class SignalValue:
+    """
+    Wrapper around protobuf generated class to make it a bit simpler to use
+    to make us learn how we want the next version of the API to look like.
+
+    Use the signal.is_{type}() functions to validate type before you get value.
+    Use signal.value() to get the actual value without any validation.
+    Use signal.get_raw() to get the raw bytes
+    Use signal.{type}_value() to get a validated typed value or error if something is wrong
+    """
+
+    def __init__(self, signal: network_api.Signal):
+        self.signal: network_api.Signal = signal
+
+    def __str__(self) -> str:
+        return self.to_json()
+
+    def to_json(self) -> str:
+        return json.dumps(self.as_dict())
+
+    def is_integer(self) -> bool:
+        return self.signal.HasField("integer")
+
+    def is_double(self) -> bool:
+        return self.signal.HasField("double")
+
+    def is_arbitration(self) -> bool:
+        return self.signal.HasField("arbitration")
+
+    def is_raw(self) -> bool:
+        return self.signal.raw != b""
+
+    def get_raw(self) -> Union[bytes, None]:
+        if self.is_raw():
+            return self.signal.raw
+        return None
+
+    def __get_value(self) -> Union[str, int, float, bool, None]:
+        if self.signal.raw != b"":
+            return "0x" + binascii.hexlify(self.signal.raw).decode("ascii")
+        if self.signal.HasField("integer"):
+            return self.signal.integer
+        if self.signal.HasField("double"):
+            return self.signal.double
+        if self.signal.HasField("arbitration"):
+            return self.signal.arbitration
+        return None
+
+    def timestamp_us(self) -> int:
+        return self.signal.timestamp
+
+    def name(self) -> str:
+        return self.signal.id.name
+
+    def namespace(self) -> str:
+        return self.signal.id.namespace.name
+
+    def value(self) -> Union[str, int, float, bool, None]:
+        return self.__get_value()
+
+    def __get_with_ensured_type(self, t: type) -> Any:
+        v = self.__get_value()
+        if isinstance(v, t):
+            return v
+        raise BrokerException(f"{v} was not expected type '{t}' but got '{type(v)}'")
+
+    def float_value(self) -> float:
+        return self.__get_with_ensured_type(float)  # type: ignore
+
+    def int_value(self) -> int:
+        return self.__get_with_ensured_type(int)  # type: ignore
+
+    def bool_value(self) -> bool:
+        return self.__get_with_ensured_type(bool)  # type: ignore
+
+    def bytes_value(self) -> bytes:
+        return self.__get_with_ensured_type(bytes)  # type: ignore
+
+    def as_dict(self) -> dict[str, Any]:
+        return {
+            "timestamp_us": self.timestamp_us(),
+            "name": self.name(),
+            "namespace": self.namespace(),
+            "value": self.value(),
+        }
+
+
+class SignalsInFrame(Iterable[SignalValue]):
+    def __init__(self, signals: List[SignalValue]):
+        self.signals = signals
+        self.index = 0
+
+    def __iter__(self) -> Iterator[SignalValue]:
+        return self
+
+    def __next__(self) -> SignalValue:
+        try:
+            result = self.signals[self.index]
+        except IndexError:
+            raise StopIteration
+        self.index += 1
+        return result
+
+
+class SignalIdentifier:
+    def __init__(self, name: str, namespace: str):
+        self.name = name
+        self.namespace = namespace
+
+    @staticmethod
+    def parse(signal_id: str) -> SignalIdentifier:
+        s = signal_id.split(":")
+        if len(s) != 2:
+            raise BrokerException("signal names must have format namespace:signal_name")
+        return SignalIdentifier(s[1], s[0])
+
+
+class BrokerException(Exception):  # noqa: N818
+    pass
+
+
+class Client:
+    def __init__(self, client_id: str = "broker_client"):
+        self._signal_creator: SignalCreator
+        self._traffic_stub: traffic_api_grpc.TrafficServiceStub
+        self._system_stub: system_api_grpc.SystemServiceStub
+        self._network_stub: network_api_grpc.NetworkServiceStub
+        self._intercept_channel: grpc.Channel
+        self.client_id = client_id
+        self.url: Optional[str] = None
+        self.api_key: Optional[str] = None
+        self.on_connect: Union[Callable[[Client], None], None] = None
+        self.on_signals: Union[Callable[[SignalsInFrame], None], None] = None
+
+    def connect(self, url: str, api_key: Union[str, None] = None) -> None:
+        self.url = url
+        self.api_key = api_key
+        if url.startswith("https"):
+            if api_key is None:
+                raise BrokerException("You must supply api-key or access-token to use a cloud broker")
+            self._intercept_channel = create_channel(url, self.api_key, None)
+        else:
+            self._intercept_channel = create_channel(url, None, None)
+
+        self._network_stub = network_api_grpc.NetworkServiceStub(self._intercept_channel)
+        self._system_stub = system_api_grpc.SystemServiceStub(self._intercept_channel)
+        self._traffic_stub = traffic_api_grpc.TrafficServiceStub(self._intercept_channel)
+        self._signal_creator = SignalCreator(self._system_stub)
+        if self.on_connect is not None:
+            self.on_connect(self)
+
+    def subscribe(
+        self,
+        signals_to_subscribe_to: List[SignalIdentifier],
+        on_signals: Optional[Callable[[SignalsInFrame], None]] = None,
+        changed_values_only: bool = True,
+    ) -> Any:
+        client_id = common.ClientId(id="subscribe-sample")
+        if on_signals is None and self.on_signals is None:
+            raise BrokerException(
+                "You have not specified global client.on_signals nor client.subscribe(on_signals=callback), "
+                "or you are invoking subscribe() before client.on_signals which is not allowed"
+            )
+
+        def to_protobuf_signal(s: SignalIdentifier) -> common.SignalId:
+            return self._signal_creator.signal(s.name, s.namespace)
+
+        _signals_to_subscribe_on = list(map(to_protobuf_signal, signals_to_subscribe_to))
+        wait_for_subscription_queue: queue.Queue[tuple[str, Any]] = queue.Queue()
+        Thread(
+            target=act_on_signal,
+            args=(
+                client_id,
+                self._network_stub,
+                _signals_to_subscribe_on,
+                changed_values_only,  # True: only report when signal changes
+                lambda frame: self._on_signals(frame, on_signals),
+                lambda sub: (wait_for_subscription_queue.put((self.client_id, sub))),
+            ),
+        ).start()
+        # Wait for subscription
+        client_id, subscription = wait_for_subscription_queue.get()  # type: ignore[assignment]
+        return subscription
+
+    def _on_signals(self, signals_in_frame: network_api.Signals, callback: Optional[Callable[[SignalsInFrame], None]]) -> None:
+        """
+        Updates "local" callback or global on_signals callback if local callback is None
+        """
+        if callback is not None:
+            callback(SignalsInFrame(list(map(SignalValue, signals_in_frame))))  # type: ignore[call-overload]
+        elif self.on_signals is not None:
+            self.on_signals(SignalsInFrame(list(map(SignalValue, signals_in_frame))))  # type: ignore[call-overload]
+
+    def list_signal_names(self) -> List[SignalIdentifier]:
+        # Lists available signals
+        configuration = self._system_stub.GetConfiguration(common.Empty())
+
+        signal_names: List[SignalIdentifier] = []
+        for network_info in configuration.networkInfo:
+            res = self._system_stub.ListSignals(network_info.namespace)
+            for finfo in res.frame:
+                signal_names.append(SignalIdentifier(finfo.signalInfo.id.name, network_info.namespace.name))
+                for sinfo in finfo.childInfo:
+                    signal_names.append(SignalIdentifier(sinfo.id.name, network_info.namespace.name))
+        return signal_names

remotivelabs/cli/broker/lib/helper.py

@@ -0,0 +1,277 @@
+from __future__ import annotations
+
+import hashlib
+import itertools
+import ntpath
+import os
+import posixpath
+from glob import glob
+from logging import getLogger
+from typing import Any, BinaryIO, Callable, Generator, Optional, Sequence
+from urllib.parse import urlparse
+
+import grpc
+from grpc_interceptor import ClientCallDetails, ClientInterceptor
+
+import remotivelabs.broker._generated.common_pb2 as common
+import remotivelabs.broker._generated.network_api_pb2 as network_api
+import remotivelabs.broker._generated.network_api_pb2_grpc as network_api_grpc
+import remotivelabs.broker._generated.system_api_pb2 as system_api
+import remotivelabs.broker._generated.system_api_pb2_grpc as system_api_grpc
+from remotivelabs.cli.utils.console import print_generic_error
+
+log = getLogger(__name__)
+
+
+class HeaderInterceptor(ClientInterceptor):
+    def __init__(self, header_dict: dict[str, str]):
+        self.header_dict = header_dict
+
+    def intercept(
+        self,
+        method: Callable[[Any, ClientCallDetails], Any],
+        request_or_iterator: Any,
+        call_details: grpc.ClientCallDetails,
+    ) -> Any:
+        new_details = ClientCallDetails(
+            call_details.method,
+            call_details.timeout,
+            self.header_dict.items(),  # type: ignore[arg-type]
+            call_details.credentials,
+            call_details.wait_for_ready,
+            call_details.compression,
+        )
+
+        return method(request_or_iterator, new_details)
+
+
+def create_channel(url: str, x_api_key: Optional[str] = None, authorization_token: Optional[str] = None) -> grpc.Channel:
+    """
+    Create communication channels for gRPC calls.
+    """
+
+    parsed_url = urlparse(url)
+    if parsed_url.hostname is None:
+        msg = f"invalid url {url}, missing hostname"
+        raise ValueError(msg)
+
+    if parsed_url.scheme == "https":
+        creds = grpc.ssl_channel_credentials(root_certificates=None, private_key=None, certificate_chain=None)
+        channel = grpc.secure_channel(parsed_url.hostname + ":" + str(parsed_url.port or "443"), creds)
+    else:
+        addr = parsed_url.hostname + ":" + str(parsed_url.port or "50051")
+        channel = grpc.insecure_channel(addr)
+
+    if x_api_key is None and authorization_token is None:
+        return channel
+
+    if x_api_key is not None:
+        return grpc.intercept_channel(channel, HeaderInterceptor({"x-api-key": x_api_key}))
+
+    # Adding both x-api-key (old) and authorization header for compatibility
+    return grpc.intercept_channel(
+        channel,
+        HeaderInterceptor(
+            {
+                "x-api-key": authorization_token,  # type: ignore
+                "authorization": f"Bearer {authorization_token}",
+            }
+        ),
+    )
+
+
+def publish_signals(
+    client_id: common.ClientId,
+    stub: network_api_grpc.NetworkServiceStub,
+    signals_with_payload: Sequence[network_api.Signal],
+    frequency: int = 0,
+) -> None:
+    """
+    Publish array of values for signals
+    """
+
+    publisher_info = network_api.PublisherConfig(
+        clientId=client_id,
+        signals=network_api.Signals(signal=signals_with_payload),
+        frequency=frequency,
+    )
+
+    try:
+        stub.PublishSignals(publisher_info)
+    except grpc._channel._Rendezvous as err:  # type:ignore[attr-defined]
+        log.error(err)
+
+
+def printer(signals: Sequence[common.SignalId]) -> None:
+    """
+    Debug printing of received array of signal with values.
+    """
+
+    for signal in signals:
+        log.info(f"{signal} {signal.namespace.name}")
+
+
+def get_sha256(path: str) -> str:
+    """
+    Calculate SHA256 for a file.
+    """
+
+    with open(path, "rb") as f:
+        b = f.read()  # read entire file as bytes
+        return hashlib.sha256(b).hexdigest()
+
+
+def generate_data(file: BinaryIO, dest_path: str, chunk_size: int, sha256: str) -> Generator[system_api.FileUploadRequest, None, None]:
+    for x in itertools.count(start=0):
+        if x == 0:
+            file_description = system_api.FileDescription(sha256=sha256, path=dest_path)
+            yield system_api.FileUploadRequest(fileDescription=file_description)
+        else:
+            buf = file.read(chunk_size)
+            if not buf:
+                break
+            yield system_api.FileUploadRequest(chunk=buf)
+
+
+def upload_file(system_stub: system_api_grpc.SystemServiceStub, path: str, dest_path: str) -> None:
+    """
+    Upload single file to internal storage on broker.
+    """
+
+    sha256 = get_sha256(path)
+    log.debug(f"SHA256 for file {path}: {sha256}")
+    with open(path, "rb") as file:
+        # make sure path is unix style (necessary for windows, and does no harm om
+        # linux)
+        upload_iterator = generate_data(file, dest_path.replace(ntpath.sep, posixpath.sep), 1000000, sha256)
+        response = system_stub.UploadFile(upload_iterator, compression=grpc.Compression.Gzip)
+        log.debug(f"Uploaded {path} with response {response}")
+
+
+def download_file(system_stub: system_api_grpc.SystemServiceStub, path: str, dest_path: str) -> None:
+    """
+    Download file from Broker remote storage.
+    """
+
+    with open(dest_path, "wb") as file:
+        for response in system_stub.BatchDownloadFiles(
+            system_api.FileDescriptions(fileDescriptions=[system_api.FileDescription(path=path.replace(ntpath.sep, posixpath.sep))])
+        ):
+            assert not response.HasField("errorMessage"), f"Error uploading file, message is: {response.errorMessage}"
+            file.write(response.chunk)
+
+
+def upload_folder(system_stub: system_api_grpc.SystemServiceStub, folder: str) -> None:
+    """
+    Upload directory and its content to Broker remote storage.
+    """
+
+    files = [y for x in os.walk(folder) for y in glob(os.path.join(x[0], "*")) if not os.path.isdir(y)]
+    assert len(files) != 0, "Specified upload folder is empty or does not exist"
+    for file in files:
+        upload_file(system_stub, file, file.replace(folder, ""))
+
+
+def reload_configuration(
+    system_stub: system_api_grpc.SystemServiceStub,
+) -> None:
+    """
+    Trigger reload of configuration on Broker.
+    """
+
+    request = common.Empty()
+    response = system_stub.ReloadConfiguration(request, timeout=60000)
+    log.debug(f"Reload configuration with response {response}")
+
+
+def check_license(
+    system_stub: system_api_grpc.SystemServiceStub,
+) -> None:
+    """
+    Check license to Broker. Throws exception if failure.
+    """
+    status = system_stub.GetLicenseInfo(common.Empty()).status
+    assert status == system_api.LicenseStatus.VALID, f"Check your license, status is: {status}"
+
+
+def act_on_signal(  # noqa: PLR0913
+    client_id: common.ClientId,
+    network_stub: network_api_grpc.NetworkServiceStub,
+    sub_signals: Sequence[common.SignalId],
+    on_change: bool,
+    fun: Callable[[Sequence[network_api.Signal]], None],
+    on_subscribed: Optional[Callable[..., None]] = None,
+) -> None:
+    """
+    Bind callback to be triggered when receiving any of the specified signals.
+    """
+
+    log.debug("Subscription started")
+
+    sub_info = network_api.SubscriberConfig(
+        clientId=client_id,
+        signals=network_api.SignalIds(signalId=sub_signals),
+        onChange=on_change,
+    )
+    try:
+        subscripton = network_stub.SubscribeToSignals(sub_info, timeout=None)
+        if on_subscribed:
+            on_subscribed(subscripton)
+        log.debug("Waiting for signal...")
+        for subs_counter in subscripton:
+            fun(subs_counter.signal)
+
+    except grpc.RpcError as e:
+        # Only try to cancel if cancel was not already attempted
+        if e.code() != grpc.StatusCode.CANCELLED:
+            try:
+                subscripton.cancel()
+                print_generic_error("A gRPC error occurred:")
+                print_generic_error(str(e))
+            except grpc.RpcError:
+                pass
+    except grpc._channel._Rendezvous as err:  # type:ignore[attr-defined]
+        log.error(err)
+    # reload, alternatively non-existing signal
+    log.debug("Subscription terminated")
+
+
+def act_on_scripted_signal(  # noqa: PLR0913
+    client_id: common.ClientId,
+    network_stub: network_api_grpc.NetworkServiceStub,
+    script: bytes,
+    on_change: bool,
+    fun: Callable[[Sequence[network_api.Signal]], None],
+    on_subscribed: Optional[Callable[..., None]] = None,
+) -> None:
+    """
+    Bind callback to be triggered when receiving any of the specified signals.
+    """
+
+    log.debug("Subscription with mapping code started...")
+
+    sub_info = network_api.SubscriberWithScriptConfig(
+        clientId=client_id,
+        script=script,
+        onChange=on_change,
+    )
+    try:
+        subscription = network_stub.SubscribeToSignalWithScript(sub_info, timeout=None)
+        if on_subscribed:
+            on_subscribed(subscription)
+        log.debug("Waiting for signal...")
+        for subs_counter in subscription:
+            fun(subs_counter.signal)
+
+    except grpc.RpcError as e:
+        try:
+            subscription.cancel()
+            print_generic_error("A gRPC error occurred:")
+            print_generic_error(str(e))
+        except grpc.RpcError:
+            pass
+
+    except grpc._channel._Rendezvous as err:  # type:ignore[attr-defined]
+        log.error(err)
+    # reload, alternatively non-existing signal
+    log.debug("Subscription terminated")

remotivelabs/cli/broker/lib/signalcreator.py

@@ -0,0 +1,196 @@
+from __future__ import annotations
+
+import logging
+from typing import Any, Dict, List, Optional, Sequence, TypeVar
+
+import remotivelabs.broker._generated.common_pb2 as common
+import remotivelabs.broker._generated.network_api_pb2 as network_api
+import remotivelabs.broker._generated.system_api_pb2_grpc as system_api_grpc
+
+T = TypeVar("T")
+
+_logger = logging.getLogger("remotivelabs.SignalCreator")
+_MSG_DUPLICATE = "Warning duplicated (namespace.signal): {}, to avoid" + 'ambiguity set "short_names": false in your interfaces.json on {}'
+
+
+class MetaGetter:
+    def __init__(self, proto_message: Any):
+        self.meta = proto_message
+
+    def _getDefault(self, field: T, default: Optional[T]) -> T:  # noqa: N802
+        if field is not None:
+            return field
+
+        if default:
+            return default
+
+        raise Exception("Failed to retrieve meta data field")
+
+    def getDescription(self, default: Optional[str] = None) -> str:  # noqa: N802
+        """Get protobuffer MetaData field description"""
+        return self._getDefault(self.meta.description, default)  # type: ignore
+
+    def getUnit(self, default: Optional[str] = None) -> str:  # noqa: N802
+        """Get protobuffer MetaData field unit"""
+        return self._getDefault(self.meta.unit, default)  # type: ignore
+
+    def getMax(self, default: Optional[float] = None) -> float:  # noqa: N802
+        """Get protobuffer MetaData field max"""
+        return self._getDefault(self.meta.max, default)  # type: ignore
+
+    def getMin(self, default: Optional[float] = None) -> float:  # noqa: N802
+        """Get protobuffer MetaData field min"""
+        return self._getDefault(self.meta.min, default)  # type: ignore
+
+    def getSize(self, default: Optional[int] = None) -> int:  # noqa: N802
+        """Get protobuffer MetaData field size"""
+        return self._getDefault(self.meta.size, default)  # type: ignore
+
+    def getIsRaw(self, default: Optional[bool] = None) -> bool:  # noqa: N802
+        """Get protobuffer MetaData field isRaw"""
+        return self._getDefault(self.meta.isRaw, default)  # type: ignore
+
+    def getFactor(self, default: Optional[float] = None) -> float:  # noqa: N802
+        """Get protobuffer MetaData field factor"""
+        return self._getDefault(self.meta.factor, default)  # type: ignore
+
+    def getOffset(self, default: Optional[float] = None) -> float:  # noqa: N802
+        """Get protobuffer MetaData field offset"""
+        return self._getDefault(self.meta.offset, default)  # type: ignore
+
+    def getSenders(self, default: Optional[Sequence[str]] = None) -> Sequence[str]:  # noqa: N802
+        """Get protobuffer MetaData field sender"""
+        return self._getDefault(self.meta.sender, default)
+
+    def getReceivers(self, default: Optional[Sequence[str]] = None) -> Sequence[str]:  # noqa: N802
+        """Get protobuffer MetaData field receiver"""
+        return self._getDefault(self.meta.receiver, default)
+
+    def getCycleTime(self, default: Optional[float] = None) -> float:  # noqa: N802
+        """Get protobuffer MetaData field cycleTime"""
+        return self._getDefault(self.meta.cycleTime, default)  # type: ignore
+
+    def getStartValue(self, default: Optional[float] = None) -> float:  # noqa: N802
+        """Get protobuffer MetaData field startValue"""
+        return self._getDefault(self.meta.startValue, default)  # type: ignore
+
+
+class SignalCreator:
+    """
+    Class for prepearing and writing signals via gRPC.
+    """
+
+    def __init__(self, system_stub: system_api_grpc.SystemServiceStub, namespaces: List[str] | None = None):
+        self._sinfos: Dict[Any, Any] = {}
+        self._virtual: List[Any] = []
+        self._networks: Dict[Any, Any] = {}
+        nss: List[common.NameSpace] = []
+        if namespaces is None:
+            conf = system_stub.GetConfiguration(common.Empty())
+            for ninfo in conf.networkInfo:
+                nss.append(ninfo.namespace)
+                if ninfo.type == "virtual":
+                    self._virtual.append(ninfo.namespace.name)
+        else:
+            nss = list(map(lambda namespace: common.NameSpace(name=namespace), namespaces))
+
+        for namespace in nss:
+            res = system_stub.ListSignals(namespace)
+            self._addframes(namespace, res)
+            for finfo in res.frame:
+                self._add(finfo.signalInfo)
+                for sinfo in finfo.childInfo:
+                    self._add(sinfo)
+
+    def _addframes(self, namespace: common.NameSpace, res: common.Frames) -> None:
+        self._networks[namespace.name] = res
+
+    def _add(self, sinfo: common.SignalInfo) -> None:
+        k = (sinfo.id.namespace.name, sinfo.id.name)
+        if k in self._sinfos:
+            msg = _MSG_DUPLICATE.format(k, sinfo.id.namespace)
+            _logger.warning(msg)
+        self._sinfos[k] = MetaGetter(sinfo.metaData)
+
+    def get_meta(self, name: str, namespace_name: str) -> MetaGetter:
+        """
+        Get meta fields for signal or frame
+        """
+
+        k = (namespace_name, name)
+        if (k not in self._sinfos) and (namespace_name not in self._virtual):
+            raise Exception(f"signal not declared (namespace, signal): {k}")
+        return self._sinfos[k]  # type: ignore
+
+    def signal(self, name: str, namespace_name: str) -> common.SignalId:
+        """
+        Create object for signal.
+        """
+
+        self.get_meta(name, namespace_name)  # Checks if the signal is present
+        return common.SignalId(name=name, namespace=common.NameSpace(name=namespace_name))
+
+    def frames(self, namespace_name: str) -> Sequence[common.SignalId]:
+        """
+        Get all frames in given namespace
+        """
+
+        all_frames = []
+        for finfo in self._networks[namespace_name].frame:
+            all_frames.append(self.signal(finfo.signalInfo.id.name, namespace_name))
+        return all_frames
+
+    def frame_by_signal(self, name: str, namespace_name: str) -> common.SignalId:
+        """
+        Get frame for the given signal.
+        """
+
+        for finfo in self._networks[namespace_name].frame:
+            for sinfo in finfo.childInfo:
+                if sinfo.id.name == name:
+                    return self.signal(finfo.signalInfo.id.name, namespace_name)
+        raise Exception(f"signal not declared (namespace, signal): {namespace_name} {name}")
+
+    def signals_in_frame(self, name: str, namespace_name: str) -> Sequence[common.SignalId]:
+        """
+        Get all signals residing in the frame.
+        """
+
+        all_signals = []
+        frame = None
+        for finfo in self._networks[namespace_name].frame:
+            if finfo.signalInfo.id.name == name:
+                frame = finfo
+                for sinfo in finfo.childInfo:
+                    all_signals.append(self.signal(sinfo.id.name, namespace_name))
+        assert frame is not None, f"frame {name} does not exist in namespace {namespace_name}"
+        return all_signals
+
+    def signal_with_payload(
+        self, name: str, namespace_name: str, value_pair: tuple[str, Any], allow_malformed: bool = False
+    ) -> network_api.Signal:
+        """
+        Create value with signal for writing.
+        """
+
+        signal = self.signal(name, namespace_name)
+        meta = self.get_meta(name, namespace_name)
+
+        key, value = value_pair
+        types = ["integer", "double", "raw", "arbitration"]
+        if key not in types:
+            raise Exception(f"type must be one of: {types}")
+        if key == "raw" and allow_malformed is False:
+            expected = meta.getSize()
+            assert len(value) * 8 == expected, f"payload size missmatch, expected {expected / 8} bytes"
+        elif key != "raw":
+            # Check bounds if any
+            check_min = meta.getMin()
+            if (check_min is not None) and (value < check_min):
+                _logger.warning(f'Value below minimum value of {check_min} for signal "{name}"')
+            check_max = meta.getMax()
+            if (check_max is not None) and (value > check_max):
+                _logger.warning(f'Value above maximum value of {check_max} for signal "{name}"')
+
+        params = {"id": signal, key: value}
+        return network_api.Signal(**params)