dataspace-sdk 0.4.2__py3-none-any.whl

dataspace_sdk/resources/datasets.py

@@ -0,0 +1,233 @@
+"""Dataset resource client for DataSpace SDK."""
+
+from typing import Any, Dict, List, Optional
+
+from dataspace_sdk.base import BaseAPIClient
+
+
+class DatasetClient(BaseAPIClient):
+    """Client for interacting with Dataset resources."""
+
+    def search(
+        self,
+        query: Optional[str] = None,
+        tags: Optional[List[str]] = None,
+        sectors: Optional[List[str]] = None,
+        geographies: Optional[List[str]] = None,
+        status: Optional[str] = None,
+        access_type: Optional[str] = None,
+        sort: Optional[str] = None,
+        page: int = 1,
+        page_size: int = 10,
+    ) -> Dict[str, Any]:
+        """
+        Search for datasets using Elasticsearch.
+
+        Args:
+            query: Search query string
+            tags: Filter by tags
+            sectors: Filter by sectors
+            geographies: Filter by geographies
+            status: Filter by status (DRAFT, PUBLISHED, etc.)
+            access_type: Filter by access type (OPEN, RESTRICTED, etc.)
+            sort: Sort order (recent, alphabetical)
+            page: Page number (1-indexed)
+            page_size: Number of results per page
+
+        Returns:
+            Dictionary containing search results and metadata
+        """
+        params: Dict[str, Any] = {
+            "page": page,
+            "page_size": page_size,
+        }
+
+        if query:
+            params["q"] = query
+        if tags:
+            params["tags"] = ",".join(tags)
+        if sectors:
+            params["sectors"] = ",".join(sectors)
+        if geographies:
+            params["geographies"] = ",".join(geographies)
+        if status:
+            params["status"] = status
+        if access_type:
+            params["access_type"] = access_type
+        if sort:
+            params["sort"] = sort
+
+        return super().get("/api/search/dataset/", params=params)
+
+    def get_by_id(self, dataset_id: str) -> Dict[str, Any]:
+        """
+        Get a dataset by ID using GraphQL.
+
+        Args:
+            dataset_id: UUID of the dataset
+
+        Returns:
+            Dictionary containing dataset information
+        """
+        query = """
+        query GetDataset($id: UUID!) {
+            dataset(id: $id) {
+                id
+                title
+                description
+                status
+                accessType
+                license
+                createdAt
+                updatedAt
+                organization {
+                    id
+                    name
+                    description
+                }
+                tags {
+                    id
+                    value
+                }
+                sectors {
+                    id
+                    name
+                }
+                geographies {
+                    id
+                    name
+                }
+                resources {
+                    id
+                    title
+                    description
+                    fileDetails
+                    schema
+                    createdAt
+                    updatedAt
+                }
+            }
+        }
+        """
+
+        response = self.post(
+            "/api/graphql",
+            json_data={
+                "query": query,
+                "variables": {"id": dataset_id},
+            },
+        )
+
+        if "errors" in response:
+            from dataspace_sdk.exceptions import DataSpaceAPIError
+
+            raise DataSpaceAPIError(f"GraphQL error: {response['errors']}")
+
+        result: Dict[str, Any] = response.get("data", {}).get("dataset", {})
+        return result
+
+    def list_all(
+        self,
+        status: Optional[str] = None,
+        organization_id: Optional[str] = None,
+        limit: int = 10,
+        offset: int = 0,
+    ) -> Any:
+        """
+        List all datasets with pagination using GraphQL.
+
+        Args:
+            status: Filter by status
+            organization_id: Filter by organization
+            limit: Number of results to return
+            offset: Number of results to skip
+
+        Returns:
+            Dictionary containing list of datasets
+        """
+        query = """
+        query ListDatasets($filters: DatasetFilter, $pagination: OffsetPaginationInput) {
+            datasets(filters: $filters, pagination: $pagination) {
+                id
+                title
+                description
+                status
+                accessType
+                license
+                createdAt
+                updatedAt
+                organization {
+                    id
+                    name
+                }
+                tags {
+                    id
+                    value
+                }
+            }
+        }
+        """
+
+        filters: Dict[str, Any] = {}
+        if status:
+            filters["status"] = status
+        if organization_id:
+            filters["organization"] = {"id": {"exact": organization_id}}
+
+        variables: Dict[str, Any] = {
+            "pagination": {"limit": limit, "offset": offset},
+        }
+        if filters:
+            variables["filters"] = filters
+
+        response = self.post(
+            "/api/graphql",
+            json_data={
+                "query": query,
+                "variables": variables,
+            },
+        )
+
+        if "errors" in response:
+            from dataspace_sdk.exceptions import DataSpaceAPIError
+
+            raise DataSpaceAPIError(f"GraphQL error: {response['errors']}")
+
+        data = response.get("data", {})
+        datasets_result: Any = data.get("datasets", []) if isinstance(data, dict) else []
+        return datasets_result
+
+    def get_trending(self, limit: int = 10) -> Dict[str, Any]:
+        """
+        Get trending datasets.
+
+        Args:
+            limit: Number of results to return
+
+        Returns:
+            Dictionary containing trending datasets
+        """
+        return self.get("/api/trending/datasets/", params={"limit": limit})
+
+    def get_organization_datasets(
+        self,
+        organization_id: str,
+        limit: int = 10,
+        offset: int = 0,
+    ) -> Any:
+        """
+        Get datasets for a specific organization.
+
+        Args:
+            organization_id: UUID of the organization
+            limit: Number of results to return
+            offset: Number of results to skip
+
+        Returns:
+            Dictionary containing organization's datasets
+        """
+        return self.list_all(
+            organization_id=organization_id,
+            limit=limit,
+            offset=offset,
+        )

