PyAutomationIO 1.1.1__py3-none-any.whl

automation/tests/test_core.py

@@ -0,0 +1,257 @@
+import unittest, os
+from datetime import datetime
+from .. import PyAutomation
+from ..alarms import Alarm, AlarmState
+
+
+class TestCore(unittest.TestCase):
+
+    def setUp(self) -> None:
+        file_path = os.path.join(".", "db", "test.db")
+        if os.path.exists(file_path):
+            os.remove(file_path)
+        self.app = PyAutomation()
+        self.app.run(debug=True, test=True, create_tables=True)
+        return super().setUp()
+
+    def tearDown(self) -> None:
+        self.app.safe_stop()
+        return super().tearDown()
+    
+    def test_tags(self):
+        
+        # CREATE TAGS
+        _tag1 = {
+            "name": "P1",
+            "unit": "Pa",
+            "variable": "Pressure"
+        }
+        tag1, _ = self.app.create_tag(**_tag1)
+        with self.subTest("Test tag in cvt"):
+            
+            tag_in_cvt = self.app.cvt.get_tag_by_name(name=_tag1['name'])
+            self.assertEqual(tag1, tag_in_cvt)
+
+        # GET TAGS
+        _tag2 = {
+            "name": "T1",
+            "unit": "C",
+            "variable": "Temperature"
+        }
+        tag2, _ = self.app.create_tag(**_tag2)
+
+        # SET TAG VALUES
+        timestamp = datetime.now()
+        value = 35
+        self.app.cvt.set_value(id=tag2.id, value=value, timestamp=timestamp)
+        with self.subTest("Test Value in CVT"):
+            
+            self.assertEqual(self.app.cvt.get_value(id=tag2.id), value)
+
+        # UPDATE TAGS
+        name = "TT"
+        updated_tag, _ = self.app.update_tag(id=tag2.id, name=name)
+        with self.subTest("Test update tag name"):
+
+            self.assertEqual(name, updated_tag.name)
+
+        with self.subTest("Test update tag name from DB"):
+
+            updated_tag = self.app.logger_engine.get_tag_by_name(name=name)
+            self.assertEqual(name, updated_tag.name)
+
+        unit = "K"
+        updated_tag, _ = self.app.update_tag(id=tag2.id, unit=unit)
+        with self.subTest("Test update tag unit"):
+
+            self.assertEqual(unit, updated_tag.unit)
+
+        with self.subTest("Test update tag unit from DB"):
+
+            updated_tag = self.app.logger_engine.get_tag_by_name(name=tag2.name)
+            self.assertEqual(unit, updated_tag.unit.unit)
+
+        # DELETE TAG
+        self.app.delete_tag(id=tag2.id)
+        with self.subTest("Test delete tag"):
+
+            self.assertIsNone(self.app.get_tag_by_name(name=tag2.name))
+
+        with self.subTest("Test delete tag from DB"):
+            tag = self.app.logger_engine.get_tag_by_name(name=tag2.name)
+            self.assertFalse(tag.active)
+
+        # DELETE TAG BY NAME
+        self.app.delete_tag_by_name(name=tag1.name)
+        with self.subTest("Test delete tag by name"):
+
+            self.assertIsNone(self.app.get_tag_by_name(name=tag1.name))
+
+        with self.subTest("Test delete tag by name from DB"):
+            tag = self.app.logger_engine.get_tag_by_name(name=tag1.name)
+            self.assertFalse(tag.active)
+
+    def test_alarms(self):
+        r"""
+        Documentation here
+        """
+
+        tag_payload = {
+            "name": "T2",
+            "unit": "C",
+            "variable": "Temperature"
+        }
+        tag, _ = self.app.create_tag(**tag_payload)
+
+        alarm_LL_payload = {
+            "name": "alarm_LL",
+            "tag": tag.name,
+            "alarm_type": "LOW-LOW",
+            "trigger_value": 10.0,
+        }
+
+        # CREATE ALARM
+        alarm_LL, _ = self.app.create_alarm(**alarm_LL_payload)
+        with self.subTest("Test create alarm instance"):
+
+            self.assertIsInstance(alarm_LL, Alarm)
+
+        with self.subTest("Test create alarm in alarm manager"):
+
+            self.assertEqual(alarm_LL, self.app.alarm_manager.get_alarm_by_name(name=alarm_LL.name))
+
+        alarm_L_payload = {
+            "name": "alarm_L",
+            "tag": tag.name,
+            "alarm_type": "LOW",
+            "trigger_value": 20.0,
+        }
+        alarm_L, _ = self.app.create_alarm(**alarm_L_payload)
+        with self.subTest("Test create alarm instance"):
+
+            self.assertIsInstance(alarm_L, Alarm)
+        
+        with self.subTest("Test create alarm in alarm manager"):
+
+            self.assertEqual(alarm_L, self.app.alarm_manager.get_alarm_by_name(name=alarm_L.name))
+
+        alarm_H_payload = {
+            "name": "alarm_H",
+            "tag": tag.name,
+            "alarm_type": "HIGH",
+            "trigger_value": 30.0,
+        }
+        alarm_H, _ = self.app.create_alarm(**alarm_H_payload)
+        with self.subTest("Test create alarm instance"):
+
+            self.assertIsInstance(alarm_H, Alarm)
+
+        with self.subTest("Test create alarm in alarm manager"):
+
+            self.assertEqual(alarm_H, self.app.alarm_manager.get_alarm_by_name(name=alarm_H.name))
+
+        alarm_HH_payload = {
+            "name": "alarm_HH",
+            "tag": tag.name,
+            "alarm_type": "HIGH-HIGH",
+            "trigger_value": 40.0,
+        }
+        alarm_HH, _ = self.app.create_alarm(**alarm_HH_payload)
+        with self.subTest("Test create alarm instance"):
+
+            self.assertIsInstance(alarm_HH, Alarm)
+
+        with self.subTest("Test create alarm in alarm manager"):
+
+            self.assertEqual(alarm_HH, self.app.alarm_manager.get_alarm_by_name(name=alarm_HH.name))
+
+        # UPDATE ALARM DEFINITION
+        self.app.update_alarm(id=alarm_HH.identifier, trigger_value=50)
+        with self.subTest("Test update alarm in Alarm Manager"):
+            
+            self.assertEqual(alarm_HH.alarm_setpoint.value, 50)
+
+        with self.subTest("Test update alarm in DB"):
+            alarm = self.app.alarms_engine.get_alarm_by_name(name=alarm_HH.name)
+            self.assertEqual(alarm.trigger_value, 50)
+
+        # TRIGGER ALARMS
+        timestamp = datetime.now()
+        self.app.cvt.set_value(id=tag.id, value=35, timestamp=timestamp)
+        with self.subTest("Test Trigger HIGH Alarm"):
+            
+            self.assertEqual(alarm_H.state.alarm_status, "Active")
+
+        with self.subTest("Test check UNACK alarm state"):
+            
+            self.assertEqual(alarm_H.state, AlarmState.UNACK)
+
+        with self.subTest("Test aknowledge alarm"):
+            alarm_H.acknowledge()
+            self.assertEqual(alarm_H.state, AlarmState.ACKED)
+
+        with self.subTest("Test not Trigger HIGH-HIGH Alarm"):
+
+            self.assertEqual(alarm_HH.state.alarm_status, "Not Active")
+
+        self.app.cvt.set_value(id=tag.id, value=0, timestamp=timestamp)
+        with self.subTest("Test Trigger LOW Alarm"):
+            
+            self.assertEqual(alarm_L.state.alarm_status, "Active")
+
+        with self.subTest("Test Trigger LOW-LOW Alarm"):
+            
+            self.assertEqual(alarm_LL.state.alarm_status, "Active")
+
+        with self.subTest("Test check UNACK alarm LL state"):
+            
+            self.assertEqual(alarm_LL.state, AlarmState.UNACK)
+
+        with self.subTest("Test check UNACK alarm L state"):
+            
+            self.assertEqual(alarm_L.state, AlarmState.UNACK)
+
+        self.app.cvt.set_value(id=tag.id, value=15, timestamp=timestamp)
+        with self.subTest("Test check UNACK alarm LL state"):
+            
+            self.assertEqual(alarm_LL.state, AlarmState.RTNUN)
+
+        with self.subTest("Test aknowledge LL alarm"):
+            alarm_LL.acknowledge()
+            self.assertEqual(alarm_LL.state, AlarmState.NORM)
+
+        with self.subTest("Test aknowledge L alarm"):
+            alarm_L.acknowledge()
+            self.assertEqual(alarm_L.state, AlarmState.ACKED)
+
+
+        # Boolean Alarm
+        tag_payload = {
+            "name": "Bool1",
+            "unit": "adim",
+            "variable": "Adimentional"
+        }
+        tag, _ = self.app.create_tag(**tag_payload)
+        alarm_B_payload = {
+            "name": "alarm_B",
+            "tag": tag.name,
+            "alarm_type": "BOOL",
+            "trigger_value": True,
+        }
+        alarm_B, _ = self.app.create_alarm(**alarm_B_payload)
+
+        with self.subTest("Test Not Trigger BOOL Alarm"):
+            
+            self.assertEqual(alarm_B.state.alarm_status, "Not Active")
+
+        self.app.cvt.set_value(id=tag.id, value=True, timestamp=timestamp)
+        with self.subTest("Test Trigger BOOL Alarm"):
+            
+            self.assertEqual(alarm_B.state.alarm_status, "Active")
+
+        # DELETE TAG
+        self.app.delete_alarm(id=alarm_LL.identifier)
+        self.app.delete_alarm(id=alarm_L.identifier)
+        self.app.delete_alarm(id=alarm_H.identifier)
+        self.app.delete_alarm(id=alarm_HH.identifier)
+        self.app.delete_tag(id=tag.id)

