python-terminusgps 1.4.7__tar.gz → 1.5.0__tar.gz

{python_terminusgps-1.4.7 → python_terminusgps-1.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-terminusgps
-Version: 1.4.7
+Version: 1.5.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.4.7 → python_terminusgps-1.5.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "python-terminusgps"
-version = "1.4.7"
+version = "1.5.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.4.7 → python_terminusgps-1.5.0}/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

{python_terminusgps-1.4.7 → python_terminusgps-1.5.0}/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:

python_terminusgps-1.5.0/terminusgps/wialon/items/unit.py

@@ -0,0 +1,152 @@
+from urllib.parse import quote_plus
+
+from terminusgps.wialon import flags
+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"):
+            raise ValueError("'name' is required on creation.")
+        if not kwargs.get("hw_type"):
+            raise ValueError("'hw_type' is required on creation.")
+
+        response = self.session.wialon_api.core_create_unit(
+            **{
+                "creatorId": kwargs["creator_id"],
+                "name": kwargs["name"],
+                "hwTypeId": kwargs["hw_type"],
+                "dataFlags": flags.DATAFLAG_UNIT_BASE,
+            }
+        )
+        return response.get("item", {}).get("id")
+
+    def execute_command(
+        self,
+        name: str,
+        link_type: str,
+        timeout: int = 5,
+        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,
+                "commandName": name,
+                "linkType": link_type,
+                "timeout": timeout,
+                "flags": flags,
+                "param": param if param else {},
+            }
+        )
+
+    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}
+        )
+
+    def activate(self) -> None:
+        """
+        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)}
+        )
+
+    def deactivate(self) -> None:
+        """
+        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)}
+        )
+
+    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 = []
+        for field in self.cfields | self.afields:
+            if field["n"] == "to_number":
+                phones.append(field["v"])
+        return phones

python_terminusgps-1.5.0/terminusgps/wialon/items/unit_group.py

