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

dimo/identity.py

@@ -0,0 +1,222 @@
+class Identity:
+  def __init__(self, dimo_instance):
+      self.dimo = dimo_instance
+
+  # Primary query method
+  async def query(self, query):
+      return await self.dimo.query('Identity', query)
+
+  # Sample query - count DIMO vehicles
+  async def count_dimo_vehicles(self):
+      query = """
+      {
+          vehicles (first:10) {
+              totalCount,
+          }
+      }
+      """
+      return await self.dimo.query('Identity', query)
+
+  # Sample query - list vehicle definitions per address
+  async def list_vehicle_definitions_per_address(self, address, limit):
+      query = """
+      query ListVehicleDefinitionsPerAddress($owner: Address!, $first: Int!) {
+        vehicles(filterBy: {owner: $owner}, first: $first) {
+          nodes {
+            aftermarketDevice {
+              tokenId
+              address
+            } 
+            syntheticDevice {
+              address
+              tokenId
+            }
+            definition {
+              make
+              model
+              year
+            }
+          }
+        }
+      }
+      """
+      variables = {
+          "owner": address,
+          "first": limit
+      }
+
+      return await self.dimo.query('Identity', query, variables=variables)
+  
+  # Sample query - MMY per owner 
+  async def mmy_by_owner(self, address, limit):
+    query = """
+    query MMYByOwner($owner: Address!, $first: Int!) {
+      vehicles(filterBy: {owner: $owner}, first: $first) {
+        nodes {
+          definition {
+            make
+            model
+            year
+          }
+        }
+      }
+    }
+    """
+    variables = {
+        "owner": address,
+        "first": limit
+    }
+
+    return await self.dimo.query('Identity', query, variables=variables)
+
+  # Sample query - tokenIDs & privileges by owner
+  async def list_token_ids_privileges_by_owner(self, address, vehicle_limit, privileges_limit):
+    query = """
+    query TokenIDsPrivilegesByOwner($owner: Address!, $firstVehicles: Int!, $firstPrivileges: Int!) {
+      vehicles(filterBy: {owner: $owner}, first: $firstVehicles) {
+        nodes {
+          tokenId
+          privileges(first: $firstPrivileges) {
+            nodes {
+              setAt
+              expiresAt
+              id
+            }
+          }
+        }
+      }
+    }
+    """
+    variables = {
+          "owner": address,
+          "firstVehicles": vehicle_limit,
+          "firstPrivileges": privileges_limit
+      }
+
+    return await self.dimo.query('Identity', query, variables=variables)
+
+# Sample query - list of tokenIDs granted to a dev from an owner
+  async def list_token_ids_granted_to_dev_by_owner(self, dev_address, owner_address, limit):
+    query = """
+    query ListTokenIdsGrantedToDevByOwner($privileged: Address!, $owner: Address!, $first: Int!) {
+      vehicles(filterBy: {privileged: $privileged, owner: $owner}, first: $first) {
+        nodes {
+          tokenId
+          definition {
+            make
+          }
+          aftermarketDevice {
+            manufacturer {
+              name
+            }
+          }
+        }
+      }
+    }
+      """
+    variables = {
+       "owner": owner_address,
+       "privileged": dev_address,
+       "first": limit
+    }
+
+    return await self.dimo.query('Identity', query, variables=variables)
+  
+  # Sample query - DCNs by Owner
+  async def dcn_by_owner(self, address, limit):
+   query = """
+    query DCNByOwner($owner: Address!, $first: Int!) {
+      vehicles(filterBy: {owner: $owner}, first: $first) {
+        nodes {
+          dcn {
+            node
+            name
+            vehicle {
+              tokenId
+            }
+          }
+        }
+      }
+    }
+    """
+   variables = {
+      "owner": address,
+      "first": limit
+   }
+
+   return await self.dimo.query('Identity', query, variables=variables)
+  
+  # Sample query - MMY by TokenID
+  async def mmy_by_token_id(self, token_id):
+    query = """
+      query MMYByTokenID($tokenId: Int!) {
+        vehicle (tokenId: $tokenId) {
+          aftermarketDevice {
+            tokenId
+            address
+          }
+          syntheticDevice {
+            tokenId
+            address
+          }
+          definition {
+            make
+            model
+            year
+          }
+        }
+      }
+      """
+    variables = {
+       "tokenId": token_id
+    }
+    
+    return await self.dimo.query('Identity', query, variables=variables)
+  
+  # Sample query - Rewards by owner
+  async def rewards_by_owner(self, address):
+     query = """
+      query RewardsByOwner($owner: Address!) {
+        rewards (user: $owner) {
+          totalTokens
+        }
+      }
+      """
+     variables = {
+        "owner": address
+     }
+
+     return await self.dimo.query('Identity', query, variables=variables)
+  
+  # Sample query - get rewards history by owner
+  async def rewards_history_by_owner(self, address, limit):
+     query = """
+      query GetVehicleDataByOwner($owner: Address!, $first: Int!) {
+        vehicles (filterBy: {owner: $owner}, first: $first) {
+          nodes {
+            earnings {
+              history (first: $first) {
+                edges {
+                  node {
+                    week
+                    aftermarketDeviceTokens
+                    syntheticDeviceTokens
+                    sentAt
+                    beneficiary
+                    connectionStreak
+                    streakTokens
+                  }
+                }
+              }
+              totalTokens
+            }
+          }
+        }
+      }
+      """
+     variables = {
+        "owner": address,
+        "first": limit
+     }
+
+     return await self.dimo.query('Identity', query, variables=variables)