automation/tests/test_unit.py

@@ -0,0 +1,21 @@
+import unittest
+from ..variables import (Pressure)
+
+class TestConversions(unittest.TestCase):
+
+    def setUp(self) -> None:
+        
+        return super().setUp()
+
+    def tearDown(self) -> None:
+        
+        return super().tearDown()
+    
+    def test_pressure_conversions(self):
+
+        value = 10
+        from_unit = "atm"
+        to_unit = "psi"
+        expected = 146.959
+
+        self.assertAlmostEqual(Pressure.convert_value(value, from_unit=from_unit, to_unit=to_unit), expected, delta=0.001)

automation/tests/test_user.py

@@ -0,0 +1,155 @@
+import unittest
+from . import assert_dict_contains_subset
+from ..modules.users.users import Users, User
+from ..modules.users.roles import roles, Role
+
+USERNAME = "user1"
+ROLE_NAME = "admin"
+EMAIL = "jhon.doe@gmail.com"
+PASSWORD = "123456"
+NAME = "Jhon"
+LASTNAME = "Doe"
+
+USERNAME2 = "user2"
+EMAIL2 = "jhon.doe2@gmail.com"
+
+class TestUsers(unittest.TestCase):
+
+    def setUp(self) -> None:
+        
+        self.roles = roles
+        self.roles._delete_all()
+        self.users = Users()
+        self.users._delete_all()
+
+        return super().setUp()
+
+    def tearDown(self) -> None:
+        delattr(self, "roles")
+        delattr(self, "users")
+        return super().tearDown()
+    
+    def test_create_role(self):
+        
+        admin = Role(name="admin", level=0)
+        expected = {
+            "name": "admin",
+            "level": 0
+        }
+        assert_dict_contains_subset(expected, admin.serialize())
+    
+    def test_add_role_to_repo(self):
+        
+        admin = Role(name="admin", level=0)
+        self.roles.add(role=admin)
+        self.assertIn(admin, self.roles.roles.values())
+
+    def test_get_role(self):
+        
+        admin = Role(name="admin", level=0)
+        admin_id, _ = self.roles.add(role=admin)
+        self.assertEqual(admin, self.roles.get(id=admin_id))
+
+    def test_get_role_by_name(self):
+        
+        admin = Role(name="admin", level=0)
+        self.roles.add(role=admin)
+        self.assertEqual(admin, self.roles.get_by_name(name=admin.name))
+
+    def test_get_role_names(self):
+        
+        roles = ["sudo", "admin", "operator"]
+        for role in roles:
+            _role = Role(name=role, level=0)
+            self.roles.add(role=_role)
+
+        self.assertListEqual(roles, self.roles.get_names())
+
+    def test_put_role(self):
+        
+        role = Role(name="admin", level=0)
+        role_id, _ = self.roles.add(role=role)
+        self.roles.put(id=role_id, name="sudo")
+        self.assertEqual(role.name, "sudo")
+
+    def test_delete_role(self):
+        
+        roles = ["sudo", "admin", "operator"]
+        for role in roles:
+            _role = Role(name=role, level=0)
+            role_id = self.roles.add(role=_role)
+        role = self.roles.get(id=role_id)
+        self.roles.delete(id=role_id)
+        self.assertNotIn(role, self.roles.roles.values())
+
+    def test_signup(self):
+
+        role = Role(name=ROLE_NAME, level=0)
+        self.roles.add(role=role)
+        user, _ = self.users.signup(username=USERNAME, role_name=ROLE_NAME, email=EMAIL, password=PASSWORD, name=NAME, lastname=LASTNAME)
+        self.assertIsInstance(user, User)
+
+    def test_login_logout(self):
+
+        role = Role(name=ROLE_NAME, level=0)
+        self.roles.add(role=role)
+        user, _ = self.users.signup(username=USERNAME, role_name=ROLE_NAME, email=EMAIL, password=PASSWORD, name=NAME, lastname=LASTNAME)
+        with self.subTest("Test Login"):
+            
+            self.assertTrue(self.users.login(password="123456", username="user1"))
+
+        with self.subTest("Test Active user"):
+
+            self.assertEqual(user, self.users.get_active_user(token=user.token))
+
+        with self.subTest("Test Logout"):
+
+            self.users.logout(user.token)
+            self.assertIsNone(self.users.get_active_user(token=user.token))
+
+    def test_login_fail(self):
+
+        role = Role(name=ROLE_NAME, level=0)
+        self.roles.add(role=role)
+        user, _ = self.users.signup(username=USERNAME, role_name=ROLE_NAME, email=EMAIL, password=PASSWORD, name=NAME, lastname=LASTNAME)
+        self.assertFalse(self.users.login(password=user.password, username="user1"))
+
+    def test_get_user(self):
+
+        role = Role(name=ROLE_NAME, level=0)
+        self.roles.add(role=role)
+        user, _ = self.users.signup(username=USERNAME, role_name=ROLE_NAME, email=EMAIL, password=PASSWORD, name=NAME, lastname=LASTNAME)
+        self.assertEqual(user, self.users.get(identifier=user.identifier))
+
+    def test_get_by_username(self):
+
+        role = Role(name=ROLE_NAME, level=0)
+        self.roles.add(role=role)
+        user, _ = self.users.signup(username=USERNAME, role_name=ROLE_NAME, email=EMAIL, password=PASSWORD, name=NAME, lastname=LASTNAME)
+        self.assertEqual(user, self.users.get_by_username(username=USERNAME))
+
+    def test_get_by_email(self):
+
+        role = Role(name=ROLE_NAME, level=0)
+        self.roles.add(role=role)
+        user, _ = self.users.signup(username=USERNAME, role_name=ROLE_NAME, email=EMAIL, password=PASSWORD, name=NAME, lastname=LASTNAME)
+        self.assertEqual(user, self.users.get_by_email(email=EMAIL))
+
+    def test_get_active_user(self):
+
+        role = Role(name=ROLE_NAME, level=0)
+        self.roles.add(role=role)
+        user1, _ = self.users.signup(username=USERNAME, role_name=ROLE_NAME, email=EMAIL, password=PASSWORD, name=NAME, lastname=LASTNAME)
+        self.users.signup(username=USERNAME2, role_name=ROLE_NAME, email=EMAIL2, password=PASSWORD, name=NAME, lastname=LASTNAME)
+        self.users.login(password=PASSWORD, username=USERNAME)
+        self.assertEqual(user1, self.users.get_active_user(token=user1.token))
+
+    def test_get_not_active_user(self):
+
+        role = Role(name=ROLE_NAME, level=0)
+        self.roles.add(role=role)
+        self.users.signup(username=USERNAME, role_name=ROLE_NAME, email=EMAIL, password=PASSWORD, name=NAME, lastname=LASTNAME)
+        user2, _ = self.users.signup(username=USERNAME2, role_name=ROLE_NAME, email=EMAIL2, password=PASSWORD, name=NAME, lastname=LASTNAME)
+        self.users.login(password=PASSWORD, username=USERNAME)
+        self.assertIsNone(self.users.get_active_user(token=user2.token))
+

