dimo-python-sdk 1.3.2__tar.gz → 1.3.4__tar.gz

{dimo_python_sdk-1.3.2 → dimo_python_sdk-1.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dimo-python-sdk
-Version: 1.3.2
+Version: 1.3.4
 Summary: DIMO SDK in Python
 Author-email: Barrett Kowalsky <barrettkowalsky@gmail.com>
 Project-URL: Homepage, https://github.com/DIMO-Network/dimo-python-sdk

{dimo_python_sdk-1.3.2 → dimo_python_sdk-1.3.4}/dimo/api/auth.py

@@ -2,6 +2,7 @@ from dimo.eth_signer import EthSigner
 from dimo.errors import check_type, check_optional_type
 from urllib.parse import urlencode
 from typing import Dict, Optional
+import json
 
 
 class Auth:
@@ -36,13 +37,18 @@ class Auth:
             "address": address,
         }
 
-        return self._request(
+        response = self._request(
             "POST",
             "Auth",
             "/auth/web3/generate_challenge",
             data=urlencode(body),
             headers=headers,
         )
+        
+        if isinstance(response, bytes):
+            response = json.loads(response.decode('utf-8'))
+            
+        return response
 
     def sign_challenge(self, message: str, private_key: str) -> str:
         check_type("message", message, str)
@@ -78,13 +84,18 @@ class Auth:
 
         encoded_data = urlencode(form_data)
 
-        return self._request(
+        response = self._request(
             "POST",
             "Auth",
             "/auth/web3/submit_challenge",
             data=encoded_data,
             headers=headers,
         )
+        
+        if isinstance(response, bytes):
+            response = json.loads(response.decode('utf-8'))
+            
+        return response
 
     # Requires client_id, domain, and private_key. Address defaults to client_id.
     def get_dev_jwt(
@@ -96,7 +107,18 @@ class Auth:
         scope="openid email",
         response_type="code",
     ) -> Dict:
-
+        """
+        Generate a signed developer JWT in one step.
+        For testing, mocks and POCs.
+
+        Args:
+            client_id (str): The Ethereum address of the client
+            domain (str): The domain name for the client
+            private_key (str): The private key to sign the challenge
+        
+        Returns:
+            dict: The authentication response containing access_token
+        """
         check_type("client_id", client_id, str)
         check_type("domain", domain, str)
         check_type("private_key", private_key, str)
@@ -109,6 +131,7 @@ class Auth:
 
         headers = {"Content-Type": "application/x-www-form-urlencoded"}
 
+        # Generate a challenge
         challenge = self.generate_challenge(
             headers=headers,
             client_id=client_id,
@@ -117,14 +140,21 @@ class Auth:
             response_type=response_type,
             address=address,
         )
-
+        
+        if isinstance(challenge, bytes):
+            challenge = json.loads(challenge.decode('utf-8'))
+        
         sign = self.sign_challenge(
             message=challenge["challenge"],
             private_key=private_key,
         )
-
+        
         state = challenge["state"]
         signature = sign
 
         submit = self.submit_challenge(client_id, domain, state, signature, headers)
+        
+        if isinstance(submit, bytes):
+            submit = json.loads(submit.decode('utf-8'))
+            
         return submit

{dimo_python_sdk-1.3.2 → dimo_python_sdk-1.3.4}/dimo/api/token_exchange.py

@@ -1,6 +1,7 @@
 from dimo.constants import dimo_constants
 from dimo.errors import check_type, check_optional_type
 from dimo.permission_decoder import PermissionDecoder
+import json
 
 
 class TokenExchange:
@@ -17,6 +18,8 @@ class TokenExchange:
     def _decode_vehicle_permissions(self, token_id: int, client_id: str) -> dict:
         response = self._identity.check_vehicle_privileges(token_id)
         try:
+            # If response is bytes
+            response = json.loads(response.decode('utf-8'))
             nodes = (
                 response.get("data", {})
                 .get("vehicle", {})

dimo_python_sdk-1.3.4/dimo/dimo.py

@@ -0,0 +1,93 @@
+from typing_extensions import Optional
+from requests import Session
+
+from .api.attestation import Attestation
+from .api.auth import Auth
+from .api.device_definitions import DeviceDefinitions
+from .api.token_exchange import TokenExchange
+from .api.trips import Trips
+from .api.valuations import Valuations
+
+from .graphql.identity import Identity
+from .graphql.telemetry import Telemetry
+
+from .request import Request
+from .environments import dimo_environment
+from typing import Optional
+from typing_extensions import Dict
+from typing import Any
+from urllib.parse import urljoin
+
+
+class DIMO:
+
+    def __init__(self, env: str = "Production", session: Optional[Session] = None) -> None:
+
+        self.env = env
+        # Assert valid environment specified
+        if env not in dimo_environment:
+            raise ValueError(f"Unknown environment: {env}")
+
+        self.urls = dimo_environment[env]
+
+        self._client_id: Optional[str] = None
+        self._services: Dict[str, Any] = {}
+        self.session = session or Session()  # Use the provided session or create a new one
+
+    # Creates a full path for endpoints combining DIMO service, specific endpoint, and optional params
+    def _get_full_path(self, service: str, path: str, params=None) -> str:
+        base_path = self.urls[service]
+        path_formatted = path.format(**(params or {}))
+        return urljoin(base_path, path_formatted)
+
+    # 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, self.session)(**kwargs)
+
+    # query method for graphQL queries, identity and telemetry
+    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
+
+    def __getattr__(self, name: str) -> Any:
+        """
+        Lazy-load and cache service modules as attributes
+        """
+        # If service is already created, return from cache
+        if name in self._services:
+            return self._services[name]
+        # Otherwise, see if its a known service
+        mapping = {
+            "attestation": (Attestation, ("request", "_get_auth_headers")),
+            "auth": (Auth, ("request", "_get_auth_headers", "env", "self")),
+            "device_definitions": (DeviceDefinitions, ("request", "_get_auth_headers")),
+            "token_exchange": (
+                TokenExchange,
+                ("request", "_get_auth_headers", "identity", "self"),
+            ),
+            "trips": (Trips, ("request", "_get_auth_headers")),
+            "valuations": (Valuations, ("request", "_get_auth_headers")),
+            "identity": (Identity, ("self",)),
+            "telemetry": (Telemetry, ("self",)),
+        }
+        if name in mapping:
+            cls, deps = mapping[name]
+            args = [getattr(self, dep) if dep != "self" else self for dep in deps]
+            instance = cls(*args)
+            # And cache the service for future use
+            self._services[name] = instance
+            return instance
+        raise AttributeError(
+            f"{self.__class__.__name__!r} object has no attribute {name!r}"
+        )

dimo_python_sdk-1.3.4/dimo/request.py

@@ -0,0 +1,57 @@
+import json
+from typing import Any
+from requests import Session, RequestException
+
+
+class HTTPError(Exception):
+    """Http error wrapper with status code and (optional) response body"""
+
+    def __init__(self, status: int, message: str, body: Any = None):
+        super().__init__(f"HTTP {status}: {message}")
+        self.status = status
+        self.body = body
+
+
+class Request:
+
+    def __init__(self, http_method: str, url: str, session: Session):
+        self.http_method = http_method
+        self.url = url
+        self.session = session
+
+    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)
+
+        try:
+            response = self.session.request(
+                method=self.http_method,
+                url=self.url,
+                headers=headers,
+                params=params,
+                data=data,
+                **kwargs,
+            )
+
+            response.raise_for_status()
+        except RequestException as exc:
+            status = getattr(exc.response, "status_code", None)
+            body = None
+            try:
+                body = exc.response.json()
+            except Exception:
+                body = exc.response.txt if exc.response else None
+            raise HTTPError(status=status or -1, message=str(exc), body=body)
+
+        content_type = response.headers.get("Content-Type", "")
+        if "application/json" in content_type:
+            return response.json()
+
+        return response.content

{dimo_python_sdk-1.3.2 → dimo_python_sdk-1.3.4}/dimo_python_sdk.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dimo-python-sdk
-Version: 1.3.2
+Version: 1.3.4
 Summary: DIMO SDK in Python
 Author-email: Barrett Kowalsky <barrettkowalsky@gmail.com>
 Project-URL: Homepage, https://github.com/DIMO-Network/dimo-python-sdk

{dimo_python_sdk-1.3.2 → dimo_python_sdk-1.3.4}/dimo_python_sdk.egg-info/SOURCES.txt

@@ -23,4 +23,8 @@ dimo_python_sdk.egg-info/PKG-INFO
 dimo_python_sdk.egg-info/SOURCES.txt
 dimo_python_sdk.egg-info/dependency_links.txt
 dimo_python_sdk.egg-info/requires.txt
-dimo_python_sdk.egg-info/top_level.txt
+dimo_python_sdk.egg-info/top_level.txt
+tests/test_dimo.py
+tests/test_errors.py
+tests/test_permission_decoder.py
+tests/test_request.py

{dimo_python_sdk-1.3.2 → dimo_python_sdk-1.3.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "dimo-python-sdk"
-version = "1.3.2"
+version = "1.3.4"
 authors = [
   { name="Barrett Kowalsky", email="barrettkowalsky@gmail.com" },
 ]

dimo_python_sdk-1.3.4/tests/test_dimo.py

@@ -0,0 +1,60 @@
+from unittest.mock import MagicMock
+
+from dimo.dimo import DIMO
+
+
+def test_get_full_path_no_params():
+    client = DIMO(env="Dev")
+    result = client._get_full_path("Valuations", "/v2/vehicles/1234/valuations")
+    assert result == "https://valuations-api.dev.dimo.zone/v2/vehicles/1234/valuations"
+
+
+def test_get_full_path_with_params():
+    client = DIMO(env="Dev")
+    result = client._get_full_path(
+        "Telemetry",
+        "/items/{item_id}",
+        {"item_id": 123},
+    )
+    assert result == "https://telemetry-api.dev.dimo.zone/items/123"
+
+
+def test_get_auth_headers():
+    client = DIMO(env="Dev")
+    headers = client._get_auth_headers("token123")
+    assert headers == {
+        "Authorization": "Bearer token123",
+        "Content-Type": "application/json",
+    }
+
+
+def test_query_calls_request_with_correct_payload(monkeypatch):
+    client = DIMO(env="Dev")
+    # Create a fake request method on the client
+    fake_request = MagicMock(return_value={"data": {"result": True}})
+    monkeypatch.setattr(client, "request", fake_request)
+
+    query_str = "query { test }"
+    variables = {"key": "value"}
+    result = client.query("Trips", query_str, variables=variables, token="mocked_token")
+
+    # Verify the fake request was invoked once
+    fake_request.assert_called_once()
+    # Inspect call arguments
+    args, kwargs = fake_request.call_args
+    assert args[0] == "POST"
+    assert args[1] == "Trips"
+    assert args[2] == ""
+
+    # Assert correct headers
+    headers = kwargs["headers"]
+    assert headers["Authorization"] == "Bearer mocked_token"
+    assert headers["Content-Type"] == "application/json"
+    assert headers["User-Agent"] == "dimo-python-sdk"
+
+    # Check payload data
+    data = kwargs["data"]
+    assert data["query"] == query_str
+    assert data["variables"] == variables
+
+    assert result == {"data": {"result": True}}

dimo_python_sdk-1.3.4/tests/test_errors.py

@@ -0,0 +1,33 @@
+import pytest
+from dimo.errors import DimoTypeError, check_type, check_optional_type
+
+
+def test_check_type_passes_for_correct_type():
+    # call check_type with valid args which should not raise anything
+    check_type("count", 5, int)
+
+
+def test_check_type_raises_for_incorrect_type():
+    with pytest.raises(DimoTypeError) as exc:
+        check_type("name", 123, str)
+    err = exc.value
+    assert err.param_name == "name"
+    assert err.expected_type is str
+    assert isinstance(err.actual_value, int)
+
+    assert "name must be a str" in str(err)
+    assert "but was entered as type int" in str(err)
+
+
+def test_check_optional_type_allows_none():
+    # None is allowed
+    check_optional_type("maybe", None, dict)
+
+
+def test_check_optional_type_raises_for_wrong_non_none():
+    with pytest.raises(DimoTypeError) as exc:
+        check_optional_type("maybe", 3.14, str)
+    err = exc.value
+    assert err.param_name == "maybe"
+    assert err.expected_type is str
+    assert isinstance(err.actual_value, float)

dimo_python_sdk-1.3.4/tests/test_permission_decoder.py

@@ -0,0 +1,13 @@
+from dimo.permission_decoder import PermissionDecoder
+
+
+def test_dimo_client_hex_to_permissions():
+    permissions_hex = "0x3ffc"
+    permissions_list = PermissionDecoder.decode_permission_bits(permissions_hex)
+    assert permissions_list == [1, 2, 3, 4, 5, 6]
+
+    one_to_five_hex = "0xffc"
+    assert PermissionDecoder.decode_permission_bits(one_to_five_hex) == [1, 2, 3, 4, 5]
+
+    another_hex = "0x3fcc"
+    assert PermissionDecoder.decode_permission_bits(another_hex) == [1, 3, 4, 5, 6]

dimo_python_sdk-1.3.4/tests/test_request.py

@@ -0,0 +1,90 @@
+import json
+import pytest
+from requests import RequestException
+from unittest.mock import Mock
+
+from dimo.request import Request, HTTPError
+
+
+class DummyResponse:
+    def __init__(
+        self, status_code=200, headers=None, json_data=None, content=b"", txt=""
+    ):
+        self.status_code = status_code
+        self.headers = headers or {}
+        self._json_data = json_data
+        self.content = content
+        self.txt = txt
+        # .raise_for_status will be set per-test via side_effect
+
+    def json(self):
+        if isinstance(self._json_data, Exception):
+            raise self._json_data
+        return self._json_data
+
+
+@pytest.fixture
+def session():
+    return Mock()
+
+
+def make_request(session, **kwargs):
+    req = Request("POST", "https://api.example.com/endpoint", session)
+    return req(**kwargs)
+
+
+def test_json_request_body_is_serialized_and_passed_through(session):
+    data = {"foo": "bar"}
+    headers = {"Content-Type": "application/json"}
+    resp = DummyResponse(
+        status_code=200,
+        headers={"Content-Type": "application/json"},
+        json_data={"ok": True},
+    )
+    resp.raise_for_status = Mock()
+    session.request.return_value = resp
+
+    result = make_request(session, headers=headers, data=data)
+
+    # ensure data was JSON-dumped
+    _, call_kwargs = session.request.call_args
+    assert call_kwargs["data"] == json.dumps(data)
+
+    # ensure we got the parsed JSON back
+    assert result == {"ok": True}
+
+
+def test_non_json_response_returns_raw_content(session):
+    resp = DummyResponse(
+        status_code=200,
+        headers={"Content-Type": "text/plain"},
+        content=b"hello world",
+    )
+    resp.raise_for_status = Mock()
+    session.request.return_value = resp
+
+    result = make_request(session)
+    assert result == b"hello world"
+
+
+def test_http_error_wraps_json_body(session):
+    # prepare a RequestException with a response whose .json() returns a dict
+    err_resp = DummyResponse(
+        status_code=400,
+        json_data={"error": "Bad things"},
+        txt="Bad things text",
+    )
+    exc = RequestException("Bad Request")
+    exc.response = err_resp
+
+    # have raise_for_status raise that exception
+    good_resp = DummyResponse()
+    good_resp.raise_for_status = Mock(side_effect=exc)
+    session.request.return_value = good_resp
+
+    with pytest.raises(HTTPError) as ei:
+        make_request(session)
+    err = ei.value
+    assert err.status == 400
+    assert err.body == {"error": "Bad things"}
+    assert "Bad Request" in str(err)

dimo_python_sdk-1.3.2/dimo/dimo.py

@@ -1,65 +0,0 @@
-from .api.attestation import Attestation
-from .api.auth import Auth
-from .api.device_definitions import DeviceDefinitions
-from .api.token_exchange import TokenExchange
-from .api.trips import Trips
-from .api.valuations import Valuations
-
-from .graphql.identity import Identity
-from .graphql.telemetry import Telemetry
-
-from .request import Request
-from .environments import dimo_environment
-import re
-
-
-class DIMO:
-
-    def __init__(self, env="Production"):
-        self.env = env
-        self.urls = dimo_environment[env]
-        self._client_id = None
-        self.attestation = Attestation(self.request, self._get_auth_headers)
-        self.auth = Auth(self.request, self._get_auth_headers, self.env, self)
-        self.device_definitions = DeviceDefinitions(
-            self.request, self._get_auth_headers
-        )
-        self.identity = Identity(self)
-        self.token_exchange = TokenExchange(
-            self.request, self._get_auth_headers, self.identity, self
-        )
-        self.trips = Trips(self.request, self._get_auth_headers)
-        self.valuations = Valuations(self.request, self._get_auth_headers)
-        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
-    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_python_sdk-1.3.2/dimo/request.py

@@ -1,38 +0,0 @@
-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