traverse-http 0.6.7__py3-none-any.whl

traverse_http/__init__.py

@@ -0,0 +1,59 @@
+from .client import TraverseHttpClient
+from .models import (
+    HealthResponse,
+    HealthDatabase,
+    LicenseInfo,
+    LicenseLimits,
+    UpdateInfo,
+    DatabaseInfo,
+    TvdbFileInfo,
+    UploadResult,
+    AliasInfo,
+    SchemaResponse,
+    SchemaProperty,
+    IndexInfo,
+    ConstraintInfo,
+    LabelDetail,
+    QueryResponse,
+    QueryStats,
+    ImportResult,
+    ImportError,
+    CsvImportResult,
+    CsvImportError,
+    CsvEdgeImportResult,
+    ColumnMapping,
+    EdgeEndpoint,
+    TaskInfo,
+    UserInfo,
+)
+from .exceptions import TraverseHttpException
+
+__all__ = [
+    "TraverseHttpClient",
+    "TraverseHttpException",
+    "HealthResponse",
+    "HealthDatabase",
+    "LicenseInfo",
+    "LicenseLimits",
+    "UpdateInfo",
+    "DatabaseInfo",
+    "TvdbFileInfo",
+    "UploadResult",
+    "AliasInfo",
+    "SchemaResponse",
+    "SchemaProperty",
+    "IndexInfo",
+    "ConstraintInfo",
+    "LabelDetail",
+    "QueryResponse",
+    "QueryStats",
+    "ImportResult",
+    "ImportError",
+    "CsvImportResult",
+    "CsvImportError",
+    "CsvEdgeImportResult",
+    "ColumnMapping",
+    "EdgeEndpoint",
+    "TaskInfo",
+    "UserInfo",
+]

traverse_http/client.py

