dimo-python-sdk 0.0.1__py3-none-any.whl

dimo/__init__.py

@@ -0,0 +1,3 @@
+from .dimo import DIMO
+
+__all__ = ["DIMO"]

dimo/auth.py

@@ -0,0 +1,85 @@
+from web3 import Web3
+from eth_account.messages import encode_defunct
+from dimo.constants import dimo_constants
+from urllib.parse import urlencode
+
+class Auth:
+
+    def __init__(self, request_method, get_auth_headers):
+        self._request = request_method
+        self._get_auth_headers = get_auth_headers
+
+    async def generate_challenge(self,
+        client_id,
+        domain,
+        address,
+        headers,
+        scope='openid email',
+        response_type='code'):
+        body = {
+            'client_id': client_id,
+            'domain': domain,
+            'scope': scope,
+            'response_type': response_type,
+            'address': address
+        }
+        headers['Content-Type'] = 'application/x-www-form-urlencoded'
+        return self._request(
+            'POST',
+            'Auth',
+            '/auth/web3/generate_challenge',
+            data=urlencode(body),
+            headers=headers
+        )
+
+    async def sign_challenge(self, message, private_key, env="Production"):
+        web3 = Web3(Web3.HTTPProvider(dimo_constants[env]['RPC_provider']))
+        signed_message = web3.eth.account.sign_message(encode_defunct(text=message), private_key=private_key)
+        return signed_message.signature.hex()
+
+    async def submit_challenge(self, form_data, headers):
+        return self._request('POST', 'Auth', '/auth/web3/submit_challenge', data=form_data, headers=headers)
+
+    # Requires client_id, domain, and private_key. Address defaults to client_id.
+    async def get_token(self, 
+                        client_id, 
+                        domain, 
+                        private_key, 
+                        address=None, 
+                        scope='openid email', 
+                        response_type='code', 
+                        grant_type="authorization_code", 
+                        env="Production"):
+        
+        if address is None:
+            address = client_id
+        
+        headers = {
+            'Content-Type': 'application/x-www-form-urlencoded'
+        }
+
+        challenge = await self.generate_challenge(
+            headers=headers,
+            client_id=client_id,
+            domain=domain,
+            scope=scope,
+            response_type=response_type,
+            address=address
+        )
+
+        sign = await self.sign_challenge(
+            message=challenge['challenge'],
+            private_key=private_key,
+            env=env
+        )
+
+        body = {
+            'client_id': client_id,
+            'domain': domain,
+            'state': challenge['state'],
+            'signature': sign,
+            'grant_type': grant_type
+        }
+
+        submit = await self.submit_challenge(body, headers)
+        return submit

dimo/constants.py

@@ -0,0 +1,10 @@
+dimo_constants = {
+    "Production": {
+        "NFT_address": "0xbA5738a18d83D41847dfFbDC6101d37C69c9B0cF",
+        "RPC_provider": "https://eth.llamarpc.com"
+    },
+    "Dev": {
+        "NFT_address": "0x45fbCD3ef7361d156e8b16F5538AE36DEdf61Da8",
+        "RPC_provider": "https://eth.llamarpc.com"
+    }
+}

dimo/device_data.py

