pyituran 0.1.0__py3-none-any.whl

pyituran/__init__.py

@@ -0,0 +1,5 @@
+"""The pyituran library."""
+
+from pyituran.ituran import Ituran
+
+__all__ = ["Ituran"]

pyituran/cmdline.py

@@ -0,0 +1,95 @@
+#!/usr/bin/env python
+
+import argparse
+import asyncio
+import sys
+from pyituran import Ituran
+
+
+async def async_main(args=None):
+    if args is None:
+        args = sys.argv[1:]
+
+    parser = argparse.ArgumentParser(
+        description="Ituran command line tool.\n"
+        + "When executing this tool, please provide a phone number on"
+        + "first use or a mobile ID if already authenticated",
+        formatter_class=argparse.RawTextHelpFormatter,
+    )
+    parser.add_argument(
+        "--id-number",
+        action="store",
+        dest="id_number",
+        default=None,
+        help="ID number of the account owner",
+        required=True,
+    )
+    parser.add_argument(
+        "--phone-number",
+        action="store",
+        dest="phone_number",
+        default="",
+        help="Phone number of the account owner, required for OTP",
+    )
+    parser.add_argument(
+        "--mobile-id",
+        action="store",
+        dest="mobile_id",
+        default=None,
+        help="A unique, 16 hex-digit, ID for this client. "
+        + "Once authenticated via OTP, it must remain constant",
+    )
+    args = parser.parse_args(args)
+
+    if not (args.phone_number or args.mobile_id):
+        parser.error("Must provide either a phone number or a mobile ID")
+
+    ituran = Ituran(args.id_number, args.phone_number, args.mobile_id)
+    if not await ituran.is_authenticated():
+        print("The provided credentials aren't authenticated.")
+        response = input(
+            f"Would you like to authenticate now with ID '{args.id_number}'"
+            + f" and phone number '{args.phone_number}' (y/n)? "
+        )
+        if response != "y":
+            return
+        try:
+            await ituran.request_otp()
+        except Exception:
+            print("Failed requesting OTP, please verify ID and phone number")
+            return
+        print("OTP request sent.")
+        while True:
+            otp = input("Please input the received one-time code: ")
+            try:
+                await ituran.authenticate(otp)
+            except:
+                print("Incorrect code, please try again.")
+            else:
+                break
+        print(
+            "Success!\n"
+            + f"Please keep the following mobile ID for future use: {ituran.mobile_id}"
+        )
+
+    vehicles = await ituran.get_vehicles()
+    for vehicle in vehicles:
+        print(
+            f"License plate: {vehicle.license_plate}:\n"
+            + f"\tMake: {vehicle.make}\n"
+            + f"\tModel: {vehicle.model}\n"
+            + f"\tLocation: {vehicle.gps_coordinates}\n"
+            + f"\tAddress: {vehicle.address}\n"
+            + f"\tHeading: {vehicle.heading}\n"
+            + f"\tSpeed: {vehicle.speed}\n"
+            + f"\tMileage: {vehicle.mileage}\n"
+            + f"\tLast update: {vehicle.last_update}\n"
+        )
+
+
+def main(args=None):
+    asyncio.run(async_main(args))
+
+
+if __name__ == "__main__":
+    main() # pragma: no cover

pyituran/const.py

