PyAutomationIO 1.1.1__py3-none-any.whl

automation/opcua/subscription.py

@@ -0,0 +1,259 @@
+import pytz
+from datetime import datetime
+from math import ceil
+from ..singleton import Singleton
+from ..tags.cvt import CVTEngine
+from ..tags import Tag
+from ..buffer import Buffer
+from ..models import StringType
+from ..logger.datalogger import DataLoggerEngine
+
+
+class SubHandler(Singleton):
+    r"""
+    Subscription Handler. To receive events from server for a subscription
+    data_change and event methods are called directly from receiving thread.
+    Do not do expensive, slow or network operation there. Create another 
+    thread if you need to do such a thing
+    """
+
+    def __init__(self):
+        
+        self.monitored_items = dict()
+
+    def subscribe(self, subscription, client_name, node_id):
+        r"""
+        Documentation here
+        """
+        
+        if client_name not in self.monitored_items:
+            
+            monitored_item = subscription.subscribe_data_change(
+                node_id
+            )
+
+            self.monitored_items[client_name] = {
+                node_id: {
+                    "subscription": subscription,
+                    "monitored_item": monitored_item,
+                    "server": client_name
+                }
+            }
+
+        else:
+
+            if node_id not in self.monitored_items[client_name]:
+            
+                monitored_item = subscription.subscribe_data_change(
+                    node_id
+                )
+
+                self.monitored_items[client_name].update({
+                    node_id: {
+                        "subscription": subscription,
+                        "monitored_item": monitored_item,
+                        "server": client_name
+                    }
+                })
+
+    def unsubscribe_all(self):
+        r"""
+        Documentation here
+        """
+
+        for _, monitored_items in self.monitored_items.items():
+
+            for _, monitored_item in monitored_items.items():
+                
+                item = monitored_item["monitored_item"]
+                subscription = monitored_item["subscription"]
+                subscription.unsubscribe(item)
+                
+        self.monitored_items = dict()  
+
+    def resubscribe_all(self, client): 
+        for client_name, monitored_items in self.monitored_items.items(): 
+            for node_id, monitored_item in monitored_items.items(): 
+                subscription = monitored_item["subscription"] 
+                monitored_item["monitored_item"] = subscription.subscribe_data_change(client.get_node(node_id))   
+
+    def datachange_notification(self, node, val, data):
+        r"""
+        Documentation here
+        """
+        pass
+
+class SubHandlerServer(Singleton):
+
+    def __init__(self):
+        from ..core import PyAutomation
+        self.app = PyAutomation()
+        self.subscriptions = dict()
+
+    def is_property(self, node):
+        from ..state_machine import ua
+        # A property is a variable that is part of another node (often an Object or another Variable)
+        parent = node.get_parent()
+        references = node.get_references(refs=ua.ObjectIds.HasProperty)
+        return bool(references)
+
+    def is_variable(self, node):
+        from ..state_machine import ua
+        return node.get_node_class() == ua.NodeClass.Variable
+
+    def datachange_notification(self, node, val, data):
+        from .. import SEGMENT, MANUFACTURER, PyAutomation
+
+        app = PyAutomation()
+
+        timestamp = data.monitored_item.Value.SourceTimestamp
+        if not timestamp:
+            timestamp = datetime.now(pytz.utc)
+        timestamp = timestamp.replace(tzinfo=pytz.UTC)
+        tag_name = node.get_display_name().Text
+        
+        tag = self.app.get_tag_by_name(name=tag_name)
+        if tag:
+            if tag.get_value()!=val:
+
+                val = tag.value.convert_value(value=val, from_unit=tag.get_unit(), to_unit=tag.get_display_unit())
+                if tag.manufacturer==MANUFACTURER and tag.segment==SEGMENT:      
+                    self.app.cvt.set_value(id=tag.id, value=val, timestamp=timestamp)
+                elif not MANUFACTURER and not SEGMENT:
+                    self.app.cvt.set_value(id=tag.id, value=val, timestamp=timestamp) 
+        else:
+            
+            parent = node.get_parent()
+            if parent:
+                machine_name = parent.get_display_name().Text
+                machine = app.get_machine(name=StringType(machine_name))
+                attr = getattr(machine, tag_name)
+                attr.value = val
+                
+
+class DAS(Singleton):
+    r"""
+    Subscription Handler. To receive events from server for a subscription
+    data_change and event methods are called directly from receiving thread.
+    Do not do expensive, slow or network operation there. Create another 
+    thread if you need to do such a thing
+    """
+
+    def __init__(self):
+  
+        self.monitored_items = dict()
+        self.cvt = CVTEngine()
+        self.logger = DataLoggerEngine()
+        self.buffer = dict()
+
+    def restart_buffer(self, tag:Tag):
+        r"""
+        Documentation here
+        """
+        scan_time = tag.get_scan_time()
+        if scan_time:
+            
+            self.buffer[tag.get_name()].update({
+                "timestamp": Buffer(size=ceil(600/ ceil(scan_time / 1000))),
+                "values": Buffer(size=ceil(600 / ceil(scan_time / 1000)))
+            })
+        else:
+            self.buffer[tag.get_name()].update({
+                "timestamp": Buffer(size=600),
+                "values": Buffer(size=600)
+            })
+
+    def subscribe(self, subscription, client_name, node_id):
+        r"""
+        Documentation here
+        """
+        if client_name not in self.monitored_items:
+            
+            monitored_item = subscription.subscribe_data_change(
+                node_id
+            )
+            self.monitored_items[client_name] = {
+                node_id.get_display_name().Text: {
+                    "subscription": subscription,
+                    "monitored_item": monitored_item,
+                    "server": client_name,
+                    "namespace": node_id.nodeid.to_string()
+                }
+            }
+
+        else:
+
+            if node_id not in self.monitored_items[client_name]:
+                
+                monitored_item = subscription.subscribe_data_change(
+                    node_id
+                )
+
+                self.monitored_items[client_name].update({
+                    node_id.get_display_name().Text: {
+                        "subscription": subscription,
+                        "monitored_item": monitored_item,
+                        "server": client_name,
+                        "namespace": node_id.nodeid.to_string()
+                    }
+                })
+        
+        ## Trying to get the value of the tag into OPCUA Client
+        try:
+            val = node_id.get_value()
+            self.update_tag_value(node=node_id, val=val)
+        except Exception:
+            pass
+
+    def unsubscribe(self, client_name:str, node_id):
+        r"""
+        Documentation here
+        """
+        if client_name in self.monitored_items:
+            
+            if node_id.get_display_name().Text in self.monitored_items[client_name]:
+                
+                node = self.monitored_items[client_name].pop(node_id.get_display_name().Text)
+                item = node["monitored_item"]
+                subscription = node["subscription"]
+                subscription.unsubscribe(item)
+
+    def resubscribe_all(self, client): 
+        for client_name, monitored_items in self.monitored_items.items(): 
+            for node_id, monitored_item in monitored_items.items(): 
+                subscription = monitored_item["subscription"] 
+                monitored_item["monitored_item"] = subscription.subscribe_data_change(client.get_node(node_id))
+
+    def update_tag_value(self, node, val, timestamp=None):
+        r"""
+        Update tag value in CVT and buffer
+        """
+        from .. import SEGMENT, MANUFACTURER, TIMEZONE
+        
+        if not timestamp:
+            timestamp = datetime.now(pytz.utc)
+        timestamp = timestamp.replace(tzinfo=pytz.UTC)
+        
+        namespace = node.nodeid.to_string()
+        tag = self.cvt.get_tag_by_node_namespace(node_namespace=namespace)
+        
+        if tag:
+            tag_name = tag.get_name()
+            val = tag.value.convert_value(value=val, from_unit=tag.get_unit(), to_unit=tag.get_display_unit())
+            if tag.manufacturer==MANUFACTURER and tag.segment==SEGMENT:      
+                val = self.cvt.set_value(id=tag.id, value=val, timestamp=timestamp)
+            elif not MANUFACTURER and not SEGMENT:
+                val = self.cvt.set_value(id=tag.id, value=val, timestamp=timestamp)
+            timestamp = timestamp.astimezone(TIMEZONE)
+            if tag_name in self.buffer:
+                self.buffer[tag_name]["timestamp"](timestamp)
+                self.buffer[tag_name]["values"](val)
+
+    def datachange_notification(self, node, val, data):
+        r"""
+        Documentation here
+        """
+        timestamp = data.monitored_item.Value.SourceTimestamp
+        self.update_tag_value(node, val, timestamp)      
+        
+        