dimo/request.py

@@ -0,0 +1,33 @@
+import json
+import requests
+
+class Request:
+
+    session = requests.Session()
+
+    def __init__(self, http_method, url):
+        self.http_method = http_method
+        self.url = url
+
+    def __call__(self, headers=None, data=None, params=None, **kwargs):
+        headers = headers or {}
+        headers.update(kwargs.pop('headers', {}))
+
+        if data and isinstance(data, dict) and headers.get('Content-Type') == 'application/json':
+            data = json.dumps(data)
+        
+        response = self.session.request (
+            method=self.http_method,
+            url=self.url,
+            headers=headers,
+            params=params,
+            data=data,
+            **kwargs
+        )
+
+        # TODO: Better error responses
+        response.raise_for_status() 
+
+        if response.content:
+            return response.json()
+        return None

dimo/telemetry.py

@@ -0,0 +1,131 @@
+class Telemetry:
+    def __init__(self, dimo_instance):
+        self.dimo = dimo_instance
+    
+    # Primary query method
+    async def query(self, query, token):
+        return await self.dimo.query('Telemetry', query, token=token)
+    
+    # Sample query - get signals latest
+    async def get_signals_latest(self, token, token_id):
+        query = """
+        query GetSignalsLatest($tokenId: Int!) {
+            signalsLatest(tokenId: $tokenId){
+                powertrainTransmissionTravelledDistance{
+                    timestamp
+                    value
+                }
+                exteriorAirTemperature{
+                    timestamp
+                    value
+                }
+                speed {
+                    timestamp
+                    value
+                }
+                powertrainType{
+                    timestamp
+                    value
+                }
+            }
+        }
+        """
+        variables = {
+            "tokenId": token_id
+        }
+
+        return await self.dimo.query('Telemetry', query, token=token, variables=variables)
+    
+    # Sample query - daily signals from autopi
+    async def get_daily_signals_autopi(self, token, token_id, start_date, end_date):
+        query = """
+        query GetDailySignalsAutopi($tokenId: Int!, $startDate: Time!, $endDate: Time!) {
+            signals(
+                tokenId: $tokenId,
+                interval: "24h",
+                from: $startDate, 
+                to: $endDate,
+                filter: {
+                    source: "autopi"
+                })
+                {
+                    speed(agg: MED)
+                    powertrainType(agg: RAND)
+                    powertrainRange(agg: MIN) 
+                    exteriorAirTemperature(agg: MAX)
+                    chassisAxleRow1WheelLeftTirePressure(agg: MIN)
+                    timestamp
+                }
+            }
+            """
+        variables = {
+            "tokenId": token_id,
+            "startDate": start_date,
+            "endDate": end_date
+        }
+
+        return await self.dimo.query('Telemetry', query, token=token, variables=variables)
+    
+    # Sample query - daily average speed of a specific vehicle
+    async def get_daily_average_speed(self, token, token_id, start_date, end_date):
+        query = """
+        query GetDailyAverageSpeed($tokenId: Int!, $startDate: Time!, $endDate: Time!) {
+         signals (
+            tokenId: $tokenId,
+            from: $startDate,
+            to: $endDate,
+            interval: "24h"
+            )
+        {
+            timestamp
+            avgSpeed: speed(agg: AVG)
+        }
+        }
+        """
+        variables = {
+            "tokenId": token_id,
+            "startDate": start_date,
+            "endDate": end_date
+        }
+
+        return await self.dimo.query('Telemetry', query, token=token, variables=variables)
+    
+    # Sample query - daily max speed of a specific vehicle
+    async def get_daily_max_speed(self, token, token_id, start_date, end_date):
+        query = """
+        query GetMaxSpeed($tokenId: Int!, $startDate: Time!, $endDate: Time!) {
+            signals(
+                tokenId: $tokenId,
+                from: $startDate,
+                to: $endDate,
+                interval: "24h"
+            )
+        {
+            timestamp
+            maxSpeed: speed(agg: MAX)
+        }
+        }
+        """
+        variables = {
+            "tokenId": token_id,
+            "startDate": start_date,
+            "endDate": end_date
+        }
+
+        return await self.dimo.query('Telemetry', query, token=token, variables=variables)
+    
+    # TODO: Update with Attestation API 
+    # Sample query - get the VIN of a specific vehicle 
+    # async def get_vin(self, token, token_id):
+    #     query = """
+    #     query GetVIN($tokenId: Int!) {
+    #         vinVCLatest (tokenId: $tokenId) {
+    #             vin
+    #         }
+    #     }"""
+    #     variables = {
+    #         "tokenId": token_id
+    #     }
+
+    #     return await self.dimo.query('Telemetry', query, token=token, variables=variables)
+

