aristotlelib 0.1.0__py3-none-any.whl

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/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

aristotlelib/local_file_utils.py

@@ -0,0 +1,421 @@
+import logging
+import os
+from pathlib import Path
+
+# Set up logger for this module
+logger = logging.getLogger("aristotle")
+
+
+MAX_FILE_SIZE_BYTES = 100 * 1024 * 1024
+
+
+class LeanProjectError(Exception):
+    """Exception raised for Lean project-related errors."""
+
+    pass
+
+
+def find_lean_project_root(start_path: Path) -> Path:
+    """
+    Find the Lean project root by looking for project markers.
+
+    Finds the OUTERMOST project root to handle cases where we're starting
+    from within .lake/packages/ subdirectories.
+
+    Searches upward from start_path for:
+    - lakefile.lean (Lake build system)
+    - leanpkg.toml (legacy package manager)
+    - lean-toolchain file
+
+    Args:
+        start_path: Path to start searching from
+
+    Returns:
+        Path: Outermost project root directory
+
+    Raises:
+        ProjectAPIError: If no Lean project markers are found
+    """
+    current = start_path.parent if start_path.is_file() else start_path
+    current = current.resolve()
+    project_markers = ["lakefile.lean", "leanpkg.toml", "lean-toolchain"]
+    found_root = None
+
+    # Search upward from the start path, keeping track of the outermost project root
+    while current != current.parent:
+        for marker in project_markers:
+            if (current / marker).exists():
+                logger.debug(f"Found project marker at {current} (marker: {marker})")
+                found_root = current
+                # Don't return immediately - keep searching for outer project roots
+                break
+        current = current.parent
+
+    if found_root:
+        logger.info(f"Found outermost project root at {found_root}")
+        return found_root
+
+    # No markers found - raise error
+    raise LeanProjectError(
+        f"No Lean project found. Could not find any of {project_markers} "
+        f"in the directory tree starting from {start_path}. "
+        "Please ensure you're running this from within a Lean project."
+    )
+
+
+def validate_local_file_path(file_path: Path, project_root: Path | None = None) -> None:
+    """
+    Validate that a file path is safe to use.
+
+    Validates that this is a real file, and if provided, within the project root.
+
+    Args:
+        file_path: Path to validate
+        project_root: Project root directory to ensure file is within (optional)
+
+    Raises:
+        ValueError: If path is invalid or outside project root
+    """
+    try:
+        resolved_path = file_path.resolve(strict=True)
+    except (OSError, RuntimeError) as e:
+        raise ValueError(f"Invalid file path {file_path}: {e}")
+
+    if project_root is not None:
+        project_root_resolved = project_root.resolve()
+        try:
+            resolved_path.relative_to(project_root_resolved)
+        except ValueError:
+            raise ValueError(
+                f"File {resolved_path} is outside project root {project_root_resolved}"
+            )
+
+    if not resolved_path.is_file():
+        raise ValueError(f"Path {resolved_path} is not a file")
+
+    if resolved_path.suffix != ".lean":
+        raise ValueError(f"File {resolved_path} is not a Lean file")
+
+
+def validate_local_file_paths(
+    file_paths: list[Path], project_root: Path | None = None
+) -> None:
+    """
+    Validate that all paths in a list of local paths are safe to use.
+    """
+    for file_path in file_paths:
+        validate_local_file_path(file_path, project_root)
+
+
+def normalize_and_dedupe_paths(file_paths: list[Path] | list[str]) -> list[Path]:
+    """
+    Normalize and remove duplicate file paths based on their resolved absolute paths.
+
+    Args:
+        file_paths: List of file paths (can be strings or Path bojects) to normalize and deduplicate
+
+    Returns:
+        List of unique Path objects (with duplicates removed)
+    """
+    # Normalize to Path objects
+    normalized_paths = [Path(p) for p in file_paths]
+
+    seen: set[Path] = set()
+    unique_paths: list[Path] = []
+
+    for file_path in normalized_paths:
+        resolved = file_path.resolve()
+        if resolved not in seen:
+            seen.add(resolved)
+            unique_paths.append(file_path)
+
+    return unique_paths
+
+
+def read_file_safely(file_path: Path, max_size: int = MAX_FILE_SIZE_BYTES) -> bytes:
+    """
+    Read a file safely, checking size before loading into memory.
+
+    Args:
+        file_path: Path to file to read
+        max_size: Maximum allowed file size in bytes
+
+    Returns:
+        File contents as bytes
+
+    Raises:
+        FileSizeError: If file is too large
+        OSError: If file cannot be read
+    """
+    file_size = file_path.stat().st_size
+    if file_size > max_size:
+        raise LeanProjectError(
+            f"File {file_path} is too large ({file_size} bytes). Maximum allowed size is {max_size} bytes."
+        )
+
+    with open(file_path, "rb") as f:
+        return f.read()
+
+
+def _clean_dependency_path(relative_path: Path) -> Path:
+    """
+    Clean dependency paths by removing .lake/packages/PACKAGE_NAME/ prefix.
+
+    This strips build infrastructure artifacts from paths to ensure dependencies
+    are uploaded with the correct naming scheme.
+
+    Args:
+        relative_path: The relative path to clean
+
+    Returns:
+        Path: Cleaned path with package prefix removed if applicable
+    """
+    path_str = str(relative_path)
+
+    if ".lake/packages/" not in path_str:
+        return relative_path
+
+    # handle nested packages
+    package = path_str.split(".lake/packages/")[-1]
+    package_and_path = package.split("/", 1)
+    if len(package_and_path) != 2:
+        raise ValueError(f"Invalid dependency path structure: {relative_path}")
+    _package_name, path = package_and_path
+    return Path(path)
+
+
+def get_files_for_upload(
+    file_paths: list[Path], project_root: Path | None = None
+) -> list[tuple[str, bytes, str]]:
+    """
+    Get files for upload, reading them safely and returning a list of tuples with the file path, contents, and file type.
+    """
+    files: tuple[str, bytes, str] = []
+    for file_path in file_paths:
+        file_content = read_file_safely(file_path)
+        # Use relative path from project root
+        if project_root is not None:
+            file_path = file_path.resolve().relative_to(project_root)
+        files.append(
+            (str(_clean_dependency_path(file_path)), file_content, "text/plain")
+        )
+
+    return files
+
+
+def _extract_imports(lean_file_path: Path) -> list[str]:
+    """
+    Extract local project import statements from a Lean file.
+    Filters out Mathlib imports.
+
+    Args:
+        lean_file_path: Path to the Lean file
+
+    Returns:
+        list[str]: List of local project import paths
+    """
+    imports: list[str] = []
+    try:
+        with lean_file_path.open("r", encoding="utf-8") as f:
+            for line in f:
+                stripped_line = line.strip()
+                import_split = stripped_line.split("import ")
+                if len(import_split) != 2:
+                    continue
+
+                import_path = import_split[1].strip()
+
+                # Skip Mathlib library imports - these are handled automatically
+                if import_path.startswith("Mathlib"):
+                    logger.debug(f"Skipping standard library import: {import_path}")
+                    continue
+
+                # Only include local project imports
+                imports.append(import_path)
+
+    except Exception as e:
+        logger.error(f"Error reading file {lean_file_path}: {e}")
+
+    return imports
+
+
+def _is_within_project(file_path: Path, project_root: Path) -> bool:
+    """
+    Check if a file path is within the project directory.
+
+    Args:
+        file_path: Path to check
+        project_root: Project root directory
+
+    Returns:
+        bool: True if file is within project
+    """
+    try:
+        file_path.resolve().relative_to(project_root.resolve())
+        return True
+    except ValueError:
+        return False
+
+
+def _resolve_import_to_file_path(
+    import_path: str, source_file_path: Path, project_root: Path
+) -> Path | None:
+    """
+    Resolve an import path to a local project file path.
+    Only resolves imports to files within the same project.
+
+    Args:
+        import_path: The import path (e.g., "MyProject.Utils", "./LocalFile", or "../Other")
+        source_file_path: Path to the file containing the import
+        project_root: Project root directory
+
+    Returns:
+        Path | None: Resolved file path or None if not a local project file
+
+    Raises:
+        ImportResolutionError: If import resolution fails with detailed context
+    """
+    source_file_path = Path(source_file_path).resolve()
+    source_dir = source_file_path.parent
+
+    attempted_paths: list[Path] = []
+
+    # Prevent self-imports
+    if (
+        source_file_path.stem == import_path
+        or source_file_path.stem == import_path.replace(".", "/").split("/")[-1]
+    ):
+        logger.debug(f"Skipping self-import: {import_path}")
+        return None
+
+    module_path = import_path.replace(".", "/") + ".lean"
+
+    # 1. Try relative to project root
+    candidate_path = (project_root / module_path).resolve()
+    attempted_paths.append(candidate_path)
+    if candidate_path.exists() and _is_within_project(candidate_path, project_root):
+        return candidate_path
+
+    # 2. Try in .lake/packages/ for third-party dependencies
+    lake_packages_base = project_root / ".lake" / "packages"
+    if lake_packages_base.exists():
+        for package_dir in lake_packages_base.iterdir():
+            if package_dir.is_dir():
+                candidate_path = (package_dir / module_path).resolve()
+                if candidate_path.exists():
+                    return candidate_path
+
+    # 3. Try relative to source file directory
+    candidate_path = (source_dir / module_path).resolve()
+    attempted_paths.append(candidate_path)
+    if candidate_path.exists() and _is_within_project(candidate_path, project_root):
+        return candidate_path
+
+    logger.debug(
+        f"Import resolution failed for '{import_path}' from {source_file_path}"
+    )
+    return None
+
+
+def _gather_all_lean_files_in_lean_package(package_dir: Path) -> set[Path]:
+    """
+    Gather all .lean files in a Lean package directory, excluding subpackages.
+
+    A subpackage is identified by having its own lakefile.lean or being in .lake/packages/.
+
+    Args:
+        package_dir: Root directory of the Lean package
+
+    Returns:
+        set[Path]: Set of all .lean files in the package (excluding subpackages)
+    """
+    lean_files: set[Path] = set()
+    if not package_dir.exists() or not package_dir.is_dir():
+        return lean_files
+
+    for root, dirs, files in os.walk(package_dir):
+        root_path = Path(root)
+
+        if ".lake" in dirs:
+            dirs.remove(".lake")
+
+        dirs_to_remove: list[str] = []
+        for dir_name in dirs:
+            dir_path = root_path / dir_name
+            if (dir_path / "lakefile.lean").exists():
+                dirs_to_remove.append(dir_name)
+
+        for dir_name in dirs_to_remove:
+            dirs.remove(dir_name)
+
+        # Add all .lean files in the current directory
+        for file_name in files:
+            if file_name.endswith(".lean"):
+                file_path = root_path / file_name
+                lean_files.add(file_path.resolve())
+
+    return lean_files
+
+
+def gather_file_imports(
+    input_file_path: Path, project_root: Path | None = None
+) -> set[Path]:
+    """
+    Gather all files in the import tree starting from the given Lean file.
+
+    Args:
+        input_file_path: Path to the starting Lean file
+        project_root: Project root directory
+
+    Returns:
+        set[Path]: Set of all files in the import tree
+    """
+    if project_root is None:
+        project_root = find_lean_project_root(input_file_path)
+
+    visited: set[Path] = set()
+    original_path = Path(input_file_path).resolve()
+    files_to_process: list[Path] = [original_path]
+
+    while files_to_process:
+        current_file = files_to_process.pop(0)
+
+        if current_file in visited:
+            continue
+
+        visited.add(current_file)
+        imports = _extract_imports(current_file)
+        logger.debug(f"Found {len(imports)} imports in {current_file}")
+
+        for import_path in imports:
+            # Package imports
+            if "." not in import_path:
+                lake_packages_dir = project_root / ".lake" / "packages" / import_path
+                if lake_packages_dir.exists() and lake_packages_dir.is_dir():
+                    logger.info(
+                        f"Found package import '{import_path}', adding all files from {lake_packages_dir}"
+                    )
+                    package_files = _gather_all_lean_files_in_lean_package(
+                        lake_packages_dir
+                    )
+                    for pkg_file in package_files:
+                        if pkg_file not in visited:
+                            visited.add(pkg_file)
+                    continue
+
+            # Regular import resolution
+            resolved_file_path = _resolve_import_to_file_path(
+                import_path, current_file, project_root
+            )
+            if resolved_file_path and resolved_file_path.exists():
+                if resolved_file_path not in visited:
+                    files_to_process.append(resolved_file_path)
+            else:
+                logger.error(
+                    f"Could not resolve import '{import_path}' from {current_file}"
+                )
+
+    if original_path in visited:
+        # don't add the original path as context
+        visited.remove(original_path)
+    return visited