automation/pages/alarms.py

@@ -0,0 +1,34 @@
+import dash
+import dash_bootstrap_components as dbc
+from automation.pages.components import Components
+from automation.pages.components.alarms import AlarmsComponents
+
+dash.register_page(__name__)
+
+layout = dbc.Container(
+    [   
+        dbc.Breadcrumb(
+            items=[
+                {"label": "Home", "href": "/"},
+                {"label": "Alarms", "active": True},
+            ],
+        ),
+        Components.modal_error(
+            title="Error",
+            modal_id="modal-alarm-create",
+            button_close_id="close-model-alarm-create",
+            body_id="modal-body-alarm-create"
+        ),
+        Components.modal_confirm(
+            title="Confirmation",
+            modal_id="modal-update-delete-alarm",
+            body_id="modal-update-delete-alarm-body",
+            yes_button_id="update-delete-alarm-yes",
+            no_button_id="update-delete-alarm-no"
+        ),
+        AlarmsComponents.create_alarm_form(),
+        AlarmsComponents.alarms_table()
+    ],
+    fluid=False,
+    className="my-3"
+)

automation/pages/alarms_history.py

@@ -0,0 +1,21 @@
+import dash
+import dash_bootstrap_components as dbc
+from automation.pages.components.alarms_summary import AlarmSummaryComponents
+
+dash.register_page(__name__)
+
+layout = dbc.Container(
+    [
+        dbc.Breadcrumb(
+            items=[
+                {"label": "Home", "href": "/"},  # Primer nivel
+                {"label": "Alarms", "href": "/alarms"},  # Segundo nivel
+                {"label": "Alarms History", "active": True},  # Página actual (sin enlace)
+            ],
+        ),
+        dash.dcc.Location(id='alarms_history_page', refresh=False),
+        AlarmSummaryComponents.alarm_summary_table()
+    ],
+    fluid=False,
+    className="my-3",
+)

