gridworks-admin 1.0.0.dev5__tar.gz → 1.0.0.dev7__tar.gz

{gridworks_admin-1.0.0.dev5 → gridworks_admin-1.0.0.dev7}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.3
 Name: gridworks-admin
-Version: 1.0.0.dev5
+Version: 1.0.0.dev7
 Summary: CLI tool for monitoring gridworks-scada devices.
 Author: Andrew Schweitzer
 Author-email: Andrew Schweitzer <schweitz72@gmail.com>
 Requires-Dist: gridworks-proactor>=4.1.9
-Requires-Dist: gridworks-scada-protocol
+Requires-Dist: gridworks-scada-protocol>=1.0.0.dev5
 Requires-Dist: numpy>=2.3.3
 Requires-Dist: paho-mqtt>=2.1.0
 Requires-Dist: pydantic>=2.11.9

{gridworks_admin-1.0.0.dev5 → gridworks_admin-1.0.0.dev7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "gridworks-admin"
-version = "1.0.0.dev5"
+version = "1.0.0.dev7"
 description = "CLI tool for monitoring gridworks-scada devices."
 readme = "README.md"
 authors = [
@@ -9,7 +9,7 @@ authors = [
 requires-python = ">=3.11"
 dependencies = [
     "gridworks-proactor>=4.1.9",
-    "gridworks-scada-protocol",
+    "gridworks-scada-protocol>=1.0.0.dev5",
     "numpy>=2.3.3",
     "paho-mqtt>=2.1.0",
     "pydantic>=2.11.9",

{gridworks_admin-1.0.0.dev5 → gridworks_admin-1.0.0.dev7}/src/gwadmin/cli.py

@@ -14,7 +14,7 @@ from pydantic import SecretStr
 from gwadmin.config import AdminConfig
 from gwadmin.config import AdminPaths
 from gwadmin.config import CurrentAdminConfig
-from gwadmin.config import LessSecretMQTTClient
+from gwadmin.config import AdminMQTTClient
 from gwadmin.watch.relay_app import RelaysApp, __version__
 from gwsproto.data_classes.house_0_names import H0N
 
@@ -39,8 +39,6 @@ app = typer.Typer(
     help=f"GridWorks Scada Admin Client, version {__version__}",
 )
 
-DEFAULT_TARGET: str = "d1.isone.me.versant.keene.orange.scada"
-
 def get_config_name(env_file: str = "", config_name: Optional[str] = None) -> str:
     if config_name is None:
         if CONFIG_ENV_VAR in os.environ and os.environ[CONFIG_ENV_VAR]:
@@ -396,7 +394,7 @@ def add_scada(
     if current_config.add_scada(
             name,
             long_name=long_name,
-            mqtt_client_config=LessSecretMQTTClient(
+            mqtt_client_config=AdminMQTTClient(
                 host=host,
                 port=port,
                 username=username,

{gridworks_admin-1.0.0.dev5 → gridworks_admin-1.0.0.dev7}/src/gwadmin/config.py

@@ -10,15 +10,20 @@ from pydantic import field_serializer
 from pydantic_settings import BaseSettings
 from pydantic_settings import SettingsConfigDict
 
-class LessSecretMQTTClient(MQTTClient):
+MAX_ADMIN_TIMEOUT = 60 * 60 * 24
+DEFAULT_ADMIN_TIMEOUT = 5 * 60
+
+class AdminMQTTClient(MQTTClient):
+
     @field_serializer("password", when_used="json")
     def dump_secret(self, v):
         return v.get_secret_value()
 
 
 class ScadaConfig(BaseSettings):
-    mqtt: LessSecretMQTTClient = LessSecretMQTTClient()
+    enabled: bool = True
     long_name: str = ""
+    mqtt: AdminMQTTClient = AdminMQTTClient()
 
 class AdminConfig(BaseModel):
     scadas: dict[str, ScadaConfig] = {}
@@ -28,7 +33,7 @@ class AdminConfig(BaseModel):
     paho_verbosity: Optional[int] = None
     show_clock: bool = False
     show_footer: bool = False
-    default_timeout_seconds: int = int(5*60)
+    default_timeout_seconds: int = DEFAULT_ADMIN_TIMEOUT
 
 class AdminPaths(Paths):
 
@@ -68,7 +73,7 @@ class CurrentAdminConfig(BaseModel):
         with self.paths.admin_config_path.open(mode="w") as file:
             file.write(self.config.model_dump_json(indent=2))
 
-    def add_scada(self, short_name: str, long_name: str, mqtt_client_config: LessSecretMQTTClient) -> Optional[ScadaConfig]:
+    def add_scada(self, short_name: str, long_name: str, mqtt_client_config: AdminMQTTClient) -> Optional[ScadaConfig]:
         if short_name not in self.config.scadas:
             self.config.scadas[short_name] = ScadaConfig(
                 long_name=long_name,
@@ -81,4 +86,4 @@ class CurrentAdminConfig(BaseModel):
     def last_scada(self) -> str:
         if self.paths.last_scada_path.exists():
             return self.paths.last_scada_path.read_text()
-        return ""
+        return ""

{gridworks_admin-1.0.0.dev5 → gridworks_admin-1.0.0.dev7}/src/gwadmin/watch/clients/admin_client.py

@@ -4,6 +4,7 @@ import threading
 from dataclasses import dataclass
 from logging import Logger
 from typing import Any
+from typing import Callable
 from typing import Optional
 from typing import Sequence
 from typing import Type
@@ -34,6 +35,9 @@ def type_name(model_type: Type[BaseModel]) -> str:
         return str(field.default)
     return ""
 
+
+ScadaSelectionResetCallback = Callable[[], None]
+
 @dataclass
 class AdminClientCallbacks:
     """Hooks for user of AdminClient. Must be threadsafe."""
@@ -47,7 +51,8 @@ class AdminClientCallbacks:
     """Hook for user. Called when any mqtt message is received. Called from Paho
     thread. Must be threadsafe."""
 
-
+    scada_selection_reset: Optional[ScadaSelectionResetCallback] = None
+    """Hook for user. Called when scada selection reset."""
 
 class AdminSubClient:
 
@@ -183,6 +188,10 @@ class AdminClient:
     def switch_scada(self) -> None:
         self._logger.info(f"Switching to scada {self.curr_scada}")
         self.stop()
+        for subclient in self._subclients:
+            subclient.scada_selection_reset()
+        if self._callbacks.scada_selection_reset:
+            self._callbacks.scada_selection_reset()
         self._paho_wrapper = ConstrainedMQTTClient(
             settings=self.curr_scada_config.mqtt,
             subscriptions=[

gridworks_admin-1.0.0.dev7/src/gwadmin/watch/clients/dac_client.py

@@ -0,0 +1,319 @@
+import copy
+import datetime
+import logging
+import threading
+import uuid
+from dataclasses import dataclass
+from logging import Logger
+from typing import Callable
+from typing import Optional
+from typing import Self
+from typing import Sequence
+
+from gwproto import Message as GWMessage
+from gwproto import MQTTTopic
+from gwproto.enums import ActorClass
+from gwproto.named_types import AnalogDispatch
+
+from gwproto.named_types import SingleReading
+from pydantic import BaseModel
+from pydantic import model_validator
+
+from gwadmin.watch.clients.admin_client import type_name
+from gwadmin.watch.clients.admin_client import AdminClient
+from gwadmin.watch.clients.admin_client import AdminSubClient
+from gwadmin.watch.clients.constrained_mqtt_client import MessageReceivedCallback
+from gwadmin.watch.clients.constrained_mqtt_client import StateChangeCallback
+from gwsproto.data_classes.house_0_names import H0N
+from gwsproto.named_types import AdminAnalogDispatch
+from gwsproto.named_types import (AdminKeepAlive, AdminReleaseControl,
+                         LayoutLite, SnapshotSpaceheat)
+
+module_logger = logging.getLogger(__name__)
+
+class DACConfig(BaseModel):
+    about_node_name: str = ""
+    channel_name: str = ""
+
+class DACState(BaseModel):
+    value: int
+    time: datetime.datetime
+
+class DACInfo(BaseModel):
+    config: DACConfig
+    observed: Optional[DACState] = None
+
+class ObservedDACStateChange(BaseModel):
+    old_state: Optional[DACState] = None
+    new_state: Optional[DACState] = None
+
+    @model_validator(mode="after")
+    def _model_validator(self) -> Self:
+        if self.old_state == self.new_state:
+            raise ValueError(
+                f"ERROR ObservedDACStateChange has no change: {self.old_state}"
+            )
+        return self
+
+DACStateChangeCallback = Callable[[dict[str, ObservedDACStateChange]], None]
+LayoutCallback = Callable[[LayoutLite], None]
+SnapshotCallback = Callable[[SnapshotSpaceheat], None]
+
+class DACConfigChange(BaseModel):
+    old_config: Optional[DACConfig] = None
+    new_config: Optional[DACConfig] = None
+
+    @model_validator(mode="after")
+    def _model_validator(self) -> Self:
+        if self.old_config == self.new_config:
+            raise ValueError(
+                f"ERROR DACConfigChange has no change: {self.old_config}"
+            )
+        return self
+
+DACConfigChangeCallback = Callable[[dict[str, DACConfigChange]], None]
+
+@dataclass
+class DACClientCallbacks:
+    """Hooks for user of DACWatchClient. Must be threadsafe."""
+
+    mqtt_state_change_callback: Optional[StateChangeCallback] = None
+    """Hook for user. Called when mqtt client 'state'
+    variable changes. Generally, but not exclusively, called from Paho thread.
+    Must be threadsafe."""
+
+    mqtt_message_received_callback: Optional[MessageReceivedCallback] = None
+    """Hook for user. Called when an mqtt message is received if that message is 
+     not DAC-related or 'pass_all_messages' is True. Called from Paho thread.
+     Must be threadsafe."""
+
+    dac_state_change_callback: Optional[DACStateChangeCallback] = None
+    """Hook for user. Called when a DAC state change is observed. 
+    Called from Paho thread. Must be threadsafe."""
+
+    dac_config_change_callback: Optional[DACConfigChangeCallback] = None
+    """Hook for user. Called when a DAC config change is observed. 
+    Called from Paho thread. Must be threadsafe."""
+
+    layout_callback: Optional[LayoutCallback] = None
+    """Hook for user. Called when a layout received. Called from Paho thread. 
+    Must be threadsafe."""
+
+    snapshot_callback: Optional[SnapshotCallback] = None
+    """Hook for user. Called when a snapshot received. Called from Paho thread. 
+    Must be threadsafe."""
+
+class DACWatchClient(AdminSubClient):
+    _lock: threading.RLock
+    _dacs: dict[str, DACInfo]
+    _channel2node: dict[str, str]
+    _pass_all_message: bool = False
+    _admin_client: AdminClient
+    _callbacks: DACClientCallbacks
+    _layout: Optional[LayoutLite] = None
+    _snap: Optional[SnapshotSpaceheat] = None
+    _logger: Logger | logging.LoggerAdapter[Logger] = module_logger
+
+    def __init__(
+            self,
+            callbacks: Optional[DACClientCallbacks] = None,
+            *,
+            pass_all_messages: bool = False,
+            logger: Logger | logging.LoggerAdapter[Logger] = module_logger,
+    ) -> None:
+        self._lock = threading.RLock()
+        self._callbacks = callbacks or DACClientCallbacks()
+        self._logger = logger
+        self._dacs = {}
+        self._channel2node = {}
+        self._pass_all_message = pass_all_messages
+
+    def set_admin_client(self, client: AdminClient) -> None:
+        self._admin_client = client
+
+    def set_callbacks(self, callbacks: DACClientCallbacks) -> None:
+        if self._admin_client.started():
+            raise ValueError(
+                "ERROR. AdminClient callbacks must be set before starting "
+                "the client."
+            )
+        self._callbacks = callbacks
+
+    @classmethod
+    def _get_dac_configs(cls, layout: LayoutLite) -> dict[str, DACConfig]:
+        dac_node_names = {node.Name for node in layout.ShNodes if node.ActorClass == ActorClass.ZeroTenOutputer}
+        dac_channels = {channel.AboutNodeName: channel for channel in layout.DataChannels if channel.AboutNodeName in dac_node_names}
+        return {
+            node_name : DACConfig(
+                about_node_name=node_name,
+                channel_name=dac_channels[node_name].Name,
+            ) for node_name in dac_node_names
+        }
+
+    def _update_layout(self, new_layout: LayoutLite) -> dict[str, DACConfigChange]:
+        with self._lock:
+            self._layout = new_layout.model_copy()
+            new_dac_configs = self._get_dac_configs(self._layout)
+            old_dac_names = set(self._dacs.keys())
+            new_dac_names = set(new_dac_configs.keys())
+            changed_configs = {}
+            for added_dac_name in (new_dac_names - old_dac_names):
+                self._dacs[added_dac_name] = DACInfo(
+                    config=new_dac_configs[added_dac_name],
+                )
+                changed_configs[added_dac_name] = DACConfigChange(
+                    old_config=None,
+                    new_config=new_dac_configs[added_dac_name],
+                )
+            for removed_dac_name in (old_dac_names - new_dac_names):
+                changed_configs[removed_dac_name] = DACConfigChange(
+                    old_config=self._dacs.pop(removed_dac_name).config,
+                    new_config=None,
+                )
+            for dac_name in new_dac_names.intersection(old_dac_names):
+                new_config = new_dac_configs[dac_name]
+                if new_config != self._dacs[dac_name].config:
+                    changed_configs[dac_name] = DACConfigChange(
+                        old_config=self._dacs[dac_name].config,
+                        new_config=new_config,
+                    )
+                    self._dacs[dac_name].config = new_config
+            if changed_configs:
+                self._channel2node = {
+                    DAC.config.channel_name: DAC.config.about_node_name
+                    for DAC in self._dacs.values()
+                }
+        return changed_configs
+
+    def process_layout_lite(self, layout: LayoutLite) -> None:
+        config_changes = self._update_layout(layout)
+        if config_changes and self._callbacks.dac_config_change_callback is not None:
+            self._callbacks.dac_config_change_callback(config_changes)
+        if self._callbacks.layout_callback is not None:
+            self._callbacks.layout_callback(layout)
+        if self._snap is not None:
+           self._process_snapshot(self._snap)
+
+    def _update_dac_states(self, new_states: dict[str, DACState]) -> dict[str, ObservedDACStateChange]:
+        changes: dict[str, ObservedDACStateChange] = {}
+        with self._lock:
+            for dac_name, new_state in new_states.items():
+                data_info = self._dacs.get(dac_name)
+                if data_info is not None:
+                    old_state = copy.deepcopy(data_info.observed)
+                    if old_state != new_state:
+                        if old_state is None or new_state.time > old_state.time:
+                            data_info.observed = new_state
+                            changes[dac_name] = ObservedDACStateChange(
+                                old_state=old_state,
+                                new_state=new_state,
+                            )
+        return changes
+
+    def _handle_new_dac_states(self, new_states: dict[str, DACState]) -> None:
+        state_changes = self._update_dac_states(new_states)
+        if state_changes and self._callbacks.dac_state_change_callback is not None:
+            self._callbacks.dac_state_change_callback(state_changes)
+
+    def _dac_info_from_channel(self, channel_name: str) -> Optional[DACInfo]:
+        return self._dacs.get(
+            self._channel2node.get(channel_name, ""), None
+        )
+
+    def _extract_dac_states(self, readings: Sequence[SingleReading]) -> dict[str, DACState]:
+        states = {}
+        for reading in readings:
+            if data_info := self._dac_info_from_channel(reading.ChannelName):
+                states[data_info.config.about_node_name] = DACState(
+                    value=reading.Value,
+                    time=reading.ScadaReadTimeUnixMs,
+                )
+        return states
+
+    def _process_single_reading(self, payload: bytes) -> None:
+        if self._layout is not None:
+            self._handle_new_dac_states(
+                self._extract_dac_states(
+                    [GWMessage[SingleReading].model_validate_json(payload).Payload]
+                )
+            )
+
+    def process_snapshot(self, snapshot: SnapshotSpaceheat) -> None:
+        # self._logger.debug("++DACWatchClient.process_snapshot")
+        path_dbg = 0
+        self._process_snapshot(snapshot)
+        if self._callbacks.snapshot_callback is not None:
+            path_dbg |= 0x0000001
+            self._callbacks.snapshot_callback(snapshot)
+        # self._logger.debug("--DACWatchClient.process_snapshot  path:0x%08X", path_dbg)
+
+    def _process_snapshot(self, snapshot: SnapshotSpaceheat) -> None:
+        if self._layout is not None:
+            self._handle_new_dac_states(
+                self._extract_dac_states(snapshot.LatestReadingList)
+            )
+
+    def process_mqtt_state_changed(self, old_state: str, new_state: str) -> None:
+        if self._callbacks.mqtt_state_change_callback is not None:
+            self._callbacks.mqtt_state_change_callback(old_state, new_state)
+
+    def process_mqtt_message(self, topic: str, payload: bytes) -> None:
+        decoded_topic = MQTTTopic.decode(topic)
+        if decoded_topic.message_type == type_name(SingleReading):
+            self._process_single_reading(payload)
+        if self._callbacks.mqtt_message_received_callback is not None:
+            self._callbacks.mqtt_message_received_callback(topic, payload)
+
+    def set_dac(self, dac_row_name: str, new_state: int, timeout_seconds: Optional[int] = None):
+        self._send_set_command(dac_row_name, new_state, datetime.datetime.now(), timeout_seconds)
+
+    def _send_set_command(
+            self,
+            dac_row_name: str,
+            value: int,
+            set_time: datetime.datetime,
+            timeout_seconds: Optional[int] = None
+    ) -> None:
+        dac_node_name = dac_row_name.lower() + "-010v"
+        self._admin_client.publish(
+            AdminAnalogDispatch(
+                Dispatch=AnalogDispatch(
+                    FromGNodeAlias=None,
+                    FromHandle=H0N.admin,
+                    ToHandle=f"{H0N.admin}.{dac_node_name}",
+                    AboutName=dac_node_name,
+                    Value=value,
+                    TriggerId=str(uuid.uuid4()),
+                    UnixTimeMs=int(set_time.timestamp() * 1000),
+                ),
+                TimeoutSeconds=timeout_seconds,
+            )
+        )
+
+    def send_keepalive(self, timeout_seconds: Optional[int] = None) -> None:
+        self._admin_client.publish(
+            AdminKeepAlive(AdminTimeoutSeconds=timeout_seconds)
+        )
+
+    def send_release_control(self) -> None:
+        self._admin_client.publish(
+            AdminReleaseControl()
+        )
+
+    def scada_selection_reset(self) -> None:
+        self._layout = None
+        self._snap = None
+        with self._lock:
+            removed_dacs = self._dacs
+            self._dacs = {}
+            self._channel2node = {}
+        if removed_dacs and self._callbacks.dac_config_change_callback is not None:
+            self._callbacks.dac_config_change_callback(
+                {
+                    dac_name: DACConfigChange(
+                        old_config=dac.config,
+                        new_config=None,
+                    )
+                    for dac_name, dac in removed_dacs.items()
+                 }
+            )

{gridworks_admin-1.0.0.dev5 → gridworks_admin-1.0.0.dev7}/src/gwadmin/watch/relay_app.py

@@ -2,21 +2,28 @@ import importlib.metadata
 import logging
 
 import dotenv
+from textual import on
 from textual.app import App, ComposeResult
 from textual.binding import Binding
 from textual.logging import TextualHandler
+from textual.widgets import Button
+from textual.widgets import DataTable
 from textual.widgets import Header, Footer
+from textual.widgets import Input
 from textual.widgets import Select
 
 from gwadmin.config import CurrentAdminConfig
-from gwadmin.settings import MAX_ADMIN_TIMEOUT
+from gwadmin.config import MAX_ADMIN_TIMEOUT
 from gwadmin.watch.clients.admin_client import AdminClient
+from gwadmin.watch.clients.dac_client import DACWatchClient
 from gwadmin.watch.clients.relay_client import RelayEnergized
 from gwadmin.watch.clients.relay_client import RelayWatchClient
+from gwadmin.watch.widgets.dacs import Dacs
 from gwadmin.watch.widgets.keepalive import KeepAliveButton
 from gwadmin.watch.widgets.keepalive import ReleaseControlButton
 from gwadmin.watch.widgets.relays import Relays
 from gwadmin.watch.widgets.relay_toggle_button import RelayToggleButton
+from gwadmin.watch.widgets.time_input import TimeInput
 from gwadmin.watch.widgets.timer import TimerDigits
 
 __version__: str = importlib.metadata.version('gridworks-admin')
@@ -29,6 +36,7 @@ class RelaysApp(App):
     TITLE: str = f"Scada Relay Monitor v{__version__}"
     _admin_client: AdminClient
     _relay_client: RelayWatchClient
+    _dac_client: DACWatchClient
     _theme_names: list[str]
     settings: CurrentAdminConfig
 
@@ -56,9 +64,10 @@ class RelaysApp(App):
         else:
             paho_logger = None
         self._relay_client = RelayWatchClient(logger=logger)
+        self._dac_client = DACWatchClient(logger=logger)
         self._admin_client = AdminClient(
             settings,
-            subclients=[self._relay_client],
+            subclients=[self._relay_client, self._dac_client],
             logger=logger,
             paho_logger=paho_logger,
         )
@@ -74,13 +83,21 @@ class RelaysApp(App):
     def compose(self) -> ComposeResult:
         yield Header(show_clock=self.settings.config.show_clock)
         relays = Relays(
-            list(self.settings.config.scadas.keys()),
-            self.settings.curr_scada,
+            scadas=[
+                scada_name
+                for scada_name, scada_config in self.settings.config.scadas.items()
+                if scada_config.enabled
+            ],
+            initial_scada=self.settings.curr_scada,
+            default_timeout_seconds=self.settings.config.default_timeout_seconds,
             logger=logger,
             id="relays"
         )
-        self._relay_client.set_callbacks(relays.relay_client_callbacks())
         yield relays
+        self._relay_client.set_callbacks(relays.relay_client_callbacks())
+        dacs = Dacs(logger=logger, id="dacs")
+        self._dac_client.set_callbacks(dacs.dac_client_callbacks())
+        yield dacs
         # Footer disabled by default as defense against memory leaks
         if self.settings.config.show_footer:
             yield Footer()
@@ -95,6 +112,26 @@ class RelaysApp(App):
             message.timeout_seconds
         )
 
+    @on(Button.Pressed, "#send_dac_button")
+    def send_dac_button(self) -> None:
+        new_state = self.query_one("#dac_value_input", Input).value
+        if new_state is not None:
+            new_state = int(new_state)
+            dac_table = self.query_one("#dacs_table", DataTable)
+            row = dac_table.get_row_at(dac_table.cursor_row)
+            time_input_value = self.app.query_one(TimeInput).value
+            try:
+                time_in_minutes = float(time_input_value) if time_input_value else int(self.settings.config.default_timeout_seconds/60)
+                timeout_seconds = int(time_in_minutes * 60)
+            except:  # noqa
+                timeout_seconds = self.settings.config.default_timeout_seconds
+            self._dac_client.set_dac(
+                dac_row_name=row[0],
+                new_state=new_state,
+                timeout_seconds=timeout_seconds,
+            )
+
+
     def action_toggle_dark(self) -> None:
         self.theme = (
             "textual-dark" if "light" in self.theme else "textual-light"

{gridworks_admin-1.0.0.dev5 → gridworks_admin-1.0.0.dev7}/src/gwadmin/watch/relay_app.tcss

@@ -14,23 +14,53 @@ Screen {
     width: auto;
 }
 
-# #select_scada {
-#     height: 1.25fr;
-#     border: solid $border;
-# }
+#dacs_table {
+    width: 60;
+    border: solid $border;
+    margin: 0 1;
+}
 
-#mqtt_state {
-    height: 1fr;
+#dac_control_container {
+    width: 60;
+}
+
+#dac_input_vertical {
+    width: 20;
+    margin: 0 3;
+}
+
+#dacs_input_label {
+    margin: 0 2;
+    width: 20;
+}
+
+#dac_value_input {
+    width: 10;
+    align: center middle;
+    margin: 1 3;
+}
+
+#send_dac_button {
+    width: 30;
+    align: center middle;
+}
+
+#dacs {
+    height: 4fr;
     border: solid $border;
 }
 
-#message_table {
-    height: 3fr;
+Relays {
+    height: 20fr;
+}
+
+#mqtt_state {
+    height: 1fr;
     border: solid $border;
 }
 
 #relays_table {
-    height: 6fr;
+    height: 3fr;
     border: solid $border;
 }
 
@@ -38,7 +68,7 @@ Screen {
     layout: horizontal;
     border: solid $border;
     align: center middle;
-    height: 2fr;
+    height: 1fr;
     padding: 1 1;
 }
 

gridworks_admin-1.0.0.dev7/src/gwadmin/watch/widgets/dac_widget_info.py

@@ -0,0 +1,86 @@
+import logging
+import re
+from functools import cached_property
+from typing import ClassVar
+from typing import Optional
+
+from pydantic import BaseModel
+from textual.logging import TextualHandler
+
+from gwadmin.watch.clients.dac_client import DACConfig
+from gwadmin.watch.clients.dac_client import DACState
+
+module_logger = logging.getLogger(__name__)
+module_logger.addHandler(TextualHandler())
+
+
+class DACTableName(BaseModel):
+    channel_name: str = ""
+    row_name: str = ""
+
+    dac_table_name_rgx: ClassVar[re.Pattern] = re.compile(
+        r"(?P<channel_part>.*)-010v"
+    )
+
+    @classmethod
+    def from_channel_name(cls, channel_name: str) -> "DACTableName":
+        dac_match = cls.dac_table_name_rgx.match(channel_name)
+        if dac_match is None:
+            channel_part = channel_name
+        else:
+            channel_part = dac_match.group("channel_part")
+        return DACTableName(
+            channel_name=channel_name,
+            row_name=" ".join(
+                [
+                    word.capitalize()
+                    for word in channel_part.replace("-", " ").split()
+                ]
+            ),
+        )
+
+    @cached_property
+    def border_title(self) -> str:
+        return self.row_name
+
+class DACWidgetConfig(DACConfig):
+
+    @cached_property
+    def table_name(self) -> DACTableName:
+        return DACTableName.from_channel_name(self.channel_name)
+
+    @classmethod
+    def from_config(
+            cls,
+            config: DACConfig,
+    ) -> "DACWidgetConfig":
+        return DACWidgetConfig(
+            **config.model_dump()
+        )
+
+    @classmethod
+    def get_state_str(cls, value: Optional[int]) -> str:
+        if value is None:
+            return "?"
+        return f"{value:3d}"
+
+    def get_current_state_str(self, value: Optional[int]) -> str:
+        return self.get_state_str(value)
+
+
+class DACWidgetInfo(BaseModel):
+    config: DACWidgetConfig = DACWidgetConfig()
+    observed: Optional[DACState] = None
+
+    @classmethod
+    def get_observed_state(cls, observed) -> Optional[int]:
+        if observed is not None:
+            return observed.value
+        return None
+
+    def get_state(self) -> Optional[int]:
+        return self.get_observed_state(self.observed)
+
+    def get_state_str(self) -> str:
+        return self.config.get_state_str(self.get_state())
+

gridworks_admin-1.0.0.dev7/src/gwadmin/watch/widgets/dacs.py

@@ -0,0 +1,166 @@
+import logging
+from logging import Logger
+from typing import Optional
+
+from textual.app import ComposeResult
+from textual.containers import Horizontal
+from textual.containers import Vertical
+from textual.logging import TextualHandler
+from textual.messages import Message
+from textual.widget import Widget
+from textual.widgets import Button
+from textual.widgets import DataTable
+from textual.widgets import Input
+from textual.widgets import Static
+from textual.widgets._data_table import CellType  # noqa
+
+from gwadmin.watch.clients.dac_client import DACClientCallbacks
+from gwadmin.watch.clients.dac_client import DACConfigChange
+from gwadmin.watch.clients.dac_client import ObservedDACStateChange
+from gwadmin.watch.widgets.dac_widget_info import DACWidgetConfig
+from gwadmin.watch.widgets.dac_widget_info import DACWidgetInfo
+from gwsproto.named_types import LayoutLite
+from gwsproto.named_types import SnapshotSpaceheat
+
+module_logger = logging.getLogger(__name__)
+module_logger.addHandler(TextualHandler())
+
+class Dacs(Widget):
+    BINDINGS = [
+        ("d", "set_dac", "Set selected DAC"),
+    ]
+
+    logger: Logger
+    _dacs: dict[str, DACWidgetInfo]
+
+    class DacStateChange(Message):
+        def __init__(self, changes: dict[str, ObservedDACStateChange]) -> None:
+            self.changes = changes
+            super().__init__()
+
+    class ConfigChange(Message):
+        def __init__(self, changes: dict[str, DACConfigChange]) -> None:
+            self.changes = changes
+            super().__init__()
+
+    class Snapshot(Message):
+        def __init__(self, snapshot: SnapshotSpaceheat) -> None:
+            self.snapshot = snapshot
+            super().__init__()
+
+    class Layout(Message):
+        def __init__(self, layout: LayoutLite) -> None:
+            self.layout = layout
+            super().__init__()
+
+    def __init__(self, logger: Optional[Logger] = None, **kwargs) -> None:
+        self.logger = logger or module_logger
+        self._dacs = {}
+        super().__init__(**kwargs)
+
+    def compose(self) -> ComposeResult:
+        with Horizontal(id="dacs_horizontal"):
+            yield DataTable(
+                id="dacs_table",
+                zebra_stripes=True,
+                cursor_type="row",
+            )
+            with Horizontal(id="dac_control_container"):
+                with Vertical(id="dac_input_vertical"):
+                    yield Static("Value for DAC:  ", id="dacs_input_label")
+                    yield Input(
+                        type="integer",
+                        id="dac_value_input",
+                    )
+                yield Button(
+                    id="send_dac_button",
+                    label="Send Value to DAC",
+                    variant="primary",
+                )
+
+    def on_mount(self) -> None:
+        data_table = self.query_one("#dacs_table", DataTable)
+        for column_name, width in [
+            ("Name", 25),
+            ("Current value", 25),
+        ]:
+            data_table.add_column(column_name, key=column_name, width=width)
+
+    def _get_dac_row_data(self, dac_name: str) -> dict[str, CellType]:
+        if dac_name in self._dacs:
+            dac = self._dacs[dac_name]
+            return {
+                "Name": dac.config.table_name.row_name,
+                "Current value": dac.config.get_current_state_str(dac.get_state()),
+            }
+        return {}
+
+    def on_dacs_dac_state_change(self, message: DacStateChange) -> None:
+        for dac_name, change in message.changes.items():
+            dac_info = self._dacs.get(dac_name, None)
+            if dac_info is not None:
+                new_state = DACWidgetInfo.get_observed_state(change.new_state)
+                if new_state != dac_info.get_state():
+                    dac_info.observed = change.new_state
+                    self._update_dac_row(dac_name)
+
+
+    def _get_dac_row(self, dac_name: str) -> list[str | CellType]:
+        return list(self._get_dac_row_data(dac_name).values())
+
+    def _update_dac_row(self, dac_name: str) -> None:
+        table = self.query_one("#dacs_table", DataTable)
+        data = self._get_dac_row_data(dac_name)
+        for column_name, value in data.items():
+            table.update_cell(
+                dac_name,
+                column_name,
+                value,
+                update_width=column_name=="State",
+            )
+
+    def on_dacs_config_change(self, message: ConfigChange) -> None:
+        message.prevent_default()
+        table = self.query_one("#dacs_table", DataTable)
+        for dac_name, change in message.changes.items():
+            dac_info = self._dacs.get(dac_name, None)
+            if dac_info is not None:
+                if change.new_config is None:
+                    self._dacs.pop(dac_name)
+                    table.remove_row(dac_name)
+                else:
+                    new_config = DACWidgetConfig.from_config(change.new_config)
+                    if new_config != dac_info.config:
+                        dac_info.config = new_config
+                        self._update_dac_row(dac_name)
+            else:
+                if change.new_config is not None:
+                    self._dacs[dac_name] = DACWidgetInfo(
+                        config=DACWidgetConfig.from_config(change.new_config)
+                    )
+                    table.add_row(
+                        *self._get_dac_row(dac_name),
+                        key=dac_name
+                    )
+        table.sort("Name")
+
+    def on_data_table_row_highlighted(self, message: DataTable.RowHighlighted) -> None:
+        self._update_dac_row(message.row_key.value)
+
+    def dac_client_callbacks(self) -> DACClientCallbacks:
+        return DACClientCallbacks(
+            mqtt_state_change_callback=None,
+            dac_state_change_callback=self.dac_state_change_callback,
+            dac_config_change_callback=self.dac_config_change_callback,
+            # disable these as defense against memroy leaks
+            mqtt_message_received_callback=None,
+            layout_callback=None,
+            snapshot_callback=None,
+        )
+
+    def dac_state_change_callback(self, changes: dict[str, ObservedDACStateChange]) -> None:
+        self.post_message(Dacs.DacStateChange(changes))
+
+    def dac_config_change_callback(self, changes: dict[str, DACConfigChange]) -> None:
+        self.post_message(Dacs.ConfigChange(changes))
+

{gridworks_admin-1.0.0.dev5 → gridworks_admin-1.0.0.dev7}/src/gwadmin/watch/widgets/keepalive.py

@@ -3,10 +3,10 @@ from textual.logging import TextualHandler
 from textual.message import Message
 from textual.widgets import Button
 
-from gwadmin.settings import MAX_ADMIN_TIMEOUT
+from gwadmin.config import DEFAULT_ADMIN_TIMEOUT
+from gwadmin.config import MAX_ADMIN_TIMEOUT
 from gwadmin.watch.widgets.timer import TimerDigits
 from gwadmin.watch.widgets.time_input import TimeInput
-from gwadmin.settings import AdminClientSettings
 
 module_logger = logging.getLogger(__name__)
 module_logger.addHandler(TextualHandler())
@@ -14,6 +14,7 @@ module_logger.addHandler(TextualHandler())
 class KeepAliveButton(Button):
     def __init__(
             self,
+            default_timeout_seconds: int = DEFAULT_ADMIN_TIMEOUT,
             logger: logging.Logger = module_logger,
             **kwargs
     ) -> None:
@@ -24,7 +25,7 @@ class KeepAliveButton(Button):
             **kwargs
         )
         self.logger = logger
-        self.default_timeout_seconds = AdminClientSettings().default_timeout_seconds
+        self.default_timeout_seconds = default_timeout_seconds
         self.timeout_seconds = self.default_timeout_seconds
 
     class Pressed(Message):
@@ -51,6 +52,7 @@ class KeepAliveButton(Button):
 class ReleaseControlButton(Button):
     def __init__(
             self,
+            default_timeout_seconds: int = DEFAULT_ADMIN_TIMEOUT,
             logger: logging.Logger = module_logger,
             **kwargs
     ) -> None:
@@ -61,7 +63,7 @@ class ReleaseControlButton(Button):
             **kwargs
         )
         self.logger = logger