@@ -0,0 +1,118 @@
+class DeviceData:
+
+    def __init__(self, request_method, get_auth_headers):
+        self._request = request_method
+        self._get_auth_headers = get_auth_headers
+
+    async def get_vehicle_history(self, privileged_token, token_id, start_time=None, end_time=None, buckets=None):
+        params = {}
+        if start_time is not None:
+            params['startTime'] = start_time
+        if end_time is not None:
+            params['endTime'] = end_time
+        if buckets is not None:
+            params['buckets'] = buckets
+        url = f'/v2/vehicle/{token_id}/history'
+        return self._request(
+            'GET',
+            'DeviceData',
+            url,
+            params=params,
+            headers=self._get_auth_headers(privileged_token)
+        )
+
+    async def get_vehicle_status(self, privileged_token, token_id):
+        url = f'/v2/vehicle/{token_id}/status'
+        return self._request(
+            'GET',
+            'DeviceData',
+            url,
+            headers=self._get_auth_headers(privileged_token)
+        )
+
+    async def get_v1_vehicle_history(self, privileged_token, token_id, start_date=None, end_date=None):
+        params = {}
+        if start_date is not None:
+            params['startDate'] = start_date
+        if end_date is not None:
+            params['endDate'] = end_date
+        url = f'/v1/vehicle/{token_id}/history'
+        return self._request(
+            'GET',
+            'DeviceData',
+            url,
+            params=params,
+            headers=self._get_auth_headers(privileged_token)
+        )
+
+    async def get_v1_vehicle_status(self, privileged_token, token_id):
+        url = f'/v1/vehicle/{token_id}/status'
+        return self._request(
+            'GET',
+            'DeviceData',
+            url,
+            headers=self._get_auth_headers(privileged_token)
+        )
+
+    async def get_v1_vehicle_status_raw(self, privileged_token, token_id):
+        url = f'/v1/vehicle/{token_id}/status-raw'
+        return self._request(
+            'GET',
+            'DeviceData',
+            url,
+            headers=self._get_auth_headers(privileged_token)
+        )
+
+    async def get_user_device_status(self, access_token, user_device_id):
+        url = f'/v1/user/device-data/{user_device_id}/status'
+        return self._request(
+            'GET',
+            'DeviceData',
+            url,
+            headers=self._get_auth_headers(access_token)
+        )
+
+    async def get_user_device_history(self, access_token, user_device_id, start_date=None, end_date=None):
+        params = {}
+        if start_date is not None:
+            params['startDate'] = start_date
+        if end_date is not None:
+            params['endDate'] = end_date
+        url = f'/v1/user/device-data/{user_device_id}/historical'
+        return self._request(
+            'GET',
+            'DeviceData',
+            url,
+            params=params,
+            headers=self._get_auth_headers(access_token),
+        )
+
+    async def get_daily_distance(self, access_token, user_device_id, time_zone):
+        params = {
+            'timeZone': time_zone
+        }
+        url = f'/v1/user/device-data/{user_device_id}/daily-distance'
+        return self._request(
+            'GET',
+            'DeviceData',
+            url,
+            headers=self._get_auth_headers(access_token),
+            params=params)
+
+    async def get_total_distance(self, access_token, user_device_id):
+        url = f'/v1/user/device-data/{user_device_id}/distance-driven'
+        return self._request(
+            'GET',
+            'DeviceData',
+            url,
+            headers=self._get_auth_headers(access_token)
+        )
+
+    async def send_json_export_email(self, access_token, user_device_id):
+        url = f'/v1/user/device-data/{user_device_id}/export/json/email'
+        return self._request(
+            'POST',
+            'DeviceData',
+            url,
+            headers=self._get_auth_headers(access_token)
+        )

dimo/device_definitions.py

@@ -0,0 +1,39 @@
+class DeviceDefinitions:
+
+    def __init__(self, request_method, get_auth_headers):
+        self._request = request_method
+        self._get_auth_headers = get_auth_headers
+
+    async def get_by_mmy(self, make, model, year):
+        params = {
+            'make': make,
+            'model': model,
+            'year': year
+        }
+        return self._request(
+            'GET',
+            'DeviceDefinitions',
+            '/device-definitions',
+            params=params
+        )
+
+    async def get_by_id(self, id):
+        url = f'/device-definitions/{id}'
+        return self._request(
+            'GET',
+            'DeviceDefinitions',
+            url)
+
+    async def list_device_makes(self):
+        return self._request(
+            'GET',
+            'DeviceDefinitions',
+            '/device-makes'
+        )
+
+    async def get_device_type_by_id(self, id):
+        url = f'/device-types/{id}'
+        return self._request(
+            'GET',
+            'DeviceDefinitions',
+            url)

dimo/devices.py

