python-terminusgps 19.2.0__py3-none-any.whl → 20.0.0__py3-none-any.whl

{python_terminusgps-19.2.0.dist-info → python_terminusgps-20.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-terminusgps
-Version: 19.2.0
+Version: 20.0.0
 Summary: Provides abstractions/utilities for working with Wialon API, Authorize.NET API, AWS API, and more.
 Project-URL: Documentation, https://app.terminusgps.com/docs/apps/python-terminusgps/index.html
 Project-URL: Repository, https://github.com/terminusgps/python-terminusgps

{python_terminusgps-19.2.0.dist-info → python_terminusgps-20.0.0.dist-info}/RECORD

@@ -15,9 +15,9 @@ terminusgps/twilio/__init__.py,sha256=dYo41F2jft_eHDWSUtSpKGSRG1bewq_qClqilUJZkY
 terminusgps/twilio/caller.py,sha256=nHCIwUulo-C_v2orsp6OY0nuJA6YetSkxpMTwrRQ-uA,1831
 terminusgps/wialon/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 terminusgps/wialon/constants.py,sha256=u7y9MsA5LYvjPjxJnCMQdprTF3QhPPR9j4MvzoSNBaw,1628
-terminusgps/wialon/errors.py,sha256=Fl8A0peF5HpDdR3y0r3g86-iQ4kQgye3FYQZKGe3T7Y,984
 terminusgps/wialon/flags.py,sha256=-OoH-eZM54yjRqxsAXL8VImdQu_7C0OAxCrFqaCEuko,13510
-terminusgps/wialon/session.py,sha256=kgBFOB_gMmQS35mcmNOVIAnMvy9smrA2cUoD3QM3-3U,10857
+terminusgps/wialon/logger.py,sha256=nUBsaLMaffSaAHGHAM6mFXDzix9hbNecVtA3INVtii8,968
+terminusgps/wialon/session.py,sha256=47Cq3cM4sF-lySPtafzizKHeHbfuDuK1CnR0Jrmwk-Q,10634
 terminusgps/wialon/utils.py,sha256=KeZmV-MEdGOHXrsyn6IIoyX0EgVYiWYjvacXyZVr1u8,6501
 terminusgps/wialon/items/__init__.py,sha256=cfUC5sfVsTwmpgsR-w9wA4ay6_EZYAPgEeuw2k06RJM,256
 terminusgps/wialon/items/base.py,sha256=EAtzlnCvB7WTu3iX1bV1-S9TvwXc-Eez7e0X4TMiK9U,6943
@@ -29,7 +29,7 @@ terminusgps/wialon/items/route.py,sha256=PTJx1gmT_PGz7nlSSUS2VzjYD-aAuvkEOIdIFne
 terminusgps/wialon/items/unit.py,sha256=PwF7xlpDWI5MpM_u6TmYZjNHWk6TSKM4rJ4OB9CIn4A,7533
 terminusgps/wialon/items/unit_group.py,sha256=xc7zYitPE59_WYS-G857jeIQnQcUAxLBH3X6Y1VDg_8,4089
 terminusgps/wialon/items/user.py,sha256=INwAibQVmjNNelepQXMfDevgJqMvIjHHgEjAMLRvhB0,7082
-python_terminusgps-19.2.0.dist-info/METADATA,sha256=t4uVsM26NzgtvX98ma1Ps1ZpG01K12isrW2PLh7urBo,912
-python_terminusgps-19.2.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-python_terminusgps-19.2.0.dist-info/licenses/COPYING,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-python_terminusgps-19.2.0.dist-info/RECORD,,
+python_terminusgps-20.0.0.dist-info/METADATA,sha256=ufm3V1VjwT2xa_damT1cBxAoOmoCcYRmH2ZtNHYLKG8,912
+python_terminusgps-20.0.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+python_terminusgps-20.0.0.dist-info/licenses/COPYING,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+python_terminusgps-20.0.0.dist-info/RECORD,,

terminusgps/wialon/logger.py

@@ -0,0 +1,29 @@
+import logging
+
+
+class WialonLogger:
+    def __init__(
+        self,
+        logger: logging.Logger,
+        level: int = logging.DEBUG,
+        format: str = "%(name)s - %(levelname)s - %(asctime)s - %(message)s",
+        use_stream_handler: bool = True,
+        use_file_handler: bool = False,
+        filename: str = "wialon_debug.log",
+    ) -> None:
+        self.logger = logger
+        self.logger.setLevel(level)
+        formatter = logging.Formatter(format)
+
+        if use_stream_handler and not self.logger.handlers:
+            stream_handler = logging.StreamHandler()
+            stream_handler.setFormatter(formatter)
+            self.logger.addHandler(stream_handler)
+
+        if use_file_handler and not self.logger.handlers:
+            file_handler = logging.FileHandler(filename)
+            file_handler.setFormatter(formatter)
+            self.logger.addHandler(file_handler)
+
+    def get_logger(self) -> logging.Logger:
+        return self.logger

terminusgps/wialon/session.py

@@ -1,15 +1,15 @@
-import threading
-import logging
-import typing
 import dataclasses
 import datetime
+import logging
+import threading
+import typing
 
-from wialon.api import WialonError
-from wialon.api import Wialon as WialonAPI
 from django.conf import settings
 from django.utils import timezone
+from wialon.api import Wialon as WialonBase
+from wialon.api import WialonError
 
-from terminusgps.wialon.errors import WialonLogoutError, WialonLoginError
+from terminusgps.wialon.logger import WialonLogger
 
 
 @dataclasses.dataclass
@@ -22,27 +22,21 @@ class WialonAPICall:
     error: Exception | None = None
 
 
-class Wialon(WialonAPI):
+class Wialon(WialonBase):
     def __init__(self, log_level: int = logging.INFO, *args, **kwargs) -> None:
         super().__init__(*args, **kwargs)
         self.call_history: list[WialonAPICall] = []
-        self.logger = self.create_logger(log_level)
+        self.logger = WialonLogger(
+            logging.getLogger(self.__class__.__name__), level=log_level
+        ).get_logger()
 
     @property
     def total_calls(self) -> int:
         return len(self.call_history)
 
-    @property
-    def successful_calls(self) -> list[WialonAPICall | None]:
-        return [call for call in self.call_history if not call.error]
-
-    @property
-    def failed_calls(self) -> list[WialonAPICall | None]:
-        return [call for call in self.call_history if call.error]
-
-    @property
-    def failure_rate(self) -> float:
-        return len(self.failed_calls) / self.total_calls
+    def token_login(self, *args, **kwargs) -> typing.Any:
+        kwargs["appName"] = "python-terminusgps"
+        return self.call("token_login", *args, **kwargs)
 
     def call(self, action_name: str, *argc, **kwargs) -> typing.Any:
         self.logger.debug(f"Executing '{action_name}'...")
@@ -56,31 +50,18 @@ class Wialon(WialonAPI):
             self.logger.debug(f"Executed '{action_name}' successfully.")
             return result
         except WialonError as e:
-            self.logger.warning(f"Failed to execute '{action_name}': '{e}'")
             call_record.error = e
-            raise
+            self.logger.warning(f"Failed to execute '{action_name}': '{e}'")
+            return
         finally:
             self.call_history.append(call_record)
 
-    def create_logger(self, log_level: int) -> logging.Logger:
-        logger = logging.getLogger(self.__class__.__name__)
-        handler = logging.StreamHandler()
-        formatter = logging.Formatter(
-            "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
-        )
-
-        logger.setLevel(log_level)
-        handler.setFormatter(formatter)
-        logger.addHandler(handler)
-        return logger
-
 
 class WialonSession:
     def __init__(
         self,
         token: str | None = None,
         sid: str | None = None,
-        uid: str | None = None,
         scheme: str = "https",
         host: str = "hst-api.wialon.com",
         port: int = 443,
@@ -93,35 +74,31 @@ class WialonSession:
         :type token: :py:obj:`str` | :py:obj:`None`
         :param sid: An optional Wialon API session id. If provided, the session is continued.
         :type sid: :py:obj:`str` | :py:obj:`None`
-        :raises ImproperlyConfigured: If either :confval:`WIALON_TOKEN` or :confval:`WIALON_ADMIN_ID` is not set.
+        :param scheme: HTTP request scheme to use. Default is ``"https"``.
+        :type scheme: :py:obj:`str`
+        :param host: Wialon API host url. Default is ``"hst-api.wialon.com"``.
+        :type host: :py:obj:`str`
+        :param port: Wialon API host port. Default is ``443``.
+        :type port: :py:obj:`int`
+        :param log_level: Severity level at which log messages should be handled. Default is ``20`` (logging.INFO).
+        :type log_level: :py:obj:`int`
         :returns: Nothing.
         :rtype: :py:obj:`None`
 
         """
 
-        self.wialon_api = Wialon(
-            scheme=scheme, host=host, port=port, sid=sid, log_level=log_level
-        )
-        self.token = token
-        self.login_id = uid
+        self._token = token or settings.WIALON_TOKEN
         self._username = None
         self._gis_sid = None
         self._hw_gp_ip = None
         self._wsdk_version = None
         self._uid = None
-        self.logger = self.create_logger(log_level)
-
-    def create_logger(self, log_level: int) -> logging.Logger:
-        logger = logging.getLogger(self.__class__.__name__)
-        handler = logging.StreamHandler()
-        formatter = logging.Formatter(
-            "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+        self.wialon_api = Wialon(
+            scheme=scheme, host=host, port=port, sid=sid, log_level=log_level
         )
-
-        logger.setLevel(log_level)
-        handler.setFormatter(formatter)
-        logger.addHandler(handler)
-        return logger
+        self.logger = WialonLogger(
+            logging.getLogger(self.__class__.__name__), level=log_level
+        ).get_logger()
 
     def __enter__(self) -> "WialonSession":
         assert self.token, "Wialon API token was not set"
@@ -275,11 +252,7 @@ class WialonSession:
         :value: :confval:`WIALON_TOKEN`
 
         """
-        return self._token
-
-    @token.setter
-    def token(self, value: str | None = None) -> None:
-        self._token = value if value else settings.WIALON_TOKEN
+        return str(self._token)
 
     def login(self, token: str, flags: int = sum([0x1, 0x2, 0x20])) -> str:
         """
@@ -289,39 +262,41 @@ class WialonSession:
         :type token: :py:obj:`str`
         :param flags: A login response flag integer.
         :type flags: :py:obj:`int`
-        :raises WialonLoginError: If the login fails.
+        :raises WialonError: If the login fails.
+        :raises AssertionError: If the login token was not set.
         :returns: The new session id.
         :rtype: :py:obj:`str`
 
         """
         try:
+            self.logger.info("Logging into Wialon API session...")
             response = self.wialon_api.token_login(**{"token": token, "fl": flags})
             self._set_login_response(response)
-            self.logger.info(f"Logged into Wialon API session '{response.get('eid')}'")
+            self.logger.debug(f"Logged into Wialon API session '{response.get('eid')}'")
             return response.get("eid")
         except (WialonError, AssertionError) as e:
             self.logger.critical(f"Failed to login to Wialon API: '{e}'")
-            raise WialonLoginError(token, e)
+            raise
 
     def logout(self) -> None:
         """
         Logs out of the Wialon API session.
 
-        :raises WialonLogoutError: If the logout fails.
         :returns: Nothing.
         :rtype: :py:obj:`None`
 
         """
+        self.logger.info("Logging out of Wialon API session...")
         response: dict = self.wialon_api.core_logout({})
-        self.logger.info(
-            f"Logged out of session '{self.id}' after {self.wialon_api.total_calls} Wialon API calls."
-        )
-        self.logger.debug(f"Failure rate: {self.wialon_api.failure_rate}%")
+
         if response.get("error") != 0:
             self.logger.warning(
                 f"Failed to logout of session: '{response.get('message')}'"
             )
-            raise WialonLogoutError(str(self.id))
+        else:
+            self.logger.debug(
+                f"Logged out after {self.wialon_api.total_calls} Wialon API calls."
+            )
 
     def _set_login_response(self, login_response: dict) -> None:
         """
@@ -367,3 +342,20 @@ class WialonSessionManager:
             if not self._session:
                 self._session = WialonSession(sid=sid, log_level=log_level)
         return self._session
+
+
+def main() -> None:
+    # Usage example
+    session = WialonSession(log_level=logging.DEBUG)  # Instantiate session
+    session.login(settings.WIALON_TOKEN)  # Login to session
+    session.wialon_api.avl_evts()  # Call Wialon API
+    session.logout()  # Logout of session
+
+    # Alternatively, use a context manager to handle logging in and out
+    with WialonSession() as session:
+        session.wialon_api.avl_evts()  # Call Wialon API, logout when scope ends
+    return
+
+
+if __name__ == "__main__":
+    main()

terminusgps/wialon/errors.py

@@ -1,29 +0,0 @@
-from wialon.api import WialonError
-
-
-class WialonBaseError(Exception):
-    def __init__(
-        self, message: str, wialon_err: WialonError | AssertionError | None = None
-    ) -> None:
-        self.wialon_err = wialon_err
-        return super().__init__(message)
-
-
-class WialonLoginError(WialonBaseError):
-    def __init__(
-        self, token: str | None, wialon_err: WialonError | AssertionError | None = None
-    ) -> None:
-        message = f"Failed to login to the Wialon API using token: '{token}'\n"
-        if wialon_err:
-            message += str(wialon_err)
-        return super().__init__(message, wialon_err)
-
-
-class WialonLogoutError(WialonBaseError):
-    def __init__(
-        self, session_id: str, wialon_err: WialonError | AssertionError | None = None
-    ) -> None:
-        message = f"Failed to logout of the Wialon API session: '{session_id}'\n"
-        if wialon_err:
-            message += str(wialon_err)
-        return super().__init__(message, wialon_err)