python-terminusgps 37.3.0__tar.gz → 37.4.0__tar.gz

{python_terminusgps-37.3.0 → python_terminusgps-37.4.0}/PKG-INFO

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

{python_terminusgps-37.3.0 → python_terminusgps-37.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "python-terminusgps"
-version = "37.3.0"
+version = "37.4.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-37.4.0/terminusgps/wialon/renderer.py

@@ -0,0 +1,188 @@
+import datetime
+import secrets
+import sys
+import typing
+
+from .session import WialonSession
+
+
+class WialonMapRenderer:
+    def __init__(self, session: WialonSession) -> None:
+        self.session = session
+        self.layers = {}
+
+    def create_messages_layer(
+        self,
+        name: str,
+        unit_id: int | str,
+        time_from: datetime.datetime,
+        time_to: datetime.datetime,
+        enable_trip_detector: bool = False,
+        enable_directional_arrows: bool = False,
+        enable_points: bool = False,
+        enable_annotations: bool = False,
+        track_color: str = "FFFF0000",
+        point_color: str = "7F00FF00",
+        track_width: int = 12,
+        flags: int = 0x0004,
+    ) -> dict[str, typing.Any]:
+        """
+        Creates a messages layer and adds it to the renderer.
+
+        :param name: Name of the new messages layer.
+        :type name: :py:obj:`str`
+        :param unit_id: A Wialon unit id to retrieve messages for.
+        :type unit_id: :py:obj:`int` | :py:obj:`str`
+        :param time_from: Start time for the messages interval.
+        :type time_from: :py:obj:`~datetime.datetime`
+        :param time_to: End time for the messages interval.
+        :type time_to: :py:obj:`~datetime.datetime`
+        :param enable_trip_detector: Whether or not to enable the trip detector on the layer. Default is :py:obj:`False`.
+        :type enable_trip_detector: :py:obj:`bool`
+        :param enable_directional_arrows: Whether or not to enable directional arrows on the layer. Default is :py:obj:`False`.
+        :type enable_directional_arrows: :py:obj:`bool`
+        :param enable_points: Whether or not to enable points of interest on the layer. Default is :py:obj:`False`.
+        :type enable_points: :py:obj:`bool`
+        :param enable_annotations: Whether or not to annotate the points of interest on the layer. Default is :py:obj:`False`.
+        :type enable_annotations: :py:obj:`bool`
+        :param track_color: ARGB color to use for the track on the layer. Default is :py:obj:`"FFFF0000"`.
+        :type track_color: :py:obj:`str`
+        :param point_color: ARGB color to use for the points of interest on the layer. Default is :py:obj:`"7F00FF00"`.
+        :type point_color: :py:obj:`str`
+        :param track_width: Width (in pixels) of the track on the layer. Default is :py:obj:`12`.
+        :type track_width: :py:obj:`int`
+        :param flags: Determines which points of interest will be rendered on the layer. Default is :py:obj:`0x0004`.
+        :type flags: :py:obj:`int`
+        :returns: A Wialon API response.
+        :rtype: :py:obj:`dict`
+
+        """
+        response = self.session.wialon_api.render_create_messages_layer(
+            **{
+                "layerName": name,
+                "itemId": int(unit_id),
+                "timeFrom": time_from.timestamp(),
+                "timeTo": time_to.timestamp(),
+                "tripDetector": int(enable_trip_detector),
+                "trackColor": "trip" if enable_trip_detector else track_color,
+                "trackWidth": track_width,
+                "arrows": int(enable_directional_arrows),
+                "points": int(enable_points),
+                "pointColor": point_color,
+                "annotations": int(enable_annotations),
+                "flags": flags,
+            }
+        )
+        self.layers.setdefault(name, {"enabled": False})
+        return response if response else {}
+
+    def enable_layer(self, name: str) -> None:
+        """
+        Enables a layer by name in the renderer.
+
+        :param name: A layer name.
+        :type name: :py:obj:`str`
+        :returns: Nothing.
+        :rtype: :py:obj:`None`
+
+        """
+        if not self.layers[name]["enabled"]:
+            self.session.wialon_api.render_enable_layer(
+                **{"layerName": name, "enable": int(True)}
+            )
+            self.layers[name]["enabled"] = True
+
+    def disable_layer(self, name: str) -> None:
+        """
+        Disables a layer by name in the renderer.
+
+        :param name: A layer name.
+        :type name: :py:obj:`str`
+        :returns: Nothing.
+        :rtype: :py:obj:`None`
+
+        """
+        if self.layers[name]["enabled"]:
+            self.session.wialon_api.render_enable_layer(
+                **{"layerName": name, "enable": int(False)}
+            )
+            self.layers[name]["enabled"] = False
+
+    def remove_layer(self, name: str) -> None:
+        """
+        Removes a layer by name in the renderer.
+
+        :param name: A layer name.
+        :type name: :py:obj:`str`
+        :returns: Nothing.
+        :rtype: :py:obj:`None`
+
+        """
+        self.session.wialon_api.render_remove_layer(**{"layerName": name})
+        self.layers.pop(name)
+
+    def set_locale(
+        self,
+        timezone: int,
+        lang: str = "en",
+        flags: int = 1,
+        date_format: str = "%Y-%m-%E %H:%M:%S",
+        density: int = 1,
+    ) -> None:
+        """
+        Updates the locale options for the renderer.
+
+        :param timezone: Timezone offset to use in the renderer.
+        :type timezone: :py:obj:`int`
+        :param lang: A 2-character language code. Default is :py:obj:`"en"`.
+        :type lang: :py:obj:`str`
+        :param flags: Measurement system to use in the renderer.
+        :type flags: :py:obj:`int`
+        :param date_format: Format to use for dates in the renderer.
+        :type date_format: :py:obj:`str`
+        :param density: Tile density to use in the renderer.
+        :type density: :py:obj:`int`
+
+        Flag options:
+
+        +-------------+--------------+
+        | value       | measurement  |
+        +=============+==============+
+        | :py:obj:`0` | Metric       |
+        +-------------+--------------+
+        | :py:obj:`1` | US           |
+        +-------------+--------------+
+        | :py:obj:`2` | Imperial     |
+        +-------------+--------------+
+
+        Density options:
+
+        +-------------+-----------+-------+
+        | value       | tile size | ratio |
+        +=============+===========+=======+
+        | :py:obj:`1` | 256*256   | 1     |
+        +-------------+-----------+-------+
+        | :py:obj:`2` | 378*378   | 1.5   |
+        +-------------+-----------+-------+
+        | :py:obj:`3` | 512*512   | 2     |
+        +-------------+-----------+-------+
+        | :py:obj:`4` | 768*768   | 3     |
+        +-------------+-----------+-------+
+        | :py:obj:`5` | 1024*1024 | 4     |
+        +-------------+-----------+-------+
+
+        """
+        self.session.wialon_api.render_set_locale(
+            **{
+                "tzOffset": timezone,
+                "language": lang,
+                "flags": flags,
+                "formatDate": date_format,
+                "density": density,
+            }
+        )
+
+    def generate_render_url(self, x: int, y: int, z: int) -> str:
+        sid = self.session.id
+        random_num = secrets.SystemRandom(sid).randint(1, sys.maxsize)
+        return f"https://hst-api.wialon.com/adfurl{random_num}/avl_render/{x}_{y}_{z}/{sid}.png"

{python_terminusgps-37.3.0 → python_terminusgps-37.4.0}/terminusgps/wialon/session.py

@@ -4,54 +4,59 @@ import typing
 
 import wialon.api
 from django.conf import settings
+from loguru import logger
+
+from . import flags as wialon_flags
+
+logger.disable(__name__)
 
 
 @dataclasses.dataclass
 class WialonAPICall:
     action: str
     timestamp: datetime.datetime
-    args: tuple
-    kwargs: dict
     result: typing.Any = None
     error: Exception | None = None
 
 
 class Wialon(wialon.api.Wialon):
-    def __init__(self, token: str, timeout: int = 300, *args, **kwargs) -> None:
+    def __init__(self, token: str, *args, **kwargs) -> None:
         super().__init__(*args, **kwargs)
         self.token = token
         self.call_history: list[WialonAPICall] = []
-        self.last_call_datetime = None
-        self.timeout = timeout
 
     @property
     def total_calls(self) -> int:
         return len(self.call_history)
 
+    @property
+    def call_actions(self) -> list[str]:
+        return [call.action for call in self.call_history]
+
     def token_login(self, *args, **kwargs) -> typing.Any:
-        kwargs["appName"] = "python-terminusgps"
+        kwargs.setdefault("appName", "python-terminusgps")
         return self.call("token_login", *args, **kwargs)
 
-    def call(self, action_name: str, *argc, **kwargs) -> typing.Any:
-        now = datetime.datetime.now()
-
+    def call(self, action_name: str, *argc, **kwargs) -> dict[str, typing.Any]:
         try:
+            timestamp = datetime.datetime.now()
             result = super().call(action_name, *argc, **kwargs)
             call_record = WialonAPICall(
-                action=action_name,
-                timestamp=now,
-                args=argc,
-                kwargs=kwargs,
-                result=result,
+                action=action_name, timestamp=timestamp, result=result
             )
             return result
         except wialon.api.WialonError as e:
             call_record = WialonAPICall(
-                action=action_name, timestamp=now, args=argc, kwargs=kwargs, error=e
+                action=action_name, timestamp=timestamp, error=e
             )
-            return None
+            return {}
         finally:
-            self.last_call_datetime = now
+            if call_record.result:
+                logger.debug("Successfully executed '{}'", action_name)
+            elif call_record.error:
+                logger.warning(
+                    "Failed to execute '{}': {}", action_name, call_record.error
+                )
             self.call_history.append(call_record)
 
 
@@ -63,7 +68,6 @@ class WialonSession:
         scheme: str = "https",
         host: str = "hst-api.wialon.com",
         port: int = 443,
-        timeout: int = 300,
     ) -> None:
         """
         Starts or continues a Wialon API session.
@@ -76,10 +80,10 @@ class WialonSession:
         :type scheme: :py:obj:`str`
         :param host: Wialon API host url. Default is ``"hst-api.wialon.com"``.
         :type host: :py:obj:`str`
+        :param host: Wialon API rendering url. Default is ``"render-maps.wialon.com"``.
+        :type host: :py:obj:`str`
         :param port: Wialon API host port. Default is ``443``.
         :type port: :py:obj:`int`
-        :param timeout: How long in seconds a session can be active for. Default is ``500`` (5 min).
-        :type timeout: :py:obj:`int`
         :returns: Nothing.
         :rtype: :py:obj:`None`
 
@@ -92,12 +96,7 @@ class WialonSession:
         self._wsdk_version = None
         self._uid = None
         self._wialon_api = Wialon(
-            scheme=scheme,
-            host=host,
-            port=port,
-            sid=sid,
-            timeout=timeout,
-            token=self.token,
+            scheme=scheme, host=host, port=port, sid=sid, token=self.token
         )
 
     def __str__(self) -> str:
@@ -110,12 +109,12 @@ class WialonSession:
         """
         Logs into the Wialon API using :py:meth:`login`.
 