@@ -0,0 +1,252 @@
+class Devices:
+
+    def __init__(self, request_method, get_auth_headers):
+        self._request = request_method
+        self._get_auth_headers = get_auth_headers
+
+    async def create_vehicle(self, access_token, country_code, device_definition_id):
+        body = {
+            'countryCode': country_code,
+            'deviceDefinitionId': device_definition_id
+        }
+        return self._request(
+            'POST',
+            'Devices',
+            '/v1/user/devices',
+            headers=self._get_auth_headers(access_token),
+            data=body
+        )
+
+    async def create_vehicle_from_smartcar(self, access_token, code, country_code, redirect_uri):
+        body = {
+            'code': code,
+            'countryCode': country_code,
+            'redirectURI': redirect_uri
+        }
+        return self._request(
+            'POST',
+            'Devices',
+            '/v1/user/devices/fromsmartcar',
+            headers=self._get_auth_headers(access_token),
+            data=body
+        )
+
+    async def create_vehicle_from_vin(self, access_token, can_protocol, country_code, vin):
+        body = {
+            'canProtocol': can_protocol,
+            'countryCode': country_code,
+            'vin': vin
+        }
+        return self._request(
+            'POST',
+            'Devices',
+            '/v1/user/devices/fromvin',
+            headers=self._get_auth_headers(access_token),
+            data=body
+        )
+
+    async def update_vehicle_vin(self, access_token, user_device_id):
+        url = f'/v1/user/devices/{user_device_id}/vin'
+        return self._request(
+            'PATCH',
+            'Devices',
+            url,
+            headers=self._get_auth_headers(access_token)
+        )
+
+    async def get_claiming_payload(self, access_token, serial):
+        url = f'/v1/aftermarket/device/by-serial/{serial}/commands/claim'
+        return self._request(
+            'POST',
+            'Devices',
+            url,
+            headers=self._get_auth_headers(access_token)
+        )
+
+    async def sign_claiming_payload(self, access_token, serial, claim_request):
+        body = {
+            'claimRequest': claim_request
+        }
+        url = f'/v1/aftermarket/device/by-serial/{serial}/commands/claim'
+        return self._request(
+            'POST',
+            'Devices',
+            url,
+            headers=self._get_auth_headers(access_token),
+            data=body
+        )
+
+    async def get_minting_payload(self, access_token, user_device_id):
+        url = f'/v1/user/devices/{user_device_id}/commands/mint'
+        return self._request(
+            'POST',
+            'Devices',
+            url,
+            headers=self._get_auth_headers(access_token)
+        )
+
+    async def sign_minting_payload(self, access_token, user_device_id, mint_request):
+        body = {
+            'mintRequest': mint_request
+        }
+        url = f'/v1/user/devices/{user_device_id}/commands/mint'
+        return self._request(
+            'POST',
+            'Devices',
+            url,
+            headers=self._get_auth_headers(access_token),
+            data=body
+        )
+
+    async def opt_in_share_data(self, access_token, user_device_id):
+        url = f'/v1/user/devices/{user_device_id}/commands/opt-in'
+        return self._request(
+            'POST',
+            'Devices',
+            url,
+            headers=self._get_auth_headers(access_token)
+        )
+
+    async def refresh_smartcar_data(self, access_token, user_device_id):
+        url = f'/v1/user/devices/{user_device_id}/commands/refresh'
+        return self._request(
+            'POST',
+            'Devices',
+            url,
+            headers=self._get_auth_headers(access_token)
+        )
+
+    async def get_pairing_payload(self, access_token, user_device_id):
+        url = f'/v1/user/devices/{user_device_id}/aftermarket/commands/pair'
+        return self._request(
+            'GET',
+            'Devices',
+            url,
+            headers=self._get_auth_headers(access_token)
+        )
+
+    async def sign_pairing_payload(self, access_token, user_device_id, user_signature):
+        body = {
+            'userSignature': user_signature
+        }
+        url = f'/v1/user/devices/{user_device_id}/aftermarket/commands/pair'
+        return self._request(
+            'POST',
+            'Devices',
+            url,
+            headers=self._get_auth_headers(access_token),
+            data=body
+        )
+
+    async def get_unpairing_payload(self, access_token, user_device_id):
+        url = f'/v1/user/devices/{user_device_id}/aftermarket/commands/unpair'
+        return self._request(
+            'GET',
+            'Devices',
+            url,
+            headers=self._get_auth_headers(access_token)
+        )
+
+    async def sign_unpairing_payload(self, access_token, user_device_id, user_signature):
+        body = {
+            'userSignature': user_signature
+        }
+        url = f'/v1/user/devices/{user_device_id}/aftermarket/commands/unpair'
+        return self._request(
+            'POST',
+            'Devices',
+            url,
+            headers=self._get_auth_headers(access_token),
+            data=body
+        )
+
+    async def lock_doors(self, privilege_token, token_id):
+        url = f'/v1/vehicle/{token_id}/commands/doors/lock'
+        return self._request(
+            'POST',
+            'Devices',
+            url,
+            headers=self._get_auth_headers(privilege_token)
+        )
+
+    async def unlock_doors(self, privilege_token, token_id):
+        url = f'/v1/vehicle/{token_id}/commands/doors/unlock'
+        return self._request(
+            'POST',
+            'Devices',
+            url,
+            headers=self._get_auth_headers(privilege_token)
+        )
+
+    async def open_frunk(self, privilege_token, token_id):
+        url = f'/v1/vehicle/{token_id}/commands/frunk/open'
+        return self._request(
+            'POST',
+            'Devices',
+            url,
+            headers=self._get_auth_headers(privilege_token)
+        )
+
+    async def open_trunk(self, privilege_token, token_id):
+        url = f'/v1/vehicle/{token_id}/commands/trunk/open'
+        return self._request(
+            'POST',
+            'Devices',
+            url,
+            headers=self._get_auth_headers(privilege_token)
+        )
+
+    async def list_error_codes(self, access_token, user_device_id):
+        url = f'/v1/user/devices/{user_device_id}/error-codes'
+        return self._request(
+            'GET',
+            'Devices',
+            url,
+            headers=self._get_auth_headers(access_token)
+        )
+
+    async def submit_error_codes(self, access_token, user_device_id, query_device_error_codes):
+        body = {
+            'queryDeviceErrorCodes': query_device_error_codes
+        }
+        url = f'/v1/user/devices/{user_device_id}/error-codes'
+        return self._request(
+            'POST',
+            'Devices',
+            url,
+            headers=self._get_auth_headers(access_token),
+            data=body
+        )
+
+    async def clear_error_codes(self, access_token, user_device_id):
+        url = f'/v1/user/devices/{user_device_id}/error-codes/clear'
+        return self._request(
+            'POST',
+            'Devices',
+            url,
+            headers=self._get_auth_headers(access_token)
+        )
+
+    async def get_aftermarket_device(self, token_id):
+        url = f'/v1/aftermarket/device/{token_id}'
+        self._request(
+            'GET',
+            'Devices',
+            url
+        )
+
+    async def get_aftermarket_device_image(self, token_id):
+        url = f'/v1/aftermarket/device/{token_id}/image'
+        self._request(
+            'GET',
+            'Devices',
+            url
+        )
+
+    async def get_aftermarket_device_metadata_by_address(self, address):
+        url = f'/v1/aftermarket/device/by-address/{address}'
+        self._request(
+            'GET',
+            'Devices',
+            url
+        )

