PyAutomationIO 0.0.0__py3-none-any.whl

automation/models.py

@@ -0,0 +1,174 @@
+# -*- coding: utf-8 -*-
+"""automation/models.py
+
+This module implements a Tags and other classes for
+modelling the subjects involved in the core of the engine.
+"""
+from .modules.users.users import User
+from .tags.tag import Tag
+from .utils.decorators import set_event, logging_error_handler
+from datetime import datetime, timezone
+
+
+FLOAT = "float"
+INTEGER = "int"
+BOOL = "bool"
+STRING = "str"
+
+class PropertyType:
+
+    """
+    Implement an abstract property type
+    """
+
+    def __init__(self, _type, default=None, unit=None):
+        from .tags.cvt import CVTEngine
+        from .opcua.subscription import DAS
+        self._type = _type
+        self.unit = unit
+        self.__value = default
+        self.cvt = CVTEngine()
+        self.das = DAS()
+
+    @property
+    def value(self):
+        r"""
+        Documentation here
+        """
+        return self.__value
+
+    @value.setter
+    def value(self, value):
+        
+        self.__value = value
+    
+    @set_event(message=f"Attribute updated", classification="State Machine", priority=2, criticity=3)
+    def set_value(self, value, user:User=None, name:str=None, machine=None):
+        
+        if isinstance(self, ProcessType):
+
+            if not self.read_only:
+
+                if hasattr(self, "tag"):
+
+                    if self.tag:
+
+                        if hasattr(machine, "data_timestamp"):
+                            timestamp = machine.data_timestamp
+                        else:
+                            timestamp = datetime.now(timezone.utc)
+                        val = self.tag.value.convert_value(value=value.value, from_unit=self.tag.get_unit(), to_unit=self.tag.get_display_unit())
+                        self.tag.value.set_value(value=val, unit=self.tag.get_display_unit()) 
+                        self.cvt.set_value(id=self.tag.id, value=val, timestamp=timestamp)
+                        if self.tag.get_name() in self.das.buffer:
+                            self.das.buffer[self.tag.get_name()]["timestamp"](timestamp)
+                            self.das.buffer[self.tag.get_name()]["values"](val)
+        
+        if self.value:
+            if value.value!=self.value.value:
+                if machine:
+                    if machine.sio:
+                        if name:
+                            payload = {machine.name.value: {name: value.value}}
+                            machine.sio.emit("on.machine.property", data=payload)
+                            machine.sio.emit("on.machine", data=machine.serialize())
+
+        if name=="machine_interval":
+            
+            return value, f"{name} To: {value.value} s."
+        
+        self.value = value
+        
+        return value, f"{name} To: {value.value}"
+
+
+class StringType(PropertyType):
+
+    """
+    Implement a Float Type
+    """
+
+    def __init__(self, default=None, unit=None):
+
+        super(StringType, self).__init__(STRING, default, unit)
+
+
+class FloatType(PropertyType):
+
+    """
+    Implement a Float Type
+    """
+
+    def __init__(self, default=None, unit=None):
+
+        super(FloatType, self).__init__(FLOAT, default, unit)
+
+
+class IntegerType(PropertyType):
+
+    """
+    Implement an Integer Typle
+    """
+
+    def __init__(self, default=None, unit=None):
+
+        super(IntegerType, self).__init__(INTEGER, default, unit)
+
+        
+class BooleanType(PropertyType):
+
+    """
+    Implement a Boolean Type
+    """
+
+    def __init__(self, default=None, unit=None):
+
+        super(BooleanType, self).__init__(BOOL, default, unit)
+
+
+class ProcessType(FloatType):
+
+    """
+    Implement a Process Type
+
+    Attributes
+
+    - read_only: [bool] only read from CVT, used to field data.
+    - tag: [Tag] Tag binded on CVT
+    """
+
+    def __init__(self, tag:Tag|None=None, default=None, read_only:bool=True, unit:str=None):
+        
+        self.tag = tag
+        self.read_only = read_only
+        
+        super(ProcessType, self).__init__(default=default, unit=unit)
+        
+    @logging_error_handler
+    def serialize(self):
+        r"""
+        Documentation here
+        """
+        tag = None
+        if self.tag:
+
+            tag = self.tag.serialize()
+
+        value = None
+        if self.value:
+            
+            if isinstance(self.value, (bool, float, int, str)):
+
+                value = self.value
+
+            elif isinstance(self.value, (BooleanType, FloatType, IntegerType, StringType)):
+
+                value = self.value.value
+
+        return {
+            "value": value,
+            "unit": self.unit,
+            "tag": tag,
+            "read_only": self.read_only
+        }
+

