commonlib-reader 1.0.0__py3-none-any.whl

commonlib_reader/__init__.py

@@ -0,0 +1,25 @@
+from commonlib_reader.utils import (
+    get_code,
+    get_code_param,
+    get_disciplines,
+    get_library_names,
+)
+
+
+from .tag import TagType, TagCategory, TagFormat
+from .ims import IMS
+from .facility import Facility
+from .unit import Unit
+
+__all__ = [
+    "Facility",
+    "IMS",
+    "TagType",
+    "TagCategory",
+    "TagFormat",
+    "Unit",
+    "get_code",
+    "get_code_param",
+    "get_disciplines",
+    "get_library_names",
+]

commonlib_reader/facility.py

@@ -0,0 +1,105 @@
+from typing import List
+
+from commonlib_reader.utils import attributes_list_to_dict, get_code
+
+
+class Facility:
+    """
+    Facility class to encapsulate information.
+
+    Attributes:
+        identity (str)         : A unique identifier for the facility (read from the data source).
+        name (str)             : The name of the facility (read from the data source).
+        description (str)      : A description of the facility (read from the data source).
+        SAPPlant (str)         : SAP Plant code (if available).
+        Field (str)            : Field identifier associated with the facility (if available).
+        ParentFacility (str)   : Parent facility identifier (if available).
+        NPDID (str)            : NPD ID (if available).
+
+    _cache (list of dict, optional):
+        Class level cache to store facility data, to minimize data source access.
+
+    """
+
+    _cache = None
+
+    def __init__(self, code):
+        """
+        Initializes the Facility instance by retrieving data related to the given STID plant code.
+
+        Parameters:
+            code (str): The code used to retrieve facility data from the data source.
+
+        Raises:
+            ValueError: If no data is found for the provided code.
+        """
+        self._data = Facility._get_facility(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"]
+
+        common_attributes = ["SAPPlant", "Field", "ParentFacility", "NPDID"]
+        for attr in common_attributes:
+            self.__setattr__(attr, "")
+
+        for key, val in self._attributes.items():
+            if key in common_attributes:
+                self.__setattr__(key, val)
+
+    def isSTID(self):
+        """
+        Checks if the facility is marked for STID.
+
+        Returns:
+            bool: True if the facility is marked for STID, False otherwise.
+        """
+        if "IsForSTID" in self._attributes.keys():
+            if self._attributes["IsForSTID"] == "True":
+                return True
+
+        return False
+
+    @classmethod
+    def get_all_facilities(cls) -> List["Facility"]:
+        """
+        Retrieves and returns a list of Facility instances for all known facilities.
+
+        Returns:
+            List[Facility]: A list of Facility instances.
+        """
+        f = Facility._get_all_facilities()
+        return [Facility(x["identity"]) for x in f]
+
+    @classmethod
+    def _get_all_facilities(cls) -> List[dict]:
+        """
+        Retrieves all facility data, using a class level cache.
+
+        Returns:
+            List[dict]: A list of dictionaries, each representing facility data.
+        """
+        if cls._cache is None:
+            cls._cache = get_code("Facility")
+
+        return cls._cache
+
+    @classmethod
+    def _get_facility(cls, code) -> dict:
+        """
+        Retrieves the facility data for the given code.
+
+        Parameters:
+            code (str): The STID plant code corresponding to the facility.
+
+        Returns:
+            dict: A dictionary containing data related to the facility.
+
+        Raises:
+            ValueError: If no data is found for the provided code.
+        """
+        for f in cls._get_all_facilities():
+            if f["identity"] == code or f["name"] == code or f["description"] == code:
+                return f
+        raise ValueError(f"No data found for {code}")

commonlib_reader/ims.py

@@ -0,0 +1,126 @@
+from typing import List, Union
+from commonlib_reader.utils import attributes_list_to_dict, get_code
+
+
+class IMS:
+    _ims_codes = []
+
+    """Class for IMS objects.
+
+    properties:
+    Facility (str) - Name of facility
+    IMSType (str) - Type of IMS
+    Alias (str) - Facility name aliases
+    isValid (bool) - True if IMS is in operation
+    """
+
+    def __init__(self, data: Union[str, dict]):
+        """Instance constructor for IMS object. End-users should use static method IMS.from_facility()
+
+        Args:
+            data (str,dict): Facility name or data dictionary to populate instance data attributes.
+
+        Raises:
+            ValueError: If input data is not a dict.
+        """
+        if isinstance(data, str):
+            data = IMS.from_facility(data)._data
+
+        if not isinstance(data, dict):
+            raise ValueError("Input data must be a dict from codetable")
+
+        self._data = data
+        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"])
+
+    @staticmethod
+    def from_facility(facility: str) -> "IMS":
+        """Get IMS instance from STID code.
+
+        Args:
+            facility (str): Facility code
+
+        Raises:
+            ValueError: Not able to instantiate IMS object from input facility code.
+
+        Returns:
+            IMS: IMS instance
+        """
+        if facility is None or len(facility) == 0:
+            raise ValueError(
+                "Facility must be provided. Empty strings are not allowed."
+            )
+        ims = IMS.get_ims_list(facility=facility)
+        if len(ims) == 1:
+            return ims[0]
+
+        raise ValueError(f"Not able to get IMS object for facility {facility}")
+
+    @classmethod
+    def _get_ims_codes(cls) -> List["IMS"]:
+        """Get list of IMS instance of entries in code library ApplicationIMS. Caches locally in memory.
+
+        Returns:
+            List[IMS]: list of IMS instance from entries in code library ApplicationIMS.
+        """
+        if cls._ims_codes is None or len(cls._ims_codes) == 0:
+            cls._ims_codes = get_code("ApplicationIMS")
+
+        return [IMS(x) for x in cls._ims_codes]
+
+    @staticmethod
+    def get_ims_list(facility: str = "") -> List["IMS"]:
+        """Get list of IMS objects.
+
+        Args:
+            facility (str, optional): Facility. Defaults to "", which will get list of all entries defined in lib.
+
+        Returns:
+            List[IMS]: list of IMS objects
+        """
+        i = IMS._get_ims_codes()
+        if len(facility) > 0:
+            return [x for x in i if x.Facility == facility]
+
+        return i
+
+    @staticmethod
+    def get_source(facility: str) -> str:
+        """Get IMS name for a facility.
+
+        Args:
+            facility (str): Name of facility.
+
+        Raises:
+            ValueError: If facility input is invalid, i.e., empty.
+
+        Returns:
+            str: Name of IMS
+        """
+
+        l_ims = IMS.from_facility(facility=facility)
+        return l_ims.Alias
+
+    @staticmethod
+    def get_type(facility: str) -> str:
+        """Get IMS type for a facility.
+
+        Args:
+            facility (str): Name of facility
+
+        Raises:
+            ValueError: If facility input is invalid, i.e., empty.
+
+        Returns:
+            str: Type of IMS
+        """
+        l_ims = IMS.from_facility(facility=facility)
+        return l_ims.IMSType

commonlib_reader/tag.py

@@ -0,0 +1,439 @@
+from typing import List, Union
+from commonlib_reader.utils import get_code, get_code_param, query_sql
+
+# from commonlib_reader.utils import attributes_list_to_dict
+
+_cache = {}
+_cache["TagType"] = {}
+_cache["TagCategory"] = {}
+_cache["TagFormat"] = {}
+
+
+class TagFormat:
+    """
+    A class that represents the format of a tag within the context of a Facility.
+
+    Attributes:
+        inst_code (str): Installation code.
+        description (str): Description of the tag format.
+        tag_category (str): Tag category this format belongs to.
+        syntax (str): The syntax structure of the tag format.
+        regex (str): The regular expression pattern representing the tag format.
+        regex_grouped (str): Grouped regular expression pattern for the tag format.
+    """
+
+    def __init__(self, data: dict, inst_code: str):
+        """
+        Initializes a TagFormat object.
+
+        Parameters:
+            data (dict): Data containing different properties of a tag format.
+            inst_code (str): Installation code for this tag format.
+        """
+        self._data = data
+        # self._attributes = attributes_list_to_dict(self._data["attributes"])
+
+        self.inst_code = inst_code
+        self.description = data["description"]
+
+        self.tag_category = ""
+        self.syntax = ""
+        self.regex = ""
+        self.regex_grouped = ""
+
+        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"]
+
+    def __str__(self):
+        return f"{self.description} - {self.tag_category}"
+
+    @staticmethod
+    def get_tagformat(
+        description: str, inst_code: str, tag_category: str
+    ) -> "TagFormat":
+        """
+        Retrieve a tag format for a given description, installation code and tag category.
+
+        Parameters:
+            description (str): Description of the tag format to retrieve.
+            inst_code (str): Installation code of the requested tag format.
+            tag_category (str): Category of the requested tag format.
+
+        Returns:
+            TagFormat: The requested tag format object.
+        """
+        t = TagCategory.get_category(inst_code=inst_code, name=tag_category)
+        return t[0].get_format(description)
+
+
+class TagType:
+    """
+    A class that represents a tag type, which is pertinent to a tag category and
+    associated with a particular facility.
+
+    Attributes:
+        inst_code (str): The facility code the tag type is associated with.
+        name (str): The name of the tag type.
+        description (str): A description of the tag type.
+        is_valid (bool): A flag indicating whether the tag type is valid.
+        tag_category (str): The category under which this tag type falls.
+        STID_tag_Count (int): The number of STID tags associated with this tag type.
+    """
+
+    def __init__(self, data: dict, inst_code: str):
+        """
+        Initializes a TagType object with provided data and installation code.
+
+        Parameters:
+            data (dict): Data containing different properties of a tag type.
+            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 = ""
+
+        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"]
+
+    def __str__(self):
+        return f"{self.name} - {self.description}"
+
+    @staticmethod
+    def get_tagtype(name: str, inst_code: str, tag_category: str) -> "TagType":
+        """
+        Retrieve a tag type object based on the name, installation code, and tag category.
+
+        Parameters:
+            name (str): Name of the tag type to retrieve.
+            inst_code (str): Installation code specific to the tag type.
+            tag_category (str): Category to which the tag type belongs.
+
+        Returns:
+            TagType: The TagType object matching the criteria.
+        """
+        t = TagCategory.get_category(inst_code=inst_code, name=tag_category)
+        return t[0].get_type(name)
+
+    @staticmethod
+    def get_tagtype_no_cache(
+        name: str, inst_code: str, tag_category: str = ""
+    ) -> "TagType":
+        """
+        Retrieve tag types for the given name and installation code without using the cache. Optionally filter by tag category.
+
+        Parameters:
+            name (str): The name of the tag type to retrieve.
+            inst_code (str): Installation code specific to the tag type.
+            tag_category (str, optional): Optional category to filter the tag types.
+
+        Returns:
+            List[TagType]: A list of TagType objects matching the criteria.
+        """
+
+        params = {}
+        params["scope"] = inst_code
+        params["name"] = name
+
+        tag_types = [
+            TagType(x, inst_code=inst_code)
+            for x in get_code_param("TagType", params=params)
+        ]
+
+        if tag_category:
+            tag_types = [x for x in tag_types if x.tag_category == tag_category]
+
+        return tag_types
+
+    @staticmethod
+    def get_master_tagtype(
+        name: str, tag_category: str = "", technology: str = "Oil&Gas"
+    ) -> "TagType":
+        """
+        Retrieve master tag types based on name, category, and technology. If name is empty,
+        sorts by name and returns all. If name is provided, filters by name.
+
+        Parameters:
+            name (str): The name of the master tag type to retrieve. Can be empty to retrieve all.
+            tag_category (str, optional): Category to filter the master tag types. Can be empty to not filter.
+            technology (str, optional): Technology to filter the master tag types, defaults to 'Oil&Gas'.
+
+        Returns:
+            List[TagType]: A list of TagType objects matching the criteria.
+        """
+        return_value = []
+        d = _get_master_type_data()
+        for k in range(0, len(d)):
+            for att in d[k]["attributes"]:
+                if att["definitionName"] == "Technology":
+                    currTechnology = att["displayValue"]
+                    break
+
+            include_technology = (
+                technology is None
+                or len(technology) == 0
+                or currTechnology == technology
+            )
+
+            include_category = tag_category is None or len(tag_category) == 0
+            if not include_category:
+                for att in d[k]["attributes"]:
+                    if (
+                        att["definitionName"] == "TagCategory"
+                        and att["displayValue"] == tag_category
+                    ):
+                        include_category = True
+                        break
+
+            if include_category and include_technology:
+                return_value.append(TagType(d[k], currTechnology))
+
+        if not name:
+            return_value.sort(key=lambda x: x.name)
+        else:
+            return_value = [x for x in return_value if x.name == name]
+
+        return return_value
+
+    @staticmethod
+    def get_master_tagtype_mappings(
+        name: str, tag_category: str = "", technology: str = "Oil&Gas"
+    ):
+        """
+        Retrieve mappings of the master tag types based on name, category,
+        and technology. Raises a ValueError if no relevant mappings are found
+        or if more than one master tag type is matching name, tag category and technology input.
+
+        Parameters:
+            name (str): The name of the master tag type to search for mappings.
+            tag_category (str, optional): Category to filter the tag type mappings. Can be empty to not filter.
+            technology (str, optional): Technology to filter the tag type mappings, defaults to 'Oil&Gas'.
+
+        Returns:
+            List: A list of mapped tag types.
+
+        Raises:
+            ValueError: If no master tag type is found, or if multiple master tag types are found.
+        """
+        mtt = TagType.get_master_tagtype(
+            name=name, tag_category=tag_category, technology=technology
+        )
+
+        if len(mtt) == 0:
+            raise ValueError("No master tag type found")
+
+        if len(mtt) > 1:
+            raise ValueError("Multiple master tag types found. Currently not supported")
+
+        sql = f"""SELECT tt.scope Facility,tt.Name LocalTagType, tt.tagcategory LocalTagCategory FROM MasterTagType mtt 
+                  inner join TagType tt on tt.MasterTagType_ID=mtt.id 
+                  where mtt.tagcategory='{mtt[0].tag_category}' and mtt.Name ='{mtt[0].name}' and mtt.Technology='{mtt[0].inst_code}' and tt.isValid='True'
+                  order by tt.name, tt.scope"""
+
+        res = query_sql(sql=sql)
+        mapped_types = []
+        [
+            mapped_types.extend(
+                TagType.get_tagtype_no_cache(
+                    x["LocalTagType"], x["Facility"], x["LocalTagCategory"]
+                )
+            )
+            for x in res
+        ]
+        return mapped_types
+
+
+class TagCategory:
+    """
+    A class representing a Facility specific category of tag types.
+
+    Attributes:
+        inst_code (str): Installation code for the facilitye the TagCategory is associated with.
+        name (str): Name of the tag category.
+        description (str): Description of the tag category.
+        is_valid (bool): Flag indicating whether the tag category is considered valid.
+        TagCategoryId (int): Unique identifier of the tag category.
+        TagCategoryDlg (str): Additional dialog information associated with the tag category.
+        IndividFlag (str): A flag indicating individual characteristics for the category.
+        SapFlCategory (str): Corresponding SAP functional location category.
+    """
+
+    def __init__(self, data, inst_code):
+        """
+        Initializes a TagCategory object.
+
+        Parameters:
+            data (dict): Data containing different properties of a tag category.
+            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"]
+
+        for attr in self._data["attributes"]:
+            if attr["definitionName"] == "TagCategoryId":
+                self.TagCategoryId = int(attr["displayValue"])
+            elif attr["definitionName"] == "TagCategoryDlg":
+                self.TagCategoryDlg = attr["displayValue"]
+            elif attr["definitionName"] == "IndividFlag":
+                self.IndividFlag = attr["displayValue"]
+            elif attr["definitionName"] == "SapFlCategory":
+                self.SapFlCategory = attr["displayValue"]
+
+        self._types = []
+        self._formats = []
+
+    def get_formats(self) -> List[TagFormat]:
+        """Get tag formats for this specific tag category.
+
+        Returns:
+            List[TagType]: List of TagFormat objects belonging to this category.
+        """
+        if self._formats is None or len(self._formats) == 0:
+            tag_formats = [
+                TagFormat(x, self.inst_code) for x in _get_format_data(self.inst_code)
+            ]
+            self._formats = [x for x in tag_formats if x.tag_category == self.name]
+
+        return self._formats
+
+    def get_format(self, description: str) -> TagFormat:
+        """Get single tag format for this specific tag category.
+
+        Args:
+            format (str): Description (name) of tag format.
+
+        Returns:
+            TagFormat: Tag format object
+        """
+        for curr_type in self.get_formats():
+            if curr_type.description == description:
+                return curr_type
+
+        return None
+
+    def get_types(self) -> List[TagType]:
+        """Get tag types for this specific tag category.
+
+        Returns:
+            List[TagType]: List of TagType objects belonging to this category.
+        """
+        if self._types is None or len(self._types) == 0:
+            tag_types = [
+                TagType(x, self.inst_code) for x in _get_type_data(self.inst_code)
+            ]
+            self._types = [x for x in tag_types if x.tag_category == self.name]
+            self._types.sort(key=lambda x: x.name)
+
+        return self._types
+
+    def get_type(self, type: str) -> Union[TagType, None]:
+        """Get single type from this specific tag category.
+
+        Args:
+            type (str): Type name
+
+        Returns:
+            Union[TagType, None]: TagType if found, else None.
+        """
+        for curr_type in self.get_types():
+            if curr_type.name == type:
+                return curr_type
+
+        return None
+
+    def __str__(self):
+        return f"{self.TagCategoryId}:{self.name} - {self.description}"
+
+    @staticmethod
+    def get_category(inst_code, name="") -> List["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)
+        if name is None:
+            pass
+        elif isinstance(name, str) and len(name) > 0:
+            tc = [x for x in tc if x.name == name or x.description == name]
+
+        return tc
+
+
+def _get_category_data(inst_code) -> List[dict]:
+    """Get code table of tag categories for a facility from commonlibapi.
+
+    Args:
+        inst_code (str): STID installation code.
+
+    Returns:
+        List[dict]: Data for each tag category.
+    """
+    global _cache
+
+    if inst_code not in _cache["TagCategory"].keys():
+        _cache["TagCategory"][inst_code] = get_code("TagCategory", scope=inst_code)
+
+    return _cache["TagCategory"][inst_code]
+
+
+def _get_type_data(inst_code: str) -> List[dict]:
+    """Get code table of tag types for an installation from commonlibapi.
+
+    Args:
+        inst_code (str): STID installation code.
+
+    Returns:
+        List[dict]: Data for each tag type.
+    """
+    global _cache
+
+    if inst_code not in _cache["TagType"].keys():
+        _cache["TagType"][inst_code] = get_code("TagType", scope=inst_code)
+
+    return _cache["TagType"][inst_code]
+
+
+def _get_master_type_data(scope="") -> List[dict]:
+    """Get code table of master tag types from commonlibapi.
+
+    Returns:
+        List[dict]: Data for each tag type.
+    """
+    global _cache
+
+    if "MasterTagType" not in _cache.keys():
+        _cache["MasterTagType"] = get_code("MasterTagType")
+
+    return _cache["MasterTagType"]
+
+
+def _get_format_data(inst_code: str) -> List[dict]:
+    """Get code table of tag formats for an installation from commonlibapi.
+
+    Args:
+        inst_code (str): STID installation code.
+
+    Returns:
+        List[dict]: Data for each format.
+    """
+    global _cache
+
+    if inst_code not in _cache["TagFormat"].keys():
+        _cache["TagFormat"][inst_code] = get_code("TagFormat", scope=inst_code)
+
+    return _cache["TagFormat"][inst_code]

commonlib_reader/unit.py

@@ -0,0 +1,44 @@
+from commonlib_reader.utils import get_code
+
+# from commonlib_reader.utils import attributes_list_to_dict
+
+
+class Unit:
+    _units = []
+
+    def __init__(self, data):
+        self.name = ""
+        self.description = ""
+
+        self.identity = ""
+        self.quantity = ""
+
+        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
+            # 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])
+
+    @classmethod
+    def get_units(cls):
+        """Get list of Unit objects of entries in code library. Caches locally in memory.
+
+        Returns:
+            List[IMS]: list of Unit objects from entries in code library.
+        """
+        if cls._units is None or len(cls._units) == 0:
+            cls._units = get_code("UnitOfMeasure")
+
+        return [Unit(x) for x in cls._units]

commonlib_reader/utils.py

@@ -0,0 +1,139 @@
+import json
+from typing import Dict, List
+from urllib.parse import urljoin
+
+import requests
+from msal_bearer.BearerAuth import BearerAuth, get_login_name
+
+
+def get_library_names():
+    url = urljoin(get_api_url(), "api/Library/NameList")
+    library_names = get_json(url=url)
+    library_names.sort()
+    return library_names
+
+
+def get_disciplines():
+    return get_code("Discipline")
+
+
+def get_code(code: str, scope: str = None, name: str = None):
+    params = {}
+    if scope is not None:
+        params["scope"] = scope
+
+    if name is not None:
+        params["name"] = name
+    return get_code_param(code=code, params=params)
+
+
+def get_code_param(code, params=None):
+    if params is None:
+        params = {}
+
+    url = urljoin(get_api_url(), f"api/Code/{code}")
+    return get_json(url, params=params)
+
+
+def query_sql(sql: str):
+    return post_sql(sql=sql, take=0, skip=0)
+
+
+def get_api_url() -> str:
+    """Get base url to api
+
+    Returns:
+        str: Base url to api
+    """
+    return "https://commonlibapi.equinor.com/"
+
+
+def get_auth() -> BearerAuth:
+    """Get Bearerauth object including token for accessing api.
+
+    Returns:
+        BearerAuth: Object with access token for api.
+    """
+    tenantID = "3aa4a235-b6e2-48d5-9195-7fcf05b459b0"
+    clientID = "728cfddd-b8e9-4ed7-b9a3-8f2fd5b8e79a"
+    scopes = ["37d598fc-da0f-46bd-949f-7107918d47a5/user_impersonation"]
+    auth = BearerAuth.get_auth(
+        tenantID=tenantID,
+        clientID=clientID,
+        scopes=scopes,
+        username=f"{get_login_name()}@equinor.com",
+    )
+
+    return auth
+
+
+def get_json(url: str, params=None) -> list:
+    """Get json from api endpoint
+
+    Args:
+        url (str): Url to api endpoint to get.
+        params (dict, optional): Dictionary of parameters to pass. Defaults to None.
+
+    Returns:
+        list: List of response from api
+    """
+    response = requests.get(url, auth=get_auth(), params=params)
+    # response.raise_for_status()
+    if response.status_code == 200:
+        try:
+            return response.json()
+        except json.JSONDecodeError:
+            print(
+                f"Warning: {str(url)} returned successfully, but not with a valid json response"
+            )
+    else:
+        print(f"Warning: {str(url)} returned status code {response.status_code}")
+
+    return []
+
+
+def post_sql(sql: str, take: int = 100, skip: int = 0) -> list:
+    """Get json from api/sql endpoint accepting sql queries.
+
+    Args:
+        sql (str): SQL query to run
+        take (int, optional): Number of results to return. Defaults to 100.
+        skip (int, optional): Number of results to skip. Defaults to 0.
+
+    Returns:
+        list: List of response from api
+    """
+    url = urljoin(get_api_url(), "api/sql")
+    response = requests.post(
+        url=url, json={"query": sql, "take": take, "skip": skip}, auth=get_auth()
+    )
+    if response.status_code == 200:
+        try:
+            return response.json()
+        except json.JSONDecodeError:
+            print(
+                f"Warning: {str(url)} returned successfully, but not with a valid json response"
+            )
+    else:
+        print(f"Warning: {str(url)} returned status code {response.status_code}")
+
+    return []
+
+
+def attributes_list_to_dict(attribute_list: List[Dict]) -> Dict:
+    """Convert list of attributes typically returned from commonlib to a normal dictionary.
+
+    Args:
+        attribute_list (List[Dict]): List of attributes
+
+    Returns:
+        Dict: Dictionary with attribute definitionName as keys.
+    """
+    d = {}
+    for r in attribute_list:
+        try:
+            d[r["definitionName"]] = r["displayValue"]
+        except:
+            pass
+
+    return d

commonlib_reader-1.0.0.dist-info/METADATA

@@ -0,0 +1,39 @@
+Metadata-Version: 2.1
+Name: commonlib-reader
+Version: 1.0.0
+Summary: Reader for Equinor commonlibapi.
+Home-page: https://github.com/equinor/commonlib-reader.git
+Author: Åsmund Våge Fannemel
+Author-email: asmf@equinor.com
+Requires-Python: >=3.9,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: msal_bearer (>0.2.1)
+Requires-Dist: pandas (>=2.1.4,<3.0.0)
+Requires-Dist: requests (>=2.31.0,<3.0.0)
+Project-URL: Repository, https://github.com/equinor/commonlib-reader.git
+Description-Content-Type: text/markdown
+
+# commonlib-python
+Connector package for Equinor Commonlib api. Used for getting code tables.
+
+Some additional functionality for asset specific Tag categories and tag types is also included.
+
+## Use
+Try it out by running the [demo](examples/demo.py).
+
+## Installing
+
+Install package from pypi using `pip install commonlib_reader`
+
+
+## Developing / testing
+
+Poetry is preferred for developers. Clone and install with required packages for testing and coverage:  
+`poetry install`
+
+For testing with coverage run:  
+`poetry run pytest --cov --cov-report=html`

commonlib_reader-1.0.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+commonlib_reader/__init__.py,sha256=tpUVIRqbBqlyWj8iqxnUCzrpLr63OKB89fcwCogCk20,434
+commonlib_reader/facility.py,sha256=V2XCUi_2gfZSiiUtA3ll9_15NXrWJeDcUq0Ux3l5S6Y,3486
+commonlib_reader/ims.py,sha256=qyHBS9ar-e-6IPoldE-almAOsBMamgkf86EGya7tK9Q,3600
+commonlib_reader/tag.py,sha256=x8OEQJ0XpLiixCZOz_0zp6hh513byAzxNr5HQFjNzQc,15543
+commonlib_reader/unit.py,sha256=NDIJA2A2m7ZzsKUmza5EQLZQQXhHW9p_DzYUrPhu3OY,1346
+commonlib_reader/utils.py,sha256=sjYYI8HpmFCYyMQ1nEMsBMBsODdicdSZkxNDJ_VBdO8,3685
+commonlib_reader-1.0.0.dist-info/METADATA,sha256=Yz7L0aH1XjV5Ifeug6-OVbMKALoVGAUYx-hh2f0Ea-w,1290
+commonlib_reader-1.0.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+commonlib_reader-1.0.0.dist-info/RECORD,,

commonlib_reader-1.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 1.9.0
+Root-Is-Purelib: true
+Tag: py3-none-any