dimo/test.py

@@ -0,0 +1,92 @@
+from dimo import DIMO
+from dotenv import load_dotenv # REMOVE!!
+import os # REMOVE !!
+import asyncio
+load_dotenv()
+
+dimo = DIMO("Production")
+
+
+# PUBLIC ENDPOINTS
+# async def test_public_endpoints():
+
+    # device_makes = await dimo.device_definitions.list_device_makes()
+    # print("DEVICE MAKES: ", device_makes)
+
+    # by_id = await dimo.device_definitions.get_by_id(id='26G4j1YDKZhFeCsn12MAlyU3Y2H')
+    # print(by_id)
+
+    # barretts_car_by_mmy = await dimo.device_definitions.get_by_mmy(
+    #     make="Hyundai",
+    #     model="Tucson",
+    #     year=2022
+    # )
+    # print("HYUNDAI TUCSON: ", barretts_car_by_mmy)
+
+    # count = await dimo.identity.count_dimo_vehicles()
+    # print(count)
+
+#     listvd = await dimo.identity.list_vehicle_definitions_per_address(address="0x48f6EdC54Ae0706b5e6cFC33C342B49bf2dDb939",limit=2)
+#     print(listvd)
+
+
+# if __name__ == "__main__":
+#         asyncio.run(test_public_endpoints())
+
+# # GET ACCESS TOKEN
+async def auth_routes():
+    authHeader = await dimo.auth.get_token(
+                client_id='0xeAa35540a94e3ebdf80448Ae7c9dE5F42CaB3481',
+                domain='http://localhost:8082',
+                private_key=os.getenv("private_key")
+    )
+    access_token = authHeader["access_token"]
+
+# GET PRIVILEGE TOKEN
+    privileged_token_req = await dimo.token_exchange.exchange(access_token, privileges=[1,3,4], token_id=17)
+    privileged_token = privileged_token_req['token']
+    print("USE THIS ONE:  ", privileged_token)
+
+# "0x48f6EdC54Ae0706b5e6cFC33C342B49bf2dDb939"
+
+# TELEMETRY TESTS
+    # try:
+    #     anything = await dimo.telemetry.get_daily_signals_autopi(token=privileged_token, token_id=21957, start_date="2024-07-20T18:32:12Z", 
+    #         end_date="2024-07-31T18:32:12Z")
+    #     print(anything)
+    # except Exception as e:
+    #     print(f"An error occurred: {e}")
+
+# BEARER AUTHENTICATION w/ ACCESS_TOKEN - SAMPLE ENDPOINTS
+    # my_events = await dimo.events.get_events(access_token)
+    # print("My events: ", my_events)
+
+
+# TEST IDENTITY 
+    # my_dev_vehicles_query = """
+    #            query {
+    #             vehicles(filterBy: { privileged: "0xeAa35540a94e3ebdf80448Ae7c9dE5F42CaB3481" }, first: 100) {
+    #                 nodes {
+    #                 tokenId
+    #                 definition {
+    #                     make
+    #                     model
+    #                     year
+    #                 }
+    #                 },
+    #                 totalCount
+    #                 }
+    #             }"""
+    # dev_vehicles = await dimo.identity.query(query=my_dev_vehicles_query, token=privileged_token)
+    # print(dev_vehicles)
+
+# TEST TELEMETRY
+    # latest_signals = await dimo.telemetry.get_signals_latest(token=privileged_token, token_id=17)
+    # print(latest_signals)
+
+# BEARER AUTHENTICATION w/ PRIVILEGE_TOKEN - SAMPLE ENDPOINTS
+    # bk_vehicle_history = await dimo.device_data.get_v1_vehicle_history(privileged_token, token_id=17)
+    # print("My vehicle history: ", bk_vehicle_history)
+
+if __name__ == "__main__":
+        asyncio.run(auth_routes())

