robosystems-client 0.2.5__tar.gz → 0.2.7__tar.gz

{robosystems_client-0.2.5 → robosystems_client-0.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: robosystems-client
-Version: 0.2.5
+Version: 0.2.7
 Summary: Python Client for RoboSystems financial graph database API
 Author: RFS LLC
 License: MIT

robosystems_client-0.2.7/bin/generate-sdk

@@ -0,0 +1,159 @@
+#!/usr/bin/env python3
+"""
+Generate Python SDK from OpenAPI specification with post-generation patches.
+
+This script handles the complete SDK generation workflow:
+1. Generate SDK using openapi-python-client
+2. Copy generated files to robosystems_client/
+3. Apply post-generation patches (NDJSON handling, etc.)
+4. Format and lint the generated code
+"""
+
+import sys
+import subprocess
+import shutil
+from pathlib import Path
+
+
+def run_command(cmd: str, description: str) -> bool:
+  """Run a shell command and return success status."""
+  print(f"📦 {description}...")
+  result = subprocess.run(cmd, shell=True, cwd=Path(__file__).parent.parent)
+  return result.returncode == 0
+
+
+def patch_ndjson_handling() -> bool:
+  """Add NDJSON handling to execute_cypher_query._parse_response."""
+
+  file_path = (
+    Path(__file__).parent.parent
+    / "robosystems_client"
+    / "api"
+    / "query"
+    / "execute_cypher_query.py"
+  )
+
+  if not file_path.exists():
+    print(f"❌ File not found: {file_path}")
+    return False
+
+  # Read the current file content
+  content = file_path.read_text()
+
+  # Check if patch is already applied
+  if "application/x-ndjson" in content:
+    print("✅ NDJSON patch already applied")
+    return True
+
+  # Define the patch to insert (note: using 4-space indentation to match generated code)
+  ndjson_check = """        content_type = response.headers.get("content-type", "")
+        if (
+            "application/x-ndjson" in content_type
+            or response.headers.get("x-stream-format") == "ndjson"
+        ):
+            return None
+"""
+
+  # Find the location to insert the patch (raw generated code uses 4 spaces)
+  search_pattern = "    if response.status_code == 200:\n        response_200 = ExecuteCypherQueryResponse200.from_dict(response.json())\n\n        return response_200"
+
+  if search_pattern not in content:
+    print(f"❌ Could not find expected pattern in {file_path}")
+    print("The generated code structure may have changed.")
+    return False
+
+  # Replace the pattern with the patched version
+  replacement = f"    if response.status_code == 200:\n{ndjson_check}        response_200 = ExecuteCypherQueryResponse200.from_dict(response.json())\n\n        return response_200"
+  patched_content = content.replace(search_pattern, replacement)
+
+  # Write the patched content back
+  _ = file_path.write_text(patched_content)
+
+  print(f"✅ Applied NDJSON patch to {file_path.name}")
+  return True
+
+
+def main():
+  """Main SDK generation workflow."""
+
+  # Get OpenAPI URL from command line or use default
+  url = sys.argv[1] if len(sys.argv) > 1 else "http://localhost:8000/openapi.json"
+
+  print(f"🚀 Generating Python SDK from {url}...")
+  print()
+
+  # Step 1: Generate SDK
+  if not run_command("rm -rf generated", "Cleaning previous generation"):
+    return 1
+
+  if not run_command(
+    f"uv run openapi-python-client generate --url {url} --output-path generated --config robosystems_client/sdk-config.yaml",
+    f"Generating SDK from {url}",
+  ):
+    return 1
+
+  # Step 2: Copy generated files
+  print("📦 Copying generated code to robosystems_client/...")
+
+  base_path = Path(__file__).parent.parent
+  generated_path = base_path / "generated" / "robo_systems_api_client"
+  target_path = base_path / "robosystems_client"
+
+  # Remove old generated files
+  for item in ["api", "models", "client.py", "errors.py", "types.py", "py.typed"]:
+    item_path = target_path / item
+    if item_path.exists():
+      if item_path.is_dir():
+        shutil.rmtree(item_path)
+      else:
+        item_path.unlink()
+
+  # Copy new generated files
+  for item in ["api", "models", "client.py", "errors.py", "types.py", "py.typed"]:
+    src = generated_path / item
+    dst = target_path / item
+    if src.exists():
+      if src.is_dir():
+        shutil.copytree(src, dst)
+      else:
+        shutil.copy2(src, dst)
+
+  # Clean up generated folder
+  shutil.rmtree(base_path / "generated")
+
+  print()
+
+  # Step 3: Apply patches
+  print("🔧 Applying post-generation patches...")
+  if not patch_ndjson_handling():
+    print("⚠️  Warning: NDJSON patch failed, but continuing...")
+
+  print()
+
+  # Step 4: Format and lint
+  if not run_command("uv run ruff format .", "Formatting code"):
+    return 1
+
+  if not run_command("uv run ruff check . --fix", "Fixing linting issues"):
+    return 1
+
+  if not run_command("uv run ruff check .", "Running final linting check"):
+    return 1
+
+  if not run_command("uv run ruff format --check .", "Verifying formatting"):
+    return 1
+
+  print()
+  print("✅ SDK generation complete!")
+  print()
+  print("Changes applied:")
+  print("  - Generated fresh SDK from OpenAPI spec")
+  print("  - Applied NDJSON streaming support patch")
+  print("  - Formatted and linted all code")
+  print()
+
+  return 0
+
+
+if __name__ == "__main__":
+  sys.exit(main())

{robosystems_client-0.2.5 → robosystems_client-0.2.7}/justfile

@@ -45,22 +45,7 @@ typecheck:
 
 # Generate SDK from localhost API
 generate-sdk url="http://localhost:8000/openapi.json":
-    @echo "🚀 Generating Client from {{url}}..."
-    rm -rf generated
-    uv run openapi-python-client generate --url {{url}} --output-path generated --config robosystems_client/sdk-config.yaml
-    @echo "📦 Copying generated code to robosystems_client..."
-    rm -rf robosystems_client/api robosystems_client/models robosystems_client/client.py robosystems_client/errors.py robosystems_client/types.py robosystems_client/py.typed
-    cp -r generated/robo_systems_api_client/api robosystems_client/
-    cp -r generated/robo_systems_api_client/models robosystems_client/
-    cp generated/robo_systems_api_client/client.py robosystems_client/
-    cp generated/robo_systems_api_client/errors.py robosystems_client/
-    cp generated/robo_systems_api_client/types.py robosystems_client/
-    cp generated/robo_systems_api_client/py.typed robosystems_client/
-    rm -rf generated
-    @just format
-    uv run ruff check . --fix
-    @just lint
-    @echo "✅ Client generation complete!"
+    bin/generate-sdk {{url}}
 
 # Build python package locally (for testing)
 build-package:

{robosystems_client-0.2.5 → robosystems_client-0.2.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "robosystems-client"
-version = "0.2.5"
+version = "0.2.7"
 description = "Python Client for RoboSystems financial graph database API"
 readme = "README.md"
 requires-python = ">=3.10"

robosystems_client-0.2.7/robosystems_client/api/agent/auto_select_agent.py

@@ -0,0 +1,369 @@
+from http import HTTPStatus
+from typing import Any, Optional, Union, cast
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.agent_request import AgentRequest
+from ...models.agent_response import AgentResponse
+from ...models.error_response import ErrorResponse
+from ...models.http_validation_error import HTTPValidationError
+from ...types import Response
+
+
+def _get_kwargs(
+  graph_id: str,
+  *,
+  body: AgentRequest,
+) -> dict[str, Any]:
+  headers: dict[str, Any] = {}
+
+  _kwargs: dict[str, Any] = {
+    "method": "post",
+    "url": f"/v1/graphs/{graph_id}/agent",
+  }
+
+  _kwargs["json"] = body.to_dict()
+
+  headers["Content-Type"] = "application/json"
+
+  _kwargs["headers"] = headers
+  return _kwargs
+
+
+def _parse_response(
+  *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Optional[Union[AgentResponse, Any, ErrorResponse, HTTPValidationError]]:
+  if response.status_code == 200:
+    response_200 = AgentResponse.from_dict(response.json())
+
+    return response_200
+
+  if response.status_code == 400:
+    response_400 = cast(Any, None)
+    return response_400
+
+  if response.status_code == 402:
+    response_402 = cast(Any, None)
+    return response_402
+
+  if response.status_code == 422:
+    response_422 = HTTPValidationError.from_dict(response.json())
+
+    return response_422
+
+  if response.status_code == 429:
+    response_429 = cast(Any, None)
+    return response_429
+
+  if response.status_code == 500:
+    response_500 = ErrorResponse.from_dict(response.json())
+
+    return response_500
+
+  if client.raise_on_unexpected_status:
+    raise errors.UnexpectedStatus(response.status_code, response.content)
+  else:
+    return None
+
+
+def _build_response(
+  *, client: Union[AuthenticatedClient, Client], response: httpx.Response
+) -> Response[Union[AgentResponse, Any, ErrorResponse, HTTPValidationError]]:
+  return Response(
+    status_code=HTTPStatus(response.status_code),
+    content=response.content,
+    headers=response.headers,
+    parsed=_parse_response(client=client, response=response),
+  )
+
+
+def sync_detailed(
+  graph_id: str,
+  *,
+  client: AuthenticatedClient,
+  body: AgentRequest,
+) -> Response[Union[AgentResponse, Any, ErrorResponse, HTTPValidationError]]:
+  r"""Auto-select agent for query
+
+   Automatically select the best agent for your query.
+
+  **Agent Selection Process:**
+
+  The orchestrator intelligently routes your query by:
+  1. Analyzing query intent and complexity
+  2. Enriching context with RAG if enabled
+  3. Evaluating all available agents against selection criteria
+  4. Selecting the best match based on confidence scores
+  5. Executing the query with the selected agent
+
+  **Available Agent Types:**
+  - `financial`: Financial analysis, SEC filings, company metrics
+  - `research`: General research, data exploration, trend analysis
+  - `rag`: Knowledge base search using RAG enrichment
+
+  **Execution Modes:**
+  - `quick`: Fast responses (~2-5s), suitable for simple queries
+  - `standard`: Balanced approach (~5-15s), default mode
+  - `extended`: Comprehensive analysis (~15-60s), deep research
+  - `streaming`: Real-time response streaming
+
+  **Confidence Score Interpretation:**
+  - `0.9-1.0`: High confidence, agent is ideal match
+  - `0.7-0.9`: Good confidence, agent is suitable
+  - `0.5-0.7`: Moderate confidence, agent can handle but may not be optimal
+  - `0.3-0.5`: Low confidence, fallback agent used
+  - `<0.3`: Very low confidence, consider using specific agent endpoint
+
+  **Credit Costs:**
+  - Quick mode: 5-10 credits per query
+  - Standard mode: 15-25 credits per query
+  - Extended mode: 30-75 credits per query
+  - RAG enrichment: +5-15 credits (if enabled)
+
+  **Use Cases:**
+  - Ask questions without specifying agent type
+  - Get intelligent routing for complex multi-domain queries
+  - Leverage conversation history for contextual understanding
+  - Enable RAG for knowledge base enrichment
+
+  See request/response examples in the \"Examples\" dropdown below.
+
+  Args:
+      graph_id (str):
+      body (AgentRequest): Request model for agent interactions.
+
+  Raises:
+      errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+      httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+  Returns:
+      Response[Union[AgentResponse, Any, ErrorResponse, HTTPValidationError]]
+  """
+
+  kwargs = _get_kwargs(
+    graph_id=graph_id,
+    body=body,
+  )
+
+  response = client.get_httpx_client().request(
+    **kwargs,
+  )
+
+  return _build_response(client=client, response=response)
+
+
+def sync(
+  graph_id: str,
+  *,
+  client: AuthenticatedClient,
+  body: AgentRequest,
+) -> Optional[Union[AgentResponse, Any, ErrorResponse, HTTPValidationError]]:
+  r"""Auto-select agent for query
+
+   Automatically select the best agent for your query.
+
+  **Agent Selection Process:**
+
+  The orchestrator intelligently routes your query by:
+  1. Analyzing query intent and complexity
+  2. Enriching context with RAG if enabled
+  3. Evaluating all available agents against selection criteria
+  4. Selecting the best match based on confidence scores
+  5. Executing the query with the selected agent
+
+  **Available Agent Types:**
+  - `financial`: Financial analysis, SEC filings, company metrics
+  - `research`: General research, data exploration, trend analysis
+  - `rag`: Knowledge base search using RAG enrichment
+
+  **Execution Modes:**
+  - `quick`: Fast responses (~2-5s), suitable for simple queries
+  - `standard`: Balanced approach (~5-15s), default mode
+  - `extended`: Comprehensive analysis (~15-60s), deep research
+  - `streaming`: Real-time response streaming
+
+  **Confidence Score Interpretation:**
+  - `0.9-1.0`: High confidence, agent is ideal match
+  - `0.7-0.9`: Good confidence, agent is suitable
+  - `0.5-0.7`: Moderate confidence, agent can handle but may not be optimal
+  - `0.3-0.5`: Low confidence, fallback agent used
+  - `<0.3`: Very low confidence, consider using specific agent endpoint
+
+  **Credit Costs:**
+  - Quick mode: 5-10 credits per query
+  - Standard mode: 15-25 credits per query
+  - Extended mode: 30-75 credits per query
+  - RAG enrichment: +5-15 credits (if enabled)
+
+  **Use Cases:**
+  - Ask questions without specifying agent type
+  - Get intelligent routing for complex multi-domain queries
+  - Leverage conversation history for contextual understanding
+  - Enable RAG for knowledge base enrichment
+
+  See request/response examples in the \"Examples\" dropdown below.
+
+  Args:
+      graph_id (str):
+      body (AgentRequest): Request model for agent interactions.
+
+  Raises:
+      errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+      httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+  Returns:
+      Union[AgentResponse, Any, ErrorResponse, HTTPValidationError]
+  """
+
+  return sync_detailed(
+    graph_id=graph_id,
+    client=client,
+    body=body,
+  ).parsed
+
+
+async def asyncio_detailed(
+  graph_id: str,
+  *,
+  client: AuthenticatedClient,
+  body: AgentRequest,
+) -> Response[Union[AgentResponse, Any, ErrorResponse, HTTPValidationError]]:
+  r"""Auto-select agent for query
+
+   Automatically select the best agent for your query.
+
+  **Agent Selection Process:**
+
+  The orchestrator intelligently routes your query by:
+  1. Analyzing query intent and complexity
+  2. Enriching context with RAG if enabled
+  3. Evaluating all available agents against selection criteria
+  4. Selecting the best match based on confidence scores
+  5. Executing the query with the selected agent
+
+  **Available Agent Types:**
+  - `financial`: Financial analysis, SEC filings, company metrics
+  - `research`: General research, data exploration, trend analysis
+  - `rag`: Knowledge base search using RAG enrichment
+
+  **Execution Modes:**
+  - `quick`: Fast responses (~2-5s), suitable for simple queries
+  - `standard`: Balanced approach (~5-15s), default mode
+  - `extended`: Comprehensive analysis (~15-60s), deep research
+  - `streaming`: Real-time response streaming
+
+  **Confidence Score Interpretation:**
+  - `0.9-1.0`: High confidence, agent is ideal match
+  - `0.7-0.9`: Good confidence, agent is suitable
+  - `0.5-0.7`: Moderate confidence, agent can handle but may not be optimal
+  - `0.3-0.5`: Low confidence, fallback agent used
+  - `<0.3`: Very low confidence, consider using specific agent endpoint
+
+  **Credit Costs:**
+  - Quick mode: 5-10 credits per query
+  - Standard mode: 15-25 credits per query
+  - Extended mode: 30-75 credits per query
+  - RAG enrichment: +5-15 credits (if enabled)
+
+  **Use Cases:**
+  - Ask questions without specifying agent type
+  - Get intelligent routing for complex multi-domain queries
+  - Leverage conversation history for contextual understanding
+  - Enable RAG for knowledge base enrichment
+
+  See request/response examples in the \"Examples\" dropdown below.
+
+  Args:
+      graph_id (str):
+      body (AgentRequest): Request model for agent interactions.
+
+  Raises:
+      errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+      httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+  Returns:
+      Response[Union[AgentResponse, Any, ErrorResponse, HTTPValidationError]]
+  """
+
+  kwargs = _get_kwargs(
+    graph_id=graph_id,
+    body=body,
+  )
+
+  response = await client.get_async_httpx_client().request(**kwargs)
+
+  return _build_response(client=client, response=response)
+
+
+async def asyncio(
+  graph_id: str,
+  *,
+  client: AuthenticatedClient,
+  body: AgentRequest,
+) -> Optional[Union[AgentResponse, Any, ErrorResponse, HTTPValidationError]]:
+  r"""Auto-select agent for query
+
+   Automatically select the best agent for your query.
+
+  **Agent Selection Process:**
+
+  The orchestrator intelligently routes your query by:
+  1. Analyzing query intent and complexity
+  2. Enriching context with RAG if enabled
+  3. Evaluating all available agents against selection criteria
+  4. Selecting the best match based on confidence scores
+  5. Executing the query with the selected agent
+
+  **Available Agent Types:**
+  - `financial`: Financial analysis, SEC filings, company metrics
+  - `research`: General research, data exploration, trend analysis
+  - `rag`: Knowledge base search using RAG enrichment
+
+  **Execution Modes:**
+  - `quick`: Fast responses (~2-5s), suitable for simple queries
+  - `standard`: Balanced approach (~5-15s), default mode
+  - `extended`: Comprehensive analysis (~15-60s), deep research
+  - `streaming`: Real-time response streaming
+
+  **Confidence Score Interpretation:**
+  - `0.9-1.0`: High confidence, agent is ideal match
+  - `0.7-0.9`: Good confidence, agent is suitable
+  - `0.5-0.7`: Moderate confidence, agent can handle but may not be optimal
+  - `0.3-0.5`: Low confidence, fallback agent used
+  - `<0.3`: Very low confidence, consider using specific agent endpoint
+
+  **Credit Costs:**
+  - Quick mode: 5-10 credits per query
+  - Standard mode: 15-25 credits per query
+  - Extended mode: 30-75 credits per query
+  - RAG enrichment: +5-15 credits (if enabled)
+
+  **Use Cases:**
+  - Ask questions without specifying agent type
+  - Get intelligent routing for complex multi-domain queries
+  - Leverage conversation history for contextual understanding
+  - Enable RAG for knowledge base enrichment
+
+  See request/response examples in the \"Examples\" dropdown below.
+
+  Args:
+      graph_id (str):
+      body (AgentRequest): Request model for agent interactions.
+
+  Raises:
+      errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+      httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+  Returns:
+      Union[AgentResponse, Any, ErrorResponse, HTTPValidationError]
+  """
+
+  return (
+    await asyncio_detailed(
+      graph_id=graph_id,
+      client=client,
+      body=body,
+    )
+  ).parsed

{robosystems_client-0.2.5 → robosystems_client-0.2.7}/robosystems_client/api/backup/create_backup.py

@@ -102,6 +102,23 @@ def sync_detailed(
   - **Download Support**: Unencrypted backups can be downloaded
   - **Restore Support**: Future support for encrypted backup restoration
 
+  **Operation State Machine:**
+  ```
+  pending → processing → completed
+                      ↘ failed
+  ```
+  - **pending**: Backup queued, waiting to start
+  - **processing**: Actively backing up database
+  - **completed**: Backup successfully created and stored
+  - **failed**: Backup failed (check error message)
+
+  **Expected Durations:**
+  Operation times vary by database size:
+  - **Small** (<1GB): 30 seconds - 2 minutes
+  - **Medium** (1-10GB): 2-10 minutes
+  - **Large** (10-100GB): 10-30 minutes
+  - **Very Large** (>100GB): 30+ minutes
+
   **Progress Monitoring:**
   Use the returned operation_id to connect to the SSE stream:
   ```javascript
@@ -109,6 +126,7 @@ def sync_detailed(
   eventSource.addEventListener('operation_progress', (event) => {
     const data = JSON.parse(event.data);
     console.log('Backup progress:', data.progress_percent + '%');
+    console.log('Status:', data.status); // pending, processing, completed, failed
   });
   ```
 
@@ -177,6 +195,23 @@ def sync(
   - **Download Support**: Unencrypted backups can be downloaded
   - **Restore Support**: Future support for encrypted backup restoration
 
+  **Operation State Machine:**
+  ```
+  pending → processing → completed
+                      ↘ failed
+  ```
+  - **pending**: Backup queued, waiting to start
+  - **processing**: Actively backing up database
+  - **completed**: Backup successfully created and stored
+  - **failed**: Backup failed (check error message)
+
+  **Expected Durations:**
+  Operation times vary by database size:
+  - **Small** (<1GB): 30 seconds - 2 minutes
+  - **Medium** (1-10GB): 2-10 minutes
+  - **Large** (10-100GB): 10-30 minutes
+  - **Very Large** (>100GB): 30+ minutes
+
   **Progress Monitoring:**
   Use the returned operation_id to connect to the SSE stream:
   ```javascript
@@ -184,6 +219,7 @@ def sync(
   eventSource.addEventListener('operation_progress', (event) => {
     const data = JSON.parse(event.data);
     console.log('Backup progress:', data.progress_percent + '%');
+    console.log('Status:', data.status); // pending, processing, completed, failed
   });
   ```
 
@@ -247,6 +283,23 @@ async def asyncio_detailed(
   - **Download Support**: Unencrypted backups can be downloaded
   - **Restore Support**: Future support for encrypted backup restoration
 
+  **Operation State Machine:**
+  ```
+  pending → processing → completed
+                      ↘ failed
+  ```
+  - **pending**: Backup queued, waiting to start
+  - **processing**: Actively backing up database
+  - **completed**: Backup successfully created and stored
+  - **failed**: Backup failed (check error message)
+
+  **Expected Durations:**
+  Operation times vary by database size:
+  - **Small** (<1GB): 30 seconds - 2 minutes
+  - **Medium** (1-10GB): 2-10 minutes
+  - **Large** (10-100GB): 10-30 minutes
+  - **Very Large** (>100GB): 30+ minutes
+
   **Progress Monitoring:**
   Use the returned operation_id to connect to the SSE stream:
   ```javascript
@@ -254,6 +307,7 @@ async def asyncio_detailed(
   eventSource.addEventListener('operation_progress', (event) => {
     const data = JSON.parse(event.data);
     console.log('Backup progress:', data.progress_percent + '%');
+    console.log('Status:', data.status); // pending, processing, completed, failed
   });
   ```
 
@@ -320,6 +374,23 @@ async def asyncio(
   - **Download Support**: Unencrypted backups can be downloaded
   - **Restore Support**: Future support for encrypted backup restoration
 
+  **Operation State Machine:**
+  ```
+  pending → processing → completed
+                      ↘ failed
+  ```
+  - **pending**: Backup queued, waiting to start
+  - **processing**: Actively backing up database
+  - **completed**: Backup successfully created and stored
+  - **failed**: Backup failed (check error message)
+
+  **Expected Durations:**
+  Operation times vary by database size:
+  - **Small** (<1GB): 30 seconds - 2 minutes
+  - **Medium** (1-10GB): 2-10 minutes
+  - **Large** (10-100GB): 10-30 minutes
+  - **Very Large** (>100GB): 30+ minutes
+
   **Progress Monitoring:**
   Use the returned operation_id to connect to the SSE stream:
   ```javascript
@@ -327,6 +398,7 @@ async def asyncio(
   eventSource.addEventListener('operation_progress', (event) => {
     const data = JSON.parse(event.data);
     console.log('Backup progress:', data.progress_percent + '%');
+    console.log('Status:', data.status); // pending, processing, completed, failed
   });
   ```