PyAutomationIO 0.0.0__py3-none-any.whl

automation/alarms/states.py

@@ -0,0 +1,192 @@
+from enum import Enum
+
+
+ACTIONS = {
+    "Normal": ['shelve', 'suppress by design', 'out of service', 'disable'],
+    "Unacknowledged": ['acknowledge', 'shelve', 'suppress by design', 'out of service', 'silence', 'disable'],
+    "Acknowledged": ['shelve', 'suppress by design', 'out of service', 'disable'],
+    "RTN Unacknowledged": ['shelve', 'suppress by design', 'out of service', 'disable'],
+    "Shelved": ["reset"],
+    "Suppressed By Design": ["unsuppress by design"],
+    "Out Of Service": ["return to service"]
+}
+
+
+class States(Enum):
+
+    NORM = "Normal"
+    UNACK = "Unacknowledged"
+    ACKED = "Acknowledged"
+    RTNUN = "RTN Unacknowledged"
+    SHLVD = "Shelved"
+    DSUPR = "Suppressed By Design"
+    OOSRV = "Out Of Service"
+
+
+class Status(Enum):
+
+    ACTV = "Active"
+    NACTV = "Not Active"
+    ANNCTD = "Annunciated"
+    NANNCTD = "Not Annunciated"
+    OR = "Not Active or Active"
+    SUPR = "Suppressed"
+    NA = "Not Applicable"
+    NORM = "Normal"
+    ABNORM = "Abnormal"
+
+
+class AlarmAttrs:
+
+    def __init__(
+        self, 
+        mnemonic: str, 
+        state: str, 
+        process_condition: str,
+        alarm_status: str, 
+        annunciate_status: str, 
+        acknowledge_status: str,
+    ):
+        self.__mnemonic = mnemonic
+        self.__state = state
+        self.__process_condition = process_condition
+        self.__alarm_status = alarm_status
+        self.__annunciate_status = annunciate_status
+        self.__acknowledge_status = acknowledge_status
+
+    @property
+    def mnemonic(self):
+        r"""
+        Documentation here
+        """
+        return self.__mnemonic
+
+    @property
+    def state(self):
+        r"""
+        Documentation here
+        """
+        return self.__state
+    
+    @property
+    def process_condition(self):
+        r"""
+        Documentation here
+        """
+        return self.__process_condition
+
+    @property
+    def alarm_status(self):
+        r"""
+        Documentation here
+        """
+        return self.__alarm_status
+
+    @property
+    def annunciate_status(self):
+        r"""
+        Documentation here
+        """
+        return self.__annunciate_status
+
+    @property
+    def acknowledge_status(self):
+        r"""
+        Documentation here
+        """
+        return self.__acknowledge_status
+
+    def is_acknowledged(self):
+        r"""
+        Documentation here
+        """
+
+        return self.acknowledge_status == States.ACKED.value
+
+    def serialize(self):
+        r"""
+        Documentation here
+        """
+        return {
+            'mnemonic': self.mnemonic,
+            'state': self.state,
+            'process_condition': self.process_condition,
+            'alarm_status': self.alarm_status,
+            'annunciate_status': self.annunciate_status,
+            'acknowledge_status': self.acknowledge_status
+        }
+
+
+class AlarmState:
+
+    NORM = AlarmAttrs(
+        mnemonic=States.NORM.name,
+        state=States.NORM.value,
+        process_condition=Status.NORM.value,
+        alarm_status=Status.NACTV.value,
+        annunciate_status=Status.NANNCTD.value,
+        acknowledge_status=States.ACKED.value
+    )
+    UNACK = AlarmAttrs(
+        mnemonic=States.UNACK.name,
+        state=States.UNACK.value,
+        process_condition=Status.ABNORM.value,
+        alarm_status=Status.ACTV.value,
+        annunciate_status=Status.ANNCTD.value,
+        acknowledge_status=States.UNACK.value
+    )
+    ACKED = AlarmAttrs(
+        mnemonic=States.ACKED.name,
+        state=States.ACKED.value,
+        process_condition=Status.ABNORM.value,
+        alarm_status=Status.ACTV.value,
+        annunciate_status=Status.ANNCTD.value,
+        acknowledge_status=States.ACKED.value
+    )
+    RTNUN = AlarmAttrs(
+        mnemonic=States.RTNUN.name,
+        state=States.RTNUN.value,
+        process_condition=Status.NORM.value,
+        alarm_status=Status.NACTV.value,
+        annunciate_status=Status.ANNCTD.value,
+        acknowledge_status=States.UNACK.value
+    )
+    SHLVD = AlarmAttrs(
+        mnemonic=States.SHLVD.name,
+        state=States.SHLVD.value,
+        process_condition=Status.NORM.value,
+        alarm_status=Status.OR.value,
+        annunciate_status=Status.SUPR.value,
+        acknowledge_status=Status.NA.value
+    )
+    DSUPR = AlarmAttrs(
+        mnemonic=States.DSUPR.name,
+        state=States.DSUPR.value,
+        process_condition=Status.NORM.value,
+        alarm_status=Status.OR.value,
+        annunciate_status=Status.SUPR.value,
+        acknowledge_status=Status.NA.value
+    )
+    OOSRV = AlarmAttrs(
+        mnemonic=States.OOSRV.name,
+        state=States.OOSRV.value,
+        process_condition=Status.NORM.value,
+        alarm_status=Status.OR.value,
+        annunciate_status=Status.SUPR.value,
+        acknowledge_status=Status.NA.value
+    )
+
+    _states = [NORM, UNACK, ACKED, RTNUN, SHLVD, DSUPR, OOSRV]
+
+    @classmethod
+    def get_state_by_name(cls, state:str):
+        r"""
+        Documentation here
+        """
+        _state = States(state)
+        for alarm_state in cls._states:
+
+            if _state==alarm_state:
+
+                return alarm_state
+

