aristotlelib 0.1.0__tar.gz

aristotlelib-0.1.0/LICENSE

@@ -0,0 +1,15 @@
+Copyright (c) 2025 Concordance Inc. dba Harmonic. All rights reserved.
+
+Concordance Inc. dba Harmonic grants you a limited, non-exclusive, non-transferable,
+revocable license to install and use this software solely to access the Aristotle
+API under a valid API key and in accordance with the Aristotle API Terms of Service
+available at https://aristotle.harmonic.fun/api-terms-of-use
+
+You may not modify, distribute, sublicense, or reverse-engineer this software,
+except as expressly permitted by Concordance Inc. dba Harmonic in writing.
+
+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 COPYRIGHT HOLDERS
+BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+CONTRACT, TORT OR OTHERWISE, ARISING FROM OR RELATING TO THE SOFTWARE OR ITS USE.

aristotlelib-0.1.0/PKG-INFO

@@ -0,0 +1,259 @@
+Metadata-Version: 2.4
+Name: aristotlelib
+Version: 0.1.0
+Summary: Aristotle SDK - Python library for automated theorem proving with Lean
+Author: Harmonic
+Maintainer: Harmonic
+Project-URL: Homepage, https://aristotle.harmonic.fun
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: httpx>=0.24.0
+Dynamic: license-file
+
+# Aristotle SDK
+
+The Aristotle SDK is a Python library that provides tools and utilities for interacting with the Aristotle API, enabling automated theorem proving for Lean projects.
+
+
+## Installation
+
+```bash
+pip install aristotlelib
+```
+
+## Quick Start
+
+### 1. Set up your API key
+
+```python
+import aristotlelib
+
+# Set your API key
+aristotlelib.set_api_key("your-api-key-here")
+
+# Or set it via environment variable
+# export ARISTOTLE_API_KEY="your-api-key-here"
+```
+
+### 2. Prove a theorem from a file
+
+The simplest way to use Aristotle is to prove a theorem from a Lean file:
+
+```python
+import asyncio
+
+async def main():
+    # Prove a theorem from a Lean file
+    solution_path = await aristotlelib.Project.prove_from_file("path/to/your/theorem.lean")
+    print(f"Solution saved to: {solution_path}")
+
+asyncio.run(main())
+```
+
+### 3. Manual project management
+
+For more control, you can manage projects manually:
+
+```python
+import asyncio
+import aristotlelib
+from pathlib import Path
+
+async def main():
+    # Create a new project
+    project = await aristotlelib.Project.create()
+    print(f"Created project: {project.project_id}")
+
+    # Add context files
+    await project.add_context(["path/to/context1.lean", "path/to/context2.lean"])
+
+    # Solve with input content
+    await project.solve(input_content="theorem my_theorem : True := trivial")
+
+    # Wait for completion and get solution
+    while project.status not in [aristotlelib.ProjectStatus.COMPLETE, aristotlelib.ProjectStatus.FAILED]:
+        await asyncio.sleep(30)  # Poll every 30 seconds
+        await project.refresh()
+        print(f"Status: {project.status}")
+
+    if project.status == aristotlelib.ProjectStatus.COMPLETE:
+        solution_path = await project.get_solution()
+        print(f"Solution saved to: {solution_path}")
+
+asyncio.run(main())
+```
+
+## API Reference
+
+### Project Class
+
+The main class for interacting with Aristotle projects.
+
+#### `Project.create(context_file_paths=None, validate_lean_project_root=True)`
+
+Create a new Aristotle project.
+
+**Parameters:**
+- `context_file_paths` (list[Path | str], optional): List of file paths to include as context
+- `validate_lean_project_root` (bool): Whether to validate Lean project structure (recommended: True)
+
+**Returns:** `Project` instance
+
+#### `Project.prove_from_file(input_file_path, auto_add_imports=True, context_file_paths=None, validate_lean_project=True, polling_interval_seconds=30, max_polling_failures=3)`
+
+Convenience method to prove a theorem from a file with automatic import resolution.
+
+**Parameters:**
+- `input_file_path` (Path | str): Path to the input Lean file
+- `auto_add_imports` (bool): Automatically add imported files as context
+- `context_file_paths` (list[Path | str], optional): Manual context files
+- `validate_lean_project` (bool): Validate Lean project structure
+- `polling_interval_seconds` (int): Seconds between status checks
+- `max_polling_failures` (int): Max polling failures before giving up
+
+**Returns:** `Path` to the solution file
+
+#### `project.add_context(context_file_paths, batch_size=10, validate_lean_project_root=True)`
+
+Add context files to an existing project.
+
+**Parameters:**
+- `context_file_paths` (list[Path | str]): Files to add as context
+- `batch_size` (int): Files to upload per batch (max 10)
+- `validate_lean_project_root` (bool): Validate project structure
+
+#### `project.solve(input_file_path=None, input_content=None)`
+
+Solve the project with either a file or text content.
+
+**Parameters:**
+- `input_file_path` (Path | str, optional): Path to input file
+- `input_content` (str, optional): Text content to solve
+
+**Note:** Exactly one of `input_file_path` or `input_content` must be provided.
+
+#### `project.get_solution(output_path=None)`
+
+Download the solution file.
+
+**Parameters:**
+- `output_path` (Path | str, optional): Where to save the solution
+
+**Returns:** `Path` to the downloaded solution file
+
+#### `project.refresh()`
+
+Refresh the project status from the API.
+
+### Project Status
+
+```python
+class ProjectStatus(Enum):
+    NOT_STARTED = "NOT_STARTED"
+    QUEUED = "QUEUED"
+    IN_PROGRESS = "IN_PROGRESS"
+    COMPLETE = "COMPLETE"
+    FAILED = "FAILED"
+```
+
+### Error Handling
+
+The SDK provides several exception types:
+
+- `AristotleAPIError`: API-related errors
+- `LeanProjectError`: Lean project validation errors
+
+## Lean Project Requirements
+
+Aristotle works best with properly structured Lean projects. Your project should have:
+
+- A `lakefile.lean` (Lake build system) or `leanpkg.toml` (legacy)
+- A `lean-toolchain` file
+- Proper import structure
+
+The SDK will automatically:
+- Detect your project root
+- Validate file paths are within the project
+- Resolve imports to include dependencies
+- Handle file size limits (100MB max per file)
+
+## Examples
+
+### Basic theorem proving
+
+```python
+import asyncio
+import aristotle
+
+async def prove_simple_theorem():
+    # Set API key
+    aristotlelib.set_api_key("your-key")
+
+    # Prove a simple theorem
+    solution = await aristotlelib.Project.prove_from_file("examples/simple.lean")
+    print(f"Proof completed: {solution}")
+
+asyncio.run(prove_simple_theorem())
+```
+
+### Working with existing projects
+
+```python
+import asyncio
+import aristotle
+
+async def work_with_existing_project():
+    # Load an existing project
+    project = await aristotlelib.Project.from_id("existing-project-id")
+
+    # Check status
+    print(f"Project status: {project.status}")
+
+    if project.status == aristotlelib.ProjectStatus.COMPLETE:
+        solution = await project.get_solution()
+        print(f"Solution available at: {solution}")
+
+asyncio.run(work_with_existing_project())
+```
+
+### Listing projects
+
+```python
+import asyncio
+import aristotle
+
+async def list_projects():
+    projects, pagination_key = await aristotlelib.Project.list_projects(limit=10)
+
+    for project in projects:
+        print(f"Project {project.project_id}: {project.status}")
+
+    # Get next page if available
+    if pagination_key:
+        more_projects, pagination_key = await aristotlelib.Project.list_projects(pagination_key=pagination_key)
+        print(f"Found {len(more_projects)} more projects")
+
+asyncio.run(list_projects())
+```
+
+## Logging
+
+The SDK uses Python's standard logging module. To see debug and info messages from the SDK, configure logging in your application:
+
+```python
+import logging
+import aristotle
+
+# Configure logging to see SDK messages
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(levelname)s - %(name)s - %(message)s"
+)
+
+# Or configure just the aristotle logger
+logging.getLogger('aristotle').setLevel(logging.INFO)
+```
+
+This will show helpful messages to track the current status.