-        :raises AssertionError: If the Wialon API token was not set.
+        :raises AssertionError: If the session's Wialon API :py:attr:`token` wasn't set.
         :returns: A valid Wialon API session.
         :rtype: :py:obj:`~terminusgps.wialon.session.WialonSession`
 
         """
-        assert self.token, "Wialon API token was not set"
+        assert self.token, "Wialon API token wasn't set."
         self.login(self.token)
         return self
 
@@ -279,7 +278,7 @@ class WialonSession:
         """
         return str(self._token)
 
-    def login(self, token: str, flags: int = sum([0x1, 0x2, 0x20])) -> str:
+    def login(self, token: str, flags: int | None = None) -> str:
         """
         Logs into the Wialon API and starts a new session.
 
@@ -293,10 +292,17 @@ class WialonSession:
         :rtype: :py:obj:`str`
 
         """
+        if flags is None:
+            flags = (
+                wialon_flags.TokenFlag.ONLINE_TRACKING
+                | wialon_flags.TokenFlag.VIEW_ACCESS
+                | wialon_flags.TokenFlag.MANAGE_NONSENSITIVE
+            )
         try:
+            print(f"{type(flags) = }")
             response = self.wialon_api.token_login(**{"token": token, "fl": flags})
             self._set_login_response(response)
