tagmapper 0.2.2__tar.gz

tagmapper-0.2.2/PKG-INFO

@@ -0,0 +1,45 @@
+Metadata-Version: 2.1
+Name: tagmapper
+Version: 0.2.2
+Summary: Python wrapper for sql tag mapping database
+Author: Åsmund Våge Fannemel
+Author-email: 34712686+asmfstatoil@users.noreply.github.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: azure-identity (>=1.17.1,<2.0.0)
+Requires-Dist: msal-bearer (>0.2.1,<2.0.0)
+Requires-Dist: pandas (>=2.2.2,<3.0.0)
+Requires-Dist: pyodbc (>=5.1.0,<6.0.0)
+Requires-Dist: sqlalchemy (>=2.0.28,<3.0.0)
+Description-Content-Type: text/markdown
+
+# tagmapper-sdk
+Prototype python package to get IMS-tag mappings for data models for separators and wells.
+
+Authentication is done using Azure credentials and bearer tokens.
+
+
+## Use
+See (examples/demo_separator.py)[demo]. Or try the following simple code.  
+```
+from tagmapper import Well
+
+
+w = Well("NO 30/6-E-2")  
+```
+
+
+## Installing
+Install from github using pip.  
+``
+pip install git+https://github.com/equinor/tagmapper-sdk.git
+``
+
+
+## Developing
+Clone repo and run ``poetry install``. Tests are run using ``poetry run pytest``.
+

tagmapper-0.2.2/README.md

@@ -0,0 +1,25 @@
+# tagmapper-sdk
+Prototype python package to get IMS-tag mappings for data models for separators and wells.
+
+Authentication is done using Azure credentials and bearer tokens.
+
+
+## Use
+See (examples/demo_separator.py)[demo]. Or try the following simple code.  
+```
+from tagmapper import Well
+
+
+w = Well("NO 30/6-E-2")  
+```
+
+
+## Installing
+Install from github using pip.  
+``
+pip install git+https://github.com/equinor/tagmapper-sdk.git
+``
+
+
+## Developing
+Clone repo and run ``poetry install``. Tests are run using ``poetry run pytest``.

tagmapper-0.2.2/pyproject.toml

@@ -0,0 +1,25 @@
+[tool.poetry]
+name = "tagmapper"
+version = "0.2.2"
+description = "Python wrapper for sql tag mapping database"
+authors = ["Åsmund Våge Fannemel <34712686+asmfstatoil@users.noreply.github.com>"]
+readme = "README.md"
+
+[tool.poetry.dependencies]
+python = "^3.9,<4.0"
+msal-bearer = ">0.2.1,<2.0.0"
+# urllib3 = [
+#     { version = "<2.0.0", markers = "sys_platform=='linux'" }, # FIX for use with RHEL7 environments
+# ]
+pyodbc = "^5.1.0"
+pandas = "^2.2.2"
+sqlalchemy = "^2.0.28"
+azure-identity = "^1.17.1"
+
+[tool.poetry.group.dev.dependencies]
+pytest = "^7.0.0"
+black = "^24.1.1"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"

tagmapper-0.2.2/tagmapper/__init__.py

@@ -0,0 +1,5 @@
+from .attribute import Attribute
+from .separator import Separator
+from .well import Well
+
+__all__ = ["Attribute", "Separator", "Well"]

tagmapper-0.2.2/tagmapper/attribute.py

@@ -0,0 +1,29 @@
+class Attribute:
+    """
+    Attribute class
+    """
+
+    def __init__(self, data):
+        if not isinstance(data, dict):
+            raise ValueError("Input data must be a dict")
+
+        self.name = ""
+        if "attribute_name" in data.keys():
+            self.name = data["attribute_name"]
+        elif "Attribute_Name" in data.keys():
+            self.name = data["Attribute_Name"]
+
+        self.tag = ""
+        if "TAG_ID" in data.keys():
+            self.tag = data["TAG_ID"]
+        elif "Tag_Id" in data.keys():
+            self.tag = data["Tag_Id"]
+
+        self.source = ""
+        if "source" in data.keys():
+            self.source = data["source"]
+        elif "Attribute_Source_Name" in data.keys():
+            self.source = data["Attribute_Source_Name"]
+
+    def __str__(self):
+        return f"{self.name} : {self.tag}"

tagmapper-0.2.2/tagmapper/connector.py

