dataspace-sdk 0.1.0__py3-none-any.whl

dataspace_sdk/__init__.py

@@ -0,0 +1,18 @@
+"""DataSpace Python SDK for programmatic access to DataSpace resources."""
+
+from dataspace_sdk.client import DataSpaceClient
+from dataspace_sdk.exceptions import (
+    DataSpaceAPIError,
+    DataSpaceAuthError,
+    DataSpaceNotFoundError,
+    DataSpaceValidationError,
+)
+
+__version__ = "0.1.0"
+__all__ = [
+    "DataSpaceClient",
+    "DataSpaceAPIError",
+    "DataSpaceAuthError",
+    "DataSpaceNotFoundError",
+    "DataSpaceValidationError",
+]

dataspace_sdk/auth.py

@@ -0,0 +1,139 @@
+"""Authentication module for DataSpace SDK."""
+
+from typing import Dict, Optional
+
+import requests
+
+from dataspace_sdk.exceptions import DataSpaceAuthError
+
+
+class AuthClient:
+    """Handles authentication with DataSpace API."""
+
+    def __init__(self, base_url: str):
+        """
+        Initialize the authentication client.
+
+        Args:
+            base_url: Base URL of the DataSpace API
+        """
+        self.base_url = base_url.rstrip("/")
+        self.access_token: Optional[str] = None
+        self.refresh_token: Optional[str] = None
+        self.user_info: Optional[Dict] = None
+
+    def login_with_keycloak(self, keycloak_token: str) -> Dict:
+        """
+        Login using a Keycloak token.
+
+        Args:
+            keycloak_token: Valid Keycloak access token
+
+        Returns:
+            Dictionary containing user info and tokens
+
+        Raises:
+            DataSpaceAuthError: If authentication fails
+        """
+        url = f"{self.base_url}/api/auth/keycloak/login/"
+        
+        try:
+            response = requests.post(
+                url,
+                json={"token": keycloak_token},
+                headers={"Content-Type": "application/json"},
+            )
+            
+            if response.status_code == 200:
+                data = response.json()
+                self.access_token = data.get("access")
+                self.refresh_token = data.get("refresh")
+                self.user_info = data.get("user")
+                return data
+            else:
+                error_msg = response.json().get("error", "Authentication failed")
+                raise DataSpaceAuthError(
+                    error_msg,
+                    status_code=response.status_code,
+                    response=response.json(),
+                )
+        except requests.RequestException as e:
+            raise DataSpaceAuthError(f"Network error during authentication: {str(e)}")
+
+    def refresh_access_token(self) -> str:
+        """
+        Refresh the access token using the refresh token.
+
+        Returns:
+            New access token
+
+        Raises:
+            DataSpaceAuthError: If token refresh fails
+        """
+        if not self.refresh_token:
+            raise DataSpaceAuthError("No refresh token available")
+
+        url = f"{self.base_url}/api/auth/token/refresh/"
+        
+        try:
+            response = requests.post(
+                url,
+                json={"refresh": self.refresh_token},
+                headers={"Content-Type": "application/json"},
+            )
+            
+            if response.status_code == 200:
+                data = response.json()
+                self.access_token = data.get("access")
+                return self.access_token
+            else:
+                raise DataSpaceAuthError(
+                    "Token refresh failed",
+                    status_code=response.status_code,
+                    response=response.json(),
+                )
+        except requests.RequestException as e:
+            raise DataSpaceAuthError(f"Network error during token refresh: {str(e)}")
+
+    def get_user_info(self) -> Dict:
+        """
+        Get current user information.
+
+        Returns:
+            Dictionary containing user information
+
+        Raises:
+            DataSpaceAuthError: If request fails
+        """
+        if not self.access_token:
+            raise DataSpaceAuthError("Not authenticated. Please login first.")
+
+        url = f"{self.base_url}/api/auth/user/info/"
+        
+        try:
+            response = requests.get(
+                url,
+                headers=self._get_auth_headers(),
+            )
+            
+            if response.status_code == 200:
+                self.user_info = response.json()
+                return self.user_info
+            else:
+                raise DataSpaceAuthError(
+                    "Failed to get user info",
+                    status_code=response.status_code,
+                    response=response.json(),
+                )
+        except requests.RequestException as e:
+            raise DataSpaceAuthError(f"Network error getting user info: {str(e)}")
+
+    def _get_auth_headers(self) -> Dict[str, str]:
+        """Get headers with authentication token."""
+        if not self.access_token:
+            return {}
+        return {"Authorization": f"Bearer {self.access_token}"}
+
+    def is_authenticated(self) -> bool:
+        """Check if the client is authenticated."""
+        return self.access_token is not None

dataspace_sdk/base.py