automation/pages/assets/styles.css

@@ -0,0 +1,7 @@
+.radiobutton-box {
+    height: 38px; /* Adjust the scale as needed */
+}
+
+.Select-menu-outer {
+    display: block !important;
+}

automation/pages/callbacks/__init__.py

@@ -0,0 +1,28 @@
+import dash
+from .tags import init_callback as init_callback_tags
+from .opcua import init_callback as init_callback_opcua
+from .alarms import init_callback as init_callback_alarms
+from .alarms_summary import init_callback as init_callback_alarms_summary
+from .trends import init_callback as init_callback_trends
+from .db import init_callback as init_callback_db
+from .machines import init_callback as init_callback_machines
+from .machines_detailed import init_callback as init_callback_machines_detailed
+from .filter import init_callback as init_callback_filter
+from .opcua_server import init_callback as init_callback_opcua_server
+
+
+def init_callbacks(app:dash.Dash):
+    r"""
+    Documentation here
+    """
+
+    init_callback_tags(app=app)
+    init_callback_opcua(app=app)
+    init_callback_alarms(app=app)
+    init_callback_alarms_summary(app=app)
+    init_callback_trends(app=app)
+    init_callback_db(app=app)
+    init_callback_machines(app=app)
+    init_callback_machines_detailed(app=app)
+    init_callback_filter(app=app)
+    init_callback_opcua_server(app=app)

automation/pages/callbacks/alarms.py