automation/alarms/trigger.py

@@ -0,0 +1,64 @@
+from enum import Enum
+
+class TriggerType(Enum):
+
+    HH = "HIGH-HIGH"
+    H = "HIGH"
+    L = "LOW"
+    LL = "LOW-LOW"
+    B = "BOOL"
+    NONE = "NOT DEFINED"
+
+
+class Trigger:
+
+    def __init__(self):
+
+        self.__type = TriggerType.NONE
+        self.__value = None
+
+    @property
+    def type(self):
+        r"""
+        Documentation here
+        """
+
+        return self.__type
+
+    @type.setter
+    def type(self, _type:str):
+
+        self.__type = TriggerType(_type)
+
+    @property
+    def value(self):
+        r"""
+        Documentation here
+        """
+        return self.__value
+
+    @value.setter
+    def value(self, value):
+
+        if self.type==TriggerType.B:
+
+            if isinstance(value, bool):
+
+                self.__value = value
+
+            else:
+
+                self.__value = bool(value)
+
+        else:
+
+            if isinstance(value, (float, int)):
+
+                self.__value = value
+
+    def serialize(self):
+
+        return {
+            "type": self.type.value,
+            "value": self.value
+        }

automation/buffer.py

@@ -0,0 +1,132 @@
+class Buffer(list):
+    r"""
+    Documentation here
+    """
+
+    def __init__(self, size:int=10, roll:str='forward'):
+        r"""
+        Documentation here
+        """
+        self._roll_type_allowed = ['forward', 'backward']
+        self._size = size
+        self.roll = roll
+
+    @property
+    def size(self):
+        r"""
+        Documentation here
+        """
+        return self._size
+
+    @size.setter
+    def size(self, value:int):
+        r"""
+        Documentation here
+        """
+        if not isinstance(value, int):
+
+            raise TypeError("Only integers are allowed")
+
+        if value <= 1:
+
+            raise ValueError(f"{value} must be greater than one (1)")
+        
+
+        self.__init__(value, roll=self.roll)
+
+    def last(self):
+        r"""
+        Returns last registered value of the buffer
+        """
+        if self:
+            if self.roll == 'forward':
+
+                return self[-1]
+            
+            return self[0]
+    
+    def current(self):
+        r"""
+        Returns lastest registered value of the buffer
+        """  
+        if self:
+            if self.roll == 'forward':
+                
+                return self[0]
+            
+            return self[-1]
+        
+    def previous_current(self):
+        r"""
+        Returns lastest registered value of the buffer
+        """
+        if self:
+            if self.roll == 'forward':
+                
+                return self[1]
+            
+            return self[-2]
+
+    @property
+    def roll(self):
+        r"""
+        Documentation here
+        """
+        return self.roll_type
+
+    @roll.setter
+    def roll(self, value:str):
+        r"""
+        Documentation here
+        """
+        if not isinstance(value, str):
+
+            raise TypeError("Only strings are allowed")
+
+        if value not in self._roll_type_allowed:
+            
+            raise ValueError(f"{value} is not allowed, you can only use: {self._roll_type_allowed}")
+
+        self.roll_type = value
+
+    def __call__(self, value):
+        r"""
+        Documentation here
+        """
+        if self.roll.lower()=='forward':
+            
+            _len = len(self)
+            
+            if _len >= self.size:
+                
+                if _len == self.size:
+                    
+                    self.pop()
+                
+                else:
+
+                    for _ in range(_len - self.size):
+
+                        self.pop()
+
+            super(Buffer, self).insert(0, value)
+
+        else:
+
+            _len = len(self)
+            
+            if _len >= self.size:
+                
+                if _len == self.size:
+                    
+                    self.pop(0)
+                
+                else:
+
+                    for _ in range(_len - self.size):
+
+                        self.pop(0)
+                
+            super(Buffer, self).append(value)
+
+        return self