PyAutomationIO 2.0.14__tar.gz → 2.1.0__tar.gz

{pyautomationio-2.0.14 → pyautomationio-2.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyAutomationIO
-Version: 2.0.14
+Version: 2.1.0
 Summary: A python framework to develop automation industrial processes applications and Artificial Intelligence applications for the industrial field
 Home-page: https://github.com/know-ai/PyAutomation
 Author: KnowAI

{pyautomationio-2.0.14 → pyautomationio-2.1.0}/PyAutomationIO.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyAutomationIO
-Version: 2.0.14
+Version: 2.1.0
 Summary: A python framework to develop automation industrial processes applications and Artificial Intelligence applications for the industrial field
 Home-page: https://github.com/know-ai/PyAutomation
 Author: KnowAI

{pyautomationio-2.0.14 → pyautomationio-2.1.0}/PyAutomationIO.egg-info/SOURCES.txt

@@ -22,6 +22,7 @@ automation/dbmodels/__init__.py
 automation/dbmodels/alarms.py
 automation/dbmodels/core.py
 automation/dbmodels/events.py
+automation/dbmodels/linear_referencing_geospatial.py
 automation/dbmodels/logs.py
 automation/dbmodels/machines.py
 automation/dbmodels/opcua.py
@@ -43,7 +44,7 @@ automation/hmi/assets/fa-solid-900-CTAAxXor.woff2
 automation/hmi/assets/fa-solid-900-D0aA9rwL.ttf
 automation/hmi/assets/fa-v4compatibility-C9RhG_FT.woff2
 automation/hmi/assets/fa-v4compatibility-CCth-dXg.ttf
-automation/hmi/assets/index-CFaA_HVS.js
+automation/hmi/assets/index-Bq8WzzWp.js
 automation/hmi/assets/index-fe9Q2n8A.css
 automation/hmi/industrial_pallete_icons/90° curve 2.svg
 automation/hmi/industrial_pallete_icons/Analog gauge.svg
@@ -86,6 +87,9 @@ automation/modules/events/resources/logs.py
 automation/modules/health/__init__.py
 automation/modules/health/resources/__init__.py
 automation/modules/health/resources/health.py
+automation/modules/linear_referencing/__init__.py
+automation/modules/linear_referencing/resources/__init__.py
+automation/modules/linear_referencing/resources/linear_referencing_geospatial.py
 automation/modules/machines/__init__.py
 automation/modules/machines/resources/__init__.py
 automation/modules/machines/resources/machines.py

{pyautomationio-2.0.14 → pyautomationio-2.1.0}/automation/core.py

@@ -357,6 +357,7 @@ class PyAutomation(Singleton):
             node_namespace=str|type(None),
             scan_time=int|float|type(None),
             dead_band=int|float|type(None),
+            kp=int|float|type(None),
             process_filter=bool,
             gaussian_filter=bool,
             gaussian_filter_threshold=float|int,
@@ -393,6 +394,7 @@ class PyAutomation(Singleton):
             frozen_data_detection:bool=False,
             segment:str|None="",
             manufacturer:str|None="",
+            kp:float|None=None,
             id:str=None,
             user:User|None=None,
             reload:bool=False,
@@ -490,6 +492,7 @@ class PyAutomation(Singleton):
             frozen_data_detection=frozen_data_detection,
             segment=segment,
             manufacturer=manufacturer,
+            kp=kp,
             id=id,
             user=user
         )
