commonlib-reader 1.0.9__tar.gz → 1.1.0__tar.gz

{commonlib_reader-1.0.9 → commonlib_reader-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: commonlib-reader
-Version: 1.0.9
+Version: 1.1.0
 Summary: Reader for Equinor commonlib api.
 License: MIT
 Author: Åsmund Våge Fannemel

{commonlib_reader-1.0.9 → commonlib_reader-1.1.0}/commonlib_reader/facility.py

@@ -38,27 +38,64 @@ class Facility:
         self._data = Facility._get_facility_data(code=code)
         self._attributes = attributes_list_to_dict(self._data["attributes"])
 
-        self.identity = self._data["identity"]
-        self.name = self._data["name"]
-        self.description = self._data["description"]
-
-        self.SAPPlant = ""
-        self.Field = ""
-        self.ParentFacility = ""
-        self.NPDID = ""
-        self.GovernmentalName = ""
-
-        for key, val in self._attributes.items():
-            if key in self.__getattribute__("__dict__").keys():
-                self.__setattr__(key, val)
-
-        self.STID = self.identity  # Alias for identity
+        if self.is_stid:
+            self.STID = self.identity
         self.instCode = self.identity  # Alias for identity
         try:
-            self.SAP = int(self.SAPPlant)  # Alias for SAPPlant as integer
+            self.SAP = int(self.sap)  # Alias for SAPPlant as integer
         except (TypeError, ValueError):
             pass
 
+    @property
+    def identity(self) -> str:
+        return self._data.get("identity", "")
+
+    @property
+    def name(self) -> str:
+        return self._data.get("name", "")
+
+    @property
+    def description(self) -> str:
+        return self._data.get("description", "")
+
+    @property
+    def stid(self) -> str:
+        return self.inst_code
+
+    @property
+    def inst_code(self) -> str:
+        if self.is_stid:
+            return self.identity
+        return ""
+
+    @property
+    def is_stid(self) -> bool:
+        return self.isSTID()
+
+    @property
+    def sap(self) -> str:
+        return self._attributes.get("SAPPlant", "")
+
+    @property
+    def field(self) -> str:
+        return self._attributes.get("Field", "")
+
+    @property
+    def parent_facility(self) -> str:
+        return self._attributes.get("ParentFacility", "")
+
+    @property
+    def npd_id(self):
+        return self._attributes.get("NPDID", "")
+
+    @property
+    def governmental_name(self) -> str:
+        return self._attributes.get("GovernmentalName", "")
+
+    @property
+    def ioc_plant(self) -> str:
+        return self._attributes.get("IOCPlant", "")
+
     def isSTID(self):
         """
         Checks if the facility is marked for STID.
@@ -72,11 +109,51 @@ class Facility:
 
         return False
 
-    def __str__(self):
-        return f"Facility: {self.identity}, Name: {self.name}, Description: {self.description}"
+    def resolve_gov_facility_name(self) -> str:
+        """
+        Retrieves the governmental facility name.
+
+        Returns:
+            str: The governmental facility name if available, otherwise an empty string.
+        """
+        if len(self.governmental_name) > 0:
+            return self.governmental_name
+
+        if self.parent_facility != "":
+            parent = Facility(self.parent_facility)
+            return parent.resolve_gov_facility_name()
+
+        raise ValueError(
+            f"Cannot resolve governmental facility name for facility {self.name}"
+        )
+
+    def resolve_inst_code(self) -> str:
+        if self.stid != "":
+            return self.stid
+        elif len(self.parent_facility) > 0:
+            f = Facility(self.parent_facility)
+            return f.resolve_inst_code()
+
+        raise ValueError(f"Cannot resolve installation code for facility {self.name}")
 
-    @staticmethod
-    def get_inst_code(facility: Union[str, int]) -> str:
+    def resolve_ioc_plant_name(self) -> str:
+        """
+        Retrieves the IOC plant name.
+
+        Returns:
+            str: The IOC plant name if available, otherwise an empty string.
+        """
+        if len(self.ioc_plant) > 0:
+            return self.ioc_plant
+
+        if self.parent_facility != "":
+            parent = Facility(self.parent_facility)
+            return parent.resolve_ioc_plant_name()
+
+        raise ValueError(f"Cannot resolve IOC plant name for facility {self.name}")
+
+    @classmethod
+    def get_inst_code(cls, facility: Union[str, int]) -> str:
         """
         Retrieves the STID installation code for the given facility identifier.
         If the facility is not a STID facility, it recursively retrieves the installation code of its parent facility.
@@ -89,15 +166,47 @@ class Facility:
             ValueError: If no facility is found for the provided identifier.
         """
 
-        f = Facility(facility)
-        if isinstance(f, Facility):
-            if f.isSTID():
-                return f.STID
-            else:
-                return Facility.get_inst_code(f.ParentFacility)
+        f = cls(facility)
+        if isinstance(f, cls):
+            return f.stid
 
         raise ValueError(f"No facility found for {facility}")
 
+    @classmethod
+    def get_child_facilities(
+        cls, parent_facility: Union[str, "Facility"], recurse=True
+    ) -> List["Facility"]:
+        """
+        Retrieves all child facilities of the given parent facility.
+
+        Parameters:
+            parent_facility (str or Facility): The parent identifier of the parent facility.
+            recurse (bool): Whether to recursively retrieve child
+            facilities. Default is True.
+        Returns:
+           List[Facility]: A list of child
+        """
+
+        if isinstance(parent_facility, Facility):
+            parent_facility = parent_facility.identity
+
+        children = []
+        for f in cls.get_all_facilities():
+            if f.parent_facility == parent_facility:
+                children.append(f)
+
+        if recurse and len(children) > 0:
+            grandkids = []
+            for c in children:
+                gc = cls.get_child_facilities(c)
+                if len(gc) > 0:
+                    grandkids.append(gc)
+
+            if len(grandkids) > 0:
+                [children.append(gc) for gc in grandkids]
+
+        return children
+
     @classmethod
     def get_all_facilities(cls) -> List["Facility"]:
         """
@@ -118,7 +227,11 @@ class Facility:
             List[dict]: A list of dictionaries, each representing facility data.
         """
         if cls._cache is None:
-            cls._cache = get_code("Facility")
+            code = get_code("Facility")
+            if isinstance(code, list):
+                cls._cache = code
+            else:
+                raise ValueError("Failed to retrieve facility data")
 
         return cls._cache
 

{commonlib_reader-1.0.9 → commonlib_reader-1.1.0}/commonlib_reader/ims.py

@@ -34,14 +34,29 @@ class IMS:
         self._attributes = attributes_list_to_dict(self._data["attributes"])
 
         self.isValid = data["isValid"]
-
-        self.Facility = ""
-        self.IMSType = ""
-        self.Alias = ""
-
         for attr in self._data["attributes"]:
             self.__setattr__(attr["definitionName"], attr["displayValue"])
 
+    @property
+    def alias(self) -> str:
+        return getattr(self, "Alias", "")
+
+    @property
+    def type(self) -> str:
+        return getattr(self, "IMSType", "")
+
+    @property
+    def facility(self) -> str:
+        return getattr(self, "Facility", "")
+
+    @property
+    def is_valid(self) -> bool:
+        return getattr(self, "isValid", False)
+
+    @property
+    def seeq_datasource(self) -> str:
+        return getattr(self, "IMSSeeqDatasource", "")
+
     @staticmethod
     def from_facility(facility: Union[Facility, str, int]) -> "IMS":
         """Get IMS instance from STID code.
@@ -56,7 +71,7 @@ class IMS:
             IMS: IMS instance
         """
         if isinstance(facility, int):
-            facility = Facility(facility).identity
+            facility = Facility(facility)
 
         if isinstance(facility, Facility):
             facility = facility.identity
@@ -94,12 +109,12 @@ class IMS:
         """
         i = IMS._get_ims_codes()
         if len(facility) > 0:
-            return [x for x in i if x.Facility == facility]
+            return [x for x in i if x.facility == facility]
 
         return i
 
-    @staticmethod
-    def get_source(facility: str) -> str:
+    @classmethod
+    def get_source(cls, facility: str) -> str:
         """Get IMS name for a facility.
 
         Args:
@@ -112,11 +127,11 @@ class IMS:
             str: Name of IMS
         """
 
-        l_ims = IMS.from_facility(facility=facility)
-        return l_ims.Alias
+        l_ims = cls.from_facility(facility=facility)
+        return l_ims.alias
 
-    @staticmethod
-    def get_type(facility: str) -> str:
+    @classmethod
+    def get_type(cls, facility: str) -> str:
         """Get IMS type for a facility.
 
         Args:
@@ -128,5 +143,5 @@ class IMS:
         Returns:
             str: Type of IMS
         """
-        l_ims = IMS.from_facility(facility=facility)
-        return l_ims.IMSType
+        l_ims = cls.from_facility(facility=facility)
+        return l_ims.type

{commonlib_reader-1.0.9 → commonlib_reader-1.1.0}/commonlib_reader/tag.py

@@ -1,5 +1,10 @@
 from typing import List, Optional, Union
-from commonlib_reader.utils import get_code, get_code_param, query_sql
+from commonlib_reader.utils import (
+    attributes_list_to_dict,
+    get_code,
+    get_code_param,
+    query_sql,
+)
 import re
 
 # from commonlib_reader.utils import attributes_list_to_dict
@@ -31,12 +36,30 @@ class TagFormatElement:
         """
         self._data = data
 
-        self.description = data["Description"]
-        self.name = data["Name"]
         self.IsValid = bool(data["IsValid"])
         self.IsRequired = bool(data["Required"])
         self.IsSelected = bool(data["SelectFlag"])
 
+    @property
+    def name(self) -> str:
+        return self._data["Name"]
+
+    @property
+    def description(self) -> str:
+        return self._data["Description"]
+
+    @property
+    def is_valid(self) -> bool:
+        return self.IsValid
+
+    @property
+    def is_required(self) -> bool:
+        return self.IsRequired
+
+    @property
+    def is_selected(self) -> bool:
+        return self.IsSelected
+
     def get_TagFormat(self) -> "TagFormat":
         tag_format_id = self._data["TagFormat_ID"]
         res = query_sql(f"Select * from tagformat where Id = '{tag_format_id}'")
@@ -86,25 +109,33 @@ class TagFormat:
         # Cache tagformatelements
         self._tfe = None
 
-        # self._attributes = attributes_list_to_dict(self._data["attributes"])
+        self._attributes = attributes_list_to_dict(self._data["attributes"])
 
-        self.inst_code = inst_code
-        self.description = data["description"]
+        self._inst_code = inst_code
 
-        self.tag_category = ""
-        self.syntax = ""
-        self.regex = ""
-        self.regex_grouped = ""
+    @property
+    def inst_code(self) -> str:
+        return self._inst_code
 
-        for attr in self._data["attributes"]:
-            if attr["definitionName"] == "TagCategory":
-                self.tag_category = attr["displayValue"]
-            elif attr["definitionName"] == "Syntax":
-                self.syntax = attr["displayValue"]
-            elif attr["definitionName"] == "Regex":
-                self.regex = attr["displayValue"]
-            elif attr["definitionName"] == "RegexGrouped":
-                self.regex_grouped = attr["displayValue"]
+    @property
+    def description(self) -> str:
+        return self._data["description"]
+
+    @property
+    def tag_category(self) -> str:
+        return self._attributes.get("TagCategory", "")
+
+    @property
+    def syntax(self) -> str:
+        return self._attributes.get("Syntax", "")
+
+    @property
+    def regex(self) -> str:
+        return self._attributes.get("Regex", "")
+
+    @property
+    def regex_grouped(self) -> str:
+        return self._attributes.get("RegexGrouped", "")
 
     def __str__(self):
         return f"{self.description} - {self.tag_category}"
@@ -237,18 +268,36 @@ class TagType:
             inst_code (str): Installation code for which this tag type applies.
         """
         self._data = data
-        self.inst_code = inst_code
-
-        self.name = self._data["name"]
-        self.description = self._data["description"]
-        self.is_valid = self._data["isValid"]
-        self.tag_category = ""
+        self._attributes = attributes_list_to_dict(self._data["attributes"])
+        self._inst_code = inst_code
 
         for attr in self._data["attributes"]:
             if attr["definitionName"] == "STIDTagCount":
                 self.STID_tag_Count = int(attr["displayValue"])
-            elif attr["definitionName"] == "TagCategory":
-                self.tag_category = attr["displayValue"]
+
+    @property
+    def inst_code(self) -> str:
+        return self._inst_code
+
+    @property
+    def name(self) -> str:
+        return self._data["name"]
+
+    @property
+    def description(self) -> str:
+        return self._data["description"]
+
+    @property
+    def tag_category(self) -> str:
+        return self._attributes.get("TagCategory", "")
+
+    @property
+    def is_valid(self) -> bool:
+        return self._data["isValid"]
+
+    @property
+    def stid_tag_count(self) -> int:
+        return self.STID_tag_Count
 
     def __str__(self):
         return f"{self.name} - {self.description}"
@@ -425,11 +474,8 @@ class TagCategory:
             inst_code (str): Installation code for which this tag category applies.
         """
         self._data = data
-        self.inst_code = inst_code
-
-        self.name = self._data["name"]
-        self.description = self._data["description"]
-        self.is_valid = self._data["isValid"]
+        self._inst_code = inst_code
+        self._attributes = attributes_list_to_dict(self._data["attributes"])
 
         for attr in self._data["attributes"]:
             if attr["definitionName"] == "TagCategoryId":
@@ -444,6 +490,42 @@ class TagCategory:
         self._types = []
         self._formats = []
 
+    @property
+    def inst_code(self) -> str:
+        return self._inst_code
+
+    @property
+    def name(self) -> str:
+        return self._data["name"]
+
+    @property
+    def description(self) -> str:
+        return self._data["description"]
+
+    @property
+    def is_valid(self) -> bool:
+        return self._data["isValid"]
+
+    @property
+    def tag_category_id(self) -> int:
+        id = self._attributes.get("TagCategoryId")
+        if id is None:
+            raise ValueError("TagCategoryId attribute not found")
+
+        return int(id)
+
+    @property
+    def tag_category_dlg(self) -> str:
+        return self._attributes.get("TagCategoryDlg", "")
+
+    @property
+    def individ_flag(self) -> str:
+        return self._attributes.get("IndividFlag", "")
+
+    @property
+    def sap_fl_category(self) -> str:
+        return self._attributes.get("SapFlCategory", "")
+
     def get_formats(self) -> List[TagFormat]:
         """Get tag formats for this specific tag category.
 
@@ -506,7 +588,7 @@ class TagCategory:
         )
 
     def __str__(self):