@@ -0,0 +1,490 @@
+from __future__ import annotations
+
+import time
+from typing import Any, BinaryIO
+from urllib.parse import quote
+
+import requests
+
+from .exceptions import TraverseHttpException
+from .models import (
+    AliasInfo,
+    ColumnMapping,
+    ConstraintInfo,
+    CsvEdgeImportResult,
+    CsvImportError,
+    CsvImportResult,
+    DatabaseInfo,
+    EdgeEndpoint,
+    HealthDatabase,
+    HealthResponse,
+    ImportError,
+    ImportResult,
+    IndexInfo,
+    LabelDetail,
+    LicenseInfo,
+    LicenseLimits,
+    QueryResponse,
+    QueryStats,
+    SchemaProperty,
+    SchemaResponse,
+    TaskInfo,
+    TvdbFileInfo,
+    UpdateInfo,
+    UploadResult,
+    UserInfo,
+)
+
+
+class TraverseHttpClient:
+    """HTTP client for the Traverse server management API."""
+
+    def __init__(
+        self,
+        base_url: str,
+        *,
+        api_key: str | None = None,
+        timeout: float = 100.0,
+        transfer_timeout: float = 3600.0,
+        allow_untrusted_certificate: bool = False,
+    ):
+        self._base_url = base_url.rstrip("/") + "/"
+        self._timeout = timeout
+        self._transfer_timeout = transfer_timeout
+        self._session = requests.Session()
+        if api_key:
+            self._session.headers["Authorization"] = f"Bearer {api_key}"
+        if allow_untrusted_certificate:
+            self._session.verify = False
+
+    def close(self) -> None:
+        self._session.close()
+
+    def __enter__(self) -> TraverseHttpClient:
+        return self
+
+    def __exit__(self, *args: Any) -> None:
+        self.close()
+
+    # ── Health ──────────────────────────────────────────────────────────
+
+    def health(self) -> HealthResponse:
+        data = self._get("api/health")
+        return _parse_health(data)
+
+    def ready(self) -> bool:
+        try:
+            resp = self._session.get(
+                self._url("api/ready"), timeout=self._timeout
+            )
+            return 200 <= resp.status_code < 300
+        except Exception:
+            return False
+
+    # ── Databases ───────────────────────────────────────────────────────
+
+    def list_databases(self) -> list[DatabaseInfo]:
+        data = self._get("api/databases")
+        return [_parse_database_info(d) for d in data]
+
+    def create_database(self, name: str) -> None:
+        self._post("api/databases", {"name": name})
+
+    def drop_database(self, name: str) -> None:
+        self._poll_task(self._delete(f"api/databases/{_encode(name)}?async=true"))
+
+    def rename_database(self, old_name: str, new_name: str) -> None:
+        self._post(f"api/databases/{_encode(old_name)}/rename", {"name": new_name})
+
+    def unload_database(self, name: str) -> None:
+        self._poll_task(
+            self._post_raw(
+                f"api/databases/{_encode(name)}/unload?async=true",
+                timeout=self._transfer_timeout,
+            )
+        )
+
+    def load_database(self, name: str, file: str) -> None:
+        self._poll_task(
+            self._post_raw(
+                "api/databases/load?async=true",
+                json={"name": name, "file": file},
+                timeout=self._transfer_timeout,
+            )
+        )
+
+    # ── Files ───────────────────────────────────────────────────────────
+
+    def list_files(self) -> list[TvdbFileInfo]:
+        data = self._get("api/files")
+        return [TvdbFileInfo(**d) for d in data]
+
+    def upload_file(self, name: str, data: bytes | BinaryIO) -> UploadResult:
+        if hasattr(data, "read"):
+            data = data.read()
+        resp = self._session.put(
+            self._url(f"api/files/{_encode(name)}"),
+            data=data,
+            headers={"Content-Type": "application/octet-stream"},
+            timeout=self._transfer_timeout,
+        )
+        _ensure_success(resp)
+        return UploadResult(**resp.json())
+
+    def download_file(self, name: str) -> bytes:
+        resp = self._session.get(
+            self._url(f"api/files/{_encode(name)}"),
+            timeout=self._transfer_timeout,
+        )
+        _ensure_success(resp)
+        return resp.content
+
+    def delete_file(self, name: str) -> None:
+        self._delete(f"api/files/{_encode(name)}")
+
+    # ── Aliases ─────────────────────────────────────────────────────────
+
+    def list_aliases(self) -> list[AliasInfo]:
+        data = self._get("api/aliases")
+        return [AliasInfo(**d) for d in data]
+
+    def create_alias(self, alias: str, database: str) -> None:
+        self._post("api/aliases", {"alias": alias, "database": database})
+
+    def alter_alias(self, alias: str, database: str) -> None:
+        self._put(f"api/aliases/{_encode(alias)}", {"database": database})
+
+    def drop_alias(self, alias: str) -> None:
+        self._delete(f"api/aliases/{_encode(alias)}")
+
+    # ── Schema ──────────────────────────────────────────────────────────
+
+    def get_schema(self, database: str | None = None) -> SchemaResponse:
+        path = "api/schema"
+        if database is not None:
+            path += f"?database={_encode(database)}"
+        data = self._get(path)
+        return _parse_schema(data)
+
+    # ── Query ───────────────────────────────────────────────────────────
+
+    def query(
+        self,
+        cypher: str,
+        parameters: dict[str, Any] | None = None,
+        database: str | None = None,
+    ) -> QueryResponse:
+        body: dict[str, Any] = {"query": cypher}
+        if parameters is not None:
+            body["parameters"] = parameters
+        if database is not None:
+            body["database"] = database
+        data = self._post("api/query", body)
+        return _parse_query_response(data)
+
+    # ── Import ──────────────────────────────────────────────────────────
+
+    def import_cypher(
+        self, cypher: str, database: str | None = None
+    ) -> ImportResult:
+        body: dict[str, str] = {"cypher": cypher}
+        if database is not None:
+            body["database"] = database
+        data = self._post("api/import", body)
+        return _parse_import_result(data)
+
+    def import_csv(
+        self,
+        csv: str,
+        label: str,
+        columns: list[ColumnMapping],
+        database: str | None = None,
+        delimiter: str | None = None,
+        skip_header: bool | None = None,
+    ) -> CsvImportResult:
+        body: dict[str, Any] = {
+            "csv": csv,
+            "label": label,
+            "columns": [c.to_dict() for c in columns],
+        }
+        if database is not None:
+            body["database"] = database
+        if delimiter is not None:
+            body["delimiter"] = delimiter
+        if skip_header is not None:
+            body["skip_header"] = skip_header
+        data = self._post("api/import/csv", body)
+        return _parse_csv_import_result(data)
+
+    def import_csv_edges(
+        self,
+        csv: str,
+        edge_type: str,
+        source: EdgeEndpoint,
+        target: EdgeEndpoint,
+        columns: list[ColumnMapping] | None = None,
+        database: str | None = None,
+        delimiter: str | None = None,
+        skip_header: bool | None = None,
+    ) -> CsvEdgeImportResult:
+        body: dict[str, Any] = {
+            "csv": csv,
+            "edge_type": edge_type,
+            "source": source.to_dict(),
+            "target": target.to_dict(),
+        }
+        if columns is not None:
+            body["columns"] = [c.to_dict() for c in columns]
+        if database is not None:
+            body["database"] = database
+        if delimiter is not None:
+            body["delimiter"] = delimiter
+        if skip_header is not None:
+            body["skip_header"] = skip_header
+        data = self._post("api/import/csv/edges", body)
+        return _parse_csv_edge_import_result(data)
+
+    # ── Users ───────────────────────────────────────────────────────────
+
+    def list_users(self) -> list[UserInfo]:
+        data = self._get("api/users")
+        return [UserInfo(**d) for d in data]
+
+    def create_user(self, username: str, password: str, role: str) -> None:
+        self._post(
+            "api/users",
+            {"username": username, "password": password, "role": role},
+        )
+
+    def update_user(
+        self,
+        username: str,
+        password: str | None = None,
+        role: str | None = None,
+    ) -> None:
+        body: dict[str, str] = {}
+        if password is not None:
+            body["password"] = password
+        if role is not None:
+            body["role"] = role
+        self._put(f"api/users/{_encode(username)}", body)
+
+    def delete_user(self, username: str) -> None:
+        self._delete(f"api/users/{_encode(username)}")
+
+    # ── Server operations ───────────────────────────────────────────────
+
+    def save(self) -> None:
+        self._poll_task(
+            self._post_raw("api/save?async=true", timeout=self._transfer_timeout)
+        )
+
+    # ── Tasks ───────────────────────────────────────────────────────────
+
+    def get_task(self, task_id: str) -> TaskInfo:
+        data = self._get(f"api/tasks/{_encode(task_id)}")
+        return _parse_task_info(data)
+
+    # ── Internal HTTP helpers ───────────────────────────────────────────
+
+    def _url(self, path: str) -> str:
+        return self._base_url + path
+
+    def _get(self, path: str) -> Any:
+        resp = self._session.get(self._url(path), timeout=self._timeout)
+        _ensure_success(resp)
+        return resp.json()
+
+    def _post(self, path: str, body: Any = None) -> Any:
+        resp = self._session.post(
+            self._url(path), json=body, timeout=self._timeout
+        )
+        _ensure_success(resp)
+        text = resp.text
+        if text:
+            return resp.json()
+        return None
+
+    def _post_raw(
+        self,
+        path: str,
+        json: Any = None,
+        timeout: float | None = None,
+    ) -> str:
+        resp = self._session.post(
+            self._url(path), json=json, timeout=timeout or self._timeout
+        )
+        _ensure_success(resp)
+        return resp.text
+
+    def _put(self, path: str, body: Any) -> None:
+        resp = self._session.put(
+            self._url(path), json=body, timeout=self._timeout
+        )
+        _ensure_success(resp)
+
+    def _delete(self, path: str) -> str:
+        resp = self._session.delete(self._url(path), timeout=self._timeout)
+        _ensure_success(resp)
+        return resp.text
+
+    def _poll_task(self, response_body: str) -> None:
+        if not response_body or not response_body.strip():
+            return
+        import json as _json
+
+        try:
+            data = _json.loads(response_body)
+        except ValueError:
+            return
+        task_id = data.get("taskId")
+        if not task_id:
+            return
+        delay = 0.25
+        while True:
+            time.sleep(delay)
+            task = self.get_task(task_id)
+            if task.status == "completed":
+                return
+            if task.status == "failed":
+                raise TraverseHttpException(task.error or "task failed")
+            delay = min(delay * 2, 2.0)
+
+
+# ── Helpers ─────────────────────────────────────────────────────────
+
+
+def _encode(s: str) -> str:
+    return quote(s, safe="")
+
+
+def _ensure_success(resp: requests.Response) -> None:
+    if 200 <= resp.status_code < 300:
+        return
+    error_message = None
+    try:
+        data = resp.json()
+        error_message = data.get("error")
+    except Exception:
+        pass
+    raise TraverseHttpException(
+        error_message or f"HTTP {resp.status_code}",
+        status_code=resp.status_code,
+    )
+
+
+# ── Model parsers ───────────────────────────────────────────────────
+
+
+def _parse_health(d: dict) -> HealthResponse:
+    license_data = d.get("license")
+    license_info = None
+    if license_data:
+        limits_data = license_data.get("limits")
+        limits = LicenseLimits(**limits_data) if limits_data else None
+        license_info = LicenseInfo(
+            status=license_data.get("status", ""),
+            plan=license_data.get("plan"),
+            trial_days_remaining=license_data.get("trial_days_remaining"),
+            subscription_expires_at=license_data.get("subscription_expires_at"),
+            limits=limits,
+        )
+    update_data = d.get("update")
+    update_info = UpdateInfo(**update_data) if update_data else None
+    return HealthResponse(
+        status=d.get("status", ""),
+        version=d.get("version", ""),
+        uptime_secs=d.get("uptime_secs", 0),
+        memory_bytes=d.get("memory_bytes", 0),
+        databases=[HealthDatabase(**db) for db in d.get("databases", [])],
+        allow_drop_database=d.get("allow_drop_database", False),
+        auth_required=d.get("auth_required", False),
+        license=license_info,
+        update=update_info,
+    )
+
+
+def _parse_database_info(d: dict) -> DatabaseInfo:
+    return DatabaseInfo(
+        name=d.get("name", ""),
+        default=d.get("default", False),
+        read_only=d.get("readOnly", False),
+        aliases=d.get("aliases", []),
+    )
+
+
+def _parse_schema(d: dict) -> SchemaResponse:
+    return SchemaResponse(
+        labels=d.get("labels", []),
+        relationship_types=d.get("relationship_types", []),
+        property_keys=[SchemaProperty(**p) for p in d.get("property_keys", [])],
+        indexes=[IndexInfo(**i) for i in d.get("indexes", [])],
+        constraints=[ConstraintInfo(**c) for c in d.get("constraints", [])],
+        labels_detail=[_parse_label_detail(ld) for ld in d.get("labels_detail", [])],
+        relationship_types_detail=[
+            _parse_label_detail(ld) for ld in d.get("relationship_types_detail", [])
+        ],
+    )
+
+
+def _parse_label_detail(d: dict) -> LabelDetail:
+    return LabelDetail(
+        name=d.get("name", ""),
+        properties=[SchemaProperty(**p) for p in d.get("properties", [])],
+    )
+
+
+def _parse_query_response(d: dict) -> QueryResponse:
+    return QueryResponse(
+        columns=d.get("columns", []),
+        rows=d.get("rows", []),
+        total_rows=d.get("total_rows", 0),
+        truncated=d.get("truncated", False),
+        query_type=d.get("query_type", ""),
+        stats=QueryStats(**d["stats"]) if "stats" in d else QueryStats(),
+        time_ms=d.get("time_ms", 0.0),
+        parsing_time_ms=d.get("parsing_time_ms", 0.0),
+        planning_time_ms=d.get("planning_time_ms", 0.0),
+        execution_time_ms=d.get("execution_time_ms", 0.0),
+    )
+
+
+def _parse_import_result(d: dict) -> ImportResult:
+    return ImportResult(
+        total_statements=d.get("total_statements", 0),
+        executed=d.get("executed", 0),
+        errors=[ImportError(**e) for e in d.get("errors", [])],
+        stats=QueryStats(**d["stats"]) if "stats" in d else QueryStats(),
+        time_ms=d.get("time_ms", 0.0),
+    )
+
+
+def _parse_csv_import_result(d: dict) -> CsvImportResult:
+    return CsvImportResult(
+        nodes_created=d.get("nodes_created", 0),
+        properties_set=d.get("properties_set", 0),
+        labels_added=d.get("labels_added", 0),
+        errors=[CsvImportError(**e) for e in d.get("errors", [])],
+        time_ms=d.get("time_ms", 0.0),
+    )
+
+
+def _parse_csv_edge_import_result(d: dict) -> CsvEdgeImportResult:
+    return CsvEdgeImportResult(
+        edges_created=d.get("edges_created", 0),
+        properties_set=d.get("properties_set", 0),
+        errors=[CsvImportError(**e) for e in d.get("errors", [])],
+        time_ms=d.get("time_ms", 0.0),
+    )
+
+
+def _parse_task_info(d: dict) -> TaskInfo:
+    return TaskInfo(
+        id=d.get("id", ""),
+        operation=d.get("operation", ""),
+        status=d.get("status", ""),
+        result=d.get("result"),
+        error=d.get("error"),
+        created_at=d.get("createdAt", ""),
+        finished_at=d.get("finishedAt"),
+    )