dimo/dimo.py

@@ -0,0 +1,79 @@
+from dimo.auth import Auth
+from dimo.device_data import DeviceData
+from dimo.device_definitions import DeviceDefinitions
+from dimo.devices import Devices
+from dimo.events import Events
+from dimo.token_exchange import TokenExchange
+from dimo.trips import Trips
+from dimo.user import User
+from dimo.valuations import Valuations
+from dimo.vehicle_signal_decoding import VehicleSignalDecoding
+
+from dimo.identity import Identity
+from dimo.telemetry import Telemetry
+
+from dimo.request import Request
+from dimo.environments import dimo_environment
+import re
+
+class DIMO:
+
+    def __init__(self, env="Production"):
+        self.env = env
+        self.urls = dimo_environment[env]
+        self.auth = Auth(self.request, self._get_auth_headers)
+        self.device_data = DeviceData(self.request, self._get_auth_headers)
+        self.device_definitions = DeviceDefinitions(self.request, self._get_auth_headers)
+        self.devices = Devices(self.request, self._get_auth_headers)
+        self.events = Events(self.request, self._get_auth_headers)
+        self.token_exchange = TokenExchange(self.request, self._get_auth_headers)
+        self.trips = Trips(self.request, self._get_auth_headers)
+        self.user = User(self.request, self._get_auth_headers)
+        self.valuations = Valuations(self.request, self._get_auth_headers)
+        self.vehicle_signal_decoding = VehicleSignalDecoding(self.request, self._get_auth_headers)
+        self.identity = Identity(self)
+        self.telemetry = Telemetry(self)
+        self._session = Request.session
+
+    # Creates a full path for endpoints combining DIMO service, specific endpoint, and optional params
+    def _get_full_path(self, service, path, params=None):
+        base_path = self.urls[service] 
+        full_path = f"{base_path}{path}"
+
+        if params:
+            for key, value in params.items():
+                pattern = f":{key}"
+                full_path = re.sub(pattern, str(value), full_path)
+        return full_path 
+
+    # Sets headers based on access_token or privileged_token
+    def _get_auth_headers(self, token):
+        return {
+            'Authorization': f'Bearer {token}',
+            'Content-Type': 'application/json'
+        }
+
+    # request method for HTTP requests for the REST API
+    def request(self, http_method, service, path, **kwargs):
+        full_path = self._get_full_path(service, path)
+        return Request(http_method, full_path)(**kwargs)
+
+    # query method for graphQL queries, identity and telemetry
+    async def query(self, service, query, variables=None, token=None):
+        headers = self._get_auth_headers(token) if token else {}
+        headers['Content-Type'] = 'application/json'
+        headers['User-Agent'] = 'dimo-python-sdk'
+
+        data = {
+            'query': query,
+            'variables': variables or {}
+        }
+
+        response = self.request(
+            'POST',
+            service,
+            '',
+            headers=headers,
+            data=data
+        )
+        return response

