python-terminusgps 1.4.6__py3-none-any.whl → 1.5.7__py3-none-any.whl

{python_terminusgps-1.4.6.dist-info → python_terminusgps-1.5.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-terminusgps
-Version: 1.4.6
+Version: 1.5.7
 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
@@ -15,5 +15,5 @@ Requires-Python: >=3.12
 Requires-Dist: argparse>=1.4.0
 Requires-Dist: authorizenet>=1.1.5
 Requires-Dist: boto3>=1.34.144
-Requires-Dist: django>=5.1.4
+Requires-Dist: django>=5.1.5
 Requires-Dist: python-wialon>=1.2.4

python_terminusgps-1.5.7.dist-info/RECORD

@@ -0,0 +1,24 @@
+terminusgps/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+terminusgps/settings.py,sha256=CIWif9AJYXk5nE-9Mqmqkeoum6-ON5MTuh0WJilgv3E,185
+terminusgps/authorizenet/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+terminusgps/authorizenet/auth.py,sha256=zITSQMH8F-3vw-lDQRbuR2s9AVlGqbOyyFo0zqU00qU,870
+terminusgps/aws/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+terminusgps/aws/secrets.py,sha256=kgRA77rs0mD4berWRLkPtJLOe4Grf--o5f8NzwQqXCk,360
+terminusgps/wialon/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+terminusgps/wialon/constants.py,sha256=dsQaNt3TIjIZbr_m94KmBGFdrqe6HER2r6lol3X8QpU,2802
+terminusgps/wialon/errors.py,sha256=SV9pVwU6FZ_zGlGP6zJN6aLE2auF4TfHFISQLiPMKrI,1758
+terminusgps/wialon/flags.py,sha256=-OoH-eZM54yjRqxsAXL8VImdQu_7C0OAxCrFqaCEuko,13510
+terminusgps/wialon/session.py,sha256=x5aXxqLcBe4e0Zj3enUvWd1_Ufmd_MxXInC_d_GMn3E,9446
+terminusgps/wialon/utils.py,sha256=J8V2F-QDMsLD5x2OhCYI2lnZZdgqKboMve5XJD7Qt30,1877
+terminusgps/wialon/items/__init__.py,sha256=3BVthghekMvhMQSzQgBMlD_phxmKSmp3Zvmo-z0O8Bs,211
+terminusgps/wialon/items/base.py,sha256=MN4FG6U1nWkYAjNfXQJRVrWJoiW4Y64tyqxUO0mhv_w,6593
+terminusgps/wialon/items/resource.py,sha256=ADjGsQaCqD6Y3_AaD8vLgYzGaMK69MpxCZojnylS4GE,815
+terminusgps/wialon/items/retranslator.py,sha256=zsQXqOhH1zFe5_e8DROPu60z3v6xPWOEPyMCi2IqJAo,3861
+terminusgps/wialon/items/route.py,sha256=qOHPN_rejwiGqvwWzlwmUIAIyc3lKavCalf8ki66rx0,760
+terminusgps/wialon/items/unit.py,sha256=tLAWPfHUUS6_Feh1aYBMFPgyuGlSiAnfumJJmGt3bKw,4662
+terminusgps/wialon/items/unit_group.py,sha256=1yc7ldPIgGbtiTj0djRDWmt6Q9K_VT9sxOaioasbbLY,5212
+terminusgps/wialon/items/user.py,sha256=bkcMw_YiocaMuhP_pBfB7apjAZwnsOzGScnGkn8Ybbw,6107
+python_terminusgps-1.5.7.dist-info/METADATA,sha256=nY0ZeyVuZ4mUV82NrlzNEXNbLQ-kpDUJW8Y1vvFAAOM,882
+python_terminusgps-1.5.7.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+python_terminusgps-1.5.7.dist-info/licenses/COPYING,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+python_terminusgps-1.5.7.dist-info/RECORD,,

terminusgps/authorizenet/auth.py

@@ -1,10 +1,14 @@
 from authorizenet.apicontractsv1 import merchantAuthenticationType
 from authorizenet.constants import constants
 
-from django.conf import settings
+from django.conf import ImproperlyConfigured, settings
 
 
 def get_merchant_auth() -> merchantAuthenticationType:
+    if not hasattr(settings, "MERCHANT_AUTH_LOGIN_ID"):
+        raise ImproperlyConfigured("'MERCHANT_AUTH_LOGIN_ID' is required.")
+    if not hasattr(settings, "MERCHANT_AUTH_TRANSACTION_KEY"):
+        raise ImproperlyConfigured("'MERCHANT_AUTH_TRANSACTION_KEY' is required.")
     return merchantAuthenticationType(
         name=str(settings.MERCHANT_AUTH_LOGIN_ID),
         transactionKey=str(settings.MERCHANT_AUTH_TRANSACTION_KEY),
@@ -12,4 +16,6 @@ def get_merchant_auth() -> merchantAuthenticationType:
 
 
 def get_environment() -> str:
+    if not hasattr(settings, "DEBUG"):
+        raise ImproperlyConfigured("'DEBUG' is required.")
     return constants.SANDBOX if settings.DEBUG else constants.PRODUCTION

terminusgps/settings.py

@@ -0,0 +1,6 @@
+from os import getenv
+
+DEBUG = False
+SECRET_KEY = "xem*6no%8d9%^qzt2f3x3ar-uq4_+7h9myc$t0!+4%bj5us6f)"
+WIALON_ADMIN_ID = getenv("WIALON_ADMIN_ID")
+WIALON_TOKEN = getenv("WIALON_TOKEN")

terminusgps/wialon/__init__.py

@@ -1,5 +0,0 @@
-from os import environ
-
-environ.setdefault("WIALON_HOST", "hst-api.wialon.com")
-environ.setdefault("WIALON_SCHEME", "https")
-environ.setdefault("WIALON_PORT", "443")

terminusgps/wialon/errors.py

@@ -2,24 +2,52 @@ from wialon.api import WialonError
 
 
 class WialonBaseError(Exception):
-    def __init__(self, message: str, wialon_err: WialonError | None = None) -> None:
+    def __init__(
+        self, message: str, wialon_err: WialonError | AssertionError | None = None
+    ) -> None:
         self.wialon_err = wialon_err
-        super().__init__(message)
+        return super().__init__(message)
 
 
 class WialonLoginError(WialonBaseError):
     def __init__(
-        self, token: str | None, wialon_err: WialonError | None = None
+        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 WialonSessionDuplicationError(WialonBaseError):
+    def __init__(
+        self,
+        session_id: str | None,
+        wialon_err: WialonError | AssertionError | None = None,
     ) -> None:
-        message = f"Failed to login to the Wialon API using token: '{token}'"
+        message = f"Failed to duplicate the Wialon session: '#{session_id}'\n"
         if wialon_err:
             message += str(wialon_err)
-        super().__init__(message, wialon_err)
+        return super().__init__(message, wialon_err)
 
 
 class WialonLogoutError(WialonBaseError):
-    def __init__(self, session_id: str, wialon_err: WialonError | None = None) -> None:
-        message = f"Failed to logout of the Wialon API session: '{session_id}'"
+    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)
+
+
+class WialonSessionInvalidError(WialonBaseError):
+    def __init__(
+        self,
+        session_id: str | None,
+        wialon_err: WialonError | AssertionError | None = None,
+    ) -> None:
+        message = f"The session was invalid/expired: '{session_id}'\n"
         if wialon_err:
             message += str(wialon_err)
-        super().__init__(message, wialon_err)
+        return super().__init__(message, wialon_err)

terminusgps/wialon/items/base.py

@@ -1,10 +1,8 @@
 import terminusgps.wialon.flags as flags
 from terminusgps.wialon.session import WialonSession
-from terminusgps.wialon.utils import repopulate
 
 
 class WialonBase:
-    @repopulate
     def __init__(
         self, *, id: str | None = None, session: WialonSession, **kwargs
     ) -> None:
@@ -16,17 +14,45 @@ class WialonBase:
             self._id = id
 
     def __str__(self) -> str:
-        return f"{self.__class__}:{self.id}"
+        return str(self.id)
+
+    def populate(self) -> None:
+        response = self.session.wialon_api.core_search_item(
+            **{"id": str(self.id), "flags": 0x1}
+        )["item"]
+        self.name = response.get("nm")
+        self.hw_type = response.get("cls")
+        self.access_lvl = response.get("uacl")
 
     @property
     def session(self) -> WialonSession:
+        """
+        A valid Wialon API session.
+
+        :type: :py:obj:`~terminusgps.wialon.session.WialonSession`
+
+        """
+
         return self._session
 
     @property
     def id(self) -> int | None:
+        """
+        A unique Wialon ID.
+
+        :type: :py:obj:`int` | :py:obj:`None`
+
+        """
+
         return int(self._id) if self._id else None
 
     def has_access(self, other: "WialonBase") -> bool:
+        """
+        Checks if this Wialon object has access to ``other``.
+
+        :type: :py:obj:`bool`
+
+        """
         response = self.session.wialon_api.core_check_accessors(
             **{"items": [other.id], "flags": False}
         )
@@ -36,22 +62,32 @@ class WialonBase:
         """Creates a Wialon object and returns the newly created Wialon object's id."""
         raise NotImplementedError("Subclasses must implement this method.")
 
-    def populate(self) -> None:
-        """Retrieves and sets hw_type and name for this Wialon object."""
-        item = self.session.wialon_api.core_search_item(
-            **{"id": self.id, "flags": flags.DATAFLAG_UNIT_BASE}
-        ).get("item", {})
-        self.hw_type = item.get("cls", None)
-        self.name = item.get("nm", None)
-        self.uid = item.get("uid", None)
-
-    @repopulate
     def rename(self, new_name: str) -> None:
+        """
+        Renames the Wialon object to the new name.
+
+        :param new_name: A new name for this object.
+        :type new_name: :py:obj:`str`
+        :returns: Nothing.
+        :rtype: :py:obj:`None`
+
+        """
+
         self.session.wialon_api.item_update_name(
             **{"itemId": self.id, "name": new_name}
         )
 
     def add_afield(self, field: tuple[str, str]) -> None:
+        """
+        Adds an admin field to the Wialon object.
+
+        :param field: A tuple containing the name of the field and the value of the field.
+        :type field: :py:obj:`tuple`
+        :returns: Nothing.
+        :rtype: :py:obj:`None`
+
+        """
+
         self.session.wialon_api.item_update_admin_field(
             **{
                 "itemId": self.id,
@@ -63,6 +99,18 @@ class WialonBase:
         )
 
     def update_afield(self, field_id: int, field: tuple[str, str]) -> None:
+        """
+        Updates an admin field by id to the Wialon object.
+
+        :param field_id: The admin field id.
+        :type field_id: :py:obj:`int`
+        :param field: A tuple containing the name of the field and the value of the field.
+        :type field: :py:obj:`tuple`
+        :returns: Nothing.
+        :rtype: :py:obj:`None`
+
+        """
+
         self.session.wialon_api.item_update_admin_field(
             **{
                 "itemId": self.id,
@@ -74,6 +122,16 @@ class WialonBase:
         )
 
     def add_cfield(self, field: tuple[str, str]) -> None:
+        """
+        Adds a custom field to the Wialon object.
+
+        :param field: A tuple containing the name of the field and the value of the field.
+        :type field: :py:obj:`tuple`
+        :returns: Nothing.
+        :rtype: :py:obj:`None`
+
+        """
+
         self.session.wialon_api.item_update_custom_field(
             **{
                 "itemId": self.id,
@@ -85,6 +143,18 @@ class WialonBase:
         )
 
     def update_cfield(self, field_id: int, field: tuple[str, str]) -> None:
+        """
+        Updates a custom field by id.
+
+        :param field_id: The admin field id.
+        :type field_id: :py:obj:`int`
+        :param field: A tuple containing the name of the field and the value of the field.
+        :type field: :py:obj:`tuple`
+        :returns: Nothing.
+        :rtype: :py:obj:`None`
+
+        """
+
         self.session.wialon_api.item_update_custom_field(
             **{
                 "itemId": self.id,
@@ -95,17 +165,46 @@ class WialonBase:
             }
         )
 
-    def add_cproperty(self, field: tuple[str, str]) -> None:
+    def add_cproperty(self, property: tuple[str, str]) -> None:
+        """
+        Adds a custom property to the Wialon object.
+
+        :param property: A tuple containing the name of the property and the value of the property.
+        :type property: :py:obj:`tuple`
+        :returns: Nothing.
+        :rtype: :py:obj:`None`
+
+        """
+
         self.session.wialon_api.item_update_custom_property(
-            **{"itemId": self.id, "name": field[0], "value": field[1]}
+            **{"itemId": self.id, "name": property[0], "value": property[1]}
         )
 
     def add_profile_field(self, field: tuple[str, str]) -> None:
+        """
+        Adds a profile field to the Wialon object.
+
+        :param field: A tuple containing the name of the field and the value of the field.
+        :type field: :py:obj:`tuple`
+        :returns: Nothing.
+        :rtype: :py:obj:`None`
+
+        """
+
         self.session.wialon_api.item_update_profile_field(
             **{"itemId": self.id, "n": field[0], "v": field[1]}
         )
 
     def delete(self) -> None:
+        """
+        Deletes the Wialon object.
+
+        :raises WialonError: If something goes wrong with Wialon.
+        :returns: Nothing.
+        :rtype: :py:obj:`None`
+
+        """
+
         self.session.wialon_api.item_delete_item(**{"itemId": self.id})
 
     def _get_cfields(self) -> dict:

terminusgps/wialon/items/resource.py

@@ -16,7 +16,7 @@ class WialonResource(WialonBase):
                 "creatorId": kwargs["creator_id"],
                 "name": kwargs["name"],
                 "dataFlags": kwargs["flags"],
-                "skipCreatorCheck": True,
+                "skipCreatorCheck": int(True),
             }
         )
         return response.get("item", {}).get("id")

terminusgps/wialon/items/retranslator.py

@@ -4,6 +4,21 @@ from terminusgps.wialon.items.base import WialonBase
 
 class WialonRetranslator(WialonBase):
     def create(self, **kwargs) -> int | None:
+        """
+        Creates a Wialon retranslator.
+
+        :param creator_id: A Wialon user that will create the retranslator.
+        :type creator_id: :py:obj:`str`
+        :param name: A name for the new retranslator.
+        :type name: :py:obj:`str`
+        :param config: A Wialon retranslator configuration object.
+        :type config: :py:obj:`dict`
+        :raises ValueError: If a required parameter was not provided.
+        :raises WialonError: If something went wrong with Wialon.
+        :returns: Nothing.
+        :rtype: :py:obj:`None`
+
+        """
         if not kwargs.get("creator_id"):
             raise ValueError("'creator_id' is required on creation.")
         if not kwargs.get("name"):
@@ -20,3 +35,83 @@ class WialonRetranslator(WialonBase):
             }
         )
         return response.get("item", {}).get("id")
+
+    def update_config(self, new_config: dict) -> None:
+        """
+        Updates the retranslator config to the new config.
+
+        :param new_config: A Wialon retranslator configuration.
+        :type units: :py:obj:`dict`
+        :raises WialonError: If something went wrong with Wialon.
+        :returns: Nothing.
+        :rtype: :py:obj:`None`
+
+        """
+        self.session.wialon_api.retranslator_update_config(
+            **{"itemId": self.id, "config": new_config}
+        )
+
+    def add_units(self, units: list[WialonBase]) -> None:
+        """
+        Adds a list of units to the Wialon retranslator.
+
+        :param units: A list of Wialon unit objects.
+        :type units: :py:obj:`list`
+        :raises WialonError: If something went wrong with Wialon.
+        :returns: Nothing.
+        :rtype: :py:obj:`None`
+
+        """
+        self.session.wialon_api.retranslator_update_units(
+            **{
+                "itemId": self.id,
+                "units": [{"a": unit.id, "i": unit.hw_type} for unit in units],
+                "callMode": "add",
+            }
+        )
+
+    def rm_units(self, units: list[WialonBase]) -> None:
+        """
+
+        Naively removes a list of units from the Wialon retranslator.
+
+        :param units: A list of Wialon unit objects.
+        :type units: :py:obj:`list`
+        :raises WialonError: If something went wrong with Wialon.
+        :returns: Nothing.
+        :rtype: :py:obj:`None`
+
+        """
+        self.session.wialon_api.retranslator_update_units(
+            **{
+                "itemId": self.id,
+                "units": [{"a": unit.id, "i": unit.hw_type} for unit in units],
+                "callMode": "remove",
+            }
+        )
+
+    def start(self, stop: int | None = None) -> None:
+        """
+        Starts the Wialon retranslator.
+
+        :raises WialonError: If something went wrong with Wialon.
+        :returns: Nothing.
+        :rtype: :py:obj:`None`
+
+        """
+        self.session.wialon_api.retranslator_update_operating(
+            **{"itemId": self.id, "operate": int(True), "stopTime": stop}
+        )
+
+    def stop(self) -> None:
+        """
+        Stops the Wialon retranslator.
+
+        :raises WialonError: If something went wrong with Wialon.
+        :returns: Nothing.
+        :rtype: :py:obj:`None`
+
+        """
+        self.session.wialon_api.retranslator_update_operating(
+            **{"itemId": self.id, "operate": int(False)}
+        )

terminusgps/wialon/items/unit.py

@@ -1,11 +1,24 @@
 from urllib.parse import quote_plus
 
 from terminusgps.wialon import flags
-from terminusgps.wialon.items.base import WialonBase, repopulate
+from terminusgps.wialon.items.base import WialonBase
 
 
 class WialonUnit(WialonBase):
     def create(self, **kwargs) -> int | None:
+        """
+        Creates a new Wialon unit.
+
+        :param creator_id: A Wialon user id.
+        :type creator_id: :py:obj:`int`
+        :param name: A new name for the unit.
+        :type name: :py:obj:`str`
+        :param hw_type: A Wialon hardware type.
+        :type hw_type: :py:obj:`str`
+        :returns: The Wialon id for the new unit.
+        :rtype: :py:obj:`int` | :py:obj:`None`
+
+        """
         if not kwargs.get("creator_id"):
             raise ValueError("'creator_id' is required on creation.")
         if not kwargs.get("name"):
@@ -23,15 +36,6 @@ class WialonUnit(WialonBase):
         )
         return response.get("item", {}).get("id")
 