@@ -0,0 +1,205 @@
+import struct
+from typing import Optional
+from azure.identity import DefaultAzureCredential
+import pandas as pd
+from sqlalchemy import URL, Connection, Engine, create_engine
+from sqlalchemy import text as sql_text
+
+from msal_bearer.BearerAuth import BearerAuth, get_login_name
+
+
+import pyodbc
+
+_engine = None
+_token = ""
+_conn_string = ""
+
+
+def set_token(token: str) -> None:
+    """Setter for global property token.
+
+    Args:
+        token (str): Token to set.
+    """
+    global _token
+    _token = token
+
+
+def get_token() -> str:
+    """Getter for token. Will first see if a global token has been set, then try to get a token using app registration, then last try to get via azure authentication.
+
+    Returns:
+        str: _description_
+    """
+    if _token:
+        return _token
+
+    az_token = get_app_token()
+    if az_token:
+        return az_token
+
+    return get_az_token()
+
+
+def reset_engine() -> None:
+    """Reset cached Engine"""
+    global _engine
+
+    if _engine is not None:
+        _engine.dispose()
+        _engine = None
+
+
+def get_engine(conn_string="", token="", reset=False) -> Engine:
+    """Getter of cached Engine. Will create one if not existing.
+
+    Args:
+        conn_string (str, optional): Connection string for odbc connection. Defaults to "" to support just getting cached engine.
+        token (str, optional): Token string. Defaults to "" to support just getting cached engine.
+        reset (bool, optional): Set true to reset engine, i.e., not get cached engine. Defaults to False.
+    """
+
+    def get_token_struct(token: str) -> bytes:
+        """Convert token string to token byte struct for use in connection string
+
+        Args:
+            token (str): Token as string
+
+        Returns:
+            (bytes): Token as bytes
+        """
+        tokenb = bytes(token, "UTF-8")
+        exptoken = b""
+        for i in tokenb:
+            exptoken += bytes({i})
+            exptoken += bytes(1)
+
+        tokenstruct = struct.pack("=i", len(exptoken)) + exptoken
+
+        return tokenstruct
+
+    global _engine
+
+    if not conn_string == _conn_string:
+        reset = True
+
+    if token == "":
+        token = get_token()
+
+    if reset:
+        reset_engine()
+
+    if _engine is None and isinstance(conn_string, str) and len(conn_string) > 0:
+        SQL_COPT_SS_ACCESS_TOKEN = 1256
+        _engine = create_engine(
+            URL.create("mssql+pyodbc", query={"odbc_connect": conn_string}),
+            connect_args={
+                "attrs_before": {SQL_COPT_SS_ACCESS_TOKEN: get_token_struct(token)}
+            },
+        )
+
+    return _engine
+
+
+def get_sql_driver() -> str:
+    """Get name of ODBC SQL driver
+
+    Raises:
+        ValueError: Raised if required ODBC driver is not installed.
+
+    Returns:
+        str: ODBC driver name
+    """
+    drivers = pyodbc.drivers()
+
+    for driver in drivers:
+        if "18" in driver and "SQL Server" in driver:
+            return driver
+
+    for driver in drivers:
+        if "17" in driver and "SQL Server" in driver:
+            return driver
+
+    raise ValueError("ODBC driver 17 or 18 for SQL server is required.")
+
+
+def get_connection_string(
+    server: str, database: str, driver: str = get_sql_driver()
+) -> str:
+    """Build database connection string
+
+    Args:
+        server (str): Server url
+        database (str): Database name
+        driver (str): ODBC driver name. Defaults to get_sql_driver().
+
+    Returns:
+        str: Database connection string
+    """
+    return f"DRIVER={driver};SERVER={server};DATABASE={database};"
+
+
+def get_az_token() -> str:
+    """Getter for token uzing azure authentication.
+
+    Returns:
+        str: Token from azure authentication
+    """
+    credential = DefaultAzureCredential()
+    databaseToken = credential.get_token("https://database.windows.net/")
+    return databaseToken[0]
+
+
+def get_app_token() -> str:
+    """Getter for token using app registration authentication.
+
+    Returns:
+        str: Token from app registration
+    """
+    # SHORTNAME@equinor.com -- short name shall be capitalized
+    username = get_login_name().upper() + "@equinor.com"
+    tenantID = "3aa4a235-b6e2-48d5-9195-7fcf05b459b0"
+    clientID = "5850cfaf-0427-4e96-9813-a7874c8324ae"
+    scope = ["https://database.windows.net/.default"]
+    auth = BearerAuth.get_auth(
+        tenantID=tenantID, clientID=clientID, scopes=scope, username=username
+    )
+    return auth.token
+
+
+def get_connection(database: str = "Lh_Gold", token: str = get_token()) -> Connection:
+    """Get Connection object to database.
+
+    Args:
+        database (str, optional): Name of database. Defaults to "Lh_Gold".
+        token (str, optional): Token string. Defaults to get_token().
+
+    Returns:
+        Connection: Connection object to database
+    """
+    server = "gwrkioxcw3kuremvp7hqlnczwa-bjb35lhdq4oubeecgujfxwyxcu.datawarehouse.fabric.microsoft.com"
+
+    return get_engine(
+        get_connection_string(server=server, database=database), token
+    ).connect()
+
+
+def query(
+    sql: str,
+    connection: Optional[Connection] = None,
+    params: Optional[dict] = None,
+) -> pd.DataFrame:
+    """Query SQL database using pd.read_sql
+
+    Args:
+        sql (str): SQL query for database
+        connection (Optional[Connection], optional): Database Connection object. Defaults to None, which resolves to get_connection().
+        params (Optional[dict], optional): SQL parameters. Defaults to None.
+
+    Returns:
+        pd.DataFrame: Result from pd.read_sql
+    """
+    if connection is None:
+        connection = get_connection()
+
+    return pd.read_sql(sql_text(sql), connection, params=params)

