python-terminusgps 1.13.6__tar.gz → 1.15.0__tar.gz

{python_terminusgps-1.13.6 → python_terminusgps-1.15.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-terminusgps
-Version: 1.13.6
+Version: 1.15.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-1.13.6 → python_terminusgps-1.15.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "python-terminusgps"
-version = "1.13.6"
+version = "1.15.0"
 description = "Provides abstractions/utilities for working with Wialon API, Authorize.NET API, AWS API, and more."
 readme = "README.md"
 authors = [ {name = "Blake Nall", email = "blake@terminusgps.com" } ]

python_terminusgps-1.15.0/terminusgps/authorizenet/subscriptions.py

@@ -0,0 +1,61 @@
+from authorizenet import apicontractsv1, apicontrollers, apicontrollersbase
+from terminusgps.authorizenet.auth import get_merchant_auth, get_environment
+
+
+class Subscription:
+    def __init__(self, name: str, id: str | int | None = None, **kwargs) -> None:
+        if id is not None and isinstance(id, str) and not id.isdigit():
+            raise ValueError(f"'id' must be a digit, got '{id}'.")
+        self.name = name
+        self.id = str(id if id else self.create(**kwargs))
+
+    @property
+    def merchantAuthentication(self) -> apicontractsv1.merchantAuthenticationType:
+        return get_merchant_auth()
+
+    @property
+    def environment(self) -> str:
+        return get_environment()
+
+    def execute_controller(
+        self, controller: apicontrollersbase.APIOperationBase
+    ) -> dict:
+        """
+        Executes an Authorize.NET controller and returns its response.
+
+        :param controller: An Authorize.NET API controller.
+        :raises ValueError: If the API call fails.
+        :returns: The Authorize.NET API response.
+        :rtype: :py:obj:`dict`
+
+        """
+        controller.setenvironment(self.environment)
+        controller.execute()
+        response = controller.getresponse()
+
+        if response.messages.resultCode != "Ok":
+            raise ValueError(response.messages.message[0]["text"].text)
+        return response
+
+    def create(
+        self,
+        schedule: apicontractsv1.paymentScheduleType,
+        amount: str,
+        payment: apicontractsv1.paymentType,
+        address: apicontractsv1.customerAddressType,
+        trial_amount: str = "0.00",
+    ) -> int:
+        request = apicontractsv1.ARBCreateSubscriptionRequest(
+            merchantAuthentication=self.merchantAuthentication,
+            subscription=apicontractsv1.ARBSubscriptionType(
+                name=self.name,
+                paymentSchedule=schedule,
+                amount=amount,
+                trialAmount=trial_amount,
+                payment=payment,
+                bill_to=address,
+            ),
+        )
+        controller = apicontrollers.ARBCreateSubscriptionController(request)
+        response = self.execute_controller(controller)
+        return int(response.subscriptionId)

{python_terminusgps-1.13.6 → python_terminusgps-1.15.0}/terminusgps/wialon/constants.py

@@ -74,7 +74,7 @@ ACCESSMASK_UNIT_SUPER: int = sum(
     ]
 )
 
-ACCESSMASK_UNIT_FULL: int = sum([flags.ACCESSFLAG_FULL_ACCESS])
+ACCESSMASK_UNIT_FULL: int = flags.ACCESSFLAG_FULL_ACCESS
 
 ACCESSMASK_UNIT_MIGRATION: int = sum(
     [

{python_terminusgps-1.13.6 → python_terminusgps-1.15.0}/terminusgps/wialon/items/unit.py

@@ -36,6 +36,12 @@ class WialonUnit(WialonBase):
         )
         return response.get("item", {}).get("id")
 
+    @property
+    def available_commands(self) -> dict:
+        return self.session.wialon_api.core_get_hw_cmds(
+            **{"deviceTypeId": 0, "unitId": self.id}
+        )
+
     def execute_command(
         self,
         name: str,

{python_terminusgps-1.13.6 → python_terminusgps-1.15.0}/terminusgps/wialon/items/user.py

@@ -180,3 +180,31 @@ class WialonUser(WialonBase):
                 "newPassword": new_password,
             }
         )