-    def populate(self) -> None:
-        super().populate()
-        unit_data = self.session.wialon_api.core_search_item(
-            **{"id": self.id, "flags": flags.DATAFLAG_UNIT_ADVANCED_PROPERTIES}
-        )
-        self.uid = unit_data.get("uid", "")
-        self.phone = unit_data.get("ph", "")
-        self.is_active = bool(unit_data.get("act", 0))
-
     def execute_command(
         self,
         name: str,
@@ -40,6 +44,24 @@ class WialonUnit(WialonBase):
         flags: int = 0,
         param: dict | None = None,
     ) -> None:
+        """
+        Executes a command on this Wialon unit.
+
+        :param name: A Wialon command name.
+        :type name: :py:obj:`str`
+        :param link_type: A protocol to use for the Wialon command.
+        :type link_type: :py:obj:`str`
+        :param timeout: How long (in seconds) to wait before timing out command execution. Default is ``5``.
+        :type timeout: :py:obj:`int`
+        :param flags: Flags to pass to the Wialon command execution.
+        :type flags: :py:obj:`int`
+        :param param: Additional parameters to execute the command with.
+        :type param: :py:obj:`dict` | :py:obj:`None`
+        :returns: Nothing.
+        :rtype: :py:obj:`None`
+
+        """
+
         self.session.wialon_api.unit_exec_cmd(
             **{
                 "itemId": self.id,
@@ -52,38 +74,78 @@ class WialonUnit(WialonBase):
         )
 
     def set_access_password(self, password: str) -> None:
+        """
+        Sets a new access password for this Wialon unit.
+
+        :param password: A new access password.
+        :type name: :py:obj:`str`
+        :raises WialonError: If something goes wrong with Wialon.
+        :returns: Nothing.
+        :rtype: :py:obj:`None`
+
+        """
+
         self.session.wialon_api.unit_update_access_password(
             **{"itemId": self.id, "accessPassword": password}
         )
 
-    @repopulate
     def activate(self) -> None:
-        if self.is_active:
-            return
+        """
+        Activates this Wialon unit.
+
+        :raises WialonError: If something goes wrong with Wialon.
+        :returns: Nothing.
+        :rtype: :py:obj:`None`
+
+        """
 
         self.session.wialon_api.unit_set_active(
             **{"itemId": self.id, "active": int(True)}
         )
 
-    @repopulate
     def deactivate(self) -> None:
-        if not self.is_active:
-            return
+        """
+        Deactivates this Wialon unit.
+
+        :raises WialonError: If something goes wrong with Wialon.
+        :returns: Nothing.
+        :rtype: :py:obj:`None`
+
+        """
 
         self.session.wialon_api.unit_set_active(
             **{"itemId": self.id, "active": int(False)}
         )
 
-    @repopulate
     def assign_phone(self, phone: str) -> None:
+        """
+        Assigns a phone number to this Wialon unit.
+
+        :param phone: A phone number beginning with a country code.
+        :type phone: :py:obj:`str`
+        :raises WialonError: If something goes wrong with Wialon.
+        :returns: Nothing.
+        :rtype: :py:obj:`None`
+
+        """
+
         self.session.wialon_api.unit_update_phone(
             **{"itemId": self.id, "phoneNumber": quote_plus(phone)}
         )
 
     def get_phone_numbers(self) -> list[str]:
+        """
+        Retrieves all phone numbers assigned to this Wialon unit.
+
+        This includes the usually assigned phone number + custom/admin fields labeled ``to_number``.
+
+        :raises WialonError: If something goes wrong with Wialon.
+        :returns: A list of phone numbers.
+        :rtype: :py:obj:`list`
+
+        """
+
         phones = []
-        if self.phone:
-            phones.append(self.phone)
         for field in self.cfields | self.afields:
             if field["n"] == "to_number":
                 phones.append(field["v"])

terminusgps/wialon/items/unit_group.py

@@ -4,6 +4,19 @@ from terminusgps.wialon.items.base import WialonBase
 
 class WialonUnitGroup(WialonBase):
     def create(self, **kwargs) -> int | None:
+        """
+        Creates a new Wialon unit group.
+
+        :param creator_id: A Wialon user id.
+        :type creator_id: :py:obj:`int`
+        :param name: A name for the group.
+        :type name: :py:obj:`str`
+        :raises WialonError: If something goes wrong with Wialon.
+        :returns: The Wialon id for the new group.
+        :rtype: :py:obj:`int` | :py:obj:`None`
+
+        """
+
         if not kwargs.get("creator_id"):
             raise ValueError("'creator_id' is required on creation.")
         if not kwargs.get("name"):
@@ -19,37 +32,107 @@ class WialonUnitGroup(WialonBase):
         return response.get("item", {}).get("id")
 
     def _update_items(self, new_items: list[str]) -> None:
+        """
+        Sets this group's members to a list of Wialon unit ids.
+
+        :param new_items: A list of Wialon unit ids.
+        :type new_items: :py:obj:`list`
+        :raises WialonError: If something goes wrong with Wialon.
+        :returns: Nothing.
+        :rtype: :py:obj:`None`
+
+        """
+
         self.session.wialon_api.unit_group_update_units(
             **{"itemId": self.id, "units": new_items}
         )
 
     def is_member(self, item: WialonBase) -> bool:
+        """
+        Determines whether or not ``item`` is a member of the group.
+
+        :param item: A Wialon object.
+        :type item: :py:obj:`~terminusgps.wialon.items.base.WialonBase`
+        :raises WialonError: If something goes wrong with Wialon.
+        :returns: :py:obj:`True` if ``item`` is a member of the group, else :py:obj:`False`.
+        :rtype: :py:obj:`bool`
+
+        """
         return True if str(item.id) in self.items else False
 
     def grant_access(
         self, item: WialonBase, access_mask: int = constants.ACCESSMASK_UNIT_BASIC
     ) -> None:
+        """
+        Grants ``item`` access to the group, if it didn't already have access.
+
+        :param item: A Wialon object.
+        :type item: :py:obj:`~terminusgps.wialon.items.base.WialonBase`
+        :param access_mask: A Wialon access mask.
+        :type access_mask: :py:obj:`int`
+        :raises WialonError: If something goes wrong with Wialon.
+        :returns: Nothing.
+        :rtype: :py:obj:`None`
+
+        """
         self.session.wialon_api.user_update_item_access(
             **{"userId": item.id, "itemId": self.id, "accessMask": access_mask}
         )
 
     def revoke_access(self, item: WialonBase) -> None:
+        """
+        Revokes ``item``'s access from the group, if it had access.
+
+        :param item: A Wialon object.
+        :type item: :py:obj:`~terminusgps.wialon.items.base.WialonBase`
+        :raises WialonError: If something goes wrong with Wialon.
+        :returns: Nothing.
+        :rtype: :py:obj:`None`
+
+        """
         self.session.wialon_api.user_update_item_access(
             **{"userId": item.id, "itemId": self.id, "accessMask": 0}
         )
 
     def add_item(self, item: WialonBase) -> None:
+        """
+        Adds a Wialon unit to the group.
+
+        :param item: A Wialon object.
+        :type item: :py:obj:`~terminusgps.wialon.items.base.WialonBase`
+        :raises WialonError: If something goes wrong with Wialon.
+        :returns: Nothing.
+        :rtype: :py:obj:`None`
+
+        """
         new_items: list[str] = self.items.copy() + [str(item.id)]
         self._update_items(new_items)
 
     def rm_item(self, item: WialonBase) -> None:
-        assert self.is_member(item), f"Cannot remove {item.name}, it's not in the group"
+        """
+        Removes a Wialon unit from the group, if it's a member of the group.
+
+        :param item: A Wialon object.
+        :type item: :py:obj:`~terminusgps.wialon.items.base.WialonBase`
+        :raises AssertionError: If the item wasn't in the group.
+        :raises WialonError: If something goes wrong with Wialon.
+        :returns: Nothing.
+        :rtype: :py:obj:`None`
+
+        """
+        assert self.is_member(item), f"Cannot remove {item}, it's not in the group"
         new_items: list[str] = self.items.copy()
         new_items.remove(str(item.id))
         self._update_items(new_items)
 
     @property
     def items(self) -> list[str]:
+        """
+        Returns a list of the group's Wialon unit ids.
+
+        :type: :py:obj:`list`
+
+        """
         response = self.session.wialon_api.core_search_items(
             **{
                 "spec": {

terminusgps/wialon/items/user.py

@@ -7,6 +7,20 @@ from terminusgps.wialon import constants
 
 class WialonUser(WialonBase):
     def create(self, **kwargs) -> int | None:
+        """
+        Creates a new Wialon user.
+
+        :param creator_id: A Wialon user id.
+        :type creator_id: :py:obj:`int`
+        :param name: A name for the user.
+        :type name: :py:obj:`str`
+        :param name: A password for the user.
+        :type name: :py:obj:`str`
+        :raises WialonError: If something goes wrong with Wialon.
+        :returns: The Wialon id for the new user.
+        :rtype: :py:obj:`int` | :py:obj:`None`
+
+        """
         if not kwargs.get("creator_id"):
             raise ValueError("'creator_id' is required on creation.")
         if not kwargs.get("name"):
@@ -25,6 +39,16 @@ class WialonUser(WialonBase):
         return response.get("item", {}).get("id")
 
     def _get_access_response(self, hw_type: str) -> dict:
+        """
+        Returns a dict of the Wialon objects the user has access to.
+
+        :param hw_type: A hardware type of Wialon objects to generate a list for.
+        :type hw_type: :py:obj:`str`
+        :raises WialonError: If something goes wrong with Wialon.
+        :returns: The Wialon API response.
+        :rtype: :py:obj:`dict`
+
+        """
         return self.session.wialon_api.user_get_items_access(
             **{
                 "userId": self.id,
@@ -36,40 +60,120 @@ class WialonUser(WialonBase):
 
     @property
     def units(self) -> list[str]:
+        """
+        The user's units.
+
+        :raises WialonError: If something goes wrong with Wialon.
+        :returns: A list of unit ids the user has access to.
+        :rtype: :py:obj:`list`
+
+        """
         response = self._get_access_response(hw_type="avl_unit")
         return [key for key in response.keys()]
 
     @property
     def groups(self) -> list[str]:
+        """
+        The user's unit groups.
+
+        :raises WialonError: If something goes wrong with Wialon.
+        :returns: A list of group ids the user has access to.
+        :rtype: :py:obj:`list`
+
+        """
         response = self._get_access_response(hw_type="avl_unit_group")
         return [key for key in response.keys()]
 
     def has_access(self, other: WialonBase) -> bool:
+        """
+        Checks if the user has access to ``other``.
+
+        :param other: A Wialon object.
+        :type phone: :py:obj:`~terminusgps.wialon.items.base.WialonBase`
+        :raises WialonError: If something goes wrong with Wialon.
+        :returns: :py:obj:`True` if the user can access ``other``, else :py:obj:`False`.
+        :rtype: :py:obj:`bool`
+
+        """
         response: dict = self._get_access_response(hw_type=other.hw_type)
         items: list[str] = [key for key in response.keys()]
         return True if str(other.id) in items else False
 
     def assign_phone(self, phone: str) -> None:
+        """
+        Assigns a phone number to the user.
+
+        :param phone: A phone number, including country code.
+        :type phone: :py:obj:`str`
+        :raises WialonError: If something goes wrong with Wialon.
+        :returns: Nothing.
+        :rtype: :py:obj:`None`
+
+        """
         self.add_cproperty(("phone", quote_plus(phone)))
 
     def assign_email(self, email: str) -> None:
-        """Assigns an email address to the Wialon user."""
+        """
+        Assigns an email address to the user.
+
+        :param phone: An email address.
+        :type phone: :py:obj:`str`
+        :raises WialonError: If something goes wrong with Wialon.
+        :returns: Nothing.
+        :rtype: :py:obj:`None`
+
+        """
         self.add_cproperty(("email", email))
 
     def grant_access(
         self, item: WialonBase, access_mask: int = constants.ACCESSMASK_UNIT_BASIC
     ) -> None:
-        """Grants item access to the Wialon user according to the access mask integer."""
+        """
+        Grants the user access to ``item``.
+
+        :param item: A Wialon object.
+        :type item: :py:obj:`~terminusgps.wialon.items.base.WialonBase`
+        :param access_mask: A Wialon access mask integer.
+        :type access_mask: :py:obj:`int`
+        :raises WialonError: If something goes wrong with Wialon.
+        :returns: Nothing.
+        :rtype: :py:obj:`None`
+
+        """
         self.session.wialon_api.user_update_item_access(
             **{"userId": self.id, "itemId": item.id, "accessMask": access_mask}
         )
 
     def set_settings_flags(self, flags: int, flags_mask: int) -> None:
+        """
+        Sets the user's settings flags.
+
+        :param flags: The new user settings flags.
+        :type flags: :py:obj:`int`
+        :param flags_mask: A user settings flag mask.
+        :type flags_mask: :py:obj:`int`
+        :raises WialonError: If something goes wrong with Wialon.
+        :returns: Nothing.
+        :rtype: :py:obj:`None`
+
+        """
         self.session.wialon_api.user_update_user_flags(
             **{"userId": self.id, "flags": flags, "flagsMask": flags_mask}
         )
 
     def update_password(self, old_password: str, new_password: str) -> None:
+        """
+        Updates the password of the user.
+
+        :param old_password: The user's original password.
+        :type old_password: :py:obj:`str`
+        :param new_password: A new password.
+        :type new_password: :py:obj:`str`
+        :raises WialonError: If something goes wrong with Wialon.
+        :returns: Nothing.
+        :rtype: :py:obj:`None`
+
+        """
         self.session.wialon_api.user_update_password(
             **{
                 "userId": self.id,

terminusgps/wialon/session.py

@@ -1,65 +1,319 @@
-import os
-
 from wialon.api import Wialon, WialonError
+from django.conf import settings
+from django.core.exceptions import ImproperlyConfigured
 
-from .errors import WialonLogoutError, WialonLoginError
+from .errors import (
+    WialonLogoutError,
+    WialonLoginError,
+    WialonSessionDuplicationError,
+    WialonSessionInvalidError,
+)
 
 
 class WialonSession:
-    def __init__(self, token: str | None = None, sid: str | None = None) -> None:
+    def __init__(
+        self,
+        token: str | None = None,
+        sid: str | None = None,
+        scheme: str = "https",
+        host: str = "hst-api.wialon.com",
+        port: int = 443,
+    ) -> None:
+        """
+        Starts or continues a Wialon API session.
+
+        :param token: An optional Wialon API token. Default is :confval:`WIALON_TOKEN`.
+        :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.
+        :returns: Nothing.
+        :rtype: :py:obj:`None`
+
+        """
+        if not hasattr(settings, "WIALON_TOKEN"):
+            raise ImproperlyConfigured("'WIALON_TOKEN' setting is required.")
+        if not hasattr(settings, "WIALON_ADMIN_ID"):
+            raise ImproperlyConfigured("'WIALON_ADMIN_ID' setting is required.")
+
+        self.wialon_api = Wialon(scheme=scheme, host=host, port=port, sid=sid)
         self.token = token
-        self.wialon_api = Wialon(
-            scheme="https", host="hst-api.wialon.com", port=443, sid=sid
-        )
+        self._username = None
+        self._gis_sid = None
+        self._hw_gp_ip = None
+        self._wsdk_version = None
+        self._uid = None
+
+    def __enter__(self) -> "WialonSession":
+        assert self.token, "Wialon API token was not set"
+        self.login(self.token)
+        return self
+
+    def __exit__(self, *args, **kwargs) -> None:
+        self.logout()
+
+    @property
+    def active(self) -> bool:
+        """
+        Whether or not the Wialon session is currently active.
+
+        :type: :py:obj:`bool`
+        :value: :py:obj:`False`
+        """
+        is_active = False
+
+        try:
+            response = self.wialon_api.core_duplicate(**{"restore": 1})
+            is_active = bool(response)
+        except WialonError as e:
+            raise WialonSessionInvalidError(self.id, e)
+        finally:
+            return is_active
+
+    @property
+    def gis_geocode(self) -> str | None:
+        """
+        Gis geocode URL.
+
+        :type: :py:obj:`str` | :py:obj:`None`
+        :value: :py:obj:`None`
+
+        """
+        return self._gis_geocode
+
+    @property
+    def gis_render(self) -> str | None:
+        """
+        Gis rendering URL.
+
+        :type: :py:obj:`str` | :py:obj:`None`
+        :value: :py:obj:`None`
+
+        """
+        return self._gis_render
+
+    @property
+    def gis_routing(self) -> str | None:
+        """
+        Gis routing URL.
+
+        :type: :py:obj:`str` | :py:obj:`None`
+        :value: :py:obj:`None`
+
+        """
+        return self._gis_routing
+
+    @property
+    def gis_search(self) -> str | None:
+        """
+        Gis search URL.
+
+        :type: :py:obj:`str` | :py:obj:`None`
+        :value: :py:obj:`None`
+
+        """
+        return self._gis_search
+
+    @property
+    def gis_sid(self) -> str | None:
+        """
+        Gis session id.
+
+        :type: :py:obj:`str` | :py:obj:`None`
+        :value: :py:obj:`None`
+
+        """
+        return self._gis_sid
+
+    @property
+    def host(self) -> str | None:
+        """
+        IP of the client hosting the Wialon session.
+
+        :type: :py:obj:`str` | :py:obj:`None`
+        :value: :py:obj:`None`
+
+        """
+        return self._host
+
+    @property
+    def hw_gw_ip(self) -> str | None:
+        """
+        Hardware gateway IP.
+
+        :type: :py:obj:`str` | :py:obj:`None`
+        :value: :py:obj:`None`
+
+        """
+        return self._hw_gw_ip
+
+    @property
+    def hw_gw_dns(self) -> str | None:
+        """
+        Hardware gateway domain name, should evaluate to :py:attr:`hw_gw_ip` if present.
+
+        :type: :py:obj:`str` | :py:obj:`None`
+        :value: :py:obj:`None`
+
+        """
+        return self._hw_gw_dns
+
+    @property
+    def wsdk_version(self) -> str | None:
+        """
+        The Wialon Source Developer Kit (WSDK) version number of the session.
+
+        :type: :py:obj:`str` | :py:obj:`None`
+        :value: :py:obj:`None`
+
+        """
+        return self._wsdk_version
+
+    @property
+    def uid(self) -> str | None:
+        """
+        A Wialon user ID this session is operating as.
+
+        :type: :py:obj:`str` | :py:obj:`None`
+        :value: :py:obj:`None`
+        """
+        return self._uid
+
+    @property
+    def username(self) -> str | None:
+        """
+        A Wialon username the session is operating as.
+
+        :type: :py:obj:`str` | :py:obj:`None`
+        :value: :py:obj:`None`
+
+        """
+        return self._username
 
     @property
     def id(self) -> str | None:
+        """
+        Shortcut property for :py:attr:`WialonSession.wialon_api.sid`.
+
+        Returns :py:obj:`None` if the session wasn't logged in.
+
+        :type: :py:obj:`str` | :py:obj:`None`
+        :value: :py:obj:`None`
+
+        """
         return self.wialon_api.sid
 
     @property
-    def token(self) -> str | None:
+    def token(self) -> str:
+        """
+        A Wialon API token set during :py:meth:`WialonSession.__init__`.
+
+        Default token value is :confval:`WIALON_TOKEN`.
+
+        :type: :py:obj:`str`
+        :value: :confval:`WIALON_TOKEN`
+
+        """
         return self._token
 
     @token.setter
     def token(self, value: str | None = None) -> None:
-        self._token = value if value else os.getenv("WIALON_TOKEN")
+        self._token = value if value else settings.WIALON_TOKEN
 
-    def __enter__(self) -> "WialonSession":
-        self.login(self.token)
-        return self
+    def duplicate(self, username: str | None = None, continued: bool = False) -> str:
+        """
+        Duplicates the active Wialon API session.
 
-    def __exit__(self, exc_type, exc_value, exc_tb) -> None:
-        self.logout()
-        return
-
-    def _deconstruct_login_response(self, login_response: dict) -> None:
-        self.wialon_api.sid = login_response.get("eid", "")
-        self.username = login_response.get("user", {}).get("nm")
-        self.uid = login_response.get("user", {}).get("id")
-        self.base_url = login_response.get("base_url", "")
-        self.gis_sid = login_response.get("gis_sid", "")
-        self.host = login_response.get("host", "")
-        self.hw_gp_ip = login_response.get("hw_gw_ip", "")
-        self.video_service_url = login_response.get("video_service_url", "")
-        self.wsdk_version = login_response.get("wsdk_version", "")
-        return
-
-    def login(self, token: str | None = None) -> None:
-        """Logs into the Wialon API and starts a new session."""
-        if not token:
-            raise ValueError("Must provide a Wialon API token to login with.")
+        :param username: A Wialon user to operate as in the session.
+        :type username: :py:obj:`str` | :py:obj:`None`
+        :param continue_session: Whether or not the original session id should be valid after duplication.
+        :type continue_session: :py:obj:`bool`
+        :raises WialonSessionDuplicationError: If the Wialon session was not duplicated.
+        :raises AssertionError: If the session was already active.
+        :returns: The new session id.
+        :rtype: :py:obj:`str`
+
+        """
         try:
-            login_response = self.wialon_api.token_login(
-                **{"token": token, "fl": sum([0x1, 0x2, 0x20])}
+            assert self.active, "Cannot duplicate an inactive session."
+            response = self.wialon_api.core_duplicate(
+                **{"operateAs": username, "continueCurrentSession": continued}
             )
-        except WialonError as e:
+            self._set_login_response(response)
+            return response.get("eid")
+        except (WialonError, AssertionError) as e:
+            raise WialonSessionDuplicationError(self.id, e)
+
+    def login(self, token: str, flags: int = sum([0x1, 0x2, 0x20])) -> str:
+        """
+        Logs into the Wialon API and starts a new session.
+
+        :param token: An active Wialon API token.
+        :type token: :py:obj:`str`
+        :param user_id: A user to operate as in the Wialon API session.
+        :type user_id: :py:obj:`str` | :py:obj:`None`
+        :param flags: A login response flag integer.
+        :type flags: :py:obj:`int`
+        :raises WialonLoginError: If the login fails.
+        :raises AssertionError: If the session was already active.
+        :returns: The new session id.
+        :rtype: :py:obj:`str`
+
+        """
+        try:
+            assert not self.active, "Cannot login to an active session."
+            response = self.wialon_api.token_login(**{"token": token, "fl": flags})
+            self._set_login_response(response)
+            return response.get("eid")
+        except (WialonError, AssertionError) as e:
             raise WialonLoginError(token, e)
-        else:
-            self._deconstruct_login_response(login_response)
 
     def logout(self) -> None:
-        """Logs out of the Wialon API and raises an error if the session was not destroyed."""
-        sid: str = str(self.id)
-        logout_response = self.wialon_api.core_logout({})
-        if logout_response.get("error") != 0:
-            raise WialonLogoutError(sid)
+        """
+        Logs out of the Wialon API session.
+
+        :raises WialonLogoutError: If the logout fails.
+        :returns: Nothing.
+        :rtype: :py:obj:`None`
+
+        """
+        response: dict = self.wialon_api.core_logout({})
+        if response.get("error") != 0:
+            raise WialonLogoutError(str(self.id))
+
+    def _set_login_response(self, login_response: dict) -> None:
+        """
+        Sets the Wialon API session's attributes based on a login response.
+
+        :param login_response: A response returned from :py:meth:`login` or :py:meth:`duplicate`.
+        :type login_response: :py:obj:`dict`
+        :returns: Nothing.
+        :rtype: :py:obj:`None`
+
+        """
+        self.wialon_api.sid = login_response.get("eid")
+        self._gis_geocode = login_response.get("gis_geocode")
+        self._gis_render = login_response.get("gis_render")
+        self._gis_routing = login_response.get("gis_routing")
+        self._gis_search = login_response.get("gis_search")
+        self._gis_sid = login_response.get("gis_sid")
+        self._host = login_response.get("host")
+        self._hw_gw_dns = login_response.get("hw_gw_dns")
+        self._hw_gw_ip = login_response.get("hw_gw_ip")
+        self._uid = login_response.get("user", {}).get("id")
+        self._nm = login_response.get("user", {}).get("nm")
+        self._username = login_response.get("au")
+        self._video_service_url = login_response.get("video_service_url")
+        self._wsdk_version = login_response.get("wsdk_version")
+
+
+def main() -> None:
+    session = WialonSession()
+    session.login(token=settings.WIALON_TOKEN)
+    session.duplicate(username="chrissyron@gmail.com", continued=False)
+    session.logout()
+    return
+
+
+if __name__ == "__main__":
+    main()

terminusgps/wialon/utils.py

@@ -5,15 +5,6 @@ from .session import WialonSession
 from .flags import DATAFLAG_UNIT_BASE
 
 
-def repopulate(func):
-    def wrapper(self, *args, **kwargs):
-        result = func(self, *args, **kwargs)
-        self.populate()
-        return result
-
-    return wrapper
-
-
 def is_unique(value: str, session: WialonSession, items_type: str = "avl_unit") -> bool:
     """Determines if the value is unique among Wialon objects of type 'items_type'."""
     result = session.wialon_api.core_check_unique(

python_terminusgps-1.4.6.dist-info/RECORD

@@ -1,24 +0,0 @@
-terminusgps/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-terminusgps/authorizenet/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-terminusgps/authorizenet/auth.py,sha256=TBq_PY_-kUlg7ZOK4iWxJbpOnMkM5170j3ZyWSsuq6E,472
-terminusgps/aws/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-terminusgps/aws/secrets.py,sha256=kgRA77rs0mD4berWRLkPtJLOe4Grf--o5f8NzwQqXCk,360
-terminusgps/wialon/__init__.py,sha256=vDlkEycUXBKRaZHJXpZIKis3v3Lmp1qjt9FNx3PtjZk,166
-terminusgps/wialon/constants.py,sha256=dsQaNt3TIjIZbr_m94KmBGFdrqe6HER2r6lol3X8QpU,2802
-terminusgps/wialon/errors.py,sha256=AFnu6RHPFlJ6x3zAC-iKn4x_8PyUgheY2IOSEv02Sp4,880
-terminusgps/wialon/flags.py,sha256=-OoH-eZM54yjRqxsAXL8VImdQu_7C0OAxCrFqaCEuko,13510
-terminusgps/wialon/session.py,sha256=A8vJbofARlOMXxc_ihSbgPSPM5B1tRtS8EjvNRB2wS8,2327
-terminusgps/wialon/utils.py,sha256=Y3N_U1-KDROvGZrVDECvBuAy1iJUazvisfPSCpsn-gg,2052
-terminusgps/wialon/items/__init__.py,sha256=3BVthghekMvhMQSzQgBMlD_phxmKSmp3Zvmo-z0O8Bs,211
-terminusgps/wialon/items/account.py,sha256=j6CoNe-NCqGOtYtoG5SY-pHviqDKIVQOsWm7zxF0yP0,504
-terminusgps/wialon/items/base.py,sha256=bmqcCmTPNXaZJA1NOXHuPvby2LNM6pwNN1jNrGg5XwU,4254
-terminusgps/wialon/items/resource.py,sha256=uK93I9dPKzZbVyxpEhfR2OdJMabYzB4vC2_FgYLlRu4,810
-terminusgps/wialon/items/retranslator.py,sha256=HkL_asa_4VTRDvl7e6I9rtUhF0PBV3HRmecgesneHUM,839
-terminusgps/wialon/items/route.py,sha256=qOHPN_rejwiGqvwWzlwmUIAIyc3lKavCalf8ki66rx0,760
-terminusgps/wialon/items/unit.py,sha256=i9rZfcX7MFkSedwaJbSzbI9CLC9Xd50R-cqwSG36S18,2828
-terminusgps/wialon/items/unit_group.py,sha256=CHcBS5hjiCKYsFts_tvc93V3rwu8wm5Ip-ykMM4_aEo,2548
-terminusgps/wialon/items/user.py,sha256=3eEPOr4ixnK-5b2J4_Rlh3p2lbo5HxecTO-0109vdKc,2919
-python_terminusgps-1.4.6.dist-info/METADATA,sha256=AQQYHavcVlNHuT8Ys5aG35kgbUjByjjdzB5dC4Ygz_E,882
-python_terminusgps-1.4.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-python_terminusgps-1.4.6.dist-info/licenses/COPYING,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-python_terminusgps-1.4.6.dist-info/RECORD,,

terminusgps/wialon/items/account.py

@@ -1,15 +0,0 @@
-from terminusgps.wialon.items.base import WialonBase
-
-
-class WialonAccount(WialonBase):
-    def create(self, **kwargs) -> int | None:
-        if not kwargs.get("resource_id"):
-            raise ValueError("'resource_id' is required for creation.")
-
-        self.session.wialon_api.account_create_account(
-            **{
-                "itemId": kwargs["resource_id"],
-                "plan": kwargs.get("plan", "terminusgps_ext_hist"),
-            }
-        )
-        return int(kwargs["resource_id"])