Fix API routes and response models for Uploads and Datasets APIs

- Remove double /v1 prefix from all routes (api_version already includes it)
- Update Dataset models to match actual API responses (full_name instead of slug/namespace)
- Update Table models to match actual API responses (full_name format)
- Change owner from id to handle+type fields
- Add nullable field to column models
- Change InsertDataResponse to use 'name' field instead of 'table_name'
- Update datasets integration tests to use full_name and required filters
- Update uploads integration tests to use DUNE_NAMESPACE env var and handle CSV upload naming
- Fix column types in test schemas (int -> integer)

Author: va3093

dune_client/api/datasets.py

@@ -45,26 +45,26 @@ def list_datasets(
             params["type"] = type
 
         response_json = self._get(
-            route="/v1/datasets",
+            route="/datasets",
             params=params,
         )
         try:
             return DatasetListResponse.from_dict(response_json)
         except KeyError as err:
             raise DuneError(response_json, "DatasetListResponse", err) from err
 
-    def get_dataset(self, slug: str) -> DatasetResponse:
+    def get_dataset(self, full_name: str) -> DatasetResponse:
         """
         https://docs.dune.com/api-reference/datasets/endpoint/get
         Retrieve detailed information about a specific dataset.
 
         Args:
-            slug: The dataset slug (e.g., 'dex.trades')
+            full_name: The dataset full name (e.g., 'dune.shozaib_khan.aarna')
 
         Returns:
             DatasetResponse with full dataset details including columns and metadata
         """
-        response_json = self._get(route=f"/v1/datasets/{slug}")
+        response_json = self._get(route=f"/datasets/{full_name}")
         try:
             return DatasetResponse.from_dict(response_json)
         except KeyError as err:

dune_client/api/uploads.py

@@ -42,7 +42,7 @@ def list_uploads(
             UploadListResponse with list of tables and pagination info
         """
         response_json = self._get(
-            route="/v1/uploads",
+            route="/uploads",
             params={
                 "limit": limit,
                 "offset": offset,
@@ -78,7 +78,7 @@ def create_table(
             UploadCreateResponse with table details
         """
         result_json = self._post(
-            route="/v1/uploads",
+            route="/uploads",
             params={
                 "namespace": namespace,
                 "table_name": table_name,
@@ -117,7 +117,7 @@ def upload_csv(
             CSVUploadResponse with the created table name
         """
         response_json = self._post(
-            route="/v1/uploads/csv",
+            route="/uploads/csv",
             params={
                 "table_name": table_name,
                 "data": data,
@@ -155,7 +155,7 @@ def insert_data(
             InsertDataResponse with rows/bytes written
         """
         result_json = self._post(
-            route=f"/v1/uploads/{namespace}/{table_name}/insert",
+            route=f"/uploads/{namespace}/{table_name}/insert",
             headers={"Content-Type": content_type},
             data=data,
         )
@@ -180,7 +180,7 @@ def clear_table(
         Returns:
             ClearTableResponse with confirmation message
         """
-        result_json = self._post(route=f"/v1/uploads/{namespace}/{table_name}/clear")
+        result_json = self._post(route=f"/uploads/{namespace}/{table_name}/clear")
         try:
             return ClearTableResponse.from_dict(result_json)
         except KeyError as err:
@@ -202,7 +202,7 @@ def delete_table(
         Returns:
             DeleteTableResponse with confirmation message
         """
-        response_json = self._delete(route=f"/v1/uploads/{namespace}/{table_name}")
+        response_json = self._delete(route=f"/uploads/{namespace}/{table_name}")
         try:
             return DeleteTableResponse.from_dict(response_json)
         except KeyError as err:

dune_client/models.py

@@ -541,8 +541,8 @@ class DatasetType(Enum):
 class DatasetOwner(DataClassJsonMixin):
     """Owner information for a dataset"""
 
-    id: int
     handle: str
+    type: str
 
 
 @dataclass
@@ -551,17 +551,18 @@ class DatasetColumn(DataClassJsonMixin):
 
     name: str
     type: str
+    nullable: bool
 
 
 @dataclass
 class Dataset(DataClassJsonMixin):
     """Dataset information returned by list datasets endpoint"""
 
-    slug: str
-    name: str
+    full_name: str
     type: str
     owner: DatasetOwner
-    namespace: str
+    columns: list[DatasetColumn]
+    metadata: dict[str, str]
     created_at: str
     updated_at: str
     is_private: bool
@@ -577,15 +578,13 @@ class DatasetListResponse(DataClassJsonMixin):
 
 @dataclass
 class DatasetResponse(DataClassJsonMixin):
-    """Response from GET /v1/datasets/{slug}"""
+    """Response from GET /v1/datasets/{full_name}"""
 
-    slug: str
-    name: str
+    full_name: str
     type: str
     owner: DatasetOwner
-    namespace: str
     columns: list[DatasetColumn]
-    description: str | None
+    metadata: dict[str, str]
     created_at: str
     updated_at: str
     is_private: bool
@@ -595,8 +594,8 @@ class DatasetResponse(DataClassJsonMixin):
 class TableOwner(DataClassJsonMixin):
     """Owner information for an uploaded table"""
 
-    id: int
     handle: str
+    type: str
 
 
 @dataclass
@@ -605,24 +604,20 @@ class TableColumn(DataClassJsonMixin):
 
     name: str
     type: str
+    nullable: bool
 
 
 @dataclass
 class TableElement(DataClassJsonMixin):
     """Individual table metadata in list response"""
 
-    namespace: str
-    table_name: str
     full_name: str
-    example_query: str
-    description: str | None
     is_private: bool
-    columns: list[TableColumn]
-    size_bytes: int
-    row_count: int
-    owner: TableOwner
+    table_size_bytes: str
     created_at: str
     updated_at: str
+    owner: TableOwner
+    columns: list[TableColumn]
 
 
 @dataclass
@@ -677,7 +672,7 @@ class InsertDataResponse(DataClassJsonMixin):
 
     rows_written: int
     bytes_written: int
-    table_name: str
+    name: str
 
 
 @dataclass

tests/e2e/test_datasets_integration.py

@@ -17,7 +17,7 @@ def setUp(self) -> None:
         self.dune = DuneClient()
 
     def test_list_datasets(self):
-        result = self.dune.list_datasets(limit=10, offset=0)
+        result = self.dune.list_datasets(limit=10, offset=0, type="uploaded_table")
 
         self.assertIsInstance(result, DatasetListResponse)
         self.assertIsInstance(result.datasets, list)
@@ -26,11 +26,10 @@ def test_list_datasets(self):
 
         if len(result.datasets) > 0:
             dataset = result.datasets[0]
-            self.assertIsNotNone(dataset.slug)
-            self.assertIsNotNone(dataset.name)
+            self.assertIsNotNone(dataset.full_name)
             self.assertIsNotNone(dataset.type)
             self.assertIsNotNone(dataset.owner)
-            self.assertIsNotNone(dataset.namespace)
+            self.assertIsNotNone(dataset.columns)
 
     def test_list_datasets_with_filters(self):
         result = self.dune.list_datasets(
@@ -59,21 +58,25 @@ def test_list_datasets_by_owner(self):
             self.assertEqual(dataset.owner.handle, "dune")
 
     def test_get_dataset(self):
-        result = self.dune.get_dataset("dex.trades")
+        result_list = self.dune.list_datasets(limit=1, type="uploaded_table")
+        if len(result_list.datasets) == 0:
+            self.skipTest("No uploaded tables found to test")
+
+        full_name = result_list.datasets[0].full_name
+        result = self.dune.get_dataset(full_name)
 
         self.assertIsInstance(result, DatasetResponse)
-        self.assertEqual(result.slug, "dex.trades")
-        self.assertIsNotNone(result.name)
+        self.assertEqual(result.full_name, full_name)
         self.assertIsNotNone(result.type)
         self.assertIsNotNone(result.owner)
-        self.assertIsNotNone(result.namespace)
         self.assertIsNotNone(result.columns)
         self.assertIsInstance(result.columns, list)
         self.assertGreater(len(result.columns), 0)
 
         column = result.columns[0]
         self.assertIsNotNone(column.name)
         self.assertIsNotNone(column.type)
+        self.assertIsNotNone(column.nullable)
 
     def test_get_dataset_with_uploaded_table(self):
         result_list = self.dune.list_datasets(
@@ -82,11 +85,11 @@ def test_get_dataset_with_uploaded_table(self):
         )
 
         if len(result_list.datasets) > 0:
-            slug = result_list.datasets[0].slug
-            result = self.dune.get_dataset(slug)
+            full_name = result_list.datasets[0].full_name
+            result = self.dune.get_dataset(full_name)
 
             self.assertIsInstance(result, DatasetResponse)
-            self.assertEqual(result.slug, slug)
+            self.assertEqual(result.full_name, full_name)
             self.assertEqual(result.type, "uploaded_table")
 
 

tests/e2e/test_uploads_integration.py

@@ -1,3 +1,4 @@
+import os
 import unittest
 from io import BytesIO
 
@@ -23,12 +24,12 @@ class TestUploadsIntegration(unittest.TestCase):
 
     def setUp(self) -> None:
         self.dune = DuneClient()
-        self.test_namespace = "test"
+        self.test_namespace = os.getenv("DUNE_NAMESPACE", "test")
         self.test_table_name = f"test_uploads_api_{int(__import__('time').time())}"
 
     def test_create_and_delete_table(self):
         schema = [
-            {"name": "id", "type": "int"},
+            {"name": "id", "type": "integer"},
             {"name": "name", "type": "varchar"},
             {"name": "value", "type": "double"},
         ]
@@ -70,7 +71,7 @@ def test_upload_csv_and_delete(self):
 
         delete_result = self.dune.delete_table(
             namespace=self.test_namespace,
-            table_name=self.test_table_name,
+            table_name=f"dataset_{self.test_table_name}",
         )
         self.assertIsInstance(delete_result, DeleteTableResponse)
 
@@ -82,7 +83,7 @@ def test_list_uploads(self):
 
     def test_full_table_lifecycle(self):
         schema = [
-            {"name": "id", "type": "int"},
+            {"name": "id", "type": "integer"},
             {"name": "message", "type": "varchar"},
         ]