PyAutomationIO 1.0.3__tar.gz → 1.1.1__tar.gz

{pyautomationio-1.0.3 → pyautomationio-1.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyAutomationIO
-Version: 1.0.3
+Version: 1.1.1
 Summary: A python library to develop automation continuous tasks using sync or async concurrent threads
 Home-page: https://github.com/know-ai/PyAutomation
 Author: KnowAI

{pyautomationio-1.0.3 → pyautomationio-1.1.1}/PyAutomationIO.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyAutomationIO
-Version: 1.0.3
+Version: 1.1.1
 Summary: A python library to develop automation continuous tasks using sync or async concurrent threads
 Home-page: https://github.com/know-ai/PyAutomation
 Author: KnowAI

{pyautomationio-1.0.3 → pyautomationio-1.1.1}/automation/core.py

@@ -373,6 +373,13 @@ class PyAutomation(Singleton):
         """
         return self.logger_engine.read_table(start, stop, timezone, tags, page, limit)
     
+    @logging_error_handler
+    def get_tabular_data(self, start:str, stop:str, timezone:str, tags:list, sample_time:int, page:int=1, limit:int=20):
+        r"""
+        Documentation here
+        """
+        return self.logger_engine.read_tabular_data(start, stop, timezone, tags, sample_time, page, limit)
+    
     @logging_error_handler
     def get_segments(self):
         r"""
@@ -1363,6 +1370,10 @@ class PyAutomation(Singleton):
         Documentation here
         """
         if self.is_db_connected():
+            
+            # Ensure pagination parameters are present or defaulted
+            if 'page' not in fields: fields['page'] = 1
+            if 'limit' not in fields: fields['limit'] = 20
 
             return self.alarms_engine.filter_alarm_summary_by(**fields)
 
@@ -1535,7 +1546,9 @@ class PyAutomation(Singleton):
             description:str="",
             greater_than_timestamp:datetime=None,
             less_than_timestamp:datetime=None,
-            timezone:str="UTC")->list:
+            timezone:str="UTC",
+            page:int=1,
+            limit:int=20)->list:
         r"""
         Documentation here
         """
@@ -1550,7 +1563,9 @@ class PyAutomation(Singleton):
                 classification=classification,
                 greater_than_timestamp=greater_than_timestamp,
                 less_than_timestamp=less_than_timestamp,
-                timezone=timezone
+                timezone=timezone,
+                page=page,
+                limit=limit
             )
         
         return list()

{pyautomationio-1.0.3 → pyautomationio-1.1.1}/automation/dbmodels/alarms.py

@@ -448,11 +448,14 @@ class AlarmSummary(BaseModel):
         tags:list[str]=None,
         greater_than_timestamp:datetime=None,
         less_than_timestamp:datetime=None,
-        timezone:str='UTC'
+        timezone:str='UTC',
+        page:int=1,
+        limit:int=20
         ):
         r"""
         Documentation here
         """
+        import math
         _timezone = pytz.timezone(timezone)
         query = cls.select()
         
@@ -478,11 +481,33 @@ class AlarmSummary(BaseModel):
             query = query.where(cls.alarm_time < less_than_timestamp)
         
         query = query.order_by(cls.id.desc())
-        if not query.exists():
-            
-            return []
         
-        return [alarm.serialize() for alarm in query]
+        total_records = query.count()
+        
+        if limit <= 0: limit = 20
+        if page <= 0: page = 1
+        
+        total_pages = math.ceil(total_records / limit)
+        if total_pages == 0: total_pages = 1
+        
+        has_next = page < total_pages
+        has_prev = page > 1
+        
+        paginated_query = query.paginate(page, limit)
+        
+        data = [alarm.serialize() for alarm in paginated_query]
+        
+        return {
+            "data": data,
+            "pagination": {
+                "page": page,
+                "limit": limit,
+                "total_records": total_records,
+                "total_pages": total_pages,
+                "has_next": has_next,
+                "has_prev": has_prev
+            }
+        }
 
     @classmethod
     def get_alarm_summary_comments(cls, id:int):

{pyautomationio-1.0.3 → pyautomationio-1.1.1}/automation/dbmodels/events.py

@@ -77,10 +77,14 @@ class Events(BaseModel):
         description:str="",
         message:str="",
         classification:str="",
-        timezone:str='UTC'):
+        timezone:str='UTC',
+        page:int=1,
+        limit:int=20
+        ):
         r"""
         Documentation here
         """
+        import math
         _timezone = pytz.timezone(timezone)
         query = cls.select()
         
@@ -113,11 +117,32 @@ class Events(BaseModel):
             
         query = query.order_by(cls.id.desc())
 
-        if not query.exists():
-            
-            return []
+        total_records = query.count()
+        
+        if limit <= 0: limit = 20
+        if page <= 0: page = 1
+        
+        total_pages = math.ceil(total_records / limit)
+        if total_pages == 0: total_pages = 1
+        
+        has_next = page < total_pages
+        has_prev = page > 1
         
-        return [event.serialize() for event in query]
+        paginated_query = query.paginate(page, limit)
+        
+        data = [event.serialize() for event in paginated_query]
+        
+        return {
+            "data": data,
+            "pagination": {
+                "page": page,
+                "limit": limit,
+                "total_records": total_records,
+                "total_pages": total_pages,
+                "has_next": has_next,
+                "has_prev": has_prev
+            }
+        }
     
     @classmethod
     def get_comments(cls, id:int):

{pyautomationio-1.0.3 → pyautomationio-1.1.1}/automation/logger/alarms.py

@@ -119,7 +119,9 @@ class AlarmsLogger(BaseLogger):
             tags:list[str]=None,
             greater_than_timestamp:datetime=None,
             less_than_timestamp:datetime=None,
-            timezone:str="UTC"
+            timezone:str="UTC",
+            page:int=1,
+            limit:int=20
         ):
         r"""
         Documentation here
@@ -138,7 +140,9 @@ class AlarmsLogger(BaseLogger):
             tags=tags,
             greater_than_timestamp=greater_than_timestamp,
             less_than_timestamp=less_than_timestamp,
-            timezone=timezone
+            timezone=timezone,
+            page=page,
+            limit=limit
         )
     
     @db_rollback