@@ -0,0 +1,152 @@
+from terminusgps.wialon import constants, flags
+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"):
+            raise ValueError("'name' is required on creation.")
+
+        response = self.session.wialon_api.core_create_unit_group(
+            **{
+                "creatorId": kwargs["creator_id"],
+                "name": kwargs["name"],
+                "dataFlags": flags.DATAFLAG_UNIT_BASE,
+            }
+        )
+        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:
+        """
+        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": {
+                    "itemsType": "avl_unit_group",
+                    "propName": "sys_id",
+                    "propValueMask": str(self.id),
+                    "sortType": "sys_id",
+                    "propType": "property",
+                    "or_logic": 0,
+                },
+                "force": 1,
+                "flags": flags.DATAFLAG_UNIT_BASE,
+                "from": 0,
+                "to": 0,
+            }
+        )
+        return [str(unit_id) for unit_id in response.get("items")[0].get("u", [])]

python_terminusgps-1.5.0/terminusgps/wialon/items/user.py

@@ -0,0 +1,183 @@
+from urllib.parse import quote_plus
+
+from terminusgps.wialon import flags
+from terminusgps.wialon.items.base import WialonBase
+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"):
+            raise ValueError("'name' is required on creation.")
+        if not kwargs.get("password"):
+            raise ValueError("'password' is required on creation.")
+
+        response = self.session.wialon_api.core_create_user(
+            **{
+                "creatorId": kwargs["creator_id"],
+                "name": kwargs["name"],
+                "password": kwargs["password"],
+                "dataFlags": flags.DATAFLAG_UNIT_BASE,
+            }
+        )
+        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,
+                "directAccess": True,
+                "itemSuperclass": hw_type,
+                "flags": 0x2,
+            }
+        )
+
+    @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 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 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,
+                "oldPassword": old_password,
+                "newPassword": new_password,
+            }
+        )

{python_terminusgps-1.4.7 → python_terminusgps-1.5.0}/terminusgps/wialon/session.py

@@ -1,12 +1,15 @@
-import os
-
 from wialon.api import Wialon, WialonError
+from django.conf import settings
+from django.core.exceptions import ImproperlyConfigured
 
 from .errors import WialonLogoutError, WialonLoginError
 
 
 class WialonSession:
     def __init__(self, token: str | None = None, sid: str | None = None) -> None:
+        if not hasattr(settings, "WIALON_TOKEN"):
+            raise ImproperlyConfigured("'WIALON_TOKEN' setting is required.")
+
         self.token = token
         self.wialon_api = Wialon(
             scheme="https", host="hst-api.wialon.com", port=443, sid=sid
@@ -22,10 +25,11 @@ class WialonSession:
 
     @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)
+        if not self.wialon_api.sid:
+            self.login(self.token)
         return self
 
     def __exit__(self, exc_type, exc_value, exc_tb) -> None:

{python_terminusgps-1.4.7 → python_terminusgps-1.5.0}/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.7 → python_terminusgps-1.5.0}/uv.lock

@@ -176,7 +176,7 @@ wheels = [
 
 [[package]]
 name = "python-terminusgps"
-version = "1.4.6"
+version = "1.4.7"
 source = { editable = "." }
 dependencies = [
     { name = "argparse" },

python_terminusgps-1.4.7/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")

python_terminusgps-1.4.7/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"])

python_terminusgps-1.4.7/terminusgps/wialon/items/unit.py

@@ -1,90 +0,0 @@
-from urllib.parse import quote_plus
-
-from terminusgps.wialon import flags
-from terminusgps.wialon.items.base import WialonBase, repopulate
-
-
-class WialonUnit(WialonBase):
-    def create(self, **kwargs) -> int | None:
-        if not kwargs.get("creator_id"):
-            raise ValueError("'creator_id' is required on creation.")
-        if not kwargs.get("name"):
-            raise ValueError("'name' is required on creation.")
-        if not kwargs.get("hw_type"):
-            raise ValueError("'hw_type' is required on creation.")
-
-        response = self.session.wialon_api.core_create_unit(
-            **{
-                "creatorId": kwargs["creator_id"],
-                "name": kwargs["name"],
-                "hwTypeId": kwargs["hw_type"],
-                "dataFlags": flags.DATAFLAG_UNIT_BASE,
-            }
-        )
-        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,
-        link_type: str,
-        timeout: int = 5,
-        flags: int = 0,
-        param: dict | None = None,
-    ) -> None:
-        self.session.wialon_api.unit_exec_cmd(
-            **{
-                "itemId": self.id,
-                "commandName": name,
-                "linkType": link_type,
-                "timeout": timeout,
-                "flags": flags,
-                "param": param if param else {},
-            }
-        )
-
-    def set_access_password(self, password: str) -> None:
-        self.session.wialon_api.unit_update_access_password(
-            **{"itemId": self.id, "accessPassword": password}
-        )
-
-    @repopulate
-    def activate(self) -> None:
-        if self.is_active:
-            return
-
-        self.session.wialon_api.unit_set_active(
-            **{"itemId": self.id, "active": int(True)}
-        )
-
-    @repopulate
-    def deactivate(self) -> None:
-        if not self.is_active:
-            return
-
-        self.session.wialon_api.unit_set_active(
-            **{"itemId": self.id, "active": int(False)}
-        )
-
-    @repopulate
-    def assign_phone(self, phone: str) -> None:
-        self.session.wialon_api.unit_update_phone(
-            **{"itemId": self.id, "phoneNumber": quote_plus(phone)}
-        )
-
-    def get_phone_numbers(self) -> list[str]:
-        phones = []
-        if self.phone:
-            phones.append(self.phone)
-        for field in self.cfields | self.afields:
-            if field["n"] == "to_number":
-                phones.append(field["v"])
-        return phones

python_terminusgps-1.4.7/terminusgps/wialon/items/unit_group.py

@@ -1,69 +0,0 @@
-from terminusgps.wialon import constants, flags
-from terminusgps.wialon.items.base import WialonBase
-
-
-class WialonUnitGroup(WialonBase):
-    def create(self, **kwargs) -> int | None:
-        if not kwargs.get("creator_id"):
-            raise ValueError("'creator_id' is required on creation.")
-        if not kwargs.get("name"):
-            raise ValueError("'name' is required on creation.")
-
-        response = self.session.wialon_api.core_create_unit_group(
-            **{
-                "creatorId": kwargs["creator_id"],
-                "name": kwargs["name"],
-                "dataFlags": flags.DATAFLAG_UNIT_BASE,
-            }
-        )
-        return response.get("item", {}).get("id")
-
-    def _update_items(self, new_items: list[str]) -> None:
-        self.session.wialon_api.unit_group_update_units(
-            **{"itemId": self.id, "units": new_items}
-        )
-
-    def is_member(self, item: WialonBase) -> 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:
-        self.session.wialon_api.user_update_item_access(
-            **{"userId": item.id, "itemId": self.id, "accessMask": access_mask}
-        )
-
-    def revoke_access(self, item: WialonBase) -> None:
-        self.session.wialon_api.user_update_item_access(
-            **{"userId": item.id, "itemId": self.id, "accessMask": 0}
-        )
-
-    def add_item(self, item: WialonBase) -> 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"
-        new_items: list[str] = self.items.copy()
-        new_items.remove(str(item.id))
-        self._update_items(new_items)
-
-    @property
-    def items(self) -> list[str]:
-        response = self.session.wialon_api.core_search_items(
-            **{
-                "spec": {
-                    "itemsType": "avl_unit_group",
-                    "propName": "sys_id",
-                    "propValueMask": str(self.id),
-                    "sortType": "sys_id",
-                    "propType": "property",
-                    "or_logic": 0,
-                },
-                "force": 1,
-                "flags": flags.DATAFLAG_UNIT_BASE,
-                "from": 0,
-                "to": 0,
-            }
-        )
-        return [str(unit_id) for unit_id in response.get("items")[0].get("u", [])]

python_terminusgps-1.4.7/terminusgps/wialon/items/user.py

@@ -1,79 +0,0 @@
-from urllib.parse import quote_plus
-
-from terminusgps.wialon import flags
-from terminusgps.wialon.items.base import WialonBase
-from terminusgps.wialon import constants
-
-
-class WialonUser(WialonBase):
-    def create(self, **kwargs) -> int | None:
-        if not kwargs.get("creator_id"):
-            raise ValueError("'creator_id' is required on creation.")
-        if not kwargs.get("name"):
-            raise ValueError("'name' is required on creation.")
-        if not kwargs.get("password"):
-            raise ValueError("'password' is required on creation.")
-
-        response = self.session.wialon_api.core_create_user(
-            **{
-                "creatorId": kwargs["creator_id"],
-                "name": kwargs["name"],
-                "password": kwargs["password"],
-                "dataFlags": flags.DATAFLAG_UNIT_BASE,
-            }
-        )
-        return response.get("item", {}).get("id")
-
-    def _get_access_response(self, hw_type: str) -> dict:
-        return self.session.wialon_api.user_get_items_access(
-            **{
-                "userId": self.id,
-                "directAccess": True,
-                "itemSuperclass": hw_type,
-                "flags": 0x2,
-            }
-        )
-
-    @property
-    def units(self) -> list[str]:
-        response = self._get_access_response(hw_type="avl_unit")
-        return [key for key in response.keys()]
-
-    @property
-    def groups(self) -> list[str]:
-        response = self._get_access_response(hw_type="avl_unit_group")
-        return [key for key in response.keys()]
-
-    def has_access(self, other: WialonBase) -> 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:
-        self.add_cproperty(("phone", quote_plus(phone)))
-
-    def assign_email(self, email: str) -> None:
-        """Assigns an email address to the Wialon user."""
-        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."""
-        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:
-        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:
-        self.session.wialon_api.user_update_password(
-            **{
-                "userId": self.id,
-                "oldPassword": old_password,
-                "newPassword": new_password,
-            }
-        )