@@ -0,0 +1,218 @@
+import dash
+from ...tags.cvt import CVTEngine
+from ...utils import find_differences_between_lists, generate_dropdown_conditional
+
+
+tag_engine = CVTEngine()
+
+def init_callback(app:dash.Dash):
+
+    @app.callback(
+        dash.Input("tag_alarm_input", "value"),
+        dash.Input("alarm_name_input", "value"), 
+        dash.Input("alarm_type_input", "value"),
+        dash.Input("alarm_trigger_value_input", "value")
+        )
+    def create_tag(
+        tag:str,
+        name:str,  
+        type:str, 
+        trigger_value:int|float
+        )->str:
+        r"""
+        Documentation here
+        """
+        if tag:
+            _tag = tag_engine.get_tag_by_name(name=tag)
+            dash.set_props("alarm_trigger_unit", {'children': _tag.get_display_unit()})
+
+        
+        if name and tag and type and trigger_value:
+            
+            dash.set_props("create_alarm_button", {'disabled': False})
+
+        else:
+            
+            dash.set_props("create_alarm_button", {'disabled': True})
+
+    @app.callback(
+        dash.Output("modal-alarm-create", "is_open"),
+        dash.Input("close-model-alarm-create", "n_clicks"),
+        [dash.State("modal-alarm-create", "is_open")],
+    )
+    def toggle_modal(n, is_open):
+        r"""
+        Documentation here
+        """
+        if n:
+
+            return not is_open
+        
+        return is_open
+
+    @app.callback(
+        dash.Output("alarm_description_input", "value"),
+        dash.Input("alarm_description_radio_button", "value")
+    )
+    def enable_description(enable:bool):
+        r"""
+        Documentation here
+        """
+        dash.set_props("alarm_description_input", {'disabled': not enable})
+        return ""
+
+    @app.callback(
+        dash.Output('alarms_datatable', 'data', allow_duplicate=True),
+        dash.Output('tag_alarm_input', 'options'),
+        dash.Output('alarms_datatable', 'dropdown'),
+        dash.Output('alarm_type_input', 'options'),
+        dash.Output('alarms_datatable', 'dropdown_conditional'),
+        dash.Input('alarms_page', 'pathname'),
+        prevent_initial_call=True
+        )
+    def display_page(pathname):
+        r"""
+        Documentation here
+        """
+        if pathname=="/alarms":
+
+            data = app.alarms_table_data()
+
+            dropdown_options_type = [
+                {'label': 'HIGH-HIGH', 'value': 'HIGH-HIGH'},
+                {'label': 'HIGH', 'value': 'HIGH'},
+                {'label': 'LOW', 'value': 'LOW'},
+                {'label': 'LOW-LOW', 'value': 'LOW-LOW'},
+                {'label': 'BOOL', 'value': 'BOOL'}
+            ]
+            dropdown_options_tag = [{"label": tag["name"], "value": tag["name"]} for tag in app.automation.cvt.get_tags()]
+            dropdown = {
+                "alarm_type": {
+                    "options": dropdown_options_type,
+                    "clearable": False
+                },
+                "tag": {
+                    "options": dropdown_options_tag,
+                    "clearable": False
+                }
+            }
+
+            return data, dropdown_options_tag, dropdown, dropdown_options_type, generate_dropdown_conditional()
+        
+        return dash.no_update, dash.no_update, dash.no_update, dash.no_update, dash.no_update
+    
+    @app.callback(
+        dash.Output('alarms_datatable', 'data', allow_duplicate=True),
+        dash.Input('create_alarm_button', 'n_clicks'),
+        dash.State("tag_alarm_input", "value"),
+        dash.State("alarm_name_input", "value"), 
+        dash.State("alarm_description_input", "value"),
+        dash.State("alarm_type_input", "value"),
+        dash.State("alarm_trigger_value_input", "value"),
+        prevent_initial_call=True
+    )
+    def CreateAlarmButton(
+        btn1, 
+        tag_name,
+        alarm_name,
+        alarm_description,
+        alarm_type,
+        trigger_value
+        ):
+        r"""
+        Documentation here
+        """
+        if "create_alarm_button" == dash.ctx.triggered_id:
+            
+            alarm, message = app.automation.create_alarm(
+                name=alarm_name,
+                tag=tag_name,
+                alarm_type=alarm_type,
+                trigger_value=float(trigger_value),
+                description=alarm_description
+            )
+            
+            if not alarm:
+                
+                dash.set_props("modal-body-alarm-create", {"children": message})
+                dash.set_props("modal-alarm-create", {'is_open': True})
+            
+            return app.alarms_table_data()
+        
+    @app.callback(
+        dash.Input('alarms_datatable', 'data_timestamp'),
+        dash.State('alarms_datatable', 'data_previous'),
+        dash.State('alarms_datatable', 'data'),
+        )
+    def delete_update_alarms(timestamp, previous, current):
+
+        if timestamp:
+
+            if previous and current: # UPDATE TAG DEFINITION
+                
+                to_updates = find_differences_between_lists(previous, current)
+                alarm_to_update = to_updates[0]
+                alarm_id = alarm_to_update.pop("id")
+                message = f"Do you want to update alarm {alarm_id} To {alarm_to_update}?"
+
+                # OPEN MODAL TO CONFIRM CHANGES
+                dash.set_props("modal-update-delete-alarm-body", {"children": message})
+                dash.set_props("modal-update-delete-alarm", {'is_open': True})
+
+    @app.callback(
+        [
+            dash.Output("modal-update-delete-alarm", "is_open"), 
+            dash.Output('alarms_datatable', 'data'), 
+            dash.Output('alarms_datatable', 'data_timestamp'),
+            dash.Output("update-delete-alarm-yes", "n_clicks"),
+            dash.Output("update-delete-alarm-no", "n_clicks")
+        ],
+        [dash.Input("update-delete-alarm-yes", "n_clicks"), dash.Input("update-delete-alarm-no", "n_clicks")],
+        [
+            dash.State('alarms_datatable', 'data_timestamp'),
+            dash.State("modal-update-delete-alarm", "is_open"),
+            dash.State('alarms_datatable', 'data_previous'),
+            dash.State('alarms_datatable', 'data')
+        ]
+    )
+    def toggle_modal_update_delete_alarm(yes_n, no_n, timestamp, is_open, previous, current):
+        r"""
+        Documentation here
+        """
+        
+        if yes_n:
+            
+            if timestamp:
+                
+                if len(previous) > len(current): # DELETE ALARM
+
+                    removed_rows = [row for row in previous if row not in current]
+                    
+                    for row in removed_rows:
+                        _id = row['id']
+                        message = app.automation.delete_alarm(id=_id)
+                        
+                        if message:
+                            dash.set_props("modal-body-alarm-create", {"children": message})
+                            dash.set_props("modal-alarm-create", {'is_open': True})
+                        
+                elif previous and current: # UPDATE TAG DEFINITION
+                    to_updates = find_differences_between_lists(previous, current)
+                    alarm_to_update = to_updates[0]
+                    alarm_id = alarm_to_update.pop("id")
+                    message = app.automation.update_alarm(id=alarm_id, **alarm_to_update)
+                    
+                    if message:
+                        dash.set_props("modal-body-alarm-create", {"children": message})
+                        dash.set_props("modal-alarm-create", {'is_open': True})
+                
+                return not is_open, app.alarms_table_data(), None, 0, 0
+        
+        elif no_n:
+            
+            return not is_open, app.alarms_table_data(), None, 0, 0
+
+        else:
+
+            return is_open, app.alarms_table_data(), None, 0, 0
+        

automation/pages/callbacks/alarms_summary.py

@@ -0,0 +1,20 @@
+import dash
+
+def init_callback(app:dash.Dash):
+
+    @app.callback(
+        dash.Output('alarms_summary_datatable', 'data'),
+        dash.Input('alarms_history_page', 'pathname'),
+        prevent_initial_call=True
+        )
+    def display_page(pathname):
+        r"""
+        Documentation here
+        """
+        if pathname=="/alarms-history":
+
+            data = app.automation.get_lasts_alarms()
+
+            return data
+        
+        return dash.no_update