dimo/token_exchange.py

@@ -0,0 +1,22 @@
+from dimo.constants import dimo_constants
+
+class TokenExchange:
+
+    def __init__(self, request_method, get_auth_headers):
+        self._request = request_method
+        self._get_auth_headers = get_auth_headers
+
+    async def exchange(self, access_token, privileges, token_id, env="Production"):
+        body = {
+                'nftContractAddress':  dimo_constants[env]['NFT_address'],
+                'privileges': privileges,
+                'tokenId': token_id
+            }
+        response = self._request(
+            'POST',
+            'TokenExchange',
+            '/v1/tokens/exchange',
+            headers=self._get_auth_headers(access_token),
+            data=body
+        )
+        return response

dimo/trips.py

@@ -0,0 +1,18 @@
+class Trips:
+
+    def __init__(self, request_method, get_auth_headers):
+        self._request = request_method
+        self._get_auth_headers = get_auth_headers
+
+    async def trips(self, privilege_token, token_id, page=None):
+        params = {}
+        if page is not None:
+            params['page'] = [page]
+        url = f'/v1/vehicle/{token_id}/trips'
+        return self._request(
+            'GET',
+            'Trips',
+            url,
+            params=params,
+            headers=self._get_auth_headers(privilege_token)
+        )

dimo/user.py

@@ -0,0 +1,53 @@
+class User:
+
+    def __init__(self, request_method, get_auth_headers):
+        self._request = request_method
+        self._get_auth_headers = get_auth_headers
+
+    async def user(self, access_token):
+        return self._request(
+            'GET',
+            'User',
+            '/v1/user',
+            headers=self._get_auth_headers(access_token)
+        )
+
+    async def update_user(self, access_token, update_user_request):
+        body = {
+            'updateUserRequest': update_user_request
+        }
+        return self._request(
+            'PUT',
+            'User',
+            '/v1/user',
+            data=body,
+            headers=self._get_auth_headers(access_token)
+        )
+
+    async def delete_user(self, access_token):
+        return self._request(
+            'DELETE',
+            'User',
+            '/v1/user',
+            headers=self._get_auth_headers(access_token)
+        )
+
+    async def send_confirmation_email(self, access_token):
+        return self._request(
+            'POST',
+            'User',
+            '/v1/user/send-confirmation-email',
+            headers=self._get_auth_headers(access_token)
+        )
+
+    async def confirm_email(self, access_token, confirm_email_request):
+        body = {
+            'confirmEmailRequest': confirm_email_request
+        }
+        return self._request(
+            'POST',
+            'User',
+            '/v1/user/confirm-email',
+            data=body,
+            headers=self._get_auth_headers(access_token)
+        )

dimo/valuations.py

@@ -0,0 +1,32 @@
+class Valuations:
+
+    def __init__(self, request_method, get_auth_headers):
+        self._request = request_method
+        self._get_auth_headers = get_auth_headers
+
+    async def get_valuations(self, access_token, user_device_id):
+        url = f'/v1/user/devices/{user_device_id}/valuations'
+        return self._request(
+            'GET',
+            'Valuations',
+            url,
+            headers=self._get_auth_headers(access_token)
+        )
+
+    async def get_instant_offer(self, access_token, user_device_id):
+        url = f'/v1/user/devices/{user_device_id}/instant-offer'
+        return self._request(
+            'GET',
+            'Valuations',
+            url,
+            headers=self._get_auth_headers(access_token)
+        )
+
+    async def get_offers(self, access_token, user_device_id):
+        url = f'/v1/user/devices/{user_device_id}/offers'
+        return self._request(
+            'GET',
+            'Valuations',
+            url,
+            headers=self._get_auth_headers(access_token)
+        )