# RoboSystems Python SDK
[](https://pypi.org/project/robosystems-python-sdk/)
[](https://opensource.org/licenses/MIT)
Official Python SDK for the RoboSystems Financial Knowledge Graph API. Access comprehensive financial data including accounting records, SEC filings, and advanced graph analytics through a type-safe, async-ready Python interface.
## Features
- **Type-safe API client** with full type hints and Pydantic models
- **Async/await support** for high-performance applications
- **Multi-tenant support** with graph-scoped operations
- **Authentication handling** with API key and SSO support
- **Comprehensive error handling** with custom exceptions
- **Pagination support** for large data sets
- **Streaming query support** for memory-efficient processing of large result sets
- **Financial AI Agent** integration for natural language queries
## Installation
```bash
pip install robosystems-python-sdk
```
## Quick Start
```python
from robosystems_client import RoboSystemsClient
from robosystems_client.api.company import list_companies
from robosystems_client.api.query import execute_cypher_query
from robosystems_client.models import CypherQueryRequest
# Initialize the client
client = RoboSystemsClient(
base_url="https://api.robosystems.ai",
token="your-api-key",
auth_header_name="X-API-Key",
prefix="" # No prefix needed for API key
)
# Async usage (recommended)
import asyncio
async def main():
# List companies in your graph
companies = await list_companies.asyncio(graph_id="your-graph-id", client=client)
print(f"Found {companies.total} companies")
# Execute a Cypher query
query = CypherQueryRequest(
query="MATCH (c:Company)-[:HAS_FILING]->(f:Filing) RETURN c.name, f.form_type, f.filing_date LIMIT 10"
)
result = await execute_cypher_query.asyncio(graph_id="your-graph-id", client=client, body=query)
for row in result.data:
print(f"{row['c.name']} filed {row['f.form_type']} on {row['f.filing_date']}")
asyncio.run(main())
```
## Key API Endpoints
### Authentication & User Management
```python
from robosystems_client.api.auth import login_user, get_current_auth_user
from robosystems_client.api.user import create_user_api_key, get_user_graphs
from robosystems_client.models import LoginRequest, CreateAPIKeyRequest
# Login and manage sessions
login_request = LoginRequest(email="user@example.com", password="your-password")
auth_response = await login_user.asyncio(client=client, body=login_request)
# Get current authenticated user
current_user = await get_current_auth_user.asyncio(client=client)
# API key management
api_key_request = CreateAPIKeyRequest(name="My API Key", key_type="user")
api_key = await create_user_api_key.asyncio(client=client, body=api_key_request)
# List user's graphs
user_graphs = await get_user_graphs.asyncio(client=client)
```
### Company & Financial Data
```python
from robosystems_client.api.company import get_company, create_company, list_companies
from robosystems_client.api.connections import create_connection, sync_connection
from robosystems_client.models import CompanyCreate, ConnectionCreate
# List companies with pagination
companies = await list_companies.asyncio(
graph_id="your-graph-id",
client=client,
limit=20,
offset=0
)
# Get specific company details
company = await get_company.asyncio(
graph_id="your-graph-id",
company_id="AAPL",
client=client
)
# Create new company
company_data = CompanyCreate(
identifier="MSFT",
name="Microsoft Corporation",
metadata={"industry": "Technology"}
)
new_company = await create_company.asyncio(
graph_id="your-graph-id",
client=client,
body=company_data
)
# Data connections (QuickBooks, bank accounts, etc.)
connection_config = ConnectionCreate(
name="QuickBooks Integration",
connection_type="quickbooks",
config={"company_id": "123456"}
)
connection = await create_connection.asyncio(
graph_id="your-graph-id",
client=client,
body=connection_config
)
```
### Graph Queries & Analytics
```python
from robosystems_client.api.query import execute_cypher_query, execute_read_only_cypher_query
from robosystems_client.api.graph_analytics import get_graph_metrics
from robosystems_client.models import CypherQueryRequest
# Execute Cypher queries with parameters
query_request = CypherQueryRequest(
query="""MATCH (c:Company {ticker: $ticker})-[:HAS_METRIC]->(m:Metric)
WHERE m.fiscal_year >= $start_year
RETURN m.name, m.value, m.fiscal_year
ORDER BY m.fiscal_year DESC""",
parameters={"ticker": "AAPL", "start_year": 2020}
)
results = await execute_cypher_query.asyncio(
graph_id="your-graph-id",
client=client,
body=query_request
)
# Read-only queries (for better performance on large datasets)
read_only_result = await execute_read_only_cypher_query.asyncio(
graph_id="your-graph-id",
client=client,
body=query_request
)
# Get graph analytics and metrics
metrics = await get_graph_metrics.asyncio(
graph_id="your-graph-id",
client=client
)
print(f"Total nodes: {metrics.total_nodes}")
print(f"Total relationships: {metrics.total_relationships}")
```
### Financial AI Agent
```python
from robosystems_client.api.agent import query_financial_agent
from robosystems_client.models import AgentQueryRequest
# Natural language financial queries
agent_request = AgentQueryRequest(
query="What was Apple's revenue growth over the last 3 years?",
include_reasoning=True,
max_tokens=1000
)
agent_response = await query_financial_agent.asyncio(
graph_id="your-graph-id",
client=client,
body=agent_request
)
print(f"Answer: {agent_response.answer}")
if agent_response.reasoning:
print(f"Reasoning: {agent_response.reasoning}")
```
### Function Patterns
Every API endpoint provides multiple calling patterns:
- **`asyncio()`** - Async call, returns parsed response (recommended)
- **`asyncio_detailed()`** - Async call, returns full Response object
- **`sync()`** - Synchronous call, returns parsed response
- **`sync_detailed()`** - Synchronous call, returns full Response object
## Streaming Queries
For large result sets, the SDK supports streaming responses that process data in chunks to minimize memory usage:
```python
from robosystems_client.extensions import asyncio_streaming, sync_streaming
from robosystems_client.models import CypherQueryRequest
# Async streaming for large datasets
async def process_large_dataset():
query = CypherQueryRequest(
query="""MATCH (c:Company)-[:HAS_METRIC]->(m:Metric)
WHERE m.fiscal_year >= 2020
RETURN c.name, m.name, m.value, m.fiscal_year
ORDER BY c.name, m.fiscal_year""",
parameters={}
)
total_rows = 0
async for chunk in asyncio_streaming(
graph_id="your-graph-id",
client=client,
body=query
):
# Process chunk with chunk['row_count'] rows
for row in chunk['data']:
# Process each row without loading entire dataset
company = row['c.name']
metric = row['m.name']
value = row['m.value']
year = row['m.fiscal_year']
# Your processing logic here
total_rows += chunk['row_count']
# Final chunk includes execution metadata
if chunk.get('final'):
print(f"Query completed: {total_rows} rows in {chunk['execution_time_ms']}ms")
# Synchronous streaming also available
def process_sync():
for chunk in sync_streaming(graph_id="your-graph-id", client=client, body=query):
# Process chunk
for row in chunk['data']:
print(f"{row['c.name']}: {row['m.name']} = {row['m.value']}")
```
Streaming is ideal for:
- Exporting large datasets without loading everything into memory
- Real-time processing of query results
- Building ETL pipelines with controlled memory usage
- Generating reports from millions of rows
## Advanced Features
### Billing & Credit Management
```python
from robosystems_client.api.credits_ import get_credit_summary, check_credit_balance
from robosystems_client.api.billing import get_current_graph_bill, get_graph_usage_details
# Monitor credits and usage
credit_summary = await get_credit_summary.asyncio(client=client)
print(f"Available credits: {credit_summary.available_credits:,}")
print(f"Monthly usage: {credit_summary.used_credits:,}/{credit_summary.total_credits:,}")
# Check credit requirements before operations
from robosystems_client.models import CreditCheckRequest
credit_check_request = CreditCheckRequest(
operation_type="query",
estimated_credits=100
)
credit_check = await check_credit_balance.asyncio(
graph_id="your-graph-id",
client=client,
body=credit_check_request
)
# Billing information
current_bill = await get_current_graph_bill.asyncio(
graph_id="your-graph-id",
client=client
)
# Detailed usage metrics
usage_details = await get_graph_usage_details.asyncio(
graph_id="your-graph-id",
client=client,
start_date="2024-01-01",
end_date="2024-01-31"
)
```
### MCP Tools Integration
```python
from robosystems_client.api.mcp import list_mcp_tools, call_mcp_tool
from robosystems_client.models import MCPToolCall
# List available MCP tools
tools = await list_mcp_tools.asyncio(client=client)
for tool in tools.tools:
print(f"{tool.name}: {tool.description}")
# Call an MCP tool
tool_call = MCPToolCall(
name="analyze_financial_statement",
arguments={
"company_id": "AAPL",
"statement_type": "income",
"fiscal_year": 2023
}
)
tool_result = await call_mcp_tool.asyncio(
client=client,
body=tool_call
)
print(f"Analysis result: {tool_result.content}")
```
## Error Handling
```python
from robosystems_client.types import Response
from robosystems_client.errors import UnexpectedStatus
import httpx
try:
# API calls that might fail
companies = await list_companies.asyncio(graph_id="your-graph-id", client=client)
except UnexpectedStatus as e:
# Handle API errors (4xx, 5xx)
print(f"API error: {e.status_code}")
print(f"Error details: {e.content}")
# Parse error response if JSON
if e.status_code == 400:
error_detail = e.content.decode('utf-8')
print(f"Validation error: {error_detail}")
elif e.status_code == 401:
print("Authentication failed - check your API key")
elif e.status_code == 403:
print("Permission denied - check graph access")
elif e.status_code == 429:
print("Rate limit exceeded - retry later")
except httpx.TimeoutException:
print("Request timed out - try again")
except httpx.NetworkError as e:
print(f"Network error: {e}")
except Exception as e:
print(f"Unexpected error: {type(e).__name__}: {e}")
# Using detailed responses for better error handling
from robosystems_client.api.company import list_companies
response = await list_companies.asyncio_detailed(
graph_id="your-graph-id",
client=client
)
if response.status_code == 200:
companies = response.parsed
print(f"Success: {companies.total} companies found")
else:
print(f"Failed with status {response.status_code}")
print(f"Headers: {response.headers}")
print(f"Content: {response.content}")
```
## Development
This SDK is auto-generated from the RoboSystems OpenAPI specification to ensure it stays in sync with the latest API changes.
### Setup
```bash
just venv
just install
```
### Regenerating the SDK
When the API changes, regenerate the SDK from the OpenAPI spec:
```bash
# From localhost (development)
just generate-sdk http://localhost:8000/openapi.json
# From staging
just generate-sdk https://staging.api.robosystems.ai/openapi.json
# From production
just generate-sdk https://api.robosystems.ai/openapi.json
```
### Testing
```bash
just test
just test-cov
```
### Code Quality
```bash
just lint
just format
just typecheck
```
### Publishing
```bash
just build-package
just publish-package
```
Raw data
{
"_id": null,
"home_page": null,
"name": "robosystems-python-sdk",
"maintainer": null,
"docs_url": null,
"requires_python": ">=3.10",
"maintainer_email": null,
"keywords": "api, client, financial, graph, kuzu, robosystems, sdk",
"author": "RoboSystems Team",
"author_email": null,
"download_url": "https://files.pythonhosted.org/packages/fa/43/508e4846c3b5b1549e66f174fc1658a734146fc484c5456efdb89f505147/robosystems_python_sdk-0.1.5.tar.gz",
"platform": null,
"description": "# RoboSystems Python SDK\n\n[](https://pypi.org/project/robosystems-python-sdk/)\n[](https://opensource.org/licenses/MIT)\n\nOfficial Python SDK for the RoboSystems Financial Knowledge Graph API. Access comprehensive financial data including accounting records, SEC filings, and advanced graph analytics through a type-safe, async-ready Python interface.\n\n## Features\n\n- **Type-safe API client** with full type hints and Pydantic models\n- **Async/await support** for high-performance applications \n- **Multi-tenant support** with graph-scoped operations\n- **Authentication handling** with API key and SSO support\n- **Comprehensive error handling** with custom exceptions\n- **Pagination support** for large data sets\n- **Streaming query support** for memory-efficient processing of large result sets\n- **Financial AI Agent** integration for natural language queries\n\n## Installation\n\n```bash\npip install robosystems-python-sdk\n```\n\n## Quick Start\n\n```python\nfrom robosystems_client import RoboSystemsClient\nfrom robosystems_client.api.company import list_companies\nfrom robosystems_client.api.query import execute_cypher_query\nfrom robosystems_client.models import CypherQueryRequest\n\n# Initialize the client\nclient = RoboSystemsClient(\n base_url=\"https://api.robosystems.ai\",\n token=\"your-api-key\",\n auth_header_name=\"X-API-Key\",\n prefix=\"\" # No prefix needed for API key\n)\n\n# Async usage (recommended)\nimport asyncio\n\nasync def main():\n # List companies in your graph\n companies = await list_companies.asyncio(graph_id=\"your-graph-id\", client=client)\n print(f\"Found {companies.total} companies\")\n \n # Execute a Cypher query\n query = CypherQueryRequest(\n query=\"MATCH (c:Company)-[:HAS_FILING]->(f:Filing) RETURN c.name, f.form_type, f.filing_date LIMIT 10\"\n )\n result = await execute_cypher_query.asyncio(graph_id=\"your-graph-id\", client=client, body=query)\n \n for row in result.data:\n print(f\"{row['c.name']} filed {row['f.form_type']} on {row['f.filing_date']}\")\n\nasyncio.run(main())\n```\n\n## Key API Endpoints\n\n### Authentication & User Management\n```python\nfrom robosystems_client.api.auth import login_user, get_current_auth_user\nfrom robosystems_client.api.user import create_user_api_key, get_user_graphs\nfrom robosystems_client.models import LoginRequest, CreateAPIKeyRequest\n\n# Login and manage sessions\nlogin_request = LoginRequest(email=\"user@example.com\", password=\"your-password\")\nauth_response = await login_user.asyncio(client=client, body=login_request)\n\n# Get current authenticated user\ncurrent_user = await get_current_auth_user.asyncio(client=client)\n\n# API key management\napi_key_request = CreateAPIKeyRequest(name=\"My API Key\", key_type=\"user\")\napi_key = await create_user_api_key.asyncio(client=client, body=api_key_request)\n\n# List user's graphs\nuser_graphs = await get_user_graphs.asyncio(client=client)\n```\n\n### Company & Financial Data\n```python\nfrom robosystems_client.api.company import get_company, create_company, list_companies\nfrom robosystems_client.api.connections import create_connection, sync_connection\nfrom robosystems_client.models import CompanyCreate, ConnectionCreate\n\n# List companies with pagination\ncompanies = await list_companies.asyncio(\n graph_id=\"your-graph-id\", \n client=client,\n limit=20,\n offset=0\n)\n\n# Get specific company details\ncompany = await get_company.asyncio(\n graph_id=\"your-graph-id\", \n company_id=\"AAPL\", \n client=client\n)\n\n# Create new company\ncompany_data = CompanyCreate(\n identifier=\"MSFT\",\n name=\"Microsoft Corporation\",\n metadata={\"industry\": \"Technology\"}\n)\nnew_company = await create_company.asyncio(\n graph_id=\"your-graph-id\", \n client=client, \n body=company_data\n)\n\n# Data connections (QuickBooks, bank accounts, etc.)\nconnection_config = ConnectionCreate(\n name=\"QuickBooks Integration\",\n connection_type=\"quickbooks\",\n config={\"company_id\": \"123456\"}\n)\nconnection = await create_connection.asyncio(\n graph_id=\"your-graph-id\", \n client=client, \n body=connection_config\n)\n```\n\n### Graph Queries & Analytics\n```python\nfrom robosystems_client.api.query import execute_cypher_query, execute_read_only_cypher_query\nfrom robosystems_client.api.graph_analytics import get_graph_metrics\nfrom robosystems_client.models import CypherQueryRequest\n\n# Execute Cypher queries with parameters\nquery_request = CypherQueryRequest(\n query=\"\"\"MATCH (c:Company {ticker: $ticker})-[:HAS_METRIC]->(m:Metric)\n WHERE m.fiscal_year >= $start_year\n RETURN m.name, m.value, m.fiscal_year\n ORDER BY m.fiscal_year DESC\"\"\",\n parameters={\"ticker\": \"AAPL\", \"start_year\": 2020}\n)\nresults = await execute_cypher_query.asyncio(\n graph_id=\"your-graph-id\", \n client=client, \n body=query_request\n)\n\n# Read-only queries (for better performance on large datasets)\nread_only_result = await execute_read_only_cypher_query.asyncio(\n graph_id=\"your-graph-id\",\n client=client,\n body=query_request\n)\n\n# Get graph analytics and metrics\nmetrics = await get_graph_metrics.asyncio(\n graph_id=\"your-graph-id\", \n client=client\n)\nprint(f\"Total nodes: {metrics.total_nodes}\")\nprint(f\"Total relationships: {metrics.total_relationships}\")\n```\n\n### Financial AI Agent\n```python\nfrom robosystems_client.api.agent import query_financial_agent\nfrom robosystems_client.models import AgentQueryRequest\n\n# Natural language financial queries\nagent_request = AgentQueryRequest(\n query=\"What was Apple's revenue growth over the last 3 years?\",\n include_reasoning=True,\n max_tokens=1000\n)\nagent_response = await query_financial_agent.asyncio(\n graph_id=\"your-graph-id\", \n client=client, \n body=agent_request\n)\nprint(f\"Answer: {agent_response.answer}\")\nif agent_response.reasoning:\n print(f\"Reasoning: {agent_response.reasoning}\")\n```\n\n### Function Patterns\n\nEvery API endpoint provides multiple calling patterns:\n\n- **`asyncio()`** - Async call, returns parsed response (recommended)\n- **`asyncio_detailed()`** - Async call, returns full Response object \n- **`sync()`** - Synchronous call, returns parsed response\n- **`sync_detailed()`** - Synchronous call, returns full Response object\n\n## Streaming Queries\n\nFor large result sets, the SDK supports streaming responses that process data in chunks to minimize memory usage:\n\n```python\nfrom robosystems_client.extensions import asyncio_streaming, sync_streaming\nfrom robosystems_client.models import CypherQueryRequest\n\n# Async streaming for large datasets\nasync def process_large_dataset():\n query = CypherQueryRequest(\n query=\"\"\"MATCH (c:Company)-[:HAS_METRIC]->(m:Metric)\n WHERE m.fiscal_year >= 2020\n RETURN c.name, m.name, m.value, m.fiscal_year\n ORDER BY c.name, m.fiscal_year\"\"\",\n parameters={}\n )\n \n total_rows = 0\n async for chunk in asyncio_streaming(\n graph_id=\"your-graph-id\",\n client=client,\n body=query\n ):\n # Process chunk with chunk['row_count'] rows\n for row in chunk['data']:\n # Process each row without loading entire dataset\n company = row['c.name']\n metric = row['m.name']\n value = row['m.value']\n year = row['m.fiscal_year']\n # Your processing logic here\n \n total_rows += chunk['row_count']\n \n # Final chunk includes execution metadata\n if chunk.get('final'):\n print(f\"Query completed: {total_rows} rows in {chunk['execution_time_ms']}ms\")\n\n# Synchronous streaming also available\ndef process_sync():\n for chunk in sync_streaming(graph_id=\"your-graph-id\", client=client, body=query):\n # Process chunk\n for row in chunk['data']:\n print(f\"{row['c.name']}: {row['m.name']} = {row['m.value']}\")\n```\n\nStreaming is ideal for:\n- Exporting large datasets without loading everything into memory\n- Real-time processing of query results \n- Building ETL pipelines with controlled memory usage\n- Generating reports from millions of rows\n\n## Advanced Features\n\n### Billing & Credit Management\n```python\nfrom robosystems_client.api.credits_ import get_credit_summary, check_credit_balance\nfrom robosystems_client.api.billing import get_current_graph_bill, get_graph_usage_details\n\n# Monitor credits and usage\ncredit_summary = await get_credit_summary.asyncio(client=client)\nprint(f\"Available credits: {credit_summary.available_credits:,}\")\nprint(f\"Monthly usage: {credit_summary.used_credits:,}/{credit_summary.total_credits:,}\")\n\n# Check credit requirements before operations\nfrom robosystems_client.models import CreditCheckRequest\ncredit_check_request = CreditCheckRequest(\n operation_type=\"query\",\n estimated_credits=100\n)\ncredit_check = await check_credit_balance.asyncio(\n graph_id=\"your-graph-id\", \n client=client, \n body=credit_check_request\n)\n\n# Billing information\ncurrent_bill = await get_current_graph_bill.asyncio(\n graph_id=\"your-graph-id\", \n client=client\n)\n\n# Detailed usage metrics\nusage_details = await get_graph_usage_details.asyncio(\n graph_id=\"your-graph-id\",\n client=client,\n start_date=\"2024-01-01\",\n end_date=\"2024-01-31\"\n)\n```\n\n### MCP Tools Integration\n```python\nfrom robosystems_client.api.mcp import list_mcp_tools, call_mcp_tool\nfrom robosystems_client.models import MCPToolCall\n\n# List available MCP tools\ntools = await list_mcp_tools.asyncio(client=client)\nfor tool in tools.tools:\n print(f\"{tool.name}: {tool.description}\")\n\n# Call an MCP tool\ntool_call = MCPToolCall(\n name=\"analyze_financial_statement\",\n arguments={\n \"company_id\": \"AAPL\", \n \"statement_type\": \"income\",\n \"fiscal_year\": 2023\n }\n)\ntool_result = await call_mcp_tool.asyncio(\n client=client,\n body=tool_call\n)\nprint(f\"Analysis result: {tool_result.content}\")\n```\n\n## Error Handling\n\n```python\nfrom robosystems_client.types import Response\nfrom robosystems_client.errors import UnexpectedStatus\nimport httpx\n\ntry:\n # API calls that might fail\n companies = await list_companies.asyncio(graph_id=\"your-graph-id\", client=client)\nexcept UnexpectedStatus as e:\n # Handle API errors (4xx, 5xx)\n print(f\"API error: {e.status_code}\")\n print(f\"Error details: {e.content}\")\n \n # Parse error response if JSON\n if e.status_code == 400:\n error_detail = e.content.decode('utf-8')\n print(f\"Validation error: {error_detail}\")\n elif e.status_code == 401:\n print(\"Authentication failed - check your API key\")\n elif e.status_code == 403:\n print(\"Permission denied - check graph access\")\n elif e.status_code == 429:\n print(\"Rate limit exceeded - retry later\")\nexcept httpx.TimeoutException:\n print(\"Request timed out - try again\")\nexcept httpx.NetworkError as e:\n print(f\"Network error: {e}\")\nexcept Exception as e:\n print(f\"Unexpected error: {type(e).__name__}: {e}\")\n\n# Using detailed responses for better error handling\nfrom robosystems_client.api.company import list_companies\n\nresponse = await list_companies.asyncio_detailed(\n graph_id=\"your-graph-id\",\n client=client\n)\n\nif response.status_code == 200:\n companies = response.parsed\n print(f\"Success: {companies.total} companies found\")\nelse:\n print(f\"Failed with status {response.status_code}\")\n print(f\"Headers: {response.headers}\")\n print(f\"Content: {response.content}\")\n```\n\n## Development\n\nThis SDK is auto-generated from the RoboSystems OpenAPI specification to ensure it stays in sync with the latest API changes.\n\n### Setup\n\n```bash\njust venv\njust install\n```\n\n### Regenerating the SDK\n\nWhen the API changes, regenerate the SDK from the OpenAPI spec:\n\n```bash\n# From localhost (development)\njust generate-sdk http://localhost:8000/openapi.json\n\n# From staging\njust generate-sdk https://staging.api.robosystems.ai/openapi.json\n\n# From production\njust generate-sdk https://api.robosystems.ai/openapi.json\n```\n\n### Testing\n\n```bash\njust test\njust test-cov\n```\n\n### Code Quality\n\n```bash\njust lint\njust format\njust typecheck\n```\n\n### Publishing\n\n```bash\njust build-package\njust publish-package\n```\n",
"bugtrack_url": null,
"license": "MIT",
"summary": "Python SDK for RoboSystems financial graph database API",
"version": "0.1.5",
"project_urls": null,
"split_keywords": [
"api",
" client",
" financial",
" graph",
" kuzu",
" robosystems",
" sdk"
],
"urls": [
{
"comment_text": null,
"digests": {
"blake2b_256": "3cbc0477d245e595889fc87313ed0be05d8c7cbb02de42b0b753cdfe527aee92",
"md5": "7c0d427c5a470577e023f355a65a0541",
"sha256": "131e6e039208be6bd9bdbf948597c462b5256e4c05ba87b66e0dbbd86ac997eb"
},
"downloads": -1,
"filename": "robosystems_python_sdk-0.1.5-py3-none-any.whl",
"has_sig": false,
"md5_digest": "7c0d427c5a470577e023f355a65a0541",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": ">=3.10",
"size": 324865,
"upload_time": "2025-08-05T03:23:05",
"upload_time_iso_8601": "2025-08-05T03:23:05.643037Z",
"url": "https://files.pythonhosted.org/packages/3c/bc/0477d245e595889fc87313ed0be05d8c7cbb02de42b0b753cdfe527aee92/robosystems_python_sdk-0.1.5-py3-none-any.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": null,
"digests": {
"blake2b_256": "fa43508e4846c3b5b1549e66f174fc1658a734146fc484c5456efdb89f505147",
"md5": "756be728daa189ec1fb294597acb56d7",
"sha256": "0220bfce400edffdc405450b5b49f080e53dc6a1776c50cdbd43a4d7c1d94577"
},
"downloads": -1,
"filename": "robosystems_python_sdk-0.1.5.tar.gz",
"has_sig": false,
"md5_digest": "756be728daa189ec1fb294597acb56d7",
"packagetype": "sdist",
"python_version": "source",
"requires_python": ">=3.10",
"size": 108560,
"upload_time": "2025-08-05T03:23:07",
"upload_time_iso_8601": "2025-08-05T03:23:07.042602Z",
"url": "https://files.pythonhosted.org/packages/fa/43/508e4846c3b5b1549e66f174fc1658a734146fc484c5456efdb89f505147/robosystems_python_sdk-0.1.5.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2025-08-05 03:23:07",
"github": false,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"lcname": "robosystems-python-sdk"
}
JSON