aristotlelib/project.py

@@ -0,0 +1,371 @@
+import asyncio
+import logging
+import pydantic  # type: ignore
+from datetime import datetime
+from pathlib import Path
+from enum import Enum
+from typing import cast, overload, Literal
+
+from aristotlelib import api_request, local_file_utils
+
+# Set up logger for this module
+logger = logging.getLogger("aristotle")
+
+MAX_FILES_PER_REQUEST = 10
+
+
+class ProjectStatus(Enum):
+    NOT_STARTED = "NOT_STARTED"
+    QUEUED = "QUEUED"
+    IN_PROGRESS = "IN_PROGRESS"
+    COMPLETE = "COMPLETE"
+    FAILED = "FAILED"
+
+
+class Project(pydantic.BaseModel):
+    project_id: str
+    status: ProjectStatus
+    created_at: datetime
+
+    @classmethod
+    async def from_id(cls, project_id: str) -> "Project":
+        project = Project(
+            project_id=project_id,
+            status=ProjectStatus.NOT_STARTED,
+            created_at=datetime.now(),
+        )
+        await project.refresh()
+        return project
+
+    @classmethod
+    async def create(
+        cls,
+        context_file_paths: list[Path] | list[str] | None = None,
+        validate_lean_project_root: bool = True,
+    ) -> "Project":
+        """Create a new project.
+
+        Args:
+            context_file_paths: List of file paths to include in the project as context.
+            validate_lean_project_root: Whether to validate that these files are part of a valid Lean project.
+               Strongly recommended to set to True, but not required if you just want to reference a small number of
+               other imported files but don't have a working Lean project.
+        """
+        context_file_paths = context_file_paths or []
+        if len(context_file_paths) > MAX_FILES_PER_REQUEST:
+            raise ValueError(
+                f"Maximum number of files to upload per request is {MAX_FILES_PER_REQUEST}"
+            )
+
+        file_paths = local_file_utils.normalize_and_dedupe_paths(context_file_paths)
+        project_root = None
+        if validate_lean_project_root:
+            example_file = file_paths[0] if file_paths else Path.cwd()
+            project_root = local_file_utils.find_lean_project_root(example_file)
+
+        local_file_utils.validate_local_file_paths(
+            file_paths, project_root=project_root
+        )
+
+        files_for_upload = local_file_utils.get_files_for_upload(
+            file_paths, project_root=project_root
+        )
+        async with api_request.AristotleRequestClient() as client:
+            response = await client.post(
+                "/project",
+                files=[("context", file) for file in files_for_upload],
+            )
+            return cls.model_validate(response.json())
+
+    async def add_context(
+        self,
+        context_file_paths: list[Path] | list[str],
+        batch_size: int = MAX_FILES_PER_REQUEST,
+        validate_lean_project_root: bool = True,
+    ) -> None:
+        file_paths = local_file_utils.normalize_and_dedupe_paths(context_file_paths)
+
+        project_root = None
+        if validate_lean_project_root:
+            example_file = file_paths[0] if file_paths else Path.cwd()
+            project_root = local_file_utils.find_lean_project_root(example_file)
+
+        local_file_utils.validate_local_file_paths(
+            file_paths, project_root=project_root
+        )
+
+        async with api_request.AristotleRequestClient() as client:
+            for i in range(0, len(file_paths), batch_size):
+                batch = file_paths[i : i + batch_size]
+                await self._add_context(client, batch, project_root=project_root)
+                num_complete = min(i + batch_size, len(file_paths))
+                logger.info(
+                    f"{num_complete} of {len(file_paths)} context files uploaded"
+                )
+
+    async def _add_context(
+        self,
+        client: api_request.AristotleRequestClient,
+        context_file_paths: list[Path],
+        project_root: Path | None = None,
+    ) -> None:
+        if len(context_file_paths) > MAX_FILES_PER_REQUEST:
+            raise ValueError(
+                f"Cannot upload more than {MAX_FILES_PER_REQUEST} files at once. Got {len(context_file_paths)}"
+            )
+        if len(context_file_paths) == 0:
+            logger.warning(f"No context files provided for project {self.project_id}")
+            return
+
+        local_file_utils.validate_local_file_paths(
+            context_file_paths, project_root=project_root
+        )
+
+        files_for_upload = local_file_utils.get_files_for_upload(
+            context_file_paths, project_root=project_root
+        )
+
+        response = await client.post(
+            f"/project/{self.project_id}/context",
+            files=[("context", file) for file in files_for_upload],
+        )
+        self._update_from_response(response.json())
+
+    @overload
+    async def solve(self, *, input_file_path: Path | str) -> None: ...
+
+    @overload
+    async def solve(self, *, input_content: str) -> None: ...
+
+    async def solve(
+        self,
+        input_file_path: Path | str | None = None,
+        input_content: str | None = None,
+    ) -> None:
+        """Solve the project with either an input file or input text.
+
+        Args:
+            input_file_path: Path to a file to upload as input
+            input_content: Text content to send as input
+
+        """
+        assert self.status == ProjectStatus.NOT_STARTED, (
+            "This project has already been attempted; create a new project instead."
+        )
+        assert input_file_path is not None or input_content is not None, (
+            "Either input_file_path or input_content must be provided."
+        )
+        assert input_file_path is None or input_content is None, (
+            "Only one of input_file_path or input_content must be provided."
+        )
+
+        async with api_request.AristotleRequestClient() as client:
+            if input_file_path is not None:
+                # Handle file upload case
+                file_path = Path(input_file_path)
+                file_content = local_file_utils.read_file_safely(file_path)
+                files = [("input_file", (str(file_path), file_content, "text/plain"))]
+                data = None
+            else:
+                # Handle text input case
+                data = {"input_text": input_content}
+                files = None
+
+            response = await client.post(
+                f"/project/{self.project_id}/solve",
+                data=data,
+                files=files,
+            )
+
+            response_data = response.json()
+            self._update_from_response(response_data)
+
+    async def get_solution(self, output_path: Path | str | None = None) -> Path:
+        """Download the solution file from the project result endpoint.
+
+        Args:
+            output_path: Path where to save the downloaded file. If None, uses filename from response headers.
+
+        Returns:
+            Path to the downloaded file
+        """
+        async with api_request.AristotleRequestClient() as client:
+            response = await client.get(f"/project/{self.project_id}/result")
+
+            if output_path is None:
+                # Try to get filename from Content-Disposition header
+                content_disposition = response.headers.get("content-disposition", "")
+                if "filename=" in content_disposition:
+                    filename = content_disposition.split("filename=")[1].strip('"')
+                    output_path = Path(filename)
+                else:
+                    output_path = Path(f"{self.project_id}_solution.lean")
+            else:
+                output_path = Path(output_path)
+
+            output_path.write_bytes(response.content)
+            return output_path
+
+    async def refresh(self) -> None:
+        async with api_request.AristotleRequestClient() as client:
+            response = await client.get(f"/project/{self.project_id}")
+            response_data = response.json()
+            self._update_from_response(response_data)
+
+    def _update_from_response(self, response_data: dict) -> None:
+        updated_project = cast(Project, self.model_validate(response_data))
+        for field_name, field_value in updated_project.model_dump().items():
+            setattr(self, field_name, field_value)
+
+    @classmethod
+    async def list_projects(
+        cls, pagination_key: str | None = None, limit: int = 30
+    ) -> tuple[list["Project"], str | None]:
+        """List projects, ordered by creation date (most recent first).
+
+        Args:
+            pagination_key: Key to start from when paginating through projects.
+            limit: Maximum number of projects to return. Must be between 1 and 100.
+
+        Returns:
+            Tuple of list of projects and the new pagination key.
+        """
+        assert 1 <= limit <= 100, "Limit must be between 1 and 100"
+
+        async with api_request.AristotleRequestClient() as client:
+            response = await client.get(
+                "/project", params={"pagination_key": pagination_key, "limit": limit}
+            )
+            response_data = response.json()
+            projects: list["Project"] = [
+                cast("Project", cls.model_validate(project))
+                for project in response_data["projects"]
+            ]
+            pagination_key = response_data.get("pagination_key")
+            assert pagination_key is None or isinstance(pagination_key, str)
+            return projects, pagination_key
+
+    @overload
+    @classmethod
+    async def prove_from_file(
+        cls,
+        input_file_path: Path | str,
+        *,
+        auto_add_imports: Literal[True],
+        validate_lean_project: Literal[True] = True,
+        polling_interval_seconds: int = 30,
+        max_polling_failures: int = 3,
+    ) -> Path: ...
+
+    @overload
+    @classmethod
+    async def prove_from_file(
+        cls,
+        input_file_path: Path | str,
+        *,
+        auto_add_imports: Literal[False] = False,
+        context_file_paths: list[Path] | list[str] | None = None,
+        validate_lean_project: bool = True,
+        polling_interval_seconds: int = 30,
+        max_polling_failures: int = 3,
+    ) -> Path: ...
+
+    @classmethod
+    async def prove_from_file(
+        cls,
+        input_file_path: Path | str,
+        auto_add_imports: bool = True,
+        context_file_paths: list[Path] | list[str] | None = None,
+        validate_lean_project: bool = True,
+        polling_interval_seconds: int = 30,
+        max_polling_failures: int = 3,
+    ) -> Path:
+        """Proves the input content.
+
+        Args:
+            input_file_path: Path to the input file
+            auto_add_imports: Whether to automatically add imports from the input file as context to the project.
+                              Requires that the input file is part of a valid Lean project.
+            context_file_paths: List of file paths to add as context to the project, manually.
+            validate_lean_project: Whether to validate that the input file is part of a valid Lean project.
+            polling_interval_seconds: Interval in seconds to poll for the project status.
+            max_polling_failures: Maximum number of polling failures before raising an error.
+
+        Returns:
+            The file path to the solution
+        """
+        logger.info("Validating input...")
+        input_file_path = Path(input_file_path)
+        if validate_lean_project:
+            project_root = local_file_utils.find_lean_project_root(input_file_path)
+        else:
+            project_root = None
+        local_file_utils.validate_local_file_path(
+            input_file_path, project_root=project_root
+        )
+        logger.info("Input Validated.")
+
+        logger.info("Creating project...")
+        project = await cls.create(validate_lean_project_root=validate_lean_project)
+        logger.info(f"Created project {project.project_id}")
+
+        try:
+            if auto_add_imports:
+                logger.info("Adding imports to project...")
+                assert context_file_paths is None, (
+                    "context_file_paths cannot be provided when auto_add_imports is True"
+                )
+                assert validate_lean_project, (
+                    "validate_lean_project must be True when auto_add_imports is True"
+                )
+                assert project_root is not None
+                context_file_paths = list(
+                    local_file_utils.gather_file_imports(input_file_path, project_root)
+                )
+                await project.add_context(
+                    context_file_paths, validate_lean_project_root=True
+                )
+                logger.info(f"Added {len(context_file_paths)} imports to project")
+            elif context_file_paths is not None:
+                logger.info("Adding context files to project...")
+                await project.add_context(
+                    context_file_paths, validate_lean_project_root=validate_lean_project
+                )
+                logger.info(f"Added {len(context_file_paths)} context files to project")
+
+            await project.solve(input_file_path=input_file_path)
+
+            num_polling_failures = 0
+            while project.status not in (ProjectStatus.COMPLETE, ProjectStatus.FAILED):
+                try:
+                    logger.info(
+                        f"Project status: {project.status} - sleeping for {polling_interval_seconds} seconds..."
+                    )
+                    await asyncio.sleep(polling_interval_seconds)
+                    await project.refresh()
+                except api_request.AristotleAPIError:
+                    num_polling_failures += 1
+                    if num_polling_failures >= max_polling_failures:
+                        logger.error(
+                            "Too many errors polling for project status. Your project might still be running; try checking on it later with project id {project.project_id}."
+                        )
+                        raise
+                    logger.warning(
+                        f"Error polling for project status. {num_polling_failures} failures so far. Sleeping for {polling_interval_seconds * num_polling_failures} seconds."
+                    )
+                    await asyncio.sleep(polling_interval_seconds * num_polling_failures)
+
+            if project.status != ProjectStatus.COMPLETE:
+                raise api_request.AristotleAPIError(
+                    "Project failed due to an internal error. The team at Harmonic has been notified; please try again."
+                )
+
+            logger.info("Solve complete! Getting solution...")
+            solution_file_path = await project.get_solution()
+            logger.info(f"Solution saved to {solution_file_path}")
+            return solution_file_path
+        finally:
+            if project.status in (ProjectStatus.QUEUED, ProjectStatus.IN_PROGRESS):
+                logger.info(
+                    f"Project {project.project_id} is still running. You can manually check on it any time with Project.from_id('{project.project_id}')"
+                )