traverse_http/exceptions.py

@@ -0,0 +1,4 @@
+class TraverseHttpException(Exception):
+    def __init__(self, message: str, status_code: int | None = None):
+        super().__init__(message)
+        self.status_code = status_code

traverse_http/models.py

@@ -0,0 +1,245 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+
+# ── Health ──────────────────────────────────────────────────────────
+
+@dataclass
+class LicenseLimits:
+    max_databases: int | None = None
+    max_nodes_per_db: int | None = None
+    max_edges_per_db: int | None = None
+    max_connections: int | None = None
+    user_management: bool = False
+    ai_chat: bool = False
+
+
+@dataclass
+class LicenseInfo:
+    status: str = ""
+    plan: str | None = None
+    trial_days_remaining: int | None = None
+    subscription_expires_at: str | None = None
+    limits: LicenseLimits | None = None
+
+
+@dataclass
+class UpdateInfo:
+    latest_version: str | None = None
+    release_notes: str | None = None
+    published_at: str | None = None
+    download_available: bool = False
+
+
+@dataclass
+class HealthDatabase:
+    name: str = ""
+    default: bool = False
+    nodes: int = 0
+    edges: int = 0
+    memory_bytes: int = 0
+
+
+@dataclass
+class HealthResponse:
+    status: str = ""
+    version: str = ""
+    uptime_secs: int = 0
+    memory_bytes: int = 0
+    databases: list[HealthDatabase] = field(default_factory=list)
+    allow_drop_database: bool = False
+    auth_required: bool = False
+    license: LicenseInfo | None = None
+    update: UpdateInfo | None = None
+
+
+# ── Databases ───────────────────────────────────────────────────────
+
+@dataclass
+class DatabaseInfo:
+    name: str = ""
+    default: bool = False
+    read_only: bool = False
+    aliases: list[str] = field(default_factory=list)
+
+
+# ── Files ───────────────────────────────────────────────────────────
+
+@dataclass
+class TvdbFileInfo:
+    name: str = ""
+    file: str = ""
+    bytes: int = 0
+    loaded: bool = False
+
+
+@dataclass
+class UploadResult:
+    ok: bool = False
+    name: str = ""
+    file: str = ""
+    bytes: int = 0
+
+
+# ── Aliases ─────────────────────────────────────────────────────────
+
+@dataclass
+class AliasInfo:
+    alias: str = ""
+    database: str = ""
+
+
+# ── Schema ──────────────────────────────────────────────────────────
+
+@dataclass
+class SchemaProperty:
+    name: str = ""
+    type: str = ""
+
+
+@dataclass
+class IndexInfo:
+    name: str = ""
+    label: str = ""
+    property: str = ""
+    entries: int = 0
+
+
+@dataclass
+class ConstraintInfo:
+    name: str = ""
+    type: str = ""
+    label: str = ""
+    property: str = ""
+
+
+@dataclass
+class LabelDetail:
+    name: str = ""
+    properties: list[SchemaProperty] = field(default_factory=list)
+
+
+@dataclass
+class SchemaResponse:
+    labels: list[str] = field(default_factory=list)
+    relationship_types: list[str] = field(default_factory=list)
+    property_keys: list[SchemaProperty] = field(default_factory=list)
+    indexes: list[IndexInfo] = field(default_factory=list)
+    constraints: list[ConstraintInfo] = field(default_factory=list)
+    labels_detail: list[LabelDetail] = field(default_factory=list)
+    relationship_types_detail: list[LabelDetail] = field(default_factory=list)
+
+
+# ── Query ───────────────────────────────────────────────────────────
+
+@dataclass
+class QueryStats:
+    nodes_created: int = 0
+    nodes_deleted: int = 0
+    relationships_created: int = 0
+    relationships_deleted: int = 0
+    properties_set: int = 0
+    labels_added: int = 0
+    labels_removed: int = 0
+
+
+@dataclass
+class QueryResponse:
+    columns: list[str] = field(default_factory=list)
+    rows: list[list[Any]] = field(default_factory=list)
+    total_rows: int = 0
+    truncated: bool = False
+    query_type: str = ""
+    stats: QueryStats = field(default_factory=QueryStats)
+    time_ms: float = 0.0
+    parsing_time_ms: float = 0.0
+    planning_time_ms: float = 0.0
+    execution_time_ms: float = 0.0
+
+
+# ── Import ──────────────────────────────────────────────────────────
+
+@dataclass
+class ImportError:
+    statement: str = ""
+    error: str = ""
+
+
+@dataclass
+class ImportResult:
+    total_statements: int = 0
+    executed: int = 0
+    errors: list[ImportError] = field(default_factory=list)
+    stats: QueryStats = field(default_factory=QueryStats)
+    time_ms: float = 0.0
+
+
+@dataclass
+class CsvImportError:
+    row: int = 0
+    error: str = ""
+
+
+@dataclass
+class CsvImportResult:
+    nodes_created: int = 0
+    properties_set: int = 0
+    labels_added: int = 0
+    errors: list[CsvImportError] = field(default_factory=list)
+    time_ms: float = 0.0
+
+
+@dataclass
+class CsvEdgeImportResult:
+    edges_created: int = 0
+    properties_set: int = 0
+    errors: list[CsvImportError] = field(default_factory=list)
+    time_ms: float = 0.0
+
+
+@dataclass
+class ColumnMapping:
+    name: str
+    property: str | None = None
+    type: str | None = None
+
+    def to_dict(self) -> dict[str, str]:
+        d: dict[str, str] = {"name": self.name}
+        if self.property is not None:
+            d["property"] = self.property
+        if self.type is not None:
+            d["type"] = self.type
+        return d
+
+
+@dataclass
+class EdgeEndpoint:
+    label: str
+    column: str
+    property: str
+
+    def to_dict(self) -> dict[str, str]:
+        return {"label": self.label, "column": self.column, "property": self.property}
+
+
+# ── Tasks ───────────────────────────────────────────────────────────
+
+@dataclass
+class TaskInfo:
+    id: str = ""
+    operation: str = ""
+    status: str = ""
+    result: Any = None
+    error: str | None = None
+    created_at: str = ""
+    finished_at: str | None = None
+
+
+# ── Users ───────────────────────────────────────────────────────────
+
+@dataclass
+class UserInfo:
+    username: str = ""
+    role: str = ""