automation/modules/__init__.py

@@ -0,0 +1,14 @@
+from .users import Role, Roles, Users
+
+# Init Resources
+def init_app(app):
+
+    from ..modules.tags.resources import init_app as init_tags
+    from ..modules.alarms.resources import init_app as init_alarms
+    from ..modules.users.resources import init_app as init_users
+    from ..modules.events.resources import init_app as init_events
+
+    init_tags()
+    init_alarms()
+    init_users()
+    init_events()

automation/modules/alarms/resources/__init__.py

@@ -0,0 +1,10 @@
+from ....extensions.api import api
+
+
+def init_app():
+
+    from .alarms import ns as ns_alarms
+    from .summary import ns as ns_summary
+
+    api.add_namespace(ns_alarms, path="/alarms")
+    api.add_namespace(ns_summary, path="/alarms/summary")

automation/modules/alarms/resources/alarms.py

@@ -0,0 +1,280 @@
+from flask_restx import Namespace, Resource, fields, reqparse
+from .... import PyAutomation
+from automation.alarms import AlarmState
+from ....extensions.api import api
+from ....extensions import _api as Api
+
+
+ns = Namespace('Alarms', description='Alarms')
+app = PyAutomation()
+
+shelve_alarm_resource_by_name_model = api.model("shelve_alarm_resource_by_name_model",{
+    'seconds': fields.Integer(required=False, description='Shelve time'),
+    'minutes': fields.Integer(required=False, description='Shelve time'),
+    'hours': fields.Integer(required=False, description='Shelve time'),
+    'days': fields.Integer(required=False, description='Shelve time'),
+    'weeks': fields.Integer(required=False, description='Shelve time')
+})
+shelve_alarm_parser = reqparse.RequestParser()
+shelve_alarm_parser.add_argument("seconds", type=int, required=False, help='Shelve time', default=0)
+shelve_alarm_parser.add_argument("minutes", type=int, required=False, help='Shelve time', default=0)
+shelve_alarm_parser.add_argument("hours", type=int, required=False, help='Shelve time', default=0)
+shelve_alarm_parser.add_argument("days", type=int, required=False, help='Shelve time', default=0)
+shelve_alarm_parser.add_argument("weeks", type=int, required=False, help='Shelve time', default=0)
+
+append_alarm_resource_model = api.model("append_alarm_resource_model",{
+    'name': fields.String(required=True, description='Alarm Name'),
+    'tag': fields.String(required=True, description='Tag to whom the alarm will be subscribed'),
+    'description': fields.String(required=False, description='Alarm description'),
+    'type': fields.String(required=True, description='Alarm Type - Allowed ["HIGH-HIGH", "HIGH", "BOOL", "LOW", "LOW-LOW"]'),
+    'trigger_value': fields.Float(required=True, description="Alarm trigger value")
+})
+append_alarm_parser = reqparse.RequestParser()
+append_alarm_parser.add_argument('name', type=str, required=True, help='Alarm Name')
+append_alarm_parser.add_argument('tag', type=str, required=True, help='Tag to whom the alarm will be subscribed')
+append_alarm_parser.add_argument('description', type=str, required=False, help='Alarm description', default="")
+append_alarm_parser.add_argument('type', type=str, required=True, help='Alarm Type', choices=["HIGH-HIGH", "HIGH", "BOOL", "LOW", "LOW-LOW"])
+append_alarm_parser.add_argument('trigger_value', type=float, required=True, help="Alarm trigger value")
+
+
+@ns.route('/')
+class AlarmsCollection(Resource):
+
+    @api.doc(security='apikey')
+    @Api.token_required(auth=True)
+    def get(self):
+        """
+        Get Alarms
+        """
+        return app.alarm_manager.serialize(), 200
+    
+@ns.route('/active_alarms')
+class ActiveAlarmsCollection(Resource):
+
+    @api.doc(security='apikey')
+    @Api.token_required(auth=True)
+    def get(self):
+        """
+        Are there active alarms?
+        """
+        if app.alarm_manager.get_lasts_active_alarms(lasts=1):
+            
+            return True, 200
+        
+        return False, 200
+
+    
+@ns.route('/<id>')
+class AlarmResource(Resource):
+
+    @api.doc(security='apikey')
+    @Api.token_required(auth=True)
+    def get(self, id):
+        """
+        Gets alarm by alarm id
+        """
+        alarm = app.get_alarm(id)
+
+        if alarm:
+        
+            return alarm.serialize(), 200
+
+        return {'message': f"Alarm ID {id} is not exist"}, 400
+    
+
+@ns.route('/name/<alarm_name>')
+class AlarmByNameResource(Resource):
+
+    @api.doc(security='apikey')
+    @Api.token_required(auth=True)
+    def get(self, alarm_name):
+        """
+        Get alarm info
+        """
+        alarm = app.alarm_manager.get_alarm_by_name(alarm_name)
+
+        if alarm:
+
+            return alarm.serialize(), 200 
+        
+        return {'message': f"Alarm Name {alarm_name} is not exist"}, 400
+    
+    
+@ns.route('/acknowledge/<alarm_name>')
+class AckAlarmByNameResource(Resource):
+    
+    @api.doc(security='apikey')
+    @Api.token_required(auth=True)
+    def post(self, alarm_name:str):
+        """
+        Acknowledge alarm
+        """
+        result = dict()
+        alarm = app.alarm_manager.get_alarm_by_name(alarm_name)
+
+        if alarm:
+
+            if alarm.state in [AlarmState.UNACK, AlarmState.RTNUN]:
+                user = Api.get_current_user()
+                alarm.acknowledge(user=user)
+                result['message'] = f"{alarm.name} was acknowledged successfully"
+                result['data'] = alarm.serialize()
+
+                return result, 200
+
+            return {'message': f"Alarm Name {alarm_name} is not in Unacknowledged state"}, 400
+
+        return {'message': f"Alarm Name {alarm_name} is not exist"}, 400
+
+    
+@ns.route('/acknowledge_all')
+class AckAllAlarmsResource(Resource):
+
+    @api.doc(security='apikey')
+    @Api.token_required(auth=True)
+    def post(self):
+        """
+        Acknowledge all alarms triggered
+        """
+        alarms = app.alarm_manager.get_alarms()
+
+        for _, alarm in alarms.items():
+
+            if alarm.state in [AlarmState.UNACK, AlarmState.RTNUN]:
+                
+                user = Api.get_current_user()
+                alarm.acknowledge(user=user)
+        
+        result = {
+            'message': "Alarms were acknowledged successfully"
+        }
+        
+        return result, 200
+    
+
+@ns.route('/designed_suppression/<alarm_name>')
+class SuppressByDesignAlarmByNameResource(Resource):
+    
+    @api.doc(security='apikey')
+    @Api.token_required(auth=True)
+    def post(self, alarm_name:str):
+        """
+        Suppressed by design alarm
+        """
+        result = dict()
+        alarm = app.alarm_manager.get_alarm_by_name(alarm_name)
+
+        if alarm:
+            user = Api.get_current_user()
+            alarm.designed_suppression(user=user)
+            result['message'] = f"{alarm.name} was suppressed by design successfully"
+            result['data'] = alarm.serialize()
+
+            return result, 200
+
+        return {'message': f"Alarm Name {alarm_name} is not exist"}, 400
+
+
+@ns.route('/designed_unsuppression/<alarm_name>')
+class DesignedUnsuppressionAlarmByNameResource(Resource):
+    
+    @api.doc(security='apikey')
+    @Api.token_required(auth=True)
+    def post(self, alarm_name:str):
+        """
+        Unsuppress by design alarm
+        """
+        result = dict()
+        alarm = app.alarm_manager.get_alarm_by_name(alarm_name)
+
+        if alarm:
+
+            if alarm.state in [AlarmState.DSUPR]:
+                user = Api.get_current_user()
+                alarm.designed_unsuppression(user=user)
+                result['message'] = f"{alarm.name} was suppressed by design successfully"
+                result['data'] = alarm.serialize()
+
+                return result, 200
+
+            return {'message': f"You cannot unsuppress by design an alarm if not in suppress state"}, 400
+
+        return {'message': f"Alarm Name {alarm_name} is not exist"}, 400
+
+
+@ns.route('/remove_from_service/<alarm_name>')
+class OutOfServiceAlarmByNameResource(Resource):
+    
+    @api.doc(security='apikey')
+    @Api.token_required(auth=True)
+    def post(self, alarm_name:str):
+        """
+        Out Of Service alarm
+        """
+        result = dict()
+        alarm = app.alarm_manager.get_alarm_by_name(alarm_name)
+
+        if alarm:
+            user = Api.get_current_user()
+            alarm.remove_from_service(user=user)
+            result['message'] = f"{alarm.name} was pusshed in out of service successfully"
+            result['data'] = alarm.serialize()
+
+            return result, 200
+
+        return {'message': f"Alarm Name {alarm_name} is not exist"}, 400
+
+
+@ns.route('/shelve/<alarm_name>')
+class ShelveAlarmByNameResource(Resource):
+    
+    @api.doc(security='apikey')
+    @Api.token_required(auth=True)
+    @ns.expect(shelve_alarm_resource_by_name_model)
+    def post(self, alarm_name:str):
+        """
+        Shelve alarm
+        """
+        result = dict()
+        args = shelve_alarm_parser.parse_args()
+        alarm = app.alarm_manager.get_alarm_by_name(alarm_name)
+        if alarm:
+            user = Api.get_current_user()
+            alarm.shelve(
+                user=user,
+                **args
+            )
+            result['message'] = f"{alarm.name} was shelved successfully"
+            result['data'] = alarm.serialize()
+
+            return result, 200
+
+        return {'message': f"Alarm Name {alarm_name} is not exist"}, 400
+
+
+@ns.route('/return_to_service/<alarm_name>')
+class ReturnToServiceAlarmByNameResource(Resource):
+    
+    @api.doc(security='apikey')
+    @Api.token_required(auth=True)
+    def post(self, alarm_name:str):
+        """
+        Return to service alarm
+        """
+        result = dict()
+        alarm = app.alarm_manager.get_alarm_by_name(alarm_name)
+
+        if alarm:
+
+            if alarm.state in [AlarmState.OOSRV]:
+                user = Api.get_current_user()
+                alarm.return_to_service(user=user)
+                result['message'] = f"{alarm.name} was returned to service successfully"
+                result['data'] = alarm.serialize()
+
+                return result, 200
+
+            return {'message': f"You cannot returned to service an alarm if not in out of service state"}, 400
+
+        return {'message': f"Alarm Name {alarm_name} is not exist"}, 400
+