@@ -326,7 +330,9 @@ class AlarmsLoggerEngine(BaseEngine):
         tags:list[int]=None,
         greater_than_timestamp:datetime=None,
         less_than_timestamp:datetime=None,
-        timezone:str='UTC'
+        timezone:str='UTC',
+        page:int=1,
+        limit:int=20
         ):
 
         _query = dict()
@@ -338,6 +344,8 @@ class AlarmsLoggerEngine(BaseEngine):
         _query["parameters"]["greater_than_timestamp"] = greater_than_timestamp
         _query["parameters"]["less_than_timestamp"] = less_than_timestamp
         _query["parameters"]["timezone"] = timezone
+        _query["parameters"]["page"] = page
+        _query["parameters"]["limit"] = limit
         
         return self.query(_query)
     

{pyautomationio-1.0.3 → pyautomationio-1.1.1}/automation/logger/datalogger.py

@@ -5,6 +5,7 @@ This module implements a database logger for the CVT instance,
 will create a time-serie for each tag in a short memory data base.
 """
 import pytz, logging, math
+from peewee import fn
 from collections import defaultdict
 from datetime import datetime
 from ..tags.tag import Tag
@@ -388,6 +389,235 @@ class DataLogger(BaseLogger):
             }
         }
         
+    @db_rollback
+    def read_tabular_data(self, start:str, stop:str, timezone:str, tags:list, sample_time:int, page:int=1, limit:int=20):
+        r"""
+        Get historical data in tabular format with pagination and forward-fill resampling.
+        
+        Args:
+            start (str): Start datetime string
+            stop (str): Stop datetime string 
+            timezone (str): Timezone string
+            tags (list): List of tag names
+            sample_time (int): Sample time in seconds
+            page (int): Page number
+            limit (int): Items per page
+            
+        Returns:
+            dict: {
+                "data": [...],
+                "pagination": {...}
+            }
+        """
+        if not self.is_history_logged:
+            return None
+        
+        if not self.check_connectivity():
+            return dict()
+
+        _timezone = pytz.timezone(timezone)
+        utc_timezone = pytz.UTC
+        
+        try:
+            start_dt = _timezone.localize(datetime.strptime(start, DATETIME_FORMAT)).astimezone(utc_timezone)
+            stop_dt = _timezone.localize(datetime.strptime(stop, DATETIME_FORMAT)).astimezone(utc_timezone)
+            start_ts = start_dt.timestamp()
+            stop_ts = stop_dt.timestamp()
+        except ValueError:
+            return dict()
+
+        if sample_time <= 0:
+            return dict()
+
+        # Check for data presence to adjust start time if necessary
+        # 1. Check if there is any data BEFORE or AT start_dt (history)
+        has_history = (TagValue
+            .select()
+            .join(Tags)
+            .where(
+                (Tags.name.in_(tags)) & 
+                (TagValue.timestamp <= start_dt)
+            )
+            .limit(1)
+            .count() > 0)
+        
+        if not has_history:
+            # 2. If no history, find the first actual data point within the requested range
+            min_ts = (TagValue
+                .select(fn.Min(TagValue.timestamp))
+                .join(Tags)
+                .where(
+                    (Tags.name.in_(tags)) & 
+                    (TagValue.timestamp >= start_dt) & 
+                    (TagValue.timestamp <= stop_dt) &
+                    (TagValue.value.is_null(False))
+                )
+                .scalar())
+            
+            if min_ts is None:
+                # No data in range and no history
+                return {"data": [], "pagination": {}}
+            
+            # Adjust start to the first actual data point
+            # Ensure min_ts is timezone aware if needed, though scalar() returns DB format
+            if isinstance(min_ts, datetime):
+                 if min_ts.tzinfo is None:
+                     min_ts = utc_timezone.localize(min_ts)
+                 start_dt = min_ts
+                 start_ts = start_dt.timestamp()
+            elif isinstance(min_ts, (int, float)):
+                 start_ts = float(min_ts)
+                 start_dt = datetime.fromtimestamp(start_ts, pytz.UTC)
+
+        # Calculate total records based on time range and sample time
+        total_duration = stop_ts - start_ts
+        if total_duration < 0:
+            return {"data": [], "pagination": {}}
+            
+        total_records = math.floor(total_duration / sample_time) + 1
+        
+        # Pagination calculations
+        if limit <= 0: limit = 20
+        if page <= 0: page = 1
+        
+        total_pages = math.ceil(total_records / limit)
+        if total_pages == 0: total_pages = 1
+        
+        has_next = page < total_pages
+        has_prev = page > 1
+        
+        # Calculate start and end for current page
+        start_index = (page - 1) * limit
+        end_index = min(start_index + limit, total_records)
+        
+        page_start_ts = start_ts + (start_index * sample_time)
+        page_end_ts = start_ts + ((end_index - 1) * sample_time)
+        
+        # Query data needed for this page plus context for forward fill
+        # We need data up to page_end_ts. 
+        # For forward fill, we need the last known value before or at page_start_ts for each tag.
+        
+        data_points = []
+        current_ts = page_start_ts
+        
+        # Pre-fetch data for optimization could be complex due to forward fill requirement across large gaps.
+        # However, we can query per tag or query all data in range. 
+        # For efficiency with many tags/large range, we should query intelligently.
+        # But to guarantee "last known value", we might need to look back indefinitely if no recent data.
+        # A simple approach for now: Query "last value before or at page_start_ts" for each tag, 
+        # and all values between page_start_ts and page_end_ts.
+        
+        # 1. Get initial values (state at page_start_ts)
+        current_values = {}
+        # Convert float timestamp to datetime for Peewee comparison
+        current_dt = datetime.fromtimestamp(current_ts, pytz.UTC)
+        
+        for tag_name in tags:
+            # Get the latest value <= current_dt
+            last_val_query = (TagValue
+                .select(TagValue.value)
+                .join(Tags)
+                .where((Tags.name == tag_name) & (TagValue.timestamp <= current_dt))
+                .order_by(TagValue.timestamp.desc())
+                .limit(1)
+                .dicts())
+            
+            entry = list(last_val_query)
+            if entry:
+                current_values[tag_name] = entry[0]['value']
+            else:
+                current_values[tag_name] = None
+
+        # 2. Get changes within the page window
+        # We query all changes for these tags in the time window of the page
+        
+        # Convert boundaries to datetime for Peewee
+        page_start_dt = datetime.fromtimestamp(page_start_ts, pytz.UTC)
+        page_end_dt = datetime.fromtimestamp(page_end_ts, pytz.UTC)
+
+        changes_query = (TagValue
+            .select(Tags.name, TagValue.value, TagValue.timestamp)
+            .join(Tags)
+            .where(
+                (Tags.name.in_(tags)) & 
+                (TagValue.timestamp > page_start_dt) & 
+                (TagValue.timestamp <= page_end_dt) &
+                (TagValue.value.is_null(False))
+            )
+            .order_by(TagValue.timestamp.asc())
+            .dicts())
+            
+        # Organize changes by timestamp
+        changes_by_ts = defaultdict(dict)
+        for change in changes_query:
+            # timestamp comes as datetime from Peewee
+            ts_val = change['timestamp']
+            if isinstance(ts_val, datetime):
+                # Ensure it's timezone aware or treat as UTC if naive
+                if ts_val.tzinfo is None:
+                    ts_val = utc_timezone.localize(ts_val)
+                ts = ts_val.timestamp()
+            else:
+                ts = float(ts_val)
+            
+            changes_by_ts[ts][change['name']] = change['value']
+            
+        # 3. Generate tabular data
+        # We iterate step by step. This might be slow if step is small and range is large, 
+        # but we are limited by pagination 'limit' (e.g. 20 rows), so it's fast!
+        
+        # We need to process from page_start_ts to page_end_ts in sample_time steps.
+        # BUT we have a list of changes. 
+        # The simple way: Iterate steps.
+        
+        # Optimization: We have 'limit' steps.
+        
+        changes_iter = sorted(changes_by_ts.keys())
+        change_idx = 0
+        
+        for i in range(end_index - start_index):
+            step_ts = page_start_ts + (i * sample_time)
+            
+            # Update current_values with any changes that happened between last step and now (inclusive)
+            # Actually, standard sample-hold means at time T we have value at T.
+            # If multiple values in (T-1, T], usually the last one prevails or the one at T?
+            # Requirement: "retorne exactamente el timestamp... valor anterior mas cercano registrado" (forward fill)
+            # So at step_ts, value is the latest value where timestamp <= step_ts.
+            
+            # Advance change_idx to consume all changes <= step_ts
+            while change_idx < len(changes_iter) and changes_iter[change_idx] <= step_ts:
+                ts = changes_iter[change_idx]
+                for tag, val in changes_by_ts[ts].items():
+                    current_values[tag] = val
+                change_idx += 1
+                
+            # Build row
+            dt_object = datetime.fromtimestamp(step_ts, pytz.UTC)
+            formatted_ts = dt_object.astimezone(_timezone).strftime(DATETIME_FORMAT)
+            
+            row = {"timestamp": formatted_ts}
+            has_data = False
+            for tag in tags:
+                val = current_values.get(tag)
+                row[tag] = val # None if no value ever recorded
+                if val is not None:
+                    has_data = True
+                
+            if has_data:
+                data_points.append(row)
+
+        return {
+            "data": data_points,
+            "pagination": {
+                "page": page,
+                "limit": limit,
+                "total_records": total_records,
+                "total_pages": total_pages,
+                "has_next": has_next,
+                "has_prev": has_prev
+            }
+        }
+
     def _agregate_data_every_seconds(self, query, result, seconds:int, timezone:str="UTC"):
         r"""Documentation here
         """
@@ -620,17 +850,18 @@ class DataLoggerEngine(BaseEngine):
         _query["parameters"]["tags"] = tags
         return self.query(_query)
 
-    def read_table(self, start:str, stop:str, timezone:str, tags:list, page:int=1, limit:int=20):
+    def read_tabular_data(self, start:str, stop:str, timezone:str, tags:list, sample_time:int, page:int=1, limit:int=20):
         r"""
