datamaker-py 0.7.0__py3-none-any.whl

datamaker/routes/__init__.py

@@ -0,0 +1,37 @@
+"""Routes package for datamaker API endpoints."""
+
+from .base import BaseClient
+from .generation import GenerationClient
+from .templates import TemplatesClient
+from .api_keys import ApiKeysClient
+from .connections import ConnectionsClient
+from .projects import ProjectsClient
+from .users import UsersClient
+from .teams import TeamsClient, TeamMembersClient
+from .custom_types import CustomDataTypesClient, EndpointFoldersClient, EndpointsClient
+from .folders_and_utils import TemplateFoldersClient, ShortcutsClient, FeedbackClient
+from .export_and_validation import ExportClient, ValidationClient
+from .scenario_files import ScenarioFilesClient
+from .sets import SetsClient
+
+__all__ = [
+    "BaseClient",
+    "GenerationClient",
+    "TemplatesClient",
+    "ApiKeysClient",
+    "ConnectionsClient",
+    "ProjectsClient",
+    "UsersClient",
+    "TeamsClient",
+    "TeamMembersClient",
+    "CustomDataTypesClient",
+    "EndpointFoldersClient",
+    "EndpointsClient",
+    "TemplateFoldersClient",
+    "ShortcutsClient",
+    "FeedbackClient",
+    "ExportClient",
+    "ValidationClient",
+    "ScenarioFilesClient",
+    "SetsClient",
+]

datamaker/routes/api_keys.py

@@ -0,0 +1,50 @@
+from .base import BaseClient
+from typing import Optional, Dict, List
+
+
+class ApiKeysClient(BaseClient):
+    """Client for API key management operations."""
+
+    def get_api_keys(self) -> List[Dict]:
+        """Get all API keys."""
+        response = self._make_request("GET", "/apiKeys")
+        return response.json()
+
+    def create_api_key(
+        self,
+        key: str,
+        scope: str,
+        name: Optional[str] = None,
+        team_id: Optional[str] = None,
+    ) -> Dict:
+        """Create a new API key."""
+        data = {"key": key, "scope": scope}
+        if name:
+            data["name"] = name
+        if team_id:
+            data["teamId"] = team_id
+
+        response = self._make_request("POST", "/apiKeys", json=data)
+        return response.json()
+
+    def update_api_key(
+        self,
+        key_id: str,
+        key: str,
+        name: Optional[str] = None,
+        team_id: Optional[str] = None,
+    ) -> Dict:
+        """Update an API key."""
+        data = {"key": key}
+        if name:
+            data["name"] = name
+        if team_id:
+            data["teamId"] = team_id
+
+        response = self._make_request("PUT", f"/apiKeys/{key_id}", json=data)
+        return response.json()
+
+    def delete_api_key(self, key_id: str) -> Dict:
+        """Delete an API key."""
+        response = self._make_request("DELETE", f"/apiKeys/{key_id}")
+        return response.json()

datamaker/routes/base.py

@@ -0,0 +1,40 @@
+import os
+import requests
+from typing import Optional, Dict
+from ..error import DataMakerError
+
+
+class BaseClient:
+    """Base client for DataMaker API operations."""
+
+    def __init__(
+        self,
+        api_key: str = None,
+        default_headers: Dict[str, Optional[str]] = None,
+        base_url: Optional[str] = None,
+        verify: bool = True,
+    ):
+        if default_headers is None:
+            default_headers = {"Content-Type": "application/json"}
+
+        self.api_key = api_key or os.getenv("DATAMAKER_API_KEY")
+        self.headers = {
+            "X-API-Key": self.api_key,
+            **(default_headers or {}),
+        }
+        # Use DATAMAKER_API_URL environment variable if base_url is not provided
+        self.base_url = base_url or os.getenv("DATAMAKER_API_URL") or "https://api.datamaker.automators.com"
+        self.verify = verify
+
+    def _make_request(self, method: str, endpoint: str, **kwargs) -> requests.Response:
+        """Make an HTTP request to the API."""
+        url = f"{self.base_url}{endpoint}"
+        # Ensure verify is passed to requests, but allow kwargs to override if needed
+        if "verify" not in kwargs:
+            kwargs["verify"] = self.verify
+        response = requests.request(method, url, headers=self.headers, **kwargs)
+
+        if response.status_code not in [200, 201]:
+            raise DataMakerError(f"API request failed: {response.text}")
+
+        return response