traverse_http-0.6.7.dist-info/METADATA

@@ -0,0 +1,93 @@
+Metadata-Version: 2.4
+Name: traverse-http
+Version: 0.6.7
+Summary: Official Python HTTP client for Traverse — Truespar's in-memory graph database. Cypher queries, schema introspection, CSV import, database management.
+Project-URL: Homepage, https://truespar.com/traverse/docs
+Project-URL: Documentation, https://truespar.com/traverse/docs
+Author: Truespar
+License-Expression: MIT
+License-File: LICENSE
+Keywords: cypher,database,graph,graph-database,traverse,truespar
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Database :: Front-Ends
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: requests>=2.28
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# traverse-http
+
+Official Python HTTP client for [Traverse](https://truespar.com/traverse/docs) — Truespar's in-memory graph database.
+
+- Execute Cypher queries with parameterized values
+- Database management (create, drop, rename, load, unload)
+- Schema introspection (labels, types, properties, indexes, constraints)
+- CSV and Cypher import with async task polling
+- File management (upload, download, delete `.tvdb` files)
+- User and alias management
+- Typed response models with dataclass return types
+- Python 3.10+, MIT licensed
+
+## Installation
+
+```bash
+pip install traverse-http
+```
+
+## Quick Start
+
+```python
+from traverse_http import TraverseHttpClient
+
+client = TraverseHttpClient("http://localhost:7691", api_key="tvs_your_key")
+
+# Execute a query
+result = client.query("MATCH (n:Person) RETURN n.name, n.age LIMIT 10")
+for row in result.rows:
+    print(row)
+
+# List databases
+databases = client.list_databases()
+for db in databases:
+    print(f"{db.name}: {db.node_count} nodes, {db.edge_count} edges")
+
+# Get schema
+schema = client.schema()
+print(schema.labels)
+```
+
+## Database Management
+
+```python
+client.create_database("mydb")
+client.rename_database("mydb", "production")
+client.drop_database("production")  # requires --allow-drop-database on server
+```
+
+## CSV Import
+
+```python
+result = client.import_csv(
+    file_path="people.csv",
+    label="Person",
+    database="mydb",
+)
+print(f"Imported {result.nodes_created} nodes")
+```
+
+## Documentation
+
+- [Traverse documentation](https://truespar.com/traverse/docs)
+- [Python SDK reference](https://truespar.com/traverse/docs/v1/python-sdk)
+
+## License
+
+MIT — see [LICENSE](LICENSE).

traverse_http-0.6.7.dist-info/RECORD

@@ -0,0 +1,8 @@
+traverse_http/__init__.py,sha256=0bSK9OK9QK22lIfm8ln2SGyeYzRD27MYSaC7Vti42DM,1196
+traverse_http/client.py,sha256=SAqv6DrMbTYNvGBpEMLxR6_F5M3KBVIxGo2n8Az5yY0,17567
+traverse_http/exceptions.py,sha256=LRx2nvtePTgXQzSm6G7NbdAh1-I5sCloGtA64V_ASRw,187
+traverse_http/models.py,sha256=-trH4erXtzX9tC0ANFvlAxnAoPZ7rjebq63asXteyWs,6825
+traverse_http-0.6.7.dist-info/METADATA,sha256=Z044XaUP5AQcAhM-DYHLBUsLqb0IIapzh3dysKcRp6c,2695
+traverse_http-0.6.7.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+traverse_http-0.6.7.dist-info/licenses/LICENSE,sha256=xiUjVMIouoNYZsUw2NUed3Dv0_SQ3-C1DpgVwBxRo-s,10019
+traverse_http-0.6.7.dist-info/RECORD,,

traverse_http-0.6.7.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

traverse_http-0.6.7.dist-info/licenses/LICENSE

@@ -0,0 +1,196 @@
+TRAVERSE END-USER LICENSE AGREEMENT (EULA)
+
+Copyright (c) 2025-2026 Truespar. All rights reserved.
+
+IMPORTANT — READ CAREFULLY: This End-User License Agreement ("Agreement") is a
+legal agreement between you (either an individual or a single entity, "Licensee")
+and Truespar ("Licensor") for the Traverse software,
+including all source code, binaries, documentation, and associated files
+(collectively, the "Software").
+
+By downloading, installing, copying, or otherwise using the Software, you agree
+to be bound by the terms of this Agreement. If you do not agree, do not use the
+Software.
+
+1. GRANT OF LICENSE
+
+   Subject to the terms of this Agreement, Licensor grants Licensee a limited,
+   non-exclusive, non-transferable, revocable license to:
+
+   (a) Use the Software for internal purposes, including evaluation, development,
+       and production deployment.
+
+   (b) Create applications and services that interface with the Software through
+       its published APIs (Bolt protocol, FFI bindings, gRPC, and CLI).
+
+2. RESTRICTIONS
+
+   Licensee shall NOT:
+
+   (a) Modify, adapt, alter, translate, or create derivative works of the
+       Software or any part thereof.
+
+   (b) Reverse engineer, disassemble, decompile, or otherwise attempt to derive
+       the source code, underlying ideas, algorithms, data structures, or
+       non-public APIs of the Software. To the extent that applicable law
+       (including EU Directive 2009/24/EC) grants a non-waivable right to
+       decompile for interoperability purposes, Licensee must first provide
+       thirty (30) days' prior written notice to Licensor and may exercise such
+       right only to the minimum extent necessary to achieve interoperability
+       with independently created software.
+
+   (c) Redistribute, sublicense, lease, rent, loan, sell, or otherwise transfer
+       the Software or any rights therein to any third party.
+
+   (d) Remove, alter, or obscure any proprietary notices, labels, or marks on
+       the Software.
+
+   (e) Use the Software to operate a service bureau, outsourcing service, or
+       managed-service offering for the benefit of third parties, or to provide
+       database-as-a-service offerings based on the Software, without a separate
+       commercial agreement with the Licensor.
+
+   (f) Use the Software to build a product or service that competes with the
+       Software.
+
+   (g) Publish benchmark results, performance comparisons, or similar evaluations
+       of the Software without prior written consent of the Licensor.
+
+3. INTELLECTUAL PROPERTY
+
+   The Software is the intellectual property of the Licensor and is protected by
+   copyright law and international treaties. Licensor retains all right, title,
+   and interest in and to the Software, including all intellectual property rights
+   therein. This Agreement does not convey any ownership interest in the Software.
+
+4. FEEDBACK
+
+   If Licensee provides suggestions, ideas, enhancement requests, or other
+   feedback regarding the Software ("Feedback"), Licensor may freely use,
+   incorporate, modify, license, and distribute such Feedback without restriction,
+   attribution, or compensation to Licensee. Licensee hereby assigns to Licensor
+   all right, title, and interest in and to any Feedback.
+
+5. CONFIDENTIALITY
+
+   (a) "Confidential Information" means the source code, object code, algorithms,
+       data structures, architecture, internal APIs, performance characteristics,
+       and any other non-public technical or business information of the Licensor
+       disclosed to or accessed by Licensee, whether in written, electronic, or
+       other form.
+
+   (b) Licensee shall hold all Confidential Information in strict confidence,
+       using at least the same degree of care it uses to protect its own
+       confidential information, but no less than reasonable care.
+
+   (c) Licensee shall not disclose Confidential Information to any third party
+       without the prior written consent of Licensor, except to Licensee's
+       employees or contractors who have a need to know and are bound by
+       confidentiality obligations at least as protective as those herein.
+
+   (d) The obligations in this section do not apply to information that:
+       (i) is or becomes publicly available through no fault of Licensee;
+       (ii) was rightfully known to Licensee prior to disclosure by Licensor;
+       (iii) is independently developed by Licensee without use of or reference
+       to the Confidential Information; or (iv) is required to be disclosed by
+       law, provided Licensee gives Licensor prompt written notice and
+       cooperates to limit the scope of disclosure.
+
+   (e) These confidentiality obligations survive termination of this Agreement
+       for a period of five (5) years, or indefinitely for trade secrets for as
+       long as they remain trade secrets under applicable law.
+
+6. THIRD-PARTY COMPONENTS
+
+   The Software incorporates open-source components licensed under permissive
+   licenses (MIT, Apache-2.0, BSD, and similar). These components retain their
+   original licenses. A list of third-party components and their licenses is
+   provided in the THIRD-PARTY-NOTICES file included with the Software.
+
+   Nothing in this Agreement restricts, limits, or otherwise affects any rights
+   Licensee may have under the licenses of such third-party components.
+
+7. NO WARRANTY
+
+   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+   FITNESS FOR A PARTICULAR PURPOSE, AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+   LICENSOR BE LIABLE FOR ANY CLAIM, DAMAGES, OR OTHER LIABILITY, WHETHER IN AN
+   ACTION OF CONTRACT, TORT, OR OTHERWISE, ARISING FROM, OUT OF, OR IN
+   CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+8. LIMITATION OF LIABILITY
+
+   (a) IN NO EVENT SHALL LICENSOR'S TOTAL AGGREGATE LIABILITY TO LICENSEE FOR
+       ALL CLAIMS ARISING UNDER OR IN CONNECTION WITH THIS AGREEMENT EXCEED THE
+       GREATER OF: (I) THE TOTAL AMOUNT OF FEES ACTUALLY PAID BY LICENSEE TO
+       LICENSOR FOR THE SOFTWARE DURING THE TWELVE (12) MONTHS IMMEDIATELY
+       PRECEDING THE EVENT GIVING RISE TO THE CLAIM; OR (II) FIFTY US DOLLARS
+       (USD $50.00).
+
+   (b) IN NO EVENT SHALL LICENSOR BE LIABLE FOR ANY INDIRECT, INCIDENTAL,
+       SPECIAL, CONSEQUENTIAL, OR PUNITIVE DAMAGES, INCLUDING BUT NOT LIMITED TO
+       LOSS OF PROFITS, DATA, BUSINESS, OR GOODWILL, REGARDLESS OF THE CAUSE OF
+       ACTION OR THE THEORY OF LIABILITY, EVEN IF LICENSOR HAS BEEN ADVISED OF
+       THE POSSIBILITY OF SUCH DAMAGES.
+
+   (c) THE LIMITATIONS IN SUBSECTIONS (a) AND (b) ABOVE SHALL NOT APPLY TO
+       LIABILITY ARISING FROM: (I) FRAUD OR FRAUDULENT MISREPRESENTATION;
+       (II) GROSS NEGLIGENCE OR WILLFUL MISCONDUCT; (III) LICENSEE'S BREACH OF
+       SECTIONS 2 (RESTRICTIONS) OR 5 (CONFIDENTIALITY); OR (IV) EITHER PARTY'S
+       INDEMNIFICATION OBLIGATIONS UNDER SECTION 9.
+
+9. INDEMNIFICATION
+
+   (a) Licensee shall defend, indemnify, and hold harmless Licensor and its
+       officers, directors, employees, and agents from and against any and all
+       third-party claims, damages, losses, liabilities, costs, and expenses
+       (including reasonable attorneys' fees) arising out of or related to:
+       (i) Licensee's breach of this Agreement, including but not limited to the
+       restrictions in Section 2 and the confidentiality obligations in
+       Section 5; (ii) Licensee's use of the Software in violation of applicable
+       law; or (iii) Licensee's gross negligence or willful misconduct.
+
+   (b) Licensor shall promptly notify Licensee of any such claim and provide
+       reasonable cooperation at Licensee's expense. Licensee shall have sole
+       control of the defense and settlement, provided that any settlement
+       requiring Licensor to admit liability or pay money shall require
+       Licensor's prior written consent.
+
+10. TERMINATION
+
+   (a) This Agreement is effective until terminated.
+
+   (b) Licensor may terminate this Agreement immediately upon written notice if
+       Licensee breaches Section 2 (Restrictions), Section 5 (Confidentiality),
+       or Section 9 (Indemnification).
+
+   (c) For any other material breach, the non-breaching party may terminate this
+       Agreement if the breaching party fails to cure such breach within thirty
+       (30) days of receiving written notice thereof.
+
+   (d) Upon termination, Licensee must immediately cease all use of the Software
+       and destroy all copies (including backups) in its possession or control
+       within five (5) business days. Upon Licensor's request, Licensee shall
+       certify such destruction in writing.
+
+   (e) Sections 2, 3, 4, 5, 7, 8, 9, 11, and 12 survive termination of this
+       Agreement.
+
+11. GOVERNING LAW
+
+   This Agreement shall be governed by and construed in accordance with the laws
+   of the State of Delaware, United States, without regard to its conflict-of-law
+   provisions. The United Nations Convention on Contracts for the International
+   Sale of Goods is expressly excluded. Any disputes arising under this Agreement
+   shall be resolved exclusively in the state or federal courts located in the
+   State of Delaware. Notwithstanding the foregoing, Licensor may seek injunctive
+   or other equitable relief in any court of competent jurisdiction to protect its
+   intellectual property rights or Confidential Information.
+
+12. ENTIRE AGREEMENT
+
+   This Agreement constitutes the entire agreement between the parties with
+   respect to the Software and supersedes all prior negotiations, representations,
+   or agreements relating thereto. No modification of this Agreement shall be
+   binding unless in writing and signed by both parties.