Split client into separate files

Author: 1pxone

README.md

@@ -11,7 +11,7 @@ pip install rushdb
 ## Quick Start
 
 ```python
-from rushdb import RushDBClient
+from src.rushdb import RushDBClient
 
 # Initialize the client
 client = RushDBClient("http://localhost:8000", "your-api-key")

rushdb/__init__.py

@@ -0,0 +1,12 @@
+"""RushDB Client Package
+
+Exposes the RushDBClient class.
+"""
+
+from .client import RushDBClient
+from .common import RushDBError, RelationOptions, RelationDetachOptions
+from .record import Record
+from .transaction import Transaction
+from .property import Property
+
+__all__ = ['RushDBClient', 'RushDBError', 'Record', 'RelationOptions', 'RelationDetachOptions', 'Transaction', 'Property']

rushdb/client/__init__.py

@@ -0,0 +1,98 @@
+"""RushDB Client"""
+
+import json
+import urllib.request
+import urllib.parse
+import urllib.error
+from typing import Any, Dict, Optional
+
+from src.rushdb.common import RushDBError
+from src.rushdb.labels_api import LabelsAPI
+from src.rushdb.properties_api import PropertiesAPI
+from src.rushdb.records_api import RecordsAPI
+from src.rushdb.transactions_api import TransactionsAPI
+
+class RushDBClient:
+    """Main client for interacting with RushDB."""
+    DEFAULT_BASE_URL = "https://api.rushdb.com"
+
+    def __init__(self, api_key: str, base_url: Optional[str] = None):
+        """Initialize the RushDB client.
+
+        Args:
+            api_key: The API key for authentication
+            base_url: Optional base URL for the RushDB server (default: https://api.rushdb.com)
+        """
+        self.base_url = (base_url or self.DEFAULT_BASE_URL).rstrip('/')
+        self.api_key = api_key
+        self.records = RecordsAPI(self)
+        self.properties = PropertiesAPI(self)
+        self.labels = LabelsAPI(self)
+        self.transactions = TransactionsAPI(self)
+
+    def _make_request(self, method: str, path: str, data: Optional[Dict] = None, headers: Optional[Dict[str, str]] = None, params: Optional[Dict[str, Any]] = None) -> Any:
+        """Make an HTTP request to the RushDB server.
+
+        Args:
+            method: HTTP method (GET, POST, PUT, DELETE)
+            path: API endpoint path
+            data: Request body data
+            headers: Optional request headers
+            params: Optional URL query parameters
+
+        Returns:
+            The parsed JSON response
+        """
+        # Ensure path starts with /
+        if not path.startswith('/'):
+            path = '/' + path
+
+        # Clean and encode path components
+        path = path.strip()
+        path_parts = [urllib.parse.quote(part, safe='') for part in path.split('/') if part]
+        clean_path = '/' + '/'.join(path_parts)
+
+        # Build URL with query parameters
+        url = f"{self.base_url}{clean_path}"
+        if params:
+            query_string = urllib.parse.urlencode(params)
+            url = f"{url}?{query_string}"
+
+        # Prepare headers
+        request_headers = {
+            'token': self.api_key,
+            'Content-Type': 'application/json',
+            **(headers or {})
+        }
+
+        try:
+            # Prepare request body
+            body = None
+            if data is not None:
+                body = json.dumps(data).encode('utf-8')
+
+            # Create and send request
+            request = urllib.request.Request(
+                url,
+                data=body,
+                headers=request_headers,
+                method=method
+            )
+
+            with urllib.request.urlopen(request) as response:
+                return json.loads(response.read().decode('utf-8'))
+        except urllib.error.HTTPError as e:
+            error_body = json.loads(e.read().decode('utf-8'))
+            raise RushDBError(error_body.get('message', str(e)), error_body)
+        except urllib.error.URLError as e:
+            raise RushDBError(f"Connection error: {str(e)}")
+        except json.JSONDecodeError as e:
+            raise RushDBError(f"Invalid JSON response: {str(e)}")
+
+    def ping(self) -> bool:
+        """Check if the server is reachable."""
+        try:
+            self._make_request('GET', '/')
+            return True
+        except RushDBError:
+            return False

rushdb/client/client.py

@@ -0,0 +1,20 @@
+from typing import Dict, List, Optional, Union, TypedDict, Literal
+
+# Relation types
+RelationDirection = Literal['in', 'out']
+
+class RelationOptions(TypedDict, total=False):
+    """Options for creating relations."""
+    direction: Optional[RelationDirection]
+    type: Optional[str]
+
+class RelationDetachOptions(TypedDict, total=False):
+    """Options for detaching relations."""
+    direction: Optional[RelationDirection]
+    typeOrTypes: Optional[Union[str, List[str]]]
+
+class RushDBError(Exception):
+    """Custom exception for RushDB client errors."""
+    def __init__(self, message: str, details: Optional[Dict] = None):
+        super().__init__(message)
+        self.details = details or {}

src/__init__.py

@@ -0,0 +1,21 @@
+from typing import List
+
+from src.rushdb import RushDBClient
+
+
+class LabelsAPI:
+    """API for managing labels in RushDB."""
+    def __init__(self, client: 'RushDBClient'):
+        self.client = client
+
+    def list(self) -> List[str]:
+        """List all labels."""
+        return self.client._make_request('GET', '/api/v1/labels')
+
+    def create(self, label: str) -> None:
+        """Create a new label."""
+        return self.client._make_request('POST', '/api/v1/labels', {'name': label})
+
+    def delete(self, label: str) -> None:
+        """Delete a label."""
+        return self.client._make_request('DELETE', f'/api/v1/labels/{label}')

src/rushdb/__init__.py

@@ -0,0 +1,47 @@
+from typing import List, Dict, Any, Optional
+
+from src.rushdb import RushDBClient
+from src.rushdb.property import Property, PropertyValuesData
+from src.rushdb.transaction import Transaction
+
+
+class PropertiesAPI:
+    """API for managing properties in RushDB."""
+    def __init__(self, client: 'RushDBClient'):
+        self.client = client
+
+    def list(self, transaction: Optional[Transaction] = None) -> List[Property]:
+        """List all properties."""
+        headers = Transaction._build_transaction_header(transaction.id if transaction else None)
+
+        return self.client._make_request('GET', '/api/v1/properties', headers=headers)
+
+    def create(self, data: Dict[str, Any], transaction: Optional[Transaction] = None) -> Property:
+        """Create a new property."""
+        headers = Transaction._build_transaction_header(transaction.id if transaction else None)
+
+        return self.client._make_request('POST', '/api/v1/properties', data, headers)
+
+    def get(self, property_id: str, transaction: Optional[Transaction] = None) -> Property:
+        """Get a property by ID."""
+        headers = Transaction._build_transaction_header(transaction.id if transaction else None)
+
+        return self.client._make_request('GET', f'/api/v1/properties/{property_id}', headers=headers)
+
+    def update(self, property_id: str, data: Dict[str, Any], transaction: Optional[Transaction] = None) -> Property:
+        """Update a property."""
+        headers = Transaction._build_transaction_header(transaction.id if transaction else None)
+
+        return self.client._make_request('PUT', f'/api/v1/properties/{property_id}', data, headers)
+
+    def delete(self, property_id: str, transaction: Optional[Transaction] = None) -> None:
+        """Delete a property."""
+        headers = Transaction._build_transaction_header(transaction.id if transaction else None)
+
+        return self.client._make_request('DELETE', f'/api/v1/properties/{property_id}', headers=headers)
+
+    def get_values(self, property_id: str, transaction: Optional[Transaction] = None) -> PropertyValuesData:
+        """Get values data for a property."""
+        headers = Transaction._build_transaction_header(transaction.id if transaction else None)
+
+        return self.client._make_request('GET', f'/api/v1/properties/{property_id}/values', headers=headers)