aristotlelib-0.1.0/README.md

@@ -0,0 +1,245 @@
+# Aristotle SDK
+
+The Aristotle SDK is a Python library that provides tools and utilities for interacting with the Aristotle API, enabling automated theorem proving for Lean projects.
+
+
+## Installation
+
+```bash
+pip install aristotlelib
+```
+
+## Quick Start
+
+### 1. Set up your API key
+
+```python
+import aristotlelib
+
+# Set your API key
+aristotlelib.set_api_key("your-api-key-here")
+
+# Or set it via environment variable
+# export ARISTOTLE_API_KEY="your-api-key-here"
+```
+
+### 2. Prove a theorem from a file
+
+The simplest way to use Aristotle is to prove a theorem from a Lean file:
+
+```python
+import asyncio
+
+async def main():
+    # Prove a theorem from a Lean file
+    solution_path = await aristotlelib.Project.prove_from_file("path/to/your/theorem.lean")
+    print(f"Solution saved to: {solution_path}")
+
+asyncio.run(main())
+```
+
+### 3. Manual project management
+
+For more control, you can manage projects manually:
+
+```python
+import asyncio
+import aristotlelib
+from pathlib import Path
+
+async def main():
+    # Create a new project
+    project = await aristotlelib.Project.create()
+    print(f"Created project: {project.project_id}")
+
+    # Add context files
+    await project.add_context(["path/to/context1.lean", "path/to/context2.lean"])
+
+    # Solve with input content
+    await project.solve(input_content="theorem my_theorem : True := trivial")
+
+    # Wait for completion and get solution
+    while project.status not in [aristotlelib.ProjectStatus.COMPLETE, aristotlelib.ProjectStatus.FAILED]:
+        await asyncio.sleep(30)  # Poll every 30 seconds
+        await project.refresh()
+        print(f"Status: {project.status}")
+
+    if project.status == aristotlelib.ProjectStatus.COMPLETE:
+        solution_path = await project.get_solution()
+        print(f"Solution saved to: {solution_path}")
+
+asyncio.run(main())
+```
+
+## API Reference
+
+### Project Class
+
+The main class for interacting with Aristotle projects.
+
+#### `Project.create(context_file_paths=None, validate_lean_project_root=True)`
+
+Create a new Aristotle project.
+
+**Parameters:**
+- `context_file_paths` (list[Path | str], optional): List of file paths to include as context
+- `validate_lean_project_root` (bool): Whether to validate Lean project structure (recommended: True)
+
+**Returns:** `Project` instance
+
+#### `Project.prove_from_file(input_file_path, auto_add_imports=True, context_file_paths=None, validate_lean_project=True, polling_interval_seconds=30, max_polling_failures=3)`
+
+Convenience method to prove a theorem from a file with automatic import resolution.
+
+**Parameters:**
+- `input_file_path` (Path | str): Path to the input Lean file
+- `auto_add_imports` (bool): Automatically add imported files as context
+- `context_file_paths` (list[Path | str], optional): Manual context files
+- `validate_lean_project` (bool): Validate Lean project structure
+- `polling_interval_seconds` (int): Seconds between status checks
+- `max_polling_failures` (int): Max polling failures before giving up
+
+**Returns:** `Path` to the solution file
+
+#### `project.add_context(context_file_paths, batch_size=10, validate_lean_project_root=True)`
+
+Add context files to an existing project.
+
+**Parameters:**
+- `context_file_paths` (list[Path | str]): Files to add as context
+- `batch_size` (int): Files to upload per batch (max 10)
+- `validate_lean_project_root` (bool): Validate project structure
+
+#### `project.solve(input_file_path=None, input_content=None)`
+
+Solve the project with either a file or text content.
+
+**Parameters:**
+- `input_file_path` (Path | str, optional): Path to input file
+- `input_content` (str, optional): Text content to solve
+
+**Note:** Exactly one of `input_file_path` or `input_content` must be provided.
+
+#### `project.get_solution(output_path=None)`
+
+Download the solution file.
+
+**Parameters:**
+- `output_path` (Path | str, optional): Where to save the solution
+
+**Returns:** `Path` to the downloaded solution file
+
+#### `project.refresh()`
+
+Refresh the project status from the API.
+
+### Project Status
+
+```python
+class ProjectStatus(Enum):
+    NOT_STARTED = "NOT_STARTED"
+    QUEUED = "QUEUED"
+    IN_PROGRESS = "IN_PROGRESS"
+    COMPLETE = "COMPLETE"
+    FAILED = "FAILED"
+```
+
+### Error Handling
+
+The SDK provides several exception types:
+
+- `AristotleAPIError`: API-related errors
+- `LeanProjectError`: Lean project validation errors
+
+## Lean Project Requirements
+
+Aristotle works best with properly structured Lean projects. Your project should have:
+
+- A `lakefile.lean` (Lake build system) or `leanpkg.toml` (legacy)
+- A `lean-toolchain` file
+- Proper import structure
+
+The SDK will automatically:
+- Detect your project root
+- Validate file paths are within the project
+- Resolve imports to include dependencies
+- Handle file size limits (100MB max per file)
+
+## Examples
+
+### Basic theorem proving
+
+```python
+import asyncio
+import aristotle
+
+async def prove_simple_theorem():
+    # Set API key
+    aristotlelib.set_api_key("your-key")
+
+    # Prove a simple theorem
+    solution = await aristotlelib.Project.prove_from_file("examples/simple.lean")
+    print(f"Proof completed: {solution}")
+
+asyncio.run(prove_simple_theorem())
+```
+
+### Working with existing projects
+
+```python
+import asyncio
+import aristotle
+
+async def work_with_existing_project():
+    # Load an existing project
+    project = await aristotlelib.Project.from_id("existing-project-id")
+
+    # Check status
+    print(f"Project status: {project.status}")
+
+    if project.status == aristotlelib.ProjectStatus.COMPLETE:
+        solution = await project.get_solution()
+        print(f"Solution available at: {solution}")
+
+asyncio.run(work_with_existing_project())
+```
+
+### Listing projects
+
+```python
+import asyncio
+import aristotle
+
+async def list_projects():
+    projects, pagination_key = await aristotlelib.Project.list_projects(limit=10)
+
+    for project in projects:
+        print(f"Project {project.project_id}: {project.status}")
+
+    # Get next page if available
+    if pagination_key:
+        more_projects, pagination_key = await aristotlelib.Project.list_projects(pagination_key=pagination_key)
+        print(f"Found {len(more_projects)} more projects")
+
+asyncio.run(list_projects())
+```
+
+## Logging
+
+The SDK uses Python's standard logging module. To see debug and info messages from the SDK, configure logging in your application:
+
+```python
+import logging
+import aristotle
+
+# Configure logging to see SDK messages
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(levelname)s - %(name)s - %(message)s"
+)
+
+# Or configure just the aristotle logger
+logging.getLogger('aristotle').setLevel(logging.INFO)
+```
+
+This will show helpful messages to track the current status.