dataspace_sdk/resources/sectors.py

@@ -0,0 +1,128 @@
+"""Sector resource client for DataSpace SDK."""
+
+from typing import Any, Dict, List, Optional
+
+from dataspace_sdk.base import BaseAPIClient
+
+
+class SectorClient(BaseAPIClient):
+    """Client for interacting with Sector resources."""
+
+    def list_all(
+        self,
+        search: Optional[str] = None,
+        min_dataset_count: Optional[int] = None,
+        min_aimodel_count: Optional[int] = None,
+        limit: int = 100,
+        offset: int = 0,
+    ) -> List[Dict[str, Any]]:
+        """
+        List all sectors with optional filters using GraphQL.
+
+        Args:
+            search: Search query for name/description
+            min_dataset_count: Filter sectors with at least this many published datasets
+            min_aimodel_count: Filter sectors with at least this many active AI models
+            limit: Number of results to return
+            offset: Number of results to skip
+
+        Returns:
+            List of sector dictionaries
+        """
+        query = """
+        query ListSectors($filters: SectorFilter, $pagination: OffsetPaginationInput) {
+            sectors(filters: $filters, pagination: $pagination) {
+                id
+                name
+                slug
+                description
+            }
+        }
+        """
+
+        filters: Dict[str, Any] = {}
+        if search:
+            filters["search"] = search
+        if min_dataset_count is not None:
+            filters["min_dataset_count"] = min_dataset_count
+        if min_aimodel_count is not None:
+            filters["min_aimodel_count"] = min_aimodel_count
+
+        variables: Dict[str, Any] = {
+            "pagination": {"limit": limit, "offset": offset},
+        }
+        if filters:
+            variables["filters"] = filters
+
+        response = self.post(
+            "/api/graphql",
+            json_data={
+                "query": query,
+                "variables": variables,
+            },
+        )
+
+        if "errors" in response:
+            from dataspace_sdk.exceptions import DataSpaceAPIError
+
+            raise DataSpaceAPIError(f"GraphQL error: {response['errors']}")
+
+        data = response.get("data", {})
+        sectors_result: List[Dict[str, Any]] = (
+            data.get("sectors", []) if isinstance(data, dict) else []
+        )
+        return sectors_result
+
+    def get_by_id(self, sector_id: str) -> Dict[str, Any]:
+        """
+        Get a sector by ID using GraphQL.
+
+        Args:
+            sector_id: UUID of the sector
+
+        Returns:
+            Dictionary containing sector information
+        """
+        query = """
+        query GetSector($id: UUID!) {
+            sector(id: $id) {
+                id
+                name
+                slug
+                description
+            }
+        }
+        """
+
+        response = self.post(
+            "/api/graphql",
+            json_data={
+                "query": query,
+                "variables": {"id": sector_id},
+            },
+        )
+
+        if "errors" in response:
+            from dataspace_sdk.exceptions import DataSpaceAPIError
+
+            raise DataSpaceAPIError(f"GraphQL error: {response['errors']}")
+
+        result: Dict[str, Any] = response.get("data", {}).get("sector", {})
+        return result
+
+    def get_sectors_with_aimodels(
+        self,
+        limit: int = 100,
+        offset: int = 0,
+    ) -> List[Dict[str, Any]]:
+        """
+        Get sectors that have at least one active AI model.
+
+        Args:
+            limit: Number of results to return
+            offset: Number of results to skip
+
+        Returns:
+            List of sector dictionaries with AI models
+        """
+        return self.list_all(min_aimodel_count=1, limit=limit, offset=offset)

dataspace_sdk/resources/usecases.py