tagmapper-0.2.2/tagmapper/mapped_object.py

@@ -0,0 +1,7 @@
+class Mapped_Object:
+    def __str__(self):
+        s = f"{self.inst_code} - {self.object_name}"
+        for att in self.attributes:
+            s = f"{s}\n{str(att)}"
+
+        return s

tagmapper-0.2.2/tagmapper/separator.py

@@ -0,0 +1,73 @@
+from typing import List
+import pandas as pd
+
+from tagmapper.attribute import Attribute
+from tagmapper.connector import query
+
+
+class Separator:
+    """
+    Separator class
+    """
+
+    _sep_attributes = pd.DataFrame()
+
+    def __init__(self, usi):
+        if isinstance(usi, str):
+            # assume data is USI
+            data = Separator.get_sep_attributes(usi)
+        elif isinstance(usi, pd.DataFrame):
+            data = usi
+
+        if not isinstance(data, pd.DataFrame):
+            raise ValueError("Input data must be a dataframe")
+
+        if data.empty:
+            raise ValueError("Input data can not be empty")
+
+        self.inst_code = data["STID_CODE"].iloc[0]
+        self.object_name = data["OBJECT_NAME"].iloc[0]
+        self.object_code = data["PDM.OBJECT_CODE"].iloc[0]
+        self.usi = data["unique_separator_identifier"].iloc[0]
+
+        self.attributes = []
+        for _, r in data.iterrows():
+            self.attributes.append(Attribute(r.to_dict()))
+
+    @classmethod
+    def get_all_separators(cls) -> List["Separator"]:
+        usi = Separator.get_separator_names()
+        sep = []
+
+        for u in usi:
+            sep.append(Separator(Separator.get_sep_attributes(u)))
+
+        return sep
+
+    @classmethod
+    def get_separator(cls, inst_code: str, tag_no: str) -> "Separator":
+        return Separator(Separator.get_sep_attributes(f"{inst_code}-{tag_no}"))
+
+    @classmethod
+    def get_sep_attributes(cls, usi: str = "") -> pd.DataFrame:
+        if cls._sep_attributes.empty:
+            cls._sep_attributes = query(
+                "select * from [dbo].[separator_attribute_mapping]"
+            )
+
+        if usi:
+            ind = cls._sep_attributes["unique_separator_identifier"] == usi
+            return cls._sep_attributes.loc[ind, :]
+        else:
+            return cls._sep_attributes
+
+    @staticmethod
+    def get_separator_names() -> List[str]:
+        d = Separator.get_sep_attributes()
+        usi = list(d["unique_separator_identifier"].unique())
+        usi.sort()
+        return usi
+
+    @staticmethod
+    def get_usi() -> List[str]:
+        return Separator.get_separator_names()

tagmapper-0.2.2/tagmapper/well.py

@@ -0,0 +1,67 @@
+from typing import List
+import pandas as pd
+
+from tagmapper.attribute import Attribute
+from tagmapper.connector import query
+
+
+class Well:
+    """
+    Well class
+    """
+
+    _well_attributes = pd.DataFrame()
+
+    def __init__(self, uwi):
+        if isinstance(uwi, str):
+            # assume data is UWI
+            data = Well.get_well_attributes(uwi)
+        elif isinstance(uwi, pd.DataFrame):
+            data = uwi
+
+        if not isinstance(data, pd.DataFrame):
+            raise ValueError("Input data must be a dataframe")
+
+        if data.empty:
+            raise ValueError("Input data can not be empty")
+
+        # self.inst_code = data["STID_CODE"].iloc[0]
+        # self.object_name = data["OBJECT_NAME"].iloc[0]
+        # self.object_code = data["PDM.OBJECT_CODE"].iloc[0]
+        self.uwi = data["Pdm_Well_UWI"].iloc[0]
+
+        self.attributes = []
+        for _, r in data.iterrows():
+            self.attributes.append(Attribute(r.to_dict()))
+
+    @classmethod
+    def get_all_wells(cls):
+        uwi = Well.get_uwis()
+        well = []
+
+        for u in uwi:
+            well.append(Well(Well.get_well_attributes(u)))
+
+        return well
+
+    @classmethod
+    def get_well(cls, inst_code: str, tag_no: str):
+        return Well(Well.get_well_attributes(f"{inst_code}-{tag_no}"))
+
+    @classmethod
+    def get_well_attributes(cls, uwi: str = ""):
+        if cls._well_attributes.empty:
+            cls._well_attributes = query("select * from [dbo].[mapped_well_attributes]")
+
+        if uwi:
+            ind = cls._well_attributes["Pdm_Well_UWI"] == uwi
+            return cls._well_attributes.loc[ind, :]
+        else:
+            return cls._well_attributes
+
+    @staticmethod
+    def get_uwis() -> List[str]:
+        d = Well.get_well_attributes()
+        uwi = list(d["Pdm_Well_UWI"].unique())
+        uwi.sort()
+        return uwi