datamaker/routes/connections.py

@@ -0,0 +1,87 @@
+from .base import BaseClient
+from typing import Optional, Dict, List, Literal
+
+
+class ConnectionsClient(BaseClient):
+    """Client for database connection management operations."""
+
+    def get_connections(self) -> List[Dict]:
+        """Get all connections."""
+        response = self._make_request("GET", "/connections")
+        return response.json()
+
+    def create_connection(
+        self,
+        name: str,
+        connection_type: Literal[
+            "db2", "postgresql", "mysql", "mssql", "mongodb", "oracle"
+        ],
+        connection_string: str,
+        created_by: str,
+        project_id: str,
+        team_id: str,
+        read_only: Optional[bool] = None,
+        endpoint_folder_id: Optional[str] = None,
+    ) -> Dict:
+        """Create a new database connection."""
+        data = {
+            "name": name,
+            "type": connection_type,
+            "connectionString": connection_string,
+            "createdBy": created_by,
+            "projectId": project_id,
+            "teamId": team_id,
+        }
+        if read_only is not None:
+            data["readOnly"] = read_only
+        if endpoint_folder_id:
+            data["endpointFolderId"] = endpoint_folder_id
+
+        response = self._make_request("POST", "/connections", json=data)
+        return response.json()
+
+    def update_connection(
+        self,
+        connection_id: str,
+        name: str,
+        connection_type: Literal[
+            "db2", "postgresql", "mysql", "mssql", "mongodb", "oracle"
+        ],
+        connection_string: str,
+        created_by: str,
+        project_id: str,
+        team_id: str,
+        read_only: Optional[bool] = None,
+        endpoint_folder_id: Optional[str] = None,
+    ) -> Dict:
+        """Update a database connection."""
+        data = {
+            "name": name,
+            "type": connection_type,
+            "connectionString": connection_string,
+            "createdBy": created_by,
+            "projectId": project_id,
+            "teamId": team_id,
+        }
+        if read_only is not None:
+            data["readOnly"] = read_only
+        if endpoint_folder_id:
+            data["endpointFolderId"] = endpoint_folder_id
+
+        response = self._make_request("PUT", f"/connections/{connection_id}", json=data)
+        return response.json()
+
+    def delete_connection(self, connection_id: str) -> Dict:
+        """Delete a database connection."""
+        response = self._make_request("DELETE", f"/connections/{connection_id}")
+        return response.json()
+
+    def test_connection(self, connection_data: Dict) -> Dict:
+        """Test a database connection."""
+        response = self._make_request("POST", "/connections/test", json=connection_data)
+        return response.json()
+
+    def get_tables(self) -> List[Dict]:
+        """Get all tables from connections."""
+        response = self._make_request("GET", "/connections/tables")
+        return response.json()

datamaker/routes/custom_types.py