-        self.default_timeout_seconds = AdminClientSettings().default_timeout_seconds
+        self.default_timeout_seconds = default_timeout_seconds
         self.timeout_seconds = self.default_timeout_seconds
 
     class Pressed(Message):

{gridworks_admin-1.0.0.dev5 → gridworks_admin-1.0.0.dev7}/src/gwadmin/watch/widgets/relay_toggle_button.py

@@ -8,11 +8,11 @@ from textual.reactive import Reactive
 from textual.reactive import reactive
 from textual.widgets import Button
 
+from gwadmin.config import DEFAULT_ADMIN_TIMEOUT
 from gwadmin.watch.widgets.relay_widget_info import RelayWidgetConfig
 from gwadmin.watch.widgets.timer import TimerDigits
 from gwadmin.watch.widgets.time_input import TimeInput
 from gwadmin.watch.widgets.keepalive import KeepAliveButton
-from gwadmin.settings import AdminClientSettings
 
 module_logger = logging.getLogger(__name__)
 module_logger.addHandler(TextualHandler())
@@ -25,11 +25,13 @@ class RelayToggleButton(Button, can_focus=True):
 
     energized: Reactive[Optional[bool]] = reactive(None)
     config: Reactive[RelayWidgetConfig] = reactive(RelayWidgetConfig)