@@ -0,0 +1,32 @@
+"""Ituran library constants."""
+
+DOMAIN = "https://www.ituran.com"
+SOAP_SERVICES = DOMAIN + "/SoapService"
+ACTIVATION_URL = SOAP_SERVICES + "/APPApi.asmx/AppActivation"
+OTP_VERIFICATION_URL = (
+    SOAP_SERVICES + "/ituran4all.asmx/AppSerializationRequest"
+)
+ITURAN_GET_VEHICLES_URL = (
+    DOMAIN + "/ituranmobileservice/mobileservice.asmx/GetUserPlatforms"
+)
+
+TEMP_NAMESPACE = "http://tempuri.org/"
+XML_RESPONSE_STATUS = f"{{{TEMP_NAMESPACE}}}ResponseStatus"
+
+IMS_NAMESPACE = "http://www.ituran.com/IturanMobileService"
+XML_RETURN_CODE = f"{{{IMS_NAMESPACE}}}ReturnCode"
+XML_ERROR_DESCRIPTION = f"{{{IMS_NAMESPACE}}}ErrorDescription"
+XML_VEHICLES_LIST = f"{{{IMS_NAMESPACE}}}VehList"
+XML_VEHICLE_MODEL = f"{{{IMS_NAMESPACE}}}Model"
+XML_VEHICLE_MAKE = f"{{{IMS_NAMESPACE}}}Make"
+XML_VEHICLE_PLATE = f"{{{IMS_NAMESPACE}}}Plate"
+XML_VEHICLE_LATITUTE = f"{{{IMS_NAMESPACE}}}Lat"
+XML_VEHICLE_LONGITUDE = f"{{{IMS_NAMESPACE}}}Lon"
+XML_VEHICLE_ADDRESS = f"{{{IMS_NAMESPACE}}}Address"
+XML_VEHICLE_SPEED = f"{{{IMS_NAMESPACE}}}Speed"
+XML_VEHICLE_HEADING = f"{{{IMS_NAMESPACE}}}Head"
+XML_VEHICLE_LAST_MILEAGE = f"{{{IMS_NAMESPACE}}}LastMileage"
+XML_VEHICLE_UPDATE_DATE = f"{{{IMS_NAMESPACE}}}Date"
+
+ERROR_OK = "ok"
+ERROR_INVALID_CREDENTIALS = "IncorrectUserNameOrPassword"

pyituran/ituran.py

@@ -0,0 +1,146 @@
+"""Module client for the Ituran web service."""
+
+import aiohttp
+from aiohttp import FormData
+import logging
+from typing import List, Optional
+import uuid
+import xml.etree.ElementTree as ElementTree
+
+from pyituran.const import (
+    ERROR_INVALID_CREDENTIALS,
+    ERROR_OK,
+    ACTIVATION_URL,
+    ITURAN_GET_VEHICLES_URL,
+    OTP_VERIFICATION_URL,
+    XML_ERROR_DESCRIPTION,
+    XML_RESPONSE_STATUS,
+    XML_RETURN_CODE,
+    XML_VEHICLES_LIST,
+)
+from pyituran.vehicle import Vehicle
+
+
+logger = logging.getLogger(__package__)
+
+
+class Ituran:
+    def __init__(
+        self,
+        id_number: str,
+        phone_number: str,
+        mobile_id: Optional[str] = None,
+    ) -> None:
+        assert id_number is not None
+        assert phone_number is not None
+        self.__id_number = id_number
+        self.__phone_number = phone_number
+        self.__mobile_id = (
+            mobile_id if mobile_id is not None else self.__generate_mobile_id()
+        )
+
+    async def is_authenticated(self) -> bool:
+        """Tests if current credentials are valid."""
+        try:
+            _ = await self.get_vehicles()
+            return True
+        except Exception as e:
+            if len(e.args) > 0 and e.args[0] == ERROR_INVALID_CREDENTIALS:
+                return False
+            raise
+
+    async def request_otp(self) -> bool:
+        data = FormData()
+        data.add_field("UserName", self.__id_number)
+        data.add_field("SiebelPassword", self.__phone_number)
+        data.add_field("AppId", 49)
+        data.add_field("OSType", "Android")
+        try:
+            async with aiohttp.ClientSession() as session:
+                logger.debug("Requesting OTP")
+                async with session.post(ACTIVATION_URL, data=data) as response:
+                    response_data = await response.text()
+            logger.debug(f"Got {response.status}: {response_data}")
+            assert response.status == 200
+            root = ElementTree.fromstring(response_data)
+            response_status = root.find(XML_RESPONSE_STATUS)
+            assert response_status is not None
+            if response_status.text != ERROR_OK:
+                raise Exception(response_status.text)
+        except Exception as e:
+            logging.error(f"Failed requesting OTP: {e}")
+            raise
+        return True
+
+    async def authenticate(self, otp: str) -> bool:
+        data = FormData()
+        data.add_field("UserName", self.__id_number)
+        data.add_field("SiebelPassword", self.__phone_number)
+        data.add_field("OTPcode", otp)
+        data.add_field("AppId", 49)
+        data.add_field("MobileId", self.__mobile_id)
+        try:
+            async with aiohttp.ClientSession() as session:
+                logger.debug(f"Authenticating with OTP {otp}")
+                async with session.post(
+                    OTP_VERIFICATION_URL, data=data
+                ) as response:
+                    response_data = await response.text()
+            logger.debug(f"Got {response.status}: {response_data}")
+            root = ElementTree.fromstring(response_data)
+            response_status = root.find(XML_RESPONSE_STATUS)
+            assert response_status is not None
+            if response_status.text != ERROR_OK:
+                raise Exception(response_status.text)
+        except Exception as e:
+            logging.error(f"Failed requesting OTP: {e}")
+            raise
+        return True
+
+    async def get_vehicles(self) -> List[Vehicle]:
+        vehicles: List[Vehicle] = []
+        try:
+            root = await self.__get_vehicles_xml()
+            error = self.__get_error_from_response(root)
+            if error is not None:
+                raise Exception(error)
+            vehicles_list = root.find(XML_VEHICLES_LIST)
+            assert vehicles_list is not None
+            for vehicle in vehicles_list:
+                vehicles.append(Vehicle(vehicle))
+        except Exception as e:
+            logging.error(f"Failed getting list of vehicles: {e}")
+            raise
+        return vehicles
+
+    @property
+    def mobile_id(self):
+        return self.__mobile_id
+
+    async def __get_vehicles_xml(self) -> ElementTree.Element:
+        data = FormData()
+        data.add_field("UserName", self.__id_number)
+        data.add_field("GetAddress", True)
+        data.add_field("Password", self.__mobile_id)
+        async with aiohttp.ClientSession() as session:
+            logger.debug("Getting list of vehicles")
+            async with session.post(
+                ITURAN_GET_VEHICLES_URL, data=data
+            ) as response:
+                response_data = await response.text()
+        assert response.status == 200
+        logger.debug(f"Got {response.status}: {response_data}")
+        return ElementTree.fromstring(response_data)
+
+    def __get_error_from_response(
+        self, xml: ElementTree.Element
+    ) -> Optional[str]:
+        return_code = xml.find(XML_RETURN_CODE)
+        error_description = xml.find(XML_ERROR_DESCRIPTION)
+        assert return_code is not None and error_description is not None
+        if return_code.text == ERROR_OK.upper():
+            return None
+        return error_description.text
+
+    def __generate_mobile_id(self) -> str:
+        return uuid.uuid4().hex[:16]