@@ -0,0 +1,100 @@
+from .base import BaseClient
+from typing import Optional, Dict, List
+
+
+class CustomDataTypesClient(BaseClient):
+    """Client for custom data type management operations."""
+
+    def get_custom_data_types(self, project_id: str) -> List[Dict]:
+        """Get all custom data types for a specific project."""
+        params = {"projectId": project_id}
+        response = self._make_request("GET", "/customDataTypes", params=params)
+        return response.json()
+
+    def create_custom_data_type(self, data_type_data: Dict) -> Dict:
+        """Create a new custom data type."""
+        response = self._make_request("POST", "/customDataTypes", json=data_type_data)
+        return response.json()
+
+    def update_custom_data_type(self, data_type_id: str, data_type_data: Dict) -> Dict:
+        """Update a custom data type."""
+        response = self._make_request(
+            "PUT", f"/customDataTypes/{data_type_id}", json=data_type_data
+        )
+        return response.json()
+
+    def delete_custom_data_type(self, data_type_id: str) -> Dict:
+        """Delete a custom data type."""
+        response = self._make_request("DELETE", f"/customDataTypes/{data_type_id}")
+        return response.json()
+
+
+class EndpointFoldersClient(BaseClient):
+    """Client for endpoint folder management operations."""
+
+    def get_endpoint_folders(self) -> List[Dict]:
+        """Get all endpoint folders."""
+        response = self._make_request("GET", "/endpointFolders")
+        return response.json()
+
+    def create_endpoint_folder(self, folder_data: Dict) -> Dict:
+        """Create a new endpoint folder."""
+        response = self._make_request("POST", "/endpointFolders", json=folder_data)
+        return response.json()
+
+    def update_endpoint_folder(self, folder_id: str, folder_data: Dict) -> Dict:
+        """Update an endpoint folder."""
+        response = self._make_request(
+            "PUT", f"/endpointFolders/{folder_id}", json=folder_data
+        )
+        return response.json()
+
+    def delete_endpoint_folder(self, folder_id: str) -> Dict:
+        """Delete an endpoint folder."""
+        response = self._make_request("DELETE", f"/endpointFolders/{folder_id}")
+        return response.json()
+
+
+class EndpointsClient(BaseClient):
+    """Client for endpoint management operations."""
+
+    def get_endpoints(self) -> List[Dict]:
+        """Get all endpoints."""
+        response = self._make_request("GET", "/endpoints")
+        return response.json()
+
+    def create_endpoint(self, endpoint_data: Dict) -> Dict:
+        """Create a new endpoint."""
+        response = self._make_request("POST", "/endpoints", json=endpoint_data)
+        return response.json()
+
+    def get_endpoint(self, endpoint_id: str) -> Dict:
+        """Get a specific endpoint by ID."""
+        response = self._make_request("GET", f"/endpoints/{endpoint_id}")
+        return response.json()
+
+    def update_endpoint(self, endpoint_id: str, endpoint_data: Dict) -> Dict:
+        """Update an endpoint."""
+        response = self._make_request(
+            "PUT", f"/endpoints/{endpoint_id}", json=endpoint_data
+        )
+        return response.json()
+
+    def delete_endpoint(self, endpoint_id: str) -> Dict:
+        """Delete an endpoint."""
+        response = self._make_request("DELETE", f"/endpoints/{endpoint_id}")
+        return response.json()
+
+    def resolve_endpoint_auth(self, endpoint_id: str) -> Dict:
+        """Resolve an endpoint's real, usable credentials.
+
+        Unlike get_endpoint(), whose auth fields are masked (`*******`), this
+        returns the decrypted Authorization header (Basic decrypted / OAuth2
+        token exchanged) plus, for Basic auth, the real username/password.
+
+        Returns a dict: {authType, authHeader, fetchCsrf, basic}.
+        """
+        response = self._make_request(
+            "POST", "/endpoints/auth-resolve", json={"endpointId": endpoint_id}
+        )
+        return response.json()

datamaker/routes/export_and_validation.py

@@ -0,0 +1,25 @@
+from .base import BaseClient
+from typing import Dict
+
+
+class ExportClient(BaseClient):
+    """Client for export operations."""
+
+    def export_to_rest(self, export_data: Dict) -> Dict:
+        """Export data to REST API."""
+        response = self._make_request("POST", "/export/rest", json=export_data)
+        return response.json()
+
+    def export_to_database(self, export_data: Dict) -> Dict:
+        """Export data to database."""
+        response = self._make_request("POST", "/export/db", json=export_data)
+        return response.json()
+
+
+class ValidationClient(BaseClient):
+    """Client for validation operations."""
+
+    def validate_api_key(self) -> Dict:
+        """Test API key authentication."""
+        response = self._make_request("GET", "/validate/apiKey")
+        return response.json()

datamaker/routes/folders_and_utils.py