automation/modules/alarms/resources/summary.py

@@ -0,0 +1,79 @@
+import pytz
+from datetime import datetime, timedelta
+from flask_restx import Namespace, Resource, fields
+from .... import PyAutomation
+from ....extensions.api import api
+from ....extensions import _api as Api
+from ....dbmodels.alarms import AlarmSummary
+from .... import _TIMEZONE, TIMEZONE
+
+ns = Namespace('Alarms Summary', description='Alarms Summary')
+app = PyAutomation()
+
+alarms_summary_filter_model = api.model("alarms_summary_filter_model",{
+    'names': fields.List(fields.String(), required=False),
+    'states': fields.List(fields.String(), required=False),
+    'tags': fields.List(fields.String(), required=False),
+    'greater_than_timestamp': fields.DateTime(required=False, default=datetime.now(pytz.utc).astimezone(TIMEZONE) - timedelta(minutes=30), description=f'Greater than timestamp - DateTime Format: {app.cvt.DATETIME_FORMAT}'),
+    'less_than_timestamp': fields.DateTime(required=False, default=datetime.now(pytz.utc).astimezone(TIMEZONE), description=f'Less than timestamp - DateTime Format: {app.cvt.DATETIME_FORMAT}'),
+    'timezone': fields.String(required=False, default=_TIMEZONE)
+})
+
+    
+@ns.route('/filter_by')
+class AlarmsSummarygFilterByResource(Resource):
+
+    @api.doc(security='apikey')
+    @Api.token_required(auth=True)
+    @ns.expect(alarms_summary_filter_model)
+    def post(self):
+        r"""
+        Alarms Summary Filter By
+        """
+        timezone = _TIMEZONE
+        if "timezone" in api.payload:
+
+            timezone = api.payload["timezone"]
+
+        if timezone not in pytz.all_timezones:
+
+            return f"Invalid Timezone", 400
+
+        separator = '.'
+        if 'greater_than_timestamp' in api.payload:
+            
+            greater_than_timestamp = api.payload['greater_than_timestamp']
+            api.payload['greater_than_timestamp'] = greater_than_timestamp.replace("T", " ").split(separator, 1)[0] + '.00'
+        
+        if "less_than_timestamp" in api.payload:
+
+            less_than_timestamp = api.payload['less_than_timestamp']
+            api.payload['less_than_timestamp'] = less_than_timestamp.replace("T", " ").split(separator, 1)[0] + '.00'
+                
+        return app.filter_alarms_by(**api.payload)
+    
+
+@ns.route('/lasts/<lasts>')
+class LastsAlarmsResource(Resource):
+
+    @api.doc(security='apikey')
+    @Api.token_required(auth=True)
+    def get(self, lasts:int=10):
+        r"""
+        Get lasts alarms
+        """
+
+        return app.get_lasts_alarms(lasts=int(lasts))
+    
+
+@ns.route('/<id>/comments')
+class AlarmsSummaryCommentsResource(Resource):
+
+    @api.doc(security='apikey')
+    @Api.token_required(auth=True)
+    def get(self, id:int):
+        r"""
+        Get Alarm Summary Comments
+        """
+        comments = AlarmSummary.get_alarm_summary_comments(id=id)
+        return comments, 200

