PyAutomationIO 0.0.0__py3-none-any.whl

automation/managers/db.py

@@ -0,0 +1,328 @@
+# -*- coding: utf-8 -*-
+"""pyhades/managers/logger.py
+
+This module implements Logger Manager.
+"""
+import logging, queue
+from ..singleton import Singleton
+from ..logger.datalogger import DataLoggerEngine
+from ..logger.logdict import  LogTable
+from ..logger.alarms import AlarmsLoggerEngine
+from ..logger.events import EventsLoggerEngine
+from ..logger.users import UsersLoggerEngine
+from ..logger.logs import LogsLoggerEngine
+from ..logger.machines import MachinesLoggerEngine
+from ..logger.opcua_server import OPCUAServerLoggerEngine
+from ..tags import CVTEngine, TagObserver
+from ..modules.users.users import User
+from ..utils.decorators import logging_error_handler
+from ..dbmodels import (
+    Manufacturer,
+    Segment,
+    Tags, 
+    TagValue, 
+    AlarmTypes,
+    AlarmStates, 
+    Alarms,  
+    AlarmSummary, 
+    Variables, 
+    Units, 
+    DataTypes,
+    OPCUA,
+    Users,
+    Roles,
+    Events,
+    Logs,
+    Machines,
+    TagsMachines,
+    AccessType,
+    OPCUAServer,
+    BaseModel
+)
+
+
+class DBManager(Singleton):
+    r"""
+    Database Manager class for database logging settings.
+    """
+
+    def __init__(self, period:float=1.0, delay:float=1.0, drop_tables:bool=False):
+
+        self._period = period
+        self._delay = delay
+        self._drop_tables = drop_tables
+        self._tag_queue = queue.Queue()
+        self.engine = CVTEngine()
+        self._logging_tags = LogTable()
+        self._logger = DataLoggerEngine()
+        self.alarms_logger = AlarmsLoggerEngine()
+        self.events_logger = EventsLoggerEngine()
+        self.users_logger = UsersLoggerEngine()
+        self.logs_logger = LogsLoggerEngine()
+        self.machines_logger = MachinesLoggerEngine()
+        self.opcuaserver_logger = OPCUAServerLoggerEngine()
+        self._tables = [
+            Manufacturer,
+            Segment,
+            Variables, 
+            Units, 
+            DataTypes, 
+            Tags, 
+            TagValue, 
+            AlarmTypes,
+            AlarmStates,
+            Alarms,
+            AlarmSummary,
+            OPCUA,
+            Roles,
+            Users,
+            Events,
+            Logs,
+            Machines,
+            TagsMachines,
+            AccessType,
+            OPCUAServer
+        ]
+
+        self._extra_tables = []
+        
+    def get_queue(self)->queue.Queue:
+        r"""
+        Documentation here
+        """
+        return self._tag_queue
+
+    def set_db(self, db, is_history_logged:bool=False):
+        r"""
+        Initialize a new DB Object SQLite - Postgres - MySQL
+
+        **Parameters**
+
+        * **db** (db object): Sqlite - Postgres or MySql db object
+
+        **Returns** `None`
+        """
+        self._logger.set_db(db)
+        self._logger.logger.set_is_history_logged(value=is_history_logged)
+        self.alarms_logger.set_db(db)
+        self.alarms_logger.logger.set_is_history_logged(value=is_history_logged)
+        self.events_logger.set_db(db)
+        self.events_logger.logger.set_is_history_logged(value=is_history_logged)
+        self.users_logger.set_db(db)
+        self.logs_logger.set_db(db)
+        self.logs_logger.logger.set_is_history_logged(value=is_history_logged)
+        self.machines_logger.set_db(db)
+        self.opcuaserver_logger.logger.set_db(db)
+        
+    def get_db(self):
+        r"""
+        Returns a DB object
+        """
+        return self._logger.get_db()
+
+    def set_dropped(self, drop_tables:bool):
+        r"""
+        Allows to you set a flag variable to drop database tables when run app.
+
+        **Parameters**
+
+        * **drop_tables** (bool) If True, drop all tables define in the app an initialized it in blank.
+
+        **Returns**
+
+        * **None**
+        """
+        self._drop_tables = drop_tables
+
+    def get_dropped(self)->bool:
+        r"""
+        Gets flag variables to drop tables when initialize the app
+
+        **Return**
+
+        * **drop_tables** (bool) Flag variables to drop table
+        """
+        return self._drop_tables
+
+    def register_table(self, cls:BaseModel):
+        r"""
+        Allows to you register a new database model
+
+        **Parameters**
+
+        * **cls* (BaseModel): A class that inherit from BaseModel
+
+        """
+        self._tables.append(cls)
+
+    def get_db_table(self, tablename:str):
+        r"""
+        Documentation here
+        """
+        for table in self._tables:
+
+            if table._meta.table_name.lower()==tablename.lower():
+
+                return table
+            
+        return None
+
+    def create_tables(self):
+        r"""
+        Creates default tables and tables registered with method *register_table*
+        """
+        self._tables.extend(self._extra_tables)
+        self._logger.create_tables(self._tables)
+        self.alarms_logger.create_tables(self._tables)
+
+    def drop_tables(self):
+        r"""
+        Drop all tables defined
+        """
+        tables = self._tables
+        
+        self._logger.drop_tables(tables)
+
+    def clear_default_tables(self):
+        r"""
+        If you want initialize any PyHades app without default tables, you can use this method
+        """
+        self._tables = []
+
+    def get_tags(self)->dict:
+        r"""
+        Gets all tag defined in tag's repository
+        """
+        return self._logger.get_tags()
+    
+    def get_alarms(self)->dict:
+        r"""
+        Gets all tag defined in tag's repository
+        """
+
+        return self.alarms_logger.get_alarms()
+
+    @logging_error_handler
+    def set_tag(
+        self, 
+        tag:str, 
+        unit:str, 
+        data_type:str, 
+        description:str,
+        display_name:str="", 
+        min_value:float=None, 
+        max_value:float=None, 
+        tcp_source_address:str=None, 
+        node_namespace:str=None):
+        r"""
+        Sets tag to Database
+
+        **Parameters**
+
+        * **tag** (str):
+        * **unit** (str):
+        * **data_type** (str):
+        * **description** (str):
+        * **min_value** (float)[Optional]:
+        * **max_value** (float)[Optional]:
+        * **tcp_source_address** (str)[Optional]:
+        * **node_namespace** (str)[Optional]:
+        """
+        self._logger.set_tag(
+            tag=tag,  
+            unit=unit,
+            data_type=data_type,
+            description=description,
+            display_name=display_name,
+            min_value=min_value,
+            max_value=max_value,
+            tcp_source_address=tcp_source_address,
+            node_namespace=node_namespace
+        )
+
+    def set_tags(self):
+        r"""
+        Allows to you define all tags added with *add_tag* method
+        """
+        for period in self._logging_tags.get_groups():
+            
+            tags = self._logging_tags.get_tags(period)
+        
+            for tag, unit, data_type, description, display_name, min_value, max_value, tcp_source_address, node_namespace in tags:
+
+                self.set_tag(
+                    tag=tag,
+                    unit=unit, 
+                    data_type=data_type, 
+                    description=description, 
+                    display_name=display_name,
+                    min_value=min_value, 
+                    max_value=max_value, 
+                    tcp_source_address=tcp_source_address, 
+                    node_namespace=node_namespace)
+
+    def init_database(self):
+        r"""
+        Initializes all databases.
+        """
+        if self.get_dropped():
+            try:
+                self.drop_tables()
+            except Exception as e:
+                error = str(e)
+                logger = logging.getLogger("pyautomation")
+                logger.error("Database:{}".format(error))
+        
+        self.create_tables()
+
+    def stop_database(self):
+        r"""
+        Documentation here
+        """
+        self._logger.stop_db()
+
+    def get_opcua_clients(self):
+        r"""
+        Documentation here
+        """
+        return OPCUA.read_all()
+
+    # USERS METHODS
+    def set_role(self, name:str, level:int, identifier:str):
+        r"""
+        Documentation here
+        """
+        return self.users_logger.set_role(name=name, level=level, identifier=identifier)
+
+    def set_user(self, user:User):
+        r"""
+        Documentation here
+        """
+        return self.users_logger.set_user(user=user)
+    
+    def login(self, password:str, username:str="", email:str=""):
+        r"""
+        Documentation here
+        """
+        return self.users_logger.login(password=password, username=username, email=email)
+
+    def summary(self)->dict:
+        r"""
+        Get database manager summary
+
+        **Returns**
+
+        * **summary** (dict): Database summary
+        """
+        result = dict()
+
+        result["period"] = self.get_period()
+        result["tags"] = self.get_tags()
+        result["delay"] = self.get_delay()
+
+        return result
+    
+    def attach(self, tag_name:str):
+
+        observer = TagObserver(self._tag_queue)
+        self.engine.attach(name=tag_name, observer=observer)

