PyAutomationIO 0.0.0__py3-none-any.whl

automation/logger/events.py

@@ -0,0 +1,194 @@
+# -*- coding: utf-8 -*-
+"""pyhades/logger/events.py
+"""
+from datetime import datetime
+from ..dbmodels.events import Events
+from ..modules.users.users import User
+from .core import BaseEngine, BaseLogger
+
+
+class EventsLogger(BaseLogger):
+
+    def __init__(self):
+
+        super(EventsLogger, self).__init__()
+
+    def create(
+        self, 
+        message:str, 
+        user:User, 
+        description:str=None, 
+        classification:str=None,
+        priority:int=None,
+        criticity:int=None,
+        timestamp:datetime=None
+        ):
+        r"""
+        Documentation here
+        """
+        if not self.is_history_logged:
+
+            return None
+        
+        if not self.check_connectivity():
+            
+            return None
+            
+        return Events.create(
+            message=message, 
+            user=user, 
+            description=description, 
+            classification=classification,
+            priority=priority,
+            criticity=criticity,
+            timestamp=timestamp
+        )
+
+    def get_lasts(self, lasts:int=1):
+        r"""
+        Documentation here
+        """
+        if not self.is_history_logged:
+
+            return list()
+        
+        if not self.check_connectivity():
+            
+            return list()
+        
+        return Events.read_lasts(lasts=lasts)
+    
+    def filter_by(
+        self,
+        usernames:list[str]=None,
+        priorities:list[int]=None,
+        criticities:list[int]=None,
+        message:str="",
+        description:str="",
+        classification:str="",
+        greater_than_timestamp:datetime=None,
+        less_than_timestamp:datetime=None,
+        timezone:str="UTC"
+        ):
+        r"""
+        Documentation here
+        """
+        if not self.is_history_logged:
+
+            return None
+        
+        if not self.check_connectivity():
+            
+            return list()
+        
+        return Events.filter_by(
+            usernames=usernames,
+            priorities=priorities,
+            criticities=criticities,
+            message=message,
+            classification=classification,
+            description=description,
+            greater_than_timestamp=greater_than_timestamp,
+            less_than_timestamp=less_than_timestamp,
+            timezone=timezone
+            )
+
+    def get_summary(self)->tuple[list, str]:
+        r"""
+        Documentation here
+        """
+        if not self.is_history_logged:
+
+            return None
+        
+        if not self.check_connectivity():
+            
+            return list()
+            
+        return Events.serialize()
+    
+class EventsLoggerEngine(BaseEngine):
+    r"""
+    Data logger Engine class for Tag thread-safe database logging.
+
+    """
+
+    def __init__(self):
+
+        super(EventsLoggerEngine, self).__init__()
+        self.logger = EventsLogger()
+
+    def create(
+        self,
+        message:str, 
+        user:User, 
+        description:str=None, 
+        classification:str=None,
+        priority:int=None,
+        criticity:int=None,
+        timestamp:datetime=None
+        ):
+
+        _query = dict()
+        _query["action"] = "create"
+        _query["parameters"] = dict()
+        _query["parameters"]["message"] = message
+        _query["parameters"]["user"] = user
+        _query["parameters"]["description"] = description
+        _query["parameters"]["classification"] = classification
+        _query["parameters"]["priority"] = priority
+        _query["parameters"]["criticity"] = criticity
+        _query["parameters"]["timestamp"] = timestamp
+        
+        return self.query(_query)
+    
+    def get_lasts(
+        self,
+        lasts:int=1
+        ):
+
+        _query = dict()
+        _query["action"] = "get_lasts"
+        _query["parameters"] = dict()
+        _query["parameters"]["lasts"] = lasts
+        
+        return self.query(_query)
+    
+    def filter_by(
+        self,
+        usernames:list[str]=None,
+        priorities:list[int]=None,
+        criticities:list[int]=None,
+        message:str="",
+        classification:str="",
+        description:str="",
+        greater_than_timestamp:datetime=None,
+        less_than_timestamp:datetime=None,
+        timezone:str='UTC'
+        ):
+
+        _query = dict()
+        _query["action"] = "filter_by"
+        _query["parameters"] = dict()
+        _query["parameters"]["usernames"] = usernames
+        _query["parameters"]["priorities"] = priorities
+        _query["parameters"]["criticities"] = criticities
+        _query["parameters"]["message"] = message
+        _query["parameters"]["classification"] = classification
+        _query["parameters"]["description"] = description
+        _query["parameters"]["greater_than_timestamp"] = greater_than_timestamp
+        _query["parameters"]["less_than_timestamp"] = less_than_timestamp
+        _query["parameters"]["timezone"] = timezone
+        
+        return self.query(_query)
+
+    def get_summary(self):
+        r"""
+        Documentation here
+        """
+        _query = dict()
+        _query["action"] = "get_summary"
+        _query["parameters"] = dict()
+        
+        return self.query(_query)
+    