automation/modules/events/resources/__init__.py

@@ -0,0 +1,10 @@
+from ....extensions.api import api
+
+
+def init_app():
+
+    from .events import ns as ns_events
+    from .logs import ns as ns_logs
+
+    api.add_namespace(ns_events, path="/events")
+    api.add_namespace(ns_logs, path="/logs")

automation/modules/events/resources/events.py

@@ -0,0 +1,83 @@
+import pytz
+from datetime import datetime, timedelta
+from flask_restx import Namespace, Resource, fields
+from .... import PyAutomation
+from ....extensions.api import api
+from ....extensions import _api as Api
+from ....dbmodels.events import Events
+from .... import _TIMEZONE, TIMEZONE
+
+ns = Namespace('Events Logger', description='Events Logger')
+app = PyAutomation()
+
+
+events_filter_model = api.model("events_filter_model",{
+    'usernames': fields.List(fields.String(), required=False),
+    'priorities': fields.List(fields.Integer(), required=False),
+    'criticities': fields.List(fields.Integer(), required=False),
+    'message': fields.String(required=False),
+    'classification': fields.String(required=False),
+    'description': fields.String(required=False),
+    'greater_than_timestamp': fields.DateTime(required=False, default=datetime.now(pytz.utc).astimezone(TIMEZONE) - timedelta(minutes=30), description=f'Greater than timestamp - DateTime Format: {app.cvt.DATETIME_FORMAT}'),
+    'less_than_timestamp': fields.DateTime(required=False, default=datetime.now(pytz.utc).astimezone(TIMEZONE), description=f'Less than timestamp - DateTime Format: {app.cvt.DATETIME_FORMAT}'),
+    'timezone': fields.String(required=False, default=_TIMEZONE)
+})
+
+    
+@ns.route('/filter_by')
+class EventsSummaryFilterByResource(Resource):
+
+    @api.doc(security='apikey')
+    @Api.token_required(auth=True)
+    @ns.expect(events_filter_model)
+    def post(self):
+        r"""
+        Events Summary Filter By
+        """
+        timezone = _TIMEZONE
+        if "timezone" in api.payload:
+
+            timezone = api.payload["timezone"]
+
+        if timezone not in pytz.all_timezones:
+
+            return f"Invalid Timezone", 400
+        
+        separator = '.'
+        if 'greater_than_timestamp' in api.payload:
+            
+            greater_than_timestamp = api.payload['greater_than_timestamp']
+            api.payload['greater_than_timestamp'] = greater_than_timestamp.replace("T", " ").split(separator, 1)[0] + '.00'
+        
+        if "less_than_timestamp" in api.payload:
+
+            less_than_timestamp = api.payload['less_than_timestamp']
+            api.payload['less_than_timestamp'] = less_than_timestamp.replace("T", " ").split(separator, 1)[0] + '.00'
+        
+        return app.filter_events_by(**api.payload)
+    
+
+@ns.route('/lasts/<lasts>')
+class LastsEventsResource(Resource):
+
+    @api.doc(security='apikey')
+    @Api.token_required(auth=True)
+    def get(self, lasts:int=10):
+        r"""
+        Get lasts events
+        """
+        
+        return app.get_lasts_events(lasts=int(lasts))
+    
+
+@ns.route('/<id>/comments')
+class EventsCommentsResource(Resource):
+
+    @api.doc(security='apikey')
+    @Api.token_required(auth=True)
+    def get(self, id:int):
+        r"""
+        Get Alarm Summary Comments
+        """
+        comments = Events.get_comments(id=id)
+        return comments, 200