pyituran/vehicle.py

@@ -0,0 +1,94 @@
+"""Class representing an Ituran vehicle."""
+
+from datetime import datetime
+import logging
+from typing import Tuple
+import xml.etree.ElementTree as ElementTree
+
+from pyituran.const import (
+    XML_VEHICLE_MODEL,
+    XML_VEHICLE_MAKE,
+    XML_VEHICLE_PLATE,
+    XML_VEHICLE_LATITUTE,
+    XML_VEHICLE_LONGITUDE,
+    XML_VEHICLE_ADDRESS,
+    XML_VEHICLE_SPEED,
+    XML_VEHICLE_HEADING,
+    XML_VEHICLE_LAST_MILEAGE,
+    XML_VEHICLE_UPDATE_DATE,
+)
+
+
+logger = logging.getLogger(__package__)
+
+
+class Vehicle:
+    def __init__(self, xml: ElementTree.Element) -> None:
+        self.__make: str = self.__xml_get_field(xml, XML_VEHICLE_MAKE)
+        self.__model: str = self.__xml_get_field(xml, XML_VEHICLE_MODEL)
+        self.__license_plate: str = self.__xml_get_field(
+            xml, XML_VEHICLE_PLATE
+        )
+        self.__latitue: float = float(
+            self.__xml_get_field(xml, XML_VEHICLE_LATITUTE)
+        )
+        self.__longitude: float = float(
+            self.__xml_get_field(xml, XML_VEHICLE_LONGITUDE)
+        )
+        self.__address: str = self.__xml_get_field(xml, XML_VEHICLE_ADDRESS)
+        self.__speed: int = int(self.__xml_get_field(xml, XML_VEHICLE_SPEED))
+        self.__heading: int = int(
+            self.__xml_get_field(xml, XML_VEHICLE_HEADING)
+        )
+        self.__mileage: float = float(
+            self.__xml_get_field(xml, XML_VEHICLE_LAST_MILEAGE)
+        )
+        self.__last_update: datetime = datetime.fromisoformat(
+            self.__xml_get_field(xml, XML_VEHICLE_UPDATE_DATE)
+        )
+
+    @property
+    def make(self) -> str:
+        return self.__make
+
+    @property
+    def model(self) -> str:
+        return self.__model
+
+    @property
+    def license_plate(self) -> str:
+        return self.__license_plate
+
+    @property
+    def gps_coordinates(self) -> Tuple[float, float]:
+        return (self.__latitue, self.__longitude)
+
+    @property
+    def address(self) -> str:
+        return self.__address
+
+    @property
+    def heading(self) -> int:
+        return self.__heading
+
+    @property
+    def speed(self) -> int:
+        return self.__speed
+
+    @property
+    def mileage(self) -> float:
+        return self.__mileage
+
+    @property
+    def last_update(self) -> datetime:
+        return self.__last_update
+
+    def __str__(self) -> str:
+        return f"{self.make} {self.model} @ {self.gps_coordinates}"
+
+    def __xml_get_field(self, xml: ElementTree.Element, path: str) -> str:
+        element = xml.find(path)
+        assert element is not None
+        text = element.text
+        assert text is not None
+        return text

