tagreader 6.2.0__tar.gz → 6.3.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tagreader
-Version: 6.2.0
+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)
@@ -37,6 +37,10 @@ Project-URL: Homepage, https://github.com/equinor/tagreader-python
 Project-URL: Repository, https://github.com/equinor/tagreader-python
 Description-Content-Type: text/markdown
 
+⚠️ **Important:** **We are phasing out TagReader, and the code will no longer be maintained.**
+
+  For employees in Equinor we recommend using Omnia Timeseries
+
 # tagreader-python <!-- omit in toc -->
 
 ![GitHub Build Status](https://github.com/equinor/tagreader-python/workflows/Test/badge.svg)
@@ -86,6 +90,3 @@ For more details, see the [Tagreader Docs](https://equinor.github.io/tagreader-p
 ## Documentation
 The full documentation can be found in [Tagreader Docs](https://equinor.github.io/tagreader-python/)
 
-## Contribute
-To starting contributing, please see [Tagreader Docs - Contribute](https://equinor.github.io/tagreader-python/docs/contribute/overview)
-

{tagreader-6.2.0 → tagreader-6.3.0}/README.md

@@ -1,3 +1,7 @@
+⚠️ **Important:** **We are phasing out TagReader, and the code will no longer be maintained.**
+
+  For employees in Equinor we recommend using Omnia Timeseries
+
 # tagreader-python <!-- omit in toc -->
 
 ![GitHub Build Status](https://github.com/equinor/tagreader-python/workflows/Test/badge.svg)
@@ -46,6 +50,3 @@ For more details, see the [Tagreader Docs](https://equinor.github.io/tagreader-p
 
 ## Documentation
 The full documentation can be found in [Tagreader Docs](https://equinor.github.io/tagreader-python/)
-
-## Contribute
-To starting contributing, please see [Tagreader Docs - Contribute](https://equinor.github.io/tagreader-python/docs/contribute/overview)

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

@@ -1,6 +1,6 @@
 [project]
 name = "tagreader"
-version = "6.2.0"
+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.0 → tagreader-6.3.0}/tagreader/cache.py

@@ -1,9 +1,8 @@
-from datetime import datetime, timedelta
+from datetime import datetime, timedelta, timezone
 from pathlib import Path
 from typing import Dict, List, Optional, Tuple, Union, cast
 
 import pandas as pd
-import pytz
 from diskcache import Cache
 
 from tagreader.logger import logger
@@ -21,7 +20,7 @@ def safe_tagname(tagname: str) -> str:
 def timestamp_to_epoch(timestamp: datetime) -> int:
     origin = datetime(1970, 1, 1)
     if timestamp.tzinfo is not None:
-        timestamp = timestamp.astimezone(pytz.utc).replace(tzinfo=None)
+        timestamp = timestamp.astimezone(timezone.utc).replace(tzinfo=None)
     return (timestamp - origin) // timedelta(seconds=1)
 
 

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

@@ -2,11 +2,11 @@ from datetime import datetime, timedelta, timezone, tzinfo
 from itertools import groupby
 from operator import itemgetter
 from typing import Any, Dict, List, Optional, Tuple, Union
-from urllib.error import HTTPError
+from zoneinfo import ZoneInfo, ZoneInfoNotFoundError
 
 import numpy as np
 import pandas as pd
-import pytz
+import requests
 
 from tagreader.cache import BucketCache, SmartCache
 from tagreader.logger import logger
@@ -21,11 +21,12 @@ from tagreader.web_handlers import (
     PIHandlerWeb,
     get_auth_aspen,
     get_auth_pi,
+    get_url_aspen,
     list_aspenone_sources,
     list_piwebapi_sources,
 )
 
-NONE_START_TIME = datetime(1970, 1, 1, tzinfo=pytz.UTC)
+NONE_START_TIME = datetime(1970, 1, 1, tzinfo=timezone.utc)
 
 
 def list_sources(
@@ -49,8 +50,6 @@ def list_sources(
             auth = get_auth_pi()
         return list_piwebapi_sources(url=url, auth=auth, verify_ssl=verify_ssl)
     elif imstype == IMSType.ASPENONE:
-        if auth is None:
-            auth = get_auth_aspen()
         return list_aspenone_sources(url=url, auth=auth, verify_ssl=verify_ssl)
     elif imstype in [IMSType.PI, IMSType.ASPEN, IMSType.IP21]:
         raise ValueError(
@@ -121,33 +120,50 @@ def get_handler(
     url: Optional[str],
     options: Dict[str, Union[int, float, str]],
     verify_ssl: Optional[Union[bool, str]],
-    auth: Optional[Any],
+    auth: Optional[Any] = None,
     cache: Optional[Union[SmartCache, BucketCache]] = None,
 ):
     if imstype is None:
+        orig_auth = auth
+        orig_url = url
         try:
-            if datasource in list_aspenone_sources(
+            aspen_source = list_aspenone_sources(
                 url=None, auth=None, verify_ssl=verify_ssl
-            ):
-                imstype = IMSType.ASPENONE
-        except HTTPError as e:
-            logger.debug(f"Could not list Aspenone sources: {e}")
+            )
+        except (requests.exceptions.HTTPError, requests.exceptions.ConnectionError):
+            # Try again using app registration auth
+            try:
+                auth = get_auth_aspen(False)
+                url = get_url_aspen(False)
+                aspen_source = list_aspenone_sources(
+                    auth=auth, url=url, verify_ssl=verify_ssl
+                )
+            except requests.exceptions.HTTPError as e:
+                logger.debug(f"Could not list Aspenone sources: {e}")
+                aspen_source = []
+
+        if datasource in aspen_source:
+            imstype = IMSType.ASPENONE
+        else:
+            auth = orig_auth
+            url = orig_url
+
     if imstype is None:
         try:
             if datasource in list_piwebapi_sources(
                 url=None, auth=None, verify_ssl=verify_ssl
             ):
                 imstype = IMSType.PIWEBAPI
-        except HTTPError as e:
+        except requests.exceptions.HTTPError as e:
             logger.debug(f"Could not list PI sources: {e}")
 
     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,
         )
 
@@ -175,7 +191,7 @@ class IMSClient:
         self,
         datasource: str,
         imstype: Optional[Union[str, IMSType]] = None,
-        tz: Union[tzinfo, str] = pytz.timezone("Europe/Oslo"),
+        tz: Optional[Union[tzinfo, str]] = None,
         url: Optional[str] = None,
         handler_options: Dict[str, Union[int, float, str]] = {},  # noqa:
         verify_ssl: Optional[Union[bool, str]] = True,
@@ -191,11 +207,15 @@ class IMSClient:
                     f" We suggest to use the tagreader.IMSType enumerator when initiating a client."
                 )
 
+        if tz is None or tz == "":
+            tz = ZoneInfo("Europe/Oslo")
         if isinstance(tz, str):
-            if tz in pytz.all_timezones:
-                self.tz = pytz.timezone(tz)
-            else:
-                raise ValueError(f"Invalid timezone string  Given type was {type(tz)}")
+            try:
+                self.tz = ZoneInfo(tz)
+            except ZoneInfoNotFoundError:
+                raise ValueError(
+                    f"Invalid timezone string. Given tz was {tz}"
+                ) from None
         elif isinstance(tz, tzinfo):
             self.tz = tz
         else:
@@ -345,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.0 → tagreader-6.3.0}/tagreader/utils.py

@@ -3,14 +3,14 @@ import hashlib
 import platform
 import socket
 import ssl
-from datetime import datetime, tzinfo
+from datetime import datetime, timezone, tzinfo
 from enum import Enum
 from pathlib import Path
-from typing import Union
+from typing import Optional, Union
+from zoneinfo import ZoneInfo, ZoneInfoNotFoundError
 
 import certifi
 import pandas as pd
-import pytz
 import requests
 from platformdirs import user_data_dir
 
@@ -50,12 +50,24 @@ def convert_to_pydatetime(date_stamp: Union[datetime, str, pd.Timestamp]) -> dat
 
 def ensure_datetime_with_tz(
     date_stamp: Union[datetime, str, pd.Timestamp],
-    tz: tzinfo = pytz.timezone("Europe/Oslo"),
+    tz: Optional[tzinfo] = None,
 ) -> datetime:
+    if tz is None:
+        try:
+            tz = ZoneInfo("Europe/Oslo")
+        except ZoneInfoNotFoundError:
+            logger.warning(
+                "Unable to load timezone 'Europe/Oslo'. Falling back to UTC."
+            )
+            tz = timezone.utc
     date_stamp = convert_to_pydatetime(date_stamp)
 
     if not date_stamp.tzinfo:
-        date_stamp = tz.localize(date_stamp)
+        localize = getattr(tz, "localize", None)
+        if callable(localize):
+            date_stamp = localize(date_stamp)
+        else:
+            date_stamp = date_stamp.replace(tzinfo=tz)
 
     return date_stamp
 

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

@@ -3,14 +3,13 @@ import json
 import re
 import urllib.parse
 from abc import ABC, abstractmethod
-from datetime import datetime, timedelta
+from datetime import datetime, timedelta, timezone
 from hashlib import new as hashlib_new_method
 from json.decoder import JSONDecodeError
 from typing import Any, Dict, List, Optional, Tuple, Union
 
 import numpy as np
 import pandas as pd
-import pytz
 import requests
 import urllib3
 from Crypto.Hash import MD4 as _MD4
@@ -87,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()
 
@@ -115,18 +108,38 @@ def list_aspenone_sources(
     except JSONDecodeError as e:
         logger.error(f"Could not decode JSON response: {e}")
 
+    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()
 
@@ -143,6 +156,30 @@ def list_piwebapi_sources(
     except JSONDecodeError as e:
         logger.error(f"Could not decode JSON response: {e}")
 
+    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,
@@ -170,6 +207,8 @@ def get_piwebapi_source_to_webid_dict(
     except JSONDecodeError as e:
         logger.error(f"Could not decode JSON response: {e}")
 
+    return []
+
 
 class BaseHandlerWeb(ABC):
     def __init__(
@@ -181,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()
@@ -188,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:
@@ -223,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):
@@ -243,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()
@@ -254,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
@@ -266,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}
@@ -333,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]:
@@ -367,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
@@ -424,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 {}
@@ -437,7 +527,7 @@ class AspenHandlerWeb(BaseHandlerWeb):
         return ret
 
     def _get_default_mapname(self, tagname: str):
-        (tagname, _) = self.split_tagmap(tagname)
+        tagname, _ = self.split_tagmap(tagname)
         all_maps = self._get_maps(tagname)
         for k, v in all_maps.items():
             if v:
@@ -452,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
@@ -513,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:
@@ -548,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 = ""
@@ -565,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,
@@ -592,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,
@@ -606,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
@@ -640,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">'
             )
@@ -655,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()
@@ -706,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()
@@ -724,12 +820,12 @@ 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
     def _time_to_UTC_string(time: datetime) -> str:
-        return time.astimezone(pytz.UTC).strftime("%d-%b-%y %H:%M:%S")
+        return time.astimezone(timezone.utc).strftime("%d-%b-%y %H:%M:%S")
 
     @staticmethod
     def escape(s: str) -> str:
@@ -774,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]}"
             )
@@ -801,6 +897,9 @@ class PIHandlerWeb(BaseHandlerWeb):
         ]:
             raise NotImplementedError
 
+        if not tag:
+            raise ValueError("Tag must be provided.")
+
         web_id = tag
 
         seconds = 0
@@ -813,7 +912,6 @@ class PIHandlerWeb(BaseHandlerWeb):
             ReaderType.SNAPSHOT: "value",
             ReaderType.SHAPEPRESERVING: "plot",
         }.get(read_type, "summary")
-
         url = f"streams/{web_id}/{get_action}"
         params = {}
 
@@ -860,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
 
@@ -994,7 +1092,7 @@ class PIHandlerWeb(BaseHandlerWeb):
         if not web_id:
             return pd.DataFrame()
 
-        (url, params) = self.generate_read_query(
+        url, params = self.generate_read_query(
             tag=web_id,
             start=start,
             end=end,