-        return f"{self.TagCategoryId}:{self.name} - {self.description}"
+        return f"{self.tag_category_id}:{self.name} - {self.description}"
 
     @staticmethod
     def get_category(inst_code: str, name="") -> List["TagCategory"]:
@@ -522,7 +604,7 @@ class TagCategory:
 
         categories = _get_category_data(inst_code=inst_code)
         tc = [TagCategory(x, inst_code=inst_code) for x in categories]
-        tc.sort(key=lambda x: x.TagCategoryId)
+        tc.sort(key=lambda x: x.tag_category_id)
         if name is None:
             pass
         elif isinstance(name, str) and len(name) > 0:

{commonlib_reader-1.0.9 → commonlib_reader-1.1.0}/commonlib_reader/unit.py

@@ -1,18 +1,12 @@
-from commonlib_reader.utils import get_code
+from typing import Union
 
-# from commonlib_reader.utils import attributes_list_to_dict
+from commonlib_reader.utils import get_code
 
 
 class Unit:
     _units = []
 
-    def __init__(self, data: dict):
-        self.name = ""
-        self.description = ""
-
-        self.identity = ""
-        self.quantity = ""
-
+    def __init__(self, data: Union[dict, str]):
         if isinstance(data, str):
             s = [x for x in Unit.get_units() if x.name == data]
             if len(s) > 0:
@@ -22,14 +16,42 @@ class Unit:
 
         if isinstance(data, dict):
             self._data = data
-            # self._attributes = attributes_list_to_dict(self._data["attributes"])
-
             for key in data.keys():
                 if key == "attributes":
                     for attr in data["attributes"]:
                         self.__setattr__(attr["definitionName"], attr["displayValue"])
                 else:
                     self.__setattr__(key, data[key])
+        else:
+            raise ValueError("Input data must be a dict from codetable")
+
+    @property
+    def name(self):
+        return getattr(self, "_name", "")
+
+    @name.setter
+    def name(self, value):
+        self._name = value
+
+    @property
+    def description(self):
+        return getattr(self, "_description", "")
+
+    @description.setter
+    def description(self, value):
+        self._description = value
+
+    @property
+    def identity(self):
+        return getattr(self, "_identity", "")
+
+    @identity.setter
+    def identity(self, value):
+        self._identity = value
+
+    @property
+    def quantity(self):
+        return getattr(self, "Quantity", "")
 
     @classmethod
     def get_units(cls):

{commonlib_reader-1.0.9 → commonlib_reader-1.1.0}/commonlib_reader/utils.py

@@ -9,7 +9,8 @@ from commonlib_reader.connector import get_connector
 
 def get_library_names():
     library_names = get_connector().get_json(url="/api/Library/NameList")
-    library_names.sort()
+    if isinstance(library_names, list):
+        library_names.sort()
     return library_names
 
 

{commonlib_reader-1.0.9 → commonlib_reader-1.1.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "commonlib-reader"
-version = "1.0.9"
+version = "1.1.0"
 description = "Reader for Equinor commonlib api."
 authors = [
 	{ name = "Åsmund Våge Fannemel", email = "asmf@equinor.com" }