automation/utils/__init__.py

@@ -0,0 +1,164 @@
+import logging
+from .observer import Observer
+from ..variables import VARIABLES
+from ..alarms.states import ACTIONS
+
+def log_detailed(e, message):
+    logger = logging.getLogger("pyautomation")
+    logger.error(message)
+    logger.error(e, exc_info=True)
+
+def chunks(lst, n):
+    for i in range(0, len(lst), n):
+        yield lst[i:i + n]
+
+def find_differences_between_lists(prev_list, curr_list):
+    r"""
+    Documentation here
+    """
+    
+    differences = []
+
+    for prev_dict, curr_dict in zip(prev_list, curr_list):
+        diff = {'id': prev_dict['id']}
+        for key in prev_dict:
+            if prev_dict[key] != curr_dict[key]:
+                diff[key] = curr_dict[key]
+        if len(diff) > 1:  # Only add if there are differences other than 'id'
+            differences.append(diff)
+    
+    return differences
+
+def find_differences_between_lists_opcua_server(prev_list, curr_list):
+    r"""
+    Documentation here
+    """
+    
+    differences = []
+
+    for prev_dict, curr_dict in zip(prev_list, curr_list):
+        diff = {'name': prev_dict['name'], 'namespace': prev_dict['namespace']}
+
+        for key in prev_dict:
+            if prev_dict[key] != curr_dict[key]:
+                diff[key] = curr_dict[key]
+        if len(diff) > 2:  # Only add if there are differences other than 'id'
+            differences.append(diff)
+    
+    return differences
+
+def find_keys_values_by_unit(d, unit):
+    r"""
+    Documentation here
+    """
+    result = []
+    
+    for _, sub_dict in d.items():
+        
+        if unit in sub_dict.values():
+            
+            for k, v in sub_dict.items():
+                
+                result.append({'label': k, 'value': v})
+
+    return result
+
+def generate_dropdown_conditional():
+    r"""
+    Documentation here
+    """
+    from .. import PyAutomation
+    app = PyAutomation()
+    data = VARIABLES
+    dropdown_conditional = []
+    # dropdown conditional for unit column in table
+    for variable, sub_dict in data.items():
+
+        for unit in sub_dict.values():
+
+            options = find_keys_values_by_unit(data, unit)
+            
+            dropdown_conditional.append({
+                'if': {'column_id': 'unit', 'filter_query': f'{{variable}} eq "{variable}"'},
+                'options': options,
+                'clearable': False
+            })
+
+            dropdown_conditional.append({
+                'if': {'column_id': 'display_unit', 'filter_query': f'{{variable}} eq "{variable}"'},
+                'options': options,
+                'clearable': False
+            })
+
+    # dropdown conditional for node_namespace column in table
+    dropdown_conditional.append({
+        'if': {'column_id': 'node_namespace', 'filter_query': f'{{opcua_address}} eq ""'},
+        'options': []
+    })
+    for client_name, info in app.get_opcua_clients().items():
+        
+        tree = app.get_opcua_tree(client_name=client_name)
+        options = list()
+        for node in tree[0]["Objects"][0]["children"]:
+            options.append({
+                "label": node["title"],
+                "value": node["key"]
+            })
+            server = info['server_url']
+            dropdown_conditional.append({
+                'if': {'column_id': 'node_namespace', 'filter_query': f'{{opcua_address}} eq "{server}"'},
+                'options': options
+            })
+
+    return dropdown_conditional
+
+def get_nodes_info(selected_files:list):
+    r"""
+    Documentation here
+    """
+    to_get_node_values = dict()
+    for file in selected_files:
+        
+        if file:
+
+            info = file[0].split("/")
+            client_name = info[0]
+            namespace = info[1]
+            
+            if client_name in to_get_node_values:
+
+                to_get_node_values[client_name].append(namespace)
+
+            else:
+
+                to_get_node_values[client_name] = [namespace]
+
+    return to_get_node_values
+
+def get_data_to_update_into_opcua_table(app, to_get_node_values:dict):
+    r"""
+    Documentation here
+    """
+    data = list()
+    for client_name, namespaces in to_get_node_values.items():
+        
+        infos = app.automation.get_node_attributes(client_name=client_name, namespaces=namespaces)
+
+        if infos:
+        
+            for info in infos:
+                _info = info[0]
+                namespace = _info["Namespace"]
+                data.append(
+                    {
+                        "server": client_name,
+                        "namespace": namespace,
+                        "data_type": _info["DataType"],
+                        "display_name": _info["DisplayName"],
+                        "value": _info["Value"],
+                        "source_timestamp": _info["DataValue"].SourceTimestamp,
+                        "status_code": _info["DataValue"].StatusCode.name
+                    }
+                )
+    
+    return data