aristotlelib-0.1.0/pyproject.toml

@@ -0,0 +1,24 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "aristotlelib"
+version = "0.1.0"
+description = "Aristotle SDK - Python library for automated theorem proving with Lean"
+readme = "README.md"
+license-files = ["LICENSE"]
+requires-python = ">=3.10"
+authors = [{ name = "Harmonic" }]
+maintainers = [{ name = "Harmonic" }]
+dependencies = ["pydantic>=2.0.0", "httpx>=0.24.0"]
+
+[project.urls]
+Homepage = "https://aristotle.harmonic.fun"
+
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-dir]
+"" = "src"

aristotlelib-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

aristotlelib-0.1.0/src/aristotlelib/__init__.py

@@ -0,0 +1,10 @@
+from aristotlelib.api_request import set_api_key
+
+from aristotlelib.project import Project, ProjectStatus
+from aristotlelib.local_file_utils import (
+    find_lean_project_root,
+    validate_local_file_paths,
+    gather_file_imports,
+    get_files_for_upload,
+)
+from aristotlelib.api_request import AristotleRequestClient, AristotleAPIError

aristotlelib-0.1.0/src/aristotlelib/api_request.py

@@ -0,0 +1,129 @@
+import os
+import httpx
+from typing import Any
+
+
+API_VERSION = "1"
+BASE_URL = f"https://aristotle.harmonic.fun/api/v{API_VERSION}"
+DEFAULT_TIMEOUT_SECONDS = 30
+
+API_KEY: str | None = None
+
+
+def get_api_key() -> str:
+    global API_KEY
+    api_key = API_KEY or os.environ.get("ARISTOTLE_API_KEY")
+    if api_key is None:
+        raise ValueError(
+            "API key has not been set. Call aristotle.set_api_key() or set the ARISTOTLE_API_KEY environment variable."
+        )
+    return api_key
+
+
+def set_api_key(api_key: str) -> str:
+    global API_KEY
+    API_KEY = api_key
+    return API_KEY
+
+
+class AristotleRequestClient:
+    """Async HTTP client for the Aristotle API."""
+
+    def __init__(self):
+        self._client: httpx.AsyncClient | None = None
+
+    async def __aenter__(self):
+        """Async context manager entry."""
+        self._client = httpx.AsyncClient(timeout=DEFAULT_TIMEOUT_SECONDS)
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """Async context manager exit."""
+        if self._client:
+            await self._client.aclose()
+
+    async def get(
+        self, endpoint: str, params: dict[str, Any] | None = None
+    ) -> httpx.Response:
+        """Make a GET request."""
+        return await self._make_request("GET", endpoint, params=params)
+
+    async def post(
+        self,
+        endpoint: str,
+        data: dict[str, Any] | None = None,
+        files: list[tuple[str, tuple[str, bytes, str]]] | None = None,
+    ) -> httpx.Response:
+        """Make a POST request."""
+        return await self._make_request("POST", endpoint, data=data, files=files)
+
+    async def put(
+        self, endpoint: str, data: dict[str, Any] | None = None
+    ) -> httpx.Response:
+        """Make a PUT request."""
+        return await self._make_request("PUT", endpoint, data=data)
+
+    async def delete(self, endpoint: str) -> httpx.Response:
+        """Make a DELETE request."""
+        return await self._make_request("DELETE", endpoint)
+
+    async def _make_request(
+        self,
+        method: str,
+        endpoint: str,
+        data: dict[str, Any] | None = None,
+        params: dict[str, Any] | None = None,
+        files: list[tuple[str, tuple[str, bytes, str]]] | None = None,
+    ) -> httpx.Response:
+        """Make an HTTP request to the Aristotle API."""
+        url = f"{BASE_URL}/{endpoint.lstrip('/')}"
+        headers = {
+            "X-API-Key": get_api_key(),
+        }
+
+        if not self._client:
+            self._client = httpx.AsyncClient(timeout=DEFAULT_TIMEOUT_SECONDS)
+
+        try:
+            if files:
+                # For file uploads, use multipart/form-data
+                files_data = []
+                for field_name, (file_path, file_content, content_type) in files:
+                    files_data.append(
+                        (field_name, (file_path, file_content, content_type))
+                    )
+
+                response = await self._client.request(
+                    method=method,
+                    url=url,
+                    data=data,
+                    files=files_data,
+                    params=params,
+                    headers=headers,
+                )
+            else:
+                # For regular requests, use JSON
+                headers["Content-Type"] = "application/json"
+                response = await self._client.request(
+                    method=method,
+                    url=url,
+                    json=data,
+                    params=params,
+                    headers=headers,
+                )
+            response.raise_for_status()
+            return response
+        except httpx.RequestError as e:
+            raise AristotleAPIError(f"Request failed: {str(e)}") from e
+
+    async def close(self):
+        """Close the async client."""
+        if self._client:
+            await self._client.aclose()
+            self._client = None
+
+
+class AristotleAPIError(Exception):
+    """Exception raised for API-related errors."""
+
+    pass