@@ -0,0 +1,148 @@
+"""Base client for making API requests."""
+
+from typing import Any, Dict, Optional
+
+import requests
+
+from dataspace_sdk.exceptions import (
+    DataSpaceAPIError,
+    DataSpaceAuthError,
+    DataSpaceNotFoundError,
+    DataSpaceValidationError,
+)
+
+
+class BaseAPIClient:
+    """Base client for making API requests to DataSpace."""
+
+    def __init__(self, base_url: str, auth_client=None):
+        """
+        Initialize the base API client.
+
+        Args:
+            base_url: Base URL of the DataSpace API
+            auth_client: Authentication client instance
+        """
+        self.base_url = base_url.rstrip("/")
+        self.auth_client = auth_client
+
+    def _get_headers(self, additional_headers: Optional[Dict[str, str]] = None) -> Dict[str, str]:
+        """
+        Get request headers including authentication.
+
+        Args:
+            additional_headers: Additional headers to include
+
+        Returns:
+            Dictionary of headers
+        """
+        headers = {"Content-Type": "application/json"}
+        
+        if self.auth_client and self.auth_client.is_authenticated():
+            headers["Authorization"] = f"Bearer {self.auth_client.access_token}"
+        
+        if additional_headers:
+            headers.update(additional_headers)
+        
+        return headers
+
+    def _make_request(
+        self,
+        method: str,
+        endpoint: str,
+        params: Optional[Dict[str, Any]] = None,
+        data: Optional[Dict[str, Any]] = None,
+        json_data: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, str]] = None,
+    ) -> Dict[str, Any]:
+        """
+        Make an HTTP request to the API.
+
+        Args:
+            method: HTTP method (GET, POST, etc.)
+            endpoint: API endpoint
+            params: Query parameters
+            data: Form data
+            json_data: JSON data
+            headers: Additional headers
+
+        Returns:
+            Response data as dictionary
+
+        Raises:
+            DataSpaceAPIError: For API errors
+            DataSpaceAuthError: For authentication errors
+            DataSpaceNotFoundError: For 404 errors
+            DataSpaceValidationError: For validation errors
+        """
+        url = f"{self.base_url}{endpoint}"
+        request_headers = self._get_headers(headers)
+
+        try:
+            response = requests.request(
+                method=method,
+                url=url,
+                params=params,
+                data=data,
+                json=json_data,
+                headers=request_headers,
+            )
+
+            # Handle different status codes
+            if response.status_code == 200 or response.status_code == 201:
+                return response.json() if response.content else {}
+            elif response.status_code == 204:
+                return {}
+            elif response.status_code == 401:
+                raise DataSpaceAuthError(
+                    "Authentication required or token expired",
+                    status_code=response.status_code,
+                    response=response.json() if response.content else {},
+                )
+            elif response.status_code == 404:
+                raise DataSpaceNotFoundError(
+                    "Resource not found",
+                    status_code=response.status_code,
+                    response=response.json() if response.content else {},
+                )
+            elif response.status_code == 400:
+                raise DataSpaceValidationError(
+                    "Validation error",
+                    status_code=response.status_code,
+                    response=response.json() if response.content else {},
+                )
+            else:
+                raise DataSpaceAPIError(
+                    f"API request failed with status {response.status_code}",
+                    status_code=response.status_code,
+                    response=response.json() if response.content else {},
+                )
+
+        except requests.RequestException as e:
+            raise DataSpaceAPIError(f"Network error: {str(e)}")
+
+    def get(self, endpoint: str, params: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """Make a GET request."""
+        return self._make_request("GET", endpoint, params=params)
+
+    def post(
+        self,
+        endpoint: str,
+        data: Optional[Dict[str, Any]] = None,
+        json_data: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        """Make a POST request."""
+        return self._make_request("POST", endpoint, data=data, json_data=json_data)
+
+    def put(
+        self,
+        endpoint: str,
+        data: Optional[Dict[str, Any]] = None,
+        json_data: Optional[Dict[str, Any]] = None,
+    ) -> Dict[str, Any]:
+        """Make a PUT request."""
+        return self._make_request("PUT", endpoint, data=data, json_data=json_data)
+
+    def delete(self, endpoint: str) -> Dict[str, Any]:
+        """Make a DELETE request."""
+        return self._make_request("DELETE", endpoint)

dataspace_sdk/client.py

@@ -0,0 +1,133 @@
+"""Main DataSpace SDK client."""
+
+from typing import Optional
+
+from dataspace_sdk.auth import AuthClient
+from dataspace_sdk.resources.aimodels import AIModelClient
+from dataspace_sdk.resources.datasets import DatasetClient
+from dataspace_sdk.resources.usecases import UseCaseClient
+
+
+class DataSpaceClient:
+    """
+    Main client for interacting with DataSpace API.
+
+    Example:
+        >>> from dataspace_sdk import DataSpaceClient
+        >>> 
+        >>> # Initialize client
+        >>> client = DataSpaceClient(base_url="https://api.dataspace.example.com")
+        >>> 
+        >>> # Login with Keycloak token
+        >>> client.login(keycloak_token="your_keycloak_token")
+        >>> 
+        >>> # Search for datasets
+        >>> datasets = client.datasets.search(query="health", tags=["public-health"])
+        >>> 
+        >>> # Get a specific dataset
+        >>> dataset = client.datasets.get_by_id("dataset-uuid")
+        >>> 
+        >>> # Get organization's resources
+        >>> org_datasets = client.datasets.get_organization_datasets("org-uuid")
+        >>> org_models = client.aimodels.get_organization_models("org-uuid")
+        >>> org_usecases = client.usecases.get_organization_usecases("org-uuid")
+    """
+
+    def __init__(self, base_url: str):
+        """
+        Initialize the DataSpace client.
+
+        Args:
+            base_url: Base URL of the DataSpace API (e.g., "https://api.dataspace.example.com")
+        """
+        self.base_url = base_url.rstrip("/")
+        self._auth = AuthClient(self.base_url)
+        
+        # Initialize resource clients
+        self.datasets = DatasetClient(self.base_url, self._auth)
+        self.aimodels = AIModelClient(self.base_url, self._auth)
+        self.usecases = UseCaseClient(self.base_url, self._auth)
+
+    def login(self, keycloak_token: str) -> dict:
+        """
+        Login using a Keycloak token.
+
+        Args:
+            keycloak_token: Valid Keycloak access token
+
+        Returns:
+            Dictionary containing user info and tokens
+
+        Raises:
+            DataSpaceAuthError: If authentication fails
+
+        Example:
+            >>> client = DataSpaceClient(base_url="https://api.dataspace.example.com")
+            >>> user_info = client.login(keycloak_token="your_token")
+            >>> print(user_info["user"]["username"])
+        """
+        return self._auth.login_with_keycloak(keycloak_token)
+
+    def refresh_token(self) -> str:
+        """
+        Refresh the access token using the refresh token.
+
+        Returns:
+            New access token
+
+        Raises:
+            DataSpaceAuthError: If token refresh fails
+
+        Example:
+            >>> client.refresh_token()
+        """
+        return self._auth.refresh_access_token()
+
+    def get_user_info(self) -> dict:
+        """
+        Get current user information.
+
+        Returns:
+            Dictionary containing user information including organizations
+
+        Raises:
+            DataSpaceAuthError: If not authenticated or request fails
+
+        Example:
+            >>> user_info = client.get_user_info()
+            >>> print(user_info["organizations"])
+        """
+        return self._auth.get_user_info()
+
+    def is_authenticated(self) -> bool:
+        """
+        Check if the client is authenticated.
+
+        Returns:
+            True if authenticated, False otherwise
+
+        Example:
+            >>> if client.is_authenticated():
+            ...     datasets = client.datasets.search()
+        """
+        return self._auth.is_authenticated()
+
+    @property
+    def user(self) -> Optional[dict]:
+        """
+        Get cached user information.
+
+        Returns:
+            User information dictionary or None if not authenticated
+        """
+        return self._auth.user_info
+
+    @property
+    def access_token(self) -> Optional[str]:
+        """
+        Get the current access token.
+
+        Returns:
+            Access token string or None if not authenticated
+        """
+        return self._auth.access_token

dataspace_sdk/exceptions.py

@@ -0,0 +1,29 @@
+"""Custom exceptions for DataSpace SDK."""
+
+
+class DataSpaceAPIError(Exception):
+    """Base exception for DataSpace API errors."""
+
+    def __init__(self, message: str, status_code: int = None, response: dict = None):
+        self.message = message
+        self.status_code = status_code
+        self.response = response
+        super().__init__(self.message)
+
+
+class DataSpaceAuthError(DataSpaceAPIError):
+    """Exception raised for authentication errors."""
+
+    pass
+
+
+class DataSpaceNotFoundError(DataSpaceAPIError):
+    """Exception raised when a resource is not found."""
+
+    pass
+
+
+class DataSpaceValidationError(DataSpaceAPIError):
+    """Exception raised for validation errors."""
+
+    pass

dataspace_sdk/resources/__init__.py

@@ -0,0 +1,7 @@
+"""Resource clients for DataSpace SDK."""
+
+from dataspace_sdk.resources.aimodels import AIModelClient
+from dataspace_sdk.resources.datasets import DatasetClient
+from dataspace_sdk.resources.usecases import UseCaseClient
+
+__all__ = ["DatasetClient", "AIModelClient", "UseCaseClient"]