PyAutomationIO 1.0.3__tar.gz → 1.1.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyAutomationIO
-Version: 1.0.3
+Version: 1.1.0
 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.0}/PyAutomationIO.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyAutomationIO
-Version: 1.0.3
+Version: 1.1.0
 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.0}/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"""

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

@@ -388,6 +388,186 @@ 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()
+
+        # 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)
+            )
+            .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}
+            for tag in tags:
+                row[tag] = current_values.get(tag) # None if no value ever recorded
+                
+            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 +800,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.0}/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.0}/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.0/version.py

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

pyautomationio-1.0.3/version.py

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