dimo/environments.py

@@ -0,0 +1,30 @@
+dimo_environment = {
+    "Production": {
+        'Auth': 'https://auth.dimo.zone',
+        'Identity': 'https://identity-api.dimo.zone/query',
+        'Devices': 'https://devices-api.dimo.zone',
+        'DeviceData': 'https://device-data-api.dimo.zone',
+        'DeviceDefinitions': 'https://device-definitions-api.dimo.zone',
+        'Events': 'https://events-api.dimo.zone',
+        'Telemetry': 'https://telemetry-api.dimo.zone/query',
+        'TokenExchange': 'https://token-exchange-api.dimo.zone',
+        'Trips': 'https://trips-api.dimo.zone',
+        'User': 'https://users-api.dimo.zone',
+        'Valuations': 'https://valuations-api.dimo.zone',
+        'VehicleSignalDecoding': 'https://vehicle-signal-decoding.dimo.zone'
+    },
+    "Dev": {
+        'Auth': 'https://auth.dev.dimo.zone',
+        'Identity': 'https://identity-api.dev.dimo.zone/query',
+        'Devices': 'https://devices-api.dev.dimo.zone',
+        'DeviceData': 'https://device-data-api.dev.dimo.zone',
+        'DeviceDefinitions': 'https://device-definitions-api.dev.dimo.zone',
+        'Events': 'https://events-api.dev.dimo.zone',
+        'Telemetry': 'https://telemetry-api.dev.dimo.zone/query',
+        'TokenExchange': 'https://token-exchange-api.dev.dimo.zone',
+        'Trips': 'https://trips-api.dev.dimo.zone',
+        'User': 'https://users-api.dev.dimo.zone',
+        'Valuations': 'https://valuations-api.dev.dimo.zone',
+        'VehicleSignalDecoding': 'https://vehicle-signal-decoding.dev.dimo.zone'
+    }
+}

dimo/events.py

@@ -0,0 +1,13 @@
+class Events:
+
+    def __init__(self, request_method, get_auth_headers):
+        self._request = request_method
+        self._get_auth_headers = get_auth_headers
+
+    async def get_events(self, access_token):
+        return self._request(
+            'GET',
+            'Events',
+            '/v1/events',
+            headers=self._get_auth_headers(access_token)
+        )