@@ -0,0 +1,80 @@
+from .base import BaseClient
+from typing import Optional, Dict, List
+
+
+class TemplateFoldersClient(BaseClient):
+    """Client for template folder management operations."""
+
+    def get_template_folders(self) -> List[Dict]:
+        """Get all template folders."""
+        response = self._make_request("GET", "/templateFolders")
+        return response.json()
+
+    def create_template_folder(self, folder_data: Dict) -> Dict:
+        """Create a new template folder."""
+        response = self._make_request("POST", "/templateFolders", json=folder_data)
+        return response.json()
+
+    def update_template_folder(self, folder_id: str, folder_data: Dict) -> Dict:
+        """Update a template folder."""
+        response = self._make_request(
+            "PUT", f"/templateFolders/{folder_id}", json=folder_data
+        )
+        return response.json()
+
+    def delete_template_folder(self, folder_id: str) -> Dict:
+        """Delete a template folder."""
+        response = self._make_request("DELETE", f"/templateFolders/{folder_id}")
+        return response.json()
+
+
+class ShortcutsClient(BaseClient):
+    """Client for shortcuts management operations."""
+
+    def get_shortcuts(self) -> List[Dict]:
+        """Get all shortcuts."""
+        response = self._make_request("GET", "/shortcuts")
+        return response.json()
+
+    def create_shortcut(self, shortcut_data: Dict) -> Dict:
+        """Create a new shortcut."""
+        response = self._make_request("POST", "/shortcuts", json=shortcut_data)
+        return response.json()
+
+    def update_shortcut(self, shortcut_id: str, shortcut_data: Dict) -> Dict:
+        """Update a shortcut."""
+        response = self._make_request(
+            "PUT", f"/shortcuts/{shortcut_id}", json=shortcut_data
+        )
+        return response.json()
+
+    def delete_shortcut(self, shortcut_id: str) -> Dict:
+        """Delete a shortcut."""
+        response = self._make_request("DELETE", f"/shortcuts/{shortcut_id}")
+        return response.json()
+
+
+class FeedbackClient(BaseClient):
+    """Client for feedback management operations."""
+
+    def get_feedback(self) -> List[Dict]:
+        """Get all feedback."""
+        response = self._make_request("GET", "/feedback")
+        return response.json()
+
+    def submit_feedback(self, feedback_data: Dict) -> Dict:
+        """Submit new feedback."""
+        response = self._make_request("POST", "/feedback", json=feedback_data)
+        return response.json()
+
+    def update_feedback(self, feedback_id: str, feedback_data: Dict) -> Dict:
+        """Update feedback."""
+        response = self._make_request(
+            "PUT", f"/feedback/{feedback_id}", json=feedback_data
+        )
+        return response.json()
+
+    def delete_feedback(self, feedback_id: str) -> Dict:
+        """Delete feedback."""
+        response = self._make_request("DELETE", f"/feedback/{feedback_id}")
+        return response.json()

datamaker/routes/generation.py

@@ -0,0 +1,14 @@
+from .base import BaseClient
+
+
+class GenerationClient(BaseClient):
+    """Client for data generation operations."""
+
+    def generate(self, template):
+        """Generate data using a template."""
+        response = self._make_request(
+            "POST",
+            "/datamaker",
+            json=template.to_dict() if hasattr(template, "to_dict") else template,
+        )
+        return response.json()

datamaker/routes/projects.py

@@ -0,0 +1,35 @@
+from .base import BaseClient
+from typing import Optional, Dict, List
+
+
+class ProjectsClient(BaseClient):
+    """Client for project management operations."""
+
+    def get_projects(self) -> List[Dict]:
+        """Get all projects."""
+        response = self._make_request("GET", "/projects")
+        return response.json()
+
+    def create_project(self, project_data: Dict, team_id: str) -> Dict:
+        """Create a new project."""
+        # Ensure required teamId is present
+        project_data["teamId"] = team_id
+        response = self._make_request("POST", "/projects", json=project_data)
+        return response.json()
+
+    def get_project(self, project_id: str) -> Dict:
+        """Get a specific project by ID."""
+        response = self._make_request("GET", f"/projects/{project_id}")
+        return response.json()
+
+    def update_project(self, project_id: str, project_data: Dict) -> Dict:
+        """Update a project."""
+        response = self._make_request(
+            "PUT", f"/projects/{project_id}", json=project_data
+        )
+        return response.json()
+
+    def delete_project(self, project_id: str) -> Dict:
+        """Delete a project."""
+        response = self._make_request("DELETE", f"/projects/{project_id}")
+        return response.json()