@@ -581,6 +584,240 @@ class PyAutomation(Singleton):
         """
         return self.cvt.get_tags_filtered(manufacturer=manufacturer, segment=segment)
 
+    @logging_error_handler
+    @validate_types(kp_min=int|float, kp_max=int|float, output=list)
+    def get_tags_by_kp_range(self, kp_min:float, kp_max:float)->list:
+        r"""
+        Retrieves tags whose KP is between kp_min and kp_max (inclusive).
+
+        **Parameters:**
+
+        * **kp_min** (float): Lower KP bound.
+        * **kp_max** (float): Upper KP bound.
+
+        **Returns:**
+
+        * **list**: Serialized tags in the requested KP range.
+        """
+        return self.cvt.get_tags_by_kp_range(kp_min=kp_min, kp_max=kp_max)
+
+    @logging_error_handler
+    @validate_types(segment_name=str, kp=int|float, latitude=int|float, longitude=int|float, elevation=int|float|type(None), output=tuple)
+    def create_linear_referencing_geospatial(
+        self,
+        segment_name:str,
+        kp:float,
+        latitude:float,
+        longitude:float,
+        elevation:float|None=None
+    )->tuple[dict|None, str]:
+        r"""
+        Creates a new linear-referencing geospatial point for a segment.
+        """
+        if not self.is_db_connected():
+            return None, "Database not connected"
+
+        from .dbmodels import LinearReferencingGeospatial
+        point, message = LinearReferencingGeospatial.create(
+            segment_name=segment_name,
+            kp=kp,
+            latitude=latitude,
+            longitude=longitude,
+            elevation=elevation
+        )
+        if point is None:
+            return None, message
+        return point.serialize(), message
+
+    @logging_error_handler
+    @validate_types(output=list)
+    def get_linear_referencing_geospatial_points(self)->list:
+        r"""
+        Retrieves all linear-referencing geospatial points.
+        """
+        if not self.is_db_connected():
+            return []
+
+        from .dbmodels import LinearReferencingGeospatial
+        return LinearReferencingGeospatial.read_all()
+
+    @logging_error_handler
+    @validate_types(segment_name=str, output=list)
+    def get_linear_referencing_geospatial_points_by_segment(self, segment_name:str)->list:
+        r"""
+        Retrieves linear-referencing points for a segment ordered by KP.
+        """
+        if not self.is_db_connected():
+            return []
+
+        from .dbmodels import LinearReferencingGeospatial
+        query = LinearReferencingGeospatial.read_by_segment_name(segment_name=segment_name)
+        return [point.serialize() for point in query]
+
+    @logging_error_handler
+    @validate_types(id=int, output=dict|None)
+    def get_linear_referencing_geospatial_point(self, id:int)->dict|None:
+        r"""
+        Retrieves one linear-referencing geospatial point by ID.
+        """
+        if not self.is_db_connected():
+            return None
+
+        from .dbmodels import LinearReferencingGeospatial
+        point = LinearReferencingGeospatial.read(id=id)
+        if point is None:
+            return None
+        return point.serialize()
+
+    @logging_error_handler
+    def update_linear_referencing_geospatial_point(self, id:int, **kwargs)->tuple[dict|None, str]:
+        r"""
+        Updates a linear-referencing geospatial point by ID.
+        """
+        if not self.is_db_connected():
+            return None, "Database not connected"
+
+        from .dbmodels import LinearReferencingGeospatial, Segment
+        point = LinearReferencingGeospatial.read(id=id)
+        if point is None:
+            return None, f"Linear referencing geospatial point {id} not found"
+
+        fields = kwargs.copy()
+        if "segment_name" in fields:
+            segment_name = fields.pop("segment_name")
+            segment_obj = Segment.read_by_name(name=segment_name)
+            if segment_obj is None:
+                return None, f"Segment {segment_name} does not exist into database"
+            fields["segment"] = segment_obj
+
+        if not fields:
+            return point.serialize(), "No fields to update"
+
+        LinearReferencingGeospatial.put(id=id, **fields)
+        updated = LinearReferencingGeospatial.read(id=id)
+        return updated.serialize(), "Linear referencing geospatial point updated successfully"
+
+    @logging_error_handler
+    @validate_types(id=int, output=tuple)
+    def delete_linear_referencing_geospatial_point(self, id:int)->tuple[bool, str]:
+        r"""
+        Deletes a linear-referencing geospatial point by ID.
+        """
+        if not self.is_db_connected():
+            return False, "Database not connected"
+
+        from .dbmodels import LinearReferencingGeospatial
+        rows = LinearReferencingGeospatial.delete_by_id(id=id)
+        if rows == 0:
+            return False, f"Linear referencing geospatial point {id} not found"
+        return True, "Linear referencing geospatial point deleted successfully"
+
+    @logging_error_handler
+    @validate_types(segment_name=str, kp=int|float, output=tuple)
+    def get_geospatial_by_segment_and_kp(self, segment_name:str, kp:float)->tuple[dict|None, str]:
+        r"""
+        Retrieves geospatial coordinates by segment and KP with interpolation support.
+        """
+        if not self.is_db_connected():
+            return None, "Database not connected"
+
+        from .dbmodels import LinearReferencingGeospatial
+        return LinearReferencingGeospatial.interpolate_by_segment_and_kp(
+            segment_name=segment_name,
+            kp=kp
+        )
+
+    @logging_error_handler
+    @validate_types(rows=list, default_segment_name=str|type(None), update_existing=bool, output=dict)
+    def import_linear_referencing_profile(
+        self,
+        rows:list[dict],
+        default_segment_name:str|None=None,
+        update_existing:bool=True
+    )->dict:
+        r"""
+        Imports a complete linear-referencing profile from parsed rows (CSV/XLSX).
+        """
+        result = {
+            "created": 0,
+            "updated": 0,
+            "skipped": 0,
+            "errors": []
+        }
+
+        if not self.is_db_connected():
+            result["errors"].append("Database not connected")
+            return result
+
+        from .dbmodels import LinearReferencingGeospatial, Segment
+
+        for idx, row in enumerate(rows, start=1):
+            try:
+                segment_name = row.get("segment_name") or default_segment_name
+                if not segment_name:
+                    result["errors"].append(f"Row {idx}: missing segment_name")
+                    continue
+
+                segment_obj = Segment.read_by_name(name=segment_name)
+                if segment_obj is None:
+                    result["errors"].append(f"Row {idx}: segment {segment_name} does not exist")
+                    continue
+
+                if row.get("kp") is None:
+                    result["errors"].append(f"Row {idx}: missing kp")
+                    continue
+                if row.get("latitude") is None:
+                    result["errors"].append(f"Row {idx}: missing latitude")
+                    continue
+                if row.get("longitude") is None:
+                    result["errors"].append(f"Row {idx}: missing longitude")
+                    continue
+
+                kp = float(row.get("kp"))
+                latitude = float(row.get("latitude"))
+                longitude = float(row.get("longitude"))
+                elevation = row.get("elevation")
+                if elevation in ("", None):
+                    elevation = None
+                else:
+                    elevation = float(elevation)
+
+                current = LinearReferencingGeospatial.get_or_none(
+                    (LinearReferencingGeospatial.segment == segment_obj)
+                    & (LinearReferencingGeospatial.kp == kp)
+                )
+
+                if current is None:
+                    point, message = LinearReferencingGeospatial.create(
+                        segment_name=segment_name,
+                        kp=kp,
+                        latitude=latitude,
+                        longitude=longitude,
+                        elevation=elevation
+                    )
+                    if point is None:
+                        result["errors"].append(f"Row {idx}: {message}")
+                    else:
+                        result["created"] += 1
+                else:
+                    if not update_existing:
+                        result["skipped"] += 1
+                        continue
+                    LinearReferencingGeospatial.put(
+                        id=current.id,
+                        latitude=latitude,
+                        longitude=longitude,
+                        elevation=elevation
+                    )
+                    result["updated"] += 1
+
+            except Exception as err:
+                result["errors"].append(f"Row {idx}: {str(err)}")
+
+        result["processed"] = len(rows)
+        result["success"] = len(result["errors"]) == 0
+        return result
+
     @logging_error_handler
     @validate_types(names=list, output=list)
     def get_tags_by_names(self, names:list)->list[Tag|None]:
@@ -4274,7 +4511,7 @@ class PyAutomation(Singleton):
 
         Exports configuration tables: Manufacturer, Segment, Variables, Units, DataTypes,
         Tags, AlarmTypes, AlarmStates, Alarms, Roles, Users, OPCUA, AccessType,
-        OPCUAServer, Machines, TagsMachines.
+        OPCUAServer, Machines, TagsMachines, LinearReferencingGeospatial.
 
         Excludes historical tables: TagValue, Events, Logs, AlarmSummary.
 
@@ -4301,7 +4538,7 @@ class PyAutomation(Singleton):
             Manufacturer, Segment, Variables, Units, DataTypes,
             Tags, AlarmTypes, AlarmStates, Alarms,
             Roles, Users, OPCUA, AccessType, OPCUAServer,
-            Machines, TagsMachines
+            Machines, TagsMachines, LinearReferencingGeospatial
         )
 
         config = {
@@ -4328,7 +4565,8 @@ class PyAutomation(Singleton):
                 "AccessType": [at.serialize() for at in AccessType.select()],
                 "OPCUAServer": [os_obj.serialize() for os_obj in OPCUAServer.select()],
                 "Machines": [m.serialize() for m in Machines.select()],
-                "TagsMachines": [tm.serialize() for tm in TagsMachines.select()]
+                "TagsMachines": [tm.serialize() for tm in TagsMachines.select()],
+                "LinearReferencingGeospatial": [lr.serialize() for lr in LinearReferencingGeospatial.select()]
             }
         }
 
@@ -4373,7 +4611,7 @@ class PyAutomation(Singleton):
             Manufacturer, Segment, Variables, Units, DataTypes,
             Tags, AlarmTypes, AlarmStates, Alarms,
             Roles, Users, OPCUA, AccessType, OPCUAServer,
-            Machines, TagsMachines
+            Machines, TagsMachines, LinearReferencingGeospatial
         )
 
         results = {
@@ -4503,6 +4741,7 @@ class PyAutomation(Singleton):
                                 manufacturer=manufacturer_name or "",
                                 scan_time=item.get("scan_time"),
                                 dead_band=item.get("dead_band"),
+                                kp=item.get("kp"),
                                 active=item.get("active", True),
                                 process_filter=item.get("process_filter", False),
                                 gaussian_filter=item.get("gaussian_filter", False),
@@ -4520,7 +4759,44 @@ class PyAutomation(Singleton):
                     except Exception as e:
                         results["errors"].setdefault("Tags", []).append(f"{item.get('name', 'unknown')}: {str(e)}")
 
-            # 7. AlarmTypes (no dependencies)
+            # 7. LinearReferencingGeospatial (depends on Segment)
+            if "LinearReferencingGeospatial" in data:
+                for item in data["LinearReferencingGeospatial"]:
+                    try:
+                        segment_name = item.get("segment_name")
+                        if not segment_name:
+                            results["errors"].setdefault("LinearReferencingGeospatial", []).append(f"{item.get('id', 'unknown')}: Missing segment_name")
+                            continue
+
+                        segment_obj = Segment.read_by_name(segment_name)
+                        if segment_obj is None:
+                            results["errors"].setdefault("LinearReferencingGeospatial", []).append(f"{item.get('id', 'unknown')}: Segment {segment_name} not found")
+                            continue
+
+                        exists = LinearReferencingGeospatial.get_or_none(
+                            (LinearReferencingGeospatial.segment == segment_obj)
+                            & (LinearReferencingGeospatial.kp == item.get("kp"))
+                        )
+                        if exists is None:
+                            point, message = LinearReferencingGeospatial.create(
+                                segment_name=segment_name,
+                                kp=item.get("kp"),
+                                latitude=item.get("latitude"),
+                                longitude=item.get("longitude"),
+                                elevation=item.get("elevation")
+                            )
+                            if point is None:
+                                results["errors"].setdefault("LinearReferencingGeospatial", []).append(f"{item.get('id', 'unknown')}: {message}")
+                            else:
+                                results["imported"].setdefault("LinearReferencingGeospatial", 0)
+                                results["imported"]["LinearReferencingGeospatial"] += 1
+                        else:
+                            results["skipped"].setdefault("LinearReferencingGeospatial", 0)
+                            results["skipped"]["LinearReferencingGeospatial"] += 1
+                    except Exception as e:
+                        results["errors"].setdefault("LinearReferencingGeospatial", []).append(f"{item.get('id', 'unknown')}: {str(e)}")
+
+            # 8. AlarmTypes (no dependencies)
             if "AlarmTypes" in data:
                 for item in data["AlarmTypes"]:
                     try:

{pyautomationio-2.0.14 → pyautomationio-2.1.0}/automation/dbmodels/__init__.py

@@ -20,4 +20,5 @@ from .users import Roles, Users
 from .events import Events
 from .logs import Logs
 from .machines import Machines, TagsMachines
-from .opcua_server import AccessType, OPCUAServer
+from .opcua_server import AccessType, OPCUAServer
+from .linear_referencing_geospatial import LinearReferencingGeospatial

pyautomationio-2.1.0/automation/dbmodels/linear_referencing_geospatial.py

@@ -0,0 +1,156 @@
+from peewee import ForeignKeyField, FloatField
+from .core import BaseModel
+from .tags import Segment
+
+
+class LinearReferencingGeospatial(BaseModel):
+    r"""
+    Database model for geospatial linear-referencing points of a pipeline segment.
+    """
+
+    segment = ForeignKeyField(Segment, backref='linear_referencing_points', on_delete='CASCADE')
+    kp = FloatField()
+    latitude = FloatField()
+    longitude = FloatField()
+    elevation = FloatField(null=True)
+
+    class Meta:
+        indexes = (
+            (('segment', 'kp'), True),
+        )
+
+    @classmethod
+    def create(
+        cls,
+        segment_name:str,
+        kp:float,
+        latitude:float,
+        longitude:float,
+        elevation:float=None
+    ):
+        r"""
+        Creates a new linear-referencing geospatial point.
+        """
+        segment_obj = Segment.read_by_name(name=segment_name)
+        if segment_obj is None:
+            return None, f"Segment {segment_name} does not exist into database"
+
+        duplicated = cls.get_or_none((cls.segment == segment_obj) & (cls.kp == kp))
+        if duplicated is not None:
+            return None, f"Duplicated linear referencing point: {segment_name} KP {kp}"
+
+        query = cls(
+            segment=segment_obj,
+            kp=kp,
+            latitude=latitude,
+            longitude=longitude,
+            elevation=elevation
+        )
+        query.save()
+        return query, "Linear referencing geospatial point created successfully"
+
+    @classmethod
+    def read_by_segment_name(cls, segment_name:str):
+        r"""
+        Retrieves all points by segment name ordered by KP ascending.
+        """
+        segment_obj = Segment.read_by_name(name=segment_name)
+        if segment_obj is None:
+            return []
+        query = cls.select().where(cls.segment == segment_obj).order_by(cls.kp.asc())
+        return query
+
+    @classmethod
+    def delete_by_id(cls, id:int):
+        r"""
+        Deletes a point by its numeric ID.
+        """
+        if not cls.id_exists(id):
+            return 0
+        query = cls.delete().where(cls.id == id)
+        return query.execute()
+
+    @classmethod
+    def interpolate_by_segment_and_kp(cls, segment_name:str, kp:float):
+        r"""
+        Retrieves geospatial data by segment and KP using linear interpolation if needed.
+        """
+        segment_obj = Segment.read_by_name(name=segment_name)
+        if segment_obj is None:
+            return None, f"Segment {segment_name} does not exist into database"
+
+        exact = cls.get_or_none((cls.segment == segment_obj) & (cls.kp == kp))
+        if exact is not None:
+            data = exact.serialize()
+            data["interpolated"] = False
+            return data, "Exact KP match"
+
+        lower = (
+            cls.select()
+            .where((cls.segment == segment_obj) & (cls.kp < kp))
+            .order_by(cls.kp.desc())
+            .first()
+        )
+        upper = (
+            cls.select()
+            .where((cls.segment == segment_obj) & (cls.kp > kp))
+            .order_by(cls.kp.asc())
+            .first()
+        )
+
+        if lower is None and upper is None:
+            return None, f"No geospatial points configured for segment {segment_name}"
+
+        if lower is None:
+            data = upper.serialize()
+            data["requested_kp"] = kp
+            data["interpolated"] = False
+            data["interpolation_note"] = "Requested KP below available range; nearest upper point returned"
+            return data, "Nearest point returned"
+
+        if upper is None:
+            data = lower.serialize()
+            data["requested_kp"] = kp
+            data["interpolated"] = False
+            data["interpolation_note"] = "Requested KP above available range; nearest lower point returned"
+            return data, "Nearest point returned"
+
+        kp_span = upper.kp - lower.kp
+        if kp_span == 0:
+            return None, "Invalid interpolation range (duplicated KP points)"
+
+        ratio = (kp - lower.kp) / kp_span
+        latitude = lower.latitude + (upper.latitude - lower.latitude) * ratio
+        longitude = lower.longitude + (upper.longitude - lower.longitude) * ratio
+        elevation = None
+        if lower.elevation is not None and upper.elevation is not None:
+            elevation = lower.elevation + (upper.elevation - lower.elevation) * ratio
+
+        return {
+            "id": None,
+            "segment_id": segment_obj.id,
+            "segment_name": segment_obj.name,
+            "kp": kp,
+            "latitude": latitude,
+            "longitude": longitude,
+            "elevation": elevation,
+            "interpolated": True,
+            "interpolation_bounds": {
+                "lower_kp": lower.kp,
+                "upper_kp": upper.kp
+            }
+        }, "Interpolated KP location"
+
+    def serialize(self):
+        r"""
+        Serializes the linear-referencing geospatial point.
+        """
+        return {
+            "id": self.id,
+            "segment_id": self.segment.id,
+            "segment_name": self.segment.name,
+            "kp": self.kp,
+            "latitude": self.latitude,
+            "longitude": self.longitude,
+            "elevation": self.elevation
+        }

{pyautomationio-2.0.14 → pyautomationio-2.1.0}/automation/dbmodels/tags.py

@@ -434,6 +434,7 @@ class Tags(BaseModel):
     node_namespace = CharField(null=True)
     scan_time = IntegerField(null=True)
     dead_band = FloatField(null=True)
+    kp = FloatField(null=True)
     active = BooleanField(default=True)
     process_filter = BooleanField(default=False)
     gaussian_filter = BooleanField(default=False)
@@ -460,6 +461,7 @@ class Tags(BaseModel):
         manufacturer:str="",
         scan_time:int=0,
         dead_band:float=0.0,
+        kp:float=None,
         active:bool=True,
         process_filter:bool=False,
         gaussian_filter:bool=False,
@@ -535,6 +537,7 @@ class Tags(BaseModel):
                                 node_namespace=node_namespace,
                                 scan_time=scan_time,
                                 dead_band=dead_band,
+                                kp=kp,
                                 active=active,
                                 process_filter=process_filter,
                                 gaussian_filter=gaussian_filter,
@@ -559,6 +562,7 @@ class Tags(BaseModel):
                                 node_namespace=node_namespace,
                                 scan_time=scan_time,
                                 dead_band=dead_band,
+                                kp=kp,
                                 active=active,
                                 process_filter=process_filter,
                                 gaussian_filter=gaussian_filter,
@@ -617,6 +621,7 @@ class Tags(BaseModel):
                             "node_namespace":node_namespace,
                             "scan_time":scan_time,
                             "dead_band":dead_band,
+                            "kp":kp,
                             "active": True
                         }
                         cls.put(id=tag.id, **payload)
@@ -790,6 +795,7 @@ class Tags(BaseModel):
             'node_namespace': self.node_namespace,
             'scan_time': self.scan_time,
             'dead_band': self.dead_band,
+            'kp': self.kp,
             'variable': self.unit.variable_id.name,
             'active': self.active,
             'process_filter': self.process_filter,
@@ -817,6 +823,8 @@ class TagValue(BaseModel):
     class Meta:
         indexes = (
             (('timestamp',), False),
+            # Consultas típicas de tendencias: por tag + rango de tiempo
+            (('tag', 'timestamp'), False),
         )
 
     @classmethod