commonlib-reader 1.3.0__tar.gz → 1.4.0__tar.gz

{commonlib_reader-1.3.0 → commonlib_reader-1.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: commonlib-reader
-Version: 1.3.0
+Version: 1.4.0
 Summary: Reader for Equinor commonlib api.
 Author: Åsmund Våge Fannemel
 Author-email: Åsmund Våge Fannemel <asmf@equinor.com>
@@ -14,9 +14,12 @@ Description-Content-Type: text/markdown
 # commonlib-reader
 Connector package for Equinor [Commonlib](https://commonlib.equinor.com/) [api](https://commonlibapi.equinor.com/swagger/index.html). 
 
+See the [changelog](CHANGELOG.md) for release history.
+
 Current features:
 - Reading any code table with the `Code` class
 - Reading library definitions and attribute definitions with the `Library` and `AttributeDefinition` classes
+- Reading projects with the `Project` class
 - Getting facility data using the [Facility](commonlib_reader/facility.py) class
 - [IMS source ](commonlib_reader/ims.py) lookup tables for facilities
 - Getting Tag category, Tag type, Tag format, and Tag format element data. See [tag.py](commonlib_reader/tag.py)
@@ -71,6 +74,18 @@ Each entry provides `name`, `description`, `identity`, `is_valid`, `attributes`,
 other CommonLib metadata. Use `Code.get_names()` or `Code.get_name_and_desc()` when
 only dropdown-friendly names or name/description data is required.
 
+### Projects
+
+Use `Project.get_all()` to retrieve projects and optionally filter by name or
+abbreviation.
+
+```python
+from commonlib_reader import Project
+
+projects = Project.get_all(name="M.IGLED.6I.X.0010")
+matching_projects = Project.get_all(abbreviation="IGLED")
+```
+
 ## Installing
 
 Install package from pypi using `pip install commonlib_reader`

{commonlib_reader-1.3.0 → commonlib_reader-1.4.0}/README.md

@@ -1,9 +1,12 @@
 # commonlib-reader
 Connector package for Equinor [Commonlib](https://commonlib.equinor.com/) [api](https://commonlibapi.equinor.com/swagger/index.html). 
 
+See the [changelog](CHANGELOG.md) for release history.
+
 Current features:
 - Reading any code table with the `Code` class
 - Reading library definitions and attribute definitions with the `Library` and `AttributeDefinition` classes
+- Reading projects with the `Project` class
 - Getting facility data using the [Facility](commonlib_reader/facility.py) class
 - [IMS source ](commonlib_reader/ims.py) lookup tables for facilities
 - Getting Tag category, Tag type, Tag format, and Tag format element data. See [tag.py](commonlib_reader/tag.py)
@@ -58,6 +61,18 @@ Each entry provides `name`, `description`, `identity`, `is_valid`, `attributes`,
 other CommonLib metadata. Use `Code.get_names()` or `Code.get_name_and_desc()` when
 only dropdown-friendly names or name/description data is required.
 
+### Projects
+
+Use `Project.get_all()` to retrieve projects and optionally filter by name or
+abbreviation.
+
+```python
+from commonlib_reader import Project
+
+projects = Project.get_all(name="M.IGLED.6I.X.0010")
+matching_projects = Project.get_all(abbreviation="IGLED")
+```
+
 ## Installing
 
 Install package from pypi using `pip install commonlib_reader`

{commonlib_reader-1.3.0 → commonlib_reader-1.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "commonlib-reader"
-version = "1.3.0"
+version = "1.4.0"
 description = "Reader for Equinor commonlib api."
 readme = "README.md"
 requires-python = ">=3.10,<4.0.0"

{commonlib_reader-1.3.0 → commonlib_reader-1.4.0}/pyproject.toml.orig

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

{commonlib_reader-1.3.0 → commonlib_reader-1.4.0}/src/commonlib_reader/code.py

@@ -8,9 +8,8 @@ class Code:
     """A generic representation of one entry in a CommonLib library.
 
     A Library defines the code table and its attribute schema; a Code stores one
-    value from that table. Use this class to read entries from libraries without
-    a dedicated domain class implemented in this package, such as Facility,
-    Discipline, Unit, TagType, TagCategory, or TagFormat.
+    value from that table. Use this class directly for generic libraries, or as
+    a base class for dedicated readers that add library-specific behavior.
 
     Attributes:
         library (str): Name of the library the code belongs to.

{commonlib_reader-1.3.0 → commonlib_reader-1.4.0}/src/commonlib_reader/discipline.py

@@ -3,38 +3,15 @@ from typing import List
 from commonlib_reader.code import Code
 
 
-class Discipline:
+class Discipline(Code):
     def __init__(self, data: dict):
         if not isinstance(data, dict):
             raise ValueError("Input data shall be dictionary.")
-
-        self._data = data
-
-    def __eq__(self, other):
-        if isinstance(other, Discipline):
-            return self._data == other._data
-
-        return False
+        super().__init__(data, library="Discipline")
 
     def __str__(self):
         return f"Discipline: {self.name}-{self.description}"
 
-    @property
-    def name(self) -> str:
-        return self._data.get("name", "")
-
-    @property
-    def description(self) -> str:
-        return self._data.get("description", "")
-
-    @property
-    def identity(self) -> str:
-        return self._data.get("identity", "")
-
-    @property
-    def is_valid(self) -> bool:
-        return self._data.get("isValid", False)
-
     @classmethod
     def get_all(cls, scope: str, only_valid: bool = True) -> List["Discipline"]:
         """Get all disciplines for
@@ -57,7 +34,7 @@ class Discipline:
                 f"No discipline data found for scope {scope}. Verify that scope is correct."
             )
 
-        dis = [Discipline(x) for x in dis_data]  # type: ignore
+        dis = [cls(x) for x in dis_data]
         if only_valid:
             dis = [x for x in dis if x.is_valid]
 

commonlib_reader-1.4.0/src/commonlib_reader/unit.py

@@ -0,0 +1,285 @@
+from typing import List, Union
+
+from commonlib_reader.code import Code
+
+
+class Unit(Code):
+    """A class representing a unit of measurement.
+
+    Properties:
+        name (str): The name of the unit.
+        description (str): A description of the unit.
+        identity (str): The unique identifier for the unit.
+        quantity (str): The quantity this unit measures.
+    """
+
+    # In memory cache for units and conversion codes
+    _units = None
+    _conversion_codes = None
+
+    def __init__(self, data: Union[dict, str]):
+        if isinstance(data, str):
+            matches = [unit for unit in self.get_units() if unit.name == data]
+            if not matches:
+                raise ValueError(f"No unit named {data} found.")
+            data = matches[0]._data
+
+        super().__init__(data, library="UnitOfMeasure")
+        self.__dict__.update(self.attributes)
+
+    @property
+    def name(self) -> str:
+        """Get or set the unit symbol."""
+        return self._data.get("name", "")
+
+    @name.setter
+    def name(self, value: str):
+        self._data["name"] = value
+
+    @property
+    def description(self) -> str:
+        """Get or set the unit description."""
+        return self._data.get("description", "")
+
+    @description.setter
+    def description(self, value: str):
+        self._data["description"] = value
+
+    @property
+    def identity(self) -> str:
+        """Get or set the unit identity."""
+        return self._data.get("identity", "")
+
+    @identity.setter
+    def identity(self, value: str):
+        self._data["identity"] = value
+
+    @staticmethod
+    def _as_bool(value) -> bool:
+        if isinstance(value, bool):
+            return value
+        return str(value).strip().lower() == "true"
+
+    @property
+    def quantity(self) -> str:
+        """Get the quantity measured by this unit."""
+        return self.attributes.get("Quantity", "")
+
+    @property
+    def conversion(self) -> str:
+        """Get the unit's conversion reference."""
+        return self.attributes.get("Conversion", "")
+
+    @property
+    def measure_system(self) -> str:
+        """Get the measurement system this unit belongs to."""
+        return self.attributes.get("MeasureSystem", "")
+
+    @property
+    def alias_of_uom(self) -> str:
+        """Get the unit symbol this unit aliases, if any."""
+        return self.attributes.get("AliasOfUoM", "")
+
+    @property
+    def alternate_symbols(self) -> str:
+        """Get alternate symbols for this unit."""
+        return self.attributes.get("AlternateSymbols", "")
+
+    @property
+    def is_in_base_units(self) -> bool:
+        """Whether the unit is expressed using the seven base units."""
+        return self._as_bool(self.attributes.get("IsInBaseUnits", False))
+
+    @property
+    def is_to_be_translated_to_alias(self) -> bool:
+        """Whether incoming values should be translated to the alias symbol."""
+        return self._as_bool(
+            self.attributes.get("IsToBeTranslatedToAlias", False)
+        )
+
+    @property
+    def is_default_for_transport(self) -> bool:
+        """Whether this is the default unit for transport."""
+        return self._as_bool(self.attributes.get("IsDefaultForTransport", False))
+
+    @property
+    def is_default_for_print(self) -> bool:
+        """Whether this is the default unit for print."""
+        return self._as_bool(self.attributes.get("IsDefaultForPrint", False))
+
+    @property
+    def definition(self) -> str:
+        """Get the unit definition, if provided."""
+        return self.attributes.get("Definition", "")
+
+    @property
+    def remark(self) -> str:
+        """Get general notes about the unit."""
+        return self.attributes.get("Remark", "")
+
+    @property
+    def iec61360_code(self) -> str:
+        """Get the IEC 61360 identifier, if provided."""
+        return self.attributes.get("IEC61360Code", "")
+
+    @property
+    def dexpi_name(self) -> str:
+        """Get the DEXPI unit name, if provided."""
+        return self.attributes.get("DEXPIName", "")
+
+    @property
+    def iso15926_name(self) -> str:
+        """Get the ISO 15926 unit name, if provided."""
+        return self.attributes.get("ISO15926Name", "")
+
+    @property
+    def iso15926_url(self) -> str:
+        """Get the ISO 15926 reference URL, if provided."""
+        return self.attributes.get("ISO15926URL", "")
+
+    @property
+    def is_cfihos(self) -> bool:
+        """Whether this unit is used by CFIHOS."""
+        return self._as_bool(self.attributes.get("IsCFIHOS", False))
+
+    @property
+    def internal_comments(self) -> str:
+        """Get internal maintenance comments, if provided."""
+        return self.attributes.get("InternalComments", "")
+
+    @classmethod
+    def _get_conversion_codes(cls):
+        if cls._conversion_codes is None:
+            codes = Code.get_codes("UnitOfMeasureConversion")
+            cls._conversion_codes = {code.identity: code for code in codes}
+        return cls._conversion_codes
+
+    def _get_conversion_factors(self):
+        """Return the API's ``(FactorA, FactorB)`` conversion coefficients.
+
+        ``FactorA`` is the scale factor and ``FactorB`` is the offset. The API
+        converts a value to its base unit as ``(value - FactorB) / FactorA``;
+        the inverse is ``base_value * FactorA + FactorB``.
+        """
+        reference = self.conversion
+        conversion_code = self._get_conversion_codes().get(reference)
+        if conversion_code is None:
+            raise ValueError(
+                f"No conversion factors found for unit {self.name} ({reference})."
+            )
+
+        try:
+            factor_a = float(conversion_code.attributes["FactorA"])
+            factor_b = float(conversion_code.attributes["FactorB"])
+        except (KeyError, TypeError, ValueError):
+            raise ValueError(
+                f"Invalid conversion factors for unit {self.name} ({reference})."
+            ) from None
+        return factor_a, factor_b
+
+    @property
+    def factor_a(self) -> float:
+        """Get the unit's multiplicative conversion factor."""
+        return self._get_conversion_factors()[0]
+
+    @property
+    def factor_b(self) -> float:
+        """Get the unit's additive conversion factor."""
+        return self._get_conversion_factors()[1]
+
+    def convert(self, value: float, to_unit: Union[str, "Unit"]) -> float:
+        """Convert a value from this unit to another unit of the same quantity.
+
+        A string target may be either a unit identity (for example,
+        ``"Pa|pressure"``) or an unambiguous symbol for this quantity.
+        """
+        if isinstance(to_unit, str):
+            matches = [unit for unit in self.get_units() if unit.identity == to_unit]
+            if not matches:
+                symbol_matches = [
+                    unit for unit in self.get_units() if unit.name == to_unit
+                ]
+                quantity_matches = [
+                    unit
+                    for unit in symbol_matches
+                    if unit.quantity == self.quantity
+                ]
+                matches = quantity_matches or symbol_matches
+            if not matches:
+                raise ValueError(f"No target unit {to_unit} found for {self.name}.")
+            if len(matches) > 1:
+                raise ValueError(f"Target unit {to_unit} is ambiguous.")
+            to_unit = matches[0]
+        elif not isinstance(to_unit, Unit):
+            raise ValueError("Target unit must be a unit symbol, identity, or Unit.")
+
+        if self.quantity != to_unit.quantity:
+            raise ValueError(
+                f"Cannot convert between {self.quantity} and {to_unit.quantity}."
+            )
+
+        source_a, source_b = self._get_conversion_factors()
+        target_a, target_b = to_unit._get_conversion_factors()
+        if source_a == 0:
+            raise ValueError(f"Conversion factor A is zero for unit {self.name}.")
+
+        base_value = (float(value) - source_b) / source_a
+        return base_value * target_a + target_b
+
+    @classmethod
+    def get_convertible_units(cls, unit: Union[str, "Unit"]) -> List["Unit"]:
+        """List units with usable conversion factors for the same quantity.
+
+        Args:
+            unit: A Unit instance, unit identity, or unambiguous unit symbol.
+
+        Returns:
+            List[Unit]: Compatible units, including the input unit when valid.
+
+        Raises:
+            ValueError: If the input cannot be resolved or has no usable factors.
+        """
+        if isinstance(unit, str):
+            matches = [candidate for candidate in cls.get_units() if candidate.identity == unit]
+            if not matches:
+                matches = [candidate for candidate in cls.get_units() if candidate.name == unit]
+            if not matches:
+                raise ValueError(f"No unit named or identified by {unit} found.")
+            if len(matches) > 1:
+                raise ValueError(f"Unit symbol {unit} is ambiguous; use its identity.")
+            unit = matches[0]
+        elif not isinstance(unit, cls):
+            raise ValueError("Input must be a Unit instance, unit symbol, or identity.")
+
+        source_a, _ = unit._get_conversion_factors()
+        if source_a == 0:
+            raise ValueError(f"Conversion factor A is zero for unit {unit.name}.")
+
+        convertible_units = []
+        for candidate in cls.get_units():
+            if candidate.quantity != unit.quantity:
+                continue
+            try:
+                factor_a, _ = candidate._get_conversion_factors()
+            except ValueError:
+                continue
+            if factor_a != 0:
+                convertible_units.append(candidate)
+
+        return convertible_units
+
+    def convertible_units(self) -> List["Unit"]:
+        """List units convertible with this unit's quantity."""
+        return type(self).get_convertible_units(self)
+
+    @classmethod
+    def get_units(cls) -> List["Unit"]:
+        """Get list of Unit objects of entries in code library. Caches locally in memory.
+
+        Returns:
+            List[Unit]: List of Unit objects from entries in code library.
+        """
+        if cls._units is None:
+            cls._units = Code._get_code_data("UnitOfMeasure")
+
+        return [cls(x) for x in cls._units]

commonlib_reader-1.3.0/src/commonlib_reader/unit.py

@@ -1,82 +0,0 @@
-from typing import List, Union
-
-from commonlib_reader.code import Code
-
-
-class Unit:
-    """A class representing a unit of measurement.
-
-    Properties:
-        name (str): The name of the unit.
-        description (str): A description of the unit.
-        identity (str): The unique identifier for the unit.
-        quantity (str): The quantity this unit measures.
-    """
-
-    _units = None
-
-    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:
-                data = s[0]._data
-            else:
-                raise ValueError(f"No unit named {data} found.")
-
-        if isinstance(data, dict):
-            self._data = data
-            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) -> str:
-        """Get the unit name."""
-        return getattr(self, "_name", "")
-
-    @name.setter
-    def name(self, value: str):
-        """Set the unit name."""
-        self._name = value
-
-    @property
-    def description(self) -> str:
-        """Get the unit description."""
-        return getattr(self, "_description", "")
-
-    @description.setter
-    def description(self, value: str):
-        """Set the unit description."""
-        self._description = value
-
-    @property
-    def identity(self) -> str:
-        """Get the unit identity."""
-        return getattr(self, "_identity", "")
-
-    @identity.setter
-    def identity(self, value: str):
-        """Set the unit identity."""
-        self._identity = value
-
-    @property
-    def quantity(self) -> str:
-        """Get the quantity measured by this unit."""
-        return getattr(self, "Quantity", "")
-
-    @classmethod
-    def get_units(cls) -> List["Unit"]:
-        """Get list of Unit objects of entries in code library. Caches locally in memory.
-
-        Returns:
-            List[Unit]: List of Unit objects from entries in code library.
-        """
-        if cls._units is None:
-            cls._units = Code._get_code_data("UnitOfMeasure")
-
-        return [Unit(x) for x in cls._units]