+    timeout_seconds: int
 
     def __init__(
         self,
         energized: Optional[bool] = None,
         config: Optional[RelayWidgetConfig] = None,
+        default_timeout_seconds: int = DEFAULT_ADMIN_TIMEOUT,
         logger: logging.Logger = module_logger,
         **kwargs
     ) -> None:
@@ -38,7 +40,7 @@ class RelayToggleButton(Button, can_focus=True):
             variant=self.variant_from_state(energized),
             **kwargs
         )
-        self.default_timeout_seconds = AdminClientSettings().default_timeout_seconds
+        self.default_timeout_seconds = default_timeout_seconds
         self.set_reactive(RelayToggleButton.energized, energized)
         self.set_reactive(RelayToggleButton.config, config or RelayWidgetConfig())
         self.update_title()
@@ -62,7 +64,7 @@ class RelayToggleButton(Button, can_focus=True):
         try:
             time_in_minutes = float(input_value) if input_value else int(self.default_timeout_seconds/60)
             self.timeout_seconds = int(time_in_minutes * 60)
-        except:
+        except: # noqa
             self.timeout_seconds = self.default_timeout_seconds
         if self.energized is not None:
             self.post_message(
@@ -95,7 +97,7 @@ class RelayToggleButton(Button, can_focus=True):
         try:
             time_in_minutes = float(input_value) if input_value else int(self.default_timeout_seconds/60)
             self.timeout_seconds = int(time_in_minutes * 60)
-        except:
+        except:  # noqa
             self.timeout_seconds = self.default_timeout_seconds
         if self.energized is not None:
             self.post_message(

{gridworks_admin-1.0.0.dev5 → gridworks_admin-1.0.0.dev7}/src/gwadmin/watch/widgets/relays.py

@@ -17,6 +17,7 @@ from textual.widgets import Select
 from textual.widgets import Static
 from textual.widgets._data_table import CellType  # noqa
 
+from gwadmin.config import DEFAULT_ADMIN_TIMEOUT
 from gwadmin.watch.clients.constrained_mqtt_client import ConstrainedMQTTClient
 from gwadmin.watch.clients.relay_client import ObservedRelayStateChange
 from gwadmin.watch.clients.relay_client import RelayClientCallbacks
@@ -47,6 +48,9 @@ class Relays(Widget):
     curr_config: Reactive[RelayWidgetConfig] = reactive(RelayWidgetConfig)
     logger: Logger
     _relays: dict[str, RelayWidgetInfo]
+    _scadas: list[str]
+    _initial_scada: str
+    _default_timeout_seconds: int = DEFAULT_ADMIN_TIMEOUT
 
     class RelayStateChange(Message):
         def __init__(self, changes: dict[str, ObservedRelayStateChange]) -> None:
@@ -68,9 +72,17 @@ class Relays(Widget):
             self.layout = layout
             super().__init__()
 
-    def __init__(self, scadas: list[str], initial_scada: str, logger: Optional[Logger] = None, **kwargs) -> None:
-        self.scadas = scadas
-        self.initial_scada = initial_scada
+    def __init__(
+        self,
+        scadas: list[str],
+        initial_scada: str,
+        default_timeout_seconds: int = DEFAULT_ADMIN_TIMEOUT,
+        logger: Optional[Logger] = None,
+        **kwargs
+    ) -> None:
+        self._scadas = scadas
+        self._initial_scada = initial_scada
+        self._default_timeout_seconds = default_timeout_seconds
         self.logger = logger or module_logger
         self._relays = {}
         super().__init__(**kwargs)
@@ -81,18 +93,18 @@ class Relays(Widget):
             yield Horizontal(
                 Static("Select Scada: ", classes="label"),
                 Select(
-                    ((scada, scada) for scada in self.scadas),
+                    ((scada, scada) for scada in self._scadas),
                     prompt="Scada",
-                    value=self.initial_scada,
+                    value=self._initial_scada,
                     id="select_scada",
                 ),
                 classes="container",
             )
             with HorizontalGroup():
-                yield KeepAliveButton()
-                yield ReleaseControlButton()
-                yield TimeInput()
-                yield TimerDigits()
+                yield KeepAliveButton(default_timeout_seconds=self._default_timeout_seconds)
+                yield ReleaseControlButton(default_timeout_seconds=self._default_timeout_seconds)
+                yield TimeInput(default_timeout_seconds=self._default_timeout_seconds)
+                yield TimerDigits(default_timeout_seconds=self._default_timeout_seconds)
             yield DataTable(
                 id="relays_table",
                 zebra_stripes=True,
@@ -108,10 +120,10 @@ class Relays(Widget):
                     energized=Relays.curr_energized,
                     config=Relays.curr_config,
                 )
-            yield DataTable(
-                id="message_table",
-                classes="undisplayed",
-            )
+            # yield DataTable(
+            #     id="message_table",
+            #     classes="undisplayed",
+            # )
 
     def on_mount(self) -> None:
         data_table = self.query_one("#relays_table", DataTable)
@@ -196,6 +208,7 @@ class Relays(Widget):
             "Name",
             key=lambda row: (row[0], row[1]) if row[0] is not None else (sys.maxsize, row[1]),
         )
+        self.logger.info("--on_relays_config_change")
 
     def _update_buttons(self, relay_name: str) -> None:
         relay_info = self._relays[relay_name]

{gridworks_admin-1.0.0.dev5 → gridworks_admin-1.0.0.dev7}/src/gwadmin/watch/widgets/time_input.py

@@ -1,10 +1,12 @@
 from textual.widgets import Input
 from textual.validation import Number
-from gwadmin.settings import AdminClientSettings
+
+from gwadmin.config import DEFAULT_ADMIN_TIMEOUT
+
 
 class TimeInput(Input):
-    def __init__(self, **kwargs):
-        default_value = int(AdminClientSettings().default_timeout_seconds/60)
+    def __init__(self, default_timeout_seconds: int = DEFAULT_ADMIN_TIMEOUT, **kwargs):
+        default_value = int(default_timeout_seconds/60)
         super().__init__(
             placeholder=f"Timeout minutes (default {default_value})",
             id="time_input",

{gridworks_admin-1.0.0.dev5 → gridworks_admin-1.0.0.dev7}/src/gwadmin/watch/widgets/timer.py

@@ -1,29 +1,33 @@
 import logging
 from time import monotonic
 from textual.logging import TextualHandler
+from textual.timer import Timer
 from textual.widgets import Digits
 from textual.reactive import reactive
 
-from gwadmin.settings import MAX_ADMIN_TIMEOUT
+from gwadmin.config import DEFAULT_ADMIN_TIMEOUT
+from gwadmin.config import MAX_ADMIN_TIMEOUT
 from gwadmin.watch.widgets.time_input import TimeInput
-from gwadmin.settings import AdminClientSettings
 
 module_logger = logging.getLogger(__name__)
 module_logger.addHandler(TextualHandler())
 
 class TimerDigits(Digits):
+    update_timer: Timer
+    start_time = reactive(monotonic)
+    time_remaining = reactive(DEFAULT_ADMIN_TIMEOUT)
+
     def __init__(
             self,
+            default_timeout_seconds: int = DEFAULT_ADMIN_TIMEOUT,
             logger: logging.Logger = module_logger,
             **kwargs
     ) -> None:
         super().__init__(**kwargs)
         self.logger = logger
-        self.default_timeout_seconds = MAX_ADMIN_TIMEOUT
+        self.default_timeout_seconds = default_timeout_seconds
         self.countdown_seconds = self.default_timeout_seconds
 
-    start_time = reactive(monotonic)
-    time_remaining = reactive(AdminClientSettings().default_timeout_seconds)
 
     def on_mount(self) -> None:
         self.update_timer = self.set_interval(1 / 60, self.update_time, pause=True)

gridworks_admin-1.0.0.dev5/src/gwadmin/settings.py

@@ -1,31 +0,0 @@
-import logging
-from typing import Optional
-from typing import Self
-
-from gwproactor import AppSettings
-from gwproactor.config import MQTTClient
-from pydantic import model_validator
-from pydantic_settings import SettingsConfigDict
-
-from gwsproto.data_classes.house_0_names import H0N
-
-MAX_ADMIN_TIMEOUT = 60 * 60 * 24
-
-class AdminClientSettings(AppSettings):
-    target_gnode: str = ""
-    default_timeout_seconds: int = int(5*60)
-    link: MQTTClient = MQTTClient()
-    verbosity: int = logging.WARN
-    paho_verbosity: Optional[int] = None
-    show_clock: bool = False
-    show_footer: bool = False
-    model_config = SettingsConfigDict(
-        env_prefix="GWADMIN_",
-        env_nested_delimiter="__",
-        extra="ignore",
-    )
-
-    @model_validator(mode="after")
-    def validate(self) -> Self:
-        self.link.update_tls_paths(self.paths.certs_dir, H0N.admin)
-        return self