tagreader 6.2.1__tar.gz → 6.3.0__tar.gz

{tagreader-6.2.1 → tagreader-6.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tagreader
-Version: 6.2.1
+Version: 6.3.0
 Summary: Tagreader is a Python package for reading trend data from the OSIsoft PI and Aspen Infoplus.21 IMS systems.
 License-Expression: MIT
 License-File: LICENSE
@@ -25,7 +25,7 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Utilities
 Requires-Dist: certifi (>=2024.12.14,<2026.0.0)
 Requires-Dist: diskcache (>=5.6.1)
-Requires-Dist: msal-bearer (>=1.3.3)
+Requires-Dist: msal-bearer (>=1.5.2)
 Requires-Dist: pandas (>=1)
 Requires-Dist: platformdirs (>=4.3.7)
 Requires-Dist: pycryptodome (>=3.20.0)

{tagreader-6.2.1 → tagreader-6.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tagreader"
-version = "6.2.1"
+version = "6.3.0"
 description = "Tagreader is a Python package for reading trend data from the OSIsoft PI and Aspen Infoplus.21 IMS systems."
 authors = [
     { name = "Einar S. Idsø", email = "eiids@equinor.com" },
@@ -32,7 +32,7 @@ dependencies = [
     "certifi>=2024.12.14,<2026.0.0",
     "requests>=2.32.5",
     "requests-kerberos>=0",
-    "msal-bearer>=1.3.3",
+    "msal-bearer>=1.5.2",
     "diskcache>=5.6.1",
     "pycryptodome>=3.20.0",
     "requests-ntlm>=1.1,<=2.0",

{tagreader-6.2.1 → tagreader-6.3.0}/tagreader/clients.py

@@ -159,11 +159,11 @@ def get_handler(
 
     if imstype == IMSType.PIWEBAPI:
         return PIHandlerWeb(
-            url=url,
             datasource=datasource,
-            options=options,
-            verify_ssl=verify_ssl,
+            url=url,
             auth=auth,
+            verify_ssl=verify_ssl,
+            options=options,
             cache=cache,
         )
 
@@ -365,7 +365,7 @@ class IMSClient:
                                 end=end,
                             )
                     frames.append(df)
-                    if len(df) < self.handler._max_rows:
+                    if len(df) < self.handler.max_rows:
                         break
                     start = df.index[-1]
 

{tagreader-6.2.1 → tagreader-6.3.0}/tagreader/web_handlers.py

@@ -86,17 +86,11 @@ def get_url_aspen(use_internal: bool = True) -> str:
     return r"https://ewepwapa1pep04-statoilsrm.msappproxy.net/ProcessExplorer/ProcessData/AtProcessDataREST.dll"
 
 
-def list_aspenone_sources(
-    url: Optional[str] = None,
-    auth: Optional[Any] = None,
-    verify_ssl: Optional[Union[bool, str]] = True,
+def _fetch_aspenone_sources(
+    url: str,
+    auth: Any,
+    verify_ssl: Optional[Union[bool, str]],
 ) -> List[str]:
-    if url is None:
-        url = get_url_aspen()
-
-    if auth is None:
-        auth = get_auth_aspen()
-
     if verify_ssl is None:
         verify_ssl = get_verify_ssl()
 
@@ -117,17 +111,35 @@ def list_aspenone_sources(
     return []
 
 
-def list_piwebapi_sources(
+# Keyed on url only so default-auth calls share the cache regardless of auth or verify_ssl.
+_aspenone_sources_cache: Dict[str, List[str]] = {}
+
+
+def list_aspenone_sources(
     url: Optional[str] = None,
     auth: Optional[Any] = None,
     verify_ssl: Optional[Union[bool, str]] = True,
 ) -> List[str]:
     if url is None:
-        url = get_url_pi()
+        url = get_url_aspen()
 
-    if auth is None:
-        auth = get_auth_pi()
+    if auth is not None:
+        return _fetch_aspenone_sources(url, auth, verify_ssl)
 
+    if url not in _aspenone_sources_cache:
+        url_sources = _fetch_aspenone_sources(url, get_auth_aspen(), verify_ssl)
+        if len(url_sources) > 0:
+            _aspenone_sources_cache[url] = url_sources
+        else:
+            return []
+    return list(_aspenone_sources_cache[url])
+
+
+def _fetch_piwebapi_sources(
+    url: str,
+    auth: Any,
+    verify_ssl: Optional[Union[bool, str]],
+) -> List[str]:
     if verify_ssl is None:
         verify_ssl = get_verify_ssl()
 
@@ -147,6 +159,28 @@ def list_piwebapi_sources(
     return []
 
 
+# Keyed on url only so default-auth calls share the cache regardless of auth or verify_ssl.
+_piwebapi_sources_cache: Dict[str, List[str]] = {}
+
+
+def list_piwebapi_sources(
+    url: Optional[str] = None,
+    auth: Optional[Any] = None,
+    verify_ssl: Optional[Union[bool, str]] = True,
+) -> List[str]:
+    if url is None:
+        url = get_url_pi()
+
+    if auth is not None:
+        return _fetch_piwebapi_sources(url, auth, verify_ssl)
+
+    if url not in _piwebapi_sources_cache:
+        url_sources = _fetch_piwebapi_sources(url, get_auth_pi(), verify_ssl)
+        if len(url_sources) > 0:
+            _piwebapi_sources_cache[url] = url_sources
+    return list(_piwebapi_sources_cache[url])
+
+
 def get_piwebapi_source_to_webid_dict(
     url: Optional[str] = None,
     auth: Optional[Any] = None,
@@ -186,6 +220,7 @@ class BaseHandlerWeb(ABC):
     ):
         self.datasource = datasource
         self.base_url = url
+        self.max_rows = 10000
         self.session = requests.Session()
         self.auth = auth
         self.session.auth = auth if auth is not None else get_auth_aspen()
@@ -193,20 +228,66 @@ class BaseHandlerWeb(ABC):
             urllib3.disable_warnings(InsecureRequestWarning)
         self.session.verify = verify_ssl if verify_ssl is not None else get_verify_ssl()
 
+    @property
+    def datasource(self) -> str:
+        return self._datasource
+
+    @datasource.setter
+    def datasource(self, value: Optional[str]) -> None:
+        self._datasource = value if value is not None else ""
+
+    @property
+    def base_url(self) -> str:
+        return self._base_url
+
+    @base_url.setter
+    def base_url(self, value: Optional[str]) -> None:
+        self._base_url = value if value is not None else ""
+
+    @property
+    def max_rows(self) -> int:
+        return self._max_rows
+
+    @max_rows.setter
+    def max_rows(self, value: int) -> None:
+        self._max_rows = value
+
     def fetch(
         self,
         url,
-        params: Optional[Union[str, Dict[str, str]]] = None,
+        params: Optional[Union[bytes, str, Dict[str, str]]] = None,
         timeout: Optional[int] = None,
+        use_post: bool = False,
     ) -> Dict:
-        res = self.session.get(
-            url,
-            params=params,
-            timeout=(
-                None,
-                timeout,
-            ),
-        )  # Noqa. Read timeout, No connect timeout.
+        if use_post:
+            headers = {}
+            if isinstance(params, dict):
+                params = urllib.parse.urlencode(
+                    params, safe="*", quote_via=urllib.parse.quote
+                ).encode("utf-8")
+                headers["Content-Type"] = (
+                    "application/x-www-form-urlencoded; charset=utf-8"
+                )
+            elif isinstance(params, str):
+                params = params.encode("utf-8")
+                headers["Content-Type"] = "text/xml; charset=utf-8"
+
+            res = self.session.post(
+                url,
+                data=params,
+                headers=headers,
+                timeout=(None, timeout),
+            )
+        else:
+            res = self.session.get(
+                url,
+                params=params,
+                timeout=(
+                    None,
+                    timeout,
+                ),
+            )  # Noqa. Read timeout, No connect timeout.
+
         res.raise_for_status()
 
         if len(res.text) == 0:
@@ -228,15 +309,18 @@ class BaseHandlerWeb(ABC):
             return json.loads(txt)
 
     def connect(self):
+        if self.datasource == "":
+            raise ValueError("Datasource must be specified")
+
         try:
             self.verify_connection(self.datasource)
         except requests.ConnectionError:
             raise ConnectionError(
-                f"Not able to connect to {self.base_url}. Check network connection."
+                f"Not able to connect to api at {self.base_url}. Check network connection."
             ) from None
 
     @abstractmethod
-    def verify_connection(self, datasource: str): ...
+    def verify_connection(self, datasource: str) -> bool: ...
 
 
 class AspenHandlerWeb(BaseHandlerWeb):
@@ -248,7 +332,7 @@ class AspenHandlerWeb(BaseHandlerWeb):
         verify_ssl: Optional[Union[bool, str]] = True,
         options: Dict[str, Any] = dict(),
     ):
-        if url is None:
+        if url is None or url == "":
             url = get_url_aspen()
         if auth is None:
             auth = get_auth_aspen()
@@ -259,7 +343,7 @@ class AspenHandlerWeb(BaseHandlerWeb):
             auth=auth,
             verify_ssl=verify_ssl,
         )
-        self._max_rows = options.get("max_rows", 100000)
+        self.max_rows = int(options.get("max_rows", 100000))
         self._connection_string = ""  # Used for raw SQL queries
 
     @staticmethod
@@ -271,6 +355,7 @@ class AspenHandlerWeb(BaseHandlerWeb):
     ) -> Dict[str, Any]:
         if not datasource:
             raise ValueError("Data source is required argument")
+
         # Aspen Web API expects single space instead of consecutive spaces.
         tag = " ".join(tag.split())
         params = {"datasource": datasource, "tag": tag, "max": max, "getTrendable": 0}
@@ -338,7 +423,7 @@ class AspenHandlerWeb(BaseHandlerWeb):
                 f"<RT>{rt}</RT>"
             )
         if read_type in [ReaderType.RAW, ReaderType.SHAPEPRESERVING]:
-            query += f"<X>{self._max_rows}</X>"
+            query += f"<X>{self.max_rows}</X>"
         if read_type not in [ReaderType.INT, ReaderType.SNAPSHOT]:
             query += f"<O>{outsiders}</O>"
         if read_type not in [ReaderType.RAW]:
@@ -372,7 +457,7 @@ class AspenHandlerWeb(BaseHandlerWeb):
 
         return query
 
-    def verify_connection(self, datasource: str):
+    def verify_connection(self, datasource: str) -> bool:
         """Connects to the URL and verifies that the provided data source exists.
 
         :param datasource: Data source to look for
@@ -429,7 +514,7 @@ class AspenHandlerWeb(BaseHandlerWeb):
     def _get_maps(self, tagname: str):
         params = self.generate_get_map_query(tagname)
         url = urljoin(self.base_url, "TagInfo")
-        data = self.fetch(url, params=params)
+        data = self.fetch(url, params=params, use_post=not tagname.isascii())
 
         if "tags" not in data["data"]:
             return {}
@@ -457,18 +542,12 @@ class AspenHandlerWeb(BaseHandlerWeb):
     ) -> Union[List[Tuple[str, str]], List[str]]:
         ret = []
 
-        if tag is None and desc is None:
-            raise ValueError("Tag is a required argument")
-            # return ret
-        elif tag is None and len(desc) == 0:
-            raise ValueError("Tag is a required argument")
-            # return ret
-        elif desc is None and len(tag) == 0:
-            raise ValueError("Tag is a required argument")
-            # return ret
+        # Currently not possible to search only using description.
+        if not tag:
+            raise ValueError("Input tag is a required argument")
 
-        if tag is None:
-            raise ValueError("Tag is a required argument")
+        if not tag and not desc:
+            raise ValueError("Either tag or desc must be provided.")
 
         tag = tag.replace("%", "*") if isinstance(tag, str) else None
         # Prepare for regex
@@ -518,7 +597,7 @@ class AspenHandlerWeb(BaseHandlerWeb):
     def _get_tag_unit(self, tag: str):
         query = self.generate_get_unit_query(tag)
         url = urljoin(self.base_url, "TagInfo")
-        data = self.fetch(url, params=query)
+        data = self.fetch(url, params=query, use_post=not tag.isascii())
         # try:
         attr_data = data["data"]["tags"][0]["attrData"]
         # except KeyError as e:
@@ -553,7 +632,7 @@ class AspenHandlerWeb(BaseHandlerWeb):
         query = self.generate_get_description_query(tag)
         url = urljoin(self.base_url, "TagInfo")
         try:
-            data = self.fetch(url, params=query)
+            data = self.fetch(url, params=query, use_post=not tag.isascii())
             desc = data["data"]["tags"][0]["attrData"][0]["samples"][0]["v"]
         # except KeyError:
         #     desc = ""
@@ -570,6 +649,7 @@ class AspenHandlerWeb(BaseHandlerWeb):
         read_type: ReaderType,
         metadata: Optional[Dict[str, str]],
         get_status: bool = False,
+        use_post: bool = False,
     ):
         if read_type not in [
             ReaderType.INT,
@@ -597,9 +677,13 @@ class AspenHandlerWeb(BaseHandlerWeb):
         # so we need to limit the range. Note -1 because INT normally includes
         # both start and end time.
         if read_type == ReaderType.INT:
-            end = min(end, start + sample_time * (self._max_rows - 1))
+            end = min(end, start + sample_time * (self.max_rows - 1))
 
         tag_name, map_name = self.split_tagmap(tag)
+        if tag_name is None or len(tag_name) == 0:
+            raise ValueError(f"Input tag: {tag} returns no tag_name. Invalid input.")
+        if map_name is None:
+            map_name = ""
 
         params = self.generate_read_query(
             tagname=tag_name,
@@ -611,15 +695,29 @@ class AspenHandlerWeb(BaseHandlerWeb):
             metadata={},
         )
 
-        data = self.fetch(url, params=params)
+        # Consider use_post = use_post or not tag.isascii()
+        data = self.fetch(url, params=params, use_post=use_post)
 
         if len(data) == 0:  # Normally for timestamps in future
             return pd.DataFrame(columns=[tag])
 
         if "er" in data["data"][0]["samples"][0]:
+            if not use_post and data["data"][0]["samples"][0]["er"] == 5:
+                return self.read_tag(
+                    tag=tag,
+                    start=start,
+                    end=end,
+                    sample_time=sample_time,
+                    read_type=read_type,
+                    metadata=metadata,
+                    get_status=get_status,
+                    use_post=True,
+                )
+
             logger.warning(
                 f"API error for {tag}: {data['data'][0]['samples'][0]['es']} params: {params}"
             )
+
             return pd.DataFrame(columns=[tag])
         if get_status:
             # The "l" field maps 1:1 to ODBC status field values 0, 1, 2, 4, 5, 6
@@ -645,12 +743,17 @@ class AspenHandlerWeb(BaseHandlerWeb):
 
     @staticmethod
     def generate_sql_query(
-        connection_string: Optional[str],
-        datasource: Optional[str],
-        query: Optional[str],
+        query: str,
+        connection_string: Optional[str] = None,
+        datasource: Optional[str] = None,
         max_rows: int = 100000,
-    ):
-        if connection_string is not None:
+    ) -> str:
+        if not query:
+            raise ValueError("Query must not be empty")
+
+        if not connection_string and not datasource:
+            raise ValueError("Either connection_string or datasource must be provided")
+        if connection_string:
             connection_string = (
                 f'<SQL c="{connection_string}" m="{max_rows}" to="30" s="1">'
             )
@@ -660,31 +763,20 @@ class AspenHandlerWeb(BaseHandlerWeb):
                 'dso="CHARINT=N;CHARFLOAT=N;CHARTIME=N;CONVERTERRORS=N" '
                 f'm="{max_rows}" to="30" s="1">'
             )
-        query = query.replace("\t", " ").replace(
-            "\n", " "
-        )  # Replace new lines and tabs that are typical in formatted SQL queries with spaces.
-
+        # Replace new lines and tabs that are typical in formatted SQL queries with spaces.
+        query = query.replace("\t", " ").replace("\n", " ")
         # Need a solution to LIKE comments. These have a % symbol in the query that does not seem to pass through the request
-
         connection_string += f"<![CDATA[{query}]]></SQL>"
         return connection_string
 
     def query_sql(self, query: str, parse: bool = True) -> Union[str, pd.DataFrame]:
         url = urljoin(self.base_url, "SQL")
-        if self._connection_string is None:
-            params = self.generate_sql_query(
-                datasource=self.datasource,
-                query=query,
-                max_rows=self._max_rows,
-                connection_string=None,
-            )
-        else:
-            params = self.generate_sql_query(
-                connection_string=self._connection_string,
-                query=query,
-                max_rows=self._max_rows,
-                datasource=None,
-            )
+        params = self.generate_sql_query(
+            query=query,
+            connection_string=self._connection_string,
+            datasource=self.datasource,
+            max_rows=self.max_rows,
+        )
 
         res = self.session.get(url, params=params)
         res.raise_for_status()
@@ -711,15 +803,14 @@ class AspenHandlerWeb(BaseHandlerWeb):
 class PIHandlerWeb(BaseHandlerWeb):
     def __init__(
         self,
-        url: Optional[str],
         datasource: Optional[str],
+        url: Optional[str],
         auth: Optional[Any],
         verify_ssl: Optional[Union[bool, str]],
         options: Dict[str, Union[int, float, str]],
         cache: Optional[Union[SmartCache, BucketCache]],
     ):
-        self._max_rows = options.get("max_rows", 10000)
-        if url is None:
+        if url is None or url == "":
             url = get_url_pi()
         if auth is None:
             auth = get_auth_pi()
@@ -729,7 +820,7 @@ class PIHandlerWeb(BaseHandlerWeb):
             auth=auth,
             verify_ssl=verify_ssl,
         )
-        self._max_rows = options.get("max_rows", 10000)
+        self.max_rows = int(options.get("max_rows", 10000))
         self.web_id_cache = cache
 
     @staticmethod
@@ -779,7 +870,7 @@ class PIHandlerWeb(BaseHandlerWeb):
         query = " AND ".join(q)
         params = {"query": f"{query}"}
 
-        if datasource is not None:
+        if isinstance(datasource, str) and len(datasource) > 0:
             params["dataserverwebid"] = (
                 f"{get_piwebapi_source_to_webid_dict(auth=auth)[datasource]}"
             )
@@ -806,6 +897,9 @@ class PIHandlerWeb(BaseHandlerWeb):
         ]:
             raise NotImplementedError
 
+        if not tag:
+            raise ValueError("Tag must be provided.")
+
         web_id = tag
 
         seconds = 0
@@ -818,7 +912,6 @@ class PIHandlerWeb(BaseHandlerWeb):
             ReaderType.SNAPSHOT: "value",
             ReaderType.SHAPEPRESERVING: "plot",
         }.get(read_type, "summary")
-
         url = f"streams/{web_id}/{get_action}"
         params = {}
 
@@ -865,7 +958,7 @@ class PIHandlerWeb(BaseHandlerWeb):
                 params["selectedFields"] += ";Good;Questionable;Substituted"
 
         if read_type == ReaderType.RAW:
-            params["maxCount"] = self._max_rows
+            params["maxCount"] = self.max_rows
 
         return url, params