-        Get historical data in table format with pagination on a thread-safe mechanism
+        Get historical data in tabular format with pagination on a thread-safe mechanism
         """
         _query = dict()
-        _query["action"] = "read_table"
+        _query["action"] = "read_tabular_data"
         _query["parameters"] = dict()
         _query["parameters"]["start"] = start
         _query["parameters"]["stop"] = stop
         _query["parameters"]["timezone"] = timezone
         _query["parameters"]["tags"] = tags
+        _query["parameters"]["sample_time"] = sample_time
         _query["parameters"]["page"] = page
         _query["parameters"]["limit"] = limit
         return self.query(_query)

{pyautomationio-1.0.3 → pyautomationio-1.1.1}/automation/logger/events.py

@@ -68,7 +68,9 @@ class EventsLogger(BaseLogger):
         classification:str="",
         greater_than_timestamp:datetime=None,
         less_than_timestamp:datetime=None,
-        timezone:str="UTC"
+        timezone:str="UTC",
+        page:int=1,
+        limit:int=20
         ):
         r"""
         Documentation here
@@ -90,7 +92,9 @@ class EventsLogger(BaseLogger):
             description=description,
             greater_than_timestamp=greater_than_timestamp,
             less_than_timestamp=less_than_timestamp,
-            timezone=timezone
+            timezone=timezone,
+            page=page,
+            limit=limit
             )
 
     def get_summary(self)->tuple[list, str]:
@@ -164,7 +168,9 @@ class EventsLoggerEngine(BaseEngine):
         description:str="",
         greater_than_timestamp:datetime=None,
         less_than_timestamp:datetime=None,
-        timezone:str='UTC'
+        timezone:str='UTC',
+        page:int=1,
+        limit:int=20
         ):
 
         _query = dict()
@@ -179,6 +185,8 @@ class EventsLoggerEngine(BaseEngine):
         _query["parameters"]["greater_than_timestamp"] = greater_than_timestamp
         _query["parameters"]["less_than_timestamp"] = less_than_timestamp
         _query["parameters"]["timezone"] = timezone
+        _query["parameters"]["page"] = page
+        _query["parameters"]["limit"] = limit
         
         return self.query(_query)
 

{pyautomationio-1.0.3 → pyautomationio-1.1.1}/automation/modules/alarms/resources/summary.py

@@ -16,7 +16,9 @@ alarms_summary_filter_model = api.model("alarms_summary_filter_model",{
     '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)
+    'timezone': fields.String(required=False, default=_TIMEZONE),
+    'page': fields.Integer(required=False, default=1, description='Page number'),
+    'limit': fields.Integer(required=False, default=20, description='Items per page')
 })
 
     

{pyautomationio-1.0.3 → pyautomationio-1.1.1}/automation/modules/events/resources/events.py