aristotlelib-0.1.0.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,9 @@
+aristotlelib/__init__.py,sha256=mp3p5DanjUA3LmL4JlyeCrsCksqh2WJ50lnjyPHXlFI,341
+aristotlelib/api_request.py,sha256=duFqGIs_0kXwMSfs_cL8fhjlCfHmICSn50Jz0m7S4HE,3992
+aristotlelib/local_file_utils.py,sha256=0DwrslgGJ9eTsztcAvfyfa_htEUFm0Tycb-4iILVFFU,13534
+aristotlelib/project.py,sha256=mwuEdDT98BFSmZFvI6DS1HGy_VC8Zg-SKv7Nyi5O12Y,15014
+aristotlelib-0.1.0.dist-info/licenses/LICENSE,sha256=ycH5WVQoUAehbfn8UML4uh5jwiEnfE1tcXPLWO9KQ9I,944
+aristotlelib-0.1.0.dist-info/METADATA,sha256=FwtkCIUe0N00RHaA6Tvy0K2O9CM9oSDbr58owZ6qSE4,7053
+aristotlelib-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+aristotlelib-0.1.0.dist-info/top_level.txt,sha256=Xwn3eTy1r_fXC5teogOo9Oekj7H5PM6CGFLjSd-3SK4,13
+aristotlelib-0.1.0.dist-info/RECORD,,

aristotlelib-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

aristotlelib-0.1.0.dist-info/licenses/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.dist-info/top_level.txt

@@ -0,0 +1 @@
+aristotlelib