-            return response.get("eid")
+            return response.get("eid", "")
         except (wialon.api.WialonError, ValueError):
             raise
 
@@ -312,13 +318,15 @@ class WialonSession:
         self.wialon_api.sid = None
 
         if response.get("error") != 0:
-            print(f"Failed to logout of session: '{response.get('message')}'")
+            logger.warning(
+                "Failed to logout of the session: '{}'", response.get("message")
+            )
 
     def _set_login_response(self, login_response: dict | None) -> 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`.
+        :param login_response: A dictionary returned from :py:meth:`login`.
         :type login_response: :py:obj:`dict`
         :raises ValueError: If ``login_response`` wasn't provided.
         :returns: Nothing.
@@ -342,189 +350,3 @@ class WialonSession:
         self._username = login_response.get("au")
         self._video_service_url = login_response.get("video_service_url")
         self._wsdk_version = login_response.get("wsdk_version")
-
-
-class WialonSessionManager:
-    """Provides an interface for generating automatically activated Wialon sessions."""
-
-    def __init__(
-        self,
-        token: str | None = None,
-        lifetime: int = 500,
-        session: WialonSession | None = None,
-        session_id: str | None = None,
-    ) -> None:
-        """
-        Sets :py:attr:`token` and :py:attr:`lifetime`.
-
-        :param token: A Wialon API token. Default is :confval:`WIALON_TOKEN`.
-        :type token: :py:obj:`str` | :py:obj:`None`
-        :param lifetime: How long in seconds a Wialon session can be valid for. Default is ``500``.
-        :type lifetime: :py:obj:`int`
-        :returns: Nothing.
-        :rtype: :py:obj:`None`
-
-        """
-        self.token = token
-        self.lifetime = lifetime
-
-        target_sid = session.id if session and session.id else session_id
-        self.session = WialonSession(sid=target_sid)
-        if not target_sid or not self.validate_session():
-            self.session.login(token=self.token)
-
-    def check_active(self) -> bool:
-        """
-        Checks if :py:attr:`session` is active.
-
-        :returns: Whether or not :py:attr:`session` is an active Wialon session.
-        :rtype: :py:obj:`bool`
-
-        """
-        if not self.session.id:
-            return False
-        if not self.session.wialon_api.last_call_datetime:
-            return self.validate_session()
-
-        now = datetime.datetime.now()
-        last_call = self.session.wialon_api.last_call_datetime
-        session_expiry = last_call + datetime.timedelta(seconds=self.lifetime)
-
-        if now > session_expiry:
-            return False
-        return self.validate_session()
-
-    def get_session(self, sid: str | None = None) -> WialonSession:
-        """
-        Returns a valid Wialon API session.
-
-        If ``sid`` is provided, tries to continue the session and return it.
-
-        :param sid: A Wialon API session id.
-        :type sid: :py:obj:`str` | :py:obj:`None`
-        :returns: A valid Wialon API session.
-        :rtype: :py:obj:`~terminusgps.wialon.session.WialonSession`
-
-        """
-        if sid is not None:
-            self.session = WialonSession(sid=sid)
-            if not self.validate_session():
-                self.session = WialonSession()
-                self.session.login(token=self.token)
-                return self.session
-        if not self.check_active():
-            self.session = WialonSession()
-            self.session.login(token=self.token)
-        return self.session
-
-    def validate_session(self) -> bool:
-        """
-        Tries to make a Wialon API request and returns whether or not it was successful.
-
-        :returns: Whether or not validation Wialon API call was successful.
-        :rtype: :py:obj:`bool`
-
-        """
-        try:
-            result = self.session.wialon_api.core_duplicate()
-            return result is not None
-        except wialon.api.WialonError:
-            return False
-
-    @property
-    def sid(self) -> str | None:
-        """
-        Current Wialon session id.
-
-        :type: :py:obj:`str` | :py:obj:`None`
-
-        """
-        return self.session.wialon_api.sid if self.session else None
-
-    @sid.setter
-    def sid(self, other: str) -> None:
-        """
-        Sets :py:attr:`sid` to ``other``.
-
-        :param other: A Wialon session id.
-        :type other: :py:obj:`str`
-        :returns: Nothing.
-        :rtype: :py:obj:`None`
-
-        """
-        if self.session:
-            self.session.wialon_api.sid = other
-        else:
-            self.session = WialonSession(sid=other)
-
-    @property
-    def token(self) -> str:
-        """
-        A Wialon API token.
-
-        :type: :py:obj:`str`
-
-        """
-        return str(self._token)
-
-    @token.setter
-    def token(self, other: str | None) -> None:
-        """
-        Sets :py:attr:`token` to ``other`` if provided.
-
-        If ``other`` isn't provided, instead sets :py:attr:`token` to :confval:`WIALON_TOKEN`.
-
-        :param other: A Wialon API token.
-        :type other: :py:obj:`str` | :py:obj:`None`
-        :returns: Nothing.
-        :rtype: :py:obj:`None`
-
-        """
-        self._token = other if other is not None else settings.WIALON_TOKEN
-
-    @property
-    def session(self) -> WialonSession:
-        """
-        A Wialon API session.
-
-        :type: :py:obj:`~terminusgps.wialon.session.WialonSession`
-
-        """
-        return self._session
-
-    @session.setter
-    def session(self, other: WialonSession) -> None:
-        """
-        Sets :py:attr:`session` to ``other``.
-
-        :param other: A Wialon session.
-        :type other: :py:obj:`~terminusgps.wialon.session.WialonSession`
-        :returns: Nothing.
-        :rtype: :py:obj:`None`
-
-        """
-        self._session = other
-
-    @property
-    def lifetime(self) -> int:
-        """
-        How long in seconds a Wialon session can live for.
-
-        :type: :py:obj:`int`
-        :value: :py:obj:`500`
-
-        """
-        return self._lifetime
-
-    @lifetime.setter
-    def lifetime(self, other: int) -> None:
-        """
-        Sets :py:attr:`lifetime` to ``other``.
-
-        :param other: An integer.
-        :type other: :py:obj:`int`
-        :returns: Nothing.
-        :rtype: :py:obj:`None`
-
-        """
-        self._lifetime = other