from src.rushdb import RushDBClient

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']

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.

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.

# 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

from typing import Dict, List, Optional, Union, TypedDict, Literal

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 {}

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}')

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)