automation/managers/opcua_client.py

@@ -0,0 +1,186 @@
+from ..opcua.models import Client
+from ..dbmodels import OPCUA
+from ..logger.datalogger import DataLoggerEngine
+from ..tags import CVTEngine
+from ..opcua.subscription import DAS
+
+class OPCUAClientManager:
+    r"""
+    Documentation here
+    """
+
+    def __init__(self):
+        r"""
+        Documentation here
+        """
+        self._clients = dict()
+        self.logger = DataLoggerEngine()
+        self.cvt = CVTEngine()
+        self.das = DAS()
+
+    def discovery(self, host:str='127.0.0.1', port:int=4840)->list[dict]:
+        r"""
+        Documentation here
+        """
+        return Client.find_servers(host, port)
+
+    def add(self, client_name:str, host:str, port:int):
+        r"""
+        Documentation here
+        """
+        endpoint_url = f"opc.tcp://{host}:{port}"
+        if client_name in self._clients:
+
+            return True, f"Client Name {client_name} duplicated"
+
+        opcua_client = Client(endpoint_url, client_name=client_name)
+        
+        message, status_connection = opcua_client.connect()
+        if status_connection==200:
+
+            self._clients[client_name] = opcua_client
+            
+            # DATABASE PERSISTENCY
+            if self.logger.get_db():
+                
+                OPCUA.create(client_name=client_name, host=host, port=port)
+
+            # RECONNECT TO SUBSCRIPTION 
+            for tag in self.cvt.get_tags():
+                
+                if tag["opcua_address"]==endpoint_url:
+
+                    if not tag["scan_time"]:
+
+                        subscription = opcua_client.create_subscription(1000, self.das)
+                        node_id = opcua_client.get_node_id_by_namespace(tag["node_namespace"])
+                        self.das.subscribe(subscription=subscription, client_name=client_name, node_id=node_id)
+
+                    self.das.restart_buffer(tag=self.cvt.get_tag(id=tag["id"]))
+        
+            return True, message
+        
+        return False, message
+
+    def remove(self, client_name:str):
+        r"""
+        Documentation here
+        """
+        if client_name in self._clients:
+            try:
+                opcua_client = self._clients.pop(client_name)
+                opcua_client.disconnect()
+                # DATABASE PERSISTENCY
+                opcua = OPCUA.get_by_client_name(client_name=client_name)
+                if opcua:
+                    if self.logger.get_db():
+                        query = OPCUA.delete().where(OPCUA.client_name == client_name)
+                        query.execute()
+
+                return True
+            except Exception as err:
+
+                return False
+        
+        return False
+
+    def connect(self, client_name:str)->dict:
+        r"""
+        Documentation here
+        """
+        if client_name in self._clients:
+
+            self._clients[client_name].connect()
+
+    def disconnect(self, client_name:str)->dict:
+        r"""
+        Documentation here
+        """
+        if client_name in self._clients:
+
+            self._clients[client_name].disconnect()
+
+    def get(self, client_name:str)->Client:
+        r"""
+        Documentation here
+        """
+        if client_name in self._clients:
+
+            return self._clients[client_name]
+        
+    def get_opcua_tree(self, client_name):
+        r"""
+        Documentation here
+        """
+        client = self.get(client_name=client_name)
+        if client.is_connected():
+            root_node = client.get_root_node()
+            _tree = client.browse_tree(root_node)
+            result = {
+                "Objects": _tree[0]["children"]
+            }
+            return result, 200
+        
+        return {}, 400
+        
+    def get_node_values(self, client_name:str, namespaces:list)->list:
+
+        if client_name in self._clients:
+
+            client = self._clients[client_name]
+            if client.is_conneted():
+                return client.get_nodes_values(namespaces=namespaces)
+        
+    def get_client_by_address(self, opcua_address:str)->Client|None:
+        r"""
+        Obtiene el cliente OPC UA correspondiente a una dirección
+        
+        Args:
+            opcua_address: Dirección del servidor OPC UA (ej: "opc.tcp://localhost:4840")
+        
+        Returns:
+            Client: Cliente OPC UA si existe y está conectado, None en caso contrario
+        """
+        for client_name, client in self._clients.items():
+            if opcua_address == client.serialize()["server_url"]:
+                if client.is_connected():
+                    return client
+        return None
+    
+    def get_node_value_by_opcua_address(self, opcua_address:str, namespace:str)->list:
+        r"""
+        Documentation here
+        """
+        for client_name, client in self._clients.items():
+
+            if opcua_address==client.serialize()["server_url"]:
+                if client.is_connected():
+                    return self.get_node_attributes(client_name=client_name, namespaces=[namespace])
+        
+    def get_node_attributes(self, client_name:str, namespaces:list)->list:
+
+        result = list()
+
+        if client_name in self._clients:
+
+            client = self._clients[client_name]
+
+            for namespace in namespaces:
+                if client.is_connected():
+                    result.append(client.get_node_attributes(node_namespace=namespace))
+
+            return result
+
+    def serialize(self, client_name:str=None)->dict:
+        r"""
+        Documentation here
+        """
+        if client_name:
+
+            if client_name in self._clients:
+
+                opcua_client = self._clients[client_name]
+
+            return opcua_client.serialize()
+
+        return {client_name: client.serialize() for client_name, client in self._clients.items()}