pyituran-0.1.0.dist-info/METADATA

@@ -0,0 +1,27 @@
+Metadata-Version: 2.1
+Name: pyituran
+Version: 0.1.0
+Summary: A module to interact with Ituran's web service.
+Home-page: https://github.com/shmuelzon/pyituran
+Author: Shmuelzon
+License: MIT
+Download-URL: https://github.com/shmuelzon/pyituran/tarball/0.1.0
+Platform: UNKNOWN
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: aiohttp
+Requires-Dist: asyncio
+Provides-Extra: test
+Requires-Dist: black; extra == "test"
+Requires-Dist: coverage; extra == "test"
+Requires-Dist: flake8; extra == "test"
+Requires-Dist: pep8-naming; extra == "test"
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-asyncio; extra == "test"
+Requires-Dist: pytest-cov; extra == "test"
+Requires-Dist: setuptools; extra == "test"
+Requires-Dist: wheel; extra == "test"
+
+# pyituran
+
+

pyituran-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+pyituran/__init__.py,sha256=oBzbaNbraC4gg3BZ_8_hEEXJP2WBXpZPNC0KwiTYfpg,86
+pyituran/cmdline.py,sha256=9R5ha5YHb_EPFWiNo-f_wuW4xWd0PW0vnQuPO1uUpbs,2949
+pyituran/const.py,sha256=JGtj1rpn4d0xcD7iyWoyYcqCXzDChfNVVgkHIr3zous,1265
+pyituran/ituran.py,sha256=EPwb97V797Glh4gqZ7YrxIayRNU-S07ccMiSWRuspAM,5246
+pyituran/vehicle.py,sha256=3moz0HufyKIwXI-MwHoF_iacz9pgEFWa5n48TBZno8w,2592
+pyituran-0.1.0.dist-info/METADATA,sha256=oMBgiT-xRDqkzK9a8O_p3V8ZIDbhUiParg8m568oEdc,789
+pyituran-0.1.0.dist-info/WHEEL,sha256=eOLhNAGa2EW3wWl_TU484h7q1UNgy0JXjjoqKoxAAQc,92
+pyituran-0.1.0.dist-info/entry_points.txt,sha256=VuU9w2Kxniw9SS_pfoPbYEfrmNhRby-8Vd-GXVCwdP8,50
+pyituran-0.1.0.dist-info/top_level.txt,sha256=a_BX035kA9RJcpur2iKFZc6Lcw5i1PExPPTlNi1AWU4,9
+pyituran-0.1.0.dist-info/RECORD,,

pyituran-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.44.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pyituran-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+ituran = pyituran.cmdline:main
+

pyituran-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pyituran