@@ -0,0 +1,248 @@
+"""UseCase resource client for DataSpace SDK."""
+
+from typing import Any, Dict, List, Optional
+
+from dataspace_sdk.base import BaseAPIClient
+
+
+class UseCaseClient(BaseAPIClient):
+    """Client for interacting with UseCase resources."""
+
+    def search(
+        self,
+        query: Optional[str] = None,
+        tags: Optional[List[str]] = None,
+        sectors: Optional[List[str]] = None,
+        geographies: Optional[List[str]] = None,
+        status: Optional[str] = None,
+        running_status: Optional[str] = None,
+        sort: Optional[str] = None,
+        page: int = 1,
+        page_size: int = 10,
+    ) -> Dict[str, Any]:
+        """
+        Search for use cases using Elasticsearch.
+
+        Args:
+            query: Search query string
+            tags: Filter by tags
+            sectors: Filter by sectors
+            geographies: Filter by geographies
+            status: Filter by status (DRAFT, PUBLISHED, etc.)
+            running_status: Filter by running status (INITIATED, ONGOING, COMPLETED)
+            sort: Sort order (recent, alphabetical, started_on, completed_on)
+            page: Page number (1-indexed)
+            page_size: Number of results per page
+
+        Returns:
+            Dictionary containing search results and metadata
+        """
+        params: Dict[str, Any] = {
+            "page": page,
+            "page_size": page_size,
+        }
+
+        if query:
+            params["q"] = query
+        if tags:
+            params["tags"] = ",".join(tags)
+        if sectors:
+            params["sectors"] = ",".join(sectors)
+        if geographies:
+            params["geographies"] = ",".join(geographies)
+        if status:
+            params["status"] = status
+        if running_status:
+            params["running_status"] = running_status
+        if sort:
+            params["sort"] = sort
+
+        return super().get("/api/search/usecase/", params=params)
+
+    def get_by_id(self, usecase_id: int) -> Dict[str, Any]:
+        """
+        Get a use case by ID using GraphQL.
+
+        Args:
+            usecase_id: ID of the use case
+
+        Returns:
+            Dictionary containing use case information
+        """
+        query = """
+        query GetUseCase($id: ID!) {
+            useCase(id: $id) {
+                id
+                title
+                summary
+                status
+                runningStatus
+                platformUrl
+                logo
+                startedOn
+                completedOn
+                createdAt
+                updatedAt
+                tags {
+                    id
+                    value
+                }
+                sectors {
+                    id
+                    name
+                }
+                geographies {
+                    id
+                    name
+                }
+                sdgs {
+                    id
+                    name
+                    description
+                }
+                datasets {
+                    id
+                    title
+                    description
+                }
+                organizations {
+                    id
+                    organization {
+                        id
+                        name
+                    }
+                    relationshipType
+                }
+                contributors {
+                    id
+                    username
+                    firstName
+                    lastName
+                }
+            }
+        }
+        """
+
+        response = self.post(
+            "/api/graphql",
+            json_data={
+                "query": query,
+                "variables": {"id": str(usecase_id)},
+            },
+        )
+
+        if "errors" in response:
+            from dataspace_sdk.exceptions import DataSpaceAPIError
+
+            raise DataSpaceAPIError(f"GraphQL error: {response['errors']}")
+
+        result: Dict[str, Any] = response.get("data", {}).get("useCase", {})
+        return result
+
+    def list_all(
+        self,
+        status: Optional[str] = None,
+        running_status: Optional[str] = None,
+        organization_id: Optional[str] = None,
+        limit: int = 10,
+        offset: int = 0,
+    ) -> Any:
+        """
+        List all use cases with pagination using GraphQL.
+
+        Args:
+            status: Filter by status
+            running_status: Filter by running status
+            organization_id: Filter by organization
+            limit: Number of results to return
+            offset: Number of results to skip
+
+        Returns:
+            Dictionary containing list of use cases
+        """
+        query = """
+        query ListUseCases($filters: UseCaseFilter, $pagination: OffsetPaginationInput) {
+            useCases(filters: $filters, pagination: $pagination) {
+                id
+                title
+                summary
+                status
+                runningStatus
+                platformUrl
+                startedOn
+                completedOn
+                createdAt
+                updatedAt
+                tags {
+                    id
+                    value
+                }
+                sectors {
+                    id
+                    name
+                }
+                organizations {
+                    id
+                    organization {
+                        id
+                        name
+                    }
+                    relationshipType
+                }
+            }
+        }
+        """
+
+        filters: Dict[str, Any] = {}
+        if status:
+            filters["status"] = status
+        if running_status:
+            filters["runningStatus"] = running_status
+        if organization_id:
+            filters["organizations"] = {"organization": {"id": {"exact": organization_id}}}
+
+        variables: Dict[str, Any] = {
+            "pagination": {"limit": limit, "offset": offset},
+        }
+        if filters:
+            variables["filters"] = filters
+
+        response = self.post(
+            "/api/graphql",
+            json_data={
+                "query": query,
+                "variables": variables,
+            },
+        )
+
+        if "errors" in response:
+            from dataspace_sdk.exceptions import DataSpaceAPIError
+
+            raise DataSpaceAPIError(f"GraphQL error: {response['errors']}")
+
+        data = response.get("data", {})
+        usecases_result: Any = data.get("useCases", []) if isinstance(data, dict) else []
+        return usecases_result
+
+    def get_organization_usecases(
+        self,
+        organization_id: str,
+        limit: int = 10,
+        offset: int = 0,
+    ) -> Any:
+        """
+        Get use cases for a specific organization.
+
+        Args:
+            organization_id: UUID of the organization
+            limit: Number of results to return
+            offset: Number of results to skip
+
+        Returns:
+            Dictionary containing organization's use cases
+        """
+        return self.list_all(
+            organization_id=organization_id,
+            limit=limit,
+            offset=offset,
+        )