automation/managers/state_machine.py

@@ -0,0 +1,183 @@
+# -*- coding: utf-8 -*-
+"""broker/managers/state_machine.py
+
+This module implements Function Manager.
+"""
+from statemachine import StateMachine
+from ..models import StringType
+from ..tags import TagObserver, CVTEngine, Tag
+import queue
+
+class StateMachineManager:
+    r"""
+    Handles and manager the state machines defined in the application in a store defined by a list of tuples
+
+    Its structure is [(machine_1, interval_1, mode_1), (machine_2, interval_2, mode_2), ... (machine_n, interval_n, mode_n)]
+    """
+
+    def __init__(self):
+
+        self._machines = list()
+        self._tag_queue = queue.Queue()
+
+    def get_queue(self)->queue.Queue:
+        r"""Documentation here
+
+        # Parameters
+
+        - 
+
+        # Returns
+
+        - 
+        """
+        return self._tag_queue
+
+    def append_machine(self, machine:StateMachine):
+        r"""
+        Appends machines to the store
+
+        **Parameters**
+
+        * **machine:** (PyHadesStateMachine) instance
+        * **interval:** (float) Execution interval in seconds
+        * **mode:** (str) Thread mode of the state machine, allowed mode ('sync', 'async')
+
+        **Returns** `None`
+
+        Usage
+
+        ```python
+        >>> manager = app.get_state_machine_manager()
+        >>> manager.append_machine(machine, interval, mode)
+        ```
+        """
+        
+        self._machines.append(machine)
+
+    def get_machines(self)->list:
+        r"""
+        Gets state machines
+
+        **Returns**
+
+        * **machines** (list of tuples)
+
+        Usage
+
+        ```python
+        >>> manager = app.get_state_machine_manager()
+        >>> machines = manager.get_machines()
+        [(machine_1, interval_1, mode_1), (machine_2, interval_2, mode_2), ... (machine_n, interval_n, mode_n)]
+        ```
+        """
+        result = self._machines
+        
+        return result
+    
+    def serialize_machines(self):
+        r"""
+        Documentation here
+        """
+
+        return [machine.serialize() for machine, _, _ in self.get_machines()]
+
+    def get_machine(self, name:StringType)->StateMachine:
+        r"""
+        Gets state machine by its name
+
+        **Parameters**
+
+        * **name:** (str) State machine name
+
+        **Returns**
+
+        * **machine:** (PyHadesStateMachine) instance
+
+        Usage
+
+        ```python
+        >>> manager = app.get_state_machine_manager()
+        >>> machine = manager.get_machine(state_machine_name)
+        ```
+        """
+        for machine, _, _ in self._machines:
+
+            if name.value == machine.name.value:
+
+                return machine
+            
+    def drop(self, name:str):
+        r"""
+        Documentation here
+        """
+        index = 0
+        for machine, _, _ in self._machines:
+
+            if name == machine.name.value:
+
+                machine_to_revome_from_worker = self._machines.pop(index)
+                break
+
+            index += 1
+
+        if machine_to_revome_from_worker:
+
+            return machine_to_revome_from_worker
+
+    def unsubscribe_tag(self, tag:Tag):
+        r"""
+        Documentation here
+        """
+        machine_to_revome_from_worker = (None, None, None)
+        for machine, _, _ in self._machines:
+
+            if hasattr(machine, "unsubscribe_to"):
+
+                machine.unsubscribe_to(tag=tag)
+
+                if machine.classification.value.lower()=="data acquisition system":
+
+                    if not machine.get_subscribed_tags():
+                
+                        machine_to_revome_from_worker = self.drop(name=machine.name.value)
+                        break
+
+        if machine_to_revome_from_worker:
+
+            return machine_to_revome_from_worker
+
+    def summary(self)->dict:
+        r"""
+        Get a summary of the state machine defined
+
+        **Returns**
+
+        * **summary:** (dict) with keys ('length' (int) - 'state_machines' (list of state machine names))
+        """
+        result = dict()
+        machines = [machine.name for machine, _, _ in self.get_machines()]
+
+        result["length"] = len(machines)
+        result["state_machines"] = machines
+
+        return result
+
+    def exist_machines(self)->bool:
+        r"""
+        Checks if exist state machines defined
+
+        **Returns**
+
+        * **Bool**
+
+        Usage
+
+        ```python
+        >>> manager = app.get_state_machine_manager()
+        >>> manager.exist_machines()
+        ```
+        """
+        return len(self._machines) > 0
+    
+