@@ -20,7 +20,9 @@ events_filter_model = api.model("events_filter_model",{
     '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)
+    'timezone': fields.String(required=False, default=_TIMEZONE),
+    'page': fields.Integer(required=False, default=1, description='Page number'),
+    'limit': fields.Integer(required=False, default=20, description='Items per page')
 })
 
     

{pyautomationio-1.0.3 → pyautomationio-1.1.1}/automation/modules/tags/resources/tags.py

@@ -25,6 +25,16 @@ query_table_model = api.model("query_table_model",{
     'limit': fields.Integer(required=False, default=20, description='Items per page')
 })
 
+query_tabular_data_model = api.model("query_tabular_data_model",{
+    'tags':  fields.List(fields.String(), required=True),
+    'greater_than_timestamp': fields.DateTime(required=True, default=datetime.now(pytz.utc).astimezone(TIMEZONE) - timedelta(minutes=30), description='Greater than DateTime'),
+    'less_than_timestamp': fields.DateTime(required=True, default=datetime.now(pytz.utc).astimezone(TIMEZONE), description='Less than DateTime'),
+    'sample_time': fields.Integer(required=True, description='Sample time in seconds'),
+    'timezone': fields.String(required=True, default=_TIMEZONE),
+    'page': fields.Integer(required=False, default=1, description='Page number'),
+    'limit': fields.Integer(required=False, default=20, description='Items per page')
+})
+
 write_value_model = api.model("write_value_model", {
     'tag_name': fields.String(required=True, description='Nombre del tag'),
     'value': fields.Raw(required=True, description='Valor a escribir (float, int, bool, str)')
@@ -134,6 +144,49 @@ class QueryTableResource(Resource):
         
         return result, 200
     
+@ns.route('/get_tabular_data')
+class GetTabularDataResource(Resource):
+
+    @api.doc(security='apikey')
+    @Api.token_required(auth=True)
+    @ns.expect(query_tabular_data_model)
+    def post(self):
+        """
+        Query tag values in tabular format with pagination and resampling.
+        
+        The result contains data points at regular intervals (sample_time) from greater_than_timestamp 
+        up to less_than_timestamp. If exact data is missing, the previous known value is used (forward fill).
+        
+        Authorized Roles: {0}
+        """
+        timezone = _TIMEZONE
+        tags = api.payload['tags']
+        page = api.payload.get('page', 1)
+        limit = api.payload.get('limit', 20)
+        sample_time = api.payload.get('sample_time', 60) # Default 1 min if not provided, but model requires it
+
+        if "timezone" in api.payload:
+            timezone = api.payload["timezone"]
+
+        if timezone not in pytz.all_timezones:
+            return f"Invalid Timezone", 400
+        
+        for tag in tags:
+            if not app.get_tag_by_name(name=tag):
+                return f"{tag} not exist into db", 404
+        
+        separator = '.'
+        greater_than_timestamp = api.payload['greater_than_timestamp']
+        # Ensure timestamp format is consistent
+        start = greater_than_timestamp.replace("T", " ").split(separator, 1)[0] + '.00'
+        
+        less_than_timestamp = api.payload['less_than_timestamp']
+        stop = less_than_timestamp.replace("T", " ").split(separator, 1)[0] + '.00'
+        
+        result = app.get_tabular_data(start, stop, timezone, tags, sample_time, page, limit)
+        
+        return result, 200
+
 @ns.route('/write_value')
 class WriteValueResource(Resource):
 

{pyautomationio-1.0.3 → pyautomationio-1.1.1}/automation/state_machine.py

@@ -457,6 +457,8 @@ class StateMachineCore(StateMachine):
         self.transitions = transitions
         self.manufacturer = MANUFACTURER
         self.segment = SEGMENT
+        self.mass_flow_unit_base = "kg/sec"
+        self.volumetric_flow_unit_base = "m3/sec"
         super(StateMachineCore, self).__init__()
 
     # State Methods

pyautomationio-1.1.1/version.py

@@ -0,0 +1,2 @@
+__version__ = '1.1.1'
+

pyautomationio-1.0.3/version.py

@@ -1,2 +0,0 @@
-__version__ = '1.0.3'
-