Remove list_tables, consume status error field APP-6033 (#185)

* Consume error message from the status endpoint when available

* remove list tables endpoint

* fix test

* format

Author: ivpusic

dune_client/api/extensions.py

@@ -359,7 +359,9 @@ def run_sql(
 
         if status.state == ExecutionState.FAILED:
             self.logger.error(status)
-            raise QueryFailedError(f"Error data: {status.error}")
+            if status.error:
+                raise QueryFailedError(status.error.message)
+            raise QueryFailedError("Query execution failed")
 
         # Fetch and return results
         return self._fetch_entire_result(self.get_execution_results(job_id))
@@ -434,7 +436,9 @@ def _refresh(
             self.logger.warning("Partial result set retrieved.")
         if status.state == ExecutionState.FAILED:
             self.logger.error(status)
-            raise QueryFailedError(f"Error data: {status.error}")
+            if status.error:
+                raise QueryFailedError(status.error.message)
+            raise QueryFailedError("Query execution failed")
         return job_id
 
     def _fetch_entire_result(

dune_client/api/table.py

@@ -14,7 +14,6 @@
     DeleteTableResult,
     DuneError,
     InsertTableResult,
-    ListTablesResponse,
 )
 
 
@@ -138,34 +137,3 @@ def delete_table(self, namespace: str, table_name: str) -> DeleteTableResult:
             return DeleteTableResult.from_dict(response_json)
         except KeyError as err:
             raise DuneError(response_json, "DeleteTableResult", err) from err
-
-    def list_tables(
-        self,
-        limit: int | None = None,
-        offset: int | None = None,
-    ) -> ListTablesResponse:
-        """
-        https://docs.dune.com/api-reference/tables/endpoint/list
-        Get a paginated list of tables uploaded to Dune.
-
-        Args:
-            limit: Maximum number of tables to return (optional)
-            offset: Offset for pagination (optional)
-
-        Returns:
-            ListTablesResponse containing list of tables and pagination info
-        """
-        params = {}
-        if limit is not None:
-            params["limit"] = limit
-        if offset is not None:
-            params["offset"] = offset
-
-        response_json = self._get(
-            route="/tables",
-            params=params if params else None,
-        )
-        try:
-            return ListTablesResponse.from_dict(response_json)
-        except KeyError as err:
-            raise DuneError(response_json, "ListTablesResponse", err) from err

dune_client/client_async.py

@@ -681,7 +681,9 @@ async def _refresh(
             if status.state in terminal_states:
                 if status.state == ExecutionState.FAILED:
                     self.logger.error(status)
-                    raise QueryFailedError(f"Error data: {status.error}")
+                    if status.error:
+                        raise QueryFailedError(status.error.message)
+                    raise QueryFailedError("Query execution failed")
                 return job_id
 
             self.logger.info(f"waiting for query execution {job_id} to complete: {status}")

dune_client/models.py

@@ -454,58 +454,3 @@ def from_dict(cls, data: dict[str, Any]) -> UsageResponse:
             private_dashboards=int(data.get("private_dashboards", 0)),
             private_queries=int(data.get("private_queries", 0)),
         )
-
-
-@dataclass
-class TableInfo:
-    """Information about a single table"""
-
-    full_name: str
-    is_private: bool
-    created_at: str
-    # Optional fields that may be present
-    table_size_bytes: str | None = None
-    updated_at: str | None = None
-
-    @property
-    def namespace(self) -> str:
-        """Extract namespace from full_name (e.g., 'dune.namespace.table' -> 'namespace')"""
-        parts = self.full_name.split(".")
-        return parts[1] if len(parts) >= 3 else ""
-
-    @property
-    def table_name(self) -> str:
-        """Extract table name from full_name (e.g., 'dune.namespace.table' -> 'table')"""
-        parts = self.full_name.split(".")
-        return parts[2] if len(parts) >= 3 else ""
-
-    @classmethod
-    def from_dict(cls, data: dict[str, Any]) -> TableInfo:
-        """Constructor from dictionary."""
-        return cls(
-            full_name=data["full_name"],
-            is_private=data["is_private"],
-            created_at=data["created_at"],
-            table_size_bytes=data.get("table_size_bytes"),
-            updated_at=data.get("updated_at"),
-        )
-
-
-@dataclass
-class ListTablesResponse:
-    """
-    Representation of Response from Dune's [GET] Tables List endpoint
-    https://docs.dune.com/api-reference/tables/endpoint/list
-    """
-
-    tables: list[TableInfo]
-    next_offset: int | None
-
-    @classmethod
-    def from_dict(cls, data: dict[str, Any]) -> ListTablesResponse:
-        """Constructor from dictionary."""
-        tables_data = data.get("tables", [])
-        return cls(
-            tables=[TableInfo.from_dict(table) for table in tables_data],
-            next_offset=data.get("next_offset"),
-        )

tests/e2e/test_client.py

@@ -467,24 +467,6 @@ def test_get_usage_with_dates(self):
         # Should have at least one billing period for this date range
         assert len(usage.billing_periods) > 0
 
-    @unittest.skip("Requires Plus subscription and uploaded tables")
-    def test_list_tables(self):
-        """Test the list_tables endpoint"""
-        dune = DuneClient()
-        tables_response = dune.list_tables(limit=10)
-        # Verify response structure
-        assert hasattr(tables_response, "tables")
-        assert hasattr(tables_response, "next_offset")
-        assert isinstance(tables_response.tables, list)
-        # If there are tables, verify their structure
-        if len(tables_response.tables) > 0:
-            table = tables_response.tables[0]
-            assert hasattr(table, "namespace")
-            assert hasattr(table, "table_name")
-            assert hasattr(table, "full_name")
-            assert hasattr(table, "created_at")
-            assert hasattr(table, "is_private")
-
 
 @unittest.skip("This is an enterprise only endpoint that can no longer be tested.")
 class TestCRUDOps(unittest.TestCase):

tests/unit/test_async_client_logic.py

@@ -213,7 +213,7 @@ async def test_failed_state_raises_query_failed_error(self):
         with pytest.raises(QueryFailedError) as exc_info:
             await client._refresh(query)
 
-        assert "Error data:" in str(exc_info.value)
+        assert "Query syntax error" in str(exc_info.value)
 
     async def test_completed_state_returns_job_id(self):
         """Test that COMPLETED state returns job_id successfully"""

tests/unit/test_models.py

@@ -16,10 +16,8 @@
     ExecutionResultCSV,
     ExecutionState,
     ExecutionStatusResponse,
-    ListTablesResponse,
     ResultMetadata,
     ResultsResponse,
-    TableInfo,
     TimeData,
     UsageResponse,
 )
@@ -351,58 +349,6 @@ def test_usage_response_parsing_with_missing_fields(self):
         assert result.private_dashboards == 0
         assert result.private_queries == 0
 
-    def test_table_info_parsing(self):
-        """Test TableInfo parsing from API response"""
-        response_data = {
-            "full_name": "dune.my_namespace.my_table",
-            "created_at": "2024-01-15T10:30:00Z",
-            "is_private": True,
-            "table_size_bytes": "1024",
-            "updated_at": "2024-01-16T10:30:00Z",
-        }
-        result = TableInfo.from_dict(response_data)
-        assert result.full_name == "dune.my_namespace.my_table"
-        assert result.namespace == "my_namespace"
-        assert result.table_name == "my_table"
-        assert result.created_at == "2024-01-15T10:30:00Z"
-        assert result.is_private is True
-        assert result.table_size_bytes == "1024"
-        assert result.updated_at == "2024-01-16T10:30:00Z"
-
-    def test_list_tables_response_parsing(self):
-        """Test ListTablesResponse parsing from API response"""
-        response_data = {
-            "tables": [
-                {
-                    "full_name": "dune.namespace1.table1",
-                    "created_at": "2024-01-15T10:30:00Z",
-                    "is_private": False,
-                },
-                {
-                    "full_name": "dune.namespace2.table2",
-                    "created_at": "2024-01-16T11:30:00Z",
-                    "is_private": True,
-                },
-            ],
-            "next_offset": 100,
-        }
-        result = ListTablesResponse.from_dict(response_data)
-        assert len(result.tables) == 2
-        assert result.tables[0].full_name == "dune.namespace1.table1"
-        assert result.tables[0].namespace == "namespace1"
-        assert result.tables[0].table_name == "table1"
-        assert result.tables[1].full_name == "dune.namespace2.table2"
-        assert result.tables[1].namespace == "namespace2"
-        assert result.tables[1].table_name == "table2"
-        assert result.next_offset == 100
-
-    def test_list_tables_response_parsing_empty(self):
-        """Test ListTablesResponse parsing with no tables"""
-        response_data = {"tables": [], "next_offset": None}
-        result = ListTablesResponse.from_dict(response_data)
-        assert len(result.tables) == 0
-        assert result.next_offset is None
-
 
 if __name__ == "__main__":
     unittest.main()