automation/logger/logdict.py

@@ -0,0 +1,53 @@
+# -*- coding: utf-8 -*-
+"""pyhades/logger/logdict.py
+
+This module implements a dictionary based Class to hold
+the tags to be logged.
+"""
+
+
+class LogTable(dict):
+
+    def __init__(self):
+
+        pass
+
+    def validate(self, period, tag):
+        
+        if not type(period) in [int, float]:
+            return False
+        
+        if type(tag) != str:
+            return False
+
+        return True
+
+    def get_groups(self):
+
+        return list(self.keys())
+
+    def get_tags(self, group):
+
+        return self[group]
+
+    def get_all_tags(self):
+
+        result = list()
+
+        for group in self.get_groups():
+
+            result += self.get_tags(group)
+
+        return result
+
+    def get_period(self, tag):
+
+        for key, value in self.items():
+
+            if tag in value:
+                return key
+
+    def serialize(self):
+
+        return self
+    

automation/logger/logs.py

@@ -0,0 +1,203 @@
+# -*- coding: utf-8 -*-
+"""pyhades/logger/events.py
+"""
+from datetime import datetime
+from ..dbmodels.logs import Logs
+from ..modules.users.users import User
+from .core import BaseEngine, BaseLogger
+from ..utils.decorators import db_rollback
+
+
+class LogsLogger(BaseLogger):
+
+    def __init__(self):
+
+        super(LogsLogger, self).__init__()
+
+    @db_rollback
+    def create(
+        self, 
+        message:str, 
+        user:User, 
+        description:str=None, 
+        classification:str=None,
+        alarm_summary_id:int=None,
+        event_id:int=None,
+        timestamp:datetime=None
+        ):
+        r"""
+        Documentation here
+        """
+        if not self.is_history_logged:
+
+            return None
+        
+        if not self.check_connectivity():
+
+            return list()
+            
+        query, message = Logs.create(
+            message=message, 
+            user=user, 
+            description=description, 
+            classification=classification,
+            alarm_summary_id=alarm_summary_id,
+            event_id=event_id,
+            timestamp=timestamp
+        )
+
+        return query, message
+
+    @db_rollback
+    def get_lasts(self, lasts:int=1):
+        r"""
+        Documentation here
+        """
+        if not self.is_history_logged:
+
+            return None
+        
+        if not self.check_connectivity():
+
+            return list()
+        
+        return Logs.read_lasts(lasts=lasts)
+        
+    
+    @db_rollback
+    def filter_by(
+        self,
+        usernames:list[str]=None,
+        alarm_names:list[str]=None,
+        event_ids:list[int]=None,
+        classification:str="",
+        message:str="",
+        description:str="",
+        greater_than_timestamp:datetime=None,
+        less_than_timestamp:datetime=None,
+        timezone:str='UTC'
+        ):
+        r"""
+        Documentation here
+        """
+        if not self.is_history_logged:
+
+            return None
+        
+        if not self.check_connectivity():
+
+            return list()
+        
+        return Logs.filter_by(
+            usernames=usernames,
+            alarm_names=alarm_names,
+            event_ids=event_ids,
+            message=message,
+            description=description,
+            classification=classification,
+            greater_than_timestamp=greater_than_timestamp,
+            less_than_timestamp=less_than_timestamp,
+            timezone=timezone
+        )
+
+    @db_rollback  
+    def get_summary(self)->tuple[list, str]:
+        r"""
+        Documentation here
+        """
+        if not self.is_history_logged:
+
+            return None
+        
+        if not self.check_connectivity():
+            
+            return list()
+            
+        return Logs.serialize()
+    
+    
+class LogsLoggerEngine(BaseEngine):
+    r"""
+    Operation Logs logger Engine class for Tag thread-safe database logging.
+
+    """
+
+    def __init__(self):
+
+        super(LogsLoggerEngine, self).__init__()
+        self.logger = LogsLogger()
+
+    def create(
+        self,
+        message:str, 
+        user:User, 
+        description:str=None, 
+        classification:str=None,
+        alarm_summary_id:int=None,
+        event_id:int=None,
+        timestamp:datetime=None
+        ):
+
+        _query = dict()
+        _query["action"] = "create"
+        _query["parameters"] = dict()
+        _query["parameters"]["message"] = message
+        _query["parameters"]["user"] = user
+        _query["parameters"]["description"] = description
+        _query["parameters"]["classification"] = classification
+        _query["parameters"]["alarm_summary_id"] = alarm_summary_id
+        _query["parameters"]["event_id"] = event_id
+        _query["parameters"]["timestamp"] = timestamp
+        
+        return self.query(_query)
+    
+    def get_lasts(
+        self,
+        lasts:int=1
+        ):
+
+        _query = dict()
+        _query["action"] = "get_lasts"
+        _query["parameters"] = dict()
+        _query["parameters"]["lasts"] = lasts
+        
+        return self.query(_query)
+    
+    def filter_by(
+        self,
+        usernames:list[str]=None,
+        alarm_names:list[str]=None,
+        event_ids:list[int]=None,
+        classification:str="",
+        message:str="",
+        description:str="",
+        greater_than_timestamp:datetime=None,
+        less_than_timestamp:datetime=None,
+        timezone:str='UTC'
+        ):
+
+        _query = dict()
+        _query["action"] = "filter_by"
+        _query["parameters"] = dict()
+        _query["parameters"]["usernames"] = usernames
+        _query["parameters"]["alarm_names"] = alarm_names
+        _query["parameters"]["event_ids"] = event_ids
+        _query["parameters"]["classification"] = classification
+        _query["parameters"]["message"] = message
+        _query["parameters"]["description"] = description
+        _query["parameters"]["greater_than_timestamp"] = greater_than_timestamp
+        _query["parameters"]["less_than_timestamp"] = less_than_timestamp
+        _query["parameters"]["timezone"] = timezone
+        
+        return self.query(_query)
+
+    def get_summary(self):
+        r"""
+        Documentation here
+        """
+        _query = dict()
+        _query["action"] = "get_summary"
+        _query["parameters"] = dict()
+        
+        return self.query(_query)
+    