+
+    def verify_auth(self, destination: str, method: str = "email") -> str:
+        """
+        Sends an authentication code to ``destination`` via ``method``.
+
+        ``Method`` can be ``"email"`` or ``"sms"``.
+
+        :param destination: The email or phone number to send an auth code to.
+        :type destination: :py:obj:`str`
+        :param method: Email or sms. Default is ``"email"``.
+        :type method: :py:obj:`str`
+        :raises ValueError: If the method isn't ``"email"`` or ``"sms"``.
+        :raises WialonError: If something goes wrong with Wialon.
+        :returns: An auth code.
+        :rtype: :py:obj:`str`
+
+        """
+        if method != "email" or "sms":
+            raise ValueError(f"Invalid method '{method}'.")
+
+        response = self.session.wialon_api.user_verify_auth(
+            **{
+                "userId": self.id,
+                "type": 1 if method == "email" else 0,
+                "destination": destination,
+            }
+        )
+        return response.get("code")

{python_terminusgps-1.13.6 → python_terminusgps-1.15.0}/terminusgps/wialon/session.py

@@ -1,33 +1,64 @@
 import threading
 import logging
+
 from typing import Any
+from dataclasses import dataclass
+from datetime import datetime
 
 from wialon.api import WialonError
 from wialon.api import Wialon as WialonAPI
 from django.conf import settings
+from django.utils import timezone
 
 from .errors import WialonLogoutError, WialonLoginError
 
-logger = logging.getLogger(__name__)
+
+@dataclass
+class WialonAPICall:
+    action: str
+    timestamp: datetime
+    args: tuple
+    kwargs: dict
+    result: Any = None
+    error: Exception | None = None
 
 
 class Wialon(WialonAPI):
     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.callstack = []
 
     @property
-    def num_calls(self) -> int:
-        return len(self.callstack)
+    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 call(self, action_name: str, *argc, **kwargs) -> Any:
-        self.logger.debug(f"Executing '{action_name}'...")
-        self.callstack.append(action_name)
+        self.logger.info(f"Executing '{action_name}'...")
+        self.logger.debug(f"Executing '{action_name}' using: '{kwargs}'")
+        call_record = WialonAPICall(
+            action=action_name, timestamp=timezone.now(), args=argc, kwargs=kwargs
+        )
+
         try:
-            return super().call(action_name, *argc, **kwargs)
+            result = super().call(action_name, *argc, **kwargs)
+            call_record.result = result
+            self.call_history.append(call_record)
+            return result
         except WialonError as e:
-            self.logger.critical(f"Failed to execute '{action_name}':'{e}'")
+            self.logger.warning(f"Failed to execute '{action_name}': '{e}'")
             raise
 
     def create_logger(self, log_level: int) -> logging.Logger:
@@ -262,13 +293,13 @@ class WialonSession:
         :rtype: :py:obj:`str`
 
         """
-        self.logger.debug("Logging into Wialon API session...")
         try:
             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')}'")
             return response.get("eid")
         except (WialonError, AssertionError) as e:
-            self.logger.critical(e)
+            self.logger.critical(f"Failed to login to Wialon API: '{e}'")
             raise WialonLoginError(token, e)
 
     def logout(self) -> None:
@@ -280,13 +311,15 @@ class WialonSession:
         :rtype: :py:obj:`None`
 
         """
-        self.logger.debug(f"Logging out of Wialon API session '{self.id}'...")
         response: dict = self.wialon_api.core_logout({})
         self.logger.info(
-            f"Called the Wialon API {self.wialon_api.num_calls} times during session '{self.id}'."
+            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.critical(response.get("error"))
+            self.logger.warning(
+                f"Failed to logout of session: '{response.get('message')}'"
+            )
             raise WialonLogoutError(str(self.id))
 
     def _set_login_response(self, login_response: dict) -> None:

{python_terminusgps-1.13.6 → python_terminusgps-1.15.0}/uv.lock

@@ -504,7 +504,7 @@ wheels = [
 
 [[package]]
 name = "python-terminusgps"
-version = "1.13.6"
+version = "1.15.0"
 source = { editable = "." }
 dependencies = [
     { name = "argparse" },