automation/logger/machines.py

@@ -0,0 +1,248 @@
+# -*- coding: utf-8 -*-
+"""pyhades/logger/machines.py
+"""
+from ..dbmodels import Machines, TagsMachines, Tags
+from .core import BaseEngine, BaseLogger
+from ..utils.decorators import db_rollback
+from ..models import IntegerType, StringType, FloatType
+from ..tags.tag import Tag
+
+
+class MachinesLogger(BaseLogger):
+
+    def __init__(self):
+
+        super(MachinesLogger, self).__init__()
+
+    @db_rollback
+    def create(
+            self,
+            identifier:str,
+            name:str,
+            interval:int,
+            description:str,
+            classification:str,
+            buffer_size:int,
+            buffer_roll_type:str,
+            criticity:int,
+            priority:int,
+            on_delay:int=None,
+            threshold:float=None
+            ):
+        r"""
+        Documentation here
+        """
+        if not self.check_connectivity():
+
+            return None
+        
+        if hasattr(threshold, "value"):
+            
+            threshold = threshold.value
+       
+        Machines.create(
+            identifier=identifier,
+            name=name,
+            interval=interval,
+            description=description,
+            classification=classification,
+            buffer_size=buffer_size,
+            buffer_roll_type=buffer_roll_type,
+            criticity=criticity,
+            priority=priority,
+            on_delay=on_delay,
+            threshold=threshold
+        )
+
+    @db_rollback
+    def put(
+        self,
+        name:StringType,
+        machine_interval:IntegerType=None,
+        description:StringType=None,
+        classification:StringType=None,
+        buffer_size:IntegerType=None,
+        buffer_roll_type:StringType=None,
+        criticity:IntegerType=None,
+        priority:IntegerType=None,
+        on_delay:IntegerType=None,
+        threshold:FloatType=None
+        ):
+
+        if not self.check_connectivity():
+            
+            return None
+
+        fields = dict()
+        machine = Machines.read_by_name(name=name.value)
+        if machine_interval:
+            
+            fields["interval"] = machine_interval.value
+        if description:
+            fields["description"] = description.value
+        if classification:
+            fields["classification"] = classification.value
+        if buffer_size:
+            fields["buffer_size"] = buffer_size.value
+        if buffer_roll_type:
+            fields["buffer_roll_type"] = buffer_roll_type.value
+        if criticity:
+            fields["criticity"] = criticity.value
+        if priority:
+            fields["priority"] = priority.value
+        if on_delay:
+            fields["on_delay"] = on_delay.value
+        if threshold:
+            if hasattr(threshold.value, "value"):
+                threshold.value = threshold.value.value
+            fields["threshold"] = threshold.value
+            
+        query = Machines.put(
+            id=machine.id,
+            **fields
+        )
+
+        return query
+    
+    @db_rollback
+    def read_all(self):
+        if not self.check_connectivity():
+
+            return list()
+        
+        return Machines.read_all()
+    
+    @db_rollback
+    def read_config(self):
+        if not self.check_connectivity():
+            
+            return None
+
+        return Machines.read_config()
+    
+    @db_rollback
+    def bind_tag(self, tag:Tag, machine, default_tag_name:str=None):
+        if not self.check_connectivity():
+
+            return None
+            
+        TagsMachines.create(tag_name=tag.name, machine_name=machine.name.value, default_tag_name=default_tag_name)
+
+    @db_rollback
+    def unbind_tag(self, tag:Tag, machine):
+        if not self.check_connectivity():
+
+            return None
+
+        tag_from_db = Tags.get_or_none(name=tag.name)
+        machine_from_db= Machines.get_or_none(name=machine.name.value)
+        tags_machine = TagsMachines.get((TagsMachines.tag == tag_from_db) & (TagsMachines.machine == machine_from_db))
+        tags_machine.delete_instance()    
+
+class MachinesLoggerEngine(BaseEngine):
+    r"""
+    Alarms logger Engine class for Tag thread-safe database logging.
+
+    """
+
+    def __init__(self):
+
+        super(MachinesLoggerEngine, self).__init__()
+        self.logger = MachinesLogger()
+
+    def create(
+        self,
+        identifier:str,
+        name:str,
+        interval:int,
+        description:str,
+        classification:str,
+        buffer_size:int,
+        buffer_roll_type:str,
+        criticity:int,
+        priority:int,
+        on_delay:int=None,
+        threshold:float=None
+        ):
+
+        _query = dict()
+        _query["action"] = "create"
+        _query["parameters"] = dict()
+        _query["parameters"]["identifier"] = identifier
+        _query["parameters"]["name"] = name
+        _query["parameters"]["interval"] = interval
+        _query["parameters"]["classification"] = classification
+        _query["parameters"]["description"] = description
+        _query["parameters"]["buffer_size"] = buffer_size
+        _query["parameters"]["buffer_roll_type"] = buffer_roll_type
+        _query["parameters"]["criticity"] = criticity
+        _query["parameters"]["priority"] = priority
+        _query["parameters"]["on_delay"] = on_delay
+        _query["parameters"]["threshold"] = threshold
+        
+        return self.query(_query)
+    
+    def put(
+        self,
+        name:StringType,
+        machine_interval:IntegerType=None,
+        description:StringType=None,
+        classification:StringType=None,
+        buffer_size:IntegerType=None,
+        buffer_roll_type:StringType=None,
+        criticity:IntegerType=None,
+        priority:IntegerType=None,
+        on_delay:IntegerType=None,
+        threshold:FloatType=None
+        ):
+
+        _query = dict()
+        _query["action"] = "put"
+        _query["parameters"] = dict()
+        _query["parameters"]["name"] = name
+        _query["parameters"]["machine_interval"] = machine_interval
+        _query["parameters"]["classification"] = classification
+        _query["parameters"]["description"] = description
+        _query["parameters"]["buffer_size"] = buffer_size
+        _query["parameters"]["buffer_roll_type"] = buffer_roll_type
+        _query["parameters"]["criticity"] = criticity
+        _query["parameters"]["priority"] = priority
+        _query["parameters"]["on_delay"] = on_delay
+        _query["parameters"]["threshold"] = threshold
+
+        return self.query(_query)
+
+    def read_all(self):
+
+        _query = dict()
+        _query["action"] = "read_all"
+        _query["parameters"] = dict()
+        return self.query(_query)
+    
+    def read_config(self):
+
+        _query = dict()
+        _query["action"] = "read_config"
+        _query["parameters"] = dict()
+        return self.query(_query)
+    
+    def bind_tag(self, tag:Tag, machine, default_tag_name:str=None):
+
+        _query = dict()
+        _query["action"] = "bind_tag"
+        _query["parameters"] = dict()
+        _query["parameters"]["tag"] = tag
+        _query["parameters"]["machine"] = machine
+        _query["parameters"]["default_tag_name"] = default_tag_name
+        return self.query(_query)
+    
+    def unbind_tag(self, tag:Tag, machine):
+
+        _query = dict()
+        _query["action"] = "unbind_tag"
+        _query["parameters"] = dict()
+        _query["parameters"]["tag"] = tag
+        _query["parameters"]["machine"] = machine
+        return self.query(_query)
+    
+